File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/twisted.zip
Back
PK Mb�Z% �b b mail/bounce.pynu �[��� # -*- test-case-name: twisted.mail.test.test_bounce -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Support for bounce message generation. """ import email.utils import os import time from io import SEEK_END, SEEK_SET, StringIO from twisted.mail import smtp BOUNCE_FORMAT = """\ From: postmaster@{failedDomain} To: {failedFrom} Subject: Returned Mail: see transcript for details Message-ID: {messageID} Content-Type: multipart/report; report-type=delivery-status; boundary="{boundary}" --{boundary} {transcript} --{boundary} Content-Type: message/delivery-status Arrival-Date: {ctime} Final-Recipient: RFC822; {failedTo} """ def generateBounce(message, failedFrom, failedTo, transcript="", encoding="utf-8"): """ Generate a bounce message for an undeliverable email message. @type message: a file-like object @param message: The undeliverable message. @type failedFrom: L{bytes} or L{unicode} @param failedFrom: The originator of the undeliverable message. @type failedTo: L{bytes} or L{unicode} @param failedTo: The destination of the undeliverable message. @type transcript: L{bytes} or L{unicode} @param transcript: An error message to include in the bounce message. @type encoding: L{str} or L{unicode} @param encoding: Encoding to use, default: utf-8 @rtype: 3-L{tuple} of (E{1}) L{bytes}, (E{2}) L{bytes}, (E{3}) L{bytes} @return: The originator, the destination and the contents of the bounce message. The destination of the bounce message is the originator of the undeliverable message. """ if isinstance(failedFrom, bytes): failedFrom = failedFrom.decode(encoding) if isinstance(failedTo, bytes): failedTo = failedTo.decode(encoding) if not transcript: transcript = """\ I'm sorry, the following address has permanent errors: {failedTo}. I've given up, and I will not retry the message again. """.format( failedTo=failedTo ) failedAddress = email.utils.parseaddr(failedTo)[1] data = { "boundary": "{}_{}_{}".format(time.time(), os.getpid(), "XXXXX"), "ctime": time.ctime(time.time()), "failedAddress": failedAddress, "failedDomain": failedAddress.split("@", 1)[1], "failedFrom": failedFrom, "failedTo": failedTo, "messageID": smtp.messageid(uniq="bounce"), "message": message, "transcript": transcript, } fp = StringIO() fp.write(BOUNCE_FORMAT.format(**data)) orig = message.tell() message.seek(0, SEEK_END) sz = message.tell() message.seek(orig, SEEK_SET) if sz > 10000: while 1: line = message.readline() if isinstance(line, bytes): line = line.decode(encoding) if len(line) <= 0: break fp.write(line) else: messageContent = message.read() if isinstance(messageContent, bytes): messageContent = messageContent.decode(encoding) fp.write(messageContent) return b"", failedFrom.encode(encoding), fp.getvalue().encode(encoding) PK Mb�Zs���� �� mail/_pop3client.pynu �[��� # -*- test-case-name: twisted.mail.test.test_pop3client -*- # Copyright (c) 2001-2004 Divmod Inc. # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ A POP3 client protocol implementation. Don't use this module directly. Use twisted.mail.pop3 instead. @author: Jp Calderone """ import re from hashlib import md5 from typing import List from twisted.internet import defer, error, interfaces from twisted.mail._except import ( InsecureAuthenticationDisallowed, LineTooLong, ServerErrorResponse, TLSError, TLSNotSupportedError, ) from twisted.protocols import basic, policies from twisted.python import log OK = b"+OK" ERR = b"-ERR" class _ListSetter: """ A utility class to construct a list from a multi-line response accounting for deleted messages. POP3 responses sometimes occur in the form of a list of lines containing two pieces of data, a message index and a value of some sort. When a message is deleted, it is omitted from these responses. The L{setitem} method of this class is meant to be called with these two values. In the cases where indices are skipped, it takes care of padding out the missing values with L{None}. @ivar L: See L{__init__} """ def __init__(self, L): """ @type L: L{list} of L{object} @param L: The list being constructed. An empty list should be passed in. """ self.L = L def setitem(self, itemAndValue): """ Add the value at the specified position, padding out missing entries. @type itemAndValue: C{tuple} @param itemAndValue: A tuple of (item, value). The I{item} is the 0-based index in the list at which the value should be placed. The value is is an L{object} to put in the list. """ (item, value) = itemAndValue diff = item - len(self.L) + 1 if diff > 0: self.L.extend([None] * diff) self.L[item] = value def _statXform(line): """ Parse the response to a STAT command. @type line: L{bytes} @param line: The response from the server to a STAT command minus the status indicator. @rtype: 2-L{tuple} of (0) L{int}, (1) L{int} @return: The number of messages in the mailbox and the size of the mailbox. """ numMsgs, totalSize = line.split(None, 1) return int(numMsgs), int(totalSize) def _listXform(line): """ Parse a line of the response to a LIST command. The line from the LIST response consists of a 1-based message number followed by a size. @type line: L{bytes} @param line: A non-initial line from the multi-line response to a LIST command. @rtype: 2-L{tuple} of (0) L{int}, (1) L{int} @return: The 0-based index of the message and the size of the message. """ index, size = line.split(None, 1) return int(index) - 1, int(size) def _uidXform(line): """ Parse a line of the response to a UIDL command. The line from the UIDL response consists of a 1-based message number followed by a unique id. @type line: L{bytes} @param line: A non-initial line from the multi-line response to a UIDL command. @rtype: 2-L{tuple} of (0) L{int}, (1) L{bytes} @return: The 0-based index of the message and the unique identifier for the message. """ index, uid = line.split(None, 1) return int(index) - 1, uid def _codeStatusSplit(line): """ Parse the first line of a multi-line server response. @type line: L{bytes} @param line: The first line of a multi-line server response. @rtype: 2-tuple of (0) L{bytes}, (1) L{bytes} @return: The status indicator and the rest of the server response. """ parts = line.split(b" ", 1) if len(parts) == 1: return parts[0], b"" return parts def _dotUnquoter(line): """ Remove a byte-stuffed termination character at the beginning of a line if present. When the termination character (C{'.'}) appears at the beginning of a line, the server byte-stuffs it by adding another termination character to avoid confusion with the terminating sequence (C{'.\\r\\n'}). @type line: L{bytes} @param line: A received line. @rtype: L{bytes} @return: The line without the byte-stuffed termination character at the beginning if it was present. Otherwise, the line unchanged. """ if line.startswith(b".."): return line[1:] return line class POP3Client(basic.LineOnlyReceiver, policies.TimeoutMixin): """ A POP3 client protocol. Instances of this class provide a convenient, efficient API for retrieving and deleting messages from a POP3 server. This API provides a pipelining interface but POP3 pipelining on the network is not yet supported. @type startedTLS: L{bool} @ivar startedTLS: An indication of whether TLS has been negotiated successfully. @type allowInsecureLogin: L{bool} @ivar allowInsecureLogin: An indication of whether plaintext login should be allowed when the server offers no authentication challenge and the transport does not offer any protection via encryption. @type serverChallenge: L{bytes} or L{None} @ivar serverChallenge: The challenge received in the server greeting. @type timeout: L{int} @ivar timeout: The number of seconds to wait on a response from the server before timing out a connection. If the number is <= 0, no timeout checking will be performed. @type _capCache: L{None} or L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @ivar _capCache: The cached server capabilities. Capabilities are not allowed to change during the session (except when TLS is negotiated), so the first response to a capabilities command can be used for later lookups. @type _challengeMagicRe: L{Pattern <re.Pattern.search>} @ivar _challengeMagicRe: A regular expression which matches the challenge in the server greeting. @type _blockedQueue: L{None} or L{list} of 3-L{tuple} of (0) L{Deferred <defer.Deferred>}, (1) callable which results in a L{Deferred <defer.Deferred>}, (2) L{tuple} @ivar _blockedQueue: A list of blocked commands. While a command is awaiting a response from the server, other commands are blocked. When no command is outstanding, C{_blockedQueue} is set to L{None}. Otherwise, it contains a list of information about blocked commands. Each list entry provides the following information about a blocked command: the deferred that should be called when the response to the command is received, the function that sends the command, and the arguments to the function. @type _waiting: L{Deferred <defer.Deferred>} or L{None} @ivar _waiting: A deferred which fires when the response to the outstanding command is received from the server. @type _timedOut: L{bool} @ivar _timedOut: An indication of whether the connection was dropped because of a timeout. @type _greetingError: L{bytes} or L{None} @ivar _greetingError: The server greeting minus the status indicator, when the connection was dropped because of an error in the server greeting. Otherwise, L{None}. @type state: L{bytes} @ivar state: The state which indicates what type of response is expected from the server. Valid states are: 'WELCOME', 'WAITING', 'SHORT', 'LONG_INITIAL', 'LONG'. @type _xform: L{None} or callable that takes L{bytes} and returns L{object} @ivar _xform: The transform function which is used to convert each line of a multi-line response into usable values for use by the consumer function. If L{None}, each line of the multi-line response is sent directly to the consumer function. @type _consumer: callable that takes L{object} @ivar _consumer: The consumer function which is used to store the values derived by the transform function from each line of a multi-line response into a list. """ startedTLS = False allowInsecureLogin = False timeout = 0 serverChallenge = None _capCache = None _challengeMagicRe = re.compile(b"(<[^>]+>)") _blockedQueue = None _waiting = None _timedOut = False _greetingError = None def _blocked(self, f, *a): """ Block a command, if necessary. If commands are being blocked, append information about the function which sends the command to a list and return a deferred that will be chained with the return value of the function when it eventually runs. Otherwise, set up for subsequent commands to be blocked and return L{None}. @type f: callable @param f: A function which sends a command. @type a: L{tuple} @param a: Arguments to the function. @rtype: L{None} or L{Deferred <defer.Deferred>} @return: L{None} if the command can run immediately. Otherwise, a deferred that will eventually trigger with the return value of the function. """ if self._blockedQueue is not None: d = defer.Deferred() self._blockedQueue.append((d, f, a)) return d self._blockedQueue = [] return None def _unblock(self): """ Send the next blocked command. If there are no more commands in the blocked queue, set up for the next command to be sent immediately. """ if self._blockedQueue == []: self._blockedQueue = None elif self._blockedQueue is not None: _blockedQueue = self._blockedQueue self._blockedQueue = None d, f, a = _blockedQueue.pop(0) d2 = f(*a) d2.chainDeferred(d) # f is a function which uses _blocked (otherwise it wouldn't # have gotten into the blocked queue), which means it will have # re-set _blockedQueue to an empty list, so we can put the rest # of the blocked queue back into it now. self._blockedQueue.extend(_blockedQueue) def sendShort(self, cmd, args): """ Send a POP3 command to which a short response is expected. Block all further commands from being sent until the response is received. Transition the state to SHORT. @type cmd: L{bytes} @param cmd: A POP3 command. @type args: L{bytes} @param args: The command arguments. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the entire response is received. On an OK response, it returns the response from the server minus the status indicator. On an ERR response, it issues a server error response failure with the response from the server minus the status indicator. """ d = self._blocked(self.sendShort, cmd, args) if d is not None: return d if args: self.sendLine(cmd + b" " + args) else: self.sendLine(cmd) self.state = "SHORT" self._waiting = defer.Deferred() return self._waiting def sendLong(self, cmd, args, consumer, xform): """ Send a POP3 command to which a multi-line response is expected. Block all further commands from being sent until the entire response is received. Transition the state to LONG_INITIAL. @type cmd: L{bytes} @param cmd: A POP3 command. @type args: L{bytes} @param args: The command arguments. @type consumer: callable that takes L{object} @param consumer: A consumer function which should be used to put the values derived by a transform function from each line of the multi-line response into a list. @type xform: L{None} or callable that takes L{bytes} and returns L{object} @param xform: A transform function which should be used to transform each line of the multi-line response into usable values for use by a consumer function. If L{None}, each line of the multi-line response should be sent directly to the consumer function. @rtype: L{Deferred <defer.Deferred>} which successfully fires with callable that takes L{object} and fails with L{ServerErrorResponse} @return: A deferred which fires when the entire response is received. On an OK response, it returns the consumer function. On an ERR response, it issues a server error response failure with the response from the server minus the status indicator and the consumer function. """ d = self._blocked(self.sendLong, cmd, args, consumer, xform) if d is not None: return d if args: self.sendLine(cmd + b" " + args) else: self.sendLine(cmd) self.state = "LONG_INITIAL" self._xform = xform self._consumer = consumer self._waiting = defer.Deferred() return self._waiting # Twisted protocol callback def connectionMade(self): """ Wait for a greeting from the server after the connection has been made. Start the connection in the WELCOME state. """ if self.timeout > 0: self.setTimeout(self.timeout) self.state = "WELCOME" self._blockedQueue = [] def timeoutConnection(self): """ Drop the connection when the server does not respond in time. """ self._timedOut = True self.transport.loseConnection() def connectionLost(self, reason): """ Clean up when the connection has been lost. When the loss of connection was initiated by the client due to a timeout, the L{_timedOut} flag will be set. When it was initiated by the client due to an error in the server greeting, L{_greetingError} will be set to the server response minus the status indicator. @type reason: L{Failure <twisted.python.failure.Failure>} @param reason: The reason the connection was terminated. """ if self.timeout > 0: self.setTimeout(None) if self._timedOut: reason = error.TimeoutError() elif self._greetingError: reason = ServerErrorResponse(self._greetingError) d = [] if self._waiting is not None: d.append(self._waiting) self._waiting = None if self._blockedQueue is not None: d.extend([deferred for (deferred, f, a) in self._blockedQueue]) self._blockedQueue = None for w in d: w.errback(reason) def lineReceived(self, line): """ Pass a received line to a state machine function and transition to the next state. @type line: L{bytes} @param line: A received line. """ if self.timeout > 0: self.resetTimeout() state = self.state self.state = None state = getattr(self, "state_" + state)(line) or state if self.state is None: self.state = state def lineLengthExceeded(self, buffer): """ Drop the connection when a server response exceeds the maximum line length (L{LineOnlyReceiver.MAX_LENGTH}). @type buffer: L{bytes} @param buffer: A received line which exceeds the maximum line length. """ # XXX - We need to be smarter about this if self._waiting is not None: waiting, self._waiting = self._waiting, None waiting.errback(LineTooLong()) self.transport.loseConnection() # POP3 Client state logic - don't touch this. def state_WELCOME(self, line): """ Handle server responses for the WELCOME state in which the server greeting is expected. WELCOME is the first state. The server should send one line of text with a greeting and possibly an APOP challenge. Transition the state to WAITING. @type line: L{bytes} @param line: A line received from the server. @rtype: L{bytes} @return: The next state. """ code, status = _codeStatusSplit(line) if code != OK: self._greetingError = status self.transport.loseConnection() else: m = self._challengeMagicRe.search(status) if m is not None: self.serverChallenge = m.group(1) self.serverGreeting(status) self._unblock() return "WAITING" def state_WAITING(self, line): """ Log an error for server responses received in the WAITING state during which the server is not expected to send anything. @type line: L{bytes} @param line: A line received from the server. """ log.msg("Illegal line from server: " + repr(line)) def state_SHORT(self, line): """ Handle server responses for the SHORT state in which the server is expected to send a single line response. Parse the response and fire the deferred which is waiting on receipt of a complete response. Transition the state back to WAITING. @type line: L{bytes} @param line: A line received from the server. @rtype: L{bytes} @return: The next state. """ deferred, self._waiting = self._waiting, None self._unblock() code, status = _codeStatusSplit(line) if code == OK: deferred.callback(status) else: deferred.errback(ServerErrorResponse(status)) return "WAITING" def state_LONG_INITIAL(self, line): """ Handle server responses for the LONG_INITIAL state in which the server is expected to send the first line of a multi-line response. Parse the response. On an OK response, transition the state to LONG. On an ERR response, cleanup and transition the state to WAITING. @type line: L{bytes} @param line: A line received from the server. @rtype: L{bytes} @return: The next state. """ code, status = _codeStatusSplit(line) if code == OK: return "LONG" consumer = self._consumer deferred = self._waiting self._consumer = self._waiting = self._xform = None self._unblock() deferred.errback(ServerErrorResponse(status, consumer)) return "WAITING" def state_LONG(self, line): """ Handle server responses for the LONG state in which the server is expected to send a non-initial line of a multi-line response. On receipt of the last line of the response, clean up, fire the deferred which is waiting on receipt of a complete response, and transition the state to WAITING. Otherwise, pass the line to the transform function, if provided, and then the consumer function. @type line: L{bytes} @param line: A line received from the server. @rtype: L{bytes} @return: The next state. """ # This is the state for each line of a long response. if line == b".": consumer = self._consumer deferred = self._waiting self._consumer = self._waiting = self._xform = None self._unblock() deferred.callback(consumer) return "WAITING" else: if self._xform is not None: self._consumer(self._xform(line)) else: self._consumer(line) return "LONG" # Callbacks - override these def serverGreeting(self, greeting): """ Handle the server greeting. @type greeting: L{bytes} @param greeting: The server greeting minus the status indicator. For servers implementing APOP authentication, this will contain a challenge string. """ # External API - call these (most of 'em anyway) def startTLS(self, contextFactory=None): """ Switch to encrypted communication using TLS. The first step of switching to encrypted communication is obtaining the server's capabilities. When that is complete, the L{_startTLS} callback function continues the switching process. @type contextFactory: L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>} @param contextFactory: The context factory with which to negotiate TLS. If not provided, try to create a new one. @rtype: L{Deferred <defer.Deferred>} which successfully results in L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} or fails with L{TLSError} @return: A deferred which fires when the transport has been secured according to the given context factory with the server capabilities, or which fails with a TLS error if the transport cannot be secured. """ tls = interfaces.ITLSTransport(self.transport, None) if tls is None: return defer.fail( TLSError( "POP3Client transport does not implement " "interfaces.ITLSTransport" ) ) if contextFactory is None: contextFactory = self._getContextFactory() if contextFactory is None: return defer.fail( TLSError( "POP3Client requires a TLS context to " "initiate the STLS handshake" ) ) d = self.capabilities() d.addCallback(self._startTLS, contextFactory, tls) return d def _startTLS(self, caps, contextFactory, tls): """ Continue the process of switching to encrypted communication. This callback function runs after the server capabilities are received. The next step is sending the server an STLS command to request a switch to encrypted communication. When an OK response is received, the L{_startedTLS} callback function completes the switch to encrypted communication. Then, the new server capabilities are requested. @type caps: L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @param caps: The server capabilities. @type contextFactory: L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>} @param contextFactory: A context factory with which to negotiate TLS. @type tls: L{ITLSTransport <interfaces.ITLSTransport>} @param tls: A TCP transport that supports switching to TLS midstream. @rtype: L{Deferred <defer.Deferred>} which successfully triggers with L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} or fails with L{TLSNotSupportedError} @return: A deferred which successfully fires when the response from the server to the request to start TLS has been received and the new server capabilities have been received or fails when the server does not support TLS. """ assert ( not self.startedTLS ), "Client and Server are currently communicating via TLS" if b"STLS" not in caps: return defer.fail( TLSNotSupportedError( "Server does not support secure communication " "via TLS / SSL" ) ) d = self.sendShort(b"STLS", None) d.addCallback(self._startedTLS, contextFactory, tls) d.addCallback(lambda _: self.capabilities()) return d def _startedTLS(self, result, context, tls): """ Complete the process of switching to encrypted communication. This callback function runs after the response to the STLS command has been received. The final steps are discarding the cached capabilities and initiating TLS negotiation on the transport. @type result: L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @param result: The server capabilities. @type context: L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>} @param context: A context factory with which to negotiate TLS. @type tls: L{ITLSTransport <interfaces.ITLSTransport>} @param tls: A TCP transport that supports switching to TLS midstream. @rtype: L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @return: The server capabilities. """ self.transport = tls self.transport.startTLS(context) self._capCache = None self.startedTLS = True return result def _getContextFactory(self): """ Get a context factory with which to negotiate TLS. @rtype: L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>} @return: A context factory or L{None} if TLS is not supported on the client. """ try: from twisted.internet import ssl except ImportError: return None else: context = ssl.ClientContextFactory() context.method = ssl.SSL.TLSv1_METHOD return context def login(self, username, password): """ Log in to the server. If APOP is available it will be used. Otherwise, if TLS is available, an encrypted session will be started and plaintext login will proceed. Otherwise, if L{allowInsecureLogin} is set, insecure plaintext login will proceed. Otherwise, L{InsecureAuthenticationDisallowed} will be raised. The first step of logging into the server is obtaining the server's capabilities. When that is complete, the L{_login} callback function continues the login process. @type username: L{bytes} @param username: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} @return: A deferred which fires when the login process is complete. On a successful login, it returns the server's response minus the status indicator. """ d = self.capabilities() d.addCallback(self._login, username, password) return d def _login(self, caps, username, password): """ Continue the process of logging in to the server. This callback function runs after the server capabilities are received. If the server provided a challenge in the greeting, proceed with an APOP login. Otherwise, if the server and the transport support encrypted communication, try to switch to TLS and then complete the login process with the L{_loginTLS} callback function. Otherwise, if insecure authentication is allowed, do a plaintext login. Otherwise, fail with an L{InsecureAuthenticationDisallowed} error. @type caps: L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @param caps: The server capabilities. @type username: L{bytes} @param username: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} @return: A deferred which fires when the login process is complete. On a successful login, it returns the server's response minus the status indicator. """ if self.serverChallenge is not None: return self._apop(username, password, self.serverChallenge) tryTLS = b"STLS" in caps # If our transport supports switching to TLS, we might want to # try to switch to TLS. tlsableTransport = interfaces.ITLSTransport(self.transport, None) is not None # If our transport is not already using TLS, we might want to # try to switch to TLS. nontlsTransport = interfaces.ISSLTransport(self.transport, None) is None if not self.startedTLS and tryTLS and tlsableTransport and nontlsTransport: d = self.startTLS() d.addCallback(self._loginTLS, username, password) return d elif self.startedTLS or not nontlsTransport or self.allowInsecureLogin: return self._plaintext(username, password) else: return defer.fail(InsecureAuthenticationDisallowed()) def _loginTLS(self, res, username, password): """ Do a plaintext login over an encrypted transport. This callback function runs after the transport switches to encrypted communication. @type res: L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @param res: The server capabilities. @type username: L{bytes} @param username: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server accepts the username and password or fails when the server rejects either. On a successful login, it returns the server's response minus the status indicator. """ return self._plaintext(username, password) def _plaintext(self, username, password): """ Perform a plaintext login. @type username: L{bytes} @param username: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server accepts the username and password or fails when the server rejects either. On a successful login, it returns the server's response minus the status indicator. """ return self.user(username).addCallback(lambda r: self.password(password)) def _apop(self, username, password, challenge): """ Perform an APOP login. @type username: L{bytes} @param username: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @type challenge: L{bytes} @param challenge: A challenge string. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On a successful login, it returns the server response minus the status indicator. """ digest = md5(challenge + password).hexdigest().encode("ascii") return self.apop(username, digest) def apop(self, username, digest): """ Send an APOP command to perform authenticated login. This should be used in special circumstances only, when it is known that the server supports APOP authentication, and APOP authentication is absolutely required. For the common case, use L{login} instead. @type username: L{bytes} @param username: The username with which to log in. @type digest: L{bytes} @param digest: The challenge response to authenticate with. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. """ return self.sendShort(b"APOP", username + b" " + digest) def user(self, username): """ Send a USER command to perform the first half of plaintext login. Unless this is absolutely required, use the L{login} method instead. @type username: L{bytes} @param username: The username with which to log in. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. """ return self.sendShort(b"USER", username) def password(self, password): """ Send a PASS command to perform the second half of plaintext login. Unless this is absolutely required, use the L{login} method instead. @type password: L{bytes} @param password: The plaintext password with which to authenticate. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. """ return self.sendShort(b"PASS", password) def delete(self, index): """ Send a DELE command to delete a message from the server. @type index: L{int} @param index: The 0-based index of the message to delete. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. """ return self.sendShort(b"DELE", b"%d" % (index + 1,)) def _consumeOrSetItem(self, cmd, args, consumer, xform): """ Send a command to which a long response is expected and process the multi-line response into a list accounting for deleted messages. @type cmd: L{bytes} @param cmd: A POP3 command to which a long response is expected. @type args: L{bytes} @param args: The command arguments. @type consumer: L{None} or callable that takes L{object} @param consumer: L{None} or a function that consumes the output from the transform function. @type xform: L{None}, callable that takes L{bytes} and returns 2-L{tuple} of (0) L{int}, (1) L{object}, or callable that takes L{bytes} and returns L{object} @param xform: A function that parses a line from a multi-line response and transforms the values into usable form for input to the consumer function. If no consumer function is specified, the output must be a message index and corresponding value. If no transform function is specified, the line is used as is. @rtype: L{Deferred <defer.Deferred>} which fires with L{list} of L{object} or callable that takes L{list} of L{object} @return: A deferred which fires when the entire response has been received. When a consumer is not provided, the return value is a list of the value for each message or L{None} for deleted messages. Otherwise, it returns the consumer itself. """ if consumer is None: L = [] consumer = _ListSetter(L).setitem return self.sendLong(cmd, args, consumer, xform).addCallback(lambda r: L) return self.sendLong(cmd, args, consumer, xform) def _consumeOrAppend(self, cmd, args, consumer, xform): """ Send a command to which a long response is expected and process the multi-line response into a list. @type cmd: L{bytes} @param cmd: A POP3 command which expects a long response. @type args: L{bytes} @param args: The command arguments. @type consumer: L{None} or callable that takes L{object} @param consumer: L{None} or a function that consumes the output from the transform function. @type xform: L{None} or callable that takes L{bytes} and returns L{object} @param xform: A function that transforms a line from a multi-line response into usable form for input to the consumer function. If no transform function is specified, the line is used as is. @rtype: L{Deferred <defer.Deferred>} which fires with L{list} of 2-L{tuple} of (0) L{int}, (1) L{object} or callable that takes 2-L{tuple} of (0) L{int}, (1) L{object} @return: A deferred which fires when the entire response has been received. When a consumer is not provided, the return value is a list of the transformed lines. Otherwise, it returns the consumer itself. """ if consumer is None: L = [] consumer = L.append return self.sendLong(cmd, args, consumer, xform).addCallback(lambda r: L) return self.sendLong(cmd, args, consumer, xform) def capabilities(self, useCache=True): """ Send a CAPA command to retrieve the capabilities supported by the server. Not all servers support this command. If the server does not support this, it is treated as though it returned a successful response listing no capabilities. At some future time, this may be changed to instead seek out information about a server's capabilities in some other fashion (only if it proves useful to do so, and only if there are servers still in use which do not support CAPA but which do support POP3 extensions that are useful). @type useCache: L{bool} @param useCache: A flag that determines whether previously retrieved results should be used if available. @rtype: L{Deferred <defer.Deferred>} which successfully results in L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @return: A deferred which fires with a mapping of capability name to parameters. For example:: C: CAPA S: +OK Capability list follows S: TOP S: USER S: SASL CRAM-MD5 KERBEROS_V4 S: RESP-CODES S: LOGIN-DELAY 900 S: PIPELINING S: EXPIRE 60 S: UIDL S: IMPLEMENTATION Shlemazle-Plotz-v302 S: . will be lead to a result of:: | {'TOP': None, | 'USER': None, | 'SASL': ['CRAM-MD5', 'KERBEROS_V4'], | 'RESP-CODES': None, | 'LOGIN-DELAY': ['900'], | 'PIPELINING': None, | 'EXPIRE': ['60'], | 'UIDL': None, | 'IMPLEMENTATION': ['Shlemazle-Plotz-v302']} """ if useCache and self._capCache is not None: return defer.succeed(self._capCache) cache = {} def consume(line): tmp = line.split() if len(tmp) == 1: cache[tmp[0]] = None elif len(tmp) > 1: cache[tmp[0]] = tmp[1:] def capaNotSupported(err): err.trap(ServerErrorResponse) return None def gotCapabilities(result): self._capCache = cache return cache d = self._consumeOrAppend(b"CAPA", None, consume, None) d.addErrback(capaNotSupported).addCallback(gotCapabilities) return d def noop(self): """ Send a NOOP command asking the server to do nothing but respond. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. """ return self.sendShort(b"NOOP", None) def reset(self): """ Send a RSET command to unmark any messages that have been flagged for deletion on the server. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. """ return self.sendShort(b"RSET", None) def retrieve(self, index, consumer=None, lines=None): """ Send a RETR or TOP command to retrieve all or part of a message from the server. @type index: L{int} @param index: A 0-based message index. @type consumer: L{None} or callable that takes L{bytes} @param consumer: A function which consumes each transformed line from a multi-line response as it is received. @type lines: L{None} or L{int} @param lines: If specified, the number of lines of the message to be retrieved. Otherwise, the entire message is retrieved. @rtype: L{Deferred <defer.Deferred>} which fires with L{list} of L{bytes}, or callable that takes 2-L{tuple} of (0) L{int}, (1) L{object} @return: A deferred which fires when the entire response has been received. When a consumer is not provided, the return value is a list of the transformed lines. Otherwise, it returns the consumer itself. """ idx = b"%d" % (index + 1,) if lines is None: return self._consumeOrAppend(b"RETR", idx, consumer, _dotUnquoter) return self._consumeOrAppend( b"TOP", b"%b %d" % (idx, lines), consumer, _dotUnquoter ) def stat(self): """ Send a STAT command to get information about the size of the mailbox. @rtype: L{Deferred <defer.Deferred>} which successfully fires with a 2-tuple of (0) L{int}, (1) L{int} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the number of messages in the mailbox and the size of the mailbox in octets. On an ERR response, the deferred fails with a server error response failure. """ return self.sendShort(b"STAT", None).addCallback(_statXform) def listSize(self, consumer=None): """ Send a LIST command to retrieve the sizes of all messages on the server. @type consumer: L{None} or callable that takes 2-L{tuple} of (0) L{int}, (1) L{int} @param consumer: A function which consumes the 0-based message index and message size derived from the server response. @rtype: L{Deferred <defer.Deferred>} which fires L{list} of L{int} or callable that takes 2-L{tuple} of (0) L{int}, (1) L{int} @return: A deferred which fires when the entire response has been received. When a consumer is not provided, the return value is a list of message sizes. Otherwise, it returns the consumer itself. """ return self._consumeOrSetItem(b"LIST", None, consumer, _listXform) def listUID(self, consumer=None): """ Send a UIDL command to retrieve the UIDs of all messages on the server. @type consumer: L{None} or callable that takes 2-L{tuple} of (0) L{int}, (1) L{bytes} @param consumer: A function which consumes the 0-based message index and UID derived from the server response. @rtype: L{Deferred <defer.Deferred>} which fires with L{list} of L{object} or callable that takes 2-L{tuple} of (0) L{int}, (1) L{bytes} @return: A deferred which fires when the entire response has been received. When a consumer is not provided, the return value is a list of message sizes. Otherwise, it returns the consumer itself. """ return self._consumeOrSetItem(b"UIDL", None, consumer, _uidXform) def quit(self): """ Send a QUIT command to disconnect from the server. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. """ return self.sendShort(b"QUIT", None) __all__: List[str] = [] PK Mb�Zơҧ�1 �1 mail/tap.pynu �[��� # -*- test-case-name: twisted.mail.test.test_options -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Support for creating mail servers with twistd. """ import os from twisted.application import internet from twisted.cred import checkers, strcred from twisted.internet import endpoints from twisted.mail import alias, mail, maildir, relay, relaymanager from twisted.python import usage class Options(usage.Options, strcred.AuthOptionMixin): """ An options list parser for twistd mail. @type synopsis: L{bytes} @ivar synopsis: A description of options for use in the usage message. @type optParameters: L{list} of L{list} of (0) L{bytes}, (1) L{bytes}, (2) L{object}, (3) L{bytes}, (4) L{None} or callable which takes L{bytes} and returns L{object} @ivar optParameters: Information about supported parameters. See L{Options <twisted.python.usage.Options>} for details. @type optFlags: L{list} of L{list} of (0) L{bytes}, (1) L{bytes} or L{None}, (2) L{bytes} @ivar optFlags: Information about supported flags. See L{Options <twisted.python.usage.Options>} for details. @type _protoDefaults: L{dict} mapping L{bytes} to L{int} @ivar _protoDefaults: A mapping of default service to port. @type compData: L{Completions <usage.Completions>} @ivar compData: Metadata for the shell tab completion system. @type longdesc: L{bytes} @ivar longdesc: A long description of the plugin for use in the usage message. @type service: L{MailService} @ivar service: The email service. @type last_domain: L{IDomain} provider or L{None} @ivar last_domain: The most recently specified domain. """ synopsis = "[options]" optParameters = [ [ "relay", "R", None, "Relay messages according to their envelope 'To', using " "the given path as a queue directory.", ], ["hostname", "H", None, "The hostname by which to identify this server."], ] optFlags = [ ["esmtp", "E", "Use RFC 1425/1869 SMTP extensions"], ["disable-anonymous", None, "Disallow non-authenticated SMTP connections"], ["no-pop3", None, "Disable the default POP3 server."], ["no-smtp", None, "Disable the default SMTP server."], ] _protoDefaults = { "pop3": 8110, "smtp": 8025, } compData = usage.Completions(optActions={"hostname": usage.CompleteHostnames()}) longdesc = """ An SMTP / POP3 email server plugin for twistd. Examples: 1. SMTP and POP server twistd mail --maildirdbmdomain=example.com=/tmp/example.com --user=joe=password Starts an SMTP server that only accepts emails to joe@example.com and saves them to /tmp/example.com. Also starts a POP mail server which will allow a client to log in using username: joe@example.com and password: password and collect any email that has been saved in /tmp/example.com. 2. SMTP relay twistd mail --relay=/tmp/mail_queue Starts an SMTP server that accepts emails to any email address and relays them to an appropriate remote SMTP server. Queued emails will be temporarily stored in /tmp/mail_queue. """ def __init__(self): """ Parse options and create a mail service. """ usage.Options.__init__(self) self.service = mail.MailService() self.last_domain = None for service in self._protoDefaults: self[service] = [] def addEndpoint(self, service, description): """ Add an endpoint to a service. @type service: L{bytes} @param service: A service, either C{b'smtp'} or C{b'pop3'}. @type description: L{bytes} @param description: An endpoint description string or a TCP port number. """ from twisted.internet import reactor self[service].append(endpoints.serverFromString(reactor, description)) def opt_pop3(self, description): """ Add a POP3 port listener on the specified endpoint. You can listen on multiple ports by specifying multiple --pop3 options. """ self.addEndpoint("pop3", description) opt_p = opt_pop3 def opt_smtp(self, description): """ Add an SMTP port listener on the specified endpoint. You can listen on multiple ports by specifying multiple --smtp options. """ self.addEndpoint("smtp", description) opt_s = opt_smtp def opt_default(self): """ Make the most recently specified domain the default domain. """ if self.last_domain: self.service.addDomain("", self.last_domain) else: raise usage.UsageError("Specify a domain before specifying using --default") opt_D = opt_default def opt_maildirdbmdomain(self, domain): """ Generate an SMTP/POP3 virtual domain. This option requires an argument of the form 'NAME=PATH' where NAME is the DNS domain name for which email will be accepted and where PATH is a the filesystem path to a Maildir folder. [Example: 'example.com=/tmp/example.com'] """ try: name, path = domain.split("=") except ValueError: raise usage.UsageError( "Argument to --maildirdbmdomain must be of the form 'name=path'" ) self.last_domain = maildir.MaildirDirdbmDomain( self.service, os.path.abspath(path) ) self.service.addDomain(name, self.last_domain) opt_d = opt_maildirdbmdomain def opt_user(self, user_pass): """ Add a user and password to the last specified domain. """ try: user, password = user_pass.split("=", 1) except ValueError: raise usage.UsageError( "Argument to --user must be of the form 'user=password'" ) if self.last_domain: self.last_domain.addUser(user, password) else: raise usage.UsageError("Specify a domain before specifying users") opt_u = opt_user def opt_bounce_to_postmaster(self): """ Send undeliverable messages to the postmaster. """ self.last_domain.postmaster = 1 opt_b = opt_bounce_to_postmaster def opt_aliases(self, filename): """ Specify an aliases(5) file to use for the last specified domain. """ if self.last_domain is not None: if mail.IAliasableDomain.providedBy(self.last_domain): aliases = alias.loadAliasFile(self.service.domains, filename) self.last_domain.setAliasGroup(aliases) self.service.monitor.monitorFile( filename, AliasUpdater(self.service.domains, self.last_domain) ) else: raise usage.UsageError( "%s does not support alias files" % (self.last_domain.__class__.__name__,) ) else: raise usage.UsageError("Specify a domain before specifying aliases") opt_A = opt_aliases def _getEndpoints(self, reactor, service): """ Return a list of endpoints for the specified service, constructing defaults if necessary. If no endpoints were configured for the service and the protocol was not explicitly disabled with a I{--no-*} option, a default endpoint for the service is created. @type reactor: L{IReactorTCP <twisted.internet.interfaces.IReactorTCP>} provider @param reactor: If any endpoints are created, the reactor with which they are created. @type service: L{bytes} @param service: The type of service for which to retrieve endpoints, either C{b'pop3'} or C{b'smtp'}. @rtype: L{list} of L{IStreamServerEndpoint <twisted.internet.interfaces.IStreamServerEndpoint>} provider @return: The endpoints for the specified service as configured by the command line parameters. """ if self[service]: # If there are any services set up, just return those. return self[service] elif self["no-" + service]: # If there are no services, but the service was explicitly disabled, # return nothing. return [] else: # Otherwise, return the old default service. return [endpoints.TCP4ServerEndpoint(reactor, self._protoDefaults[service])] def postOptions(self): """ Check the validity of the specified set of options and configure authentication. @raise UsageError: When the set of options is invalid. """ from twisted.internet import reactor if self["esmtp"] and self["hostname"] is None: raise usage.UsageError("--esmtp requires --hostname") # If the --auth option was passed, this will be present -- otherwise, # it won't be, which is also a perfectly valid state. if "credCheckers" in self: for ch in self["credCheckers"]: self.service.smtpPortal.registerChecker(ch) if not self["disable-anonymous"]: self.service.smtpPortal.registerChecker(checkers.AllowAnonymousAccess()) anything = False for service in self._protoDefaults: self[service] = self._getEndpoints(reactor, service) if self[service]: anything = True if not anything: raise usage.UsageError("You cannot disable all protocols") class AliasUpdater: """ A callable object which updates the aliases for a domain from an aliases(5) file. @ivar domains: See L{__init__}. @ivar domain: See L{__init__}. """ def __init__(self, domains, domain): """ @type domains: L{dict} mapping L{bytes} to L{IDomain} provider @param domains: A mapping of domain name to domain object @type domain: L{IAliasableDomain} provider @param domain: The domain to update. """ self.domains = domains self.domain = domain def __call__(self, new): """ Update the aliases for a domain from an aliases(5) file. @type new: L{bytes} @param new: The name of an aliases(5) file. """ self.domain.setAliasGroup(alias.loadAliasFile(self.domains, new)) def makeService(config): """ Configure a service for operating a mail server. The returned service may include POP3 servers, SMTP servers, or both, depending on the configuration passed in. If there are multiple servers, they will share all of their non-network state (i.e. the same user accounts are available on all of them). @type config: L{Options <usage.Options>} @param config: Configuration options specifying which servers to include in the returned service and where they should keep mail data. @rtype: L{IService <twisted.application.service.IService>} provider @return: A service which contains the requested mail servers. """ if config["esmtp"]: rmType = relaymanager.SmartHostESMTPRelayingManager smtpFactory = config.service.getESMTPFactory else: rmType = relaymanager.SmartHostSMTPRelayingManager smtpFactory = config.service.getSMTPFactory if config["relay"]: dir = config["relay"] if not os.path.isdir(dir): os.mkdir(dir) config.service.setQueue(relaymanager.Queue(dir)) default = relay.DomainQueuer(config.service) manager = rmType(config.service.queue) if config["esmtp"]: manager.fArgs += (None, None) manager.fArgs += (config["hostname"],) helper = relaymanager.RelayStateHelper(manager, 1) helper.setServiceParent(config.service) config.service.domains.setDefaultDomain(default) if config["pop3"]: f = config.service.getPOP3Factory() for endpoint in config["pop3"]: svc = internet.StreamServerEndpointService(endpoint, f) svc.setServiceParent(config.service) if config["smtp"]: f = smtpFactory() if config["hostname"]: f.domain = config["hostname"] f.fArgs = (f.domain,) if config["esmtp"]: f.fArgs = (None, None) + f.fArgs for endpoint in config["smtp"]: svc = internet.StreamServerEndpointService(endpoint, f) svc.setServiceParent(config.service) return config.service PK Mb�Z�� &0 &0 mail/protocols.pynu �[��� # -*- test-case-name: twisted.mail.test.test_mail -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Mail protocol support. """ from zope.interface import implementer from twisted.copyright import longversion from twisted.cred.credentials import CramMD5Credentials, UsernamePassword from twisted.cred.error import UnauthorizedLogin from twisted.internet import defer, protocol from twisted.mail import pop3, relay, smtp from twisted.python import log @implementer(smtp.IMessageDelivery) class DomainDeliveryBase: """ A base class for message delivery using the domains of a mail service. @ivar service: See L{__init__} @ivar user: See L{__init__} @ivar host: See L{__init__} @type protocolName: L{bytes} @ivar protocolName: The protocol being used to deliver the mail. Sub-classes should set this appropriately. """ service = None protocolName: bytes = b"not-implemented-protocol" def __init__(self, service, user, host=smtp.DNSNAME): """ @type service: L{MailService} @param service: A mail service. @type user: L{bytes} or L{None} @param user: The authenticated SMTP user. @type host: L{bytes} @param host: The hostname. """ self.service = service self.user = user self.host = host def receivedHeader(self, helo, origin, recipients): """ Generate a received header string for a message. @type helo: 2-L{tuple} of (L{bytes}, L{bytes}) @param helo: The client's identity as sent in the HELO command and its IP address. @type origin: L{Address} @param origin: The origination address of the message. @type recipients: L{list} of L{User} @param recipients: The destination addresses for the message. @rtype: L{bytes} @return: A received header string. """ authStr = heloStr = b"" if self.user: authStr = b" auth=" + self.user.encode("xtext") if helo[0]: heloStr = b" helo=" + helo[0] fromUser = b"from " + helo[0] + b" ([" + helo[1] + b"]" + heloStr + authStr by = ( b"by " + self.host + b" with " + self.protocolName + b" (" + longversion.encode("ascii") + b")" ) forUser = ( b"for <" + b" ".join(map(bytes, recipients)) + b"> " + smtp.rfc822date() ) return b"Received: " + fromUser + b"\n\t" + by + b"\n\t" + forUser def validateTo(self, user): """ Validate the address for which a message is destined. @type user: L{User} @param user: The destination address. @rtype: L{Deferred <defer.Deferred>} which successfully fires with no-argument callable which returns L{IMessage <smtp.IMessage>} provider. @return: A deferred which successfully fires with a no-argument callable which returns a message receiver for the destination. @raise SMTPBadRcpt: When messages cannot be accepted for the destination address. """ # XXX - Yick. This needs cleaning up. if self.user and self.service.queue: d = self.service.domains.get(user.dest.domain, None) if d is None: d = relay.DomainQueuer(self.service, True) else: d = self.service.domains[user.dest.domain] return defer.maybeDeferred(d.exists, user) def validateFrom(self, helo, origin): """ Validate the address from which a message originates. @type helo: 2-L{tuple} of (L{bytes}, L{bytes}) @param helo: The client's identity as sent in the HELO command and its IP address. @type origin: L{Address} @param origin: The origination address of the message. @rtype: L{Address} @return: The origination address. @raise SMTPBadSender: When messages cannot be accepted from the origination address. """ if not helo: raise smtp.SMTPBadSender(origin, 503, "Who are you? Say HELO first.") if origin.local != b"" and origin.domain == b"": raise smtp.SMTPBadSender(origin, 501, "Sender address must contain domain.") return origin class SMTPDomainDelivery(DomainDeliveryBase): """ A domain delivery base class for use in an SMTP server. """ protocolName = b"smtp" class ESMTPDomainDelivery(DomainDeliveryBase): """ A domain delivery base class for use in an ESMTP server. """ protocolName = b"esmtp" class SMTPFactory(smtp.SMTPFactory): """ An SMTP server protocol factory. @ivar service: See L{__init__} @ivar portal: See L{__init__} @type protocol: no-argument callable which returns a L{Protocol <protocol.Protocol>} subclass @ivar protocol: A callable which creates a protocol. The default value is L{SMTP}. """ protocol = smtp.SMTP portal = None def __init__(self, service, portal=None): """ @type service: L{MailService} @param service: An email service. @type portal: L{Portal <twisted.cred.portal.Portal>} or L{None} @param portal: A portal to use for authentication. """ smtp.SMTPFactory.__init__(self) self.service = service self.portal = portal def buildProtocol(self, addr): """ Create an instance of an SMTP server protocol. @type addr: L{IAddress <twisted.internet.interfaces.IAddress>} provider @param addr: The address of the SMTP client. @rtype: L{SMTP} @return: An SMTP protocol. """ log.msg(f"Connection from {addr}") p = smtp.SMTPFactory.buildProtocol(self, addr) p.service = self.service p.portal = self.portal return p class ESMTPFactory(SMTPFactory): """ An ESMTP server protocol factory. @type protocol: no-argument callable which returns a L{Protocol <protocol.Protocol>} subclass @ivar protocol: A callable which creates a protocol. The default value is L{ESMTP}. @type context: L{IOpenSSLContextFactory <twisted.internet.interfaces.IOpenSSLContextFactory>} or L{None} @ivar context: A factory to generate contexts to be used in negotiating encrypted communication. @type challengers: L{dict} mapping L{bytes} to no-argument callable which returns L{ICredentials <twisted.cred.credentials.ICredentials>} subclass provider. @ivar challengers: A mapping of acceptable authorization mechanism to callable which creates credentials to use for authentication. """ protocol = smtp.ESMTP context = None def __init__(self, *args): """ @param args: Arguments for L{SMTPFactory.__init__} @see: L{SMTPFactory.__init__} """ SMTPFactory.__init__(self, *args) self.challengers = {b"CRAM-MD5": CramMD5Credentials} def buildProtocol(self, addr): """ Create an instance of an ESMTP server protocol. @type addr: L{IAddress <twisted.internet.interfaces.IAddress>} provider @param addr: The address of the ESMTP client. @rtype: L{ESMTP} @return: An ESMTP protocol. """ p = SMTPFactory.buildProtocol(self, addr) p.challengers = self.challengers p.ctx = self.context return p class VirtualPOP3(pop3.POP3): """ A virtual hosting POP3 server. @type service: L{MailService} @ivar service: The email service that created this server. This must be set by the service. @type domainSpecifier: L{bytes} @ivar domainSpecifier: The character to use to split an email address into local-part and domain. The default is '@'. """ service = None domainSpecifier = b"@" # Gaagh! I hate POP3. No standardized way # to indicate user@host. '@' doesn't work # with NS, e.g. def authenticateUserAPOP(self, user, digest): """ Perform APOP authentication. Override the default lookup scheme to allow virtual domains. @type user: L{bytes} @param user: The name of the user attempting to log in. @type digest: L{bytes} @param digest: The challenge response. @rtype: L{Deferred} which successfully results in 3-L{tuple} of (L{IMailbox <pop3.IMailbox>}, L{IMailbox <pop3.IMailbox>} provider, no-argument callable) @return: A deferred which fires when authentication is complete. If successful, it returns an L{IMailbox <pop3.IMailbox>} interface, a mailbox and a logout function. If authentication fails, the deferred fails with an L{UnauthorizedLogin <twisted.cred.error.UnauthorizedLogin>} error. """ user, domain = self.lookupDomain(user) try: portal = self.service.lookupPortal(domain) except KeyError: return defer.fail(UnauthorizedLogin()) else: return portal.login( pop3.APOPCredentials(self.magic, user, digest), None, pop3.IMailbox ) def authenticateUserPASS(self, user, password): """ Perform authentication for a username/password login. Override the default lookup scheme to allow virtual domains. @type user: L{bytes} @param user: The name of the user attempting to log in. @type password: L{bytes} @param password: The password to authenticate with. @rtype: L{Deferred} which successfully results in 3-L{tuple} of (L{IMailbox <pop3.IMailbox>}, L{IMailbox <pop3.IMailbox>} provider, no-argument callable) @return: A deferred which fires when authentication is complete. If successful, it returns an L{IMailbox <pop3.IMailbox>} interface, a mailbox and a logout function. If authentication fails, the deferred fails with an L{UnauthorizedLogin <twisted.cred.error.UnauthorizedLogin>} error. """ user, domain = self.lookupDomain(user) try: portal = self.service.lookupPortal(domain) except KeyError: return defer.fail(UnauthorizedLogin()) else: return portal.login(UsernamePassword(user, password), None, pop3.IMailbox) def lookupDomain(self, user): """ Check whether a domain is among the virtual domains supported by the mail service. @type user: L{bytes} @param user: An email address. @rtype: 2-L{tuple} of (L{bytes}, L{bytes}) @return: The local part and the domain part of the email address if the domain is supported. @raise POP3Error: When the domain is not supported by the mail service. """ try: user, domain = user.split(self.domainSpecifier, 1) except ValueError: domain = b"" if domain not in self.service.domains: raise pop3.POP3Error("no such domain {}".format(domain.decode("utf-8"))) return user, domain class POP3Factory(protocol.ServerFactory): """ A POP3 server protocol factory. @ivar service: See L{__init__} @type protocol: no-argument callable which returns a L{Protocol <protocol.Protocol>} subclass @ivar protocol: A callable which creates a protocol. The default value is L{VirtualPOP3}. """ protocol = VirtualPOP3 service = None def __init__(self, service): """ @type service: L{MailService} @param service: An email service. """ self.service = service def buildProtocol(self, addr): """ Create an instance of a POP3 server protocol. @type addr: L{IAddress <twisted.internet.interfaces.IAddress>} provider @param addr: The address of the POP3 client. @rtype: L{POP3} @return: A POP3 protocol. """ p = protocol.ServerFactory.buildProtocol(self, addr) p.service = self.service return p PK Mb�Z���< < # mail/__pycache__/pb.cpython-310.pycnu �[��� o �bw � @ s` d dl Z d dlmZ G dd� dej�ZG dd� dej�ZG dd� dej�ZG d d � d ej�ZdS ) � N)�pbc @ s� e Zd Zdd� Zdd� Zdd� Zdd� ZeZd d � ZeZ d d � Z e Z d d� Z e Z dd� ZeZdd� ZeZdd� ZeZdd� ZdS )�Maildirc C s || _ || _tj�||�| _d S �N)�virtualDirectory� rootDirectory�os�path�join� directory)�selfr r � r �1/usr/lib/python3/dist-packages/twisted/mail/pb.py�__init__ s zMaildir.__init__c C sV d|v r t d| ��ttj�| jd|��� }|�� W d � S 1 s$w Y d S )N�/z&can only open files in '%s' directory'�new)�OSError�openr r r r �read)r �folder�name�fpr r r �getFolderMessage s $�zMaildir.getFolderMessagec C sB d|v r t d| ��t�tj�| j||�tj�| jd||�� d S )Nr z(can only delete files in '%s' directory'z.Trash)r r �renamer r r r )r r r r r r �deleteFolderMessage s �zMaildir.deleteFolderMessagec C � | � d|�S �Nr �r �r r r r r �deleteNewMessage � zMaildir.deleteNewMessagec C r �N�curr r r r r �deleteCurMessage# r zMaildir.deleteCurMessagec C � t �t j�| jd��S r �r �listdirr r r �r r r r �getNewMessages( � zMaildir.getNewMessagesc C r# r r$ r& r r r �getCurMessages- r( zMaildir.getCurMessagesc C r r �r r r r r � getNewMessage2 r zMaildir.getNewMessagec C r r r* r r r r � getCurMessage7 r zMaildir.getCurMessagec C s` |d dkr t d��|�dd�}| jdkrd| }n| jd | }| �|�s*t d��t|| j�S )Nr �.z&subfolder name cannot begin with a '.'r �:znot a subfolder)r �replace�virtualDirectoyr � _isSubFolderr r r r r r � getSubFolder< s zMaildir.getSubFolderc C s6 t j�t j�| j|�� pt j�t j�| j|d�� S )N� maildirfolder)r r �isdirr r �isfiler r r r r1 J s ��zMaildir._isSubFolderN)�__name__� __module__� __qualname__r r r r �remote_deleteNewMessager" �remote_deleteCurMessager' �remote_getNewMessagesr) �remote_getCurMessagesr+ �remote_getNewMessager, �remote_getCurMessager2 �remote_getSubFolderr1 r r r r r s& r c @ s, e Zd Zdd� Zdd� ZeZdd� ZeZdS )�MaildirCollectionc C s || _ d S r )�root)r rA r r r r Q s zMaildirCollection.__init__c C s t �| �� �S r )r r% �getRootr& r r r � getSubFoldersT s z MaildirCollection.getSubFoldersc C s4 d|v s |d dkrt d��tdtj�| �� |��S )Nr r r- z invalid name)r r r r r rB r r r r r2 Y s z MaildirCollection.getSubFolderN)r6 r7 r8 r rC �remote_getSubFoldersr2 r? r r r r r@ P s r@ c @ s e Zd Zdd� Zdd� ZdS )� MaildirBrokerc C s0 | � � }|d u r| �|d� d S | �||� d S )Nzpermission denied)�_getCollection� sendError� sendAnswer)r � requestIDr �domain�password� collectionr r r �proto_getCollectionb s z!MaildirBroker.proto_getCollectionc C sF || j vrd S | j | }||jv r |j| |kr!t|�|��S d S d S r )�domains�dbmr@ � userDirectory)r r rJ rK r r r � getCollectioni s �zMaildirBroker.getCollectionN)r6 r7 r8 rM rQ r r r r rE a s rE c @ s e Zd Zdd� ZdS )� MaildirClientc C s, | � � }||f| j|< | �d||||� d S )NrQ )� newRequestID�waitingForAnswers�sendCall)r r rJ rK �callback�errbackrI r r r rQ r s zMaildirClient.getCollectionN)r6 r7 r8 rQ r r r r rR q s rR ) r �twisted.spreadr � Referenceabler r@ �BrokerrE rR r r r r �<module> s FPK Mb�Z8 �U� � + mail/__pycache__/pop3client.cpython-310.pycnu �[��� o �b� � @ s^ U d Z ddlZddlmZ ddlmZmZmZ ejde dd� e e e g Z ee e d< dS ) zr Deprecated POP3 client protocol implementation. Don't use this module directly. Use twisted.mail.pop3 instead. � N)�List)�ERR�OK� POP3ClientzXtwisted.mail.pop3client was deprecated in Twisted 21.2.0. Use twisted.mail.pop3 instead.� )� stacklevel�__all__) �__doc__�warnings�typingr �twisted.mail._pop3clientr r r �warn�DeprecationWarningr �str�__annotations__� r r �9/usr/lib/python3/dist-packages/twisted/mail/pop3client.py�<module> s �PK Mb�Z.�YD-� -� & mail/__pycache__/imap4.cpython-310.pycnu �[��� o �bW: � @ s d Z ddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z mZ ddlmZ ddlmZ ddlmZmZmZ ddlmZ ddlmZ dd lm Z m Z dd l m Z m Z m!Z! dd l"m#Z# dd l$m%Z%m&Z&m'Z'm(Z(m)Z) dd l*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z: ddl;m<Z=m>Z>m?Z@mAZBmCZDmEZFmGZHmIZJmKZLmMZNmOZOmPZQ ddlRmSZSmTZT ddlUmVZVmWZW ddlXmYZYmZZZm[Z[m\Z\m]Z] e^e_e`dd�d�a� ��Zbdd� Zcdd� ZdG dd� d�ZeG dd � d �ZfG d d � d �ZgG d d � d �ZhG d!d"� d"�Zid#Zjekee`d$�e`d%d&���Zld'ej el Zmem�nd(�Zoe�pd)eo d* �Zqekd+d,� e`d&�D ��ZreeF�G d-d.� d.eSjseTjt��Zue �v� ZweeF�G d/d0� d0eSjseTjt��Zxd�d1d2�Zyd3Zzd4Z{e|Z}d�d5d6�Z~d7d8� Zd9d:� Z�d�d;d<�Z�d=d>� Z�d?d@� Z�dAdB� Z�d�dCdD�Z�dEdF� Z�dGekdHekfdIdJ�Z�G dKdL� dL�Z�dMZ�dNdO� Z�dPdQ� Z�dRdS� Z�dTdU� Z�dVdW� Z�ee=�G dXdY� dY��Z�eeO�G dZd[� d[e���Z�d\d]d^d_d`da�Z�dbdc� Z�ddde� Z�dfdg� Z�dhdi� Z�djdk� Z�dldm� Z�dndo� Z�G dpdq� dq�Z�G drds� dse��Z�G dtdu� due��Z�G dvdw� dwe��Z�G dxdy� dye��Z�d�d{d|�Z�d}d~� Z�dd�� Z�d�d�� Z�G d�d�� d��Z�G d�d�� d��Z�G d�d�� d��Z�d�d�� Z�e�e�d�d�d�� �Z�d�d�� Z�d�d�� Z�d�d�d��Z�d�d�d��Z�G d�d�� d�ej��Z�G d�d�� d�ej��Z�e��e�e�e�e��Z�d�d�� Z�e��e�� g d��Z�dS )�a� An IMAP4 protocol implementation @author: Jp Calderone To do:: Suspend idle timeout while server is processing Use an async message parser instead of buffering in memory Figure out a way to not queue multi-message client requests (Flow? A simple callback?) Clarify some API docs (Query, etc) Make APPEND recognize (again) non-existent mailboxes before accepting the literal � N)� decodebytes� encodebytes)�BytesIO)�chain)�Any�List�cast)� implementer)� credentials)�UnauthorizedLogin�UnhandledCredentials)�defer�error� interfaces)� maybeDeferred)�CramMD5ClientAuthenticator�LOGINAuthenticator�LOGINCredentials�PLAINAuthenticator�PLAINCredentials)�IllegalClientResponse�IllegalIdentifierError�IllegalMailboxEncoding�IllegalOperation�IllegalQueryError�IllegalServerResponse�IMAP4Exception�MailboxCollision�MailboxException�MismatchedNesting�MismatchedQuoting�NegativeResponse� NoSuchMailbox�NoSupportedAuthentication�ReadOnlyMailbox�UnhandledResponse) � IAccountIMAP�IClientAuthentication�ICloseableMailboxIMAP� IMailboxIMAP�IMailboxIMAPInfo�IMailboxIMAPListener� IMessageIMAP�IMessageIMAPCopier�IMessageIMAPFile�IMessageIMAPPart�INamespacePresenter�ISearchableIMAPMailbox)�basic�policies)�log�text)�_get_async_param�_matchingString� iterbytes� nativeString� networkString� � z/Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Decc C s | |u r|S | S )z� Swap C{this} with C{that} if C{this} is C{ifIs}. @param this: The object that may be replaced. @param that: The object that may replace C{this}. @param ifIs: An object whose identity will be compared to C{this}. � )�this�that�ifIsr= r= �4/usr/lib/python3/dist-packages/twisted/mail/imap4.py�_swap` s rB c s � �fdd�| D �S )a� Swap each element in each pair in C{of} with C{that} it is C{ifIs}. @param of: A list of 2-L{tuple}s, whose members may be the object C{that} @type of: L{list} of 2-L{tuple}s @param ifIs: An object whose identity will be compared to members of each pair in C{of} @return: A L{list} of 2-L{tuple}s with all occurences of C{ifIs} replaced with C{that} c s( g | ]\}}t |�� �t |�� �f�qS r= )rB )�.0�first�second�r@ r? r= rA � <listcomp>} s �z!_swapAllPairs.<locals>.<listcomp>r= )�ofr? r@ r= rF rA � _swapAllPairsn s �rI c @ s� e Zd ZU dZg Zee ed< ed�Z eefdd�Z e dd� �Z e j dd� �Z efd d �Zd d � Zd d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdefd d �Zdefd d �Zd edefd!d"�Z d#S )$� MessageSeta A set of message identifiers usable by both L{IMAP4Client} and L{IMAP4Server} via L{IMailboxIMAP.store} and L{IMailboxIMAP.fetch}. These identifiers can be either message sequence numbers or unique identifiers. See Section 2.3.1, "Message Numbers", RFC 3501. This represents the C{sequence-set} described in Section 9, "Formal Syntax" of RFC 3501: - A L{MessageSet} can describe a single identifier, e.g. C{MessageSet(1)} - A L{MessageSet} can describe C{*} via L{None}, e.g. C{MessageSet(None)} - A L{MessageSet} can describe a range of identifiers, e.g. C{MessageSet(1, 2)}. The range is inclusive and unordered (see C{seq-range} in RFC 3501, Section 9), so that C{Message(2, 1)} is equivalent to C{MessageSet(1, 2)}, and both describe messages 1 and 2. Ranges can include C{*} by specifying L{None}, e.g. C{MessageSet(None, 1)}. In all cases ranges are normalized so that the smallest identifier comes first, and L{None} always comes last; C{Message(2, 1)} becomes C{MessageSet(1, 2)} and C{MessageSet(None, 1)} becomes C{MessageSet(1, None)} - A L{MessageSet} can describe a sequence of single identifiers and ranges, constructed by addition. C{MessageSet(1) + MessageSet(5, 10)} refers the message identified by C{1} and the messages identified by C{5} through C{10}. B{NB: The meaning of * varies, but it always represents the largest number in use}. B{For servers}: Your L{IMailboxIMAP} provider must set L{MessageSet.last} to the highest-valued identifier (unique or message sequence) before iterating over it. B{For clients}: C{*} consumes ranges smaller than it, e.g. C{MessageSet(1, 100) + MessageSet(50, None)} is equivalent to C{1:*}. @type getnext: Function taking L{int} returning L{int} @ivar getnext: A function that returns the next message number, used when iterating through the L{MessageSet}. By default, a function returning the next integer is supplied, but as this can be rather inefficient for sparse UID iterations, it is recommended to supply one when messages are requested by UID. The argument is provided as a hint to the implementation and may be ignored if it makes sense to do so (eg, if an iterator is being used that maintains its own state, it is guaranteed that it will not be called out-of-order). �_empty�infc C sZ | j | _g | _dd� | _|| j u rdS t|t�r%|dd� | _| �� dS | �||� dS )z� Create a new MessageSet() @type start: Optional L{int} @param start: Start of range, or only message number @type end: Optional L{int} @param end: End of range. c S s | d S �Nr; r= ��xr= r= rA �<lambda>� � z%MessageSet.__init__.<locals>.<lambda>N)rK �_last�ranges�getnext� isinstance�list�clean�add��self�start�endr= r= rA �__init__� s zMessageSet.__init__c C s | j S )z{ The largest number in use. This is undefined until it has been set by assigning to this property. )rR �rZ r= r= rA �last� s zMessageSet.lastc C sv | j | jur td��|| _ t| j�D ]"\}\}}|du r |}|du r$|}||kr-||}}||f| j|< q| �� dS )z� Replaces all occurrences of "*". This should be the largest number in use. Must be set before attempting to use the MessageSet as a container. @raises ValueError: if a largest value has already been set. zlast already setN)rR rK � ValueError� enumeraterS rW )rZ �value�i�low�highr= r= rA r_ � s c C st || j u r|}| j| j ur|du r| j}|du r| j}t||gtjt| jdd�d�\}}| j� ||f� | � � dS )z� Add another range @type start: L{int} @param start: Start of range, or only message number @type end: Optional L{int} @param end: End of range. N�r? r@ )�key) rK rR r_ �sorted� functools�partialrB � _infinityrS �appendrW rY r= r= rA rX � s � zMessageSet.addc C sl t |t�r| j|j }t|�S t| j�}| j| jur | j|_z|j|� W |S ty5 |�|� Y |S w �N)rU rJ rS r_ rK rX � TypeError)rZ �otherrS �resr= r= rA �__add__ s � �zMessageSet.__add__c C sT t |t�r| j�|j� | �� | S z| j|� W | S ty) | �|� Y | S w )z� Extend our messages with another message or set of messages. @param other: The messages to include. @type other: L{MessageSet}, L{tuple} of two L{int}s, or a single L{int} )rU rJ rS �extendrW rX rn �rZ ro r= r= rA rr s � � �zMessageSet.extendc C s� t t| j| jdd��}td�td�fg}|D ]$\}}|d \}}||d k r.|�||f� qt||�t||�f|d< qt|dd� d| jd�| _dS )z> Clean ranges list, combining adjacent ranges Nrf z-inf���r; )rh rI rS rk �floatrl �min�max)rZ rS � mergedRangesrd re � previousLow� previousHighr= r= rA rW 0 s zMessageSet.cleanc C s | j d d du S )a� Is there a L{None} in our ranges? L{MessageSet.clean} merges overlapping or consecutive ranges. None is represents a value larger than any number. There are thus two cases: 1. C{(x, *) + (y, z)} such that C{x} is smaller than C{y} 2. C{(z, *) + (x, y)} such that C{z} is larger than C{y} (Other cases, such as C{y < x < z}, can be split into these two cases; for example C{(y - 1, y)} + C{(x, x) + (z, z + 1)}) In case 1, C{* > y} and C{* > z}, so C{(x, *) + (y, z) = (x, *)} In case 2, C{z > x and z > y}, so the intervals do not merge, and the ranges are sorted as C{[(x, y), (z, *)]}. C{*} is represented as C{(*, *)}, so this is the same as 2. but with a C{z} that is greater than everything. The result is that there is a maximum of two L{None}s, and one of them has to be the high element in the last tuple in C{self.ranges}. That means checking if C{self.ranges[-1][-1]} is L{None} suffices to check if I{any} element is L{None}. @return: L{True} if L{None} is in some range in ranges and L{False} if otherwise. rt N)rS r^ r= r= rA � _noneInRangesD s zMessageSet._noneInRangesc C s@ | � � rtd��| jD ]\}}|| kr|kr dS q q dS )z� May raise TypeError if we encounter an open-ended range @param value: Is this in our ranges? @type value: L{int} z.Can't determine membership; last value not setTF)r{ rn rS )rZ rb rd re r= r= rA � __contains__e s �zMessageSet.__contains__c c sD � | j D ]\}}| �|d �}||kr |V | �|�}||ksqd S rM )rS rT )rZ �l�hr= r= rA � _iteratorv s � ���zMessageSet._iteratorc C s | � � rtd��| �� S )Nz!Can't iterate; last value not set)r{ rn r r^ r= r= rA �__iter__} s zMessageSet.__iter__c C sJ d}| j D ] \}}|d u r|d7 }q|d u rtd��||| d 7 }q|S )Nr r; z%Can't size object; last value not set)rS rn )rZ rp r} r~ r= r= rA �__len__� s zMessageSet.__len__�returnc C sv g }| j D ]0\}}||kr |d u r|�d� q|�t|�� q|d u r,|�d|f � q|�d||f � qd�|�S )N�*z%d:*z%d:%d�,)rS rl �str�join)rZ �prd re r= r= rA �__str__� s zMessageSet.__str__c C s dt | �� d�S )Nz <MessageSet �>�r� r^ r= r= rA �__repr__� � zMessageSet.__repr__ro c C s t |t�rtt| j|jk�S tS rm )rU rJ r �boolrS �NotImplementedrs r= r= rA �__eq__� s zMessageSet.__eq__N) �__name__� __module__� __qualname__�__doc__rK r r �__annotations__ru rk r] �propertyr_ �setterrX rq rr rW r{ r| r r� r� r� r� r� �objectr� r� r= r= r= rA rJ � s* 9 ! rJ c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )� LiteralStringc C s || _ g | _|| _d S rm )�size�datar �rZ r� �deferedr= r= rA r] � � zLiteralString.__init__c C �n | j t|�8 _ d }| j dkr| j�|� |S | j r+|d | j � || j d � }}nd}|r5| j�|� |S �Nr � )r� �lenr� rl �rZ r� �passonr= r= rA �write� s � zLiteralString.writec C s | j �d�| j�|f� dS )�: Call deferred with data and rest of line r� N)r �callbackr� r� �rZ �liner= r= rA r� � s zLiteralString.callbackN)r� r� r� r] r� r� r= r= r= rA r� � s r� c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) � LiteralFile� � c C s0 || _ || _|| jkrt�� | _d S t� | _d S rm )r� r �_memoryFileLimit�tempfile� TemporaryFiler� r r� r= r= rA r] � s zLiteralFile.__init__c C r� r� )r� r� r� r� r� r= r= rA r� � s � zLiteralFile.writec C s$ | j �dd� | j�| j |f� dS )r� r N)r� �seekr r� r� r= r= rA r� � s zLiteralFile.callbackN)r� r� r� r� r] r� r� r= r= r= rA r� � s r� c @ s* e Zd ZdZd dd�Zdd� Zdd� Zd S ) � WriteBufferzU Buffer up a bunch of writes before sending them all to a transport at once. � c C s || _ || _d| _g | _d S �Nr )� bufferSize� transport�_length�_writes)rZ r� r� r= r= rA r] � s zWriteBuffer.__init__c C s: | j t|�7 _ | j�|� | j | jkr| �� d S d S rm )r� r� r� rl r� �flush�rZ �sr= r= rA r� � s �zWriteBuffer.writec C s( | j r| j�| j � g | _ d| _d S d S r� )r� r� � writeSequencer� r^ r= r= rA r� � s �zWriteBuffer.flushN)r� )r� r� r� r� r] r� r� r= r= r= rA r� � s r� c @ sJ e Zd ZdZdZdZdZ ddd�Zdefd d �Z d d � Z d d� Z dS )�Command)� CAPABILITY� FLAGS� LIST� LSUB� STATUS� SEARCH� NAMESPACE)� EXISTS� EXPUNGE� FETCH� RECENT)� UIDVALIDITY� UNSEEN� READ-WRITE� READ-ONLY� UIDNEXT� PERMANENTFLAGSNr= c s. || _ || _|| _� ��fdd�| _g | _d S )Nc s �| g� �R i ���S rm r= rN ��contArgs�contKw� continuationr= rA rP � z"Command.__init__.<locals>.<lambda>)�command�args� wantResponser� �lines)rZ r� r� r� r� r� r� r= r� rA r] s zCommand.__init__r� c C s d� | j| j| j| j| j�S )Nz(<imap4.Command {!r} {!r} {!r} {!r} {!r}>)�formatr� r� r� r� r� r^ r= r= rA r� s �zCommand.__repr__c C s. | j d u r d�|| jf�S d�|| j| j f�S �N� )r� r� r� �rZ �tagr= r= rA r� $ s zCommand.formatc C s� g }g }| j D ]E}t|�}t|�}|dkr |d | jv sA|dkr'|d | jv sA|dkrG|d dkrGt|d t�rG|d d | jv rG|�|� q|�|� q| j d }| _ |� ||f� |rc||� d S d S )Nr; r � � OK) r� �parseNestedParensr� � _1_RESPONSES� _2_RESPONSESrU rV � _OK_RESPONSESrl r r� ) rZ �lastLine�unusedCallback�send�unuse�L�names�N�dr= r= rA �finish) s* � �zCommand.finish)Nr= N) r� r� r� r� r� r� r r] r� r� r� r� r= r= r= rA r� � s � r� r� �! � � s ]\\(){%*"�charmap�[�]c c s � | ] }|t vr|V qd S rm )� _nonAtomChars)rC �chr= r= rA � <genexpr>R s � r� c @ s� e Zd ZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZdZh d�Zd Zd Z�dMd d �Zd d� Zdd� Zdd� Zdd� Zdd� ZdZdd� Zdd� Z dd � Z d d � Z �dNd d �Z d!d"� Z d#d$� Z!d%d&� Z"d'd(� Z#d)d*� Z$d+d,� Z%d-d.� Z&�dOd/d0�Z'e(�)d1e(�*e+� d2 �Z,d3d4� Z-d5d6� Z.d7d8� Z/d9d:� Z0d;d<� Z1d=d>� Z2d?d@� Z3dAdB� Z4dCdD� Z5dEdF� Z6dGdH� Z7dIdJ� Z8�dPdLdM�Z9�dPdNdO�Z:�dPdPdQ�Z;�dNdRdS�Z<�dQdUdV�Z=dWdX� Z>dYdZ� Z?d[d\� Z@e@fZAeAZBeAZCeAZDd]d^� ZEeEfZFeFZGeFZHeFZId_d`� ZJeJfZKeKZLeKZMeKZNdadb� ZOeOe-fZPdcdd� ZQdedf� ZRdgdh� ZSdidj� ZTdkdl� ZUdmdn� ZVdodp� ZWeWfZXdqdr� ZYeYe'e&fZZdsdt� Z[dudv� Z\dwdx� Z]dydz� Z^e^fZ_e_Z`d{d|� Zad}d~� Zbdd�� Zceae'd�d�fZdedZeeae'd�d�fZfefZgd�d�� Zhd�d�� ZiehfZjejZkd�d�� Zlele&fZmemZnd�d�� Zoeoe&fZpepZqd�d�� Zrere'e&fZsesZtd�d�� Zueue&fZvevZwd�d�� Zxexe&fZyeyZzd�d�� Z{d�d�� Z|d�d�� Z}e{e'e'd�d�fZ~e~Ze{e'e'd�d�fZ�e�Z�d�d�� Z�d�d�� Z�d�d�� Z�e�e'e.fZ�e�Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�e�e'e5e6e/fZ�e�Z�d�d�� Z�d�d�� Z�d�d�� Z�e�fZ�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�e�fZ�d�d�� Z�d�d�� Z�d�d�� Z�e�fZ�d�d�� Z�d�d Z��dRd�dĄZ�e�e7e0fZ�d�dƄ Z��dNd�dȄZ�d�dʄ Z�d�d̄ Z�d�d΄ Z�d�dЄ Z�d�d҄ Z�d�dԄ Z�d�dք Z�d�d Z�d�dڄ Z�d�d܄ Z�d�dބ Z�d�d� Z�d�d� Z�d�d� Z�d�d� Z�d�d� Z�d�d� Z�d�d� Z�d�d� Z�d�d� Z�d�d� Z�d�d� Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�d�d�� Z�d��d � Z��d�d� Z��d�d� Z��d�d� Z��d�d� Z��d �d � Z��d �d � Zd �d� ZÐd�d� ZĐd�d� ZŐd�d� ZƐdR�d�d�Z�e�e1e2fZȐd�d� Zɐd�d� ZʐdS�d�d �ZːdS�d �d �Z̐dS�d �d �Z͐dS�d!�d"�ZΐdS�d#�d$�ZϐdS�d%�d&�ZАdS�d'�d(�ZѐdS�d)�d*�ZҐdS�d+�d,�ZӐdS�d-�d.�ZԐd/�d0� ZՐd1�d2� ZdR�d3�d4�Z�e�e1e-e3fZؐd5�d6� Zِd7�d8� ZڐdR�d9�d:�Z�e�e1e&fZܐd;�d<� Zݐd=�d>� Zސd?�d@� ZߐdA�dB� Z�dC�dD� Z�dE�dF� Z�e�e-e4fZ�dG�dH� Z�dI�dJ� Z�dK�dL� Z�dS (T � IMAP4Serverz� Protocol implementation for an IMAP4rev1 server. The server can be in any of four states: - Non-authenticated - Authenticated - Selected - Logout s Twisted IMAP4rev1 Ready�< i FNi > � OR� NOT� UID�unauthr� c C s4 |d u ri }|| _ || _|d u rt}|| _g | _d S rm )� challengers�ctx�iterateInReactor� _scheduler� _queuedAsync)rZ �chal�contextFactory� schedulerr= r= rA r] � s zIMAP4Server.__init__c C sZ dt | j�� �i}| jr#| jr#| js#t�| jd �d u r#d |d< d |d< d |d< d |d< |S )N� AUTH� LOGINDISABLED� STARTTLSr� s IDLE) rV r� �keysr� � canStartTLS� startedTLSr � ISSLTransportr� )rZ �capr= r= rA � capabilities� s �zIMAP4Server.capabilitiesc C s2 i | _ t�| jd �d u| _| �| j� | �� d S rm )�tagsr � ITLSTransportr� r � setTimeout�timeOut�sendServerGreetingr^ r= r= rA �connectionMade� s zIMAP4Server.connectionMadec C s& | � d � | jr| �� d | _d S d S rm )r � _onLogout)rZ �reasonr= r= rA �connectionLost� s �zIMAP4Server.connectionLostc C s\ | � d� | j�� | jr)| j�| � t| jd �}|d ur&t|j��t j � d | _d| _ d S )Ns* * BYE Autologout; connection idle too long�timeout) �sendLiner� �loseConnection�mbox�removeListener�ICloseableMailboxr �close� addErrbackr4 �err�state)rZ �cmbxr= r= rA �timeoutConnection� s z IMAP4Server.timeoutConnectionc C s. | � � | j�|�}|d ur| �|� d S d S rm )� resetTimeout�_pendingLiteralr� � setLineModer� r= r= rA �rawDataReceived� s �zIMAP4Server.rawDataReceivedc C sV | j }d | _ |r | j d u r | �|�d�� |r | j d u s | j d ur)| j �|� d S d S r� )�blocked� lineReceived�poprr )rZ �commandsr= r= rA �_unblock� s � �zIMAP4Server._unblockc C s� | j d ur | j �|� d S | �� t| d| j �}z||� W d S tyB } z| �dtt|�� � t � � W Y d }~d S d }~ww )N�parse_s BAD Server error: ) r# rl r �getattr� parseState� Exception�sendUntaggedResponser: r� r4 r )rZ r� �f�er= r= rA r$ � s ��zIMAP4Server.lineReceivedc C sB |� d d�}d }t|�dkr|\}}}n%t|�dkr |\}}nt|�dkr1|d }| �|d� d S | �d d� d S |�� }z| �|||�W S tyd } z| �|dtt|�� � W Y d }~d S d }~w ty� } z| � |dtt|�� � W Y d }~d S d }~w t y� } z| � |d tt|�� � W Y d }~d S d }~ww ) Nr� � r; r s Missing commands Null command� Illegal syntax: � Illegal operation: � Illegal mailbox name: ) �splitr� �sendBadResponse�upper�dispatchCommandr r: r� r �sendNegativeResponser )rZ r� r� �restr� �cmdr. r= r= rA � parse_command� s: &������zIMAP4Server.parse_commandc C s | j }d | _ d| _|�|� d S )Nr� )r r* r� )rZ r� r� r= r= rA � parse_pending� s zIMAP4Server.parse_pendingc C sN | � |�}|r |d }|dd � }| �||| |g|||� d S | �|d� d S )Nr r; s Unsupported command)� lookupCommand�_IMAP4Server__doCommandr4 )rZ r� r9 r8 �uidr- �fn� parseargsr= r= rA r6 s zIMAP4Server.dispatchCommandc C s t | d�| jt|�� �f�d �S )N�_)r) r� r r9 r5 )rZ r9 r= r= rA r< s zIMAP4Server.lookupCommandc C s� t |�D ],\}}t|�r+||d d � }t|| |��| j|||||��| j|� d S |�|� q|r;tdt |� ��|d urH||d|i� d S ||� d S )Nr; z Too many arguments for command: r> ) ra �callabler � addCallback�_IMAP4Server__cbDispatchr �_IMAP4Server__ebDispatchrl r �repr) rZ r� �handlerr� r@ r� r> rc �argr= r= rA � __doCommand s � zIMAP4Server.__doCommandc C s* |\}}|� |� | �||||||� d S rm )rl r= ) rZ �resultr� r? r� r@ r> rH r8 r= r= rA � __cbDispatch s zIMAP4Server.__cbDispatchc C s� |� t�r| �|dtt|j�� � d S |� t�r(| �|dtt|j�� � d S |� t�r<| �|dtt|j�� � d S | �|dtt|j�� � t � |� d S )Nr0 r1 r2 � Server error: ) �checkr r4 r: r� rb r r7 r r4 r �rZ �failurer� r= r= rA � __ebDispatch% s � � ��zIMAP4Server.__ebDispatchc C sR || j kr td| j f ��t�� }d| _t||�| _| �td| �� | � � |S )Nz,Literal too long! I accept at most %d octets�pendingzReady for %d octets of text) �_literalStringLimitr r �Deferredr* r� r �sendContinuationRequestr: � setRawMode�rZ r� r� r= r= rA �_stringLiteral8 s �� �zIMAP4Server._stringLiteralc C s8 t �� }d| _t||�| _| �td| �� | �� |S )NrQ zReady for %d octets of data)r rS r* r� r rT r: rU rV r= r= rA � _fileLiteralG s �zIMAP4Server._fileLiteralc C s | j |dd�S )a Parse an astring from line that represents a command's final argument. This special case exists to enable parsing empty string literals. @param line: A line that contains a string literal. @type line: L{bytes} @return: A 2-tuple containing the parsed argument and any trailing data, or a L{Deferred} that fires with that 2-tuple @rtype: L{tuple} of (L{bytes}, L{bytes}) or a L{Deferred} @see: https://twistedmatrix.com/trac/ticket/9207 T)�final)� arg_astringr� r= r= rA �arg_finalastringQ s z IMAP4Server.arg_finalastringc C s |� � }|s td��d}d\}}|dd� dkr5z|�dd�\}}}|dd� }W n^ ty4 td��w |dd� d krs|d d� d krItd ��z t|dd � �}W n tyf td t|dd � � ��w |rm|smdS | �|�}n|�dd�}t|�dkr�|�d� |\}}|p�||fS )a� Parse an astring from the line, return (arg, rest), possibly via a deferred (to handle literals) @param line: A line that contains a string literal. @type line: L{bytes} @param final: Is this the final argument? @type final L{bool} @return: A 2-tuple containing the parsed argument and any trailing data, or a L{Deferred} that fires with that 2-tuple @rtype: L{tuple} of (L{bytes}, L{bytes}) or a L{Deferred} �Missing argumentN�NNr r; � "r� zUnmatched quotes� {rt � }�Malformed literal�Bad literal size: )r� r� r� r� ) �stripr r3 r` �intrF rW r� rl )rZ r� rY r� rH r8 �spamr� r= r= rA rZ c s8 � � zIMAP4Server.arg_astrings (?P<atom>[s ]+)( (?P<rest>.*$)|$)c C s8 |st d��| j�|�}|r|�d�|�d�fS t d��)z- Parse an atom from the line r\ �atomr8 zMalformed ATOM)r �atomre�match�group)rZ r� �mr= r= rA �arg_atom� s zIMAP4Server.arg_atomc C s` |st d��|dd� dkrt d��|�d�}|dkr t d��t|d|� d �||d d� fS ) zG Parse a (non-nested) parenthesised list from the line r\ Nr; � (zMissing parenthesis� )rt �Mismatched parenthesisr r� )r �findr� )rZ r� rc r= r= rA � arg_plist� s "zIMAP4Server.arg_plistc C s� |st d��|dd� dkrt d��|dd� dkr t d��z t|dd� �}W n ty: t d |dd� ����w | �|�S ) z/ Parse a literal from the line r\ Nr; r_ zMissing literalrt r` ra rb )r rd r` rX )rZ r� r� r= r= rA � arg_literal� s � zIMAP4Server.arg_literalc C s t |�}|dfS )z searchkeys r� )r� )rZ r� �queryr= r= rA �arg_searchkeys� s zIMAP4Server.arg_searchkeysc C sd d}|� dd�}t|�dkr|d }|d }zt|�|fW S ty1 } ztdt|� ��d}~ww )z sequence-set r� r� r; r� r zBad message number N)r3 r� � parseIdListr r r� )rZ r� r8 rH r. r= r= rA � arg_seqset� s ��zIMAP4Server.arg_seqsetc C s t � }|�|� |jdfS )z fetch-att r� )� _FetchParser� parseStringrJ )rZ r� r� r= r= rA � arg_fetchatt� s zIMAP4Server.arg_fetchattc C s� g }|dd� dkr |dd� dkrt d��|dd� }|r]| j�|�}|s*t d��|dd� d krC|�� dkrC|�d |�d � � n|�� dkrR|�|�d �� nt d��|�d �}|s |d fS ) z- Flag part of store-att-flag r r; rl rt Nrm rn zMalformed flag� \rf r8 r� )r rg �searchr[ rl ri )rZ r� �flagsrj r= r= rA � arg_flaglist� s" � zIMAP4Server.arg_flaglistc C s |dfS )z- Command line of UID command r� r= r� r= r= rA �arg_line� s zIMAP4Server.arg_linec C s |� d�r | �|�S d|fS )z- Optional parenthesised list rl N)� startswithrp r� r= r= rA � opt_plist s zIMAP4Server.opt_plistc C sP |� d�r$z |�dd�\}}}W n ty td��w ||dd� fS d|fS )z+ Optional date-time string r^ r� zMalformed date-timer; N)r~ r3 r` r )rZ r� re �dater8 r= r= rA � opt_datetime s �zIMAP4Server.opt_datetimec C sd |dd� � � dkr.|�dd�}t|�dkrtd��t|�dkr%|�d� |\}}}||fS d|fS ) z4 Optional charset of SEARCH command N� s CHARSETr� r� r; zMissing charset identifierr� )r5 r3 r� r rl )rZ r� rH re r8 r= r= rA � opt_charset s zIMAP4Server.opt_charsetc C s, dd� | �� � d | j }| j|d� d S )Ns [CAPABILITY r� � ] )�message)r� �listCapabilities�IDENT�sendPositiveResponse�rZ �msgr= r= rA r * s z IMAP4Server.sendServerGreetingr� c C � | � d||� d S )N� BAD��_respond�rZ r� r� r= r= rA r4 . � zIMAP4Server.sendBadResponsec C r� )Nr� r� r� r= r= rA r� 1 r� z IMAP4Server.sendPositiveResponsec C r� )N� NOr� r� r= r= rA r7 4 r� z IMAP4Server.sendNegativeResponsec K s@ t |fi |��}|r| jd u r| �|d d � d S | j�|� d S rm )r6 r# r� r� rl )rZ r� �isAsync�kwargsr= r= rA r, 7 s z IMAP4Server.sendUntaggedResponse�! Ready for additional command textc C s$ |r | � d| � d S | � d� d S )Ns + � +�r r� r= r= rA rT > s z#IMAP4Server.sendContinuationRequestc C sp |dv r| j r| j }g | _ |D ] }| �|d d � q|s d}|r,| �d�|||f�� d S | �d�||f�� d S )N)r� r� r� � *r� )r� r� r r� )rZ r r� r� r� r� r= r= rA r� D s zIMAP4Server._respondc sT dg}| � � �� D ] \� }|d u r|�� � q t|�r'|�� fdd�|D �� q |S )Ns IMAP4rev1c s g | ]}� d | �qS )� =r= )rC r ��cr= rA rG W � z0IMAP4Server.listCapabilities.<locals>.<listcomp>)r �itemsrl r� rr )rZ �caps�vr= r� rA r� Q s �z IMAP4Server.listCapabilitiesc C s( | � dd�| �� � � | �|d� d S )Ns CAPABILITY r� s CAPABILITY completed)r, r� r� r� r� r= r= rA � do_CAPABILITYZ s zIMAP4Server.do_CAPABILITYc C s$ | � d� | �|d� | j�� d S )Ns BYE Nice talking to yous LOGOUT successful)r, r� r� r r� r= r= rA � do_LOGOUTc s zIMAP4Server.do_LOGOUTc C s | � |d� d S )Ns NOOP No operation performed�r� r� r= r= rA �do_NOOPm r� zIMAP4Server.do_NOOPc C s> |� � �� }|| jvr| �|d� d S | �| j| � |� d S )Ns AUTHENTICATE method unsupported)r5 rc r� r7 � authenticate)rZ r� r� r= r= rA �do_AUTHENTICATEu s zIMAP4Server.do_AUTHENTICATEc C s* | j d u r | �|d� d S | �||� d S )Ns Temporary authentication failure)�portalr7 �_setupChallenge)rZ r� r� r= r= rA r� ~ s zIMAP4Server.authenticatec C s� z|� � }W n ty% } z| �|dtt|�� � W Y d }~d S d }~ww t|�d d� }d| _t�� | _ | � |� | j � | j ||� | j � | j|� d S )NrL rt rQ )� getChallenger+ r4 r: r� r r* r rS r rT rC �_IMAP4Server__cbAuthChunkr �_IMAP4Server__ebAuthChunk)rZ r� r� � challenger. �codedr= r= rA r� � s &�� zIMAP4Server._setupChallengec C st zt |�}W n tjy td��w |�|� |�� r$| �||� d S | j�|d t �� | j | j |fd |fd � d S )Nz Malformed Response - not base64) r �binascii�Errorr � setResponse�moreChallengesr� r� �login�IAccount� addCallbacks�_IMAP4Server__cbAuthResp�_IMAP4Server__ebAuthResp)rZ rJ r� r� �uncodedr= r= rA � __cbAuthChunk� s � �zIMAP4Server.__cbAuthChunkc C sH |\}}}|t u s J d��|| _d| _|| _| �|d� | �| j� d S )Nz(IAccount is the only supported interface�auths Authentication successful)r� �accountr r r� r �POSTAUTH_TIMEOUT�rZ rJ r� �iface�avatar�logoutr= r= rA � __cbAuthResp� s zIMAP4Server.__cbAuthRespc C sN |� t�r | �|d� d S |� t�r| �|d� d S | �|d� t�|� d S )Ns# Authentication failed: unauthorizeds+ Authentication failed: server misconfigureds' Server error: login failed unexpectedly)rM r r7 r r4 r4 r rN r= r= rA � __ebAuthResp� s � zIMAP4Server.__ebAuthRespc C � | � |dtt|j�� � d S )Ns Authentication failed: )r7 r: r� rb rN r= r= rA � __ebAuthChunk� � �zIMAP4Server.__ebAuthChunkc C s� | j r | �|d� d S | jr?| jr?| �|d� | j�| j� d| _ | j�� | _d| jvr1t | jd< d| jvr=t | jd< d S d S | �|d� d S )Ns TLS already negotiateds Begin TLS negotiation nowT� LOGINs PLAINs TLS not available) r r7 r� r r� r� �startTLSr� �copyr r r� r= r= rA � do_STARTTLS� s �zIMAP4Server.do_STARTTLSc C sB d| � � v r| �|d� d S t| j||��| j|��| j|� d S )Nr s! LOGIN is disabled before STARTTLS)r r4 r �authenticateLoginrC �_IMAP4Server__cbLoginr �_IMAP4Server__ebLogin)rZ r� �user�passwdr= r= rA �do_LOGIN� s �zIMAP4Server.do_LOGINc C s$ | j r| j �t�||�dt�S t� �)a� Lookup the account associated with the given parameters Override this method to define the desired authentication behavior. The default behavior is to defer authentication to C{self.portal} if it is not None, or to deny the login otherwise. @type user: L{str} @param user: The username to lookup @type passwd: L{str} @param passwd: The password to login with N)r� r� r �UsernamePasswordr� r )rZ r� r� r= r= rA r� � s �z IMAP4Server.authenticateLoginc C sb |\}}}|t ur| �|d� t�d|�d�� d S || _|| _| �|d� d| _| �| j � d S )Ns- Server error: login returned unexpected valuez__cbLogin called with z, IAccount expecteds LOGIN succeededr� ) r� r4 r4 r r� r r� r r r� r� r= r= rA � __cbLogin� s zIMAP4Server.__cbLoginc C sB |� t�r | �|d� d S | �|dtt|j�� � t�|� d S )Ns LOGIN failedrL ) rM r r7 r4 r: r� rb r4 r rN r= r= rA � __ebLogin� s �zIMAP4Server.__ebLoginc C s` d } }}t | jd �}|d ur |�� }|�� }|�� }| �dt|||g� � | �|d� d S )Ns NAMESPACE s NAMESPACE command completed)r0 r� �getPersonalNamespaces�getSharedNamespacesr, �collapseNestedListsr� )rZ r� �personal�public�shared�npr= r= rA � do_NAMESPACE� s �zIMAP4Server.do_NAMESPACEc C s| | j r"| j �| � t| j d �}|d ur t|j��tj� d | _ d| _t |�}t| j j t |�|�� | j ||��| j||� d S )Nr� )r r r r r r r4 r r � _parseMboxr� �selectrC � _cbSelectWork� _ebSelectWork)rZ r� �name�rw�cmdNamer r= r= rA � _selectWork s �zIMAP4Server._selectWorkc C s | � ||d � t�|� d S )Ns failed: Server error�r4 r4 r )rZ rO r� r� r= r= rA r� s zIMAP4Server._ebSelectWorkc C s� |d u r | � |d� d S ddd� |�� D �v r | � |d� d S dd� |�� D �}| �d|�� f � | �d|�� f � | �d d �|� d � | �d d |�� f � |�� rYd pZd}|� | � | �|d| d | d � d| _ || _ d S )Ns No such mailboxz \noselectc S � g | ]}|� � �qS r= )�lower�rC r� r= r= rA rG $ � z-IMAP4Server._cbSelectWork.<locals>.<listcomp>zMailbox cannot be selectedc S � g | ]}t |��qS r= �r: �rC �flagr= r= rA rG ( r� � %d EXISTS� %d RECENT� FLAGS (r� rm s [UIDVALIDITY %d]r� r� � [r� s successfulr� ) r7 �getFlagsr, �getMessageCount�getRecentCountr� r� �getUIDValidity� isWriteable� addListenerr r )rZ r r� r� r{ r� r= r= rA r� s zIMAP4Server._cbSelectWorkr; � SELECTr � EXAMINEc C s" | � d � || _| j| _d| _d S )N�idle)rT �parseTagr* � lastStater� r= r= rA �do_IDLE: s zIMAP4Server.do_IDLEc G s" | j | _| ` | �| jd� | `d S )Ns IDLE terminated)r� r* r� r� )rZ r� r= r= rA � parse_idle@ s zIMAP4Server.parse_idlec C s� t |�}z| j�|�}W n0 ty) } z| �|tt|��� W Y d }~d S d }~w ty< | �|d� t � � Y d S w |rG| � |d� d S | �|d� d S )Ns/ Server error encountered while creating mailboxs Mailbox createds Mailbox not created) r� r� �creater r7 r: r� � BaseExceptionr4 r4 r r� )rZ r� r� rJ r� r= r= rA � do_CREATEI s "� ��zIMAP4Server.do_CREATEc C s� t |�}|�� dkr| �|d� d S z| j�|� W n1 ty8 } z| �|t|��d�� W Y d }~d S d }~w tyK | � |d� t � � Y d S w | � |d� d S )N�inboxs You cannot delete the inbox� imap4-utf-7s/ Server error encountered while deleting mailboxs Mailbox deleted) r� r� r7 r� �deleter r� �encoder� r4 r4 r r� �rZ r� r� rj r= r= rA � do_DELETE] s $� ��zIMAP4Server.do_DELETEc C s� dd� ||fD �\}}|� � dks|� � dkr | �|d� d S z | j�||� W n? ty8 | �|d� Y d S tyT } z| �|tt|��� W Y d }~d S d }~w t yg | �|d� t � � Y d S w | � |d� d S )Nc s � � | ]}t |�V qd S rm )r� )rC �nr= r= rA r� r � � z(IMAP4Server.do_RENAME.<locals>.<genexpr>r� s@ You cannot rename the inbox, or rename another mailbox to inbox.s Invalid command syntaxs/ Server error encountered while renaming mailboxs Mailbox renamed) r� r7 r� �renamern r4 r r: r� r� r4 r r� )rZ r� �oldname�newnamerj r= r= rA � do_RENAMEq s( � "� ��zIMAP4Server.do_RENAMEc C � t |�}z| j�|� W n0 ty) } z| �|tt|��� W Y d }~d S d }~w ty< | �|d� t � � Y d S w | � |d� d S )Ns5 Server error encountered while subscribing to mailboxs Subscribed) r� r� � subscriber r7 r: r� r� r4 r4 r r� r r= r= rA � do_SUBSCRIBE� � "� ��zIMAP4Server.do_SUBSCRIBEc C r )Ns9 Server error encountered while unsubscribing from mailboxs Unsubscribed) r� r� � unsubscriber r7 r: r� r� r4 r4 r r� r r= r= rA �do_UNSUBSCRIBE� r zIMAP4Server.do_UNSUBSCRIBEc C s< t |�}t |�}t| jj||��| j|||��| j|� d S rm )r� r r� � listMailboxesrC � _cbListWorkr � _ebListWork)rZ r� �refr �subr� r= r= rA � _listWork� s �zIMAP4Server._listWorkc C s| |D ]1\}}|r| j �|�r3dd� |�� D �}|�� �d�}t|�tt|�||�d�f} | �t| �� q| � ||d � d S )Nc S r� r= r� r� r= r= rA rG � r� z+IMAP4Server._cbListWork.<locals>.<listcomp>r� s completed) r� � isSubscribedr� �getHierarchicalDelimiterr � DontQuoteMe�mapr, r� r� ) rZ � mailboxesr� r r� r� �boxr{ �delim�respr= r= rA r � s ��zIMAP4Server._cbListWorkc C � | � |d� t�|� d S )Ns1 Server error encountered while listing mailboxes.r� rN r= r= rA r � � zIMAP4Server._ebListWorkr� r� c C sP g }|D ] }|� t|�� qt|�}t| jj|d��| j|||��| j |� d S r� ) rl r9 r� r r� r� rC �_cbStatusGotMailboxr �_ebStatusGotMailbox)rZ r� �mailboxr� � nativeNamesr� r= r= rA � do_STATUS� s �zIMAP4Server.do_STATUSc C s@ |rt |j|��| j| j||fd ||fd � d S | �|d� d S )Ns Could not open mailbox)r � requestStatusr� �_IMAP4Server__cbStatus�_IMAP4Server__ebStatusr7 )rZ r r� r" r� r= r= rA r � s � z IMAP4Server._cbStatusGotMailboxc C r �Ns/ Server error encountered while opening mailbox.r� rN r= r= rA r! � r z IMAP4Server._ebStatusGotMailboxc C sL t d�dd� |�� D ���}| �d|�d� d | d � | �|d� d S ) N� c S s g | ]}d | �qS )z%s %sr= �rC rO r= r= rA rG � r� z*IMAP4Server.__cbStatus.<locals>.<listcomp>� STATUS r� � (rm s STATUS complete)r: r� r� r, r r� )rZ �statusr� r r� r= r= rA � __cbStatus� s �zIMAP4Server.__cbStatusc C s& | � |d| d tt|j�� � d S )Nr+ s failed: �r4 r: r� rb )rZ rO r� r r= r= rA � __ebStatus� s �zIMAP4Server.__ebStatusc C s4 t |�}t| jj|��| j||||��| j|� d S rm )r� r r� r� rC �_cbAppendGotMailboxr �_ebAppendGotMailbox)rZ r� r" r{ r� r� r= r= rA � do_APPEND� � �zIMAP4Server.do_APPENDc C sR |s | � |d� d S dd� |D �}|�|||�}|�| j||� |�| j|� d S )Nz[TRYCREATE] No such mailboxc S r� r= �r9 r� r= r= rA rG r� z3IMAP4Server._cbAppendGotMailbox.<locals>.<listcomp>)r7 � addMessagerC �_IMAP4Server__cbAppendr �_IMAP4Server__ebAppend)rZ r r� r{ r� r� � decodedFlagsr� r= r= rA r1 � s z IMAP4Server._cbAppendGotMailboxc C r r( r� rN r= r= rA r2 r z IMAP4Server._ebAppendGotMailboxc C s$ | � d|�� f � | �|d� d S )Nr� s APPEND complete)r, r� r� )rZ rJ r� r r= r= rA � __cbAppend s zIMAP4Server.__cbAppendc C r� )Ns APPEND failed: r/ rN r= r= rA � __ebAppend r� zIMAP4Server.__ebAppendc C s> | � � }|d u r| �d |� d S |j| j| j|f|fd� d S )N)� callbackArgs� errbackArgs)� checkpoint�_IMAP4Server__cbCheckr� �_IMAP4Server__ebCheck�rZ r� r� r= r= rA �do_CHECK s �zIMAP4Server.do_CHECKc C s | � |d� d S )Ns CHECK completedr� �rZ rJ r� r= r= rA � __cbCheck! r� zIMAP4Server.__cbCheckc C r� )Ns CHECK failed: r/ rN r= r= rA � __ebCheck$ � zIMAP4Server.__ebCheckc C � dS )ah Called when the client issues a CHECK command. This should perform any checkpoint operations required by the server. It may be a long running operation, but may not block. If it returns a deferred, the client will only be informed of success (or failure) when the deferred's callback (or errback) is invoked. Nr= r^ r= r= rA r> ' s zIMAP4Server.checkpointc s� d }| j �� r t| j j�}t| j d �� � d ur*|d ur%|�� fdd�� nt� j�}|d ur>|�| j| j |fd |fd � d S | �d |� d S )Nc � � � � S rm )r )rJ �r r= rA rP 9 rQ z&IMAP4Server.do_CLOSE.<locals>.<lambda>) r r� r �expunger rC r r� �_IMAP4Server__cbClose�_IMAP4Server__ebCloserA r= rI rA �do_CLOSE2 s zIMAP4Server.do_CLOSEc C s( | � |d� | j�| � d | _d| _d S )Ns CLOSE completedr� )r� r r r rC r= r= rA � __cbCloseC s zIMAP4Server.__cbClosec C r� )Ns CLOSE failed: r/ rN r= r= rA � __ebCloseI rF zIMAP4Server.__ebClosec C sB | j �� rt| j j��| j| j|fd |fd � d S | �|d� d S )Ns$ EXPUNGE ignored on read-only mailbox)r r� r rJ r� �_IMAP4Server__cbExpunge�_IMAP4Server__ebExpunger7 r� r= r= rA � do_EXPUNGEL s �zIMAP4Server.do_EXPUNGEc C s* |D ] }| � d|f � q| �|d� d S )Ns %d EXPUNGEs EXPUNGE completed)r, r� )rZ rJ r� r. r= r= rA � __cbExpungeV s zIMAP4Server.__cbExpungec C �( | � |dtt|j�� � t�|� d S )Ns EXPUNGE failed: �r4 r: r� rb r4 r rN r= r= rA � __ebExpunge[ � �zIMAP4Server.__ebExpungec C s| t | jd �}|d ur!t|j||d��| j|| j|��| j|� d S td�}t| jj ||d��| j || j||��| j|� d S )N�r> s 1:*) �ISearchableMailboxr r rz rC �_IMAP4Server__cbSearchr �_IMAP4Server__ebSearchrt �fetch� _IMAP4Server__cbManualSearch)rZ r� �charsetrr r> �smr� r= r= rA � do_SEARCHa s ��zIMAP4Server.do_SEARCHc C sF |rt |j|�}td�dd� |D ���}| �d| � | �|d� d S )Nr) c S r� r= r� �rC rc r= r= rA rG t r� z*IMAP4Server.__cbSearch.<locals>.<listcomp>� SEARCH � SEARCH completed)r �getUIDr: r� r, r� )rZ rJ r� r r> �idsr= r= rA � __cbSearchq s zIMAP4Server.__cbSearchc C s� |du rg }d}|o|d d }|o|d d � � } tttd�|��D ] \}\} } | �t�|�| | || �rC|�d|r>| � � n| f � q#|dkrcddlm } | � d| j t|dd� �|||||� dS |ro| � d d � |� � | �|d � dS ) aL Apply the search filter to a set of messages. Send the response to the client. @type result: L{list} of L{tuple} of (L{int}, provider of L{imap4.IMessage}) @param result: A list two tuples of messages with their sequence ids, sorted by the ids in descending order. @type tag: L{str} @param tag: A command tag. @type mbox: Provider of L{imap4.IMailbox} @param mbox: The searched mailbox. @type query: L{list} @param query: A list representing the parsed form of the search query. @param uid: A flag indicating whether the search is over message sequence numbers or UIDs. @type searchResults: L{list} @param searchResults: The search results so far or L{None} if no results yet. Nr rt r; � s %d� ��reactorrb r� rc )rd rV �zip�range� _searchFilterr� �deepcopyrl �twisted.internetrj � callLaterr] r, r� r� ) rZ rJ r� r rr r> � searchResultsrc �lastSequenceId� lastMessageId�msgIdr� rj r= r= rA �__cbManualSearchx s4 � � � z IMAP4Server.__cbManualSearchc C s" |r| � |||||�s dS |sdS )a� Pop search terms from the beginning of C{query} until there are none left and apply them to the given message. @param query: A list representing the parsed form of the search query. @param id: The sequence number of the message being checked. @param msg: The message being checked. @type lastSequenceId: L{int} @param lastSequenceId: The highest sequence number of any message in the mailbox being searched. @type lastMessageId: L{int} @param lastMessageId: The highest UID of any message in the mailbox being searched. @return: Boolean indicating whether all of the query terms match the message. FT��_singleSearchStep)rZ rr �idr� rr rs r= r= rA rm � s ��zIMAP4Server._searchFilterc C s� |� d�}t|t�r| �|||||�sdS dS |�� }|dd� �� s,t||�}||v S t| dt|� d�} | du rBt dt|� ��|| j v rQ| |||||f�} n| |||�} | s[dS dS )a� Pop one search term from the beginning of C{query} (possibly more than one element) and return whether it matches the given message. @param query: A list representing the parsed form of the search query. @param msgId: The sequence number of the message being checked. @param msg: The message being checked. @param lastSequenceId: The highest sequence number of any message in the mailbox being searched. @param lastMessageId: The highest UID of any message in the mailbox being searched. @return: Boolean indicating whether the query term matched the message. r FNr; �search_zInvalid search command %sT) r% rU rV rm r5 �isalphart r) r9 r �_requiresLastMessageInfo) rZ rr rt r� rr rs �qr� � messageSetr- rJ r= r= rA rw � s( � � z IMAP4Server._singleSearchStepc C rG )aS Returns C{True} if the message matches the ALL search key (always). @type query: A L{list} of L{str} @param query: A list representing the parsed query string. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} Tr= �rZ rr rx r� r= r= rA � search_ALL s zIMAP4Server.search_ALLc C � d|� � v S )aA Returns C{True} if the message has been answered. @type query: A L{list} of L{str} @param query: A list representing the parsed query string. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} � \Answered�r� r~ r= r= rA �search_ANSWERED s zIMAP4Server.search_ANSWEREDc C �0 |� dd��dd�}|�� �|�d��� �dkS )aR Returns C{True} if the message has a BCC address matching the query. @type query: A L{list} of L{str} @param query: A list whose first element is a BCC L{str} @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} F�bcc� r rt �� getHeaders�getr� ro r% )rZ rr rx r� r� r= r= rA � search_BCC s zIMAP4Server.search_BCCc C s& t |�d��}tj�t|�� ��|k S r� )� parseTimer% �email�utils� parsedater9 �getInternalDate�rZ rr rx r� r� r= r= rA � search_BEFORE, s zIMAP4Server.search_BEFOREc C � |� d��� }t�||�� d�S �Nr F�r% r� r5 �strFile� getBodyFile�rZ rr rx r� �bodyr= r= rA � search_BODY0 s zIMAP4Server.search_BODYc C r� )NF�ccr� r rt r� )rZ rr rx r� r� r= r= rA � search_CC4 � zIMAP4Server.search_CCc C r� �Nz\Deletedr� r~ r= r= rA �search_DELETED8 � zIMAP4Server.search_DELETEDc C r� �Nz\Draftr� r~ r= r= rA � search_DRAFT; r� zIMAP4Server.search_DRAFTc C r� �Nz\Flaggedr� r~ r= r= rA �search_FLAGGED> r� zIMAP4Server.search_FLAGGEDc C r� )NF�fromr� r rt r� )rZ rr rx r� �fmr= r= rA � search_FROMA r� zIMAP4Server.search_FROMc C s> |� d��� }|�d|��|d�}|�� �|� d��� �dkS )Nr Fr� rt )r% r� r� r� ro )rZ rr rx r� �hdrr= r= rA � search_HEADERE s zIMAP4Server.search_HEADERc C � |� d� dS r� �r% r~ r= r= rA �search_KEYWORDJ � zIMAP4Server.search_KEYWORDc C s t |�d��|�� k S r� �rd r% �getSizer~ r= r= rA � search_LARGERN � zIMAP4Server.search_LARGERc C s d|� � v o d|� � vS )N�\Recent�\Seenr� r~ r= r= rA � search_NEWQ s zIMAP4Server.search_NEWc C s |\}}| � |||||� S )a� Returns C{True} if the message does not match the query. @type query: A L{list} of L{str} @param query: A list representing the parsed form of the search query. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} @param msg: The message being checked. @type lastIDs: L{tuple} @param lastIDs: A tuple of (last sequence id, last message id). The I{last sequence id} is an L{int} containing the highest sequence number of a message in the mailbox. The I{last message id} is an L{int} containing the highest UID of a message in the mailbox. rv )rZ rr rx r� �lastIDsrr rs r= r= rA � search_NOTT s zIMAP4Server.search_NOTc C � d|� � vS �Nr� r� r~ r= r= rA � search_OLDj r� zIMAP4Server.search_OLDc C s" t |�d��}tj�|�� �|kS r� �r� r% r� r� r� r� r� r= r= rA � search_ONm � zIMAP4Server.search_ONc C s4 |\}}| � |||||�}| � |||||�}|p|S )a� Returns C{True} if the message matches any of the first two query items. @type query: A L{list} of L{str} @param query: A list representing the parsed form of the search query. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} @param msg: The message being checked. @type lastIDs: L{tuple} @param lastIDs: A tuple of (last sequence id, last message id). The I{last sequence id} is an L{int} containing the highest sequence number of a message in the mailbox. The I{last message id} is an L{int} containing the highest UID of a message in the mailbox. rv ) rZ rr rx r� r� rr rs �a�br= r= rA � search_ORq s zIMAP4Server.search_ORc C r� r� r� r~ r= r= rA � search_RECENT� r� zIMAP4Server.search_RECENTc C r� �Nr� r� r~ r= r= rA � search_SEEN� r� zIMAP4Server.search_SEENc C s2 |� dd��dd�}tj�|�}|t|�d��k S )a� Returns C{True} if the message date is earlier than the query date. @type query: A L{list} of L{str} @param query: A list whose first element starts with a stringified date that is a fragment of an L{imap4.Query()}. The date must be in the format 'DD-Mon-YYYY', for example '03-March-2003' or '03-Mar-2003'. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} Fr� r� r �r� r� r� r� r� r� r% r� r= r= rA �search_SENTBEFORE� s z IMAP4Server.search_SENTBEFOREc C sB |� dd��dd�}tj�|�}|dd� t|�d��dd� kS )a� Returns C{True} if the message date is the same as the query date. @type query: A L{list} of L{str} @param query: A list whose first element starts with a stringified date that is a fragment of an L{imap4.Query()}. The date must be in the format 'DD-Mon-YYYY', for example '03-March-2003' or '03-Mar-2003'. @type msg: Provider of L{imap4.IMessage} Fr� r� Nr/ r r� r� r= r= rA � search_SENTON� s "zIMAP4Server.search_SENTONc C s2 |� dd��dd�}tj�|�}|t|�d��kS )a� Returns C{True} if the message date is later than the query date. @type query: A L{list} of L{str} @param query: A list whose first element starts with a stringified date that is a fragment of an L{imap4.Query()}. The date must be in the format 'DD-Mon-YYYY', for example '03-March-2003' or '03-Mar-2003'. @type msg: Provider of L{imap4.IMessage} Fr� r� r r� r� r= r= rA �search_SENTSINCE� s z IMAP4Server.search_SENTSINCEc C s" t |�d��}tj�|�� �|kS r� r� r� r= r= rA � search_SINCE� r� zIMAP4Server.search_SINCEc C s t |�d��|�� kS r� r� r~ r= r= rA �search_SMALLER� r� zIMAP4Server.search_SMALLERc C r� )NF�subjectr� r rt r� )rZ rr rx r� �subjr= r= rA �search_SUBJECT� r� zIMAP4Server.search_SUBJECTc C r� r� r� r� r= r= rA � search_TEXT� s zIMAP4Server.search_TEXTc C r� )NF�tor� r rt r� )rZ rr rx r� r� r= r= rA � search_TO� r� zIMAP4Server.search_TOc C s( |\}}|� d�}t||�}|�� |v S )al Returns C{True} if the message UID is in the range defined by the search query. @type query: A L{list} of L{bytes} @param query: A list representing the parsed form of the search query. Its first element should be a L{str} that can be interpreted as a sequence range, for example '2:4,5:*'. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} @param msg: The message being checked. @type lastIDs: L{tuple} @param lastIDs: A tuple of (last sequence id, last message id). The I{last sequence id} is an L{int} containing the highest sequence number of a message in the mailbox. The I{last message id} is an L{int} containing the highest UID of a message in the mailbox. r )r% rt rd ) rZ rr rx r� r� rr rs r� rj r= r= rA � search_UID� s zIMAP4Server.search_UIDc C r� )Nr� r� r~ r= r= rA �search_UNANSWERED� r� z IMAP4Server.search_UNANSWEREDc C r� r� r� r~ r= r= rA �search_UNDELETED� r� z IMAP4Server.search_UNDELETEDc C r� r� r� r~ r= r= rA �search_UNDRAFT� r� zIMAP4Server.search_UNDRAFTc C r� r� r� r~ r= r= rA �search_UNFLAGGED� r� z IMAP4Server.search_UNFLAGGEDc C r� r� r� r~ r= r= rA �search_UNKEYWORD� r� z IMAP4Server.search_UNKEYWORDc C r� r� r� r~ r= r= rA � search_UNSEEN� r� zIMAP4Server.search_UNSEENc C rT )Ns SEARCH failed: rU rN r= r= rA � __ebSearch rW zIMAP4Server.__ebSearchc C sT |r"| � d �| _t| jj||d��t��| j|||��| j |� d S | � |d� d S )NrX s FETCH complete) r � _oldTimeoutr r r\ rC �iter�_IMAP4Server__cbFetchr �_IMAP4Server__ebFetchr� )rZ r� �messagesrr r> r= r= rA �do_FETCH s ��zIMAP4Server.do_FETCHc s� �j d u rg �_ zt��\}}W n ty, ���j� �`���d� ��� Y d S w ��||� ���� ����fdd��� �j � d S )Ns FETCH completedc s �� ��� ��S rm )r� �rA �rr �resultsrZ r� r> r= rA rP 4 s z'IMAP4Server.__cbFetch.<locals>.<lambda>) r# �next� StopIterationr r� r� r' � spewMessagerC r �_IMAP4Server__ebSpewMessage)rZ r� r� rr r> rx r� r= r� rA � __cbFetch s ��zIMAP4Server.__cbFetchc C s t �|� | j�� d S rm )r4 r r� r �rZ rO r= r= rA �__ebSpewMessage7 s zIMAP4Server.__ebSpewMessagec C s* |d u r| j j}|dtt|�g� � d S )Ns ENVELOPE )r� r� r� � getEnvelope�rZ rx r� �_w�_fr= r= rA � spew_envelope? s zIMAP4Server.spew_envelopec C s< |d u r| j j}dd� |�� D �}|dd�|� d � d S )Nc S r� r= r� r� r= r= rA rG G r� z*IMAP4Server.spew_flags.<locals>.<listcomp>r� r� rm )r� �writenr� r� )rZ rx r� r� r� � encodedFlagsr= r= rA � spew_flagsD s zIMAP4Server.spew_flagsc C s� |d u r| j j}|�� }tj�t|��}|d u r&t�d|||f � t d��t � d|d d� �}t |t |d f �}|d d u rF|d }n&|d dkrOd} nd } || d t|d �d d t|d �d d f }|dt|� � d S )Nz$%d:%r: unpareseable internaldate: %rz(Internal failure generating INTERNALDATEz%d-%%s-%Y %H:%M:%S � r; s +0000r r� � -s %04di �d r� s INTERNALDATE )r� r� r� r� r� � parsedate_tzr9 r4 r� r �time�strftimer: � _MONTH_NAMES�abs�_quote) rZ rx r� r� r� �idate�ttup�strdate�odate�signr= r= rA �spew_internaldateJ s. �(���z IMAP4Server.spew_internaldatec C s2 |d u r| j j}t|�d��}|dt|� � d S )NTs RFC822.HEADER )r� r� �_formatHeadersr� �_literal)rZ rx r� r� r� �hdrsr= r= rA �spew_rfc822headere s z IMAP4Server.spew_rfc822headerc C s2 |d u r| j j}|d� |� t|�� ��| j �S )Ns RFC822.TEXT )r� r� � FileProducerr� �beginProducingr� r= r= rA �spew_rfc822textk s zIMAP4Server.spew_rfc822textc C �& |d u r| j j}|d|�� f � d S )Ns RFC822.SIZE %d)r� r� r� r� r= r= rA �spew_rfc822sizer � zIMAP4Server.spew_rfc822sizec C sZ |d u r| j j}|d� |� t|d �}|d ur"t|�� ��| j �S t|d | j��| j �S )Ns RFC822 )r� r� � IMessageFiler �openr �MessageProducerr� )rZ rx r� r� r� �mfr= r= rA � spew_rfc822w s �zIMAP4Server.spew_rfc822c C r )Ns UID %d)r� r� rd r� r= r= rA �spew_uid� r zIMAP4Server.spew_uidc C s |dt t|d�g� � d S )Ns BODYSTRUCTURE T)r� �getBodyStructurer� r= r= rA �spew_bodystructure� s z IMAP4Server.spew_bodystructurec C sp |d u r| j j}|jD ]}|�� r|�|�}q |dkr td��q |jrB|j|jjg|jj �R � }t |�}||� � d t |� � d S |j rZ||� � d � |� t|�� ��| j �S |jrrt |�d��}||� � d t |� � d S |jr�||� � d � |� |jr�t|�� ��| j �S t|d �}|d ur�t|�� ��| j �S t|d | j��| j �S |dtt|�g� � d S )Nr z*Requested subpart of non-multipart messager� Ts BODY )r� r� �part� isMultipart� getSubPartrn �headerr� �negate�fieldsr� � __bytes__r� r5 r r� r �mime�emptyr r r r� r� r ) rZ r rx r� r� r� r� r� r r= r= rA � spew_body� s> � �zIMAP4Server.spew_bodyc sf t �j�}|j� |j��� fdd��� fdd�� � fdd��� ��������� f dd�}��|� �S ) Nc s �d� f � d S )Ns * %d FETCH (r= r= )rx r� r= rA r[ � r� z&IMAP4Server.spewMessage.<locals>.startc � � d� d S )Ns ) r= r= �r� r= rA r� � r� z'IMAP4Server.spewMessage.<locals>.finishc r r� r= r= r r= rA �space� r� z&IMAP4Server.spewMessage.<locals>.spacec 3 s� � d} �� �D ]2}|j dkrd} |j dkr!��|��� ��V nt�d|j �}|��� ��V |�d ur:�� q�rK| sK�� ����� ��V � � �� d S )NFr> Tr� �spew_rt )�typer r) r )�seenUIDr r- � r� r� rx r� rr rZ r r[ r> r� r= rA �spew� s$ � � z%IMAP4Server.spewMessage.<locals>.spew)r� r� r� r� r� )rZ rx r� rr r> �wbufr r= r rA r� � s zIMAP4Server.spewMessagec C s8 | � | j� | `t�|� | �|dtt|j�� � d S )Ns FETCH failed: )r r� r4 r r4 r: r� rb rN r= r= rA � __ebFetch� s zIMAP4Server.__ebFetchc C s~ |� � }|�d�}|�d�rd}n |�d�rd}nd}dd� |D �}t| jj||||d ��| j| j|| j||fd |fd � d S ) Ns SILENTr� r; r� rt r c S r� r= r5 r� r= r= rA rG � r� z(IMAP4Server.do_STORE.<locals>.<listcomp>rX ) r5 �endswithr~ r r �storer� �_IMAP4Server__cbStore�_IMAP4Server__ebStore)rZ r� r� �moder{ r> �silentr= r= rA �do_STORE� s �zIMAP4Server.do_STOREc C sl |r.|s.|� � D ]%\}}|rd|�|�f }nd}dd� |D �} | �d|d�| �|f � q| �|d� d S )Ns UID %dr� c S r� r= r� r� r= r= rA rG � r� z)IMAP4Server.__cbStore.<locals>.<listcomp>s %d FETCH (FLAGS (%b)%b)r� s STORE completed)r� rd r, r� r� ) rZ rJ r� r r> r( �kr� �uidstrr{ r= r= rA � __cbStore� s �zIMAP4Server.__cbStorec C r� �NrL r/ rN r= r= rA � __ebStore� rF zIMAP4Server.__ebStorec C s4 t |�}t| jj|��| j||||��| j|� d S rm )r� r r� r� rC �_cbCopySelectedMailboxr �_ebCopySelectedMailbox)rZ r� r� r" r> r= r= rA �do_COPY r4 zIMAP4Server.do_COPYc C sN |s | � |d| � d S t| jj||��| j||��| j||��| j|� d S )NzNo such mailbox: ) r7 r r r\ rC �_IMAP4Server__cbCopy�_IMAP4Server__cbCopiedr �_IMAP4Server__ebCopy)rZ r r� r� r" r> r= r= rA r/ s � z"IMAP4Server._cbCopySelectedMailboxc C r� r- r/ rN r= r= rA r0 rF z"IMAP4Server._ebCopySelectedMailboxc s� g }t � d �}|D ]U\}}|d ur t|j|�}|�|� q |�� } |�� } t|d �} | d ur;| �� } t� j| | | �}n dd� �t � � } t || | j �� d ��| | | f� �fdd� �}|�|� q t�|�S )Nc S s | � d� | S r� )r� �r- r= r= rA �rewind+ r� z$IMAP4Server.__cbCopy.<locals>.rewindc s � � �|�||�S rm )r6 )rA r� r- r� �r r6 r= rA rP 4 s �z&IMAP4Server.__cbCopy.<locals>.<lambda>)�IMessageCopierr r� rl r� r� r r r6 r� r� r r� r rC r � DeferredList)rZ r� r� r �addedDeferreds� fastCopyMboxrx r� r� r{ r� r� �bodyFile�bufferr= r7 rA �__cbCopy s. �� zIMAP4Server.__cbCopyc C sV g }g }|D ]\}}|r|� |� q|� |j� q|r#| �|d� d S | �|d� d S )Nz%[ALERT] Some messages were not copieds COPY completed)rl rb r7 r� )rZ � deferredIdsr� r re �failuresr- rJ r= r= rA � __cbCopied< s zIMAP4Server.__cbCopiedc C rT )Ns COPY failed:rU rN r= r= rA �__ebCopyI s zIMAP4Server.__ebCopyc C s. |� � }|dvr t|��| j|||dd� d S )N)� COPYr� � STOREr� r; rX )r5 r r6 )rZ r� r� r� r= r= rA �do_UIDM s zIMAP4Server.do_UIDc C s( |r | j ddd� d S | j ddd� d S )Ns [READ-WRITE]T)r� r� s [READ-ONLY]�r, �rZ � writeabler= r= rA � modeChangedZ s zIMAP4Server.modeChangedc C sD |� � D ]\}}dd� |D �}d|d�|�f }| j|dd� qd S )Nc S r� r= r� r� r= r= rA rG b r� z,IMAP4Server.flagsChanged.<locals>.<listcomp>s %d FETCH (FLAGS (%b))r� T�r� )r� r� r, )rZ �newFlags�mIdr{ r� r� r= r= rA � flagsChanged` s �zIMAP4Server.flagsChangedc C s@ |d ur| j d|f dd� |d ur | j d|f dd� d S d S )Nr� TrJ r� rF �rZ �exists�recentr= r= rA � newMessagesf s �zIMAP4Server.newMessages�NNNrm �F�Nr� )r� �r r] )�r� r� r� r� r� r r� r r r r� r� r r r rR r� r{ r r* r] r r r r r" r# r' r$ r: r; r6 r< r= rD rE rW rX r[ rZ �re�compile�escape� _atomCharsrg rk rp rq rs ru rx r| r} r r� r� r r4 r� r7 r, rT r� r� r� �unauth_CAPABILITY�auth_CAPABILITY�select_CAPABILITY�logout_CAPABILITYr� � unauth_LOGOUT� auth_LOGOUT� select_LOGOUT� logout_LOGOUTr� � unauth_NOOP� auth_NOOP� select_NOOP� logout_NOOPr� �unauth_AUTHENTICATEr� r� r� r� r� r� r� �unauth_STARTTLSr� � unauth_LOGINr� r� r� r� �auth_NAMESPACE�select_NAMESPACEr� r� r� � auth_SELECT� select_SELECT� auth_EXAMINE�select_EXAMINEr� r� � select_IDLE� auth_IDLEr� � auth_CREATE� select_CREATEr � auth_DELETE� select_DELETEr � auth_RENAME� select_RENAMEr �auth_SUBSCRIBE�select_SUBSCRIBEr �auth_UNSUBSCRIBE�select_UNSUBSCRIBEr r r � auth_LIST� select_LIST� auth_LSUB� select_LSUBr$ r r! � auth_STATUS� select_STATUSr& r' r3 r1 r2 � auth_APPEND� select_APPENDr7 r8 rB � select_CHECKr? r@ r> rM � select_CLOSErK rL rR �select_EXPUNGErP rQ r` � select_SEARCHrZ r] rm rw r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r[ r� � select_FETCHr� r� r� r� r� r r r r r r r r� r� r) � select_STOREr% r& r1 � select_COPYr/ r0 r2 r3 r4 rE � select_UIDrI rM rQ r= r= r= rA r� U s� /� < 0 " & # ( r� c @ sJ e Zd ZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZeeed�ZdZd�d d �Zd d � Zd d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Z d d � Z d!d"� Z d#d$� Z d%d&� Z d'd(� Z!d)d*� Z"d+d,� Z#d�d-d.�Z$d/d0� Z%d1d2� Z&d3d4� Z'd5d6� Z(d7d8� Z)d�d9d:�Z*d;d<� Z+d=d>� Z,d?d@� Z-dAdB� Z.dCdD� Z/dEdF� Z0dGdH� Z1dIdJ� Z2dKdL� Z3dMdN� Z4dOdP� Z5dQdR� Z6dSdT� Z7dUdV� Z8dWdX� Z9dYdZ� Z:d[d\� Z;d]d^� Z<d_d`� Z=dadb� Z>dcdd� Z?dedf� Z@dgdh� ZAdidj� ZBdkdl� ZCdmdn� doD �ZDdpdq� ZEdrds� ZFd�dudv�ZGdwdx� ZHdydz� ZId{d|� ZJd}d~� ZKdd�� ZLd�d�� ZMdd��d�d��ZNd�d�� ZOd�d�d��ZPd�d�d��ZQd�d�d��ZRd�d�d��ZSd�d�d��ZTd�d�d��ZUd�d�d��ZVd�d�d��ZWd�d�d��ZXd�d�d��ZYd�d�d��ZZd�d�d��Z[d�d�d��Z\d�d�� Z]d�d�� Z^ d�d�d��Z_d�d�d��Z`d�d�d��Zad�d�d��Zbd�d�d��Zcd�d�� Zdd�d�� Zed�d�� Zfd�d�� Zgd�d�� ZhdS )�� IMAP4ClientzIMAP4 client protocol implementation @ivar state: A string representing the state the connection is currently in. Nr; Fr r� )�OK�NO�BAD�PREAUTH�BYE)�MESSAGES�RECENT�UNSEENc C s. i | _ g | _i | _|| _d | _d | _d | _d S rm )r �queued�authenticators�context�_tag�_parts�_lastCmd)rZ r� r= r= rA r] � s zIMAP4Client.__init__c C s || j |�� �� < dS )a� Register a new form of authentication When invoking the authenticate() method of IMAP4Client, the first matching authentication scheme found will be used. The ordering is that in which the server lists support authentication schemes. @type auth: Implementor of C{IClientAuthentication} @param auth: The object to use to perform the client side of this authentication scheme. N)r� �getNamer5 )rZ r� r= r= rA �registerAuthenticator� s z!IMAP4Client.registerAuthenticatorc C s� | j dkr | �� | jt|�8 _| jdkr | j�|� d S d}| jdk r5|d | j� || jd � }}| j�|� | j}d | _d | _|�dd� | j�|� � � | � |� d�� d S )Nr r� � ) r r � _pendingSizer� �_pendingBufferr� r� r� rl �readr! �lstrip)rZ r� r� r8 r= r= rA r" � s zIMAP4Client.rawDataReceivedc C sD | � |�| _|| _| jd u r|dg| _n| j�|dg� | �� d S )Nr� )� messageFiler� r� r� rr rU )rZ r8 �octetsr= r= rA �_setupForLiteral� s z IMAP4Client._setupForLiteralc C s | j dkr | �| j � d S d S r� )r r r^ r= r= rA r � s �zIMAP4Client.connectionMadec C s� | j dkr | �d� | jdur | j}d| _|D ]}|j�|� q| jdurA| j}d| _|�� D ]}|dur@|jdur@|j�|� q/dS dS )z, We are no longer connected r N)r r r� r �errbackr �values)rZ r r� r9 r r= r= rA r � s ��zIMAP4Client.connectionLostc C s� | j dkr | �� |�d�}|dkrN||d d� }|�d�rNz t|dd� �}W n ty4 t|��w | jdu rD|�dd�\| _ }n|}| � ||� dS | jdu rZ| � |� dS | j� |� | j d� | j�}}d | _ | _| �||� dS )aF Attempt to parse a single line from the server. @type line: L{bytes} @param line: The line from the server, without the line delimiter. @raise IllegalServerResponse: If the line or some part of the line does not represent an allowed message from the server at this time. r r_ rt r; Nr` r� )r r �rfindr# rd r` r r� r3 r� r� �_regularDispatchrl r� r6 )rZ r� �lastPartr� �partsr� r8 r= r= rA r$ � s, � zIMAP4Client.lineReceivedc C sp | j r| j jd ur| j jd }| j _|�t� | jr1| jD ]}|jd ur0|j|}|_|�t� q | j�� d S rm )r� r r� � TIMEOUT_ERRORr� r� r )rZ r� r9 r= r= rA r s �z IMAP4Client.timeoutConnectionc C s: |� d d�}t|�dkr|�d� |\}}| �||� d S )Nr; r� r� )r3 r� rl r6 )rZ r� r� r� r8 r= r= rA r� s z IMAP4Client._regularDispatchc C s || j kr t�� S t� S )a8 Create a file to which an incoming message may be written. @type octets: L{int} @param octets: The number of octets which will be written to the file @rtype: Any object which implements C{write(string)} and C{seek(int, int)} @return: A file-like object )r� r� r� r )rZ r� r= r= rA r� ! s zIMAP4Client.messageFilec C s" d| j �d�}| j d7 _ |S )Nz%0.4X�asciir; )�tagIDr r� r= r= rA �makeTag1 s zIMAP4Client.makeTagc C s� | j d u r | j}n t| d| j �� d �}|r2z|||� W d S ty1 t�� | j�� Y d S w t�d| j � d|�d|��� | j�� d S )N� response_zCannot dispatch: z, ) r �response_UNAUTHr) r5 r� r4 r r� r )rZ r� r8 r- r= r= rA r6 6 s � zIMAP4Client.dispatchCommandc C s� | j d u r]|�d d�\}}|�� dkrd| _ n|�� dkr!d| _ n | j�� t|d | ��|�d�|�d�}}|d krV|d krV| �| �t ||d |� �gd f�� d S | �d � d S | � ||� d S ) Nr; r� r� s PREAUTHr� r� r� � ]rt ) r r3 r5 r� r r ro �serverGreeting� _IMAP4Client__cbCapabilitiesr� �_defaultHandler)rZ r� r8 r- r� r. r= r= rA r� E s �zIMAP4Client.response_UNAUTHc C s | � ||� d S rm )r� )rZ r� r8 r= r= rA � response_AUTH\ r� zIMAP4Client.response_AUTHc C s� |dks|dkr.| j s| �t|�g� d S | j| j }|dkr&|�|� d S |j�|� d S z| j| }W n tyI | j� � t |d | ��w |� d d�\}}|dkr^|� || j� n|j �t|�� | j|= d | _ | �� d S )Nr� r� r� r; r� )�waiting� _extraInfor� r r� r� rl �KeyErrorr� r r r3 r� r r� r � _flushQueue)rZ r� r8 r9 r- r� r= r= rA r� _ s( � zIMAP4Client._defaultHandlerc C sB | j r | j �d�}| �� }|| j|< | �|�|�� || _d S d S r� )r� r% r� r r r� r� �rZ r9 �tr= r= rA r� { s �zIMAP4Client._flushQueuec C s6 i }d }}|D ]y}t |�}|dkr |d dgkr | �d� q|dkr0|d dgkr0| �d� q|dkrA|d dkrAt|d �}q|dkrR|d d krRt|d �}q|d kry|d d kryt|d �}| �|d �\}} |�|g ��|�d d �� qt�d|� �� q|r�| � |� |d us�|d ur�| � ||� d S d S )Nr; r r� Fr� Tr� r� r� r/ r� �FLAGSr= z Unhandled unsolicited response: ) r� rI rd �_parseFetchPairs� setdefaultrr r� r4 r� rM rQ ) rZ r� r{ rP rO �response�elementsrL r� rA r= r= rA r� � s, �zIMAP4Client._extraInfoc C sV t �� |_ | jr| j�|� |j S | �� }|| j|< | �|�|�� || _|| _ |j S rm ) r rS r� r� rl r� r r r� r� r� r= r= rA � sendCommand� s zIMAP4Client.sendCommandc C sD |r | j dur t�| j �S d}d}| �t||d��}|�| j� |S )av Request the capabilities available on this server. This command is allowed in any state of connection. @type useCache: C{bool} @param useCache: Specify whether to use the capability-cache or to re-retrieve the capabilities from the server. Server capabilities should never change, so for normal use, this flag should never be false. @rtype: L{Deferred} @return: A deferred whose callback will be invoked with a dictionary mapping capability types to lists of supported mechanisms, or to None if a support list is not applicable. Nr� )r� �r� )� _capCacher �succeedr� r� rC r� )rZ �useCacher9 r r� r= r= rA �getCapabilities� s zIMAP4Client.getCapabilitiesc C s� |\}}i }|D ],}|dd � D ]#}|� dd�}t|�dkr&|d d }} n|\}} |�|g ��| � qq|D ] }|| d gkrDd ||< q7|| _|S )Nr; r� r )r3 r� r� rl r� ) rZ rJ r� �tagliner� r8 r r� �categoryrb r= r= rA �__cbCapabilities� s � �z IMAP4Client.__cbCapabilitiesc C s" | � tddd��}|�| j� |S )a* Inform the server that we are done with the connection. This command is allowed in any state of connection. @rtype: L{Deferred} @return: A deferred whose callback will be invoked with None when the proper server acknowledgement has been received. s LOGOUT)s BYEr� )r� r� rC �_IMAP4Client__cbLogout�rZ r� r= r= rA r� � s zIMAP4Client.logoutc C s |\}}| j �� d S rm )r� r �rZ rJ r� r� r= r= rA � __cbLogout� s zIMAP4Client.__cbLogoutc C s | � td��}|�| j� |S )a Perform no operation. This command is allowed in any state of connection. @rtype: L{Deferred} @return: A deferred whose callback will be invoked with a list of untagged status updates the server responds with. s NOOP)r� r� rC �_IMAP4Client__cbNoopr� r= r= rA �noop� s zIMAP4Client.noopc C s |\}}|S rm r= r� r= r= rA �__cbNoop� s zIMAP4Client.__cbNoopc s� � j rJ d��|du r� �� }|du rt�td��S d� jvr&t�td��S t�� jd�}|du r8t�td��S � � t d��}|� � j |� |� � fdd�� |S ) a: Initiates a 'STARTTLS' request and negotiates the TLS / SSL Handshake. @param contextFactory: The TLS / SSL Context Factory to leverage. If the contextFactory is None the IMAP4Client will either use the current TLS / SSL Context Factory or attempt to create a new one. @type contextFactory: C{ssl.ClientContextFactory} @return: A Deferred which fires when the transport has been secured according to the given contextFactory, or which fails if the transport cannot be secured. z5Client and Server are currently communicating via TLSNzEIMAP4Client requires a TLS context to initiate the STARTTLS handshaker z:Server does not support secure communication via TLS / SSLzAIMAP4Client transport does not implement interfaces.ITLSTransportc rH rm �r� r� r^ r= rA rP 1 rQ z&IMAP4Client.startTLS.<locals>.<lambda>) r �_getContextFactoryr �failr r� r r r� r� r� rC � _startedTLS)rZ r� �tlsr� r= r^ rA r� s: ���� ����zIMAP4Client.startTLSc C s2 | j du r | �� }nt�| j �}|�| j|� |S )a2 Attempt to enter the authenticated state with the server This command is allowed in the Non-Authenticated state. @rtype: L{Deferred} @return: A deferred whose callback is invoked if the authentication succeeds and whose errback will be invoked otherwise. N)r� r� r r� rC � _IMAP4Client__cbAuthenticate)rZ �secretr� r= r= rA r� 4 s zIMAP4Client.authenticatec s� |� dd�� � D ]}|�� �jv r"td|d�j||�}��|� S q�jr1t�t � �j� � ��S � �fdd�}�� � }|� |� |� �fdd�� |� �j|� |S )Nr r= � AUTHENTICATEc s | � t� t�t� �j�� ��S rm )�trapr r r� r# r� r )r ��authsrZ r= rA � ebStartTLST s �z0IMAP4Client.__cbAuthenticate.<locals>.ebStartTLSc rH rm r� r� r^ r= rA rP ] rQ z.IMAP4Client.__cbAuthenticate.<locals>.<lambda>)r� r5 r� r� � _IMAP4Client__cbContinueAuthr� r r r� r# r r� r rC �_IMAP4Client__cbAuthTLS)rZ r� r� �schemer9 r� r� r= r� rA �__cbAuthenticateE s$ ��� z IMAP4Client.__cbAuthenticatec C s` zt |d �}W n tjy | �d� t|��w | j| }|�||�}| �t|��� � d S )N� r� ) r r� r� r r r� �challengeResponser rc )rZ r8 r� r� r� r� r= r= rA �__cbContinueAutha s � z IMAP4Client.__cbContinueAuthc C sV |� dd�}|D ]}|�� | jv r"td|d| j||�}| �|� S qt|| j�� ��)Nr r= r� )r� r5 r� r� r� r� r# r )rZ r� r� r� r� r9 r= r= rA � __cbAuthTLSl s ��zIMAP4Client.__cbAuthTLSc C s t | j�}|�| j||� |S )a� Authenticate with the server using a username and password This command is allowed in the Non-Authenticated state. If the server supports the STARTTLS capability and our transport supports TLS, TLS is negotiated before the login command is issued. A more secure way to log in is to use C{startTLS} or C{authenticate} or both. @type username: L{str} @param username: The username to log in with @type password: L{str} @param password: The password to log in with @rtype: L{Deferred} @return: A deferred whose callback is invoked if login is successful and whose errback is invoked otherwise. )r r� rC �_IMAP4Client__cbLoginCaps)rZ �username�passwordr� r= r= rA r� v s zIMAP4Client.loginc C rG )z� Called when the server has sent us a greeting. @type caps: C{dict} @param caps: Capabilities the server advertised in its greeting. Nr= )rZ r� r= r= rA r� � � zIMAP4Client.serverGreetingc C sL | j d ur| j S zddlm} W n ty Y d S w |�� }|jj|_|S )Nr )�ssl)r� ro r� � ImportError�ClientContextFactory�SSL� TLSv1_METHOD�method)rZ r� r� r= r= rA r� � s � z IMAP4Client._getContextFactoryc C s� d|v }t �| jd �d u}t �| jd �d u }| js1|r1|r1|r1| �� }|j| j| j||fd� |S |r8t � d� d� t |�t |�f�}| � td|��S )Nr )r< z5Server has no TLS support. logging in over cleartext!r� r� )r r r� r r r� r� �_IMAP4Client__cbLoginTLS�_IMAP4Client__ebLoginTLSr4 r� r� r� r� r� ) rZ r r� r� �tryTLS�tlsableTransport�nontlsTransportr� r� r= r= rA � __cbLoginCaps� s � zIMAP4Client.__cbLoginCapsc C s | j �|� d | _d| _|S )NT)r� r� r� r )rZ rJ r� r= r= rA r� � s zIMAP4Client._startedTLSc C s& d� t|�t|�f�}| �td|��S )Nr� r� )r� r� r� r� )rZ rJ r� r� r� r= r= rA � __cbLoginTLS� s zIMAP4Client.__cbLoginTLSc C s t �|� |S rm )r4 r r� r= r= rA � __ebLoginTLS� r� zIMAP4Client.__ebLoginTLSc C �* d}d}| � t||d��}|�| j� |S )a� Retrieve information about the namespaces available to this account This command is allowed in the Authenticated and Selected states. @rtype: L{Deferred} @return: A deferred whose callback is invoked with namespace information. An example of this information is:: [[['', '/']], [], []] which indicates a single personal namespace called '' with '/' as its hierarchical delimiter, and no shared or user namespaces. r� )r� r� )r� r� rC �_IMAP4Client__cbNamespace�rZ r9 r r� r= r= rA � namespace� � zIMAP4Client.namespacec sd |\}}dd� � |D ] }t |�dkr'|d dkr'� fdd�|dd � D � S q t�d � g g g gS ) Nc S s dd� | D �S )Nc S � g | ]}|� d ��qS )r� )�decode)rC �elementr= r= rA rG � r� zSIMAP4Client.__cbNamespace.<locals>._prepareNamespaceOrDelimiter.<locals>.<listcomp>r= )� namespaceListr= r= rA � _prepareNamespaceOrDelimiter� � z?IMAP4Client.__cbNamespace.<locals>._prepareNamespaceOrDelimiterrh r r� c s* g | ]}|d u r g n� fdd�|D ��qS )Nc � g | ]}� |��qS r= r= )rC rb �r� r= rA rG � r� z8IMAP4Client.__cbNamespace.<locals>.<listcomp>.<listcomp>r= )rC � pairOrNoner r= rA rG � s ���z-IMAP4Client.__cbNamespace.<locals>.<listcomp>r; z*No NAMESPACE response to NAMESPACE command)r� r4 r )rZ rJ r� r_ r� r= r rA � __cbNamespace� s �� zIMAP4Client.__cbNamespacec C �6 d}t |�}d}| �t|||d��}|�| jd� |S )a� Select a mailbox This command is allowed in the Authenticated and Selected states. @type mailbox: L{str} @param mailbox: The name of the mailbox to select @rtype: L{Deferred} @return: A deferred whose callback is invoked with mailbox information if the select is successful and whose errback is invoked otherwise. Mailbox information consists of a dictionary with the following L{str} keys and values:: FLAGS: A list of strings containing the flags settable on messages in this mailbox. EXISTS: An integer indicating the number of messages in this mailbox. RECENT: An integer indicating the number of "recent" messages in this mailbox. UNSEEN: The message sequence number (an integer) of the first unseen message in the mailbox. PERMANENTFLAGS: A list of strings containing the flags that can be permanently set on messages in this mailbox. UIDVALIDITY: An integer uniquely identifying this mailbox. r� )r� �EXISTSr� r� �PERMANENTFLAGS� UIDVALIDITYr� r; ��_prepareMailboxNamer� r� rC �_IMAP4Client__cbSelect�rZ r" r9 r� r r� r= r= rA r� � s zIMAP4Client.selectc C r )a� Select a mailbox in read-only mode This command is allowed in the Authenticated and Selected states. @type mailbox: L{str} @param mailbox: The name of the mailbox to examine @rtype: L{Deferred} @return: A deferred whose callback is invoked with mailbox information if the examine is successful and whose errback is invoked otherwise. Mailbox information consists of a dictionary with the following keys and values:: 'FLAGS': A list of strings containing the flags settable on messages in this mailbox. 'EXISTS': An integer indicating the number of messages in this mailbox. 'RECENT': An integer indicating the number of "recent" messages in this mailbox. 'UNSEEN': An integer indicating the number of messages not flagged \Seen in this mailbox. 'PERMANENTFLAGS': A list of strings containing the flags that can be permanently set on messages in this mailbox. 'UIDVALIDITY': An integer uniquely identifying this mailbox. r� )r� r� r� r� r� r� r� r r r r= r= rA �examine# s zIMAP4Client.examinec C s" zt |�W S ty t|��w )z� Parse C{value} as an integer and return the result or raise L{IllegalServerResponse} with C{phrase} as an argument if C{value} cannot be parsed as an integer. )rd r` r )rZ rb �phraser= r= rA � _intOrRaiseQ s �zIMAP4Client._intOrRaisec C s� |\}}d|i}|� t|�� |D ]�}t|�dkr�|d �� dkr�|d }t|t�r/|d }n|}|�� }|dkr>d|d< q|dkrGd|d< q|d krV| �|d |�|d < q|d kre| �|d |�|d < q|d krt| �|d |�|d< q|dkr�tdd� |d D ��|d< qt� d|� �� qt|�dkr�|d �� dkr�tdd� |d D ��|d< qt|d t �r�|d �� dkr�| �|d |�|d< q|d �� dkr�| �|d |�|d< qt� d |� �� qt� d |� �� qt� d |� �� q|S ) zy Handle lines received in response to a SELECT or EXAMINE command. See RFC 3501, section 6.3.1. z READ-WRITEr r� r; r� Fr� Tr� r r� r� r� �UIDNEXTr� c s r rm r5 r� r= r= rA r� | s � �z)IMAP4Client.__cbSelect.<locals>.<genexpr>r z Unhandled SELECT response (2): r� r� c s r rm r5 r� r= r= rA r� � r r� r� r r� r� z Unhandled SELECT response (0): z Unhandled SELECT response (1): z Unhandled SELECT response (4): ) rl r� r� r5 rU rV r �tupler4 r �bytes) rZ rJ r� r� r� �datumr3 �contentrg r= r= rA � __cbSelect\ sJ � zIMAP4Client.__cbSelectc C � | � tdt|���S )a| Create a new mailbox on the server This command is allowed in the Authenticated and Selected states. @type name: L{str} @param name: The name of the mailbox to create. @rtype: L{Deferred} @return: A deferred whose callback is invoked if the mailbox creation is successful and whose errback is invoked otherwise. s CREATE�r� r� r �rZ r� r= r= rA r� � � zIMAP4Client.createc C r )ak Delete a mailbox This command is allowed in the Authenticated and Selected states. @type name: L{str} @param name: The name of the mailbox to delete. @rtype: L{Deferred} @return: A deferred whose calblack is invoked if the mailbox is deleted successfully and whose errback is invoked otherwise. s DELETEr r r= r= rA r� � r zIMAP4Client.deletec C s* t |�}t |�}| �tdd�||f���S )a� Rename a mailbox This command is allowed in the Authenticated and Selected states. @type oldname: L{str} @param oldname: The current name of the mailbox to rename. @type newname: L{str} @param newname: The new name to give the mailbox. @rtype: L{Deferred} @return: A deferred whose callback is invoked if the rename is successful and whose errback is invoked otherwise. s RENAMEr� )r r� r� r� )rZ r r r= r= rA r � s zIMAP4Client.renamec C r )a� Add a mailbox to the subscription list This command is allowed in the Authenticated and Selected states. @type name: L{str} @param name: The mailbox to mark as 'active' or 'subscribed' @rtype: L{Deferred} @return: A deferred whose callback is invoked if the subscription is successful and whose errback is invoked otherwise. s SUBSCRIBEr r r= r= rA r � r zIMAP4Client.subscribec C r )a{ Remove a mailbox from the subscription list This command is allowed in the Authenticated and Selected states. @type name: L{str} @param name: The mailbox to unsubscribe @rtype: L{Deferred} @return: A deferred whose callback is invoked if the unsubscription is successful and whose errback is invoked otherwise. s UNSUBSCRIBEr r r= r= rA r � r zIMAP4Client.unsubscribec C sF d}d|� d|� d�� d�}d}| �t|||d��}|�| jd� |S )ap List a subset of the available mailboxes This command is allowed in the Authenticated and Selected states. @type reference: L{str} @param reference: The context in which to interpret C{wildcard} @type wildcard: L{str} @param wildcard: The pattern of mailbox names to match, optionally including either or both of the '*' and '%' wildcards. '*' will match zero or more characters and cross hierarchical boundaries. '%' will also match zero or more characters, but is limited to a single hierarchical level. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a list of L{tuple}s, the first element of which is a L{tuple} of mailbox flags, the second element of which is the hierarchy delimiter for this mailbox, and the third of which is the mailbox name; if the command is unsuccessful, the deferred's errback is invoked instead. B{NB}: the delimiter and the mailbox name are L{str}s. r� �"z" "r� )r� r� )r r� r� rC �_IMAP4Client__cbList)rZ � reference�wildcardr9 r� r r� r= r= rA rV � s zIMAP4Client.listc C sV d}|� d�}|� d�}d�d|d|dg�}d}| �t|||d��}|�| jd� |S ) aa List a subset of the subscribed available mailboxes This command is allowed in the Authenticated and Selected states. The parameters and returned object are the same as for the L{list} method, with one slight difference: Only mailboxes which have been subscribed can be included in the resulting list. r� r� r� r� r^ s " ")r� r� )r r� r� r� rC r ) rZ r r r9 �encodedReference�encodedWildcardr� r r� r= r= rA �lsub s �� zIMAP4Client.lsubc C s� |\}}g }|D ]8}t |�dkr@|d |kr@tdd� |d D ��|d< |d �d�|d< |d �d�|d< |�t|dd � �� q|S ) Nrh r c s r rm r5 r� r= r= rA r� + r z'IMAP4Client.__cbList.<locals>.<genexpr>r; r� r� r/ )r� r r� rl )rZ rJ r� r� r_ r� r� r= r= rA �__cbList$ s �zIMAP4Client.__cbListc C s i | ]}||� d ��qS )r� �r �rC r� r= r= rA � <dictcomp>? s ��zIMAP4Client.<dictcomp>�r� r� r r r� c s� d}t |�}zd�� fdd�|D ��}W n ty) tdt|�t� j� ����w d�|d|dg�}d }� �t|||d ��}|�� j � |S ) a7 Retrieve the status of the given mailbox This command is allowed in the Authenticated and Selected states. @type mailbox: L{str} @param mailbox: The name of the mailbox to query @type names: L{bytes} @param names: The status names to query. These may be any number of: C{'MESSAGES'}, C{'RECENT'}, C{'UIDNEXT'}, C{'UIDVALIDITY'}, and C{'UNSEEN'}. @rtype: L{Deferred} @return: A deferred which fires with the status information if the command is successful and whose errback is invoked otherwise. The status information is in the form of a C{dict}. Each element of C{names} is a key in the dictionary. The value for each key is the corresponding response from the server. r� r� c 3 s � | ]}� j | V qd S rm )� _statusNamesr# r^ r= rA r� c s � z%IMAP4Client.status.<locals>.<genexpr>zUnknown names: r� r, rm )r� r� ) r r� r� r` �setr& r� r� rC �_IMAP4Client__cbStatus)rZ r" r� r9 �preparedMailboxr� r r� r= r^ rA r- J s � zIMAP4Client.statusc s� |\}}i }|D ]7}|d dkr?|d � � fdd�t dt� �d�D �� � D ]\}}z||t|�< W q% ty> tt� ���w q|�� D ]3}| j�|�}|rwz ||| �||< W qD t yv } ztd| d || d t | � ��d } ~ ww qD|S ) Nr r� r� c s g | ] }� ||d � �qS )r� r= ra �r� r= rA rG s � z*IMAP4Client.__cbStatus.<locals>.<listcomp>�(r) z): ) rl r� r9 �UnicodeDecodeErrorr rF r �STATUS_TRANSFORMATIONSr� r+ r� ) rZ rJ r� r_ r- r� r* r� r� r. r= r* rA r. m s4 �� ����zIMAP4Client.__cbStatusr= c C s~ |� dd� |�� }|� dd� |rtdt|� �}nd}dd� |D �}dt|�d�|�||f }| �td |d | j|��}|S ) a� Add the given message to the given mailbox. This command is allowed in the Authenticated and Selected states. @type mailbox: L{str} @param mailbox: The mailbox to which to add this message. @type message: Any file-like object opened in B{binary mode}. @param message: The message to add, in RFC822 format. Newlines in this file should be \r\n-style. @type flags: Any iterable of L{str} @param flags: The flags to associated with this message. @type date: L{str} @param date: The date to associate with this message. This should be of the format DD-MM-YYYY HH:MM:SS +/-HHMM. For example, in Eastern Standard Time, on July 1st 2004 at half past 1 PM, "01-07-2004 13:30:00 -0500". @rtype: L{Deferred} @return: A deferred whose callback is invoked when this command succeeds or whose errback is invoked if it fails. r r� z "%s"r� c S r� r= r� r� r= r= rA rG � r� z&IMAP4Client.append.<locals>.<listcomp>s %b (%b)%b {%d}r� s APPENDr= ) r� �tellr: r9 r r� r� r� � _IMAP4Client__cbContinueAppend) rZ r" r� r{ r� r� r� r9 r� r= r= rA rl � s" ��zIMAP4Client.appendc C s t �� }|�|| jd ��| j�S rm )r2 � FileSender�beginFileTransferr� rC � _IMAP4Client__cbFinishAppend)rZ r� r� r� r= r= rA �__cbContinueAppend� s �z IMAP4Client.__cbContinueAppendc C s | � d� d S rT r� )rZ �foor= r= rA �__cbFinishAppend� r z IMAP4Client.__cbFinishAppendc C � | � td��S )a Tell the server to perform a checkpoint This command is allowed in the Selected state. @rtype: L{Deferred} @return: A deferred whose callback is invoked when this command succeeds or whose errback is invoked if it fails. s CHECK�r� r� r^ r= r= rA rM � s zIMAP4Client.checkc C r7 )a� Return the connection to the Authenticated state. This command is allowed in the Selected state. Issuing this command will also remove all messages flagged \Deleted from the selected mailbox if it is opened in read-write mode, otherwise it indicates success by no messages are removed. @rtype: L{Deferred} @return: A deferred whose callback is invoked when the command completes successfully or whose errback is invoked if it fails. s CLOSEr8 r^ r= r= rA r � s zIMAP4Client.closec C r� )a� Return the connection to the Authenticate state. This command is allowed in the Selected state. Issuing this command will perform the same actions as issuing the close command, but will also generate an 'expunge' response for every message deleted. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a list of the 'expunge' responses when this command is successful or whose errback is invoked otherwise. r� )r� r� )r� r� rC �_IMAP4Client__cbExpunger� r= r= rA rJ � r� zIMAP4Client.expungec C sH |\}}g }|D ]}t |�dkr!|d dkr!|�| �|d |�� q|S )Nr� r; r� r )r� rl r )rZ rJ r� r_ re r� r= r= rA rS � s �zIMAP4Client.__cbExpungerX c G sJ dd� |D �}|r dnd}d� |�}| �t|||fd��}|�| j� |S )a� Search messages in the currently selected mailbox This command is allowed in the Selected state. Any non-zero number of queries are accepted by this method, as returned by the C{Query}, C{Or}, and C{Not} functions. @param uid: if true, the server is asked to return message UIDs instead of message sequence numbers. @type uid: L{bool} @rtype: L{Deferred} @return: A deferred whose callback will be invoked with a list of all the message sequence numbers return by the search, or whose errback will be invoked if there is an error. c S r� )r� r" )rC rr r= r= rA rG r� z&IMAP4Client.search.<locals>.<listcomp>s UID SEARCHr� r� r� )r� r� r� rC �_IMAP4Client__cbSearch)rZ r> �queriesr9 r� r� r= r= rA rz � s zIMAP4Client.searchc sT |\}}g }|D ] � t � �dkr'� d dkr'|�� �fdd�� dd � D �� q|S )Nr r� c s g | ]}�� |� ��qS r= )r �rC r� �r� rZ r= rA rG r� z*IMAP4Client.__cbSearch.<locals>.<listcomp>r; )r� rr )rZ rJ r� r\ re r= r= rA rf s "�zIMAP4Client.__cbSearchc C � | j ||dd�S )aV Retrieve the unique identifier for one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message sequence numbers to unique message identifiers, or whose errback is invoked if there is an error. r; )�useUIDr> ��_fetch�rZ r� r> r= r= rA �fetchUID � zIMAP4Client.fetchUIDc C r> )aH Retrieve the flags for one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: The messages for which to retrieve flags. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to lists of flags, or whose errback is invoked if there is an error. r; )r? r{ r@ rB r= r= rA � fetchFlags. rD zIMAP4Client.fetchFlagsc C r> )a� Retrieve the internal date associated with one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: The messages for which to retrieve the internal date. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to date strings, or whose errback is invoked if there is an error. Date strings take the format of "day-month-year time timezone". r; )r? � internaldater@ rB r= r= rA �fetchInternalDateB s z IMAP4Client.fetchInternalDatec C r> )a� Retrieve the envelope data for one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: The messages for which to retrieve envelope data. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to envelope data, or whose errback is invoked if there is an error. Envelope data consists of a sequence of the date, subject, from, sender, reply-to, to, cc, bcc, in-reply-to, and message-id header fields. The date, subject, in-reply-to, and message-id fields are L{str}, while the from, sender, reply-to, to, cc, and bcc fields contain address data as L{str}s. Address data consists of a sequence of name, source route, mailbox name, and hostname. Fields which are not present for a particular address may be L{None}. r; )r? �enveloper@ rB r= r= rA � fetchEnvelopeW � zIMAP4Client.fetchEnvelopec C r> )a� Retrieve the structure of the body of one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: The messages for which to retrieve body structure data. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to body structure data, or whose errback is invoked if there is an error. Body structure data describes the MIME-IMB format of a message and consists of a sequence of mime type, mime subtype, parameters, content id, description, encoding, and size. The fields following the size field are variable: if the mime type/subtype is message/rfc822, the contained message's envelope information, body structure data, and number of lines of text; if the mime type is text, the number of lines of text. Extension fields may also be included; if present, they are: the MD5 hash of the body, body disposition, body language. r; )r? � bodystructurer@ rB r= r= rA �fetchBodyStructuret rJ z IMAP4Client.fetchBodyStructurec C r> )a� Retrieve the simplified body structure of one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: C{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to body data, or whose errback is invoked if there is an error. The simplified body structure is the same as the body structure, except that extension fields will never be present. r; )r? r� r@ rB r= r= rA �fetchSimplifiedBody� s z IMAP4Client.fetchSimplifiedBodyc C r> )a) Retrieve one or more entire messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: C{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A L{Deferred} which will fire with a C{dict} mapping message sequence numbers to C{dict}s giving message data for the corresponding message. If C{uid} is true, the inner dictionaries have a C{'UID'} key mapped to a L{str} giving the UID for the message. The text of the message is a L{str} associated with the C{'RFC822'} key in each dictionary. r; )r? �rfc822r@ rB r= r= rA � fetchMessage� s zIMAP4Client.fetchMessagec C r> )a< Retrieve headers of one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to dicts of message headers, or whose errback is invoked if there is an error. r; )r? � rfc822headerr@ rB r= r= rA � fetchHeaders� rD zIMAP4Client.fetchHeadersc C r> )aL Retrieve body text of one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to file-like objects containing body text, or whose errback is invoked if there is an error. r; )r? � rfc822textr@ rB r= r= rA � fetchBody� rD zIMAP4Client.fetchBodyc C r> )a6 Retrieve the size, in octets, of one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to sizes, or whose errback is invoked if there is an error. r; )r? � rfc822sizer@ rB r= r= rA � fetchSize� rD zIMAP4Client.fetchSizec C s | j ||dddddd�S )aV Retrieve several different fields of one or more messages This command is allowed in the Selected state. This is equivalent to issuing all of the C{fetchFlags}, C{fetchInternalDate}, C{fetchSize}, C{fetchEnvelope}, and C{fetchSimplifiedBody} functions. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to dict of the retrieved data values, or whose errback is invoked if there is an error. They dictionary keys are "flags", "date", "size", "envelope", and "body". r; )r? r{ rF rT rH r� r@ rB r= r= rA � fetchFull� s �zIMAP4Client.fetchFullc C s | j ||ddddd�S )a. Retrieve several different fields of one or more messages This command is allowed in the Selected state. This is equivalent to issuing all of the C{fetchFlags}, C{fetchInternalDate}, C{fetchSize}, and C{fetchEnvelope} functions. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to dict of the retrieved data values, or whose errback is invoked if there is an error. They dictionary keys are "flags", "date", "size", and "envelope". r; )r? r{ rF rT rH r@ rB r= r= rA �fetchAll s �zIMAP4Client.fetchAllc C s | j ||dddd�S )a Retrieve several different fields of one or more messages This command is allowed in the Selected state. This is equivalent to issuing all of the C{fetchFlags}, C{fetchInternalDate}, and C{fetchSize} functions. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to dict of the retrieved data values, or whose errback is invoked if there is an error. They dictionary keys are "flags", "date", and "size". r; )r? r{ rF rT r@ rB r= r= rA � fetchFast4 s zIMAP4Client.fetchFastc s� � fdd�� i }g }t |�} zt|�}W n ty! Y ||fS w zt|�}W n ty4 td|��w |dvr<d}n t|t�sDd}nt|�dkrMd}n|rYt|d t�rYd}nd}t|�}|�|� |r�t|�dk rd d � |D �}|�|� |t |�f}n t|d �}d d � |d D �} |�|| g� ||t | �ff}zt|�}W n ty� td|��w |� d �r�|� d�r�z t |d d� � W n t y� Y n"w t|�}|�|� ||f }zt|�}W n ty� td|��w � |�}|�|� |||< q)a� Given the result of parsing a single I{FETCH} response, construct a L{dict} mapping response keys to response values. @param fetchResponseList: The result of parsing a I{FETCH} response with L{parseNestedParens} and extracting just the response data (that is, just the part that comes after C{"FETCH"}). The form of this input (and therefore the output of this method) is very disagreeable. A valuable improvement would be to enumerate the possible keys (representing them as structured objects of some sort) rather than using strings and tuples of tuples of strings and so forth. This would allow the keys to be documented more easily and would allow for a much simpler application-facing API (one not based on looking up somewhat hard to predict keys in a dict). Since C{fetchResponseList} notionally represents a flattened sequence of pairs (identifying keys followed by their associated values), collapsing such complex elements of this list as C{["BODY", ["HEADER.FIELDS", ["SUBJECT"]]]} into a single object would also greatly simplify the implementation of this method. @return: A C{dict} of the response data represented by C{pairs}. Keys in this dictionary are things like C{"RFC822.TEXT"}, C{"FLAGS"}, or C{("BODY", ("HEADER.FIELDS", ("SUBJECT",)))}. Values are entirely dependent on the key with which they are associated, but retain the same structured as produced by L{parseNestedParens}. c s4 t | t�r | �d�S t | t�r� fdd�| D �S d S )Nr� c r r= r= )rC �subthing��nativeStringResponser= rA rG u r� zNIMAP4Client._parseFetchPairs.<locals>.nativeStringResponse.<locals>.<listcomp>)rU r r� rV )�thingrZ r= rA r[ q s �z:IMAP4Client._parseFetchPairs.<locals>.nativeStringResponseTs Not enough arguments)� BODYs BODY.PEEKFr� r c S r� r= r5 �rC r� r= r= rA rG � r� z0IMAP4Client._parseFetchPairs.<locals>.<listcomp>c S r� r= r5 r^ r= r= rA rG � r� r; � <� >rt )r� r� r� r rU rV r� r9 rl r r~ r# rd r` ) rZ �fetchResponseListr� � unstructured� responsePartsrg rb � hasSection� valueHead� valueTailr= rZ rA r� K s~ & `� � �� � �� �z IMAP4Client._parseFetchPairsc C s� |\}}i }|D ]-}t |�dkr5|d dkr5| �|d |�}||vr*|d g||< q|| d �|d � qi } i } |�� D ]"\} } | �| d �\} }| �| g g�d �|� | �| i ��| � q>| }i }t| �� �D ]I} | | } t| �� �D ]<}||vr�|dkr�| d || < t t || d ��D ]}|| d | dkr�|| d ||d �= nq�| d= | s�| | = qwqk|r�| � |� |r�| S |S )Nr/ r; r� r r� r� ) r� r rr r� r� r� �updaterV r rl rM )rZ rJ �requestedParts� structuredr� r_ �infor� rx r� � decodedInfo� messageIdr� � structuredMap�unstructuredList� flagChangesr rc r= r= rA �_cbFetch� sJ � ��� zIMAP4Client._cbFetchc C s� d} |du r d} nt |t�rt|�} nd�tt|��} |du r"d} n | r)d| } n|} | r@|dv r@|dur=dd�|� } nd} nd} |du rId} nd ||f } |rSd pTd }| ||r[d p\d| | | | f }|�d �}| �t||dd��}|�| j dd� |S )a^ Retrieve a specific section of one or more messages @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @type headerType: L{str} @param headerType: If specified, must be one of HEADER, HEADER.FIELDS, HEADER.FIELDS.NOT, MIME, or TEXT, and will determine which part of the message is retrieved. For HEADER.FIELDS and HEADER.FIELDS.NOT, C{headerArgs} must be a sequence of header names. For MIME, C{headerNumber} must be specified. @type headerNumber: L{int} or L{int} sequence @param headerNumber: The nested rfc822 index specifying the entity to retrieve. For example, C{1} retrieves the first entity of the message, and C{(2, 1, 3}) retrieves the 3rd entity inside the first entity inside the second entity of the message. @type headerArgs: A sequence of L{str} @param headerArgs: If C{headerType} is HEADER.FIELDS, these are the headers to retrieve. If it is HEADER.FIELDS.NOT, these are the headers to exclude from retrieval. @type peek: C{bool} @param peek: If true, cause the server to not set the \Seen flag on this message as a result of this command. @type offset: L{int} @param offset: The number of octets at the beginning of the result to skip. @type length: L{int} @param length: The number of octets to retrieve. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a mapping of message numbers to retrieved data, or whose errback is invoked if there is an error. z%s BODY%s[%s%s%s]%sNr� �.)z HEADER.FIELDSzHEADER.FIELDS.NOTz (%s)r) z ()z<%d.%d>� UID FETCHr� z.PEEKr� �r� r� r= F) rU rd r� r� r r r� r� rC rp )rZ r� r> � headerType� headerNumber� headerArgs�peek�offset�length�fmt�numberr �payload�extrar\ r9 r� r= r= rA � fetchSpecific s2 7 zIMAP4Client.fetchSpecificc K s� t |��d�}|r dp d}d|v r|d= d|d< d|v r#|d= d|d< d |v r.|d = d|d < d d � |D �}|d d�dd � |D �� d }| �t||dd��}|�| jdd � |�� D �d� |S )Nr� rr r� rR T� rfc822.textrT � rfc822.sizerP � rfc822.headerc S r� r= r� r� r= r= rA rG v r� z&IMAP4Client._fetch.<locals>.<listcomp>r, r� c S r� r= �r5 r� r= r= rA rG w r� rm rs r� c S r� r= r� )rC r� r= r= rA rG z r� )r� r r� r� r� rC rp r )rZ r� r? �termsr\ � encodedTermsr9 r� r= r= rA rA e s zIMAP4Client._fetchc C � | � |d|||�S )a Set the flags for one or more messages. This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type flags: Any iterable of L{str} @param flags: The flags to set @type silent: L{bool} @param silent: If true, cause the server to suppress its verbose response. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a list of the server's responses (C{[]} if C{silent} is true) or whose errback is invoked if there is an error. r� ��_store�rZ r� r{ r( r> r= r= rA �setFlags} � zIMAP4Client.setFlagsc C r� )a Add to the set flags for one or more messages. This command is allowed in the Selected state. @type messages: C{MessageSet} or L{str} @param messages: A message sequence set @type flags: Any iterable of L{str} @param flags: The flags to set @type silent: C{bool} @param silent: If true, cause the server to suppress its verbose response. @type uid: C{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a list of the server's responses (C{[]} if C{silent} is true) or whose errback is invoked if there is an error. s +FLAGSr� r� r= r= rA �addFlags� r� zIMAP4Client.addFlagsc C r� )a Remove from the set flags for one or more messages. This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type flags: Any iterable of L{str} @param flags: The flags to set @type silent: L{bool} @param silent: If true, cause the server to suppress its verbose response. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a list of the server's responses (C{[]} if C{silent} is true) or whose errback is invoked if there is an error. s -FLAGSr� r� r= r= rA � removeFlags� r� zIMAP4Client.removeFlagsc C s� t |��d�}dd� |D �}|r|d }|rdpd}d�||dd�|� d f�}| �t||d d ��} d } |s9d } | �| j| d� | S )Nr� c S r� r= r� r� r= r= rA rG � r� z&IMAP4Client._store.<locals>.<listcomp>s .SILENTs UID STORErD r� rl rm rs r� r= )r� T)r� r r� r� r� rC rp ) rZ r� r9 r( r{ r> r� r$ r� r� �expectedr= r= rA r� � s zIMAP4Client._storec C s> t |��d�}|r d}nd}d�|t|�g�}| �t||��S )a� Copy the specified messages to the specified mailbox. This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type mailbox: L{str} @param mailbox: The mailbox to which to copy the messages @type uid: C{bool} @param uid: If true, the C{messages} refers to message UIDs, rather than message sequence numbers. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a true value when the copy is successful, or whose errback is invoked if there is an error. r� s UID COPYrC r� )r� r r� r r� r� )rZ r� r" r> r9 r� r= r= rA r� � s zIMAP4Client.copyc C rG �z Override meNr= rG r= r= rA rI � r� zIMAP4Client.modeChangedc C rG r� r= )rZ rK r= r= rA rM � r� zIMAP4Client.flagsChangedc C rG r� r= rN r= r= rA rQ r� zIMAP4Client.newMessagesrm �r; )r= NrU )r NNNNNN)r; r )ir� r� r� r� r r� r� r� r r r r� r� r� � STATUS_CODESrd r. r� r] r� r" r� r r r$ r r� r� r� r6 r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r� r� r r r rV r r r& r- r( rl r0 r3 rM r rJ r9 rz r: rC rE rG rI rL rM rO rQ rS rU rV rW rX r� rp r~ rA r� r� r� r� r� rI rM rQ r= r= r= rA r� p s� * 3 ). 9# � # 0 - � Z r� c C s6 t � }| �d�}|D ]�}d|v rl|�dd�\}}zH|dkr d}nt|�}|dkr+d}nt|�}|| u r<du r=t|�� |durE|dksM|durQ|dkrQt|��|pT|}|pX|}|�||� W q tyk t|��w z|dkrtd}nt|�}|dur�|dkr�t|��W n ty� t|��w |�|p�|� q |S )a� Parse a message set search key into a C{MessageSet}. @type s: L{bytes} @param s: A string description of an id list, for example "1:3, 4:*" @type lastMessageId: L{int} @param lastMessageId: The last message sequence id or UID, depending on whether we are parsing the list in UID or sequence id context. The caller should pass in the correct value. @rtype: C{MessageSet} @return: A C{MessageSet} that contains the ids defined in the list � ,� :r; r� Nr )rJ r3 rd r rX r` rr )r� rs rp r� r� rd re r= r= rA rt sF � �� �rt )�ALL�ANSWERED�DELETED�DRAFT�FLAGGED�NEW�OLDr� �SEEN� UNANSWERED� UNDELETED�UNDRAFT� UNFLAGGEDr� )�LARGER�SMALLER�UIDc K s: g }|� � }| r t|�}|D ]z}|| }|�� }|tv r$|r$|�|� q|dkr9|�|t|d �t|d �g� q|dksA|dkrOt�d|�}|�||g� q|t vrpt |t �r[d}n t |t�rcd}nd}|�|||f g� qt |t �r�|�|d |f g� q|�||� g� qt |�dkr�d d �|� d S d �|�S ) a Create a query string Among the accepted keywords are:: all : If set to a true value, search all messages in the current mailbox answered : If set to a true value, search messages flagged with \Answered bcc : A substring to search the BCC header field for before : Search messages with an internal date before this value. The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. body : A substring to search the body of the messages for cc : A substring to search the CC header field for deleted : If set to a true value, search messages flagged with \Deleted draft : If set to a true value, search messages flagged with \Draft flagged : If set to a true value, search messages flagged with \Flagged from : A substring to search the From header field for header : A two-tuple of a header name and substring to search for in that header keyword : Search for messages with the given keyword set larger : Search for messages larger than this number of octets messages : Search only the given message sequence set. new : If set to a true value, search messages flagged with \Recent but not \Seen old : If set to a true value, search messages not flagged with \Recent on : Search messages with an internal date which is on this date. The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. recent : If set to a true value, search for messages flagged with \Recent seen : If set to a true value, search for messages flagged with \Seen sentbefore : Search for messages with an RFC822 'Date' header before this date. The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. senton : Search for messages with an RFC822 'Date' header which is on this date The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. sentsince : Search for messages with an RFC822 'Date' header which is after this date. The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. since : Search for messages with an internal date that is after this date.. The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. smaller : Search for messages smaller than this number of octets subject : A substring to search the 'subject' header for text : A substring to search the entire message for to : A substring to search the 'to' header for uid : Search only the messages in the given message set unanswered : If set to a true value, search for messages not flagged with \Answered undeleted : If set to a true value, search for messages not flagged with \Deleted undraft : If set to a true value, search for messages not flagged with \Draft unflagged : If set to a true value, search for messages not flagged with \Flagged unkeyword : Search for messages without the given keyword set unseen : If set to a true value, search for messages not flagged with \Seen @type sorted: C{bool} @param sorted: If true, the output will be sorted, alphabetically. The standard does not require it, but it makes testing this function easier. The default is zero, and this should be acceptable for any application. @rtype: L{str} @return: The formatted query string �HEADERr r; �KEYWORD� UNKEYWORDr� z"%s"z"%d"z%dr, r) �))r �_sortedr5 � _SIMPLE_BOOLrl rr r� � _nonAtomREr � _NO_QUOTESrU rJ rd r� r� )rh �kwargr9 r r* r� rz r= r= rA �QueryU s6 n " r� c G sJ t | �dk r t| ��t | �dkrd| S d| d � dt| dd� � � d�S ) z0 The disjunction of two or more queries r� z (OR %s %s)z(OR r r) r; Nr� )r� r �Or)r� r= r= rA r� � s "r� c C s d| � d�S )zThe negation of a queryz(NOT r� r= )rr r= r= rA �Not� s r� c C sF | � dd�} |d u r| � dd�} n | � ddt�|� �} t�| tj�S )Nr� z(?:.*?)�%z(?:(?:[^%s])*?))�replacerV rX rW �I)r r r= r= rA �wildcardToRegexp� s r� c C st | � � } g }g }d }}td| �}td| �}td| �}td| �}tt| ��D ]t\} } | |krV| rD| | d | � |krD|�� |�|� q&|sId}q&d}|�|�|�� g }q&|sl|sl| |tj� d� vrld}|�| � q&|r�|s�| tj� d�v r�|�|�} | |kr�|�d � n|�| � g }d}q&|s�|r�|�| � q&|r�t | ��|r�|�|�} | |kr�|�d � |S |�| � |S ) a� Split a string into whitespace delimited tokens Tokens that would otherwise be separated but are surrounded by " remain as a single token. Any token that is not quoted and is equal to "NIL" is tokenized as L{None}. @type s: L{bytes} @param s: The string to be split @rtype: L{list} of L{bytes} @return: A list of the resulting tokens @raise MismatchedQuoting: Raised if an odd number of quotes are present Fr �\r� �NILr; Tr� N) rc r7 ra r8 r% rl r� �string� whitespacer r ) r� rJ �word�inQuote�inWord�qu�escr �nilrc r� �wr= r= rA � splitQuoted sX �� � �r� c C sz g }|| d �}| d g}| dd � D ] }||�}||kr,|� || |�� |g}|}q|�|� q|� || |�� |S �Nr r; )rr rl )�sequence� predicate� transformersrJ r' �tmpr. r� r= r= rA �splitOnA s r� c C s� g }d}dd� }dd� dd� d�}t | �D ]*\}}t|t�r9|dur1|�t| ||� ||�� d}|�t|�� q|du r?|}q|durQ|�t| |d� ||�� |S )a{ Turns a list of length-one strings and lists into a list of longer strings and lists. For example, ['a', 'b', ['c', 'd']] is returned as ['ab', ['cd']] @type results: L{list} of L{bytes} and L{list} @param results: The list to be collapsed @rtype: L{list} of L{bytes} and L{list} @return: A new list which is the collapsed form of C{results} Nc S s t | t�S rm )rU r �r. r= r= rA rP a s z!collapseStrings.<locals>.<lambda>c S s t d�| ��S rT )r� r� r� r= r= rA rP c s c S s d� dd� | D ��gS )Nr� c S s g | ]}|d �qS rU r= ra r= r= rA rG d r� z5collapseStrings.<locals>.<lambda>.<locals>.<listcomp>)r� r� r= r= rA rP d r� )r r; )ra rU rV rr r� rl �collapseStrings)r� r� �begun�pred�tranrc r� r= r= rA r� Q s$ � �r� c C s� | � � } d}g g}z�d}t| �}||k r�| ||d � }|rG|dkr4|d �| ||d � � |d7 }q|dkr;| }|d �|� |d7 }n}|dkrZ|d �|� | }|d7 }nj|r�|dkr�| �d|�}|dkrntd ��t| |d |� �}|d �| |d |d | � f� |d | }n3|d ks�|d kr�|�g � |d7 }n!|d ks�|dkr�|d �|�� � |d7 }n |d �|� |d7 }||k sW n ty� t| ��w t|�dkr�t| ��t |d �S )ak Parse an s-exp-like string into a more useful data structure. @type s: L{bytes} @param s: The s-exp-like string to parse @rtype: L{list} of L{bytes} and L{list} @return: A list containing the tokens present in the input. @raise MismatchedNesting: Raised if the number or placement of opening or closing parenthesis is invalid. r r; ry rt r� r^ r_ r` ra r/ rl r� rm r� ���) rc r� rl ro r` rd r% � IndexErrorr r� ) r� � handleLiteralr� � contentStackrc r� r� r\ � literalSizer= r= rA r� s sX $ �� � r� c C s8 t d| �}t d| �}|| �||| ��||| � | S )Nr r� )r7 r� )r� r� r� r= r= rA r� � s $r� r� r� c C s dt | �| f S )Ns {%d} %b)r� �r� r= r= rA r� � r� r� c @ s" e Zd Zdd� Zdefdd�ZdS )r c C � || _ d S rm )rb )rZ rb r= r= rA r] � � zDontQuoteMe.__init__r� c C s t | j�S rm )r� rb r^ r= r= rA r� � r� zDontQuoteMe.__str__N)r� r� r� r] r� r� r= r= r= rA r � s r s (){ %*"c C sB | dkrdS t | �D ]}|dk s|dkr dS |tv r dS q dS )Nr� r; r� � r )r8 �_ATOM_SPECIALS)r� r� r= r= rA � _needsQuote� s �r� c C s: t | t�r| S z| �d�W S ty t�� t| ��w )Nr� )rU r� r� r� r4 r r �r� r= r= rA r� � s �r� c C s2 t | t�s | �d�} | �d�} t| �rt| �S | S )Nr� r� )rU r� r� r r� r� r� r= r= rA r � s r c C s0 t d| �}t d| �}|| v p|| v pt| �dkS )N� � i� )r7 r� )r� �cr�lfr= r= rA � _needsLiteral� s r� c C s g }| D ]�}t |t�r|�d�}|du r |�ddg� qt |t�r-|�dtt|��g� qt |t�r;|�d|jg� qt |t�r^t |�rT|�ddt |�f t j |g� q|�dt |�g� qt|d�rw|�� }|�ddt |�f t j |g� q|�ddt|� d g� qd �|d d� �S ) a� Turn a nested list structure into an s-exp-like string. Strings in C{items} will be sent as literals if they contain CR or LF, otherwise they will be quoted. References to None in C{items} will be translated to the atom NIL. Objects with a 'read' attribute will have it called on them with no arguments and the returned string will be inserted into the output as a literal. Integers will be converted to strings and inserted into the output unquoted. Instances of C{DontQuoteMe} will be converted to strings and inserted into the output unquoted. This function used to be much nicer, and only quote things that really needed to be quoted (and C{DontQuoteMe} did not exist), however, many broken IMAP4 clients were unable to deal with this level of sophistication, forcing the current behavior to be adopted for practical reasons. @type items: Any iterable @rtype: L{str} r� Nr� s NILs {%d}r� rl rm r� r; )rU r� r rr rd r: r rb r r� r� r� � delimiterr� �hasattrr� r� r� )r� �piecesrc r� r= r= rA r� � s& r� c @ s� e Zd ZdZdZdZdd� Zdd� Zd dd�Zd d � Z d d � Z d dd�Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zd d � ZdS ) � MemoryAccountWithoutNamespacesNr c C s || _ i | _g | _d S rm )r� r � subscriptionsr r= r= rA r] r� z'MemoryAccountWithoutNamespaces.__init__c C s | j }| j d7 _ |S rM )�top_id)rZ rx r= r= rA � allocateID# s z)MemoryAccountWithoutNamespaces.allocateIDc C sD t |�� �}|| jv rt|��|d u r| �|| �� �}|| j|< dS rM )r� r5 r r � _emptyMailboxr� )rZ r� r r= r= rA � addMailbox+ s z)MemoryAccountWithoutNamespaces.addMailboxc C s� dd� |� d�D �}tdt|��D ]}z| �d�|d |� �� W q ty* Y qw z | �d�|�� W dS tyH |�d�sEY dS Y dS w )Nc S s g | ]}|r|�qS r= r= )rC �pathr= r= rA rG 5 r� z9MemoryAccountWithoutNamespaces.create.<locals>.<listcomp>�/r; FT)r3 rl r� r� r� r r# )rZ �pathspec�paths�accumr= r= rA r� 4 s � � ��z%MemoryAccountWithoutNamespaces.createc C s t �rm )�NotImplementedError)rZ r� rx r= r= rA r� B � z,MemoryAccountWithoutNamespaces._emptyMailboxr; c C s | j �t|�� ��S rm )r r� r� r5 )rZ r� � readwriter= r= rA r� E s z%MemoryAccountWithoutNamespaces.selectc C s� t |�� �}| j�|�}|std��d|�� v r-| j�� D ]}||kr,|�|�r,td��q |�� t | � |��dkrBtd|� d���| j|= d S )NzNo such mailboxz \Noselectz<Hierarchically inferior mailboxes exist and \Noselect is setr; zName "z!" has inferior hierarchical names) r� r5 r r� r r� r r~ �destroyr� �_inferiorNames)rZ r� r �othersr= r= rA r� H s �� z%MemoryAccountWithoutNamespaces.deletec s� t ��� ��t � �� �� �| jvrt���| ���}� �fdd�|D �}|D ] \}}|| jv r3t|��q&|D ]\}}| j| | j|< | j|= q6d S )Nc s g | ] }||� �� d �f�qS r� )r� )rC �o�r r r= rA rG f � z9MemoryAccountWithoutNamespaces.rename.<locals>.<listcomp>)r� r5 r r" r� r )rZ r r � inferiors�old�newr= r� rA r _ s � �z%MemoryAccountWithoutNamespaces.renamec C s, g }| j �� D ] }|�|�r|�|� q|S rm )r r r~ rl )rZ r� r� �infnamer= r= rA r� p s �z-MemoryAccountWithoutNamespaces._inferiorNamesc C s t |�� �| jv S rm )r� r5 r� r r= r= rA r w r� z+MemoryAccountWithoutNamespaces.isSubscribedc C s* t |�� �}|| jvr| j�|� d S d S rm )r� r5 r� rl r r= r= rA r z s �z(MemoryAccountWithoutNamespaces.subscribec C s4 t |�� �}|| jvrtd|� ���| j�|� d S )Nz Not currently subscribed to )r� r5 r� r �remover r= r= rA r s z*MemoryAccountWithoutNamespaces.unsubscribec s0 � � t|�� ��}t�d��� �fdd�|D �S )Nr� c s$ g | ]}�� |�r|� j| f�qS r= )rh r ra �rZ r r= rA rG � s $ z@MemoryAccountWithoutNamespaces.listMailboxes.<locals>.<listcomp>)r� r� r5 r� )rZ r r r= r� rA r � s z,MemoryAccountWithoutNamespaces.listMailboxesrm r� )r� r� r� r r� r� r] r� r� r� r� r� r� r r� r r r r r= r= r= rA r� s" r� c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) � MemoryAccountc C s ddggS )Nr� � /r= r^ r= r= rA r� � r� z#MemoryAccount.getPersonalNamespacesc C � d S rm r= r^ r= r= rA r� � r� z!MemoryAccount.getSharedNamespacesc C r� rm r= r^ r= r= rA �getOtherNamespaces� r� z MemoryAccount.getOtherNamespacesc C r� rm r= r^ r= r= rA �getUserNamespaces� s z MemoryAccount.getUserNamespacesN)r� r� r� r� r� r� r� r= r= r= rA r� � s r� r� r� � getUIDNextr� �getUnseenCountr% c C s* i }|D ]}t | t|�� �� ||< q|S rm )r) �_statusRequestDictr5 )r r� �rr r= r= rA �statusRequestHelper� s r c C s* | d u rdgS t j�| g�} dd� | D �S )NrR c S s& g | ]\}}|p d d g|� d� �qS )N�@�r3 )rC r? �addressr= r= rA rG � s & z parseAddr.<locals>.<listcomp>)r� r� � getaddresses)�addrr= r= rA � parseAddr� s �r c C s� | � d�}|�d�}|�d�}|�d�}|�d|�}|�d|�}|�d�}|�d�}|�d �} |�d �} |�d �} ||t|�t|�|oFt|�|oKt|�|oPt|�| oUt| �| | f S ) NTr� r� r� �senderzreply-tor� r� r� z in-reply-toz message-id)r� r� r ) r� �headersr� r� �from_r �reply_tor� r� r� � in_reply_to�midr= r= rA r� � s, �r� c C s d}| � � D ]}|d7 }q|S r� )r� )r� r� rA r= r= rA � getLineCount� s r c C s2 | d | d krdkrn | S | dd� S | S )Nr rt r r; r= r� r= r= rA �unquote� s �r c C s� d}| � dd��dd�}d�|�� �}|rA|�d�}|d �dd�}t|�dkr/|d }d}n|\}}td d � |dd� D ��}nd }}|||fS ) zJ Return a two-tuple of the main and subtype of the given message. NF� content-typer� �;r r� r; c s s$ � | ] }|� � �� �d d�V qdS )�=r; N)rc r� r3 r* r= r= rA r� � s �" z"_getContentType.<locals>.<genexpr>)r� r� r� � splitlinesr3 r� �dict)r� �attrs�mm�mimetyper �major�minorr= r= rA �_getContentType� s r c C s� t | �\}}}|dur|�� }|dur|�� }|dkr!t| ||�S ||fdkr.t| |||�S |dkr9t| |||�S t| |||�S )aE Construct an appropriate type of message structure object for the given message object. @param message: A L{IMessagePart} provider @return: A L{_MessageStructure} instance of the most specific type available for the given message, determined by inspecting the MIME type of the message. N� multipart)r� rN r5 )r r� �_MultipartMessageStructure�_RFC822MessageStructure�_TextMessageStructure�_SinglepartMessageStructure)r� �main�subtyper r= r= rA �_getMessageStructure� s r! c @ r� ) �_MessageStructurez� L{_MessageStructure} is a helper base class for message structure classes representing the structure of particular kinds of messages, as defined by their MIME type. c C s || _ || _dS )z� @param message: An L{IMessagePart} provider which this structure object reports on. @param attrs: A C{dict} giving the parameters of the I{Content-Type} header of the message. N)r� r )rZ r� r r= r= rA r] s z_MessageStructure.__init__c C sh |r2|� d�}t|�dkr|d �� df}|S t|�dkr0dd� |dd� D �}|d �� |g}|S dS )a Parse a I{Content-Disposition} header into a two-sequence of the disposition and a flattened list of its parameters. @return: L{None} if there is no disposition header value, a L{list} with two elements otherwise. z; r; r Nc S s" g | ] }|� d d�D ]}|�q qS �r r; r )rC �paramrO r= r= rA rG 0 s " z2_MessageStructure._disposition.<locals>.<listcomp>)r3 r� r� )rZ �disp�paramsr= r= rA � _disposition" s �z _MessageStructure._dispositionc C s0 | j rdd� | j �� D �}dd� t|�D �S dS )z� @return: The I{Content-Type} parameters, unquoted, as a flat list with each Nth element giving a parameter name and N+1th element giving the corresponding parameter value. c S s g | ] \}}|t |�f�qS r= )r �rC r* r� r= r= rA rG = r+ z4_MessageStructure._unquotedAttrs.<locals>.<listcomp>c S s g | ] }|D ]}|�qqS r= r= )rC rO �yr= r= rA rG > � N)r r� rh )rZ �unquotedr= r= rA �_unquotedAttrs6 s z _MessageStructure._unquotedAttrsN)r� r� r� r� r] r' r, r= r= r= rA r" s r" c @ s8 e Zd ZdZg d�Zdd� Zdd� Zdd� Zd d � Zd S ) r zn L{_SinglepartMessageStructure} represents the message structure of a non-I{multipart/*} message. )� content-id�content-description�content-transfer-encodingc C s$ t �| ||� || _|| _|| _dS )a� @param message: An L{IMessagePart} provider which this structure object reports on. @param main: A L{str} giving the main MIME type of the message (for example, C{"text"}). @param subtype: A L{str} giving the MIME subtype of the message (for example, C{"plain"}). @param attrs: A C{dict} giving the parameters of the I{Content-Type} header of the message. N)r" r] r r r )rZ r� r r r r= r= rA r] J s z$_SinglepartMessageStructure.__init__c C sZ | j jdg| j�R � }| j �� }| j| j}}| �� }||||�d�|�d�|�d�|gS )zN Return a list of the basic fields for a single-part message. Fr- r. r/ )r� r� �_HEADERSr� r r r, r� )rZ r r� r r � unquotedAttrsr= r= rA � _basicFields] s �z(_SinglepartMessageStructure._basicFieldsc C s | � � }|r |�| �� � |S )z� Construct and return a list of the basic and extended fields for a single-part message. The list suitable to be encoded into a BODY or BODYSTRUCTURE response. )r2 rr � _extended�rZ �extendedrJ r= r= rA r u s z"_SinglepartMessageStructure.encodec C sb g }| j �ddddd�}|�|�d�� |�| �|�d��� |�|�d�� |�|�d�� |S )aw The extension data of a non-multipart body part are in the following order: 1. body MD5 A string giving the body MD5 value as defined in [MD5]. 2. body disposition A parenthesized list with the same content and function as the body disposition for a multipart body part. 3. body language A string or parenthesized list giving the body language value as defined in [LANGUAGE-TAGS]. 4. body location A string list giving the body content URI as defined in [LOCATION]. Fz content-md5�content-disposition�content-language�content-location)r� r� rl r� r' �rZ rJ r r= r= rA r3 � s �z%_SinglepartMessageStructure._extendedN) r� r� r� r� r0 r] r2 r r3 r= r= r= rA r B s r c @ � e Zd ZdZdd� ZdS )r z_ L{_TextMessageStructure} represents the message structure of a I{text/*} message. c C s0 t �| �}|�t| j�� |r|�| �� � |S )a A body type of type TEXT contains, immediately after the basic fields, the size of the body in text lines. Note that this size is the size in its content transfer encoding and not the resulting size after any decoding. )r r2 rl r r� rr r3 r4 r= r= rA r � s z _TextMessageStructure.encodeN�r� r� r� r� r r= r= r= rA r � � r c @ r: )r zi L{_RFC822MessageStructure} represents the message structure of a I{message/rfc822} message. c C sH t �| |�}| j�d�}|�t|�� |�t|d�� |�t|�� |S )z� A body type of type MESSAGE and subtype RFC822 contains, immediately after the basic fields, the envelope structure, body structure, and size in text lines of the encapsulated message. r F)r r r� r rl r� r r )rZ r5 rJ � containedr= r= rA r � s z _RFC822MessageStructure.encodeNr; r= r= r= rA r � r< r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) r zi L{_MultipartMessageStructure} represents the message structure of a I{multipart/*} message. c C s t �| ||� || _dS )aR @param message: An L{IMessagePart} provider which this structure object reports on. @param subtype: A L{str} giving the MIME subtype of the message (for example, C{"plain"}). @param attrs: A C{dict} giving the parameters of the I{Content-Type} header of the message. N)r" r] r )rZ r� r r r= r= rA r] � s z#_MultipartMessageStructure.__init__c c s> � d} z| j �|�}W n ty Y dS w |V |d7 }q)zR Return an iterator over all of the sub-messages of this message. r Tr; N)r� r r� )rZ rc r r= r= rA � _getParts� s � ��z$_MultipartMessageStructure._getPartsc s8 � fdd�| � � D �}|�| j� � r|�| �� � |S )zW Encode each sub-message and added the additional I{multipart} fields. c s g | ] }t |��� ��qS r= �r! r r< �r5 r= rA rG � r* z5_MultipartMessageStructure.encode.<locals>.<listcomp>)r> rl r rr r3 r4 r= r@ rA r � s z!_MultipartMessageStructure.encodec C sb g }| j �dddd�}|�| �� � |�| �|�d��� |�|�dd�� |�|�dd�� |S )af The extension data of a multipart body part are in the following order: 1. body parameter parenthesized list A parenthesized list of attribute/value pairs [e.g., ("foo" "bar" "baz" "rag") where "bar" is the value of "foo", and "rag" is the value of "baz"] as defined in [MIME-IMB]. 2. body disposition A parenthesized list, consisting of a disposition type string, followed by a parenthesized list of disposition attribute/value pairs as defined in [DISPOSITION]. 3. body language A string or parenthesized list giving the body language value as defined in [LANGUAGE-TAGS]. 4. body location A string list giving the body content URI as defined in [LOCATION]. Fr7 r8 r6 N)r� r� rl r, r' r� r9 r= r= rA r3 � s �z$_MultipartMessageStructure._extendedN)r� r� r� r� r] r> r r3 r= r= r= rA r � s r Fc C s t | ��|�S )ar RFC 3501, 7.4.2, BODYSTRUCTURE:: A parenthesized list that describes the [MIME-IMB] body structure of a message. This is computed by the server by parsing the [MIME-IMB] header fields, defaulting various fields as necessary. For example, a simple text message of 48 lines and 2279 octets can have a body structure of: ("TEXT" "PLAIN" ("CHARSET" "US-ASCII") NIL NIL "7BIT" 2279 48) This is represented as:: ["TEXT", "PLAIN", ["CHARSET", "US-ASCII"], None, None, "7BIT", 2279, 48] These basic fields are documented in the RFC as: 1. body type A string giving the content media type name as defined in [MIME-IMB]. 2. body subtype A string giving the content subtype name as defined in [MIME-IMB]. 3. body parameter parenthesized list A parenthesized list of attribute/value pairs [e.g., ("foo" "bar" "baz" "rag") where "bar" is the value of "foo" and "rag" is the value of "baz"] as defined in [MIME-IMB]. 4. body id A string giving the content id as defined in [MIME-IMB]. 5. body description A string giving the content description as defined in [MIME-IMB]. 6. body encoding A string giving the content transfer encoding as defined in [MIME-IMB]. 7. body size A number giving the size of the body in octets. Note that this size is the size in its transfer encoding and not the resulting size after any decoding. Put another way, the body structure is a list of seven elements. The semantics of the elements of this list are: 1. Byte string giving the major MIME type 2. Byte string giving the minor MIME type 3. A list giving the Content-Type parameters of the message 4. A byte string giving the content identifier for the message part, or None if it has no content identifier. 5. A byte string giving the content description for the message part, or None if it has no content description. 6. A byte string giving the Content-Encoding of the message body 7. An integer giving the number of octets in the message body The RFC goes on:: Multiple parts are indicated by parenthesis nesting. Instead of a body type as the first element of the parenthesized list, there is a sequence of one or more nested body structures. The second element of the parenthesized list is the multipart subtype (mixed, digest, parallel, alternative, etc.). For example, a two part message consisting of a text and a BASE64-encoded text attachment can have a body structure of: (("TEXT" "PLAIN" ("CHARSET" "US-ASCII") NIL NIL "7BIT" 1152 23)("TEXT" "PLAIN" ("CHARSET" "US-ASCII" "NAME" "cc.diff") "<960723163407.20117h@cac.washington.edu>" "Compiler diff" "BASE64" 4554 73) "MIXED") This is represented as:: [["TEXT", "PLAIN", ["CHARSET", "US-ASCII"], None, None, "7BIT", 1152, 23], ["TEXT", "PLAIN", ["CHARSET", "US-ASCII", "NAME", "cc.diff"], "<960723163407.20117h@cac.washington.edu>", "Compiler diff", "BASE64", 4554, 73], "MIXED"] In other words, a list of N + 1 elements, where N is the number of parts in the message. The first N elements are structures as defined by the previous section. The last element is the minor MIME subtype of the multipart message. Additionally, the RFC describes extension data:: Extension data follows the multipart subtype. Extension data is never returned with the BODY fetch, but can be returned with a BODYSTRUCTURE fetch. Extension data, if present, MUST be in the defined order. The C{extended} flag controls whether extension data might be returned with the normal data. r? )r� r5 r= r= rA r " s ir c C s( dd� | � � D �}d�|�d }t|�S )Nc S s, g | ]\}}d � |�� d� |�� �f��qS )z: � )r� �titler r( r= r= rA rG � s ��z"_formatHeaders.<locals>.<listcomp>rA )r� r� r: )r r� r= r= rA r� � s �r� c c s4 � d}z | � |�V |d7 }q ty Y d S w )Nr Tr; )r r� )rj rc r= r= rA �subparts� s � � �rC c s2 ddl m� t�� � � ���fdd���d� � S )a� Consume an interator at most a single iteration per reactor iteration. If the iterator produces a Deferred, the next iteration will not occur until the Deferred fires, otherwise the next iteration will be taken in the next reactor iteration. @rtype: C{Deferred} @return: A deferred which fires (with None) when the iterator is exhausted or whose errback is called if there is an exception. r ri c sr zt ��}W n ty � �| � Y d S ty" � �� Y d S w t|tj�r0|��� d S �� d�|� d S r� ) r� r� r� r� r� rU r rS rC rp )r_ r� �r� �gorc rj r= rA rE � s � z iterateInReactor.<locals>.goN)ro rj r rS )rc r= rD rA r� � s r� c @ s4 e Zd ZdZeej�Zd dd�Zdd� Z dd� Z dS ) r � Nc C s< || _ |du r t�� }|| _|du rt}|| _| jj| _dS )a Produce this message. @param msg: The message I am to produce. @type msg: L{IMessage} @param buffer: A buffer to hold the message in. If None, I will use a L{tempfile.TemporaryFile}. @type buffer: file-like N)r� r� r� r= r� r r� )rZ r� r= r r= r= rA r] � s zMessageProducer.__init__c C s || _ | �| �� �S rm )�consumerr �_produce)rZ rG r= r= rA r � s z MessageProducer.beginProducingc # s� � � j �d�}d }� j �� rZ|�d�}dd� |�d�dd � D �}dd� |D �}|�d �}|d u rFd � �� j� �}|d d |� d �7 < n|�d �rV|�d �rV|dd � }t |�}� � t |�� � � d� � j �� r�t � j �D ]}� � d| d � t |� j� j��d �V qp� � d| d � n� j �� } |�� j�}|r�� j� |� d V nnq�� jrɈ j�dd� t� j��� j��� fdd��V d S d S )NTr c S s g | ]}|� d d��qS r# r r* r= r= rA rG � r� z,MessageProducer._produce.<locals>.<listcomp>r r; c S s i | ] \}}|� � �� |�qS r= )r� rc r( r= r= rA r$ � r� z,MessageProducer._produce.<locals>.<dictcomp>�boundaryz----=z ; boundary="r rt r� s --s -- r c s � S rm r= r� r^ r= rA rP r� z*MessageProducer._produce.<locals>.<lambda>)r� r� r r� r3 �_uuid4�hexr~ r# r: r� r� rC r r= r r r� r� � CHUNK_SIZErG r� r rC )rZ r rI r r� r� r- r� r= r^ rA rH � sJ � � � ��zMessageProducer._producer] ) r� r� r� rL � staticmethod�uuid�uuid4rJ r] r rH r= r= r= rA r � s r c @ sz e Zd ZG dd� d�ZG dd� d�ZG dd� d�ZG dd� d�ZG d d � d �ZG d d � d �ZG d d� d�Z G dd� d�Z G dd� d�Z G dd� d�Z G dd� d�Z G dd� d�ZG dd� d�ZdZd efd efd efd efd efd!efd"e fd#e fd$e fg Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Ze� d7�Z d8d9� Z d:d;� Z d<d=� Z d>d?� Z!d@dA� Z"dS )Brv c @ r: )z_FetchParser.EnveloperH c C rG )NrH r= r^ r= r= rA rP r� z _FetchParser.Envelope.<lambda>N�r� r� r� r r� r= r= r= rA �Envelope s rQ c @ r: )z_FetchParser.Flagsr{ c C rG )Nr{ r= r^ r= r= rA rP r� z_FetchParser.Flags.<lambda>NrP r= r= r= rA �Flags � rR c @ r: )z_FetchParser.InternalDaterF c C rG )NrF r= r^ r= r= rA rP r� z"_FetchParser.InternalDate.<lambda>NrP r= r= r= rA � InternalDate rS rT c @ r: )z_FetchParser.RFC822HeaderrP c C rG )Nr� r= r^ r= r= rA rP " r� z"_FetchParser.RFC822Header.<lambda>NrP r= r= r= rA � RFC822Header rS rU c @ r: )z_FetchParser.RFC822TextrR c C rG )Nr r= r^ r= r= rA rP & r� z _FetchParser.RFC822Text.<lambda>NrP r= r= r= rA � RFC822Text$ rS rV c @ r: )z_FetchParser.RFC822SizerT c C rG )Nr� r= r^ r= r= rA rP * r� z _FetchParser.RFC822Size.<lambda>NrP r= r= r= rA � RFC822Size( rS rW c @ r: )z_FetchParser.RFC822rN c C rG )NrN r= r^ r= r= rA rP . r� z _FetchParser.RFC822.<lambda>NrP r= r= r= rA �RFC822, rS rX c @ r: )z_FetchParser.UIDr> c C rG )Nr> r= r^ r= r= rA rP 2 r� z_FetchParser.UID.<lambda>NrP r= r= r= rA r� 0 rS r� c @ sL e Zd ZdZdZdZdZdZdZdZ dZ dZ de fdd�Z defdd �ZdS ) z_FetchParser.Bodyr� FNr= r� c C � | � � �d�S �Nr� �r r� r^ r= r= rA r� ? r z_FetchParser.Body.__str__c C s� d}d}d}| j rd�dd� | j D ��}d}| jr,|d| | t| j��d� d 7 }n'| jr:|d| | d 7 }n| jrH|d| | d 7 }n | jrS|d| d 7 }| jd urb|d | j| j f 7 }|S ) Nr] r� � .c S s g | ] }t |d ��d��qS )r; r� )r� r r* r= r= rA rG G r� z/_FetchParser.Body.__bytes__.<locals>.<listcomp>r� r� r� s TEXT]s MIME]s <%d.%d>) r r� r r� r r5 r r � partialBegin� partialLength)rZ �baser � separatorr= r= rA r B s& � z_FetchParser.Body.__bytes__)r� r� r� r rw r r r5 r r r] r^ r� r� r r r= r= r= rA �Body4 s ra c @ r: )z_FetchParser.BodyStructurerK c C rG )NrK r= r^ r= r= rA rP [ r� z#_FetchParser.BodyStructure.<lambda>NrP r= r= r= rA � BodyStructureY rS rb c @ s4 e Zd ZdZdZdZdefdd�Zdefdd�Z dS )z_FetchParser.HeaderFNr� c C rY rZ r[ r^ r= r= rA r� c r z_FetchParser.Header.__str__c C s� d}| j r4|d7 }| jr|d7 }g }| j D ]}|�� }t|�r#t|�}|�|� q|dd�|� d 7 }| jrFd�dd � | jD ��d | }|S ) Ns HEADERs .FIELDSs .NOTr, r� rm r\ c S s g | ]}|d � � �qS r� )r r* r= r= rA rG v r� z1_FetchParser.Header.__bytes__.<locals>.<listcomp>)r r rB r� r� rl r� r )rZ r_ r r- r= r= rA r f s z _FetchParser.Header.__bytes__) r� r� r� r r r r� r� r r r= r= r= rA �Header^ s rc c @ � e Zd ZdS )z_FetchParser.TextN�r� r� r� r= r= r= rA �Texty � rf c @ rd )z_FetchParser.MIMENre r= r= r= rA �MIME| rg rh Ns envelopes flagss internaldates rfc822.headers rfc822.texts rfc822.sizes rfc822s uids bodystructurec C s dg| _ g | _d| _d S )N�initialr� )r rJ � remainingr^ r= r= rA r] � s z_FetchParser.__init__c C s� | j | }zB|s | jrB| jstd��| j�� }z t| d| �|�}W n ty0 | j�|� � w ||d � }|s | js W || _ d S W || _ d S || _ w )NzInvalid Argument�state_)rj r r r% r) r� rl )rZ r� r �usedr= r= rA rw � s" � � �z_FetchParser.parseStringc C s� |dkrdS |� � }|�d�r#| j�| �� | �� | �� | �� f� dS |�d�r?| j�| �� | �� | �� | �� | �� f� dS |�d�rU| j�| �� | �� | �� f� dS |�d�rb| j �d � d S | j � d � dS ) Nr� r s allr/ s fullrh s fastrl )� close_paren�maybe_fetch_att� fetch_attr; ro ) r� r~ rJ rr rR rT rW rQ ra r rl )rZ r� r} r= r= rA � state_initial� s> � �� �� z_FetchParser.state_initialc C s |� d�rdS td��)Nrm r; z Missing )�r~ r+ r� r= r= rA �state_close_paren� s z _FetchParser.state_close_parenc C sP |r |dd� � � std��d}tt|��D ]}|||d � � � s% |S q|S )Nr r; z Whitespace expected, none found)�isspacer+ rl r� )rZ r� rc r= r= rA �state_whitespace� s �z _FetchParser.state_whitespacec C s |� d�s | j�d� dS )Nrm )rn ro r� r �r~ r rr r� r= r= rA �state_maybe_fetch_att� s z"_FetchParser.state_maybe_fetch_attc C s� |� � }| jD ]\}}|�|�r | j�|� � t|� S q| �� }|�d�r-d|_d}n|�d�r5d}ntd|� ���|| _ | j � d� |S )Ns body.peekTr� s bodyrh z!Nothing recognized in fetch_att: )�got_body� maybe_partial� maybe_section) r� �_simple_fetch_attr~ rJ rl r� ra rw r+ � pending_bodyr rr )rZ r� r} r� �clsr� rl r= r= rA �state_fetch_att� s � z _FetchParser.state_fetch_attc C s | j �| j� | `dS r� )rJ rl r{ r� r= r= rA �state_got_body� s z_FetchParser.state_got_bodyc C s |� d�sdS | j�d� dS )Nr� r )�section� part_numberr; ru r� r= r= rA �state_maybe_section s z _FetchParser.state_maybe_sections (\d+(?:\.\d+)*)\.?c C sD | j �|�}|d ur dd� |�� d �d�D �| _|�� S g | _dS )Nc S s g | ]}t |�d �qS r� )rd r< r= r= rA rG r� z2_FetchParser.state_part_number.<locals>.<listcomp>r r\ )� _partExprrh �groupsr3 r� r\ )rZ r� rj r= r= rA �state_part_number s z _FetchParser.state_part_numberc C s |� � }d}|�d�rd| j_|d7 }nd|�d�r,| �� }| j_d|_d|_|d7 }nL|�d�r<| �� | j_ |d 7 }n<|�d �rL| � � | j_ |d 7 }n,| �� }|�d �r]d|_|d 7 }n|�d �rg|d7 }nt d|����|| j_| j �d� t| j�| j_d | _|S )Nr r� Tr; s header]r= r� s text]rg s mime]s header.fields.not� s header.fieldsr< z Unhandled section contents: )�finish_section� header_listr� )r� r~ r{ r rc r r r rf r5 rh r r+ r rr r r� r )rZ r� r} rl r~ r= r= rA � state_section s8 z_FetchParser.state_sectionc C s |� d�s td��dS )Nr� zsection must end with ]r; rq r� r= r= rA �state_finish_section9 s z!_FetchParser.state_finish_sectionc C sX |� d�s td��|�d�}|dkrtd��|d|� �� }dd� |D �| jj_|d S ) Nrl z Header list must begin with (rm rt zHeader list must end with )r; c S r� r= r� )rC r~ r= r= rA rG F r� z2_FetchParser.state_header_list.<locals>.<listcomp>)r~ r+ ro r3 r{ r r )rZ r� r\ r r= r= rA �state_header_list> s z _FetchParser.state_header_listc C sz |� d�sdS |�d�}|dkrtd��|d|� }|�dd�}t|�dkr*td ��tt|�\}}|| j_|| j_ |d S ) Nr_ r r` rt zFound < but not >r; r\ r� z>Partial specification did not include two .-delimited integers) r~ ro r+ r3 r� r rd r{ r] r^ )rZ r� r\ rj r� �beginry r= r= rA �state_maybe_partialI s �z _FetchParser.state_maybe_partial)#r� r� r� rQ rR rT rU rV rW rX r� ra rb rc rf rh r� rz r] rw rp rr rt rv r} r~ r� rV rW r� r� r� r� r� r� r= r= r= rA rv sP %� ) % rv c @ sD e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dS )r rF Tc C r� rm r5 )rZ r- r= r= rA r] c r� zFileProducer.__init__c C s. || _ |j| _t�� }| _| j �| d� |S )NF)rG r� �producer rS �_onDone�registerProducer)rZ rG r� r= r= rA r f s zFileProducer.beginProducingc C sx d}| j rd| �� f }d| _ | jsd S || j�| j� }|s5| j�� | j�| � d | _ | _| _d S | � |� d S )Nr� s {%d} F) � firstWrite�_sizer- r� rL rG �unregisterProducerr� r� r� )rZ r� r= r= rA �resumeProducingm s z FileProducer.resumeProducingc C rG )z9 Pause the producer. This does nothing. Nr= r^ r= r= rA �pauseProducing| r� zFileProducer.pauseProducingc C rG )z8 Stop the producer. This does nothing. Nr= r^ r= r= rA � stopProducing� r� zFileProducer.stopProducingc C s8 | j �� }| j �dd� | j �� }| j �|d� || S )Nr r� )r- r/ r� )rZ r� r. r= r= rA r� � s zFileProducer._sizeN) r� r� r� rL r� r] r r� r� r� r� r= r= r= rA r ^ s r c C s� g d�}dddd�}t �d| | �}|std| ����|�� }z!d|�|d �� �d |d < t|d �|d < t|d �|d < W n tyN td| ����w t�|d |d |d d d d dddf �S )N)�jan�feb�mar�apr�may�jun�jul�aug�sep�oct�nov�dec�january�february�march�aprilr� �june�july�august� september�october�november�decemberz+(?P<day>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])z (?P<mon>\w+)z(?P<year>\d\d\d\d))�day�mon�yearz%(day)s-%(mon)s-%(year)szCannot parse time string r; r� � r� r� r rt ) rV rh r` � groupdict�indexr� rd r� � struct_time)r� �months�exprrj r� r= r= rA r� � s" � �(r� r c G s | d S r� r= rN r= r= rA rP � rQ rP c C s | � d�}|dd� �dd�S )N�utf-7r; rt r� r� )r r� �r� �s_utf7r= r= rA �modified_base64� s r� c C s d| � dd� d }|�d�S )Nr� r� r� r� r� )r� r� r� r= r= rA �modified_unbase64� s r� c C s� t � }g }ttttdd���dh }| D ]D}||v r6|r.|dtd�|�� d 7 }|dd�= |�t|�� q|dkrS|rN|dtd�|�� d 7 }|dd�= |d7 }q|�|� q|ri|� dtd�|�� d � t |�t | �fS ) ap Encode the given C{unicode} string using the IMAP4 specific variation of UTF-7. @type s: C{unicode} @param s: The text to encode. @param errors: Policy for handling encoding errors. Currently ignored. @return: L{tuple} of a L{str} giving the encoded bytes and an L{int} giving the number of code units consumed from the input. � � �&� &r� r� Ns &-) � bytearrayr' r �chrrl r� r� rl �ordrr r r� )r� �errorsr� �_in� valid_charsr� r= r= rA �encoder� s$ r� c C s� g }g }t t| �d�} | D ]@}|dkr|s|�d� q |dkr>|r>t|�dkr-|�d� n|�td�|dd� ��� g }q |rF|�|� q |�|�� � q |r^|�td�|dd� ��� d�|�t| �fS ) aw Decode the given L{str} using the IMAP4 specific variation of UTF-7. @type s: L{str} @param s: The bytes to decode. @param errors: Policy for handling decoding errors. Currently ignored. @return: a L{tuple} of a C{unicode} string giving the text which was decoded and an L{int} giving the number of bytes consumed from the input. r� r� r� r; r� r� Nr� )� memory_cast� memoryviewrl r� r� r� r� )r� r� r� r� r� r= r= rA �decoder� s" r� c @ � e Zd Zddd�ZdS )� StreamReader�strictc C � t |�S rm )r� �rZ r� r� r= r= rA r� � zStreamReader.decodeN�r� )r� r� r� r� r= r= r= rA r� � r� c @ r� )� StreamWriterr� c C r� rm )r� r� r= r= rA r r� zStreamWriter.encodeNr� )r� r� r� r r= r= r= rA r� r� r� c C s | � dd�dkr tS d S )N�-rA � imap4_utf_7)r� � _codecInfor� r= r= rA r� s �r� )(r� r� �IMailboxListenerr' r� �IMailboxr0 r � IMailboxInfo�IMessager8 r rY � IMessagePartr r r r r% r! r# r r r r r r r r" r$ r r r r r r� r� r� r� r rm rU r� rS )�r� r� �codecsr� � email.utilsr� ri rV r� r� r� rN �base64r r �ior � itertoolsr �typingr r r �zope.interfacer � twisted.credr �twisted.cred.errorr r ro r r r �twisted.internet.deferr �twisted.mail._credr r r r r �twisted.mail._exceptr r r r r r r r r r r r! r" r# r$ r% �twisted.mail.interfacesr& r� r' r( r r) r� r* r� r+ r� r, r� r- r8 r. r r/ r� r0 r1 rY �twisted.protocolsr2 r3 �twisted.pythonr4 r5 �twisted.python.compatr6 r7 r8 r9 r: r rk rl r3 r� rB rI rJ r� r� r� r� �_SPr �_CTLr� r� �_nativeNonAtomCharsrW r� rY � LineReceiver� TimeoutMixinr� � TimeoutErrorr� r� rt r� r� rh r� r� r� r� r� r� r� r� r� r� r� r r� r� r� r r� r� r� r� r� r r r� r r r r! r" r r r r r r� rC r� r rv r r� r) r� r� r� r� r� r� r� r� � CodecInfor� r� �register�__all__r= r= r= rA �<module> s H8 � & !K % $9 A ": 1r� 2h Ol !F W02 "" PK Mb�Z@`K�� � % mail/__pycache__/smtp.cpython-310.pycnu �[��� o �bt � @ s\ d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZ ddlmZ ddlmZ ddlmZ dd lmZmZmZmZ dd lmZ dd l m Z m Z dd l m Z m!Z!m"Z# dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z6m7Z7 ddl8m9Z9m:Z:m;Z;m<Z= ddl>m?Z?m@Z@ ddlAmBZBmCZC ddlDmEZEmFZFmGZG ddlHmIZI g d�ZJeI�K� r�e�L� �Md�ZNne�O� �Md�ZNeP�QeRdd��ZSdNdd�ZTdd� ZUeU� ZVdd d � fd d �ZWd d!� ZXd"\ZYZZZ[d#Z\G d$d%� d%�Z]G d&d'� d'�Z^G d(d)� d)e?j_e@j`�ZaG d*d+� d+ejb�ZcG d,d-� d-e?jde@j`�ZeG d.d/� d/ee�ZfG d0d1� d1ea�ZgG d2d3� d3�ZhG d4d5� d5ehee�ZiG d6d7� d7ejj�ZkG d8d9� d9e#�Z"ee9�G d:d;� d;��ZlG d<d=� d=ehef�ZmG d>d?� d?ek�Zndd@edddAdAfdBdC�ZoddlpZpdOdDdE�ZqdOdFdG�ZrG dHdI� dIepjs�ZtG dJdK� dKepju�ZvdLdM� Zwep�xew� dS )Pz/ Simple Mail Transfer Protocol implementation. � N)� parseaddr)�BytesIO)�Type)� implementer)�cred)� longversion)�defer�error�protocol�reactor)� _idnaText)� ISSLTransport� ITLSTransport)�CramMD5ClientAuthenticator�LOGINAuthenticator�LOGINCredentials)� AddressError�AUTHDeclinedError�AuthenticationError�AUTHRequiredError�EHLORequiredError�ESMTPClientError�SMTPAddressError� SMTPBadRcpt� SMTPBadSender�SMTPClientError�SMTPConnectError�SMTPDeliveryError� SMTPError�SMTPProtocolError�SMTPServerError�SMTPTimeoutError� SMTPTLSError�TLSRequiredError)�IClientAuthentication�IMessageDelivery�IMessageDeliveryFactory� IMessageSMTP)�basic�policies)�log�util)� iterbytes� nativeString� networkString)�platform)0r r r r r r r r r r r r r r r! �TLSErrorr# r r$ �IMessager% r& r r r �PLAINAuthenticator�Address�User�sendmail� SenderMixin�ESMTP� ESMTPClient� ESMTPSender�ESMTPSenderFactory�SMTP� SMTPClient� SMTPFactory� SMTPSender�SMTPSenderFactory� idGenerator� messageid� quoteaddr� rfc822date�xtextStreamReader�xtextStreamWriter� xtext_codec� xtext_decode� xtext_encode�ascii�� i, � c C s� | s |r t �� } nt �� } |r9| d rt j }nt j }tt|�d�\}}|r1|tt|�| �9 }t|d�\}}nd\}}tdg d�| d | d g d �| d d | d | d | d | d ||f �S )a� Format an RFC-2822 compliant date string. @param timeinfo: (optional) A sequence as returned by C{time.localtime()} or C{time.gmtime()}. Default is now. @param local: (optional) Indicates if the supplied time is local or universal time, or if no time is given, whether now should be local or universal time. Default is local, as suggested (SHOULD) by rfc-2822. @returns: A L{bytes} representing the time and date in RFC-2822 format. � i �< )r r z)%s, %02d %s %04d %02d:%02d:%02d %+03d%02d)�Mon�Tue�Wed�Thu�Fri�Sat�Sun� � ) �Jan�Feb�Mar�Apr�May�Jun�Jul�Aug�Sep�Oct�Nov�DecrK r � � � ) �time� localtime�gmtime�altzone�timezone�divmod�abs�intr. )�timeinfo�local�tz�tzhr�tzmin�tzsec� rt �3/usr/lib/python3/dist-packages/twisted/mail/smtp.pyrC � s: ����rC c c s � d} | V | d7 } q)Nr TrK rt )�irt rt ru r@ � s ��r@ c C s t t�S �N)�next�_genrt rt rt ru �<lambda>� s rz c C sV t �dt �� �}t�� }t�d�}| du rd} nd| } d�|||| |� t� � �� � S )z� Return a globally unique random string in RFC 2822 Message-ID format <datetime.pid.random@host.dom.ain> Optional uniq string will be added to strengthen uniqueness if given. z %Y%m%d%H%M%Si���N� �.z<{}.{}.{}{}.{}@{}>) rf �strftimerh �os�getpid�random� randrange�format�DNSNAME�decode�encode)�uniq�N�datetime�pid�randrt rt ru rA � s ��rA c C sd t | t�r dt| � d S t | t�r| �d�} t| �}|dkr'dt| � d S d|d �d� d S )zq Turn an email address, possibly with realname part etc, into a form suitable for and SMTP envelope. � <� >rI �NNrK )� isinstancer3 �bytesr� r r� )�addr�resrt rt ru rB � s rB )�COMMAND�DATA�AUTHs [-A-Za-z0-9!\#$%&'*+/=?^_`{|}~]c @ sv e Zd ZdZe�de d ej�Ze�e�Z ddd�Z e�d�Z dd � Z d e fd d �Zd efd d�Zd e fdd�ZdS )r3 aF Parse and hold an RFC 2821 address. Source routes are stipped and ignored, UUCP-style bang-paths and %-style routing are not parsed. @type domain: C{bytes} @ivar domain: The domain within which this address resides. @type local: C{bytes} @ivar local: The local ("user") portion of this address. s� ( # A string of (?:"[^"]*" # quoted string |\\. # backslash-escaped characted |sL # atom character )+|.) # or any single characterNc C s� t |t�r|j}t |t�r|j�� | _d S t |t�s!t|��d�}|| _ t t d | j � |���}g }g }|r�|d dkrL|d dkrEtd��|dd� }nv|d dkr�|dd � }|s}|rp|d d krp|dd � }|rp|d d ksb|svtd ��|dd � }nE|r�td ��d g}n;t|d �dkr�| j�|d �s�|d d kr�td|d �d||f����|s�|�|d � n|�|d � |dd � }|s5d �|�| _d �|�| _| jd kr�| jd kr�|d u r�t}|| _d S d S d S )NrI r r� ���r� z Unbalanced <>rK � @� :zMalformed source routez Too many @� � .zParse error at z of )r� r4 �destr3 �__dict__�copyr� �strr� �addrstr�list�filter�tstring�splitr �len�atomre�match�append�joinro �domainr� )�selfr� � defaultDomain�atlro r� rt rt ru �__init__ sT �, � �zAddress.__init__s \\(.)c C s� g }t |t�st|��d�}td| j�|��}|D ],}|d dkr1|d dkr1|�|dd� � qd|v r@|�| j� d|�� q|�|� qd � |�S ) z6 Remove RFC-2821 quotes from address. rI Nr � "r� rK �\s \1r� ) r� r� r� r� r� r� r� r� � dequotebs�subr� )r� r� r� r� �trt rt ru �dequoteJ s zAddress.dequote�returnc C � | � � �d�S �NrI �� __bytes__r� �r� rt rt ru �__str___ � zAddress.__str__c C s" | j s| jrd�| j | jf�S dS )Nr� r� )ro r� r� r� rt rt ru r� b s zAddress.__bytes__c C s d� | j| jjtt| ���S )Nz {}.{}({}))r� � __module__� __class__�__name__�reprr� r� rt rt ru �__repr__h s �zAddress.__repr__rw )r� r� � __qualname__�__doc__�re�compile�atom�Xr� r� r� r� r� r� r� r� r� r� rt rt rt ru r3 � s" ��� 4r3 c @ s< e Zd ZdZdd� Zdd� Zdefdd�Zdefd d �Z d S ) r4 zu Hold information about and SMTP message recipient, including information on where the message came from c C s^ z|j }W n ty d }Y nw t||�| _|| _|| _t|t�r'|| _d S t||�| _d S rw )�host�AttributeErrorr3 r� �helor r� �orig)r� � destinationr� r r� r� rt rt ru r� t s � z User.__init__c C s | j | jd| jd�S )z� Helper for pickle. protocol isn't picklabe, but we want User to be, so skip it in the pickle. N)r� r� r r� )r� r� r� r� rt rt ru � __getstate__� s �zUser.__getstate__r� c C r� r� r� r� rt rt ru r� � r� z User.__str__c C s t | j�S rw )r� r� r� rt rt ru r� � � zUser.__bytes__N) r� r� r� r� r� r� r� r� r� r� rt rt rt ru r4 n s r4 c @ s� e Zd ZdZdZdZdZdZdZdZ dLdd�Z e dd� �Z e j d d� �Z d d � Zd d � Zdd� ZdMdd�Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#e d$ Ze � d%e d& e d' e j e j B �Z e � d(e d& e d' e j e j B �Z!d)d*� Z"dNd-d.�Z#d/d0� Z$d1d2� Z%dOd4d5�Z&d6d7� Z'd8d9� Z(d:d;� Z)d<d=� Z*d>d?� Z+d@dA� Z,e,Z-dBdC� Z.dDdE� Z/dFdG� Z0dHdI� Z1dJdK� Z2dS )Pr; zp SMTP server-side protocol. @ivar host: The hostname of this mail server. @type host: L{bytes} �X NTc C s. t | _d | _d | _g | _|| _|| _t| _d S rw ) r� �mode�_from�_helo�_to�delivery�deliveryFactoryr� r� )r� r� r� rt rt ru r� � s z SMTP.__init__c C s | j S rw )�_hostr� rt rt ru r� � s z SMTP.hostc C s" t |t�s t|��d�}|| _d S r� )r� r� r� r� r� )r� �toSetrt rt ru r� � s c C s$ | j d }| �d|� | j�� d S )Ns' Timeout. Try talking faster next time!i� )r� �sendCode� transport�loseConnection)r� �msgrt rt ru �timeoutConnection� s zSMTP.timeoutConnectionc C s | j d S )Ns NO UCE NO UBE NO RELAY PROBES)r� r� rt rt ru �greeting� r� z SMTP.greetingc C sZ | j �� }z|j}W n ty t|�}Y nw d |f| _| �d| �� � | �| j � d S �N�� ) r� �getPeerr� r� r� r� r� r� � setTimeout�timeout)r� �peerr� rt rt ru �connectionMade� s � zSMTP.connectionMader� c C sf |� � }|dd� }|dd� D ]}| �td|f �| � q| �td|f �|r-|d p.d � dS )z3 Send an SMTP code with a message. r� Nz%3.3d-z%3.3d r r� )� splitlines�sendLiner. )r� �code�message�lines�lastline�linert rt ru r� � s �z SMTP.sendCodec C s | � � t| d| j �|�S )N�state_)� resetTimeout�getattrr� �r� r� rt rt ru � lineReceived� s zSMTP.lineReceivedc C s` |� � }|�d d�}|r*| �|d �p| j}t|�dkr$||d � d S |d� d S | �� d S )NrK r rV r� )�stripr� � lookupMethod� do_UNKNOWNr� �sendSyntaxError)r� r� �parts�methodrt rt ru � state_COMMAND� s zSMTP.state_COMMANDc C � | � dd� d S )N�� s Error: bad syntax�r� r� rt rt ru r� � � zSMTP.sendSyntaxErrorc C s& t |t�s t|�}t| d|�� d�S )z� @param command: The command to get from this class. @type command: L{str} @return: The function which executes this command. �do_N)r� r� r- r� �upper)r� �commandrt rt ru r� � s zSMTP.lookupMethodc C s8 | j tu r| jD ]}|�� qt| _ | `| �dd� d S )Nr� s Line too long)r� r� �_SMTP__messages�connectionLostr� r� )r� r� r� rt rt ru �lineLengthExceeded s zSMTP.lineLengthExceededc C r� )Nr� s Command not implementedr� �r� �restrt rt ru r� r� zSMTP.do_UNKNOWNc C sx | j �� }z|j}W n ty t|�}Y nw t|t�s"|�d�}||f| _d | _ g | _ | � d| jd | d � d S )N�idna� � Hello s , nice to meet you) r� r� r� r� r� r� r� r� r� r� r� r� )r� r r� r� rt rt ru �do_HELO s � z SMTP.do_HELOc C s | � dd� | j�� d S )N�� s See you later)r� r� r� r rt rt ru �do_QUIT$ s z SMTP.do_QUITs ("[^"]*"|\\.|s |[@.,:])+s> \s*FROM:\s*(?P<path><> # Empty <> |<s& > # <addr> |sq # addr )\s*(\s(?P<opts>.*))? # Optional WS + ESMTP options $s \s*TO:\s*(?P<path><c C s� | j r | �dd� d S g | _| j�|�}|s | �dd� d S z t|�d�| j�}W n tyF } z| �dt t |��� W Y d }~d S d }~ww t � | j | j|�}|�| j| j� d S )N� s# Only one sender per message, please� � Syntax error�path�) )r� r� r� �mail_rer� r3 �groupr� r r. r� r � maybeDeferred� validateFromr� � addCallbacks�_cbFromValidate�_ebFromValidate)r� r �mr� �e� validatedrt rt ru �do_MAILD s" ��z SMTP.do_MAILr � Sender address acceptedc C s || _ | �||� d S rw )r� r� )r� � fromEmailr� r� rt rt ru r X s zSMTP._cbFromValidatec C s| |� t�r | �|jjdt|jj� d t|jj� � d S |� t �r0| �|jjt|jj�� d S t � |d� | �dd� d S )Ns& Cannot receive from specified address � : z SMTP sender validation failure�� �3 Requested action aborted: local error in processing) �checkr r� �valuer� rB r� r. �respr r* �err�r� �failurert rt ru r \ s �� �� zSMTP._ebFromValidatec C s� | j s | �dd� d S | j�|�}|s| �dd� d S zt|�d�| j| | j �}W n tyF } z| �dtt |��� W Y d }~d S d }~ww t � | j |�}|j | j| j|fd� d S )Nr s! Must have sender before recipientr r r r )� callbackArgs)r� r� �rcpt_rer� r4 r r� r r. r� r r � validateTor � _cbToValidate� _ebToValidate)r� r r �userr �drt rt ru �do_RCPTm s ��z SMTP.do_RCPT� Recipient address acceptedc C s, |d u r|}| j �||f� | �||� d S rw )r� r� r� )r� �tor( r� r� rt rt ru r& s zSMTP._cbToValidatec C sB |� tt�r| �|jjt|jj�� d S t� |� | �dd� d S )Nr r ) r r r r� r r� r. r r* r r! rt rt ru r' � s zSMTP._ebToValidatec C s> |D ]}z|� � W q ty t�d� t�� Y qw d S )Nz(msg raised exception from connectionLost)r� � BaseExceptionr* r� r )r� �msgsr� rt rt ru � _disconnect� s ��zSMTP._disconnectc C s\ | j d u s| js| �dd� d S t| _| j| j }}| j}d | _ g | _d | _g }|D ]]\}}z|� }| �|||g�} | rA|�| � |� |� W q* t yk } z| �| j | j � t | _| �|� W Y d } ~ d S d } ~ w ty� t�� | �dd� t | _| �|� Y d S w || _d | _| _| �dd� | jr�d} t�| |d d � |D �f � d S d S ) Nr s' Must have valid receiver and originator�& s Internal server errorr �b s Continuez-Receiving message for delivery: from=%s to=%sc S s g | ]\}}t |��qS rt )r� )�.0�u�frt rt ru � <listcomp>� s z SMTP.do_DATA.<locals>.<listcomp>)r� r� r� r� r� r� � datafailed�receivedHeaderr� r� r r� r r� r/ r- r* r r� �_SMTP__inheader� _SMTP__inbody�noisyr� ) r� r r� �origin� recipientsr. r( �msgFuncr� �rcvdhdrr �fmtrt rt ru �do_DATA� sJ � � �z SMTP.do_DATAc C sz | j tu r,z | jD ]}z|�� W q ty t�� Y q w | `W n ty+ Y nw | jr6| �� d | _| � d � d S rw ) r� r� r� r� r- r* r r� � _onLogoutr� )r� �reasonr� rt rt ru r� � s � �zSMTP.connectionLostc C s d | _ g | _| �dd� d S )Nr s I remember nothing.)r� r� r� r rt rt ru �do_RSET� s z SMTP.do_RSETc C s4 |d d� dkrC|dkr=t | _| jr | �| jj| jj� d S | js(| �d� d S tj dd� | jD �dd�� | j� | `d S |dd � }| jrHd S z1| j sg| j sgd|v rWd| _ n|rg| jD ]}|� d � q\d| _ |sld| _ | jD ]}|� |� qoW d S ty� } z|| _| jD ]}|�� q�W Y d }~d S d }~ww ) NrK r� z thrown awayc S s g | ]}|� � �qS rt )� eomReceived)r2 r rt rt ru r5 � s z)SMTP.dataLineReceived.<locals>.<listcomp>T)� consumeErrorsr� r� )r� r� r6 r� r� r r� �_messageHandledr � DeferredList� addCallbackr8 r9 r� r r� )r� r� r� r rt rt ru �dataLineReceived� sL � � ���zSMTP.dataLineReceivedc C sz d}|D ]\}}|s|d7 }t �|� q|r5d}t|�}|dkr+|d|� d|� d�7 }| �dt|�� d S | �dd � d S ) Nr rK zCould not send e-mailz (z failures out of z recipients)r0 r s Delivery in progress)r* r r� r� r. )r� � resultList�failures�success�resultr� � resultLenrt rt ru rF s �zSMTP._messageHandledc C sZ |\}}}t |t�r|| _d| _nt |t�r d| _|| _nt|j� d���|| _d| _dS )zR Save the state resulting from a successful anonymous cred login. Nz is not a supported interface) � issubclassr& r� r� r% � RuntimeErrorr� rA � challenger)r� rM �iface�avatar�logoutrt rt ru �_cbAnonymousAuthentication s z SMTP._cbAnonymousAuthenticationc s� �j dur �j �� �_�jdurt��jj� ��S �jrD�j�tj � � dt t �}�fdd�}|� �j|� � ��fdd�}|�|� |S t���)a Validate the address from which the message originates. @type helo: C{(bytes, bytes)} @param helo: The argument to the HELO command and the client's IP address. @type origin: C{Address} @param origin: The address the message is from @rtype: C{Deferred} or C{Address} @return: C{origin} or a C{Deferred} whose callback will be passed C{origin}. @raise SMTPBadSender: Raised of messages from this address are not to be accepted. Nc sB | � tjj�r t� �}n| � tjj�rt� dd�}n| S t�|�S )z� Translate cred exceptions into SMTP exceptions so that the protocol code which invokes C{validateFrom} can properly report the failure. z#Unauthenticated senders not allowed)r )r r r �UnauthorizedLoginr �UnhandledCredentialsr �fail)r �exc)r; rt ru �ebAuthenticationE s � z+SMTP.validateFrom.<locals>.ebAuthenticationc s �� � ��S )zE Re-attempt from address validation. )r )�ignored�r� r; r� rt ru �continueValidationW s z-SMTP.validateFrom.<locals>.continueValidation)r� �getMessageDeliveryr� r r r �portal�loginr � credentials� Anonymousr& r% r rU rH r )r� r� r; rM rZ r] rt r\ ru r ! s" � zSMTP.validateFromc C s | j dur | j �|�S t|��)a Validate the address for which the message is destined. @type user: L{User} @param user: The address to validate. @rtype: no-argument callable @return: A C{Deferred} which becomes, or a callable which takes no arguments and returns an object implementing C{IMessage}. This will be called and the returned object used to deliver the message when it arrives. @raise SMTPBadRcpt: Raised if messages to the address are not to be accepted. N)r� r% r �r� r( rt rt ru r% b s zSMTP.validateToc C s� | j d ur | j �|||�S d}|d rd|d }t| j�� j�}d|d d |d d | d }d || jjtf }d d � t t |��t � f }d | d | d | S )Nr� r s helo=s from s ([rK � ]� )s by %s with %s (%s)s for %s; %s� s Received: s ) r� r7 r. r� �getHostr� r� r� r r� �mapr� rC ) r� r� r; r< �heloStrr� �from_�by�for_rt rt ru r7 v s $zSMTP.receivedHeaderr� )r� )r r )Nr r+ )3r� r� r� r� r� r_ r: r� r� rA r� �propertyr� �setterr� r� r� r� r� r� r� r� r� r� r r r� �qstringr� r� �Ir� r r$ r r r r* r& r' r/ r@ r� rC rI � state_DATArF rU r r% r7 rt rt rt ru r; � s� ���� � ���� � (*A r; c @ s2 e Zd ZdZeZdZeZdZ ddd�Z dd� Z dS ) r= z Factory for SMTP. r� Nc C � || _ d S rw )r_ )r� r_ rt rt ru r� � r� zSMTPFactory.__init__c C s" t j�| |�}| j|_| j|_|S rw )r � ServerFactory� buildProtocolr_ r� r� �r� r� �prt rt ru rt � s zSMTPFactory.buildProtocolrw ) r� r� r� r� r� r� r� r; r r_ r� rt rt rt rt ru r= � s r= c @ s� e Zd ZdZdZdZd3dd�Zdd� Zd d � Ze j fd d �Z d d� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Z d/d0� Z d1d2� Z dS )4r< a� SMTP client for sending emails. After the client has connected to the SMTP server, it repeatedly calls L{SMTPClient.getMailFrom}, L{SMTPClient.getMailTo} and L{SMTPClient.getMailData} and uses this information to send an email. It then calls L{SMTPClient.getMailFrom} again; if it returns L{None}, the client will disconnect, otherwise it will continue as normal i.e. call L{SMTPClient.getMailTo} and L{SMTPClient.getMailData} and send a new email. TN� c C sL t |t�r |�d�}|p d| _g | _g | _d | _g | _d| _t � |�| _ d S )NrI r� r� ) r� r� r� �identity�toAddressesResult�successAddressesr� r r� r+ �LineLogr* )r� rx �logsizert rt ru r� � s zSMTPClient.__init__c C s( | j r | j�d| � tj�| |� d S )Ns >>> )�debugr* r� r( � LineReceiverr� r� rt rt ru r� � s zSMTPClient.sendLinec C s( | � | j� dg| _| j| _| j| _d S r� )r� r� � _expected�smtpState_helo� _okresponse�smtpConnectionFailed� _failresponser� rt rt ru r� � s zSMTPClient.connectionMadec C s | � d� d| _dS )z, We are no longer connected N)r� �mailFile�r� rB rt rt ru r� � s zSMTPClient.connectionLostc C s | � tdd| j�� �� d S )Nr� s( Timeout waiting for SMTP server response)� sendErrorr! r* r� r� rt rt ru r� � s ��z SMTPClient.timeoutConnectionc C s� | � � | jr| j�d| � d }z t|d d� �| _W n ty5 | �tdd|� �| j� � �� Y d S w |dd� dkr@d S | j �|dd � � |dd� d krTd S | j| j v rf| � | jd � | j ��}n | �| jd � | j ��}d| _g | _ |S ) Ns <<< rc r� z#Invalid response from SMTP server: r rK � 0rd � -� )r� r} r* r� rm r� � ValueErrorr� r r� r r r� r� r� )r� r� �whyrt rt ru r� � s6 ��� zSMTPClient.lineReceivedc C s | � t||| j�� �� d S rw )r� r r* r� �r� r� r rt rt ru r� s z SMTPClient.smtpConnectionFailedc C s4 |dk r| � t||| j�� �� d S | �||� d S )Nr )r� r r* r� �smtpState_msgSentr� rt rt ru �smtpTransferFailed s z SMTPClient.smtpTransferFailedc C s" | � d| j � t| _| j| _d S )Ns HELO )r� rx �SUCCESSr �smtpState_fromr� r� rt rt ru r� s zSMTPClient.smtpState_heloc C sP | � � | _| j| _| jd ur"| �dt| j� � dg| _| j| _d S | � � d S )Ns MAIL FROM:r ) � getMailFromr� r� r� r� rB r � smtpState_tor� �_disconnectFromServerr� rt rt ru r� s zSMTPClient.smtpState_fromc C s | j �� d S rw )r� r� r� rt rt ru �smtpState_disconnect r� z SMTPClient.smtpState_disconnectc C s@ t | �� �| _g | _g | _| j| _tdd�| _d | _ | �dd�S )Nr �� r� ) �iter� getMailTo� toAddressesry rz �smtpState_toOrDatar� �ranger � lastAddressr� rt rt ru r� s zSMTPClient.smtpState_toc C s� | j d ur| j�| j ||f� |tv r| j�| j � zt| j�| _ W n" tyD | jr<| �d� dg| _ | j | _ Y d S | � |d� Y S w | �dt | j � � d S )Ns DATAr1 zNo recipients accepteds RCPT TO:)r� ry r� r� rz rx r� � StopIterationr� r �smtpState_datar� r� rB r� rt rt ru r� % s �z SMTPClient.smtpState_toOrDatac sJ t �� }|�� �� � j� j�}� fdd�}|�� j|� t� _ � j � _ d S )Nc s � � | j� d S rw )r� r )r r� rt ru � ebTransfer: r� z-SMTPClient.smtpState_data.<locals>.ebTransfer) r( � FileSender�beginFileTransfer� getMailDatar� �transformChunkr �finishedFileTransferr� r r� r� )r� r� r �sr) r� rt r� ru r� 6 s zSMTPClient.smtpState_datac C sN | j d ur| �||t| j�| j| j� g | _d | _ | �d� t| _| j | _ d S )Ns RSET) r� �sentMailr� rz ry r* r� r� r r� r� r� rt rt ru r� A s � z SMTPClient.smtpState_msgSentc C s | � � |�dd��dd�S )a Perform the necessary local to network newline conversion and escape leading periods. This method also resets the idle timeout so that as long as process is being made sending the message body, the client will not time out. r� s � .s ..)r� �replace)r� �chunkrt rt ru r� P s zSMTPClient.transformChunkc C s |dkrd}nd}| � |� d S )Nr� r� r� )r� )r� �lastsentr� rt rt ru r� [ s z SMTPClient.finishedFileTransferc C � t �)z< Return the email address the mail is from. ��NotImplementedErrorr� rt rt ru r� d � zSMTPClient.getMailFromc C r� )z5 Return a list of emails to send to. r� r� rt rt ru r� j r� zSMTPClient.getMailToc C r� )z� Return file-like object containing data of message to be sent. Lines in the file should be delimited by '\n'. r� r� rt rt ru r� p s zSMTPClient.getMailDatac C s, t |t�r|js| �� dS | �dd� dS )a2 If an error occurs before a mail message is sent sendError will be called. This base class method sends a QUIT if the error is non-fatal and disconnects the connection. @param exc: The SMTPClientError (or child class) raised @type exc: C{SMTPClientError} r� N)r� r �isFatalr� r� �r� rY rt rt ru r� x s zSMTPClient.sendErrorc C r� )a� Called when an attempt to send an email is completed. If some addresses were accepted, code and resp are the response to the DATA command. If no addresses were accepted, code is -1 and resp is an informative message. @param code: the code returned by the SMTP Server @param resp: The string response returned from the SMTP Server @param numOk: the number of addresses accepted by the remote host. @param addresses: is a list of tuples (address, code, resp) listing the response to each RCPT command. @param log: is the SMTP session log r� )r� r� r �numOk� addressesr* rt rt ru r� � s zSMTPClient.sentMailc C s" t dd�| _| j| _| �d� d S )Nr r� s QUIT)r� r r� r� r� r� rt rt ru r� � s z SMTPClient._disconnectFromServer)rw ) r� r� r� r� r} r� r� r� r� r �connectionDoner� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rt rt rt ru r< � s6 * r< c @ s� e Zd ZdZdZdZdZdZdZd0dd�Z dd� Z d d � Z d1d d �Z d1dd�Z d1dd�Zd1dd�Zd1dd�Zd1dd�Zd1dd�Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Z d.d/� Z dS )2r8 a A client for sending emails over ESMTP. @ivar heloFallback: Whether or not to fall back to plain SMTP if the C{EHLO} command is not recognised by the server. If L{requireAuthentication} is C{True}, or L{requireTransportSecurity} is C{True} and the connection is not over TLS, this fallback flag will not be honored. @type heloFallback: L{bool} @ivar requireAuthentication: If C{True}, refuse to proceed if authentication cannot be performed. Overrides L{heloFallback}. @type requireAuthentication: L{bool} @ivar requireTransportSecurity: If C{True}, refuse to proceed if the transport cannot be secured. If the transport layer is not already secured via TLS, this will override L{heloFallback}. @type requireAuthentication: L{bool} @ivar context: The context factory to use for STARTTLS, if desired. @type context: L{IOpenSSLClientConnectionCreator} @ivar _tlsMode: Whether or not the connection is over TLS. @type _tlsMode: L{bool} TFNc O s. t j| g|�R i |�� g | _|| _|| _d S rw )r< r� �authenticators�secret�context)r� r� �contextFactory�args�kwrt rt ru r� � s zESMTPClient.__init__c C s2 |dkrt jdtdd� | jS td| jj|f ��)N�tlsMode�StlsMode attribute of twisted.mail.smtp.ESMTPClient is deprecated since Twisted 13.0rV ��category� stacklevelz %s instance has no attribute %r)�warnings�warn�DeprecationWarning�_tlsModer� r� r� )r� �namert rt ru � __getattr__� s ����zESMTPClient.__getattr__c C s0 |dkrt jdtdd� || _d S || j|< d S )Nr� r� rV r� )r� r� r� r� r� )r� r� r rt rt ru � __setattr__� s � zESMTPClient.__setattr__r� c C � | � tdd| j�� �� dS )a� Fail because authentication is required, but the server does not support ESMTP, which is required for authentication. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} � s, Server does not support ESMTP AuthenticationN)r� r r* r� r� rt rt ru �esmtpEHLORequired� s ��z ESMTPClient.esmtpEHLORequiredc C sP g }| j D ] }|�|�� �� � qdd�|� }| �tdd| | j�� �� dS )a� Fail because authentication is required, but the server does not support any schemes we support. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} s [%s]s , r� s8 Server does not support Client Authentication schemes %sN) r� r� �getNamer� r� r� r r* r� )r� r� r �tmp�a�authrt rt ru �esmtpAUTHRequired� s ��z ESMTPClient.esmtpAUTHRequiredc C r� )a` Fail because TLS is required and the server does not support it. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} r� s: Server does not support secure communication via TLS / SSLN)r� r# r* r� r� rt rt ru �esmtpTLSRequired s ��z ESMTPClient.esmtpTLSRequiredc C s | � t|d| j�� �� dS )a[ Fail because the TLS handshake wasn't able to be completed. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} s( Could not complete the SSL/TLS handshakeN)r� r0 r* r� r� rt rt ru �esmtpTLSFailed& s ��zESMTPClient.esmtpTLSFailedc C � | � t||| j�� �� dS )aM Fail because the authentication was rejected. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} N)r� r r* r� r� rt rt ru �esmtpAUTHDeclined8 � z ESMTPClient.esmtpAUTHDeclinedc C r� )ab Fail because the server sent a malformed authentication challenge. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} r sR Login failed because the SMTP Server returned a malformed Authentication ChallengeN�r� r r* r� r� rt rt ru �esmtpAUTHMalformedChallengeF s ��z'ESMTPClient.esmtpAUTHMalformedChallengec C r� )aP Fail because of some other authentication error. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} Nr� r� rt rt ru �esmtpAUTHServerError[ r� z ESMTPClient.esmtpAUTHServerErrorc C s | j �|� dS )a� Registers an Authenticator with the ESMTPClient. The ESMTPClient will attempt to login to the SMTP Server in the order the Authenticators are registered. The most secure Authentication mechanism should be registered first. @param auth: The Authentication mechanism to register @type auth: L{IClientAuthentication} implementor @return: L{None} N)r� r� )r� r� rt rt ru �registerAuthenticatori s z!ESMTPClient.registerAuthenticatorc C s$ t �| j�| _t�| � | j| _dS )zp Called when a connection has been made, and triggers sending an C{EHLO} to the server. N)r � providedByr� r� r< r� �esmtpState_ehlor� r� rt rt ru r� w s zESMTPClient.connectionMadec C sT t | _| j| _| j| _| jrd}n| j}| jr | j s |s | j | _| � d| j � dS )a� Send an C{EHLO} to the server. If L{heloFallback} is C{True}, and there is no requirement for TLS or authentication, the client will fall back to basic SMTP. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} @return: L{None} Fs EHLO N) r� r �esmtpState_serverConfigr� r� r� r� �requireTransportSecurity� heloFallback�requireAuthenticationr� r� rx )r� r� r �needTLSrt rt ru r� � s zESMTPClient.esmtpState_ehloc C sZ i }|� � D ] }|�dd�}t|�dkr |d ||d < qd||d < q| �|||� dS )z� Handle a positive response to the I{EHLO} command by parsing the capabilities in the server's response and then taking the most appropriate next step towards entering a mail transaction. NrK r )r� r� r� �tryTLS)r� r� r �itemsr� r rt rt ru r� � s z#ESMTPClient.esmtpState_serverConfigc C sn | j }| jo d|v }| j}|s|s |s | �|||� dS |r1dg| _| j| _| j| _| � d� dS | � � dS )a� Take a necessary step towards being able to begin a mail transaction. The step may be to ask the server to being a TLS session. If TLS is already in use or not necessary and not available then the step may be to authenticate with the server. If TLS is necessary and not available, fail the mail transmission attempt. This is an internal helper method. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} @param items: A mapping of ESMTP extensions offered by the server. Keys are extension identifiers and values are the associated values. @type items: L{dict} mapping L{bytes} to L{bytes} @return: L{None} � STARTTLSr� N) r� r� r� � authenticater �esmtpState_starttlsr� r� r� r� r� )r� r� r r� �hasTLS�canTLS�mustTLSrt rt ru r� � s % zESMTPClient.tryTLSc C sN z | j �| j� d| _W n ty t�� | �d� Y nw | �||� dS )z� Handle a positive response to the I{STARTTLS} command by starting a new TLS session on C{self.transport}. Upon success, re-handshake with the server to discover what capabilities it has when TLS is in use. Tr N) r� �startTLSr� r� r- r* r r� r� r� rt rt ru r� � s �z ESMTPClient.esmtpState_starttlsc C s� | j rk|�d�rk|d �� }i }|D ]}d||�� < q| jD ]L}|�� �� }||v rj|| _|dkrT| j| _| j | _ dg| _ t � | j�| j d��} | �d|| f � d S dg| _ | j| _| j| _ | �d| � d S q | jrt| �� d S | �||� d S )N� AUTHrK � PLAIN�� s AUTH %s %s�N s AUTH )r� �getr� r� r� r� � _authinfor� r� �_esmtpState_plainAuthr� r �base64� b64encode�challengeResponser� �esmtpState_challenger� r� r� ) r� r� r r� �schemes� tmpSchemesr� r� r� � challengert rt ru r� � s6 � �� zESMTPClient.authenticatec C s@ | j | _| j| _dg| _t�| j�| j d��}| � d| � d S )Nr� rV s AUTH PLAIN ) r� r� r� r� r r� r� r� r� r� r� )r� r� r r� rt rt ru r� s z!ESMTPClient._esmtpState_plainAuthc C s | � | j|� d S rw )� _authResponser� r� rt rt ru r� $ s z ESMTPClient.esmtpState_challengec C s| | j | _zt�|�}W n tjy# | �d� | j| _| j| _Y d S w |� | j |�}ddg| _ | j | _| �t� |�� d S )N� *r� r� )r� r� r� � b64decode�binascii�Errorr� r� r� r� r� r � smtpState_maybeAuthenticatedr� )r� r� r� r rt rt ru r� ' s � zESMTPClient._authResponsec C s. |dkr| ` | �||� dS | �| j |� dS )z� Called to handle the next message from the server after sending a response to a SASL challenge. The server response might be another challenge or it might indicate authentication has succeeded. r� N)r� r� r� r� rt rt ru r� 6 s z(ESMTPClient.smtpState_maybeAuthenticatedrw )r� N) r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rt rt rt ru r8 � s8 3' r8 c @ s~ e Zd ZdZdZdZdZddd�Zdd� Zdd� Z d d � Z d d � Z d d� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� ZdS ) r7 NFc C s, t �| � |d u r i }|| _d| _|| _d S )NF)r; r� � challengers� authenticated�ctx)r� �chalr� rt rt ru r� L s zESMTP.__init__c C s. t �| � t�| j�| _| jo| jd u| _d S rw )r; r� r r� r� � canStartTLSr� r� rt rt ru r� T s zESMTP.connectionMadec C s t �| �d S )Ns ESMTP)r; r� r� rt rt ru r� Y r� zESMTP.greetingc C s* dt | j�� �i}| jr| jsd|d< |S )z� SMTP service extensions @return: the SMTP service extensions that are supported. @rtype: L{dict} with L{bytes} keys and a value of either L{None} or a L{list} of L{bytes}. r� Nr� )r� r� �keysr� � startedTLS)r� �extrt rt ru � extensions\ s zESMTP.extensionsc C s4 t |�}t�| |�}|d u rt| d|�� d �}|S )N�ext_)r- r; r� r� r� )r� r� r rt rt ru r� i s zESMTP.lookupMethodc C sT g }| � � �� D ] \}}|d ur |r |�|d d�|� � q|�|� qd�|�S )N� r� )r r� r� r� )r� �r�c�vrt rt ru �listExtensionsq s � zESMTP.listExtensionsc C s\ | j �� j}t|t�s|�d�}||f| _d | _g | _| � d| jd | d | � � � d S )Nr r r s , nice to meet you ) r� r� r� r� r� r� r� r� r� r� r )r� r r� rt rt ru �do_EHLO} s$ �����z ESMTP.do_EHLOc C sV | j r | �dd� d S | jr#| jr#| �dd� | j�| j� d| _ d S | �dd� d S )Nr s TLS already negotiatedr� s Begin TLS negotiation nowT�� s TLS not available)r r� r� r� r� r� r rt rt ru � ext_STARTTLS� s zESMTP.ext_STARTTLSc C s� | j r | �dd� d S |�d d�}| j�|d �� dd� �� }|s)| �dd� d S t| _|| _t |�dkr>|� � |d }nd }| � |� d S ) Nr s Already authenticatedrK r c S s d S rw rt rt rt rt ru rz � s z ESMTP.ext_AUTH.<locals>.<lambda>i� s Unrecognized authentication type) r� r� r� r� r� r� r� r� rQ r� � getChallenge� state_AUTH)r� r r� r� rt rt ru �ext_AUTH� s zESMTP.ext_AUTHc C s t �| |�}d| _|S )zz Save the state resulting from a successful cred login and mark this connection as authenticated. T)r; rU r� )r� � loginInforM rt rt ru �_cbAuthenticated� s zESMTP._cbAuthenticatedc C s@ d| _ |�tjj�r| �dd� dS t�|d� | �dd� dS )a Handle cred login errors by translating them to the SMTP authenticate failed. Translate all other errors into a generic SMTP error code and log the failure for inspection. Stop all errors from propagating. @param reason: Reason for failure. Ni s Authentication failedzSMTP authentication failurer r )r� r r r rV r� r* r r� rt rt ru �_ebAuthenticated� s zESMTP._ebAuthenticatedc s4 � j du r� �dd� t� _dS |du r&� j�� }t�|�}� �d|� dS |dkr8� �dd� d� _t� _dS zt�|�}W n t t j fyX � �dd� d� _t� _Y dS w � j� |� � j� � rv� j�� }t�|�}� �d|� dS t� _� j �� jdtt�}|�� j� |�� fd d �� |�� j� dS ) a+ Handle one step of challenge/response authentication. @param response: The text of a response. If None, this function has been called as a result of an AUTH command with no initial response. A response of '*' aborts authentication, as per RFC 2554. Nr s Temporary authentication failurer� r� r s Authentication aborteds' Syntax error in parameters or argumentsc s � � dd�S )Nr� s Authentication successful.r� )�ignr� rt ru rz � s z"ESMTP.state_AUTH.<locals>.<lambda>)r_ r� r� r� rQ r r� r� r� � TypeErrorr� r� � setResponse�moreChallengesr` r& r% rH r � addErrbackr )r� �responser� �encoded�uncoded�codedrM rt r� ru r � sJ � � �zESMTP.state_AUTHr� )r� r� r� r� r� r r� r� r� r� r r� r r r r r r r rt rt rt ru r7 E s" r7 c @ s< e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d S )r6 zi Utility class for sending emails easily. Use with SMTPSenderFactory or ESMTPSenderFactory. r c C s | j s d| _ t| jj�S d S �NrK )�doner� �factoryr r� rt rt ru r� s zSenderMixin.getMailFromc C � | j jS rw )r �toEmailr� rt rt ru r� � zSenderMixin.getMailToc C r rw )r �filer� rt rt ru r� r zSenderMixin.getMailDatac C sT t �| |� | jjdks|js&|jdkr|jdk s(d| j_| jj�|� d S d S d S )Nr i� r� T) r< r� r �retries�retryr� � sendFinishedrM �errbackr� rt rt ru r� s ��zSenderMixin.sendErrorc C s� d| j _|tvrBg }|D ]\}}} |tvr'|�|d td|f � d | � q |�|�� � t||d�|�|�} | j j� | � d S | j j� ||f� d S )NTr z%03dr r� ) r r$ r� r� r. r� r r� rM r% �callback) r� r� r r� r� r* �errlogr� �acode�aresprY rt rt ru r� ! s ��zSenderMixin.sentMailN) r� r� r� r� r r� r� r� r� r� rt rt rt ru r6 � s r6 c @ s e Zd ZdZdS )r> z| SMTP protocol that sends a single email based on information it gets from its factory, a L{SMTPSenderFactory}. N)r� r� r� r� rt rt rt ru r> 4 s r> c @ s` e Zd ZU dZeZeZee e d< ddd�Z dd� Z d d � Z d d � Zd d� Zdd� Zdd� ZdS )r? a� Utility factory for sending emails easily. @type currentProtocol: L{SMTPSender} @ivar currentProtocol: The current running protocol returned by L{buildProtocol}. @type sendFinished: C{bool} @ivar sendFinished: When the value is set to True, it means the message has been sent or there has been an unrecoverable error or the sending has been cancelled. The default value is False. r re Nc C s� t |t�sJ �t |t�r|�d�g}n!t |t�r |g}ng }|D ]}t |t�s,|�d�}|�|� q |}t|�| _t|�| _ || _ || _ || _ | j � | j� d| _d| _| | _|| _dS )ao @param fromEmail: The RFC 2821 address from which to send this message. @param toEmail: A sequence of RFC 2821 addresses to which to send this message. @param file: A file-like object containing the message to send. @param deferred: A Deferred to callback or errback when sending of this message completes. @type deferred: L{defer.Deferred} @param retries: The number of times to retry delivery of this message. @param timeout: Period, in seconds, for which to wait for server responses, or None to wait forever. rI FN)r� rm r� r� r� r� r3 r r� �nEmailsr r! rM �addBoth�_removeDeferredr$ �currentProtocolr" r� ) r� r r r! �deferredr" r� � toEmailFinal�_emailrt rt ru r� L s* zSMTPSenderFactory.__init__c C s | ` |S rw )rM �r� rM rt rt ru r, { s z!SMTPSenderFactory._removeDeferredc C � | � ||� d S rw ��_processConnectionError�r� � connectorr rt rt ru �clientConnectionFailed r� z(SMTPSenderFactory.clientConnectionFailedc C r2 rw r3 r5 rt rt ru �clientConnectionLost� r� z&SMTPSenderFactory.clientConnectionLostc C s� d | _ | jdk r(| js(t�d| j � | j�dd� |�� | jd7 _d S | js@|�t j �r7t dd�|_ | j �|j � d S d S )Nr z&SMTP Client retrying server. Retry: %srK r� z Unable to connect to server.)r- r" r$ r* r� r! �seek�connectr r �ConnectionDoner r rM r% r5 rt rt ru r4 � s �z)SMTPSenderFactory._processConnectionErrorc C s> | � | j| jd d �}| |_| j|_|| _| j�| j� |S )NrV ) r r� r* r r� r- rM r+ �_removeProtocolru rt rt ru rt � s z SMTPSenderFactory.buildProtocolc C s | j rd| _ |S )z� Remove the protocol created in C{buildProtocol}. @param result: The result/error passed to the callback/errback of L{defer.Deferred}. @return: The C{result} untouched. N)r- r1 rt rt ru r< � s z!SMTPSenderFactory._removeProtocol)re N)r� r� r� r� r� r� r> r r r< �__annotations__r� r, r7 r8 r4 rt r< rt rt rt ru r? ; s / r? c @ s e Zd ZdZdd� ZdS )r a& L{LOGINCredentials} generates challenges for I{LOGIN} authentication. For interoperability with Outlook, the challenge generated does not exactly match the one defined in the U{draft specification<http://sepp.oetiker.ch/sasl-2.1.19-ds/draft-murchison-sasl-login-00.txt>}. c C s t �| � ddg| _d S )Ns Password:s Username:)� _lcredentialsr� � challengesr� rt rt ru r� � s zLOGINCredentials.__init__N)r� r� r� r� r� rt rt rt ru r � s r c @ s& e Zd Zdd� Zdd� Zd dd�ZdS ) r2 c C rr rw �r( rc rt rt ru r� � r� zPLAINAuthenticator.__init__c C s dS )Nr� rt r� rt rt ru r� � s zPLAINAuthenticator.getNamerK c C s2 |dkr| j d | j d | S d| j d | S )NrK � r@ )r� r� r� rt rt ru r� � s z$PLAINAuthenticator.challengeResponseN)rK )r� r� r� r� r� r� rt rt rt ru r2 � s r2 c @ s. e Zd ZdZdZd dd�Zdd� Zdd� ZdS ) r9 TNc O sR d| _ || _|�dd �| _|d u r| �� }tj| ||g|�R i |�� | �� d S )Nr �hostname)r� �username�pop� _hostname�_getContextFactoryr8 r� �_registerAuthenticators)r� rC r� r� r� r� rt rt ru r� � s zESMTPSender.__init__c C s4 | � t| j�� | � t| j�� | � t| j�� d S rw )r� r rC r r2 r� rt rt ru rG � s z#ESMTPSender._registerAuthenticatorsc C sR | j d ur| j S | jd u rd S zddlm} W n ty! Y d S w || j�}|S )Nr )�optionsForClientTLS)r� rE �twisted.internet.sslrH � ImportError)r� rH r� rt rt ru rF � s � z ESMTPSender._getContextFactoryrw )r� r� r� r� r� r� rG rF rt rt rt ru r9 � s r9 c @ s4 e Zd ZdZeZ d dd�Zdd � ZdS ) r: z� Utility factory for sending emails easily. @type currentProtocol: L{ESMTPSender} @ivar currentProtocol: The current running protocol as made by L{buildProtocol}. re NFTc C sD t �| ||||||� || _|| _| | _| | _| | _| | _| | _d S rw ) r? r� rC �password�_contextFactory� _heloFallback�_requireAuthentication�_requireTransportSecurityrE )r� rC rK r r r! r. r" r� r� r� r� r� rB rt rt ru r� � s � zESMTPSenderFactory.__init__c C sh | j | j| j| j| j| jd d | jd�}| j|_| j |_ | j |_ | |_ | j|_|| _| j�| j� |S )a) Build an L{ESMTPSender} protocol configured with C{heloFallback}, C{requireAuthentication}, and C{requireTransportSecurity} as specified in L{__init__}. This sets L{currentProtocol} on the factory, as well as returning it. @rtype: L{ESMTPSender} rV )rB )r rC rK rL r� r* rE rM r� rN r� rO r� r r� r- rM r+ r< ru rt rt ru rt s �z ESMTPSenderFactory.buildProtocol)re NNFTTN)r� r� r� r� r9 r r� rt rt rt rt ru r: � s � r: � Fc s� t |d�s tt|��}� �fdd�} t�| �} t|t�r!|�d�}t|t�r+|�d�}| } t| t�s6t| �} t |||||| d| | | d� �|durMt |��_ |� | |��� | S )aR Send an email. This interface is intended to be a replacement for L{smtplib.SMTP.sendmail} and related methods. To maintain backwards compatibility, it will fall back to plain SMTP, if ESMTP support is not available. If ESMTP support is available, it will attempt to provide encryption via STARTTLS and authentication if a secret is provided. @param smtphost: The host the message should be sent to. @type smtphost: L{bytes} @param from_addr: The (envelope) address sending this mail. @type from_addr: L{bytes} @param to_addrs: A list of addresses to send this mail to. A string will be treated as a list of one address. @type to_addrs: L{list} of L{bytes} or L{bytes} @param msg: The message, including headers, either as a file or a string. File-like objects need to support read() and close(). Lines must be delimited by '\n'. If you pass something that doesn't look like a file, we try to convert it to a string (so you should be able to pass an L{email.message} directly, but doing the conversion with L{email.generator} manually will give you more control over the process). @param senderDomainName: Name by which to identify. If None, try to pick something sane (but this depends on external configuration and may not succeed). @type senderDomainName: L{bytes} @param port: Remote port to which to connect. @type port: L{int} @param username: The username to use, if wanting to authenticate. @type username: L{bytes} or L{unicode} @param password: The secret to use, if wanting to authenticate. If you do not specify this, SMTP authentication will not occur. @type password: L{bytes} or L{unicode} @param requireTransportSecurity: Whether or not STARTTLS is required. @type requireTransportSecurity: L{bool} @param requireAuthentication: Whether or not authentication is required. @type requireAuthentication: L{bool} @param reactor: The L{reactor} used to make the TCP connection. @rtype: L{Deferred} @returns: A cancellable L{Deferred}, its callback will be called if a message is sent to ANY address, the errback if no message is sent. When the C{cancel} method is called, it will stop retrying and disconnect the connection immediately. The callback will be called with a tuple (numOk, addresses) where numOk is the number of successful recipient addresses and addresses is a list of tuples (address, code, resp) giving the response to the RCPT command for each address. �readc s( d�_ �jr�jj�� dS � �� dS )z� Cancel the L{twisted.mail.smtp.sendmail} call, tell the factory not to retry and disconnect the connection. @param d: The L{defer.Deferred} to be cancelled. TN)r$ r- r� �abortConnection� disconnect)r) �r6 r rt ru �cancel s zsendmail.<locals>.cancelzutf-8T)r� r� r� rB N) �hasattrr r� r �Deferredr� r� r� r r: r. r� � connectTCP)�smtphost� from_addr�to_addrsr� �senderDomainName�portr rC rK r� r� rU r) � tlsHostnamert rT ru r5 2 s6 I � r5 c C st g }t | �D ]*}t|�}|dks |dks |dk s |dkr(|�td|d���� q|�t|f�� qd�|�t| �fS )N�+�=�! �~ �02Xr� )r, �ordr� r. r� r� r� )r� �errorsr �ch�ort rt ru rH � s rH c C s� g }d}|t | �k r`| ||d � dkrFz|�ttt| |d |d � �d��� W n ty@ |�t| ||d � �� Y nw |d7 }n|�t| ||d � ��d�� |d7 }|t | �k s d�|�t | �fS )z� Decode the xtext-encoded string C{s}. @param s: String to decode. @param errors: codec error handling scheme. @return: The decoded string. r rK � +rc � rI r{ ) r� r� �chrrm r� r� rd r� r� )r� re r rv rt rt ru rG � s , � � rG c @ � e Zd Zddd�ZdS )rD �strictc C � t |�S rw )rG �r� r� re rt rt ru r� � r zxtextStreamReader.decodeN�rl �r� r� r� r� rt rt rt ru rD � � rD c @ rk )rE rl c C rm rw )rH rn rt rt ru r� � r zxtextStreamWriter.decodeNro rp rt rt rt ru rE � rq rE c C s | dkr t tttfS d S )N�xtext)rH rG rD rE )r� rt rt ru rF � s �rF r rw )yr� r� r� r~ r� r� �socketrf r� � email.utilsr �ior �typingr �zope.interfacer �twistedr �twisted.copyrightr �twisted.internetr r r r �twisted.internet._idnar �twisted.internet.interfacesr r �twisted.mail._credr r r r> �twisted.mail._exceptr r r r r r r r r r r r r r r r! r" r0 r# �twisted.mail.interfacesr$ r% r& r' r1 �twisted.protocolsr( r) �twisted.pythonr* r+ �twisted.python.compatr, r- r. �twisted.python.runtimer/ �__all__�isMacOSX� gethostnamer� r� �getfqdn�dict�fromkeysr� r� rC r@ ry rA rB r� r� r� r� r3 r4 �LineOnlyReceiver� TimeoutMixinr; rs r= r~ r< r8 r7 r6 r> � ClientFactoryr? r2 r9 r: r5 �codecsrH rG � StreamReaderrD � StreamWriterrE rF �registerrt rt rt ru �<module> s� P 6 < s( r ) 88q&H �{ PK Mb�ZQ��� � , mail/__pycache__/_pop3client.cpython-310.pycnu �[��� o �b�� � @ s� U d Z ddlZddlmZ ddlmZ ddlmZmZm Z ddl m Z m Z m Z mZmZ ddlmZmZ ddlmZ d Zd ZG d d � d �Zd d� Zdd� Zdd� Zdd� Zdd� Z G dd� dej ej �Z g Z ee! e"d< dS )z� A POP3 client protocol implementation. Don't use this module directly. Use twisted.mail.pop3 instead. @author: Jp Calderone � N)�md5)�List)�defer�error� interfaces)� InsecureAuthenticationDisallowed� LineTooLong�ServerErrorResponse�TLSError�TLSNotSupportedError)�basic�policies)�logs +OKs -ERRc @ s e Zd ZdZdd� Zdd� ZdS )� _ListSettera$ A utility class to construct a list from a multi-line response accounting for deleted messages. POP3 responses sometimes occur in the form of a list of lines containing two pieces of data, a message index and a value of some sort. When a message is deleted, it is omitted from these responses. The L{setitem} method of this class is meant to be called with these two values. In the cases where indices are skipped, it takes care of padding out the missing values with L{None}. @ivar L: See L{__init__} c C s || _ dS )z� @type L: L{list} of L{object} @param L: The list being constructed. An empty list should be passed in. N��L)�selfr � r �:/usr/lib/python3/dist-packages/twisted/mail/_pop3client.py�__init__0 s z_ListSetter.__init__c C sB |\}}|t | j� d }|dkr| j�dg| � || j|< dS )aI Add the value at the specified position, padding out missing entries. @type itemAndValue: C{tuple} @param itemAndValue: A tuple of (item, value). The I{item} is the 0-based index in the list at which the value should be placed. The value is is an L{object} to put in the list. � r N)�lenr �extend)r � itemAndValue�item�value�diffr r r �setitem8 s z_ListSetter.setitemN)�__name__� __module__� __qualname__�__doc__r r r r r r r ! s r c C s | � dd�\}}t|�t|�fS )a/ Parse the response to a STAT command. @type line: L{bytes} @param line: The response from the server to a STAT command minus the status indicator. @rtype: 2-L{tuple} of (0) L{int}, (1) L{int} @return: The number of messages in the mailbox and the size of the mailbox. Nr ��split�int)�line�numMsgs� totalSizer r r � _statXformH s r( c C s$ | � dd�\}}t|�d t|�fS )a� Parse a line of the response to a LIST command. The line from the LIST response consists of a 1-based message number followed by a size. @type line: L{bytes} @param line: A non-initial line from the multi-line response to a LIST command. @rtype: 2-L{tuple} of (0) L{int}, (1) L{int} @return: The 0-based index of the message and the size of the message. Nr r" )r% �index�sizer r r � _listXformW s r+ c C s | � dd�\}}t|�d |fS )a� Parse a line of the response to a UIDL command. The line from the UIDL response consists of a 1-based message number followed by a unique id. @type line: L{bytes} @param line: A non-initial line from the multi-line response to a UIDL command. @rtype: 2-L{tuple} of (0) L{int}, (1) L{bytes} @return: The 0-based index of the message and the unique identifier for the message. Nr r" )r% r) �uidr r r � _uidXformi s r- c C s( | � dd�}t|�dkr|d dfS |S )a Parse the first line of a multi-line server response. @type line: L{bytes} @param line: The first line of a multi-line server response. @rtype: 2-tuple of (0) L{bytes}, (1) L{bytes} @return: The status indicator and the rest of the server response. � r r � �r# r )r% �partsr r r �_codeStatusSplit| s r2 c C s | � d�r | dd� S | S )a Remove a byte-stuffed termination character at the beginning of a line if present. When the termination character (C{'.'}) appears at the beginning of a line, the server byte-stuffs it by adding another termination character to avoid confusion with the terminating sequence (C{'.\r\n'}). @type line: L{bytes} @param line: A received line. @rtype: L{bytes} @return: The line without the byte-stuffed termination character at the beginning if it was present. Otherwise, the line unchanged. s ..r N)� startswith)r% r r r � _dotUnquoter� s r4 c @ sx e Zd ZdZdZdZdZdZdZe � d�Z dZ dZ dZdZdd� Zdd � Zd d � Zd d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Z d d!� Z d"d#� Z dSd$d%�Z d&d'� Z d(d)� Z!d*d+� Z"d,d-� Z#d.d/� Z$d0d1� Z%d2d3� Z&d4d5� Z'd6d7� Z(d8d9� Z)d:d;� Z*d<d=� Z+d>d?� Z,d@dA� Z-dTdCdD�Z.dEdF� Z/dGdH� Z0dUdIdJ�Z1dKdL� Z2dSdMdN�Z3dSdOdP�Z4dQdR� Z5dS )V� POP3Clienta2 A POP3 client protocol. Instances of this class provide a convenient, efficient API for retrieving and deleting messages from a POP3 server. This API provides a pipelining interface but POP3 pipelining on the network is not yet supported. @type startedTLS: L{bool} @ivar startedTLS: An indication of whether TLS has been negotiated successfully. @type allowInsecureLogin: L{bool} @ivar allowInsecureLogin: An indication of whether plaintext login should be allowed when the server offers no authentication challenge and the transport does not offer any protection via encryption. @type serverChallenge: L{bytes} or L{None} @ivar serverChallenge: The challenge received in the server greeting. @type timeout: L{int} @ivar timeout: The number of seconds to wait on a response from the server before timing out a connection. If the number is <= 0, no timeout checking will be performed. @type _capCache: L{None} or L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @ivar _capCache: The cached server capabilities. Capabilities are not allowed to change during the session (except when TLS is negotiated), so the first response to a capabilities command can be used for later lookups. @type _challengeMagicRe: L{Pattern <re.Pattern.search>} @ivar _challengeMagicRe: A regular expression which matches the challenge in the server greeting. @type _blockedQueue: L{None} or L{list} of 3-L{tuple} of (0) L{Deferred <defer.Deferred>}, (1) callable which results in a L{Deferred <defer.Deferred>}, (2) L{tuple} @ivar _blockedQueue: A list of blocked commands. While a command is awaiting a response from the server, other commands are blocked. When no command is outstanding, C{_blockedQueue} is set to L{None}. Otherwise, it contains a list of information about blocked commands. Each list entry provides the following information about a blocked command: the deferred that should be called when the response to the command is received, the function that sends the command, and the arguments to the function. @type _waiting: L{Deferred <defer.Deferred>} or L{None} @ivar _waiting: A deferred which fires when the response to the outstanding command is received from the server. @type _timedOut: L{bool} @ivar _timedOut: An indication of whether the connection was dropped because of a timeout. @type _greetingError: L{bytes} or L{None} @ivar _greetingError: The server greeting minus the status indicator, when the connection was dropped because of an error in the server greeting. Otherwise, L{None}. @type state: L{bytes} @ivar state: The state which indicates what type of response is expected from the server. Valid states are: 'WELCOME', 'WAITING', 'SHORT', 'LONG_INITIAL', 'LONG'. @type _xform: L{None} or callable that takes L{bytes} and returns L{object} @ivar _xform: The transform function which is used to convert each line of a multi-line response into usable values for use by the consumer function. If L{None}, each line of the multi-line response is sent directly to the consumer function. @type _consumer: callable that takes L{object} @ivar _consumer: The consumer function which is used to store the values derived by the transform function from each line of a multi-line response into a list. Fr Ns (<[^>]+>)c G s2 | j durt�� }| j �|||f� |S g | _ dS )a� Block a command, if necessary. If commands are being blocked, append information about the function which sends the command to a list and return a deferred that will be chained with the return value of the function when it eventually runs. Otherwise, set up for subsequent commands to be blocked and return L{None}. @type f: callable @param f: A function which sends a command. @type a: L{tuple} @param a: Arguments to the function. @rtype: L{None} or L{Deferred <defer.Deferred>} @return: L{None} if the command can run immediately. Otherwise, a deferred that will eventually trigger with the return value of the function. N)� _blockedQueuer �Deferred�append)r �f�a�dr r r �_blocked� s zPOP3Client._blockedc C s` | j g kr d| _ dS | j dur.| j }d| _ |�d�\}}}||� }|�|� | j �|� dS dS )z� Send the next blocked command. If there are no more commands in the blocked queue, set up for the next command to be sent immediately. Nr )r6 �pop� chainDeferredr )r r6 r; r9 r: �d2r r r �_unblock s �zPOP3Client._unblockc C sT | � | j||�}|dur|S |r| �|d | � n| �|� d| _t�� | _| jS )a+ Send a POP3 command to which a short response is expected. Block all further commands from being sent until the response is received. Transition the state to SHORT. @type cmd: L{bytes} @param cmd: A POP3 command. @type args: L{bytes} @param args: The command arguments. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the entire response is received. On an OK response, it returns the response from the server minus the status indicator. On an ERR response, it issues a server error response failure with the response from the server minus the status indicator. Nr. �SHORT)r< � sendShort�sendLine�stater r7 �_waiting)r �cmd�argsr; r r r rB 1 s zPOP3Client.sendShortc C sd | � | j||||�}|dur|S |r | �|d | � n| �|� d| _|| _|| _t�� | _| jS )a� Send a POP3 command to which a multi-line response is expected. Block all further commands from being sent until the entire response is received. Transition the state to LONG_INITIAL. @type cmd: L{bytes} @param cmd: A POP3 command. @type args: L{bytes} @param args: The command arguments. @type consumer: callable that takes L{object} @param consumer: A consumer function which should be used to put the values derived by a transform function from each line of the multi-line response into a list. @type xform: L{None} or callable that takes L{bytes} and returns L{object} @param xform: A transform function which should be used to transform each line of the multi-line response into usable values for use by a consumer function. If L{None}, each line of the multi-line response should be sent directly to the consumer function. @rtype: L{Deferred <defer.Deferred>} which successfully fires with callable that takes L{object} and fails with L{ServerErrorResponse} @return: A deferred which fires when the entire response is received. On an OK response, it returns the consumer function. On an ERR response, it issues a server error response failure with the response from the server minus the status indicator and the consumer function. Nr. � LONG_INITIAL) r< �sendLongrC rD �_xform� _consumerr r7 rE )r rF rG �consumer�xformr; r r r rI R s ! zPOP3Client.sendLongc C s& | j dkr | �| j � d| _g | _dS )z� Wait for a greeting from the server after the connection has been made. Start the connection in the WELCOME state. r �WELCOMEN)�timeout� setTimeoutrD r6 �r r r r �connectionMade� s zPOP3Client.connectionMadec C s d| _ | j�� dS )zO Drop the connection when the server does not respond in time. TN)� _timedOut� transport�loseConnectionrQ r r r �timeoutConnection� s z POP3Client.timeoutConnectionc C s� | j dkr | �d� | jrt�� }n| jrt| j�}g }| jdur*|�| j� d| _| j dur=|� dd� | j D �� d| _ |D ]}|� |� q?dS )a� Clean up when the connection has been lost. When the loss of connection was initiated by the client due to a timeout, the L{_timedOut} flag will be set. When it was initiated by the client due to an error in the server greeting, L{_greetingError} will be set to the server response minus the status indicator. @type reason: L{Failure <twisted.python.failure.Failure>} @param reason: The reason the connection was terminated. r Nc S s g | ]\}}}|�qS r r )�.0�deferredr9 r: r r r � <listcomp>� s z-POP3Client.connectionLost.<locals>.<listcomp>) rO rP rS r � TimeoutError�_greetingErrorr rE r8 r6 r �errback)r �reasonr; �wr r r �connectionLost� s �zPOP3Client.connectionLostc C sL | j dkr | �� | j}d| _t| d| �|�p|}| jdu r$|| _dS dS )z� Pass a received line to a state machine function and transition to the next state. @type line: L{bytes} @param line: A received line. r N�state_)rO � resetTimeoutrD �getattr)r r% rD r r r � lineReceived� s �zPOP3Client.lineReceivedc C s2 | j dur| j d}| _ |�t� � | j�� dS )z� Drop the connection when a server response exceeds the maximum line length (L{LineOnlyReceiver.MAX_LENGTH}). @type buffer: L{bytes} @param buffer: A received line which exceeds the maximum line length. N)rE r\ r rT rU )r �buffer�waitingr r r �lineLengthExceeded� s z POP3Client.lineLengthExceededc C s\ t |�\}}|tkr|| _| j�� n| j�|�}|dur#|�d�| _| � |� | � � dS )a� Handle server responses for the WELCOME state in which the server greeting is expected. WELCOME is the first state. The server should send one line of text with a greeting and possibly an APOP challenge. Transition the state to WAITING. @type line: L{bytes} @param line: A line received from the server. @rtype: L{bytes} @return: The next state. Nr �WAITING) r2 �OKr[ rT rU �_challengeMagicRe�search�group�serverChallenge�serverGreetingr@ )r r% �code�status�mr r r � state_WELCOME� s zPOP3Client.state_WELCOMEc C s t �dt|� � dS )z� Log an error for server responses received in the WAITING state during which the server is not expected to send anything. @type line: L{bytes} @param line: A line received from the server. zIllegal line from server: N)r �msg�repr)r r% r r r � state_WAITING� s zPOP3Client.state_WAITINGc C sJ | j d}| _ | �� t|�\}}|tkr |�|� dS |�t|�� dS )a� Handle server responses for the SHORT state in which the server is expected to send a single line response. Parse the response and fire the deferred which is waiting on receipt of a complete response. Transition the state back to WAITING. @type line: L{bytes} @param line: A line received from the server. @rtype: L{bytes} @return: The next state. Nrg )rE r@ r2 rh �callbackr\ r )r r% rX rn ro r r r � state_SHORT� s �zPOP3Client.state_SHORTc C sR t |�\}}|tkr dS | j}| j}d | _ | _| _| �� |�t||�� dS )a� Handle server responses for the LONG_INITIAL state in which the server is expected to send the first line of a multi-line response. Parse the response. On an OK response, transition the state to LONG. On an ERR response, cleanup and transition the state to WAITING. @type line: L{bytes} @param line: A line received from the server. @rtype: L{bytes} @return: The next state. �LONGNrg )r2 rh rK rE rJ r@ r\ r )r r% rn ro rL rX r r r �state_LONG_INITIAL s z POP3Client.state_LONG_INITIALc C sh |dkr | j }| j}d | _ | _| _| �� |�|� dS | jdur-| � | �|�� dS | � |� dS )aL Handle server responses for the LONG state in which the server is expected to send a non-initial line of a multi-line response. On receipt of the last line of the response, clean up, fire the deferred which is waiting on receipt of a complete response, and transition the state to WAITING. Otherwise, pass the line to the transform function, if provided, and then the consumer function. @type line: L{bytes} @param line: A line received from the server. @rtype: L{bytes} @return: The next state. � .Nrg rw )rK rE rJ r@ ru )r r% rL rX r r r � state_LONG+ s �zPOP3Client.state_LONGc C s dS )a Handle the server greeting. @type greeting: L{bytes} @param greeting: The server greeting minus the status indicator. For servers implementing APOP authentication, this will contain a challenge string. Nr )r �greetingr r r rm K � zPOP3Client.serverGreetingc C sf t �| jd�}|du rt�td��S |du r| �� }|du r%t�td��S | �� }|�| j ||� |S )a� Switch to encrypted communication using TLS. The first step of switching to encrypted communication is obtaining the server's capabilities. When that is complete, the L{_startTLS} callback function continues the switching process. @type contextFactory: L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>} @param contextFactory: The context factory with which to negotiate TLS. If not provided, try to create a new one. @rtype: L{Deferred <defer.Deferred>} which successfully results in L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} or fails with L{TLSError} @return: A deferred which fires when the transport has been secured according to the given context factory with the server capabilities, or which fails with a TLS error if the transport cannot be secured. Nz@POP3Client transport does not implement interfaces.ITLSTransportz@POP3Client requires a TLS context to initiate the STLS handshake) r � ITLSTransportrT r �failr �_getContextFactory� capabilities� addCallback� _startTLS)r �contextFactory�tlsr; r r r �startTLSV s$ ����zPOP3Client.startTLSc sV � j rJ d��d|vrt�td��S � �dd�}|�� j||� |�� fdd�� |S )a� Continue the process of switching to encrypted communication. This callback function runs after the server capabilities are received. The next step is sending the server an STLS command to request a switch to encrypted communication. When an OK response is received, the L{_startedTLS} callback function completes the switch to encrypted communication. Then, the new server capabilities are requested. @type caps: L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @param caps: The server capabilities. @type contextFactory: L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>} @param contextFactory: A context factory with which to negotiate TLS. @type tls: L{ITLSTransport <interfaces.ITLSTransport>} @param tls: A TCP transport that supports switching to TLS midstream. @rtype: L{Deferred <defer.Deferred>} which successfully triggers with L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} or fails with L{TLSNotSupportedError} @return: A deferred which successfully fires when the response from the server to the request to start TLS has been received and the new server capabilities have been received or fails when the server does not support TLS. z5Client and Server are currently communicating via TLS� STLSz:Server does not support secure communication via TLS / SSLNc s � � � S �N)r� )�_rQ r r �<lambda>� s z&POP3Client._startTLS.<locals>.<lambda>)� startedTLSr r~ r rB r� � _startedTLS)r �capsr� r� r; r rQ r r� � s ���� zPOP3Client._startTLSc C s" || _ | j �|� d| _d| _|S )a� Complete the process of switching to encrypted communication. This callback function runs after the response to the STLS command has been received. The final steps are discarding the cached capabilities and initiating TLS negotiation on the transport. @type result: L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @param result: The server capabilities. @type context: L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>} @param context: A context factory with which to negotiate TLS. @type tls: L{ITLSTransport <interfaces.ITLSTransport>} @param tls: A TCP transport that supports switching to TLS midstream. @rtype: L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @return: The server capabilities. NT)rT r� � _capCacher� )r �result�contextr� r r r r� � s zPOP3Client._startedTLSc C s< zddl m} W n ty Y dS w |�� }|jj|_|S )a Get a context factory with which to negotiate TLS. @rtype: L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>} @return: A context factory or L{None} if TLS is not supported on the client. r )�sslN)�twisted.internetr� � ImportError�ClientContextFactory�SSL� TLSv1_METHOD�method)r r� r� r r r r � s � z POP3Client._getContextFactoryc C s | � � }|�| j||� |S )a Log in to the server. If APOP is available it will be used. Otherwise, if TLS is available, an encrypted session will be started and plaintext login will proceed. Otherwise, if L{allowInsecureLogin} is set, insecure plaintext login will proceed. Otherwise, L{InsecureAuthenticationDisallowed} will be raised. The first step of logging into the server is obtaining the server's capabilities. When that is complete, the L{_login} callback function continues the login process. @type username: L{bytes} @param username: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} @return: A deferred which fires when the login process is complete. On a successful login, it returns the server's response minus the status indicator. )r� r� �_login)r �username�passwordr; r r r �login� s zPOP3Client.loginc C s� | j dur | �||| j �S d|v }t�| jd�du}t�| jd�du }| js:|r:|r:|r:| �� }|�| j ||� |S | jsB|rB| j rH| � ||�S t � t� �S )a� Continue the process of logging in to the server. This callback function runs after the server capabilities are received. If the server provided a challenge in the greeting, proceed with an APOP login. Otherwise, if the server and the transport support encrypted communication, try to switch to TLS and then complete the login process with the L{_loginTLS} callback function. Otherwise, if insecure authentication is allowed, do a plaintext login. Otherwise, fail with an L{InsecureAuthenticationDisallowed} error. @type caps: L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @param caps: The server capabilities. @type username: L{bytes} @param username: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} @return: A deferred which fires when the login process is complete. On a successful login, it returns the server's response minus the status indicator. Nr� )rl �_apopr r} rT � ISSLTransportr� r� r� � _loginTLS�allowInsecureLogin� _plaintextr r~ r )r r� r� r� �tryTLS�tlsableTransport�nontlsTransportr; r r r r� s zPOP3Client._loginc C s | � ||�S )a Do a plaintext login over an encrypted transport. This callback function runs after the transport switches to encrypted communication. @type res: L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @param res: The server capabilities. @type username: L{bytes} @param username: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server accepts the username and password or fails when the server rejects either. On a successful login, it returns the server's response minus the status indicator. )r� )r �resr� r� r r r r� 5 s zPOP3Client._loginTLSc s �� |��� �fdd��S )aj Perform a plaintext login. @type username: L{bytes} @param username: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server accepts the username and password or fails when the server rejects either. On a successful login, it returns the server's response minus the status indicator. c s �� � �S r� )r� ��r�r� r r r r� ` s z'POP3Client._plaintext.<locals>.<lambda>)�userr� )r r� r� r r� r r� O s zPOP3Client._plaintextc C s" t || ��� �d�}| �||�S )as Perform an APOP login. @type username: L{bytes} @param username: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @type challenge: L{bytes} @param challenge: A challenge string. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On a successful login, it returns the server response minus the status indicator. �ascii)r � hexdigest�encode�apop)r r� r� � challenge�digestr r r r� b s zPOP3Client._apopc C s | � d|d | �S )a� Send an APOP command to perform authenticated login. This should be used in special circumstances only, when it is known that the server supports APOP authentication, and APOP authentication is absolutely required. For the common case, use L{login} instead. @type username: L{bytes} @param username: The username with which to log in. @type digest: L{bytes} @param digest: The challenge response to authenticate with. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. s APOPr. �rB )r r� r� r r r r� x s zPOP3Client.apopc C � | � d|�S )a� Send a USER command to perform the first half of plaintext login. Unless this is absolutely required, use the L{login} method instead. @type username: L{bytes} @param username: The username with which to log in. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. s USERr� )r r� r r r r� � � zPOP3Client.userc C r� )a� Send a PASS command to perform the second half of plaintext login. Unless this is absolutely required, use the L{login} method instead. @type password: L{bytes} @param password: The plaintext password with which to authenticate. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. s PASSr� )r r� r r r r� � r� zPOP3Client.passwordc C s | � dd|d f �S )aM Send a DELE command to delete a message from the server. @type index: L{int} @param index: The 0-based index of the message to delete. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. s DELE� %dr r� )r r) r r r �delete� s zPOP3Client.deletec sD |du rg � t � �j}| �||||��� fdd��S | �||||�S )a� Send a command to which a long response is expected and process the multi-line response into a list accounting for deleted messages. @type cmd: L{bytes} @param cmd: A POP3 command to which a long response is expected. @type args: L{bytes} @param args: The command arguments. @type consumer: L{None} or callable that takes L{object} @param consumer: L{None} or a function that consumes the output from the transform function. @type xform: L{None}, callable that takes L{bytes} and returns 2-L{tuple} of (0) L{int}, (1) L{object}, or callable that takes L{bytes} and returns L{object} @param xform: A function that parses a line from a multi-line response and transforms the values into usable form for input to the consumer function. If no consumer function is specified, the output must be a message index and corresponding value. If no transform function is specified, the line is used as is. @rtype: L{Deferred <defer.Deferred>} which fires with L{list} of L{object} or callable that takes L{list} of L{object} @return: A deferred which fires when the entire response has been received. When a consumer is not provided, the return value is a list of the value for each message or L{None} for deleted messages. Otherwise, it returns the consumer itself. Nc � � S r� r r� r r r r� � r| z.POP3Client._consumeOrSetItem.<locals>.<lambda>)r r rI r� �r rF rG rL rM r r r �_consumeOrSetItem� s z POP3Client._consumeOrSetItemc s@ |du rg � � j }| �||||��� fdd��S | �||||�S )a� Send a command to which a long response is expected and process the multi-line response into a list. @type cmd: L{bytes} @param cmd: A POP3 command which expects a long response. @type args: L{bytes} @param args: The command arguments. @type consumer: L{None} or callable that takes L{object} @param consumer: L{None} or a function that consumes the output from the transform function. @type xform: L{None} or callable that takes L{bytes} and returns L{object} @param xform: A function that transforms a line from a multi-line response into usable form for input to the consumer function. If no transform function is specified, the line is used as is. @rtype: L{Deferred <defer.Deferred>} which fires with L{list} of 2-L{tuple} of (0) L{int}, (1) L{object} or callable that takes 2-L{tuple} of (0) L{int}, (1) L{object} @return: A deferred which fires when the entire response has been received. When a consumer is not provided, the return value is a list of the transformed lines. Otherwise, it returns the consumer itself. Nc r� r� r r� r r r r� r| z-POP3Client._consumeOrAppend.<locals>.<lambda>)r8 rI r� r� r r r �_consumeOrAppend� s zPOP3Client._consumeOrAppendTc sd |r �j dur t��j �S i � � fdd�}dd� }� �fdd�}��dd|d�}|�|��|� |S ) a� Send a CAPA command to retrieve the capabilities supported by the server. Not all servers support this command. If the server does not support this, it is treated as though it returned a successful response listing no capabilities. At some future time, this may be changed to instead seek out information about a server's capabilities in some other fashion (only if it proves useful to do so, and only if there are servers still in use which do not support CAPA but which do support POP3 extensions that are useful). @type useCache: L{bool} @param useCache: A flag that determines whether previously retrieved results should be used if available. @rtype: L{Deferred <defer.Deferred>} which successfully results in L{dict} mapping L{bytes} to L{list} of L{bytes} and/or L{bytes} to L{None} @return: A deferred which fires with a mapping of capability name to parameters. For example:: C: CAPA S: +OK Capability list follows S: TOP S: USER S: SASL CRAM-MD5 KERBEROS_V4 S: RESP-CODES S: LOGIN-DELAY 900 S: PIPELINING S: EXPIRE 60 S: UIDL S: IMPLEMENTATION Shlemazle-Plotz-v302 S: . will be lead to a result of:: | {'TOP': None, | 'USER': None, | 'SASL': ['CRAM-MD5', 'KERBEROS_V4'], | 'RESP-CODES': None, | 'LOGIN-DELAY': ['900'], | 'PIPELINING': None, | 'EXPIRE': ['60'], | 'UIDL': None, | 'IMPLEMENTATION': ['Shlemazle-Plotz-v302']} Nc sL | � � }t|�dkrd � |d < d S t|�dkr$|dd � � |d < d S d S )Nr r r0 )r% �tmp)�cacher r �consumeC s �z(POP3Client.capabilities.<locals>.consumec S s | � t� d S r� )�trapr )�errr r r �capaNotSupportedJ s z1POP3Client.capabilities.<locals>.capaNotSupportedc s � �_ � S r� )r� )r� �r� r r r �gotCapabilitiesN s z0POP3Client.capabilities.<locals>.gotCapabilitiess CAPA)r� r �succeedr� � addErrbackr� )r �useCacher� r� r� r; r r� r r� s 0 zPOP3Client.capabilitiesc C � | � dd�S )a� Send a NOOP command asking the server to do nothing but respond. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. s NOOPNr� rQ r r r �noopV � zPOP3Client.noopc C r� )a Send a RSET command to unmark any messages that have been flagged for deletion on the server. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. s RSETNr� rQ r r r �resetc s zPOP3Client.resetc C s> d|d f }|du r| � d||t�S | � dd||f |t�S )a� Send a RETR or TOP command to retrieve all or part of a message from the server. @type index: L{int} @param index: A 0-based message index. @type consumer: L{None} or callable that takes L{bytes} @param consumer: A function which consumes each transformed line from a multi-line response as it is received. @type lines: L{None} or L{int} @param lines: If specified, the number of lines of the message to be retrieved. Otherwise, the entire message is retrieved. @rtype: L{Deferred <defer.Deferred>} which fires with L{list} of L{bytes}, or callable that takes 2-L{tuple} of (0) L{int}, (1) L{object} @return: A deferred which fires when the entire response has been received. When a consumer is not provided, the return value is a list of the transformed lines. Otherwise, it returns the consumer itself. r� r Ns RETRs TOPs %b %d)r� r4 )r r) rL �lines�idxr r r �retrieveq s �zPOP3Client.retrievec C s | � dd��t�S )aJ Send a STAT command to get information about the size of the mailbox. @rtype: L{Deferred <defer.Deferred>} which successfully fires with a 2-tuple of (0) L{int}, (1) L{int} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the number of messages in the mailbox and the size of the mailbox in octets. On an ERR response, the deferred fails with a server error response failure. s STATN)rB r� r( rQ r r r �stat� s zPOP3Client.statc C � | � dd|t�S )a� Send a LIST command to retrieve the sizes of all messages on the server. @type consumer: L{None} or callable that takes 2-L{tuple} of (0) L{int}, (1) L{int} @param consumer: A function which consumes the 0-based message index and message size derived from the server response. @rtype: L{Deferred <defer.Deferred>} which fires L{list} of L{int} or callable that takes 2-L{tuple} of (0) L{int}, (1) L{int} @return: A deferred which fires when the entire response has been received. When a consumer is not provided, the return value is a list of message sizes. Otherwise, it returns the consumer itself. s LISTN)r� r+ �r rL r r r �listSize� � zPOP3Client.listSizec C r� )a� Send a UIDL command to retrieve the UIDs of all messages on the server. @type consumer: L{None} or callable that takes 2-L{tuple} of (0) L{int}, (1) L{bytes} @param consumer: A function which consumes the 0-based message index and UID derived from the server response. @rtype: L{Deferred <defer.Deferred>} which fires with L{list} of L{object} or callable that takes 2-L{tuple} of (0) L{int}, (1) L{bytes} @return: A deferred which fires when the entire response has been received. When a consumer is not provided, the return value is a list of message sizes. Otherwise, it returns the consumer itself. s UIDLN)r� r- r� r r r �listUID� r� zPOP3Client.listUIDc C r� )a� Send a QUIT command to disconnect from the server. @rtype: L{Deferred <defer.Deferred>} which successfully fires with L{bytes} or fails with L{ServerErrorResponse} @return: A deferred which fires when the server response is received. On an OK response, the deferred succeeds with the server response minus the status indicator. On an ERR response, the deferred fails with a server error response failure. s QUITNr� rQ r r r �quit� r� zPOP3Client.quitr� )T)NN)6r r r r! r� r� rO rl r� �re�compileri r6 rE rS r[ r< r@ rB rI rR rV r_ rc rf rq rt rv rx rz rm r� r� r� r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r5 � sd Q !0 -. 5& $H ! r5 �__all__)#r! r� �hashlibr �typingr r� r r r �twisted.mail._exceptr r r r r �twisted.protocolsr r �twisted.pythonr rh �ERRr r( r+ r- r2 r4 �LineOnlyReceiver� TimeoutMixinr5 r� �str�__annotations__r r r r �<module> s4 ' :PK Mb�Zu]t�� � ) mail/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z> Twisted Mail: Servers and clients for POP3, ESMTP, and IMAP. N)�__doc__� r r �7/usr/lib/python3/dist-packages/twisted/mail/__init__.py�<module> s PK Mb�Zѧh� � ' mail/__pycache__/bounce.cpython-310.pycnu �[��� o �bb � @ sN d Z ddlZddlZddlZddlmZmZmZ ddl m Z dZ d dd �Z dS ) z( Support for bounce message generation. � N)�SEEK_END�SEEK_SET�StringIO)�smtpa] From: postmaster@{failedDomain} To: {failedFrom} Subject: Returned Mail: see transcript for details Message-ID: {messageID} Content-Type: multipart/report; report-type=delivery-status; boundary="{boundary}" --{boundary} {transcript} --{boundary} Content-Type: message/delivery-status Arrival-Date: {ctime} Final-Recipient: RFC822; {failedTo} � �utf-8c C sV t |t�r |�|�}t |t�r|�|�}|s dj|d�}tj�|�d }d�t�� t� � d�t� t�� �||� dd�d ||t j dd�| |d � }t� }|�tjdi |��� | �� }| �d t� | �� } | �|t� | d kr� | �� } t | t�r}| �|�} t| �d kr�n|�| � qon| �� } t | t�r�| �|�} |�| � d |�|�|�� �|�fS )a^ Generate a bounce message for an undeliverable email message. @type message: a file-like object @param message: The undeliverable message. @type failedFrom: L{bytes} or L{unicode} @param failedFrom: The originator of the undeliverable message. @type failedTo: L{bytes} or L{unicode} @param failedTo: The destination of the undeliverable message. @type transcript: L{bytes} or L{unicode} @param transcript: An error message to include in the bounce message. @type encoding: L{str} or L{unicode} @param encoding: Encoding to use, default: utf-8 @rtype: 3-L{tuple} of (E{1}) L{bytes}, (E{2}) L{bytes}, (E{3}) L{bytes} @return: The originator, the destination and the contents of the bounce message. The destination of the bounce message is the originator of the undeliverable message. zzI'm sorry, the following address has permanent errors: {failedTo}. I've given up, and I will not retry the message again. )�failedTo� z{}_{}_{}�XXXXX�@�bounce)�uniq) �boundary�ctime� failedAddress� failedDomain� failedFromr � messageID�message� transcriptr i' � N� )� isinstance�bytes�decode�format�email�utils� parseaddr�time�os�getpidr �splitr � messageidr �write� BOUNCE_FORMAT�tell�seekr r �readline�len�read�encode�getvalue) r r r r �encodingr �data�fp�orig�sz�line�messageContentr r �5/usr/lib/python3/dist-packages/twisted/mail/bounce.py�generateBounce$ sR � � � r5 )r r ) �__doc__� email.utilsr r r �ior r r � twisted.mailr r% r5 r r r r4 �<module> s PK Mb�Z��[tc tc & mail/__pycache__/alias.cpython-310.pycnu �[��� o �b�] � @ sJ d Z ddlZddlZddlmZ ddlmZmZmZ ddl m Z ddl m Z ddl mZmZ dd � Zd d d �ZG d d � d �Zee �G dd� de��Zee j�G dd� d��Zee �G dd� de��ZG dd� de�Zee j�G dd� d��ZG dd� dej�Zee �G dd� de��Z ee j�G d d � d ��Z ee �G d d � d e��Z dS )!zD Support for aliases(5) configuration files. @author: Jp Calderone � N)� implementer)�defer�protocol�reactor)�smtp)�IAlias)�failure�logc C sp dd� |� dd�D �}t|�dkr d}||f}t�|| � dS |\}}| �|�� g ��ttj|� d��� dS ) a� Parse a line from an aliases file. @type result: L{dict} mapping L{bytes} to L{list} of L{bytes} @param result: A dictionary mapping username to aliases to which the results of parsing the line are added. @type line: L{bytes} @param line: A line from an aliases file. @type filename: L{bytes} @param filename: The full or relative path to the aliases file. @type lineNo: L{int} @param lineNo: The position of the line within the aliases file. c S � g | ]}|� � �qS � ��strip)�.0�pr r �4/usr/lib/python3/dist-packages/twisted/mail/alias.py� <listcomp>) � zhandle.<locals>.<listcomp>�:� � z+Invalid format on line %d of alias file %s.�,N) �split�lenr �err� setdefaultr �extend�map�str) �result�line�filename�lineNo�parts�fmt�arg�user�aliasr r r �handle s (r' c C s� i }d}|du rt |�}d}nt|dd�}d}d}z7|D ],}|d7 }|�� }|�� �d �r.q |�d �s8|�d �r=|| }q |rFt||||� |}q W |rP|�� n|rX|�� w w |rbt||||� |�� D ] \}} t| | |�||< qf|S ) a� Load a file containing email aliases. Lines in the file should be formatted like so:: username: alias1, alias2, ..., aliasN Aliases beginning with a C{|} will be treated as programs, will be run, and the message will be written to their stdin. Aliases beginning with a C{:} will be treated as a file containing additional aliases for the username. Aliases beginning with a C{/} will be treated as the full pathname to a file to which the message will be appended. Aliases without a host part will be assumed to be addresses on localhost. If a username is specified multiple times, the aliases for each are joined together as if they had all been on one line. Lines beginning with a space or a tab are continuations of the previous line. Lines beginning with a C{#} are comments. @type domains: L{dict} mapping L{bytes} to L{IDomain} provider @param domains: A mapping of domain name to domain object. @type filename: L{bytes} or L{None} @param filename: The full or relative path to a file from which to load aliases. If omitted, the C{fp} parameter must be specified. @type fp: file-like object or L{None} @param fp: The file from which to load aliases. If specified, the C{filename} parameter is ignored. @rtype: L{dict} mapping L{bytes} to L{AliasGroup} @return: A mapping from username to group of aliases. FNT�namez <unknown>r � r �#� � ) �open�getattr�rstrip�lstrip� startswithr' �close�items� AliasGroup) �domainsr �fpr r2 �i�prevr �u�ar r r � loadAliasFile3 s> ) � �� �r; c @ s* e Zd ZdZdd� Zdd� Zd dd�ZdS ) � AliasBasez� The default base class for aliases. @ivar domains: See L{__init__}. @type original: L{Address} @ivar original: The original address being aliased. c C s || _ t�|�| _dS )z� @type domains: L{dict} mapping L{bytes} to L{IDomain} provider @param domains: A mapping of domain name to domain object. @type original: L{bytes} @param original: The original address being aliased. N)r5 r �Address�original)�selfr5 r> r r r �__init__� s zAliasBase.__init__c C s | j | jj S )z� Return the domain associated with original address. @rtype: L{IDomain} provider @return: The domain for the original address. )r5 r> �domain�r? r r r rA � � zAliasBase.domainNc C s0 |du ri }t | �|v rdS d|t | �< | �� S �aY Map this alias to its ultimate destination. @type aliasmap: L{dict} mapping L{bytes} to L{AliasBase} @param aliasmap: A mapping of username to alias or group of aliases. @type memo: L{None} or L{dict} of L{AliasBase} @param memo: A record of the aliases already considered in the resolution process. If provided, C{memo} is modified to include this alias. @rtype: L{IMessage <smtp.IMessage>} or L{None} @return: A message receiver for the ultimate destination or None for an invalid destination. N)r �createMessageReceiver�r? �aliasmap�memor r r �resolve� s zAliasBase.resolve�N)�__name__� __module__� __qualname__�__doc__r@ rA rI r r r r r< { s r< c @ s8 e Zd ZdZdd� Zdefdd�Zdd� Zd d d �Zd S ) � AddressAliasz� An alias which translates one email address into another. @type alias : L{Address} @ivar alias: The destination address. c G s" t j| g|�R � t�|�| _dS )aQ @type alias: L{Address}, L{User}, L{bytes} or object which can be converted into L{bytes} @param alias: The destination address. @type args: 2-L{tuple} of (0) L{dict} mapping L{bytes} to L{IDomain} provider, (1) L{bytes} @param args: Arguments for L{AliasBase.__init__}. N)r< r@ r r= r& )r? r& �argsr r r r@ � s zAddressAlias.__init__�returnc C � d| j � d�S )z� Build a string representation of this L{AddressAlias} instance. @rtype: L{bytes} @return: A string containing the destination address. z <Address �>)r& rB r r r �__str__� rC zAddressAlias.__str__c C s | � � �t| j��S )z� Create a message receiver which delivers a message to the destination address. @rtype: L{IMessage <smtp.IMessage>} provider @return: A message receiver. )rA �existsr r& rB r r r rE � s z"AddressAlias.createMessageReceiverNc C s� |du ri }t | �|v rdS d|t | �< z| �� �t�| jddd�|�� W S tjy/ Y nw | jj|v r@|| jj �||�S dS rD ) r rA rU r �Userr& � SMTPBadRcpt�localrI rF r r r rI � s "� zAddressAlias.resolverJ ) rK rL rM rN r@ r rT rE rI r r r r rO � s rO c @ �> e Zd ZdZdd� Zdd� Zdd� Zdd � Zd efd d �Z d S )� FileWrappera A message receiver which delivers a message to a file. @type fp: file-like object @ivar fp: A file used for temporary storage of the message. @type finalname: L{bytes} @ivar finalname: The name of the file in which the message should be stored. c C s t �� | _|| _dS )z� @type filename: L{bytes} @param filename: The name of the file in which the message should be stored. N)�tempfile� TemporaryFiler6 � finalname)r? r r r r r@ s zFileWrapper.__init__c C s | j �|d � dS )z� Write a received line to the temporary file. @type line: L{bytes} @param line: A received line of the message. � N)r6 �write�r? r r r r � lineReceived � zFileWrapper.lineReceivedc C s� | j �dd� zt| jd�}W n ty t�t�� � Y S w |� |� | j � � � | j � � W d � n1 s:w Y t� | j�S )ac Handle end of message by writing the message to the file. @rtype: L{Deferred <defer.Deferred>} which successfully results in L{bytes} @return: A deferred which succeeds with the name of the file to which the message has been stored or fails if the message cannot be saved to the file. r r: N) r6 �seekr- r] � BaseExceptionr �failr �Failurer_ �readr2 �succeed)r? �fr r r � eomReceived s � � zFileWrapper.eomReceivedc C s | j �� d| _ dS )zG Close the temporary file when the connection is lost. N)r6 r2 rB r r r �connectionLost- s zFileWrapper.connectionLostrQ c C rR )z� Build a string representation of this L{FileWrapper} instance. @rtype: L{bytes} @return: A string containing the file name of the message. z <FileWrapper rS )r] rB r r r rT 4 rC zFileWrapper.__str__N� rK rL rM rN r@ ra rj rk r rT r r r r rZ � s rZ c @ s. e Zd ZdZdd� Zdefdd�Zdd� Zd S ) � FileAliasz_ An alias which translates an address to a file. @ivar filename: See L{__init__}. c G s t j| g|�R � || _dS )a" @type filename: L{bytes} @param filename: The name of the file in which to store the message. @type args: 2-L{tuple} of (0) L{dict} mapping L{bytes} to L{IDomain} provider, (1) L{bytes} @param args: Arguments for L{AliasBase.__init__}. N)r< r@ r )r? r rP r r r r@ F s zFileAlias.__init__rQ c C rR )z� Build a string representation of this L{FileAlias} instance. @rtype: L{bytes} @return: A string containing the name of the file. z<File rS )r rB r r r rT R rC zFileAlias.__str__c C � t | j�S )z� Create a message receiver which delivers a message to the file. @rtype: L{FileWrapper} @return: A message receiver which writes a message to the file. )rZ r rB r r r rE [ � z FileAlias.createMessageReceiverN)rK rL rM rN r@ r rT rE r r r r rm > s rm c @ s e Zd ZdZdS )�ProcessAliasTimeoutzb An error indicating that a timeout occurred while waiting for a process to complete. N)rK rL rM rN r r r r rp e s rp c @ s` e Zd ZdZdZdZdZeZddd�Zdd� Z d d � Z d d � Z d d� Z dd� Z defdd�ZdS )�MessageWrapperaF A message receiver which delivers a message to a child process. @type completionTimeout: L{int} or L{float} @ivar completionTimeout: The number of seconds to wait for the child process to exit before reporting the delivery as a failure. @type _timeoutCallID: L{None} or L{IDelayedCall <twisted.internet.interfaces.IDelayedCall>} provider @ivar _timeoutCallID: The call used to time out delivery, started when the connection to the child process is closed. @type done: L{bool} @ivar done: A flag indicating whether the child process has exited (C{True}) or not (C{False}). @type reactor: L{IReactorTime <twisted.internet.interfaces.IReactorTime>} provider @ivar reactor: A reactor which will be used to schedule timeouts. @ivar protocol: See L{__init__}. @type processName: L{bytes} or L{None} @ivar processName: The process name. @type completion: L{Deferred <defer.Deferred>} @ivar completion: The deferred which will be triggered by the protocol when the child process exits. F�< Nc C sD || _ || _t�� | _| j| j_| j�| j� |dur || _dS dS )a� @type protocol: L{ProcessAliasProtocol} @param protocol: The protocol associated with the child process. @type process: L{bytes} or L{None} @param process: The process name. @type reactor: L{None} or L{IReactorTime <twisted.internet.interfaces.IReactorTime>} provider @param reactor: A reactor which will be used to schedule timeouts. N) � processNamer r �Deferred� completion�onEnd�addBoth� _processEndedr )r? r �processr r r r r@ � s �zMessageWrapper.__init__c C s( d| _ | jdur| j�� d| _dS |S )a� Record process termination and cancel the timeout call if it is active. @type result: L{Failure <failure.Failure>} @param result: The reason the child process terminated. @rtype: L{None} or L{Failure <failure.Failure>} @return: None, if the process end is expected, or the reason the child process terminated, if the process end is unexpected. TN)�done�_timeoutCallID�cancel)r? r r r r rx � s z MessageWrapper._processEndedc C s | j rdS | jj�|d � dS )z� Write a received line to the child process. @type line: L{bytes} @param line: A received line of the message. Nr^ )rz r � transportr_ r` r r r ra � s zMessageWrapper.lineReceivedc C s, | j s| jj�� | j�| j| j�| _| j S )z� Disconnect from the child process and set up a timeout to wait for it to exit. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which will be called back when the child process exits. ) rz r r} �loseConnectionr � callLater�completionTimeout�_completionCancelr{ ru rB r r r rj � s �zMessageWrapper.eomReceivedc C sD d| _ | jj�d� td| j� d��}d| j_| j�t � |�� dS )z� Handle the expiration of the timeout for the child process to exit by terminating the child process forcefully and issuing a failure to the L{completion} deferred. N�KILLzNo answer after z seconds) r{ r r} � signalProcessrp r� rv ru �errbackr rf )r? �excr r r r� � s z MessageWrapper._completionCancelc C s dS )z9 Ignore notification of lost connection. Nr rB r r r rk � s z MessageWrapper.connectionLostrQ c C rR )z� Build a string representation of this L{MessageWrapper} instance. @rtype: L{bytes} @return: A string containing the name of the process. z<ProcessWrapper rS )rs rB r r r rT � rC zMessageWrapper.__str__�NN)rK rL rM rN rz r� r{ r r@ rx ra rj r� rk r rT r r r r rq l s rq c @ s e Zd ZdZdZdd� ZdS )�ProcessAliasProtocolz� A process protocol which errbacks a deferred when the associated process ends. @type onEnd: L{None} or L{Deferred <defer.Deferred>} @ivar onEnd: If set, a deferred on which to errback when the process ends. Nc C s | j dur | j �|� dS dS )z� Call an errback. @type reason: L{Failure <failure.Failure>} @param reason: The reason the child process terminated. N)rv r� )r? �reasonr r r � processEnded� s �z!ProcessAliasProtocol.processEnded)rK rL rM rN rv r� r r r r r� � s r� c @ s: e Zd ZdZeZdd� Zdefdd�Zdd� Zd d � Z d S ) � ProcessAliasa6 An alias which is handled by the execution of a program. @type path: L{list} of L{bytes} @ivar path: The arguments to pass to the process. The first string is the executable's name. @type program: L{bytes} @ivar program: The path of the program to be executed. @type reactor: L{IReactorTime <twisted.internet.interfaces.IReactorTime>} and L{IReactorProcess <twisted.internet.interfaces.IReactorProcess>} provider @ivar reactor: A reactor which will be used to create and timeout the child process. c G s, t j| g|�R � |�� | _| jd | _dS )aX @type path: L{bytes} @param path: The command to invoke the program consisting of the path to the executable followed by any arguments. @type args: 2-L{tuple} of (0) L{dict} mapping L{bytes} to L{IDomain} provider, (1) L{bytes} @param args: Arguments for L{AliasBase.__init__}. r N)r< r@ r �path�program)r? r� rP r r r r@ s zProcessAlias.__init__rQ c C rR )z� Build a string representation of this L{ProcessAlias} instance. @rtype: L{bytes} @return: A string containing the command used to invoke the process. z <Process rS )r� rB r r r rT . rC zProcessAlias.__str__c C s | j �|||�S )aP Spawn a process. This wraps the L{spawnProcess <twisted.internet.interfaces.IReactorProcess.spawnProcess>} method on L{reactor} so that it can be customized for test purposes. @type proto: L{IProcessProtocol <twisted.internet.interfaces.IProcessProtocol>} provider @param proto: An object which will be notified of all events related to the created process. @type program: L{bytes} @param program: The full path name of the file to execute. @type path: L{list} of L{bytes} @param path: The arguments to pass to the process. The first string should be the executable's name. @rtype: L{IProcessTransport <twisted.internet.interfaces.IProcessTransport>} provider @return: A process transport. )r � spawnProcess)r? �protor� r� r r r r� 7 s zProcessAlias.spawnProcessc C s, t � }t|| j| j�}| �|| j| j� |S )z� Launch a process and create a message receiver to pass a message to the process. @rtype: L{MessageWrapper} @return: A message receiver which delivers a message to the process. )r� rq r� r r� r� )r? r �mr r r rE Q s z"ProcessAlias.createMessageReceiverN) rK rL rM rN r r@ r rT r� rE r r r r r� s r� c @ rY )� MultiWrapperz� A message receiver which delivers a single message to multiple other message receivers. @ivar objs: See L{__init__}. c C s || _ dS )z� @type objs: L{list} of L{IMessage <smtp.IMessage>} provider @param objs: Message receivers to which the incoming message should be directed. N)�objs)r? r� r r r r@ h s zMultiWrapper.__init__c C s | j D ]}|�|� qdS )z� Pass a received line to the message receivers. @type line: L{bytes} @param line: A line of the message. N)r� ra )r? r �or r r ra p s �zMultiWrapper.lineReceivedc C s t �dd� | jD ��S )aG Pass the end of message along to the message receivers. @rtype: L{DeferredList <defer.DeferredList>} whose successful results are L{bytes} or L{None} @return: A deferred list which triggers when all of the message receivers have finished handling their end of message. c S r r )rj )r r� r r r r � r z,MultiWrapper.eomReceived.<locals>.<listcomp>)r � DeferredListr� rB r r r rj z s zMultiWrapper.eomReceivedc C s | j D ]}|�� qdS )zQ Inform the message receivers that the connection has been lost. N)r� rk )r? r� r r r rk � s �zMultiWrapper.connectionLostrQ c C s dt t| j��d�S )z� Build a string representation of this L{MultiWrapper} instance. @rtype: L{bytes} @return: A string containing a list of the message receivers. z<GroupWrapper rS )r r r� rB r r r rT � rb zMultiWrapper.__str__Nrl r r r r r� _ s r� c @ sD e Zd ZdZeZdd� Zdd� Zdefdd�Z d d � Z dd d �Z d S )r4 aL An alias which points to multiple destination aliases. @type processAliasFactory: no-argument callable which returns L{ProcessAlias} @ivar processAliasFactory: A factory for process aliases. @type aliases: L{list} of L{AliasBase} which implements L{IAlias} @ivar aliases: The destination aliases. c G sJ t j| g|�R � g | _|r�|�� �� }|�d�r^z t|dd� �}W n ty8 t� d|dd� ��� Y ngw |� d� dd� |D ��}W d � n1 sPw Y |� |� d�� nA|�d �ru| j� | j|dd� g|�R � � n*|�d �r�tj�|�r�t� d � n| j� t|g|�R � � n | j� t|g|�R � � |sdS dS ) a� Create a group of aliases. Parse a list of alias strings and, for each, create an appropriate alias object. @type items: L{list} of L{bytes} @param items: Aliases. @type args: n-L{tuple} of (0) L{dict} mapping L{bytes} to L{IDomain} provider, (1) L{bytes} @param args: Arguments for L{AliasBase.__init__}. r r Nz Invalid filename in alias file r+ c S r r r )r �lr r r r � r z'AliasGroup.__init__.<locals>.<listcomp>r �|�/z Directory delivery not supported)r< r@ �aliases�popr r1 r- rd r r �joinr r �append�processAliasFactory�osr� �isdirrm rO )r? r3 rP �addrri r r r r@ � s, � � $ �zAliasGroup.__init__c C rn )z� Return the number of aliases in the group. @rtype: L{int} @return: The number of aliases in the group. )r r� rB r r r �__len__� ro zAliasGroup.__len__rQ c C s dd� tt| j�� S )z� Build a string representation of this L{AliasGroup} instance. @rtype: L{bytes} @return: A string containing the aliases in the group. z<AliasGroup [%s]>z, )r� r r r� rB r r r rT � s zAliasGroup.__str__c C s t dd� | jD ��S )a, Create a message receiver for each alias and return a message receiver which will pass on a message to each of those. @rtype: L{MultiWrapper} @return: A message receiver which passes a message on to message receivers for each alias in the group. c S r r )rE )r r: r r r r � r z4AliasGroup.createMessageReceiver.<locals>.<listcomp>)r� r� rB r r r rE � s z AliasGroup.createMessageReceiverNc C s< |du ri }g }| j D ] }|�|�||�� q ttd|��S )a� Map each of the aliases in the group to its ultimate destination. @type aliasmap: L{dict} mapping L{bytes} to L{AliasBase} @param aliasmap: A mapping of username to alias or group of aliases. @type memo: L{None} or L{dict} of L{AliasBase} @param memo: A record of the aliases already considered in the resolution process. If provided, C{memo} is modified to include this alias. @rtype: L{MultiWrapper} @return: A message receiver which passes the message on to message receivers for the ultimate destination of each alias in the group. N)r� r� rI r� �filter)r? rG rH �rr: r r r rI � s zAliasGroup.resolverJ ) rK rL rM rN r� r� r@ r� r rT rE rI r r r r r4 � s & r4 r� ) rN r� r[ �zope.interfacer �twisted.internetr r r � twisted.mailr �twisted.mail.interfacesr �twisted.pythonr r r' r; r< rO �IMessagerZ rm � Exceptionrp rq �ProcessProtocolr� r� r� r4 r r r r �<module> s8 H6FE& T6PK Mb�Z+̱� � & mail/__pycache__/_cred.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z m Z ddl m Z ee �G dd � d ��Zee �G d d � d ��Zee �G d d � d ��Zee �G dd� dej��Zee �G dd� dej��Zg d�ZdS )z* Credential managers for L{twisted.mail}. � N)� implementer)� credentials)�IllegalClientResponse)�IChallengeResponse�IClientAuthentication)� nativeStringc @ �$ e Zd Zdd� Zdd� Zdd� ZdS )�CramMD5ClientAuthenticatorc C � || _ d S �N��user��selfr � r �4/usr/lib/python3/dist-packages/twisted/mail/_cred.py�__init__ � z#CramMD5ClientAuthenticator.__init__c C � dS )Ns CRAM-MD5r �r r r r �getName � z"CramMD5ClientAuthenticator.getNamec C s* t j||tjd��� }| jd |�d� S )N)� digestmod� �ascii)�hmac�HMAC�hashlib�md5� hexdigestr �encode)r �secret�chal�responser r r �challengeResponse s z,CramMD5ClientAuthenticator.challengeResponseN��__name__� __module__� __qualname__r r r$ r r r r r � r c @ �, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �LOGINAuthenticatorc C s || _ | j| _d S r )r �challengeUsernamer$ r r r r r # s zLOGINAuthenticator.__init__c C r )Ns LOGINr r r r r r ' r zLOGINAuthenticator.getNamec C s | j | _| jS r )�challengeSecretr$ r �r r! r" r r r r, * s z$LOGINAuthenticator.challengeUsernamec C s |S r r r. r r r r- / s z"LOGINAuthenticator.challengeSecretN)r& r' r( r r r, r- r r r r r+ ! s r+ c @ r )�PLAINAuthenticatorc C r r r r r r r r 6 r zPLAINAuthenticator.__init__c C r )Ns PLAINr r r r r r 9 r zPLAINAuthenticator.getNamec C s d| j d | S )N� r r. r r r r$ < s z$PLAINAuthenticator.challengeResponseNr% r r r r r/ 4 r) r/ c @ r* ) �LOGINCredentialsc C s( ddg| _ ddg| _tj�| d d � d S )Ns Password s User Name s passwords username)� challenges� responsesr �UsernamePasswordr r r r r r B s zLOGINCredentials.__init__c C s | j �� S r )r2 �popr r r r � getChallengeG r z LOGINCredentials.getChallengec C s t | t| j�� �|� d S r )�setattrr r3 r5 )r r# r r r � setResponseJ s z LOGINCredentials.setResponsec C s t | j�S r )�boolr2 r r r r �moreChallengesM r z LOGINCredentials.moreChallengesN�r& r' r( r r6 r8 r: r r r r r1 @ s r1 c @ r* ) �PLAINCredentialsc C s t j�| d d � d S r )r r4 r r r r r r S s zPLAINCredentials.__init__c C r )N� r r r r r r6 V r z PLAINCredentials.getChallengec C s0 |� d�}t|�dkrtd��|\}| _| _d S )Nr0 � z*Malformed Response - wrong number of parts)�split�lenr �username�password)r r# �parts�uselessr r r r8 Y s z PLAINCredentials.setResponsec C r )NFr r r r r r: _ r z PLAINCredentials.moreChallengesNr; r r r r r< Q s r< )r r1 r+ r< r/ )�__doc__r r �zope.interfacer � twisted.credr �twisted.mail._exceptr �twisted.mail.interfacesr r �twisted.python.compatr r r+ r/ r4 r1 r< �__all__r r r r �<module> s& PK Mb�Zm�v��2 �2 * mail/__pycache__/protocols.cpython-310.pycnu �[��� o �b&0 � @ s� d Z ddlmZ ddlmZ ddlmZmZ ddlm Z ddl m Z m Z ddl mZmZmZ ddlmZ eej�G d d � d ��ZG d d � d e�ZG d d� de�ZG dd� dej�ZG dd� de�ZG dd� dej�ZG dd� de j�Z dS )z Mail protocol support. � )� implementer)� longversion)�CramMD5Credentials�UsernamePassword)�UnauthorizedLogin)�defer�protocol)�pop3�relay�smtp)�logc @ sH e Zd ZU dZdZdZeed< ej fdd�Z dd� Z d d � Z d d � Z dS ) �DomainDeliveryBaseaN A base class for message delivery using the domains of a mail service. @ivar service: See L{__init__} @ivar user: See L{__init__} @ivar host: See L{__init__} @type protocolName: L{bytes} @ivar protocolName: The protocol being used to deliver the mail. Sub-classes should set this appropriately. Ns not-implemented-protocol� protocolNamec C s || _ || _|| _dS )z� @type service: L{MailService} @param service: A mail service. @type user: L{bytes} or L{None} @param user: The authenticated SMTP user. @type host: L{bytes} @param host: The hostname. N)�service�user�host)�selfr r r � r �8/usr/lib/python3/dist-packages/twisted/mail/protocols.py�__init__% s zDomainDeliveryBase.__init__c C s� d }}| j rd| j �d� }|d rd|d }d|d d |d d | | }d | j d | j d t�d � d }dd�tt|�� d t� � }d| d | d | S )a� Generate a received header string for a message. @type helo: 2-L{tuple} of (L{bytes}, L{bytes}) @param helo: The client's identity as sent in the HELO command and its IP address. @type origin: L{Address} @param origin: The origination address of the message. @type recipients: L{list} of L{User} @param recipients: The destination addresses for the message. @rtype: L{bytes} @return: A received header string. � s auth=�xtextr s helo=s from s ([� � ]s by s with s (�ascii� )s for <� s > s Received: s ) r �encoder r r �join�map�bytesr � rfc822date) r �helo�origin� recipients�authStr�heloStr�fromUser�by�forUserr r r �receivedHeader4 s. $������� �z!DomainDeliveryBase.receivedHeaderc C sX | j r | jjr | jj�|jjd�}|du r t�| jd�}n| jj|jj }t � |j |�S )a9 Validate the address for which a message is destined. @type user: L{User} @param user: The destination address. @rtype: L{Deferred <defer.Deferred>} which successfully fires with no-argument callable which returns L{IMessage <smtp.IMessage>} provider. @return: A deferred which successfully fires with a no-argument callable which returns a message receiver for the destination. @raise SMTPBadRcpt: When messages cannot be accepted for the destination address. NT) r r �queue�domains�get�dest�domainr � DomainQueuerr � maybeDeferred�exists)r r �dr r r � validateToY s �z DomainDeliveryBase.validateToc C s8 |s t �|dd��|jdkr|jdkrt �|dd��|S )a� Validate the address from which a message originates. @type helo: 2-L{tuple} of (L{bytes}, L{bytes}) @param helo: The client's identity as sent in the HELO command and its IP address. @type origin: L{Address} @param origin: The origination address of the message. @rtype: L{Address} @return: The origination address. @raise SMTPBadSender: When messages cannot be accepted from the origination address. i� z Who are you? Say HELO first.r i� z#Sender address must contain domain.)r � SMTPBadSender�localr/ )r r" r# r r r � validateFromr s z DomainDeliveryBase.validateFrom)�__name__� __module__� __qualname__�__doc__r r r �__annotations__r �DNSNAMEr r* r4 r7 r r r r r s % r c @ � e Zd ZdZdZdS )�SMTPDomainDeliveryzA A domain delivery base class for use in an SMTP server. s smtpN�r8 r9 r: r; r r r r r r? � � r? c @ r> )�ESMTPDomainDeliveryzB A domain delivery base class for use in an ESMTP server. s esmtpNr@ r r r r rB � rA rB c @ s, e Zd ZdZejZdZddd�Zdd� Z dS )� SMTPFactorya; An SMTP server protocol factory. @ivar service: See L{__init__} @ivar portal: See L{__init__} @type protocol: no-argument callable which returns a L{Protocol <protocol.Protocol>} subclass @ivar protocol: A callable which creates a protocol. The default value is L{SMTP}. Nc C s t j�| � || _|| _dS )z� @type service: L{MailService} @param service: An email service. @type portal: L{Portal <twisted.cred.portal.Portal>} or L{None} @param portal: A portal to use for authentication. N)r rC r r �portal)r r rD r r r r � s zSMTPFactory.__init__c C s2 t �d|� �� tj�| |�}| j|_| j|_|S )a Create an instance of an SMTP server protocol. @type addr: L{IAddress <twisted.internet.interfaces.IAddress>} provider @param addr: The address of the SMTP client. @rtype: L{SMTP} @return: An SMTP protocol. zConnection from )r �msgr rC � buildProtocolr rD �r �addr�pr r r rF � s zSMTPFactory.buildProtocol)N) r8 r9 r: r; r �SMTPr rD r rF r r r r rC � s rC c @ s* e Zd ZdZejZdZdd� Zdd� Z dS )� ESMTPFactorya An ESMTP server protocol factory. @type protocol: no-argument callable which returns a L{Protocol <protocol.Protocol>} subclass @ivar protocol: A callable which creates a protocol. The default value is L{ESMTP}. @type context: L{IOpenSSLContextFactory <twisted.internet.interfaces.IOpenSSLContextFactory>} or L{None} @ivar context: A factory to generate contexts to be used in negotiating encrypted communication. @type challengers: L{dict} mapping L{bytes} to no-argument callable which returns L{ICredentials <twisted.cred.credentials.ICredentials>} subclass provider. @ivar challengers: A mapping of acceptable authorization mechanism to callable which creates credentials to use for authentication. Nc G s t j| g|�R � dti| _dS )zk @param args: Arguments for L{SMTPFactory.__init__} @see: L{SMTPFactory.__init__} s CRAM-MD5N)rC r r � challengers)r �argsr r r r � s zESMTPFactory.__init__c C s t �| |�}| j|_| j|_|S )a Create an instance of an ESMTP server protocol. @type addr: L{IAddress <twisted.internet.interfaces.IAddress>} provider @param addr: The address of the ESMTP client. @rtype: L{ESMTP} @return: An ESMTP protocol. )rC rF rL �context�ctxrG r r r rF � s zESMTPFactory.buildProtocol) r8 r9 r: r; r �ESMTPr rN r rF r r r r rK � s rK c @ s0 e Zd ZdZdZdZdd� Zdd� Zdd � ZdS ) � VirtualPOP3a[ A virtual hosting POP3 server. @type service: L{MailService} @ivar service: The email service that created this server. This must be set by the service. @type domainSpecifier: L{bytes} @ivar domainSpecifier: The character to use to split an email address into local-part and domain. The default is '@'. N� @c C sZ | � |�\}}z| j�|�}W n ty t�t� � Y S w |�t� | j ||�dtj �S )a1 Perform APOP authentication. Override the default lookup scheme to allow virtual domains. @type user: L{bytes} @param user: The name of the user attempting to log in. @type digest: L{bytes} @param digest: The challenge response. @rtype: L{Deferred} which successfully results in 3-L{tuple} of (L{IMailbox <pop3.IMailbox>}, L{IMailbox <pop3.IMailbox>} provider, no-argument callable) @return: A deferred which fires when authentication is complete. If successful, it returns an L{IMailbox <pop3.IMailbox>} interface, a mailbox and a logout function. If authentication fails, the deferred fails with an L{UnauthorizedLogin <twisted.cred.error.UnauthorizedLogin>} error. N) � lookupDomainr � lookupPortal�KeyErrorr �failr �loginr �APOPCredentials�magic�IMailbox)r r �digestr/ rD r r r �authenticateUserAPOP s ��z VirtualPOP3.authenticateUserAPOPc C sT | � |�\}}z| j�|�}W n ty t�t� � Y S w |�t||�dt j �S )aY Perform authentication for a username/password login. Override the default lookup scheme to allow virtual domains. @type user: L{bytes} @param user: The name of the user attempting to log in. @type password: L{bytes} @param password: The password to authenticate with. @rtype: L{Deferred} which successfully results in 3-L{tuple} of (L{IMailbox <pop3.IMailbox>}, L{IMailbox <pop3.IMailbox>} provider, no-argument callable) @return: A deferred which fires when authentication is complete. If successful, it returns an L{IMailbox <pop3.IMailbox>} interface, a mailbox and a logout function. If authentication fails, the deferred fails with an L{UnauthorizedLogin <twisted.cred.error.UnauthorizedLogin>} error. N) rS r rT rU r rV r rW r r rZ )r r �passwordr/ rD r r r �authenticateUserPASS+ s �z VirtualPOP3.authenticateUserPASSc C sX z |� | jd�\}}W n ty d}Y nw || jjvr(t�d�|�d����||fS )a� Check whether a domain is among the virtual domains supported by the mail service. @type user: L{bytes} @param user: An email address. @rtype: 2-L{tuple} of (L{bytes}, L{bytes}) @return: The local part and the domain part of the email address if the domain is supported. @raise POP3Error: When the domain is not supported by the mail service. r r zno such domain {}zutf-8) �split�domainSpecifier� ValueErrorr r, r � POP3Error�format�decode)r r r/ r r r rS H s � zVirtualPOP3.lookupDomain) r8 r9 r: r; r r` r\ r^ rS r r r r rQ � s rQ c @ s( e Zd ZdZeZdZdd� Zdd� ZdS )� POP3Factorya A POP3 server protocol factory. @ivar service: See L{__init__} @type protocol: no-argument callable which returns a L{Protocol <protocol.Protocol>} subclass @ivar protocol: A callable which creates a protocol. The default value is L{VirtualPOP3}. Nc C s || _ dS )zY @type service: L{MailService} @param service: An email service. N)r )r r r r r r n s zPOP3Factory.__init__c C s t j�| |�}| j|_|S )a Create an instance of a POP3 server protocol. @type addr: L{IAddress <twisted.internet.interfaces.IAddress>} provider @param addr: The address of the POP3 client. @rtype: L{POP3} @return: A POP3 protocol. )r � ServerFactoryrF r rG r r r rF u s zPOP3Factory.buildProtocol) r8 r9 r: r; rQ r r r rF r r r r re _ s re N) r; �zope.interfacer �twisted.copyrightr �twisted.cred.credentialsr r �twisted.cred.errorr �twisted.internetr r � twisted.mailr r r �twisted.pythonr �IMessageDeliveryr r? rB rC rK �POP3rQ rf re r r r r �<module> s u.1fPK Mb�Z �+��- �- $ mail/__pycache__/tap.cpython-310.pycnu �[��� o �b�1 � @ s� d Z ddlZddlmZ ddlmZmZ ddlmZ ddl m Z m Z m Z m Z mZ ddlmZ G dd � d ejej�ZG d d � d �Zd d � ZdS )z0 Support for creating mail servers with twistd. � N)�internet)�checkers�strcred)� endpoints)�alias�mail�maildir�relay� relaymanager)�usagec @ s� e Zd ZdZdZg d�g d�gZg d�g d�g d�g d�gZd d d �Zej d e� � id �Z dZ dd� Z dd� Zdd� ZeZdd� ZeZdd� ZeZdd� ZeZdd � ZeZd d � ZeZd d � ZeZ d!d"� Z d#d$� Z d%S )&�Optionsa� An options list parser for twistd mail. @type synopsis: L{bytes} @ivar synopsis: A description of options for use in the usage message. @type optParameters: L{list} of L{list} of (0) L{bytes}, (1) L{bytes}, (2) L{object}, (3) L{bytes}, (4) L{None} or callable which takes L{bytes} and returns L{object} @ivar optParameters: Information about supported parameters. See L{Options <twisted.python.usage.Options>} for details. @type optFlags: L{list} of L{list} of (0) L{bytes}, (1) L{bytes} or L{None}, (2) L{bytes} @ivar optFlags: Information about supported flags. See L{Options <twisted.python.usage.Options>} for details. @type _protoDefaults: L{dict} mapping L{bytes} to L{int} @ivar _protoDefaults: A mapping of default service to port. @type compData: L{Completions <usage.Completions>} @ivar compData: Metadata for the shell tab completion system. @type longdesc: L{bytes} @ivar longdesc: A long description of the plugin for use in the usage message. @type service: L{MailService} @ivar service: The email service. @type last_domain: L{IDomain} provider or L{None} @ivar last_domain: The most recently specified domain. z [options])r �RNz[Relay messages according to their envelope 'To', using the given path as a queue directory.)�hostname�HNz.The hostname by which to identify this server.)�esmtp�Ez!Use RFC 1425/1869 SMTP extensions)�disable-anonymousNz+Disallow non-authenticated SMTP connections)zno-pop3Nz Disable the default POP3 server.)zno-smtpNz Disable the default SMTP server.i� iY )�pop3�smtpr )� optActionsa� An SMTP / POP3 email server plugin for twistd. Examples: 1. SMTP and POP server twistd mail --maildirdbmdomain=example.com=/tmp/example.com --user=joe=password Starts an SMTP server that only accepts emails to joe@example.com and saves them to /tmp/example.com. Also starts a POP mail server which will allow a client to log in using username: joe@example.com and password: password and collect any email that has been saved in /tmp/example.com. 2. SMTP relay twistd mail --relay=/tmp/mail_queue Starts an SMTP server that accepts emails to any email address and relays them to an appropriate remote SMTP server. Queued emails will be temporarily stored in /tmp/mail_queue. c C s4 t j�| � t�� | _d| _| jD ]}g | |< qdS )z: Parse options and create a mail service. N)r r �__init__r � MailService�service� last_domain�_protoDefaults)�selfr � r �2/usr/lib/python3/dist-packages/twisted/mail/tap.pyr k s �zOptions.__init__c C s& ddl m} | | �t�||�� dS )a Add an endpoint to a service. @type service: L{bytes} @param service: A service, either C{b'smtp'} or C{b'pop3'}. @type description: L{bytes} @param description: An endpoint description string or a TCP port number. r ��reactorN)�twisted.internetr �appendr �serverFromString)r r � descriptionr r r r � addEndpointu s zOptions.addEndpointc C � | � d|� dS )z� Add a POP3 port listener on the specified endpoint. You can listen on multiple ports by specifying multiple --pop3 options. r N�r$ �r r# r r r �opt_pop3� � zOptions.opt_pop3c C r% )z� Add an SMTP port listener on the specified endpoint. You can listen on multiple ports by specifying multiple --smtp options. r Nr& r' r r r �opt_smtp� r) zOptions.opt_smtpc C s$ | j r | j�d| j � dS t�d��)zM Make the most recently specified domain the default domain. � z2Specify a domain before specifying using --defaultN)r r � addDomainr � UsageError�r r r r � opt_default� s zOptions.opt_defaultc C sX z |� d�\}}W n ty t�d��w t�| jtj� |��| _ | j� || j � dS )a; Generate an SMTP/POP3 virtual domain. This option requires an argument of the form 'NAME=PATH' where NAME is the DNS domain name for which email will be accepted and where PATH is a the filesystem path to a Maildir folder. [Example: 'example.com=/tmp/example.com'] �=z>Argument to --maildirdbmdomain must be of the form 'name=path'N) �split� ValueErrorr r- r �MaildirDirdbmDomainr �os�path�abspathr r, )r �domain�namer5 r r r �opt_maildirdbmdomain� s ���z Options.opt_maildirdbmdomainc C sP z |� dd�\}}W n ty t�d��w | jr#| j�||� dS t�d��)zG Add a user and password to the last specified domain. r0 � z6Argument to --user must be of the form 'user=password'z(Specify a domain before specifying usersN)r1 r2 r r- r �addUser)r � user_pass�user�passwordr r r �opt_user� s �� zOptions.opt_userc C s d| j _dS )z@ Send undeliverable messages to the postmaster. r: N)r � postmasterr. r r r �opt_bounce_to_postmaster� s z Options.opt_bounce_to_postmasterc C st | j dur5tj�| j �r*t�| jj|�}| j �|� | jj � |t | jj| j �� dS t � d| j jjf ��t � d��)zR Specify an aliases(5) file to use for the last specified domain. Nz %s does not support alias filesz*Specify a domain before specifying aliases)r r �IAliasableDomain� providedByr � loadAliasFiler �domains� setAliasGroup�monitor� monitorFile� AliasUpdaterr r- � __class__�__name__)r �filename�aliasesr r r � opt_aliases� s � �� zOptions.opt_aliasesc C s4 | | r| | S | d| rg S t �|| j| �gS )a� Return a list of endpoints for the specified service, constructing defaults if necessary. If no endpoints were configured for the service and the protocol was not explicitly disabled with a I{--no-*} option, a default endpoint for the service is created. @type reactor: L{IReactorTCP <twisted.internet.interfaces.IReactorTCP>} provider @param reactor: If any endpoints are created, the reactor with which they are created. @type service: L{bytes} @param service: The type of service for which to retrieve endpoints, either C{b'pop3'} or C{b'smtp'}. @rtype: L{list} of L{IStreamServerEndpoint <twisted.internet.interfaces.IStreamServerEndpoint>} provider @return: The endpoints for the specified service as configured by the command line parameters. zno-)r �TCP4ServerEndpointr )r r r r r r � _getEndpoints� s zOptions._getEndpointsc C s� ddl m} | d r| d du rt�d��d| v r'| d D ] }| jj�|� q | d s4| jj�t�� � d }| j D ]}| � ||�| |< | | rId }q9|sQt�d ��dS ) z� Check the validity of the specified set of options and configure authentication. @raise UsageError: When the set of options is invalid. r r r r Nz--esmtp requires --hostname� credCheckersr FTz You cannot disable all protocols) r r r r- r � smtpPortal�registerCheckerr �AllowAnonymousAccessr rP )r r �ch�anythingr r r r � postOptions s" � �zOptions.postOptionsN) rK � __module__� __qualname__�__doc__�synopsis� optParameters�optFlagsr r � Completions�CompleteHostnames�compData�longdescr r$ r( �opt_pr* �opt_sr/ �opt_Dr9 �opt_dr? �opt_urA �opt_brN �opt_ArP rW r r r r r sD "� �� "r c @ s e Zd ZdZdd� Zdd� ZdS )rI z� A callable object which updates the aliases for a domain from an aliases(5) file. @ivar domains: See L{__init__}. @ivar domain: See L{__init__}. c C s || _ || _dS )z� @type domains: L{dict} mapping L{bytes} to L{IDomain} provider @param domains: A mapping of domain name to domain object @type domain: L{IAliasableDomain} provider @param domain: The domain to update. N)rE r7 )r rE r7 r r r r 2 s zAliasUpdater.__init__c C s | j �t�| j|�� dS )z� Update the aliases for a domain from an aliases(5) file. @type new: L{bytes} @param new: The name of an aliases(5) file. N)r7 rF r rD rE )r �newr r r �__call__= s zAliasUpdater.__call__N)rK rX rY rZ r rj r r r r rI ) s rI c C sh | d r t j}| jj}nt j}| jj}| d rc| d }tj�|�s&t� |� | j� t � |�� t � | j�}|| jj�}| d rF| jd7 _| j| d f7 _t �|d�}|�| j� | jj�|� | d r| j�� }| d D ]}t�||�} | �| j� qp| d r�|� }| d r�| d |_|jf|_| d r�d|j |_| d D ]}t�||�} | �| j� q�| jS )a� Configure a service for operating a mail server. The returned service may include POP3 servers, SMTP servers, or both, depending on the configuration passed in. If there are multiple servers, they will share all of their non-network state (i.e. the same user accounts are available on all of them). @type config: L{Options <usage.Options>} @param config: Configuration options specifying which servers to include in the returned service and where they should keep mail data. @rtype: L{IService <twisted.application.service.IService>} provider @return: A service which contains the requested mail servers. r r )NNr r: r r )r � SmartHostESMTPRelayingManagerr �getESMTPFactory� SmartHostSMTPRelayingManager�getSMTPFactoryr4 r5 �isdir�mkdir�setQueue�Queuer � DomainQueuer�queue�fArgs�RelayStateHelper�setServiceParentrE �setDefaultDomain�getPOP3Factoryr �StreamServerEndpointServicer7 ) �config�rmType� smtpFactory�dir�default�manager�helper�f�endpoint�svcr r r � makeServiceG sD r� )rZ r4 �twisted.applicationr � twisted.credr r r r � twisted.mailr r r r r �twisted.pythonr r �AuthOptionMixinrI r� r r r r �<module> s PK Mb�Z� H�� �� % mail/__pycache__/pop3.cpython-310.pycnu �[��� o �bg� � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl m Z ddl m Z mZmZ ddlmZ dd lmZmZmZ dd lmZmZ dd lm Z m Z dd l m Z e e j j!�G d d� d��Z"G dd� d�Z#G dd� d�Z$dd� Z%dd� Z&dd� Z'dd� Z(dd � Z)d d � Z*d d � Z+e ej,�G d!d"� d"e j-e j.��Z/e e�G d#d$� d$��Z0e1d%�\Z2Z3Z4Z5i Z6e2e6e2< e2e6e3< e5e6e4< e2e6e5< G d&d'� d'e j-�Z7dd(lm8Z8m9Z9m:Z:m;Z;m<Z< dd)l=m7Z> g d*�Z?dS )+zQ Post-office Protocol version 3. @author: Glyph Lefkowitz @author: Jp Calderone � N)�md5)�Optional)� implementer)�cred)�defer� interfaces�task)�smtp)�POP3ClientError� POP3Error�_POP3MessageDeleted)� IMailboxPOP3�IServerFactoryPOP3)�basic�policies)�logc @ � e Zd ZdZdd� Zdd� ZdS )�APOPCredentialsz� Credentials for use in APOP authentication. @ivar magic: See L{__init__} @ivar username: See L{__init__} @ivar digest: See L{__init__} c C s || _ || _|| _dS )a� @type magic: L{bytes} @param magic: The challenge string used to encrypt the password. @type username: L{bytes} @param username: The username associated with these credentials. @type digest: L{bytes} @param digest: An encrypted version of the user's password. Should be generated as an MD5 hash of the challenge string concatenated with the plaintext password. N)�magic�username�digest)�selfr r r � r �3/usr/lib/python3/dist-packages/twisted/mail/pop3.py�__init__- s zAPOPCredentials.__init__c C s | j | }t|��� }|| jkS )a4 Validate a plaintext password against the credentials. @type password: L{bytes} @param password: A plaintext password. @rtype: L{bool} @return: C{True} if the credentials represented by this object match the given password, C{False} if they do not. )r r � hexdigestr )r �password�seed�myDigestr r r � checkPassword> s z APOPCredentials.checkPasswordN)�__name__� __module__� __qualname__�__doc__r r r r r r r # s r c @ r )�_HeadersPlusNLinesa� A utility class to retrieve the header and some lines of the body of a mail message. @ivar _file: See L{__init__} @ivar _extraLines: See L{__init__} @type linecount: L{int} @ivar linecount: The number of full lines of the message body scanned. @type headers: L{bool} @ivar headers: An indication of which part of the message is being scanned. C{True} for the header and C{False} for the body. @type done: L{bool} @ivar done: A flag indicating when the desired part of the message has been scanned. @type buf: L{bytes} @ivar buf: The portion of the message body that has been scanned, up to C{n} lines. c C s( || _ || _d| _d| _d| _d| _dS )z� @type file: file-like object @param file: A file containing a mail message. @type extraLines: L{int} @param extraLines: The number of lines of the message body to retrieve. r � � N)�_file� _extraLines� linecount�headers�done�buf)r �file� extraLinesr r r r f s z_HeadersPlusNLines.__init__c C s� | j rdS | j�|�}|s|S | jrA|�d�d}}|dkr&|�d�d}}|dkr@||7 }|d|� }||d� }d| _d | _nd}| jd krz| j| �d �}|d | _|dd� D ] }| j| jkrjd| _ | S ||d 7 }| jd7 _q[|S |S ) a Scan bytes from the file. @type bytes: L{int} @param bytes: The number of bytes to read from the file. @rtype: L{bytes} @return: Each portion of the header as it is scanned. Then, full lines of the message body as they are scanned. When more than one line of the header and/or body has been scanned, the result is the concatenation of the lines. When the scan results in no full lines, the empty string is returned. r& s � ���s � Nr% r � ) r+ r' �readr* �findr) r, �splitr( )r �bytes�data�df�sz�val�dsplit�lnr r r r3 u s8 � z_HeadersPlusNLines.readN)r r! r" r# r r3 r r r r r$ N s r$ c @ s2 e Zd ZdZdZd dd�Zdd� Zdd � ZeZdS ) �_IteratorBuffera� An iterator which buffers the elements of a container and periodically passes them as input to a writer. @ivar write: See L{__init__}. @ivar memoryBufferSize: See L{__init__}. @type bufSize: L{int} @ivar bufSize: The number of bytes currently in the buffer. @type lines: L{list} of L{bytes} @ivar lines: The buffer, which is a list of strings. @type iterator: iterator which yields L{bytes} @ivar iterator: An iterator over a container of strings. r Nc C s, g | _ || _t|�| _|du rd}|| _dS )a� @type write: callable that takes L{list} of L{bytes} @param write: A writer which is a callable that takes a list of strings. @type iterable: iterable which yields L{bytes} @param iterable: An iterable container of strings. @type memoryBufferSize: L{int} or L{None} @param memoryBufferSize: The number of bytes to buffer before flushing the buffer to the writer. Ni )�lines�write�iter�iterator�memoryBufferSize)r r? �iterablerB r r r r � s z_IteratorBuffer.__init__c C � | S )z� Return an iterator. @rtype: iterator which yields L{bytes} @return: An iterator over strings. r �r r r r �__iter__� � z_IteratorBuffer.__iter__c C s� zt | j�}W n ty | jr| �| j� | `| `| `� w |durF| j�|� | jt|�7 _| j| jkrH| �| j� g | _d| _dS dS dS )a\ Get the next string from the container, buffer it, and possibly send the buffer to the writer. The contents of the buffer are written when it is full or when no further values are available from the container. @raise StopIteration: When no further values are available from the container. Nr ) �nextrA � StopIterationr> r? �append�bufSize�lenrB )r �vr r r �__next__� s" � �z_IteratorBuffer.__next__�N) r r! r" r# rK r rF rN rH r r r r r= � s r= c C s t | jj|�}| �|�S )a} Direct the output of an iterator to the transport of a protocol and arrange for iteration to take place. @type proto: L{POP3} @param proto: A POP3 server protocol. @type gen: iterator which yields L{bytes} @param gen: An iterator over strings. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which fires when the iterator finishes. )r= � transport� writeSequence�schedule)�proto�gen�collr r r �iterateLineGenerator� s rV c C s$ t | t�s t| ��d�} d| d S )z� Format an object as a positive response. @type response: stringifyable L{object} @param response: An object with a string representation. @rtype: L{bytes} @return: A positive POP3 response string. �utf-8s +OK � )� isinstancer6 �str�encode)�responser r r �successResponse s r] c c s@ � d}d}| D ] }|d7 }||7 }dV qt d||f �V dS )a� Format a list of message sizes into a STAT response. This generator function is intended to be used with L{Cooperator <twisted.internet.task.Cooperator>}. @type msgs: L{list} of L{int} @param msgs: A list of message sizes. @rtype: L{None} or L{bytes} @return: Yields none until a result is available, then a string that is suitable for use in a STAT response. The string consists of the number of messages and the total size of the messages in octets. r r% N� %d %d�r] )�msgs�ir6 �sizer r r �formatStatResponse s �rc c c s* � d}| D ] }|d7 }d||f V qdS )a_ Format a list of message sizes for use in a LIST response. @type msgs: L{list} of L{int} @param msgs: A list of message sizes. @rtype: L{bytes} @return: Yields a series of strings that are suitable for use as scan listings in a LIST response. Each string consists of a message number and its size in octets. r r% s %d %d Nr )r` ra rb r r r �formatListLines+ s � �rd c c s. � t dt| �f �V t| �E dH dV dS )ai Format a list of message sizes into a complete LIST response. This generator function is intended to be used with L{Cooperator <twisted.internet.task.Cooperator>}. @type msgs: L{list} of L{int} @param msgs: A list of message sizes. @rtype: L{bytes} @return: Yields a series of strings which make up a complete LIST response. s %dN� . )r] rL rd �r` r r r �formatListResponse= s � rg c c sR � t | �D ]!\}}|dur&||�}t|t�s t|��d�}d|d |f V qdS )ar Format a list of message sizes for use in a UIDL response. @param msgs: See L{formatUIDListResponse} @param getUidl: See L{formatUIDListResponse} @rtype: L{bytes} @return: Yields a series of strings that are suitable for use as unique-id listings in a UIDL response. Each string consists of a message number and its unique id. NrW s %d %b r% )� enumeraterY r6 rZ r[ )r` �getUidlra �m�uidr r r �formatUIDListLinesO s � ��rl c c s& � t d�V t| |�E dH dV dS )a. Format a list of message sizes into a complete UIDL response. This generator function is intended to be used with L{Cooperator <twisted.internet.task.Cooperator>}. @type msgs: L{list} of L{int} @param msgs: A list of message sizes. @type getUidl: one-argument callable returning bytes @param getUidl: A callable which takes a message index number and returns the UID of the corresponding message in the mailbox. @rtype: L{bytes} @return: Yields a series of strings which make up a complete UIDL response. � Nre )r] rl )r` ri r r r �formatUIDListResponsec s � rn c @ s� e Zd ZU dZdZee ed< dZdZ g d�Z dZ dZ dZ dZdZdZeej�ZdZdd � Zd d � Zd d � ZdXdd�ZdYdd�Zdd� Zdd� Z dd� Z dd� Z d d � Z d d � Z dZd d!�Z!d"d#� Z"d$d%� Z#d&d'� Z$d(d)� Z%d*d+� Z&d,d-� Z'd.d/� Z(d0d1� Z)d2d3� Z*d4d5� Z+dZd6d7�Z,dZd8d9�Z-d:d;� Z.d<d=� Z/d>d?� Z0d@dA� Z1dBdC� Z2dDdE� Z3dFdG� Z4dHdI� Z5dJdK� Z6dLdM� Z7dNdO� Z8dPdQ� Z9dRdS� Z:dTdU� Z;dVdW� Z<dS )[�POP3a� A POP3 server protocol. @type portal: L{Portal} @ivar portal: A portal for authentication. @type factory: L{IServerFactory} provider @ivar factory: A server factory which provides an interface for querying capabilities of the server. @type timeOut: L{int} @ivar timeOut: The number of seconds to wait for a command from the client before disconnecting. @type schedule: callable that takes interator and returns L{Deferred <defer.Deferred>} @ivar schedule: A callable that arranges for an iterator to be cooperatively iterated over along with all other iterators which have been passed to it such that runtime is divided between all of them. It returns a deferred which fires when the iterator finishes. @type magic: L{bytes} or L{None} @ivar magic: An APOP challenge. If not set, an APOP challenge string will be generated when a connection is made. @type _userIs: L{bytes} or L{None} @ivar _userIs: The username sent with the USER command. @type _onLogout: no-argument callable or L{None} @ivar _onLogout: The function to be executed when the connection is lost. @type mbox: L{IMailbox} provider @ivar mbox: The mailbox for the authenticated user. @type state: L{bytes} @ivar state: The state which indicates what type of messages are expected from the client. Valid states are 'COMMAND' and 'AUTH' @type blocked: L{None} or L{list} of 2-L{tuple} of (E{1}) L{bytes} (E{2}) L{tuple} of L{bytes} @ivar blocked: A list of blocked commands. While a response to a command is being generated by the server, other commands are blocked. When no command is outstanding, C{blocked} is set to none. Otherwise, it contains a list of information about blocked commands. Each list entry consists of the command and the arguments to the command. @type _highest: L{int} @ivar _highest: The 1-based index of the highest message retrieved. @type _auth: L{IUsernameHashedPassword <cred.credentials.IUsernameHashedPassword>} provider @ivar _auth: Authorization credentials. Nr )s CAPA� USER� PASS� APOPs AUTHs RPOP� QUITi, �COMMANDr c C sZ | j du r | �� | _ | �| j � | �| j� t| jdd�r+t�dt | j � � � � dS dS )zS Send a greeting to the client after the connection has been made. N�noisyTzNew connection from ) r � generateMagicr] � setTimeout�timeOut�getattr�factoryr �msgrZ rP �getPeerrE r r r �connectionMade� s �zPOP3.connectionMadec C s& | j dur | � � d| _ | �d� dS )z� Clean up when the connection has been lost. @type reason: L{Failure} @param reason: The reason the connection was terminated. N)� _onLogoutrw )r �reasonr r r �connectionLost� s zPOP3.connectionLostc C s t �� S )z} Generate an APOP challenge. @rtype: L{bytes} @return: An RFC 822 message id format string. )r � messageidrE r r r rv � s zPOP3.generateMagicrm c C s | j �t|�� dS )z� Send a response indicating success. @type message: stringifyable L{object} @param message: An object whose string representation should be included in the response. N)rP r? r] �r �messager r r r] � s zPOP3.successResponser& c C s* t |t�s t|��d�}| �d| � dS )z� Send a response indicating failure. @type message: stringifyable L{object} @param message: An object whose string representation should be included in the response. rW s -ERR N)rY r6 rZ r[ �sendLiner� r r r � failResponse� s zPOP3.failResponsec C s | � � t| d| j �|� dS )z� Pass a received line to a state machine function. @type line: L{bytes} @param line: A received line. �state_N)� resetTimeoutry �state�r �liner r r � lineReceived s zPOP3.lineReceivedc C sf | j }d| _ |r$| j du r$|�d�\}}| j|g|�R � |r$| j du s | j dur1| j �|� dS dS )z� Process as many blocked commands as possible. If there are no more blocked commands, set up for the next command to be sent immediately. @type _: L{object} @param _: Ignored. Nr )�blocked�pop�processCommand�extend)r �_�commands�cmd�argsr r r �_unblock s � �z POP3._unblockc C sr z | j |�d�� W S ttttfy8 } z t�� | �d� d|j j � d�d� |j �g�� W Y d}~dS d}~ww )z� Handle received lines for the COMMAND state in which commands from the client are expected. @type line: L{bytes} @param line: A received command. � s : s bad protocol or serverrW r& N)r� r5 � ValueError�AttributeErrorr � TypeErrorr �errr� �join� __class__r r[ r� )r r� �er r r � state_COMMAND s �����zPOP3.state_COMMANDc G st | j dur| j �||f� dS |�� }|| jv }| js#|s#td| ��t| d|�d� d�}|r4||� S td| ��)aq Dispatch a command from the client for handling. @type command: L{bytes} @param command: A POP3 command. @type args: L{tuple} of L{bytes} @param args: Arguments to the command. @raise POP3Error: When the command is invalid or the command requires prior authentication which hasn't been performed. Ns! not authenticated yet: cannot do �do_rW s Unknown protocol command: )r� rJ �upper� AUTH_CMDS�mboxr ry �decode)r �commandr� �authCmd�fr r r r� 4 s zPOP3.processCommandc C s� g d�}t �| j�r�z| j�� }|r t|t�s t|��d�}W n ty( Y n t y4 t � � Y nw |� d| � z| j� � }|rPt|t�sPt|��d�}W n tyZ Y n0 t yf t � � Y n$w |du rmd}| j�� r�| jrt| jj��d�}n|d }|� d| � z| j�� }|r�t|t�s�t|��d�}W n ty� Y n* t y� t � � Y n w | j�� r�| jr�t| jj��d�}n|d }|� d| � z| jj}W n ty� Y |S t y� t � � Y |S w |� d d �|�� � � |S ) z� Return a list of server capabilities suitable for use in a CAPA response. @rtype: L{list} of L{bytes} @return: A list of server capabilities. )s TOPrp � UIDLs PIPELINEs CELERITYs AUSPEXs POTENCErW s IMPLEMENTATION Ns NEVERs USERs EXPIRE s LOGIN-DELAY s SASL r� )�IServerFactory� providedByrz �cap_IMPLEMENTATIONrY r6 rZ r[ �NotImplementedError� BaseExceptionr r� rJ � cap_EXPIRE�perUserExpirationr� �messageExpiration�cap_LOGIN_DELAY�perUserLoginDelay� loginDelay� challengersr� r� �keys)r �baseCapsrM r r r �listCapabilitiesN sp � � � � � � � �zPOP3.listCapabilitiesc C s0 | � d� | �� D ]}| �|� q | �d� dS )zW Handle a CAPA command. Respond with the server capabilities. s I can do the following:� .N)r] r� r� )r �capr r r �do_CAPA� s z POP3.do_CAPAc C s� t | jdd�s| �d� dS |du r,| �d� | jjD ] }| �|�� � q| �d� dS | jj�|�� �� �}| j r<|sC| �d� dS |� | _ | j � � }| �dt � |� � d| _dS ) a� Handle an AUTH command. If the AUTH extension is not supported, send an error response. If an authentication mechanism was not specified in the command, send a list of all supported authentication methods. Otherwise, send an authentication challenge to the client and transition to the AUTH state. @type args: L{bytes} or L{None} @param args: The name of an authentication mechanism. r� Ns AUTH extension unsupportedz!Supported authentication methods:r� s Unsupported SASL selecteds + �AUTH)ry rz r� r] r� r� r� �get�strip�portal�_auth� getChallenge�base64� b64encoder� )r r� �a�auth�chalr r r �do_AUTH� s" z POP3.do_AUTHc C s� d| _ z t�|��dd�}W n tjy | �d� Y dS w t|�dkr,| �d� dS |d | j_ |d | j_ | j � | jdt �}|�| j|d � |�| j� |�| j� dS )a� Handle received lines for the AUTH state in which an authentication challenge response from the client is expected. Transition back to the COMMAND state. Check the credentials and complete the authorization process with the L{_cbMailbox} callback function on success or the L{_ebMailbox} and L{_ebUnexpected} errback functions on failure. @type line: L{bytes} @param line: The challenge response. rt Nr% s Invalid BASE64 encodingr1 s Invalid AUTH responser )r� r� � b64decoder5 �binascii�Errorr� rL r� r r\ r� �login�IMailbox� addCallback� _cbMailbox� addErrback� _ebMailbox� _ebUnexpected)r r� �parts�dr r r � state_AUTH� s � zPOP3.state_AUTHc C s2 t �| j||�}|j| j| j|fd��| j� dS )a� Handle an APOP command. Perform APOP authentication and complete the authorization process with the L{_cbMailbox} callback function on success or the L{_ebMailbox} and L{_ebUnexpected} errback functions on failure. @type user: L{bytes} @param user: A username. @type digest: L{bytes} @param digest: An MD5 digest string. �� callbackArgsN)r � maybeDeferred�authenticateUserAPOP� addCallbacksr� r� r� r� )r �userr r� r r r �do_APOP� s �z POP3.do_APOPc C sd |\}}}|t ur| �d� t�d� dS || _|| _| �d� t| jdd�r0t� d| � dS dS )a� Complete successful authentication. Save the mailbox and logout function for the authenticated user and send a successful response to the client. @type result: C{tuple} @param result: The first item of the tuple is a C{zope.interface.Interface} which is the interface supported by the avatar. The second item of the tuple is a L{IMailbox} provider which is the mailbox for the authenticated user. The third item of the tuple is a no-argument callable which is a function to be invoked when the session is terminated. @type user: L{bytes} @param user: The user being authenticated. � Authentication failedz9_cbMailbox() called with an interface other than IMailboxNzAuthentication succeededru Ts Authenticated login for ) r� r� r r� r� r~ r] ry rz r{ )r �resultr� � interface�avatar�logoutr r r r� � s �zPOP3._cbMailboxc C s| |� tjjtjj�}t|tjj�r| �dt|� � n t|tjj�r'| �d� t| j dd�r<t � dt| j � � � � dS dS )a Handle an expected authentication failure. Send an appropriate error response for a L{LoginDenied} or L{LoginFailed} authentication failure. @type failure: L{Failure} @param failure: The authentication error. zAccess denied: r� ru TzDenied login attempt from N)�trapr �error� LoginDenied� LoginFailed� issubclassr� rZ ry rz r r{ rP r| �r �failurer r r r� s �zPOP3._ebMailboxc C s | � d|�� � t�|� dS )z� Handle an unexpected authentication failure. Send an error response for an unexpected authentication failure. @type failure: L{Failure} @param failure: The authentication error. zServer error: N)r� �getErrorMessager r� r� r r r r� ) s zPOP3._ebUnexpectedc C s || _ | �d� dS )z� Handle a USER command. Save the username and send a successful response prompting the client for the password. @type user: L{bytes} @param user: A username. s USER accepted, send PASSN)�_userIsr] �r r� r r r �do_USER5 s z POP3.do_USERc G sf | j du r | �d� dS | j }d| _ d�|f| �}t�| j||�}|j| j| j|fd�� | j � dS )a2 Handle a PASS command. If a USER command was previously received, authenticate the user and complete the authorization process with the L{_cbMailbox} callback function on success or the L{_ebMailbox} and L{_ebUnexpected} errback functions on failure. If a USER command was not previously received, send an error response. @type password: L{bytes} @param password: A password. @type words: L{tuple} of L{bytes} @param words: Other parts of the password split by spaces. Ns USER required before PASSr� r� ) r� r� r� r r� �authenticateUserPASSr� r� r� r� r� )r r �wordsr� r� r r r �do_PASSB s �z POP3.do_PASSc s: � j �� �d� g � _|�� j� |�� �fdd�� |S )a� Stop timeouts and block further command processing while a long operation completes. @type d: L{Deferred <defer.Deferred>} @param d: A deferred which triggers at the completion of a long operation. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which triggers after command processing resumes and timeouts restart after the completion of a long operation. Nc s � � ��S rO )rw )�ign�r rx r r �<lambda>n � z%POP3._longOperation.<locals>.<lambda>)rx rw r� r� r� )r r� r r� r �_longOperation] s zPOP3._longOperationc C s | � t| jj|��S )aG Direct the output of an iterator to the transport and arrange for iteration to take place. @type gen: iterable which yields L{bytes} @param gen: An iterator over strings. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which fires when the iterator finishes. )rR r= rP rQ )r rT r r r � _coiterateq s zPOP3._coiteratec s8 t �� jj�}� fdd�}� fdd�}� �|�||��S )z� Handle a STAT command. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which triggers after the response to the STAT command has been issued. c � � � t| ��S rO )r� rc rf rE r r � cbMessages� � z POP3.do_STAT.<locals>.cbMessagesc �& � � | �� � t�d� t�| � d S )NzUnexpected do_STAT failure:�r� r� r r{ r� �r� rE r r � ebMessages� � z POP3.do_STAT.<locals>.ebMessages)r r� r� � listMessagesr� r� )r r� r� r� r rE r �do_STAT~ s z POP3.do_STATc s� � du r t ��jj�}�fdd�}�fdd�}��|�||��S z t� �� � dk r,t� �W n tyJ t� t �s@t � �� d�� �� d� � Y dS w t ��jj� d �}� �fd d �}� �fd d �}|�||� ��|�S ) a Handle a LIST command. @type i: L{bytes} or L{None} @param i: A 1-based message index. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which triggers after the response to the LIST command has been issued. Nc r� rO )r� rg rf rE r r r� � r� z POP3.do_LIST.<locals>.cbMessagesc r� )N�Unexpected do_LIST failure:r� r� rE r r r� � r� z POP3.do_LIST.<locals>.ebMessagesr% rW � Invalid message-number: c s �� d� | f � d S )Nr^ r_ )r{ �ra r r r � cbMessage� s z POP3.do_LIST.<locals>.cbMessagec s� | � tt�}|d ur-|tu rt�dt� � }|r$t|t�s$t|�� d�}�� d| � d S �� | � � � t � d� t �| � d S )N�}twisted.mail.pop3.IMailbox.listMessages may not raise IndexError for out-of-bounds message numbers: raise ValueError instead.rW r� r� )�checkr� � IndexError�warnings�warn�PendingDeprecationWarningrY r6 rZ r[ r� r� r r{ r� )r� �errcls� invalidNumr� r r � ebMessage� s � z POP3.do_LIST.<locals>.ebMessage) r r� r� r� r� r� �intr� rY r6 rZ r[ r� )r ra r� r� r� r� r r r� r �do_LIST� s( � � z POP3.do_LISTc s� |du r t �� jj�}� fdd�}� fdd�}� �|�||��S z t|�}|dk r,t� �W n ty< � �d� Y dS w z � j� |d �}W n# t y\ t � dt � � �d� Y dS tyj � �d� Y dS w t|t�swt|��d �}� �|� dS ) a Handle a UIDL command. @type i: L{bytes} or L{None} @param i: A 1-based message index. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which triggers after the response to the UIDL command has been issued. Nc s � � t| � jj��S rO )r� rn r� ri rf rE r r r� � s �z POP3.do_UIDL.<locals>.cbMessagesc r� )NzUnexpected do_UIDL failure:r� r� rE r r r� � r� z POP3.do_UIDL.<locals>.ebMessagesr% �Bad message number argumentzxtwisted.mail.pop3.IMailbox.getUidl may not raise IndexError for out-of-bounds message numbers: raise ValueError instead.rW )r r� r� r� r� r� r r� r� ri r r r r rY r6 rZ r[ r] )r ra r� r� r� r{ r rE r �do_UIDL� s6 � � � � z POP3.do_UIDLc s� zt |�d � � dk rt� �W n ty" ��d� t�d� Y S w t��jj� �}� �fdd�}�fdd�}|�|� |� |� |S ) a� Retrieve the size and contents of a message. @type i: L{bytes} @param i: A 1-based message index. @rtype: L{Deferred <defer.Deferred>} which successfully fires with 2-L{tuple} of (E{1}) L{int}, (E{2}) file-like object @return: A deferred which successfully fires with the size of the message and a file containing the contents of the message. r% r r Nc s6 � st �t� �S t ��jj��}|�� fdd�� |S )Nc s � | fS rO r )�fObj�rb r r r� s z=POP3._getMessageFile.<locals>.cbMessageSize.<locals>.<lambda>)r �failr r� r� � getMessager� )rb � fileDeferred�r{ r r r � cbMessageSize s z+POP3._getMessageFile.<locals>.cbMessageSizec sj | � ttt�}|tu r� �d� d S |ttfv r)|tu r"t�dt� � �d� d S t� d� t� | � d S )Nzmessage deletedr r z#Unexpected _getMessageFile failure:) r r r� r r� r r r r r{ r� )r� r rE r r �ebMessageSomething! s �� � z0POP3._getMessageFile.<locals>.ebMessageSomething) r r� r� r �succeedr� r� r� r� r� )r ra � sizeDeferredr r r r r �_getMessageFile s � � zPOP3._getMessageFilec s, �� ��}� ���fdd�}��|�|��S )a� Send the contents of a message. @type i: L{bytes} @param i: A 1-based message index. @type fpWrapper: callable that takes a file-like object and returns a file-like object @param fpWrapper: @type successResponse: callable that takes L{int} and returns L{bytes} @param successResponse: @rtype: L{Deferred} @return: A deferred which triggers after the message has been sent. c s� | d u rd S t �jt����_| \}}� |�}���|�� t�� }|�|�j�j�}�fdd�}�fdd�}|� |� |� |� |S )Nc s | dkrd}nd}� � |� d S )Nr2 � .r� �r� )�lastsentr� rE r r �cbFileTransferY s zGPOP3._sendMessageContent.<locals>.cbMessageFile.<locals>.cbFileTransferc s" � j �� t�d� t�| � d S )Nz(Unexpected error in _sendMessageContent:)rP �loseConnectionr r{ r� r� rE r r �ebFileTransfer` s zGPOP3._sendMessageContent.<locals>.cbMessageFile.<locals>.ebFileTransfer) �max�_highestr r] r � FileSender�beginFileTransferrP �transformChunkr� r� )�info�resp�fp�sr� r r �� fpWrapperra r r] r r � cbMessageFileL s z/POP3._sendMessageContent.<locals>.cbMessageFile)r r� r� )r ra r( r] r� r) r r' r �_sendMessageContent8 s zPOP3._sendMessageContentc sR z t � �� � dk r t�W n ty | �d� Y dS w | �|� fdd�dd� �S )a[ Handle a TOP command. @type i: L{bytes} @param i: A 1-based message index. @type size: L{bytes} @param size: The number of lines of the message to retrieve. @rtype: L{Deferred} @return: A deferred which triggers after the response to the TOP command has been issued. r zBad line count argumentc s t | � �S rO )r$ �r% r r r r� � r� z POP3.do_TOP.<locals>.<lambda>c S � dS )NzTop of message followsr r r r r r� � � N)r r� r� r* )r ra rb r r r �do_TOPk s � � �z POP3.do_TOPc C s | � |dd� dd� �S )z� Handle a RETR command. @type i: L{bytes} @param i: A 1-based message index. @rtype: L{Deferred} @return: A deferred which triggers after the response to the RETR command has been issued. c S rD rO r r+ r r r r� � r- z POP3.do_RETR.<locals>.<lambda>c S s d| f S )Nz%dr r r r r r� � r� )r* �r ra r r r �do_RETR� s z POP3.do_RETRc C s |� dd�� dd�S )a� Transform a chunk of a message to POP3 message format. Make sure each line ends with C{'\r\n'} and byte-stuff the termination character (C{'.'}) by adding an extra one when one appears at the beginning of a line. @type chunk: L{bytes} @param chunk: A string to transform. @rtype: L{bytes} @return: The transformed string. r2 rX r s ..)�replace)r �chunkr r r r" � s zPOP3.transformChunkc C s |dkrd}nd}| � |� dS )z� Send the termination sequence. @type lastsent: L{bytes} @param lastsent: The last character of the file. r2 r r� Nr )r r r� r r r �finishedFileTransfer� s zPOP3.finishedFileTransferc C s$ t |�d }| j�|� | �� dS )z� Handle a DELE command. Mark a message for deletion and issue a successful response. @type i: L{int} @param i: A 1-based message index. r% N)r r� � deleteMessager] r/ r r r �do_DELE� s z POP3.do_DELEc C s | � � dS )z] Handle a NOOP command. Do nothing but issue a successful response. Nr_ rE r r r �do_NOOP� s z POP3.do_NOOPc C sF z| j �� W n ty t�� | �� Y dS w d| _| �� dS )zj Handle a RSET command. Unmark any messages that have been flagged for deletion. r N)r� �undeleteMessagesr� r r� r� r r] rE r r r �do_RSET� s � z POP3.do_RSETc C s | � | j� dS )zr Handle a LAST command. Respond with the 1-based index of the highest retrieved message. N)r] r rE r r r �do_LAST� s z POP3.do_LASTc C � | � d� dS )z� Handle an RPOP command. RPOP is not supported. Send an error response. @type user: L{bytes} @param user: A username. zpermission denied, suckerN)r� r� r r r �do_RPOP� s z POP3.do_RPOPc C s& | j r| j �� | �� | j�� dS )z� Handle a QUIT command. Remove any messages marked for deletion, issue a successful response, and drop the connection. N)r� �syncr] rP r rE r r r �do_QUIT� s z POP3.do_QUITc C s. | j dur| j �t| j||�dt�S tj�� �)ax Perform APOP authentication. @type user: L{bytes} @param user: The name of the user attempting to log in. @type digest: L{bytes} @param digest: The challenge response. @rtype: L{Deferred <defer.Deferred>} which successfully results in 3-L{tuple} of (E{1}) L{IMailbox <pop3.IMailbox>}, (E{2}) L{IMailbox <pop3.IMailbox>} provider, (E{3}) no-argument callable @return: A deferred which fires when authentication is complete. If successful, it returns an L{IMailbox <pop3.IMailbox>} interface, a mailbox, and a function to be invoked with the session is terminated. If authentication fails, the deferred fails with an L{UnathorizedLogin <cred.error.UnauthorizedLogin>} error. @raise cred.error.UnauthorizedLogin: When authentication fails. N)r� r� r r r� r r� �UnauthorizedLogin�r r� r r r r r� � � � zPOP3.authenticateUserAPOPc C s. | j dur| j �tj�||�dt�S tj�� �)a� Perform authentication for a username/password login. @type user: L{bytes} @param user: The name of the user attempting to log in. @type password: L{bytes} @param password: The password to authenticate with. @rtype: L{Deferred <defer.Deferred>} which successfully results in 3-L{tuple} of (E{1}) L{IMailbox <pop3.IMailbox>}, (E{2}) L{IMailbox <pop3.IMailbox>} provider, (E{3}) no-argument callable @return: A deferred which fires when authentication is complete. If successful, it returns a L{pop3.IMailbox} interface, a mailbox, and a function to be invoked with the session is terminated. If authentication fails, the deferred fails with an L{UnathorizedLogin <cred.error.UnauthorizedLogin>} error. @raise cred.error.UnauthorizedLogin: When authentication fails. N)r� r� r � credentials�UsernamePasswordr� r� r> )r r� r r r r r� r@ zPOP3.authenticateUserPASSc C s t � �rO )r� rE r r r � stopProducing* s zPOP3.stopProducing�rm )r& rO )=r r! r" r# r r r6 �__annotations__r� r~ r� r� rz r� rx r� r� � staticmethodr � coiteraterR r r} r� rv r] r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r* r. r0 r" r3 r5 r6 r8 r9 r; r= r� r� rC r r r r ro y sj 7 L # ?343 ro c @ sB e Zd ZdZddd�Zdd� Zdd� Zd d � Zd d � Zd d� Z dS )�Mailboxz% A base class for mailboxes. Nc C s g S )a� Retrieve the size of a message, or, if none is specified, the size of each message in the mailbox. @type i: L{int} or L{None} @param i: The 0-based index of the message. @rtype: L{int}, sequence of L{int}, or L{Deferred <defer.Deferred>} @return: The number of octets in the specified message, or, if an index is not specified, a sequence of the number of octets for all messages in the mailbox or a deferred which fires with one of those. Any value which corresponds to a deleted message is set to 0. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. r r/ r r r r� 5 s zMailbox.listMessagesc C � t �)a Retrieve a file containing the contents of a message. @type i: L{int} @param i: The 0-based index of a message. @rtype: file-like object @return: A file containing the message. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. �r� r/ r r r r I s zMailbox.getMessagec C rI )a� Get a unique identifier for a message. @type i: L{int} @param i: The 0-based index of a message. @rtype: L{bytes} @return: A string of printable characters uniquely identifying the message for all time. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. rJ r/ r r r ri X � zMailbox.getUidlc C rI )a� Mark a message for deletion. This must not change the number of messages in this mailbox. Further requests for the size of the deleted message should return 0. Further requests for the message itself may raise an exception. @type i: L{int} @param i: The 0-based index of a message. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. rJ r/ r r r r4 h rK zMailbox.deleteMessagec C r, )z� Undelete all messages marked for deletion. Any message which can be undeleted should be returned to its original position in the message sequence and retain its original UID. Nr rE r r r r7 x rG zMailbox.undeleteMessagesc C r, )zJ Discard the contents of any message marked for deletion. Nr rE r r r r< � s z Mailbox.syncrO ) r r! r" r# r� r ri r4 r7 r< r r r r rH / s rH r/ c @ s� e Zd ZdZeZdZddlZe�d�Z dd� Z d'dd �Z d d � Z d d � Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd(d d �Zd(d d �Zd!d"� Zd#d$� ZeZd%d&� ZdS ))� POP3Clienta| A POP3 client protocol. @type mode: L{int} @ivar mode: The type of response expected from the server. Choices include none (0), a one line response (1), the first line of a multi-line response (2), and subsequent lines of a multi-line response (3). @type command: L{bytes} @ivar command: The command most recently sent to the server. @type welcomeRe: L{Pattern <re.Pattern.search>} @ivar welcomeRe: A regular expression which matches the APOP challenge in the server greeting. @type welcomeCode: L{bytes} @ivar welcomeCode: The APOP challenge passed in the server greeting. s WELCOMEr Ns <(.*)>c C s ddl }|jdtdd� dS )z, Issue deprecation warning. r Nzdtwisted.mail.pop3.POP3Client is deprecated, please use twisted.mail.pop3.AdvancedPOP3Client instead.� )� stacklevel)r r �DeprecationWarning)r r r r r r � s �zPOP3Client.__init__c C sN |durt |t�st|��d�}| �|d | � n| �|� || _t| _dS )z� Send a POP3 command to which a short response is expected. @type command: L{bytes} @param command: A POP3 command. @type params: stringifyable L{object} or L{None} @param params: Command arguments. NrW r� )rY r6 rZ r[ r� r� �SHORT�mode�r r� �paramsr r r � sendShort� s zPOP3Client.sendShortc C sJ |rt |t�st|��d�}| �|d | � n| �|� || _t| _dS )z� Send a POP3 command to which a long response is expected. @type command: L{bytes} @param command: A POP3 command. @type params: stringifyable L{object} @param params: Command arguments. rW r� N)rY r6 rZ r[ r� r� � FIRST_LONGrQ rR r r r �sendLong� s zPOP3Client.sendLongc C s |dd� dkr t | _dS dS )z� Handle responses from the server for which no other handler exists. @type line: L{bytes} @param line: A received line. N���s -ERR)�NONErQ r� r r r �handle_default� s �zPOP3Client.handle_defaultc C sJ |� dd�\}}|dkr| j�� dS | j�|�}|r#|�d�| _dS dS )z� Handle a server response which is expected to be a server greeting. @type line: L{bytes} @param line: A received line. r� r% s +OKN)r5 rP r � welcomeRe�match�group� welcomeCode)r r� �coder7 rj r r r �handle_WELCOME� s �zPOP3Client.handle_WELCOMEc G sP zt | d|�d� |�}|dur||� W dS W dS ty' t�� Y dS w )a� Dispatch a response from the server for handling. Command X is dispatched to handle_X() if it exists. If not, it is dispatched to the default handler. @type command: L{bytes} @param command: The command. @type default: callable that takes L{bytes} or L{None} @param default: The default handler. @type args: L{tuple} or L{None} @param args: Arguments to the handler function. �handle_rW N)ry r� r� r r� )r r� �defaultr� �methodr r r � _dispatch� s � �zPOP3Client._dispatchc C s� | j tks | j tkrt| j | _ | �| j| j|� dS | j tkrO|dkr5t| j | _ | �| jd d� dS |dd� dkrC|dd� }| �| jd d|� dS dS )a� Dispatch a received line for processing. The choice of function to handle the received line is based on the type of response expected to the command sent to the server and how much of that response has been received. An expected one line response to command X is handled by handle_X(). The first line of a multi-line response to command X is also handled by handle_X(). Subsequent lines of the multi-line response are handled by handle_X_continue() except for the last line which is handled by handle_X_end(). @type line: L{bytes} @param line: A received line. r� s _endNr% s _continue)rQ rP rU �NEXTrc r� rY �LONGr� r r r r� s �zPOP3Client.lineReceivedc C s& t || ��� �d�}| �||� dS )a@ Perform an authenticated login. @type user: L{bytes} @param user: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @type magic: L{bytes} @param magic: The challenge provided by the server. �asciiN)r r r[ �apop)r r� r r r r r r �apopAuthenticate- s zPOP3Client.apopAuthenticatec C s | � dd�||f�� dS )a Send an APOP command to perform authenticated login. @type user: L{bytes} @param user: The username with which to log in. @type digest: L{bytes} @param digest: The challenge response with which to authenticate. rr r� N)rV r� r? r r r rg = s zPOP3Client.apopc C � | � d|� dS )z� Send a RETR command to retrieve a message from the server. @type i: L{int} or L{bytes} @param i: A 0-based message index. s RETRN�rV r/ r r r �retrI � zPOP3Client.retrc C ri )z� Send a DELE command to delete a message from the server. @type i: L{int} or L{bytes} @param i: A 0-based message index. s DELEN�rT r/ r r r �deleR rl zPOP3Client.delerm c C ri )a Send a LIST command to retrieve the size of a message or, if no message is specified, the sizes of all messages. @type i: L{int} or L{bytes} @param i: A 0-based message index or the empty string to specify all messages. s LISTNrj r/ r r r �list[ � zPOP3Client.listc C ri )a, Send a UIDL command to retrieve the unique identifier of a message or, if no message is specified, the unique identifiers of all messages. @type i: L{int} or L{bytes} @param i: A 0-based message index or the empty string to specify all messages. r� Nrj r/ r r r �uidlf rp zPOP3Client.uidlc C ri )z� Send a USER command to perform the first half of a plaintext login. @type name: L{bytes} @param name: The username with which to log in. rp Nrm )r �namer r r r� q rl zPOP3Client.userc C ri )z� Perform the second half of a plaintext login. @type password: L{bytes} @param password: The plaintext password with which to authenticate. rq Nrm )r r r r r r z rl zPOP3Client.passwordc C r: )zD Send a QUIT command to disconnect from the server. rs Nrm rE r r r �quit� s zPOP3Client.quitrO rD )r r! r" r# rP rQ r� �re�compilerZ r rT rV rY r_ rc r� rh rg rk rn ro rq r� r �pass_rs r r r r rL � s. rL )� InsecureAuthenticationDisallowed� LineTooLong�ServerErrorResponse�TLSError�TLSNotSupportedError)rL )r� r� r r rw ry rx rz r{ ro rL �AdvancedPOP3Clientr rH )@r# r� r� r �hashlibr �typingr �zope.interfacer �twistedr �twisted.internetr r r � twisted.mailr �twisted.mail._exceptr r r �twisted.mail.interfacesr r� r r� �twisted.protocolsr r �twisted.pythonr rA �IUsernamePasswordr r$ r= rV r] rc rd rg rl rn � IProducer�LineOnlyReceiver� TimeoutMixinro rH �rangerX rP rU re rd rL rw rx ry rz r{ �twisted.mail._pop3clientr| �__all__r r r r �<module> s^ *TP <X | PK Mb�Z&< ��t �t ( mail/__pycache__/maildir.cpython-310.pycnu �[��� o �bMl � @ s~ d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl m Z ddl m Z m Z mZ ddlmZ ddlmZmZmZ dd lmZmZmZ dd lmZ dd lm Z dd l m Z m Z d Z G dd� d�Z!e!e�j"Z#dd� Z$G dd� dej%�Z&e ej'�G dd� d��Z(e ej)�G dd� d��Z*G dd� dej+�Z,e ej-�G dd� d��Z.e ej/�G d d � d e(��Z0e e j1�G d d � d ��Z2dS ) z Maildir-style mailbox support. � N)�md5)�IO)� implementer)�checkers� credentials�portal)�UnauthorizedLogin)�defer� interfaces�reactor)�mail�pop3�smtp��dirdbm)�basic)�failure�logz�From: Twisted.mail Internals Subject: An Error Occurred An internal server error has occurred. Please contact the server administrator. c @ sD e Zd ZdZdZe�� Ze� � � dd�� dd�Z dd� Z d d � Z d S ) �_MaildirNameGeneratoraK A utility class to generate a unique maildir name. @type n: L{int} @ivar n: A counter used to generate unique integers. @type p: L{int} @ivar p: The ID of the current process. @type s: L{bytes} @ivar s: A representation of the hostname. @ivar _clock: See C{clock} parameter of L{__init__}. r �/z\057�:z\072c C � || _ dS )z� @type clock: L{IReactorTime <interfaces.IReactorTime>} provider @param clock: A reactor which will be used to learn the current time. N)�_clock)�self�clock� r �6/usr/lib/python3/dist-packages/twisted/mail/maildir.py�__init__8 � z _MaildirNameGenerator.__init__c C sb | j d | _ | j�� }tt|��}dt|t|� d �f }|� d|� d| j� d| j � d| j� � S )a� Generate a string which is intended to be unique across all calls to this function (across all processes, reboots, etc). Strings returned by earlier calls to this method will compare less than strings returned by later calls as long as the clock provided doesn't go backwards. @rtype: L{bytes} @return: A unique string. � z%07dg �cAz.M�P�Q�.)�nr �seconds�str�int�p�s)r �tr$ � microsecondsr r r �generate? s &z _MaildirNameGenerator.generateN)�__name__� __module__� __qualname__�__doc__r# �os�getpidr' �socket� gethostname�replacer( r r+ r r r r r $ s r c C s� t �| �} t j�| �sAt �| d� dD ] }t �t j�| |�d� qdD ]}t �t j�| d|�d� q#tt j�| dd�d��� dS dS )z� Create a maildir user directory if it doesn't already exist. @type dir: L{bytes} @param dir: The path name for a user directory. i� )�new�cur�tmp�.Trash)r5 r6 r7 r8 � maildirfolder�wN)r0 �fsdecode�path�isdir�mkdir�join�open�close)�dir�subdirr r r �initializeMaildirU s �rD c @ s, e Zd ZdZdZdd� Zdd� Zdd� ZdS ) �MaildirMessagez� A message receiver which adds a header and delivers a message to a file whose name includes the size of the message. @type size: L{int} @ivar size: The number of octets in the message. Nc O s< d| }|� |� t|�| _tjj| |g|�R i |�� dS )a� @type address: L{bytes} @param address: The address of the message recipient. @type fp: file-like object @param fp: The file in which to store the message while it is being received. @type a: 2-L{tuple} of (0) L{bytes}, (1) L{bytes} @param a: Positional arguments for L{FileMessage.__init__}. @type kw: L{dict} @param kw: Keyword arguments for L{FileMessage.__init__}. zDelivered-To: %s N)�write�len�sizer � FileMessager )r �address�fp�a�kw�headerr r r r r s zMaildirMessage.__init__c C s( t j�| |� | jt|�d 7 _dS )zo Write a line to the file. @type line: L{bytes} @param line: A received line. r N)r rI � lineReceivedrH rG )r �liner r r rO � s zMaildirMessage.lineReceivedc C s | j d| j | _ tj�| �S )aO At the end of message, rename the file holding the message to its final name concatenated with the size of the file. @rtype: L{Deferred <defer.Deferred>} which successfully results in L{bytes} @return: A deferred which returns the name of the file holding the message. z,S=%d)� finalNamerH r rI � eomReceived�r r r r rR � s zMaildirMessage.eomReceived)r, r- r. r/ rH r rO rR r r r r rE g s rE c @ sZ e Zd ZdZdZdZdd� Zdd� Zdd� Zdd d �Z d d � Z d d� Z dd� Z dd� Z dS )�AbstractMaildirDomainz� An abstract maildir-backed domain. @type alias: L{None} or L{dict} mapping L{bytes} to L{AliasBase} @ivar alias: A mapping of username to alias. @ivar root: See L{__init__}. Nc C s || _ dS )z� @type service: L{MailService} @param service: An email service. @type root: L{bytes} @param root: The maildir root directory. N)�root)r �servicerU r r r r � s z AbstractMaildirDomain.__init__c C � dS )z� Return the maildir directory for a user. @type user: L{bytes} @param user: A username. @rtype: L{bytes} or L{None} @return: The user's mail directory for a valid user. Otherwise, L{None}. Nr �r �userr r r � userDirectory� s z#AbstractMaildirDomain.userDirectoryc C r )z� Set the group of defined aliases for this domain. @type alias: L{dict} mapping L{bytes} to L{IAlias} provider. @param alias: A mapping of domain name to alias. N)�alias)r r[ r r r � setAliasGroup� s z#AbstractMaildirDomain.setAliasGroupc s� �� �jj�dur��fdd�S z �j�jj }W n ty% t����w |��j|�� � r5� fdd�S t� dt �� � t����)a� Check whether a user exists in this domain or an alias of it. @type user: L{User} @param user: A user. @type memo: L{None} or L{dict} of L{AliasBase} @param memo: A record of the addresses already considered while resolving aliases. The default value should be used by all external code. @rtype: no-argument callable which returns L{IMessage <smtp.IMessage>} provider. @return: A function which takes no arguments and returns a message receiver for the user. @raises SMTPBadRcpt: When the given user does not exist in this domain or an alias of it. Nc s � � ��S �N)� startMessager rX r r �<lambda>� s z.AbstractMaildirDomain.exists.<locals>.<lambda>c s � S r] r r )�aliasesr r r_ � � zBad alias configuration: ) rZ �dest�localr[ � BaseExceptionr � SMTPBadRcpt�resolver �errr% )r rY �memorL r )r` r rY r �exists� s � z AbstractMaildirDomain.existsc C s| t |t�r|�dd�\}}n |jj|jj}}| �|�}t� }tj � |d|�}t |d�}t |� d|� �||tj � |d|��S )z� Create a maildir message for a user. @type user: L{bytes} @param user: A username. @rtype: L{MaildirMessage} @return: A message receiver for this user. �@r r7 r: r5 ) � isinstancer% �splitrb rc �domainrZ �_generateMaildirNamer0 r< r? r@ rE )r rY �namerm rB �fname�filenamerK r r r r^ � s �z"AbstractMaildirDomain.startMessagec C rW )a� Check whether this domain will relay. @type user: L{Address} @param user: The destination address. @type protocol: L{SMTP} @param protocol: The protocol over which the message to be relayed is being received. @rtype: L{bool} @return: An indication of whether this domain will relay the message to the destination. Fr )r rY �protocolr r r � willRelay s z AbstractMaildirDomain.willRelayc C � t �)z� Add a user to this domain. Subclasses should override this method. @type user: L{bytes} @param user: A username. @type password: L{bytes} @param password: A password. ��NotImplementedError�r rY �passwordr r r �addUser s z AbstractMaildirDomain.addUserc C rt )a Return credentials checkers for this domain. Subclasses should override this method. @rtype: L{list} of L{ICredentialsChecker <checkers.ICredentialsChecker>} provider @return: Credentials checkers for this domain. ru rS r r r �getCredentialsCheckers# s z,AbstractMaildirDomain.getCredentialsCheckersr] )r, r- r. r/ r[ rU r rZ r\ ri r^ rs ry rz r r r r rT � s ! rT c @ s� e Zd ZdZeej�Zeej�Z eej �Z eej �Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zddd�Zdd� Zdd� ZdS )� _MaildirMailboxAppendMessageTaska� A task which adds a message to a maildir mailbox. @ivar mbox: See L{__init__}. @type defer: L{Deferred <defer.Deferred>} which successfully returns L{None} @ivar defer: A deferred which fires when the task has completed. @type opencall: L{IDelayedCall <interfaces.IDelayedCall>} provider or L{None} @ivar opencall: A scheduled call to L{prodProducer}. @type msg: file-like object @ivar msg: The message to add. @type tmpname: L{bytes} @ivar tmpname: The pathname of the temporary file holding the message while it is being transferred. @type fh: file @ivar fh: The new maildir file. @type filesender: L{FileSender <basic.FileSender>} @ivar filesender: A file sender which sends the message. @type myproducer: L{IProducer <interfaces.IProducer>} @ivar myproducer: The registered producer. @type streaming: L{bool} @ivar streaming: Indicates whether the registered producer provides a streaming interface. c C s4 || _ t�� | _d| _t|d�st�|�}|| _dS )z� @type mbox: L{MaildirMailbox} @param mbox: A maildir mailbox. @type msg: L{bytes} or file-like object @param msg: The message to add. N�read)�mboxr �Deferred�openCall�hasattr�io�BytesIO�msg)r r} r� r r r r Y s z)_MaildirMailboxAppendMessageTask.__init__c C s4 | � � | jdkrt�� | _| j�| j| � dS dS )z@ Start transferring the message to the mailbox. ���N)�createTempFile�fhr � FileSender� filesender�beginFileTransferr� rS r r r �startUph s �z(_MaildirMailboxAppendMessageTask.startUpc C s || _ || _|s| �� dS dS )aS Register a producer and start asking it for data if it is non-streaming. @type producer: L{IProducer <interfaces.IProducer>} @param producer: A producer. @type streaming: L{bool} @param streaming: A flag indicating whether the producer provides a streaming interface. N)� myproducer� streaming� prodProducer)r �producerr� r r r �registerProducerq s �z1_MaildirMailboxAppendMessageTask.registerProducerc C s2 d| _ | jdurt�d| j�| _ | j�� dS dS )zK Repeatedly prod a non-streaming producer to produce data. Nr )r r� r � callLaterr� �resumeProducingrS r r r r� � s �z-_MaildirMailboxAppendMessageTask.prodProducerc C s$ d| _ d| _| �| j� | �� dS )zA Finish transferring the message to the mailbox. N)r� r� �oscloser� � moveFileToNewrS r r r �unregisterProducer� s z3_MaildirMailboxAppendMessageTask.unregisterProducerc C s2 z | � | j|� W dS ty | �� Y dS w )z� Write data to the maildir file. @type data: L{bytes} @param data: Data to be written to the file. N)�oswriter� rd �fail)r �datar r r rF � s �z&_MaildirMailboxAppendMessageTask.writeNc C s: |du rt �� }| jdur| j�� | j�|� d| _dS )z� Fire the deferred to indicate the task completed with a failure. @type err: L{Failure <failure.Failure>} @param err: The error that occurred. N)r �Failurer �cancelr �errback)r rg r r r r� � s z%_MaildirMailboxAppendMessageTask.failc C s� t j�| jjdt� �}z | �| j|� W n- tyA } z |j\}}ddl }||j kr7| � � d}W Y d}~n W Y d}~nd}~ww q|durY| jj � |� | j�d� d| _dS dS )z� Place the message in the I{new/} directory, add it to the mailbox and fire the deferred to indicate that the task has completed successfully. Tr5 r N)r0 r< r? r} rn �osrename�tmpname�OSError�args�errno�EEXISTr� �list�appendr �callback)r �newname�erg �estrr� r r r r� � s* ���� �z._MaildirMailboxAppendMessageTask.moveFileToNewc C s� t jt jB t jB tt dd�B tt dd�B }d}d| _ t j�| jjdt � �| _ z | � | j |d�| _W dS t yV |d 7 }|d krT| j �td | jj �� d| _ Y dS Y nw q) zY Create a temporary file to hold the message as it is being transferred. � O_NOINHERITr � O_NOFOLLOWr� Tr7 i� Nr i� z Could not create tmp file for %s)r0 �O_RDWR�O_CREAT�O_EXCL�getattrr� r< r? r} rn r� �osopenr� r r� � RuntimeError)r �attr�triesr r r r� � s< �� � �� �����z/_MaildirMailboxAppendMessageTask.createTempFiler] )r, r- r. r/ � staticmethodr0 r@ r� rF r� rA r� �renamer� r r� r� r� r� r� r� r� r r r r r{ 0 s " r{ c @ sN e Zd ZdZeZdd� Zddd�Zdd� Zd d � Z d d � Z d d� Z dd� Z dS )�MaildirMailboxa� A maildir-backed mailbox. @ivar path: See L{__init__}. @type list: L{list} of L{int} or 2-L{tuple} of (0) file-like object, (1) L{bytes} @ivar list: Information about the messages in the mailbox. For undeleted messages, the file containing the message and the full path name of the file are stored. Deleted messages are indicated by 0. @type deleted: L{dict} mapping 2-L{tuple} of (0) file-like object, (1) L{bytes} to L{bytes} @type deleted: A mapping of the information about a file before it was deleted to the full path name of the deleted file in the I{.Trash/} subfolder. c C sz || _ g | _i | _t|� dD ] }t�tj �||��D ]}| j�|tj �|||�f� qq| j�� dd� | jD �| _dS )ze @type path: L{bytes} @param path: The directory name for a maildir mailbox. )r6 r5 c S s g | ]}|d �qS )r r )�.0r� r r r � <listcomp> s z+MaildirMailbox.__init__.<locals>.<listcomp>N) r< r� �deletedrD r0 �listdirr? r� �sort)r r< ro �filer r r r � s � zMaildirMailbox.__init__Nc C sf |du r!g }| j D ]}|r|�t�|�tj � q |�d� q |S | j | r1t�| j | �tj p2dS )al Retrieve the size of a message, or, if none is specified, the size of each message in the mailbox. @type i: L{int} or L{None} @param i: The 0-based index of a message. @rtype: L{int} or L{list} of L{int} @return: The number of octets in the specified message, or, if an index is not specified, a list of the number of octets for all messages in the mailbox. Any value which corresponds to a deleted message is set to 0. @raise IndexError: When the index does not correspond to a message in the mailbox. Nr )r� r� r0 �stat�ST_SIZE)r �i�ret�messr r r � listMessages s $zMaildirMailbox.listMessagesc C s t | j| �S )aR Retrieve a file-like object with the contents of a message. @type i: L{int} @param i: The 0-based index of a message. @rtype: file-like object @return: A file containing the message. @raise IndexError: When the index does not correspond to a message in the mailbox. )r@ r� �r r� r r r � getMessage% s zMaildirMailbox.getMessagec C s t j�| j| �}t|��� S )ar Get a unique identifier for a message. @type i: L{int} @param i: The 0-based index of a message. @rtype: L{bytes} @return: A string of printable characters uniquely identifying the message for all time. @raise IndexError: When the index does not correspond to a message in the mailbox. )r0 r< �basenamer� r � hexdigest)r r� �baser r r �getUidl4 s zMaildirMailbox.getUidlc C sR t j�| jddt j�| j| ��}t �| j| |� || j| j| < d| j|< dS )aK Mark a message for deletion. Move the message to the I{.Trash/} subfolder so it can be undeleted by an administrator. @type i: L{int} @param i: The 0-based index of a message. @raise IndexError: When the index does not correspond to a message in the mailbox. r8 r6 r N)r0 r< r? r� r� r� r� )r r� � trashFiler r r � deleteMessageF s �z MaildirMailbox.deleteMessagec C s� | j �� D ]H\}}zt�||� W n! ty2 } z|j\}}ddl}||jkr(� W Y d}~qd}~ww z || j| j� d�< W q t yM | j� |� Y qw | j � � dS )z� Undelete all messages marked for deletion. Move each message marked for deletion from the I{.Trash/} subfolder back to its original position. r N) r� �itemsr0 r� r� r� r� �ENOENTr� �index� ValueErrorr� �clear)r �real�trashr� rg r� r� r r r �undeleteMessagesZ s" ��� �z MaildirMailbox.undeleteMessagesc C s | � | |�}|j}|�� |S )a Add a message to the mailbox. @type txt: L{bytes} or file-like object @param txt: A message to add. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which fires when the message has been added to the mailbox. )� AppendFactoryr r� )r �txt�task�resultr r r � appendMessages s z MaildirMailbox.appendMessager] ) r, r- r. r/ r{ r� r r� r� r� r� r� r� r r r r r� � s r� c @ sX e Zd ZdZdd� Zddd�Zdedee fd d �Z d d � Z d d� Z dd� Z dd� Z dS )�StringListMailboxz� An in-memory mailbox. @ivar msgs: See L{__init__}. @type _delete: L{set} of L{int} @ivar _delete: The indices of messages which have been marked for deletion. c C s || _ t� | _dS )zs @type msgs: L{list} of L{bytes} @param msgs: The contents of each message in the mailbox. N)�msgs�set�_delete)r r� r r r r � s zStringListMailbox.__init__Nc s@ |du r� fdd�t t� j��D �S |� jv rdS t� j| �S )ak Retrieve the size of a message, or, if none is specified, the size of each message in the mailbox. @type i: L{int} or L{None} @param i: The 0-based index of a message. @rtype: L{int} or L{list} of L{int} @return: The number of octets in the specified message, or, if an index is not specified, a list of the number of octets in each message in the mailbox. Any value which corresponds to a deleted message is set to 0. @raise IndexError: When the index does not correspond to a message in the mailbox. Nc s g | ]}� � |��qS r )r� )r� r� rS r r r� � s z2StringListMailbox.listMessages.<locals>.<listcomp>r )�rangerG r� r� r� r rS r r� � s z StringListMailbox.listMessagesr� �returnc C s t �| j| �S )a9 Return an in-memory file-like object with the contents of a message. @param i: The 0-based index of a message. @return: An in-memory file-like object containing the message. @raise IndexError: When the index does not correspond to a message in the mailbox. )r� r� r� r� r r r r� � s z StringListMailbox.getMessagec C s t | j| ��� S )aP Get a unique identifier for a message. @type i: L{int} @param i: The 0-based index of a message. @rtype: L{bytes} @return: A hash of the contents of the message at the given index. @raise IndexError: When the index does not correspond to a message in the mailbox. )r r� r� r� r r r r� � s zStringListMailbox.getUidlc C s | j �|� dS )z� Mark a message for deletion. @type i: L{int} @param i: The 0-based index of a message to delete. @raise IndexError: When the index does not correspond to a message in the mailbox. N)r� �addr� r r r r� � s z StringListMailbox.deleteMessagec C s t � | _dS )zL Undelete any messages which have been marked for deletion. N)r� r� rS r r r r� � s z"StringListMailbox.undeleteMessagesc C s" | j D ]}d| j|< qt� | _ dS )zK Discard the contents of any messages marked for deletion. � N)r� r� r� )r r� r r r �sync� s zStringListMailbox.syncr] )r, r- r. r/ r r� r& r �bytesr� r� r� r� r� r r r r r� � s r� c @ sB e Zd ZdZdZdZddd�Zdd� Zdd � Zd d � Z d d � Z dS )�MaildirDirdbmDomaina� A maildir-backed domain where membership is checked with a L{DirDBM <dirdbm.DirDBM>} database. The directory structure of a MaildirDirdbmDomain is: /passwd <-- a DirDBM directory /USER/{cur, new, del} <-- each user has these three directories @ivar postmaster: See L{__init__}. @type dbm: L{DirDBM <dirdbm.DirDBM>} @ivar dbm: The authentication database for the domain. Nr c C sR t �|�}t�| ||� t j�|d�}t j�|�s t �|� t� |�| _ || _ dS )av @type service: L{MailService} @param service: An email service. @type root: L{bytes} @param root: The maildir root directory. @type postmaster: L{bool} @param postmaster: A flag indicating whether non-existent addresses should be forwarded to the postmaster (C{True}) or bounced (C{False}). s passwdN) r0 �fsencoderT r r< r? ri �makedirsr r@ �dbm� postmaster)r rV rU r� r� r r r r � s z MaildirDirdbmDomain.__init__c C s@ || j vr | js dS d}tj�| j|�}tj�|�s t|� |S )aq Return the path to a user's mail directory. @type name: L{bytes} @param name: A username. @rtype: L{bytes} or L{None} @return: The path to the user's mail directory for a valid user. For an invalid user, the path to the postmaster's mailbox if bounces are redirected there. Otherwise, L{None}. Nr� )r� r� r0 r< r? rU ri rD )r ro rB r r r rZ s z!MaildirDirdbmDomain.userDirectoryc C s || j |< | �|� dS )a Add a user to this domain by adding an entry in the authentication database and initializing the user's mail directory. @type user: L{bytes} @param user: A username. @type password: L{bytes} @param password: A password. N)r� rZ rw r r r ry $ s zMaildirDirdbmDomain.addUserc C s | j du r t| j�g| _ | j S )z� Return credentials checkers for this domain. @rtype: L{list} of L{ICredentialsChecker <checkers.ICredentialsChecker>} provider @return: Credentials checkers for this domain. N)� _credcheckers�DirdbmDatabaser� rS r r r rz 3 s z*MaildirDirdbmDomain.getCredentialsCheckersc G sL t j|vr td��|tjkrttg�}n ttj � | j |��}t j|dd� fS )aw Get the mailbox for an authenticated user. The mailbox for the authenticated user will be returned only if the given interfaces include L{IMailbox <pop3.IMailbox>}. Requests for anonymous access will be met with a mailbox containing a message indicating that an internal error has occurred. @type avatarId: L{bytes} or C{twisted.cred.checkers.ANONYMOUS} @param avatarId: A string which identifies a user or an object which signals a request for anonymous access. @type mind: L{None} @param mind: Unused. @type interfaces: n-L{tuple} of C{zope.interface.Interface} @param interfaces: A group of interfaces, one of which the avatar must support. @rtype: 3-L{tuple} of (0) L{IMailbox <pop3.IMailbox>}, (1) L{IMailbox <pop3.IMailbox>} provider, (2) no-argument callable @return: A tuple of the supported interface, a mailbox, and a logout function. @raise NotImplementedError: When the given interfaces do not include L{IMailbox <pop3.IMailbox>}. z No interfacec S s d S r] r r r r r r_ c ra z3MaildirDirdbmDomain.requestAvatar.<locals>.<lambda>) r �IMailboxrv r � ANONYMOUSr� �INTERNAL_ERRORr� r0 r< r? rU )r �avatarId�mindr r} r r r � requestAvatar? s z!MaildirDirdbmDomain.requestAvatar)r ) r, r- r. r/ r r� r rZ ry rz r� r r r r r� � s r� c @ s, e Zd ZdZejejfZdd� Zdd� Z dS )r� z� A credentials checker which authenticates users out of a L{DirDBM <dirdbm.DirDBM>} database. @type dirdbm: L{DirDBM <dirdbm.DirDBM>} @ivar dirdbm: An authentication database. c C r )zf @type dbm: L{DirDBM <dirdbm.DirDBM>} @param dbm: An authentication database. Nr )r r� r r r r v r zDirdbmDatabase.__init__c C s* |j | jv r|�| j|j �r|j S t� �)a� Authenticate a user and, if successful, return their username. @type c: L{IUsernamePassword <credentials.IUsernamePassword>} or L{IUsernameHashedPassword <credentials.IUsernameHashedPassword>} provider. @param c: Credentials. @rtype: L{bytes} @return: A string which identifies an user. @raise UnauthorizedLogin: When the credentials check fails. )�usernamer � checkPasswordr )r �cr r r �requestAvatarId} s z DirdbmDatabase.requestAvatarIdN) r, r- r. r/ r �IUsernamePassword�IUsernameHashedPassword�credentialInterfacesr r� r r r r r� f s � r� )3r/ r� r0 r2 r� �hashlibr �typingr �zope.interfacer � twisted.credr r r �twisted.cred.errorr �twisted.internetr r r � twisted.mailr r r �twisted.persistedr �twisted.protocolsr �twisted.pythonr r r� r r+ rn rD rI rE �IAliasableDomainrT � IConsumerr{ �Mailboxr� r� r� �IRealmr� �ICredentialsCheckerr� r r r r �<module> sF .7 5 ` PK Mb�Z���n� � - mail/__pycache__/relaymanager.cpython-310.pycnu �[��� o �bd� � @ sp d Z ddlZddlZddlZddlZddlmZ ddlm Z ddl m Z ddl m Z mZ ddlmZ ddlmZ dd lmZmZmZ dd lmZ dd lmZ G d d � d �ZG dd� deej �Z G dd� deej �Z G dd� de j �Z!G dd� de!�Z"G dd� d�Z#G dd� d�Z$G dd� d�Z%G d d � d e%�Z&d d � Z'd d!� Z(G d"d#� d#e)�Z*G d$d%� d%e)�Z+G d&d'� d'�Z,dS )(aI Infrastructure for relaying mail through a smart host. Traditional peer-to-peer email has been increasingly replaced by smart host configurations. Instead of sending mail directly to the recipient, a sender sends mail to a smart host. The smart host finds the mail exchange server for the recipient and sends on the message. � N)�Type)�internet)�protocol)�Deferred� DeferredList)�DNSLookupError)�connectionDone)�bounce�relay�smtp)�log)�Failurec @ sL e Zd ZdZdd� Zedd� �Zejdd� �Zdd� Ze fd e fd d �Z d S ) �ManagedRelayerMixinz� SMTP Relayer which notifies a manager Notify the manager about successful mail, failed mail and broken connections c C � || _ d S �N��manager)�selfr � r �;/usr/lib/python3/dist-packages/twisted/mail/relaymanager.py�__init__& s z ManagedRelayerMixin.__init__c C s | j S r ��_factory�r r r r �factory) s zManagedRelayerMixin.factoryc C r r r )r �valuer r r r - s c C sJ | j d }|tjv r| j�| j|� n| j�| j|� | jd= | j d= dS )z` called when e-mail has been sent we will always get 0 or 1 addresses. r N)�namesr �SUCCESSr � notifySuccessr � notifyFailure�messages)r �code�resp�numOk� addressesr �messager r r �sentMail1 s z ManagedRelayerMixin.sentMail�reasonc C s | j �| j� dS )zm called when connection is broken notify manager we will try to send no more e-mail N)r � notifyDoner )r r' r r r �connectionLost? s z"ManagedRelayerMixin.connectionLostN) �__name__� __module__� __qualname__�__doc__r �propertyr �setterr& r r r) r r r r r s r c @ � e Zd ZdZdd� ZdS )�SMTPManagedRelayeraV An SMTP managed relayer. This managed relayer is an SMTP client which is responsible for sending a set of messages and keeping an attempt manager informed about its progress. @type factory: L{SMTPManagedRelayerFactory} @ivar factory: The factory that created this relayer. This must be set by the factory. c O �, t �| |� tjj| |g|�R i |�� dS )a� @type messages: L{list} of L{bytes} @param messages: The base filenames of messages to be relayed. @type manager: L{_AttemptManager} @param manager: An attempt manager. @type args: 1-L{tuple} of (0) L{bytes} or 2-L{tuple} of (0) L{bytes}, (1) L{int} @param args: Positional arguments for L{SMTPClient.__init__} @type kw: L{dict} @param kw: Keyword arguments for L{SMTPClient.__init__} N)r r r � SMTPRelayer�r r r �args�kwr r r r T s zSMTPManagedRelayer.__init__N�r* r+ r, r- r r r r r r1 H s r1 c @ r0 )�ESMTPManagedRelayerz� An ESMTP managed relayer. This managed relayer is an ESMTP client which is responsible for sending a set of messages and keeping an attempt manager informed about its progress. c O r2 )a� @type messages: L{list} of L{bytes} @param messages: The base filenames of messages to be relayed. @type manager: L{_AttemptManager} @param manager: An attempt manager. @type args: 3-L{tuple} of (0) L{bytes}, (1) L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>}, (2) L{bytes} or 4-L{tuple} of (0) L{bytes}, (1) L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>}, (2) L{bytes}, (3) L{int} @param args: Positional arguments for L{ESMTPClient.__init__} @type kw: L{dict} @param kw: Keyword arguments for L{ESMTPClient.__init__} N)r r r � ESMTPRelayerr4 r r r r o s z ESMTPManagedRelayer.__init__Nr7 r r r r r8 g s r8 c @ s6 e Zd ZU dZeZded< dd� Zdd� Zdd � Z d S ) �SMTPManagedRelayerFactorya� A factory to create an L{SMTPManagedRelayer}. This factory creates a managed relayer which relays a set of messages over SMTP and informs an attempt manager of its progress. @ivar messages: See L{__init__} @ivar manager: See L{__init__} @type protocol: callable which returns L{SMTPManagedRelayer} @ivar protocol: A callable which returns a managed relayer for SMTP. See L{SMTPManagedRelayer.__init__} for parameters to the callable. @type pArgs: 1-L{tuple} of (0) L{bytes} or 2-L{tuple} of (0) L{bytes}, (1), L{int} @ivar pArgs: Positional arguments for L{SMTPClient.__init__} @type pKwArgs: L{dict} @ivar pKwArgs: Keyword arguments for L{SMTPClient.__init__} zType[protocol.Protocol]r c O s || _ || _|| _|| _dS )a� @type messages: L{list} of L{bytes} @param messages: The base filenames of messages to be relayed. @type manager: L{_AttemptManager} @param manager: An attempt manager. @type args: 1-L{tuple} of (0) L{bytes} or 2-L{tuple} of (0) L{bytes}, (1), L{int} @param args: Positional arguments for L{SMTPClient.__init__} @type kw: L{dict} @param kw: Keyword arguments for L{SMTPClient.__init__} N)r r �pArgs�pKwArgsr4 r r r r � s z"SMTPManagedRelayerFactory.__init__c C s, | j | j| jg| j�R i | j��}| |_|S )a Create an L{SMTPManagedRelayer}. @type addr: L{IAddress <twisted.internet.interfaces.IAddress>} provider @param addr: The address of the SMTP server. @rtype: L{SMTPManagedRelayer} @return: A managed relayer for SMTP. )r r r r; r< r )r �addrr r r r � buildProtocol� s ���z'SMTPManagedRelayerFactory.buildProtocolc C s | j �| � | j �| � dS )aH Notify the attempt manager that a connection could not be established. @type connector: L{IConnector <twisted.internet.interfaces.IConnector>} provider @param connector: A connector. @type reason: L{Failure} @param reason: The reason the connection attempt failed. N)r �notifyNoConnectionr( )r � connectorr' r r r �clientConnectionFailed� s z0SMTPManagedRelayerFactory.clientConnectionFailedN) r* r+ r, r- r1 r �__annotations__r r> rA r r r r r: � s r: c @ s$ e Zd ZdZeZdd� Zdd� ZdS )�ESMTPManagedRelayerFactorya� A factory to create an L{ESMTPManagedRelayer}. This factory creates a managed relayer which relays a set of messages over ESMTP and informs an attempt manager of its progress. @type protocol: callable which returns L{ESMTPManagedRelayer} @ivar protocol: A callable which returns a managed relayer for ESMTP. See L{ESMTPManagedRelayer.__init__} for parameters to the callable. @ivar secret: See L{__init__} @ivar contextFactory: See L{__init__} c O s, || _ || _tj| ||g|�R i |�� dS )a� @type messages: L{list} of L{bytes} @param messages: The base filenames of messages to be relayed. @type manager: L{_AttemptManager} @param manager: An attempt manager. @type secret: L{bytes} @param secret: A string for the authentication challenge response. @type contextFactory: L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>} @param contextFactory: An SSL context factory. @type args: 1-L{tuple} of (0) L{bytes} or 2-L{tuple} of (0) L{bytes}, (1), L{int} @param args: Positional arguments for L{SMTPClient.__init__} @param kw: Keyword arguments for L{SMTPClient.__init__} N)�secret�contextFactoryr: r )r r r rD rE r5 r6 r r r r � s z#ESMTPManagedRelayerFactory.__init__c C sB | j o| � |�}| j| j| j|| jg| j�R i | j��}| |_|S )a Create an L{ESMTPManagedRelayer}. @type addr: L{IAddress <twisted.internet.interfaces.IAddress>} provider @param addr: The address of the ESMTP server. @rtype: L{ESMTPManagedRelayer} @return: A managed relayer for ESMTP. )rD r r r rE r; r< r )r r= �sr r r r r> � s ���z(ESMTPManagedRelayerFactory.buildProtocolN)r* r+ r, r- r8 r r r> r r r r rC � s rC c @ s� e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#S )$�Queuea. A queue for messages to be relayed. @ivar directory: See L{__init__} @type n: L{int} @ivar n: A number used to form unique filenames. @type waiting: L{dict} of L{bytes} @ivar waiting: The base filenames of messages waiting to be relayed. @type relayed: L{dict} of L{bytes} @ivar relayed: The base filenames of messages in the process of being relayed. @type noisy: L{bool} @ivar noisy: A flag which determines whether informational log messages will be generated (C{True}) or not (C{False}). Tc C s || _ | �� dS )z� Initialize non-volatile state. @type directory: L{bytes} @param directory: The pathname of the directory holding messages in the queue. N)� directory�_init)r rH r r r r * s zQueue.__init__c C s d| _ i | _i | _| �� dS )z, Initialize volatile state. r N)�n�waiting�relayed� readDirectoryr r r r rI 5 s z Queue._initc C s d| j iS )z� Create a representation of the non-volatile state of the queue. @rtype: L{dict} mapping L{bytes} to L{object} @return: The non-volatile state of the queue. rH )rH r r r r � __getstate__> � zQueue.__getstate__c C s | j �|� | �� dS )z� Restore the non-volatile state of the queue and recreate the volatile state. @type state: L{dict} mapping L{bytes} to L{object} @param state: The non-volatile state of the queue. N)�__dict__�updaterI �r �stater r r � __setstate__G s zQueue.__setstate__c C s: t �| j�D ]}|dd� dkrq| �|dd� � qdS )z> Scan the message directory for new messages. ���N�-D)�os�listdirrH � addMessage�r r% r r r rM R s �zQueue.readDirectoryc C � | j �� S )z� Return the base filenames of messages waiting to be relayed. @rtype: L{list} of L{bytes} @return: The base filenames of messages waiting to be relayed. )rK �keysr r r r � getWaiting\ rO zQueue.getWaitingc C s t | j�dkS )z� Return an indication of whether the queue has messages waiting to be relayed. @rtype: L{bool} @return: C{True} if messages are waiting to be relayed. C{False} otherwise. r )�lenrK r r r r � hasWaitinge s zQueue.hasWaitingc C r[ )z� Return the base filenames of messages in the process of being relayed. @rtype: L{list} of L{bytes} @return: The base filenames of messages in the process of being relayed. )rL r\ r r r r � getRelayedp s zQueue.getRelayedc C � | j |= d| j|< dS )z� Mark a message as being relayed. @type message: L{bytes} @param message: The base filename of a message. � N)rK rL rZ r r r � setRelayingz � zQueue.setRelayingc C ra )z� Mark a message as waiting to be relayed. @type message: L{bytes} @param message: The base filename of a message. rb N)rL rK rZ r r r � setWaiting� rd zQueue.setWaitingc C s8 || j vrd| j|< | jrt�d| d � dS dS dS )z� Mark a message as waiting to be relayed unless it is in the process of being relayed. @type message: L{bytes} @param message: The base filename of a message. rb zSet � waitingN)rL rK �noisyr �msgrZ r r r rY � s �zQueue.addMessagec C s@ t j�|�}t �| �|�d � t �| �|�d � | j|= dS )z� Remove a message from the queue. @type message: L{bytes} @param message: The base filename of a message. rV �-HN)rW �path�basename�remove�getPathrL rZ r r r �done� s z Queue.donec C s t j�| j|�S )z� Return the full base pathname of a message in the queue. @type message: L{bytes} @param message: The base filename of a message. @rtype: L{bytes} @return: The full base pathname of the message. )rW rj �joinrH rZ r r r rm � s z Queue.getPathc C s8 | � |�� }t�|�W d � S 1 sw Y dS )a Get the envelope for a message. @type message: L{bytes} @param message: The base filename of a message. @rtype: L{list} of two L{bytes} @return: A list containing the origination and destination addresses for the message. N)�getEnvelopeFile�pickle�load)r r% �fr r r � getEnvelope� s $�zQueue.getEnvelopec C s t tj�| j|d �d�S )z� Return the envelope file for a message in the queue. @type message: L{bytes} @param message: The base filename of a message. @rtype: file @return: The envelope file for the message. ri �rb)�openrW rj ro rH rZ r r r rp � s zQueue.getEnvelopeFilec C s� t �� � dt�� � d| j� dt| �� �}| jd | _tt j�| j|d �d�}t j�| j|d �}t j�| j|d �}t|d�}ddl m } |||||�fS ) z� Create a new message in the queue. @rtype: 2-L{tuple} of (0) file, (1) L{FileMessage} @return: The envelope file and a message receiver for a new message in the queue. �_rb ri �wbz-CrV r )� FileMessage) rW �getpid�timerJ �idrv rj ro rH �twisted.mail.mailry )r �fname� headerFile� tempFilename� finalFilename� messageFilery r r r �createNewMessage� s ( zQueue.createNewMessageN)r* r+ r, r- rg r rI rN rT rM r] r_ r` rc re rY rn rm rt rp r� r r r r rG s& rG c @ sJ e Zd ZdZddd�Zdd� Zdd � Zd d � Zd d � Zdd� Z dd� Z dS )�_AttemptManagera* A manager for an attempt to relay a set of messages to a mail exchange server. @ivar manager: See L{__init__} @type _completionDeferreds: L{list} of L{Deferred} @ivar _completionDeferreds: Deferreds which are to be notified when the attempt to relay is finished. TNc C s, || _ g | _|| _|sddlm} || _dS )a� @type manager: L{SmartHostSMTPRelayingManager} @param manager: A smart host. @type noisy: L{bool} @param noisy: A flag which determines whether informational log messages will be generated (L{True}) or not (L{False}). @type reactor: L{IReactorTime <twisted.internet.interfaces.IReactorTime>} provider @param reactor: A reactor which will be used to schedule delayed calls. r ��reactorN)r �_completionDeferredsrg �twisted.internetr� )r r rg r� r r r r � s z_AttemptManager.__init__c C s | j �t� � | j d S )z� Return a deferred which will fire when the attempt to relay is finished. @rtype: L{Deferred} @return: A deferred which will fire when the attempt to relay is finished. ���)r� �appendr r r r r �getCompletionDeferred s z%_AttemptManager.getCompletionDeferredc C s, | j j| �tj�|�� | j j�|� dS )aY Remove a message from the relay queue and from the smart host's list of messages being relayed. @type relay: L{SMTPManagedRelayerFactory} @param relay: The factory for the relayer which sent the message. @type message: L{bytes} @param message: The path of the file holding the message. N)r �managedrl rW rj rk �queuern �r r r% r r r �_finish s z_AttemptManager._finishc C s$ | j r t�d| � | �||� dS )aD Remove a message from the relay queue after it has been successfully sent. @type relay: L{SMTPManagedRelayerFactory} @param relay: The factory for the relayer which sent the message. @type message: L{bytes} @param message: The path of the file holding the message. z'success sending %s, removing from queueN)rg r rh r� r� r r r r s z _AttemptManager.notifySuccessc C s | j r t�d| � tj�|�}| jj�|��}t � |�\}}W d � n1 s)w Y t � t | jj�|�d �||�\}}}| jj�� \}}|� t �||g|� W d � n1 s^w Y |�� D ]}|�|� qg|�� | �|| jj�|�� dS )a7 Generate a bounce message for a message which cannot be relayed. @type relay: L{SMTPManagedRelayerFactory} @param relay: The factory for the relayer responsible for the message. @type message: L{bytes} @param message: The path of the file holding the message. zcould not relay NrV )rg r rh rW rj rk r r� rp rq rr r �generateBouncerv rm r� �dump� splitlines� lineReceived� eomReceivedr� ) r r r% �fp�from_�to� bounceMessage�outgoingMessage�liner r r r + s" � � � z _AttemptManager.notifyFailurec C s� | j j�|d�D ]}| jrt�d| d � | j j�|� qz| j j|= W n ty. Y nw | j }d| _ |D ]}|� d� q7dS )aF When the connection is lost or cannot be established, prepare to resend unsent messages and fire all deferred which are waiting for the completion of the attempt to relay. @type relay: L{SMTPManagedRelayerFactory} @param relay: The factory for the relayer for the connection. r zSetting rf N) r r� �getrg r rh r� re �KeyErrorr� �callback)r r r% � notifications�dr r r r( H s � �z_AttemptManager.notifyDonec C st z| j j| }W n ty t�d� Y dS w | jr$t�dt|� � dd� }| j�d|| j j |� | j j|= dS )a When a connection to the mail exchange server cannot be established, prepare to resend messages later. @type relay: L{SMTPManagedRelayerFactory} @param relay: The factory for the relayer meant to use the connection. z(notifyNoConnection passed unknown relay!NzBacking off on delivery of c S � t | j|� d S r ��mapre �r� r r r r re p � z6_AttemptManager.notifyNoConnection.<locals>.setWaiting� ) r r� r� r rh rg �strr� � callLaterr� )r r �msgsre r r r r? ^ s �z"_AttemptManager.notifyNoConnection)TN) r* r+ r, r- r r� r� r r r( r? r r r r r� � s r� c @ sf e Zd ZU dZeZeej e d< dZ dZ ddd�Z d d � Z d d � Zd d� Zdd� Zdd� Zdd� ZdS )� SmartHostSMTPRelayingManagera� A smart host which uses SMTP managed relayers to send messages from the relay queue. L{checkState} must be called periodically at which time the state of the relay queue is checked and new relayers are created as needed. In order to relay a set of messages to a mail exchange server, a smart host creates an attempt manager and a managed relayer factory for that set of messages. When a connection is made with the mail exchange server, the managed relayer factory creates a managed relayer to send the messages. The managed relayer reports on its progress to the attempt manager which, in turn, updates the smart host's relay queue and information about its managed relayers. @ivar queue: See L{__init__}. @ivar maxConnections: See L{__init__}. @ivar maxMessagesPerConnection: See L{__init__}. @type fArgs: 3-L{tuple} of (0) L{list} of L{bytes}, (1) L{_AttemptManager}, (2) L{bytes} or 4-L{tuple} of (0) L{list} of L{bytes}, (1) L{_AttemptManager}, (2) L{bytes}, (3) L{int} @ivar fArgs: Positional arguments for L{SMTPManagedRelayerFactory.__init__}. @type fKwArgs: L{dict} @ivar fKwArgs: Keyword arguments for L{SMTPManagedRelayerFactory.__init__}. @type factory: callable which returns L{SMTPManagedRelayerFactory} @ivar factory: A callable which creates a factory for creating a managed relayer. See L{SMTPManagedRelayerFactory.__init__} for parameters to the callable. @type PORT: L{int} @ivar PORT: The port over which to connect to the SMTP server. @type mxcalc: L{None} or L{MXCalculator} @ivar mxcalc: A resource for mail exchange host lookups. @type managed: L{dict} mapping L{SMTPManagedRelayerFactory} to L{list} of L{bytes} @ivar managed: A mapping of factory for a managed relayer to filenames of messages the managed relayer is responsible for. r � N� � c C s( || _ || _i | _|| _d| _i | _dS )a Initialize a smart host. The default values specify connection limits appropriate for a low-volume smart host. @type queue: L{Queue} @param queue: A relay queue. @type maxConnections: L{int} @param maxConnections: The maximum number of concurrent connections to SMTP servers. @type maxMessagesPerConnection: L{int} @param maxMessagesPerConnection: The maximum number of messages for which a relayer will be given responsibility. r N)�maxConnections�maxMessagesPerConnectionr� r� �fArgs�fKwArgs)r r� r� r� r r r r � s z%SmartHostSMTPRelayingManager.__init__c C s | j �� }|d= |S )z� Create a representation of the non-volatile state of this object. @rtype: L{dict} mapping L{bytes} to L{object} @return: The non-volatile state of the queue. r� )rP �copy)r �dctr r r rN � s z)SmartHostSMTPRelayingManager.__getstate__c C s | j �|� i | _dS )z� Restore the non-volatile state of this object and recreate the volatile state. @type state: L{dict} mapping L{bytes} to L{object} @param state: The non-volatile state of the queue. N)rP rQ r� rR r r r rT � s z)SmartHostSMTPRelayingManager.__setstate__c C s4 | j �� t| j�| jkrdS | j �� sdS | �� S )af Check the state of the relay queue and, if possible, launch relayers to handle waiting messages. @rtype: L{None} or L{Deferred} @return: No return value if no further messages can be relayed or a deferred which fires when all of the SMTP connections initiated by this call have disconnected. N)r� rM r^ r� r� r_ � _checkStateMXr r r r � checkState� s z'SmartHostSMTPRelayingManager.checkStatec s� | j �� }|�� i }|D ]K}| j �|�\}}tj�|�\}}|�dd�}t|�dkr3t � d| � q |d } | j � |� |� | g �� | j �|�� t|�| jt| j� krX nq | jd u rbt� | _g } |�� D ]T\} } t| | j j�} | j| | g| j�R i | j��} ttjj | �| j| < | � � � | j� | �}|� dd� � |� | j | j!| � |�"� fdd�� |�"| j#| | � | � � � qht$| �S )N�@rb r� z Illegal message destination: c S s t | j�S r )r� �name)�mxr r r �<lambda> s z<SmartHostSMTPRelayingManager._checkStateMX.<locals>.<lambda>c s � � | �| fd S )Nrb )�errback��err��relayAttemptDeferredr r r� s )%r� r] �reversert �email�utils� parseaddr�splitr^ r r� rc � setdefaultr� rm r� r� �mxcalc� MXCalculator� iteritemsr� rg r r� r� r� rW rj rk r� �getMX� addCallback� _cbExchange�PORT� addErrback� _ebExchanger )r � nextMessages� exchangesrh r� r� r� r= �parts�domain�relaysr� r r �connectSetupDeferredr r� r r� � sB � � z*SmartHostSMTPRelayingManager._checkStateMXc C s ddl m} |�|||� dS )a� Initiate a connection with a mail exchange server. This callback function runs after mail exchange server for the domain has been looked up. @type address: L{bytes} @param address: The hostname of a mail exchange server. @type port: L{int} @param port: A port number. @type factory: L{SMTPManagedRelayerFactory} @param factory: A factory which can create a relayer for the mail exchange server. r r� N)r� r� � connectTCP)r �address�portr r� r r r r� s z(SmartHostSMTPRelayingManager._cbExchangec C sP t �d| � t �|� dd� }ddlm} |�d|| j| j| � | j|= dS )a� Prepare to resend messages later. This errback function runs when no mail exchange server for the domain can be found. @type failure: L{Failure} @param failure: The reason the mail exchange lookup failed. @type factory: L{SMTPManagedRelayerFactory} @param factory: A factory which can create a relayer for the mail exchange server. @type domain: L{bytes} @param domain: A domain. z+Error setting up managed relay factory for c S r� r r� r� r r r re ; r� z<SmartHostSMTPRelayingManager._ebExchange.<locals>.setWaitingr r� r� N)r r� r� r� r� r� r� )r �failurer r� re r� r r r r� ' s z(SmartHostSMTPRelayingManager._ebExchange)r� r� )r* r+ r, r- r: r r r � ClientFactoryrB r� r� r rN rT r� r� r� r� r r r r r� w s - & r� c @ s e Zd ZdZeZdS )� SmartHostESMTPRelayingManagera] A smart host which uses ESMTP managed relayers to send messages from the relay queue. @type factory: callable which returns L{ESMTPManagedRelayerFactory} @ivar factory: A callable which creates a factory for creating a managed relayer. See L{ESMTPManagedRelayerFactory.__init__} for parameters to the callable. N)r* r+ r, r- rC r r r r r r� D s r� c C s | � � dS )z� Prompt a relaying manager to check state. @type manager: L{SmartHostSMTPRelayingManager} @param manager: A relaying manager. N)r� r r r r � _checkStateR s r� c C s t �|t| �S )a� Set up a periodic call to prompt a relaying manager to check state. @type manager: L{SmartHostSMTPRelayingManager} @param manager: A relaying manager. @type delay: L{float} @param delay: The number of seconds between calls. @rtype: L{TimerService <internet.TimerService>} @return: A service which periodically reminds a relaying manager to check state. )r � TimerServicer� )r �delayr r r �RelayStateHelper\ s r� c @ � e Zd ZdZdS )�CanonicalNameLoopz� An error indicating that when trying to look up a mail exchange host, a set of canonical name records was found which form a cycle and resolution was abandoned. N�r* r+ r, r- r r r r r� m � r� c @ r� )�CanonicalNameChainTooLongz� An error indicating that when trying to look up a mail exchange host, too many canonical name records which point to other canonical name records were encountered and resolution was abandoned. Nr� r r r r r� u r� r� c @ sT e Zd ZdZdZdZddd�Zdd� Zd d � Zdd d �Z dd� Z dd� Z dd� Z dS )r� a� A utility for looking up mail exchange hosts and tracking whether they are working or not. @type clock: L{IReactorTime <twisted.internet.interfaces.IReactorTime>} provider @ivar clock: A reactor which will be used to schedule timeouts. @type resolver: L{IResolver <twisted.internet.interfaces.IResolver>} @ivar resolver: A resolver. @type badMXs: L{dict} mapping L{bytes} to L{float} @ivar badMXs: A mapping of non-functioning mail exchange hostname to time at which another attempt at contacting it may be made. @type timeOutBadMX: L{int} @ivar timeOutBadMX: Period in seconds between attempts to contact a non-functioning mail exchange host. @type fallbackToDomain: L{bool} @ivar fallbackToDomain: A flag indicating whether to attempt to use the hostname directly when no mail exchange can be found (C{True}) or not (C{False}). i TNc C sD i | _ |du rddlm} |� }|| _|du r ddlm} || _dS )aU @type resolver: L{IResolver <twisted.internet.interfaces.IResolver>} provider or L{None} @param resolver: A resolver. @type clock: L{IReactorTime <twisted.internet.interfaces.IReactorTime>} provider or L{None} @param clock: A reactor which will be used to schedule timeouts. Nr )�createResolverr� )�badMXs�twisted.names.clientr� �resolverr� r� �clock)r r� r� r� r r r r � s zMXCalculator.__init__c C s | j �� | j | jt|�< dS )z� Record that a mail exchange host is not currently functioning. @type mx: L{bytes} @param mx: The hostname of a mail exchange host. N)r� �seconds� timeOutBadMXr� r� �r r� r r r �markBad� s zMXCalculator.markBadc C s$ z| j |= W dS ty Y dS w )z� Record that a mail exchange host is functioning. @type mx: L{bytes} @param mx: The hostname of a mail exchange host. N)r� r� r� r r r �markGood� s �zMXCalculator.markGood� c C s: | j �|�}|�| j� |�| j||� |�| j|� |S )ad Find the name of a host that acts as a mail exchange server for a domain. @type domain: L{bytes} @param domain: A domain name. @type maximumCanonicalChainLength: L{int} @param maximumCanonicalChainLength: The maximum number of unique canonical name records to follow while looking up the mail exchange host. @rtype: L{Deferred} which successfully fires with L{Record_MX} @return: A deferred which succeeds with the MX record for the mail exchange server for the domain or fails if none can be found. )r� �lookupMailExchanger� �_filterRecords�_cbMXr� �_ebMX)r r� �maximumCanonicalChainLength�mailExchangeDeferredr r r r� � s �zMXCalculator.getMXc C s0 i }|d D ]}|� t|j�g ��|j� q|S )af Organize the records of a DNS response by record name. @type records: 3-L{tuple} of (0) L{list} of L{RRHeader <twisted.names.dns.RRHeader>}, (1) L{list} of L{RRHeader <twisted.names.dns.RRHeader>}, (2) L{list} of L{RRHeader <twisted.names.dns.RRHeader>} @param records: Answer resource records, authority resource records and additional resource records. @rtype: L{dict} mapping L{bytes} to L{list} of L{IRecord <twisted.names.dns.IRecord>} provider @return: A mapping of record name to record payload. r )r� r� r� r� �payload)r �records� recordBag�answerr r r r� � s zMXCalculator._filterRecordsc C s> ddl m}m} t� }g }|�|g �}|r^|�� } | j|jkrN|�|� t | j �} | |v r>| |v r7t t | ��S || }g }n|rH| � | |d �S t t| ��S | j|jkr\|�| j| f� |s|r�|�� |D ](\} } t | j �} | | jvrx| S | j�� | j| } | dkr�| j| = | S qf|d d S t |�d|����S )a� Try to find the mail exchange host for a domain from the given DNS records. This will attempt to resolve canonical name record results. It can recognize loops and will give up on non-cyclic chains after a specified number of lookups. @type answers: L{dict} mapping L{bytes} to L{list} of L{IRecord <twisted.names.dns.IRecord>} provider @param answers: A mapping of record name to record payload. @type domain: L{bytes} @param domain: A domain name. @type cnamesLeft: L{int} @param cnamesLeft: The number of unique canonical name records left to follow while looking up the mail exchange host. @rtype: L{Record_MX <twisted.names.dns.Record_MX>} or L{Failure} @return: An MX record for the mail exchange host or a failure if one cannot be found. r ��dns�errorrb zNo MX records for )� twisted.namesr� r� �setr� �pop�TYPE�CNAME�addr� r� r r� r� r� �MXr� � preference�sortr� r� r� � DNSNameError)r �answersr� � cnamesLeftr� r� � seenAliasesr� �pertinentRecords�record� canonicalNamer �host�tr r r r� � sB � � zMXCalculator._cbMXc s� ddl m� m� | jr3|��j� t�d�|�� | j � |�}� fdd�}�fdd�}|� ||� |S |� �j�r@t d|����|S ) aX Attempt to use the name of the domain directly when mail exchange lookup fails. @type failure: L{Failure} @param failure: The reason for the lookup failure. @type domain: L{bytes} @param domain: The domain name. @rtype: L{Record_MX <twisted.names.dns.Record_MX>} or L{Failure} @return: An MX record for the domain or a failure if the fallback to domain option is not in effect and an error, other than not finding an MX record, occurred during lookup. @raise IOError: When no MX record could be found and the fallback to domain option is not in effect. @raise DNSLookupError: When no MX record could be found and the fallback to domain option is in effect but no address for the domain could be found. r r� z:MX lookup failed; attempting to use hostname ({}) directlyc s � j | d�S )N)r� )� Record_MX)r= )r� r r � cbResolvedf s z&MXCalculator._ebMX.<locals>.cbResolvedc s | � � j� t� �r )�trapr r r� )r� r r � ebResolvedi s z&MXCalculator._ebMX.<locals>.ebResolvedzNo MX found for )r� r� r� �fallbackToDomainr r r rh �formatr� � getHostByName� addCallbacks�check�OSError)r r� r� r� r r r r� r r� B s �� zMXCalculator._ebMX)NN)r� ) r* r+ r, r- r� r r r� r� r� r� r� r� r r r r r� } s Rr� )-r- � email.utilsr� rW rq r{ �typingr �twisted.applicationr r� r �twisted.internet.deferr r �twisted.internet.errorr �twisted.internet.protocolr � twisted.mailr r r �twisted.pythonr �twisted.python.failurer r r3 r1 r9 r8 r� r: rC rG r� r� r� r� r� � Exceptionr� r� r� r r r r �<module> s> * KA O N PK Mb�Zߙ�a [ [ % mail/__pycache__/mail.cpython-310.pycnu �[��� o �baP � @ s� d Z ddlZddlZddlmZ ddlmZmZ ddlm Z ddl m Z ddl m Z mZ ddlmZmZ dd lmZmZ G d d � d �Zee�G d d � d ��Zeej�G dd� d��ZG dd� dej�ZG dd� dej�Z dS )z Mail service support. � N)� implementer)�internet�service)�Portal)�defer)� protocols�smtp)�IAliasableDomain�IDomain)�log�utilc @ s� e Zd ZdZdd� Zdd� Zdd� Zed4d d ��Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdefdd�Zdefdd�Zd4d d �Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Z d2d3� Z dS )5�DomainWithDefaultDictz� A simulated dictionary for mapping domain names to domain objects with a default value for non-existing keys. @ivar domains: See L{__init__} @ivar default: See L{__init__} c C s || _ || _dS )z� @type domains: L{dict} of L{bytes} -> L{IDomain} provider @param domains: A mapping of domain name to domain object. @type default: L{IDomain} provider @param default: The default domain. N)�domains�default)�selfr r � r �3/usr/lib/python3/dist-packages/twisted/mail/mail.py�__init__$ s z DomainWithDefaultDict.__init__c C � || _ dS )z Set the default domain. @type domain: L{IDomain} provider @param domain: The default domain. N)r )r �domainr r r �setDefaultDomain/ � z&DomainWithDefaultDict.setDefaultDomainc C s t jdtdd� dS )� Test for the presence of a domain name in this dictionary. This always returns C{True} because a default value will be returned if the name doesn't exist in this dictionary. @type name: L{bytes} @param name: A domain name. @rtype: L{bool} @return: C{True} to indicate that the domain name is in this dictionary. zotwisted.mail.mail.DomainWithDefaultDict.has_key was deprecated in Twisted 16.3.0. Use the `in` keyword instead.� )�category� stacklevel� )�warnings�warn�DeprecationWarning�r �namer r r �has_key8 s �z DomainWithDefaultDict.has_keyNc C s | � }|D ]}|||< q|S )a� Create a new L{DomainWithDefaultDict} with the specified keys. @type keys: iterable of L{bytes} @param keys: Domain names to serve as keys in the new dictionary. @type value: L{None} or L{IDomain} provider @param value: A domain object to serve as the value for all new keys in the dictionary. @rtype: L{DomainWithDefaultDict} @return: A new dictionary. r )�klass�keys�value�d�kr r r �fromkeysO s z DomainWithDefaultDict.fromkeysc C � dS )r r r r r r r � __contains__c � z"DomainWithDefaultDict.__contains__c C s | j �|| j�S )a- Look up a domain name and, if it is present, return the domain object associated with it. Otherwise return the default domain. @type name: L{bytes} @param name: A domain name. @rtype: L{IDomain} provider or L{None} @return: A domain object. )r �getr r r r r � __getitem__s s z!DomainWithDefaultDict.__getitem__c C s || j |< dS )z� Associate a domain object with a domain name in this dictionary. @type name: L{bytes} @param name: A domain name. @type value: L{IDomain} provider @param value: A domain object. N�r )r r! r% r r r � __setitem__� s z!DomainWithDefaultDict.__setitem__c C s | j |= dS )z� Delete the entry for a domain name in this dictionary. @type name: L{bytes} @param name: A domain name. Nr. r r r r � __delitem__� s z!DomainWithDefaultDict.__delitem__c C � t | j�S )z� Return an iterator over the domain names in this dictionary. @rtype: iterator over L{bytes} @return: An iterator over the domain names. )�iterr �r r r r �__iter__� r z DomainWithDefaultDict.__iter__c C r1 )z� Return the number of domains in this dictionary. @rtype: L{int} @return: The number of domains in this dictionary. )�lenr r3 r r r �__len__� r z DomainWithDefaultDict.__len__�returnc C � d| j � d�S )z� Build an informal string representation of this dictionary. @rtype: L{bytes} @return: A string containing the mapping of domain names to domain objects. z<DomainWithDefaultDict �>r. r3 r r r �__str__� � z DomainWithDefaultDict.__str__c C r8 )z� Build an "official" string representation of this dictionary. @rtype: L{bytes} @return: A pseudo-executable string describing the underlying domain mapping of this object. zDomainWithDefaultDict(�)r. r3 r r r �__repr__� r; z DomainWithDefaultDict.__repr__c C � | j �||�S )a� Look up a domain name in this dictionary. @type key: L{bytes} @param key: A domain name. @type default: L{IDomain} provider or L{None} @param default: A domain object to be returned if the domain name is not in this dictionary. @rtype: L{IDomain} provider or L{None} @return: The domain object associated with the domain name if it is in this dictionary. Otherwise, the default value. )r r, �r �keyr r r r r, � � zDomainWithDefaultDict.getc C s t | j�� | j�S )z� Make a copy of this dictionary. @rtype: L{DomainWithDefaultDict} @return: A copy of this dictionary. )r r �copyr r3 r r r rB � s zDomainWithDefaultDict.copyc C � | j �� S )a� Return an iterator over the domain name/domain object pairs in the dictionary. Using the returned iterator while adding or deleting entries from the dictionary may result in a L{RuntimeError} or failing to iterate over all the domain name/domain object pairs. @rtype: iterator over 2-L{tuple} of (E{1}) L{bytes}, (E{2}) L{IDomain} provider or L{None} @return: An iterator over the domain name/domain object pairs. )r � iteritemsr3 r r r rD � s z DomainWithDefaultDict.iteritemsc C rC )ae Return an iterator over the domain names in this dictionary. Using the returned iterator while adding or deleting entries from the dictionary may result in a L{RuntimeError} or failing to iterate over all the domain names. @rtype: iterator over L{bytes} @return: An iterator over the domain names. )r �iterkeysr3 r r r rE � � z DomainWithDefaultDict.iterkeysc C rC )a� Return an iterator over the domain objects in this dictionary. Using the returned iterator while adding or deleting entries from the dictionary may result in a L{RuntimeError} or failing to iterate over all the domain objects. @rtype: iterator over L{IDomain} provider or L{None} @return: An iterator over the domain objects. )r � itervaluesr3 r r r rG � s z DomainWithDefaultDict.itervaluesc C rC )z� Return a list of all domain names in this dictionary. @rtype: L{list} of L{bytes} @return: The domain names in this dictionary. )r r$ r3 r r r r$ � s zDomainWithDefaultDict.keysc C rC )z� Return a list of all domain objects in this dictionary. @rtype: L{list} of L{IDomain} provider or L{None} @return: The domain objects in this dictionary. )r �valuesr3 r r r rH r z DomainWithDefaultDict.valuesc C rC )a Return a list of all domain name/domain object pairs in this dictionary. @rtype: L{list} of 2-L{tuple} of (E{1}) L{bytes}, (E{2}) L{IDomain} provider or L{None} @return: Domain name/domain object pairs in this dictionary. )r �itemsr3 r r r rI � zDomainWithDefaultDict.itemsc C rC )aE Remove a random domain name/domain object pair from this dictionary and return it as a tuple. @rtype: 2-L{tuple} of (E{1}) L{bytes}, (E{2}) L{IDomain} provider or L{None} @return: A domain name/domain object pair. @raise KeyError: When this dictionary is empty. )r �popitemr3 r r r rK rF z DomainWithDefaultDict.popitemc C s | j �|�S )a� Update this dictionary with domain name/domain object pairs from another dictionary. When this dictionary contains a domain name which is in the other dictionary, its value will be overwritten. @type other: L{dict} of L{bytes} -> L{IDomain} provider and/or L{bytes} -> L{None} @param other: Another dictionary of domain name/domain object pairs. @rtype: L{None} @return: None. )r �update)r �otherr r r rL * s z DomainWithDefaultDict.updatec C rC )zh Remove all items from this dictionary. @rtype: L{None} @return: None. )r �clearr3 r r r rN ; r zDomainWithDefaultDict.clearc C r> )a� Return the domain object associated with the domain name if it is present in this dictionary. Otherwise, set the value for the domain name to the default and return that value. @type key: L{bytes} @param key: A domain name. @type default: L{IDomain} provider @param default: A domain object. @rtype: L{IDomain} provider or L{None} @return: The domain object associated with the domain name. )r � setdefaultr? r r r rO D rA z DomainWithDefaultDict.setdefault�N) �__name__� __module__� __qualname__�__doc__r r r" � classmethodr( r* r- r/ r0 r4 r6 �strr: r= r, rB rD rE rG r$ rH rI rK rL rN rO r r r r r s6 r c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � BounceDomainzN A domain with no users. This can be used to block off a domain. c C s t �|��)z� Raise an exception to indicate that the user does not exist in this domain. @type user: L{User} @param user: A user. @raise SMTPBadRcpt: When the given user does not exist in this domain. )r � SMTPBadRcpt)r �userr r r �exists^ � zBounceDomain.existsc C r) )aq Indicate that this domain will not relay. @type user: L{Address} @param user: The destination address. @type protocol: L{Protocol <twisted.internet.protocol.Protocol>} @param protocol: The protocol over which the message to be relayed is being received. @rtype: L{bool} @return: C{False}. Fr )r rZ �protocolr r r � willRelayj r+ zBounceDomain.willRelayc C r) )z� Ignore attempts to add a user to this domain. @type user: L{bytes} @param user: A username. @type password: L{bytes} @param password: A password. Nr )r rZ �passwordr r r �addUserz s zBounceDomain.addUserc C s g S )z{ Return no credentials checkers for this domain. @rtype: L{list} @return: The empty list. r r3 r r r �getCredentialsCheckers� s z#BounceDomain.getCredentialsCheckersN)rQ rR rS rT r[ r^ r` ra r r r r rX V s rX c @ rW ) � FileMessagez� A message receiver which delivers a message to a file. @ivar fp: See L{__init__}. @ivar name: See L{__init__}. @ivar finalName: See L{__init__}. c C s || _ || _|| _dS )a� @type fp: file-like object @param fp: The file in which to store the message while it is being received. @type name: L{bytes} @param name: The full path name of the temporary file. @type finalName: L{bytes} @param finalName: The full path name that should be given to the file holding the message after it has been fully received. N)�fpr! � finalName)r rc r! rd r r r r � s zFileMessage.__init__c C s | j �|d � dS )zx Write a received line to the file. @type line: L{bytes} @param line: A received line. � N)rc �write)r �liner r r � lineReceived� s zFileMessage.lineReceivedc C s& | j �� t�| j| j� t�| j�S )z� At the end of message, rename the file holding the message to its final name. @rtype: L{Deferred} which successfully results in L{bytes} @return: A deferred which returns the final name of the file. )rc �close�os�renamer! rd r �succeedr3 r r r � eomReceived� s zFileMessage.eomReceivedc C s | j �� t�| j� dS )zI Delete the file holding the partially received message. N)rc ri rj �remover! r3 r r r �connectionLost� s zFileMessage.connectionLostN)rQ rR rS rT r rh rm ro r r r r rb � s rb c @ sl e Zd ZdZdZdZdZdZdZdd� Z dd� Z dd� Z d d � Z d d � Z d d� Zdd� Zdd� Zdd� ZdS )� MailServicea� An email service. @type queue: L{Queue} or L{None} @ivar queue: A queue for outgoing messages. @type domains: L{dict} of L{bytes} -> L{IDomain} provider @ivar domains: A mapping of supported domain name to domain object. @type portals: L{dict} of L{bytes} -> L{Portal} @ivar portals: A mapping of domain name to authentication portal. @type aliases: L{None} or L{dict} of L{bytes} -> L{IAlias} provider @ivar aliases: A mapping of domain name to alias. @type smtpPortal: L{Portal} @ivar smtpPortal: A portal for authentication for the SMTP server. @type monitor: L{FileMonitoringService} @ivar monitor: A service to monitor changes to files. Nc C sB t j�| � ti t� �| _i | _t� | _| j� | � t | �| _ dS )z. Initialize the mail service. N) r � MultiServicer r rX r �portals�FileMonitoringService�monitor�setServiceParentr � smtpPortalr3 r r r r � s zMailService.__init__c C s t �| �S )z{ Create a POP3 protocol factory. @rtype: L{POP3Factory} @return: A POP3 protocol factory. )r � POP3Factoryr3 r r r �getPOP3Factory� r zMailService.getPOP3Factoryc C � t �| | j�S )z� Create an SMTP protocol factory. @rtype: L{SMTPFactory <protocols.SMTPFactory>} @return: An SMTP protocol factory. )r � SMTPFactoryrv r3 r r r �getSMTPFactory� � zMailService.getSMTPFactoryc C ry )z� Create an ESMTP protocol factory. @rtype: L{ESMTPFactory <protocols.ESMTPFactory>} @return: An ESMTP protocol factory. )r � ESMTPFactoryrv r3 r r r �getESMTPFactory r| zMailService.getESMTPFactoryc C sT t |�}t|j|�� � || j|< || j|< | jr&t�|�r(|� | j� dS dS dS )z� Add a domain for which the service will accept email. @type name: L{bytes} @param name: A domain name. @type domain: L{IDomain} provider @param domain: A domain object. N) r �map�registerCheckerra r rr �aliasesr � providedBy� setAliasGroup)r r! r �portalr r r � addDomain s �zMailService.addDomainc C r )z� Set the queue for outgoing emails. @type queue: L{Queue} @param queue: A queue for outgoing messages. N)�queue)r r� r r r �setQueue r zMailService.setQueuec G s, t j|v rt�| |�}t j|dd� fS t� �)a� Return a message delivery for an authenticated SMTP user. @type avatarId: L{bytes} @param avatarId: A string which identifies an authenticated user. @type mind: L{None} @param mind: Unused. @type interfaces: n-L{tuple} of C{zope.interface.Interface} @param interfaces: A group of interfaces one of which the avatar must support. @rtype: 3-L{tuple} of (E{1}) L{IMessageDelivery}, (E{2}) L{ESMTPDomainDelivery}, (E{3}) no-argument callable @return: A tuple of the supported interface, a message delivery, and a logout function. @raise NotImplementedError: When the given interfaces do not include L{IMessageDelivery}. c S s d S rP r r r r r �<lambda>@ s z+MailService.requestAvatar.<locals>.<lambda>)r �IMessageDeliveryr �ESMTPDomainDelivery�NotImplementedError)r �avatarId�mind� interfaces�ar r r � requestAvatar( s zMailService.requestAvatarc C s | j | S )z� Find the portal for a domain. @type name: L{bytes} @param name: A domain name. @rtype: L{Portal} @return: A portal. �rr r r r r � lookupPortalC r\ zMailService.lookupPortalc C s | j d S )z� Return the portal for the default domain. The default domain is named ''. @rtype: L{Portal} @return: The portal for the default domain. � r� r3 r r r � defaultPortalO rJ zMailService.defaultPortal)rQ rR rS rT r� r rr r� rv r rx r{ r~ r� r� r� r� r� r r r r rp � s rp c @ sJ e Zd ZdZdd� Zdd� Zdd� Zdd � Zdd d �Zd d� Z dd� Z dS )rs a_ A service for monitoring changes to files. @type files: L{list} of L{list} of (E{1}) L{float}, (E{2}) L{bytes}, (E{3}) callable which takes a L{bytes} argument, (E{4}) L{float} @ivar files: Information about files to be monitored. Each list entry provides the following information for a file: interval in seconds between checks, filename, callback function, time of last modification to the file. @type intervals: L{_IntervalDifferentialIterator <twisted.python.util._IntervalDifferentialIterator>} @ivar intervals: Intervals between successive file checks. @type _call: L{IDelayedCall <twisted.internet.interfaces.IDelayedCall>} provider @ivar _call: The next scheduled call to check a file. @type index: L{int} @ivar index: The index of the next file to be checked. c C s g | _ tt�g d��| _dS )z9 Initialize the file monitoring service. �< N)�filesr2 r �IntervalDifferential� intervalsr3 r r r r r s z FileMonitoringService.__init__c C s t j�| � | �� dS )z4 Start the file monitoring service. N)r �Service� startService� _setupMonitorr3 r r r r� y s z"FileMonitoringService.startServicec C s0 ddl m} | j�� \}| _|�|| j�| _dS )z4 Schedule the next monitoring call. r )�reactorN)�twisted.internetr� r� �next�index� callLater�_monitor�_call)r r� �tr r r r� � s z#FileMonitoringService._setupMonitorc C s* t j�| � | jr| j�� d| _dS dS )z3 Stop the file monitoring service. N)r r� � stopServicer� �cancelr3 r r r r� � s �z!FileMonitoringService.stopService� c C sL zt j�|�}W n ty d}Y nw | j�||||g� | j�|� dS )av Start monitoring a file for changes. @type name: L{bytes} @param name: The name of a file to monitor. @type callback: callable which takes a L{bytes} argument @param callback: The function to call when the file has changed. @type interval: L{float} @param interval: The interval in seconds between checks. r N)rj �path�getmtime� BaseExceptionr� �appendr� � addInterval)r r! �callback�interval�mtimer r r � monitorFile� s �z!FileMonitoringService.monitorFilec C sN t t| j��D ] }|| j| d kr$| j�| j| d � | j|= dS qdS )zi Stop monitoring a file. @type name: L{bytes} @param name: A file name. r r N)�ranger5 r� r� �removeInterval)r r! �ir r r � unmonitorFile� s ��z#FileMonitoringService.unmonitorFilec C s� d| _ | jdurA| j| j dd� \}}}ztj�|�}W n ty( d}Y nw ||krAt�|� d�� || j| j d< ||� | � � dS )zG Monitor a file and make a callback if it has changed. Nr r z changed, notifying listener� ) r� r� r� rj r� r� r� r �msgr� )r r! r� r� �nowr r r r� � s � z FileMonitoringService._monitorN)r� ) rQ rR rS rT r r� r� r� r� r� r� r r r r rs [ s rs ) rT rj r �zope.interfacer �twisted.applicationr r �twisted.cred.portalr r� r � twisted.mailr r �twisted.mail.interfacesr r �twisted.pythonr r r rX �IMessagerb rq rp � TimerServicers r r r r �<module> s( =97 PK Mb�Z%��)0 )0 ( mail/__pycache__/_except.cpython-310.pycnu �[��� o �b" � @ s� d Z ddlmZ G dd� de�ZG dd� de�ZG dd� de�ZG d d � d e�ZG d d � d e�ZG d d� de�Z G dd� de�Z G dd� de�Z G dd� de�Z G dd� de�Z G dd� de�ZG dd� de�ZG dd � d e�ZG d d � d e�ZG d d � d e�ZG d!d"� d"e�ZG d#d$� d$e�ZG d%d&� d&e�ZG d'd(� d(e�ZG d)d*� d*e�ZG d+d,� d,e�ZG d-d.� d.e�ZG d/d0� d0e�ZG d1d2� d2e�ZG d3d4� d4e�Z G d5d6� d6e�Z G d7d8� d8e�Z G d9d:� d:e�Z G d;d<� d<e�Z G d=d>� d>e�Z!G d?d@� d@e!�Z"G dAdB� dBe"�Z#G dCdD� dDe"�Z$G dEdF� dFe�Z%G dGdH� dHe�Z&G dIdJ� dJe�Z'G dKdL� dLe�Z(G dMdN� dNe(�Z)G dOdP� dPe(�Z*G dQdR� dRe(�Z+G dSdT� dTe(�Z,G dUdV� dVe(�Z-dWS )Xz Exceptions in L{twisted.mail}. � )�Optionalc @ � e Zd ZdS )�IMAP4ExceptionN��__name__� __module__� __qualname__� r r �6/usr/lib/python3/dist-packages/twisted/mail/_except.pyr � r c @ r )�IllegalClientResponseNr r r r r r r r c @ r )�IllegalOperationNr r r r r r r r c @ r )�IllegalMailboxEncodingNr r r r r r r r c @ r )�MailboxExceptionNr r r r r r r r c @ � e Zd Zdefdd�ZdS )�MailboxCollision�returnc C � d| j S )Nz Mailbox named %s already exists��args��selfr r r �__str__ � zMailboxCollision.__str__N�r r r �strr r r r r r � r c @ r )� NoSuchMailboxr c C r )NzNo mailbox named %s existsr r r r r r % r zNoSuchMailbox.__str__Nr r r r r r $ r r c @ r )�ReadOnlyMailboxr c C s dS )Nz Mailbox open in read-only stater r r r r r * s zReadOnlyMailbox.__str__Nr r r r r r ) r r c @ r )�UnhandledResponseNr r r r r r . r r c @ r )�NegativeResponseNr r r r r r 2 r r c @ �" e Zd Zdd� Zdefdd�ZdS )�NoSupportedAuthenticationc C s t �| d� || _|| _d S )Nz-No supported authentication schemes available)r �__init__�serverSupports�clientSupports)r r$ r% r r r r# 7 s z"NoSupportedAuthentication.__init__r c C s t �| �d�| j| j� S )Nz,: Server supports {!r}, client supports {!r})r r �formatr$ r% r r r r r < s ���z!NoSupportedAuthentication.__str__N�r r r r# r r r r r r r" 6 s r" c @ r )�IllegalServerResponseNr r r r r r( E r r( c @ r )�IllegalIdentifierErrorNr r r r r r) I r r) c @ r )�IllegalQueryErrorNr r r r r r* M r r* c @ r )�MismatchedNestingNr r r r r r+ Q r r+ c @ r )�MismatchedQuotingNr r r r r r, U r r, c @ r )� SMTPErrorNr r r r r r- Y r r- c @ s` e Zd ZdZ ddededee dee ded ef d d �Z d e fd d�Z d efdd�Z dS )�SMTPClientErrorz, Base class for SMTP client errors. NF�code�resp�log� addresses�isFatal�retryc C sP t |t�r |�d�}t |t�r|�d�}|| _|| _|| _|| _|| _|| _dS )a @param code: The SMTP response code associated with this error. @param resp: The string response associated with this error. @param log: A string log of the exchange leading up to and including the error. @param isFatal: A boolean indicating whether this connection can proceed or not. If True, the connection will be dropped. @param retry: A boolean indicating whether the delivery should be retried. If True and the factory indicates further retries are desirable, they will be attempted, otherwise the delivery will be failed. �utf-8N) � isinstancer �encoder/ r0 r1 r2 r3 r4 �r r/ r0 r1 r2 r3 r4 r r r r# b s zSMTPClientError.__init__r c C s | � � �d�S )Nr5 )� __bytes__�decoder r r r r � s zSMTPClientError.__str__c C sT | j dkr| j d�d��� | j g}n| jg}| jr%|�| j� |�d� d�|�S )Nr �03d� � � )r/ r7 r0 r1 �append�join)r �resr r r r9 � s zSMTPClientError.__bytes__)NNFF) r r r �__doc__�int�bytesr �object�boolr# r r r9 r r r r r. ] s* ������ �"r. c @ � e Zd ZdZdS )�ESMTPClientErrorz- Base class for ESMTP client errors. N�r r r rB r r r r rH � � rH c @ rG )�EHLORequiredErrorz{ The server does not support EHLO. This is considered a non-fatal error (the connection will not be dropped). NrI r r r r rK � rJ rK c @ rG )�AUTHRequiredErrorz� Authentication was required but the server does not support it. This is considered a non-fatal error (the connection will not be dropped). NrI r r r r rL � rJ rL c @ rG )�TLSRequiredErrorz� Transport security was required but the server does not support it. This is considered a non-fatal error (the connection will not be dropped). NrI r r r r rM � rJ rM c @ rG )�AUTHDeclinedErrorz� The server rejected our credentials. Either the username, password, or challenge response given to the server was rejected. This is considered a non-fatal error (the connection will not be dropped). NrI r r r r rN � rJ rN c @ rG )�AuthenticationErrorz� An error occurred while authenticating. Either the server rejected our request for authentication or the challenge received was malformed. This is considered a non-fatal error (the connection will not be dropped). NrI r r r r rO � rJ rO c @ rG )� SMTPTLSErrorz� An error occurred while negiotiating for transport security. This is considered a non-fatal error (the connection will not be dropped). NrI r r r r rP � rJ rP c @ � e Zd ZdZddd�ZdS )�SMTPConnectErrorzt Failed to connect to the mail exchange host. This is considered a fatal error. A retry will be made. NTc C � t �| ||||||� d S �N�r. r# r8 r r r r# � � zSMTPConnectError.__init__�NNTT�r r r rB r# r r r r rR � � rR c @ rQ )�SMTPTimeoutErrorz� Failed to receive a response from the server in the expected time period. This is considered a fatal error. A retry will be made. NTc C rS rT rU r8 r r r r# � rV zSMTPTimeoutError.__init__rW rX r r r r rZ � rY rZ c @ s e Zd ZdZddd�ZdS )�SMTPProtocolErrorzo The server sent a mangled response. This is considered a fatal error. A retry will not be made. NTFc C rS rT rU r8 r r r r# � rV zSMTPProtocolError.__init__)NNTFrX r r r r r[ � rY r[ c @ rG )�SMTPDeliveryErrorz= Indicates that a delivery attempt has had an error. NrI r r r r r\ � rJ r\ c @ r! )�SMTPServerErrorc C s || _ || _d S rT �r/ r0 )r r/ r0 r r r r# � s zSMTPServerError.__init__r c C s d| j | jf S )Nz%.3d %sr^ r r r r r � s zSMTPServerError.__str__Nr' r r r r r] � s r] c @ r! )�SMTPAddressErrorc C s( ddl m} t�| ||� ||�| _d S )Nr )�Address)�twisted.mail.smtpr` r] r# �addr)r rb r/ r0 r` r r r r# s zSMTPAddressError.__init__r c C s d| j | j| jf S )Nz%.3d <%s>... %s)r/ rb r0 r r r r r � zSMTPAddressError.__str__Nr' r r r r r_ s r_ c @ � e Zd Zddd�ZdS )� SMTPBadRcpt�& �$Cannot receive for specified addressc C � t �| |||� d S rT �r_ r# �r rb r/ r0 r r r r# rc zSMTPBadRcpt.__init__N)rf rg �r r r r# r r r r re � re c @ rd )� SMTPBadSenderrf �Sender not acceptablec C rh rT ri rj r r r r# rc zSMTPBadSender.__init__N)rf rn rk r r r r rm rl rm c @ rG )� AddressErrorz Parse error in address NrI r r r r ro rJ ro c @ rG )� POP3Errorz) The base class for POP3 errors. NrI r r r r rp s rp c @ rG )�_POP3MessageDeletedzb An internal control-flow error which indicates that a deleted message was requested. NrI r r r r rq # rJ rq c @ rG )�POP3ClientErrorzA The base class for all exceptions raised by POP3Client. NrI r r r r rr * rJ rr c @ rG )� InsecureAuthenticationDisallowedze An error indicating secure authentication was required but no mechanism could be found. NrI r r r r rs 0 rJ rs c @ rG )�TLSErrorz� An error indicating secure authentication was required but either the transport does not support TLS or no TLS context factory was supplied. NrI r r r r rt 7 rJ rt c @ rG )�TLSNotSupportedErrorzi An error indicating secure authentication was required but the server does not support TLS. NrI r r r r ru > rJ ru c @ s e Zd ZdZddd�ZdS )�ServerErrorResponsez An error indicating that the server returned an error response to a request. @ivar consumer: See L{__init__} Nc C s t �| |� || _dS )a @type reason: L{bytes} @param reason: The server response minus the status indicator. @type consumer: callable that takes L{object} @param consumer: The function meant to handle the values for a multi-line response. N)rr r# �consumer)r �reasonrw r r r r# M s z ServerErrorResponse.__init__rT rX r r r r rv E s rv c @ rG )� LineTooLongz� An error indicating that the server sent a line which exceeded the maximum line length (L{LineOnlyReceiver.MAX_LENGTH}). NrI r r r r ry Z rJ ry N).rB �typingr � Exceptionr r r r r r r r r r r" r( r) r* r+ r, r- r. rH rK rL rM rN rO rP rR rZ r[ r\ r] r_ re rm ro rp rq rr rs rt ru rv ry r r r r �<module> sX 5 PK Mb�Z+���� � & mail/__pycache__/relay.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ G dd� d�Z G dd � d �Z G d d � d e ej �Z G d d � d e ej �ZdS )z Support for relaying mail. � N)� UNIXAddress)�smtp)�logc @ s2 e Zd ZdZd dd�Zdd� Zdd� Zd d � Zd S ) � DomainQueuerzM An SMTP domain which add messages to a queue intended for relaying. Fc C s || _ || _d S �N)�service�authed)�selfr � authenticated� r �4/usr/lib/python3/dist-packages/twisted/mail/relay.py�__init__ s zDomainQueuer.__init__c sp � � �j�j�r3tdt�j��dd��}tdt�j��dd��}t|�dkr3t|�dkr3� �fdd�S t� ���)a� Check whether mail can be relayed to a user. @type user: L{User} @param user: A user. @rtype: no-argument callable which returns L{IMessage <smtp.IMessage>} provider @return: A function which takes no arguments and returns a message receiver for the user. @raise SMTPBadRcpt: When mail cannot be relayed to the user. N�@� � c s � � ��S r )� startMessager �r �userr r �<lambda>- s z%DomainQueuer.exists.<locals>.<lambda>) � willRelay�dest�protocol�filter�str�orig�split�lenr � SMTPBadRcpt)r r r r r r r �exists s zDomainQueuer.existsc C s$ |j �� }| jpt|t�p|jdkS )z� Check whether we agree to relay. The default is to relay for all connections over UNIX sockets and all connections from localhost. z 127.0.0.1)� transport�getPeerr � isinstancer �host)r �addressr �peerr r r r 0 s zDomainQueuer.willRelayc C s| | j j}|�� \}}|�( t�dt|j��dt|j���� t� t|j�t|j�g|� W d � |S 1 s7w Y |S )z� Create an envelope and a message receiver for the relay queue. @type user: L{User} @param user: A user. @rtype: L{IMessage <smtp.IMessage>} @return: A message receiver. zQueueing mail z -> N) r �queue�createNewMessager �msgr r r �pickle�dump)r r r% � envelopeFile� smtpMessager r r r : s " ��zDomainQueuer.startMessageN)F)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s r c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) � RelayerMixinc C s� g | _ g | _|D ]5}t|d d�� }t�|�}W d � n1 s!w Y t|d �}|�|� | j �|� | j�|� qd S )N�-H�rb�-D)�messages�names�openr( �load�append)r � messagePaths�message�fp�messageContentsr r r � loadMessagesR s � �zRelayerMixin.loadMessagesc C s | j sd S | j d d S )Nr �r4 �r r r r � getMailFrom] � zRelayerMixin.getMailFromc C s | j sd S | j d d gS )Nr r r> r? r r r � getMailTob s zRelayerMixin.getMailToc C s | j sd S | j d d S )Nr r r> r? r r r � getMailDatag rA zRelayerMixin.getMailDatac C sF |t jv rt�| jd d � t�| jd d � | jd= | jd= dS )z�Since we only use one recipient per envelope, this will be called with 0 or 1 addresses. We probably want to do something with the error message if we failed. r r3 r1 N)r �SUCCESS�os�remover5 r4 )r �code�resp�numOk� addressesr r r r �sentMaill s zRelayerMixin.sentMailN)r, r- r. r= r@ rB rC rK r r r r r0 L s r0 c @ � e Zd ZdZdd� ZdS )� SMTPRelayerz) A base class for SMTP relayers. c O �( t jj| g|�R i |�� | �|� dS )a� @type messagePaths: L{list} of L{bytes} @param messagePaths: The base filename for each message to be relayed. @type args: 1-L{tuple} of (0) L{bytes} or 2-L{tuple} of (0) L{bytes}, (1) L{int} @param args: Positional arguments for L{SMTPClient.__init__} @type kw: L{dict} @param kw: Keyword arguments for L{SMTPClient.__init__} N)r � SMTPClientr r= �r r9 �args�kwr r r r ~ s zSMTPRelayer.__init__N�r, r- r. r/ r r r r r rM y � rM c @ rL )� ESMTPRelayerz* A base class for ESMTP relayers. c O rN )a� @type messagePaths: L{list} of L{bytes} @param messagePaths: The base filename for each message to be relayed. @type args: 3-L{tuple} of (0) L{bytes}, (1) L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>}, (2) L{bytes} or 4-L{tuple} of (0) L{bytes}, (1) L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>}, (2) L{bytes}, (3) L{int} @param args: Positional arguments for L{ESMTPClient.__init__} @type kw: L{dict} @param kw: Keyword arguments for L{ESMTPClient.__init__} N)r � ESMTPClientr r= rP r r r r � s zESMTPRelayer.__init__NrS r r r r rU � rT rU )r/ rE r( �twisted.internet.addressr � twisted.mailr �twisted.pythonr r r0 rO rM rV rU r r r r �<module> s ;-PK Mb�Zx�!}� }� + mail/__pycache__/interfaces.cpython-310.pycnu �[��� o �bI} � @ sl d Z ddlmZ G dd� de�ZG dd� de�ZG dd� de�ZG d d � d e�ZG d d � d e�ZG d d� de�ZG dd� de�Z G dd� de�Z G dd� de�Z G dd� de�Z G dd� de�Z G dd� de �ZG dd � d e�ZG d d � d e�ZG d d � d e�ZG d!d"� d"e�ZG d#d$� d$e�ZG d%d&� d&e�ZG d'd(� d(e�ZG d)d*� d*e�ZG d+d,� d,e�Zg d-�Zd.S )/z/ Interfaces for L{twisted.mail}. @since: 16.5 � )� Interfacec @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �IChallengeResponsez; An C{IMAPrev4} authorization challenge mechanism. c C � dS )zd Return a client challenge. @return: A challenge. @rtype: L{bytes} N� r r r �9/usr/lib/python3/dist-packages/twisted/mail/interfaces.py� getChallenge � z IChallengeResponse.getChallengec C r )aL Extract a username and possibly a password from a response and assign them to C{username} and C{password} instance variables. @param response: A decoded response. @type response: L{bytes} @see: L{credentials.IUsernamePassword} or L{credentials.IUsernameHashedPassword} Nr )�responser r r � setResponse r z IChallengeResponse.setResponsec C r )a= Are there more challenges than just the first? If so, callers should challenge clients with the result of L{getChallenge}, and check their response with L{setResponse} in a loop until this returns L{False} @return: Are there more challenges? @rtype: L{bool} Nr r r r r �moreChallenges' r z!IChallengeResponse.moreChallengesN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r c @ s e Zd Zdd� Zdd� ZdS )�IClientAuthenticationc C r )zl Return an identifier associated with this authentication scheme. @rtype: L{bytes} Nr r r r r �getName4 r z IClientAuthentication.getNamec C r )z7 Generate a challenge response string. Nr )�secret� challenger r r �challengeResponse; r z'IClientAuthentication.challengeResponseN)r r r r r r r r r r 3 s r c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �IServerFactoryPOP3a� An interface for querying capabilities of a POP3 server. Any cap_* method may raise L{NotImplementedError} if the particular capability is not supported. If L{cap_EXPIRE()} does not raise L{NotImplementedError}, L{perUserExpiration()} must be implemented, otherwise they are optional. If L{cap_LOGIN_DELAY()} is implemented, L{perUserLoginDelay()} must be implemented, otherwise they are optional. @type challengers: L{dict} of L{bytes} -> L{IUsernameHashedPassword <cred.credentials.IUsernameHashedPassword>} @ivar challengers: A mapping of challenger names to L{IUsernameHashedPassword <cred.credentials.IUsernameHashedPassword>} provider. c C r )z� Return a string describing the POP3 server implementation. @rtype: L{bytes} @return: Server implementation information. Nr r r r r �cap_IMPLEMENTATIONR r z%IServerFactoryPOP3.cap_IMPLEMENTATIONc C r )z� Return the minimum number of days messages are retained. @rtype: L{int} or L{None} @return: The minimum number of days messages are retained or none, if the server never deletes messages. Nr r r r r � cap_EXPIREZ r z IServerFactoryPOP3.cap_EXPIREc C r )z� Indicate whether the message expiration policy differs per user. @rtype: L{bool} @return: C{True} when the message expiration policy differs per user, C{False} otherwise. Nr r r r r �perUserExpirationc r z$IServerFactoryPOP3.perUserExpirationc C r )z� Return the minimum number of seconds between client logins. @rtype: L{int} @return: The minimum number of seconds between client logins. Nr r r r r �cap_LOGIN_DELAYl r z"IServerFactoryPOP3.cap_LOGIN_DELAYc C r )z� Indicate whether the login delay period differs per user. @rtype: L{bool} @return: C{True} when the login delay differs per user, C{False} otherwise. Nr r r r r �perUserLoginDelayt r z$IServerFactoryPOP3.perUserLoginDelayN) r r r r r r r r r r r r r r A s r c @ sB e Zd ZdZddd�Zdd� Zdd� Zd d � Zd d � Zd d� Z dS )� IMailboxPOP3a� An interface for mailbox access. Message indices are 0-based. @type loginDelay: L{int} @ivar loginDelay: The number of seconds between allowed logins for the user associated with this mailbox. @type messageExpiration: L{int} @ivar messageExpiration: The number of days messages in this mailbox will remain on the server before being deleted. Nc C r )a Retrieve the size of a message, or, if none is specified, the size of each message in the mailbox. @type index: L{int} or L{None} @param index: The 0-based index of the message. @rtype: L{int}, sequence of L{int}, or L{Deferred <defer.Deferred>} @return: The number of octets in the specified message, or, if an index is not specified, a sequence of the number of octets for all messages in the mailbox or a deferred which fires with one of those. Any value which corresponds to a deleted message is set to 0. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. Nr ��indexr r r � listMessages� r zIMailboxPOP3.listMessagesc C r )a� Retrieve a file containing the contents of a message. @type index: L{int} @param index: The 0-based index of a message. @rtype: file-like object @return: A file containing the message. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. Nr r r r r � getMessage� r zIMailboxPOP3.getMessagec C r )a� Get a unique identifier for a message. @type index: L{int} @param index: The 0-based index of a message. @rtype: L{bytes} @return: A string of printable characters uniquely identifying the message for all time. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. Nr r r r r �getUidl� r zIMailboxPOP3.getUidlc C r )a� Mark a message for deletion. This must not change the number of messages in this mailbox. Further requests for the size of the deleted message should return 0. Further requests for the message itself may raise an exception. @type index: L{int} @param index: The 0-based index of a message. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. Nr r r r r � deleteMessage� r zIMailboxPOP3.deleteMessagec C r )z� Undelete all messages marked for deletion. Any message which can be undeleted should be returned to its original position in the message sequence and retain its original UID. Nr r r r r �undeleteMessages� r z IMailboxPOP3.undeleteMessagesc C r )zJ Discard the contents of any message marked for deletion. Nr r r r r �sync� r zIMailboxPOP3.sync�N) r r r r r r r! r" r# r$ r r r r r ~ s r c @ r ) �IDomainz) An interface for email domains. c C r )a� Check whether a user exists in this domain. @type user: L{User} @param user: A user. @rtype: no-argument callable which returns L{IMessageSMTP} provider @return: A function which takes no arguments and returns a message receiver for the user. @raise SMTPBadRcpt: When the given user does not exist in this domain. Nr ��userr r r �exists� r zIDomain.existsc C r )z� Add a user to this domain. @type user: L{bytes} @param user: A username. @type password: L{bytes} @param password: A password. Nr )r( �passwordr r r �addUser� r zIDomain.addUserc C r )z� Return credentials checkers for this domain. @rtype: L{list} of L{ICredentialsChecker <twisted.cred.checkers.ICredentialsChecker>} provider @return: Credentials checkers for this domain. Nr r r r r �getCredentialsCheckers� r z IDomain.getCredentialsCheckersN)r r r r r) r+ r, r r r r r& � s r& c @ � e Zd ZdZdd� ZdS )�IAliasz# An interface for aliases. c C r )z{ Create a message receiver. @rtype: L{IMessageSMTP} provider @return: A message receiver. Nr r r r r �createMessageReceiver r z IAlias.createMessageReceiverN)r r r r r/ r r r r r. s r. c @ s" e Zd ZdZdd� Zddd�ZdS )�IAliasableDomainzO An interface for email domains which can be aliased to other domains. c C r )z� Set the group of defined aliases for this domain. @type aliases: L{dict} of L{bytes} -> L{IAlias} provider @param aliases: A mapping of domain name to alias. Nr )�aliasesr r r � setAliasGroup r z IAliasableDomain.setAliasGroupNc C r )a� Check whether a user exists in this domain or an alias of it. @type user: L{User} @param user: A user. @type memo: L{None} or L{dict} of L{AliasBase <twisted.mail.alias.AliasBase>} @param memo: A record of the addresses already considered while resolving aliases. The default value should be used by all external code. @rtype: no-argument callable which returns L{IMessageSMTP} provider @return: A function which takes no arguments and returns a message receiver for the user. @raise SMTPBadRcpt: When the given user does not exist in this domain or an alias of it. Nr )r( �memor r r r) r zIAliasableDomain.existsr% )r r r r r2 r) r r r r r0 s r0 c @ �$ e Zd Zdd� Zdd� Zdd� ZdS )�IMessageDeliveryc C r )a Generate the Received header for a message. @type helo: 2-L{tuple} of L{bytes} and L{bytes}. @param helo: The argument to the HELO command and the client's IP address. @type origin: L{Address} @param origin: The address the message is from @type recipients: L{list} of L{User} @param recipients: A list of the addresses for which this message is bound. @rtype: L{bytes} @return: The full C{"Received"} header string. Nr )�helo�origin� recipientsr r r �receivedHeader4 r z IMessageDelivery.receivedHeaderc C r )a# Validate the address for which the message is destined. @type user: L{User} @param user: The address to validate. @rtype: no-argument callable @return: A L{Deferred} which becomes, or a callable which takes no arguments and returns an object implementing L{IMessageSMTP}. This will be called and the returned object used to deliver the message when it arrives. @raise SMTPBadRcpt: Raised if messages to the address are not to be accepted. Nr r' r r r � validateToG r zIMessageDelivery.validateToc C r )a# Validate the address from which the message originates. @type helo: 2-L{tuple} of L{bytes} and L{bytes}. @param helo: The argument to the HELO command and the client's IP address. @type origin: L{Address} @param origin: The address the message is from @rtype: L{Deferred} or L{Address} @return: C{origin} or a L{Deferred} whose callback will be passed C{origin}. @raise SMTPBadSender: Raised of messages from this address are not to be accepted. Nr )r6 r7 r r r � validateFromX r z IMessageDelivery.validateFromN)r r r r9 r: r; r r r r r5 3 s r5 c @ r- )�IMessageDeliveryFactorya� An alternate interface to implement for handling message delivery. It is useful to implement this interface instead of L{IMessageDelivery} directly because it allows the implementor to distinguish between different messages delivery over the same connection. This can be used to optimize delivery of a single message to multiple recipients, something which cannot be done by L{IMessageDelivery} implementors due to their lack of information. c C r )zf Return an L{IMessageDelivery} object. This will be called once per message. Nr r r r r �getMessageDeliveryx r z*IMessageDeliveryFactory.getMessageDeliveryN)r r r r r= r r r r r< l s r< c @ r ) � IMessageSMTPzF Interface definition for messages that can be sent via SMTP. c C r )z& Handle another line. Nr )�liner r r � lineReceived� r zIMessageSMTP.lineReceivedc C r )z� Handle end of message. return a deferred. The deferred should be called with either: callback(string) or errback(error) @rtype: L{Deferred} Nr r r r r � eomReceived� r zIMessageSMTP.eomReceivedc C r )z_ Handle message truncated. semantics should be to discard the message Nr r r r r �connectionLost� r zIMessageSMTP.connectionLostN)r r r r r@ rA rB r r r r r> � s r> c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �IMessageIMAPPartc G r )a� Retrieve a group of message headers. @type names: L{tuple} of L{str} @param names: The names of the headers to retrieve or omit. @type negate: L{bool} @param negate: If True, indicates that the headers listed in C{names} should be omitted from the return value, rather than included. @rtype: L{dict} @return: A mapping of header field names to header field values Nr )�negate�namesr r r � getHeaders� r zIMessageIMAPPart.getHeadersc C r )zR Retrieve a file object containing only the body of this message. Nr r r r r � getBodyFile� r z IMessageIMAPPart.getBodyFilec C r )z^ Retrieve the total size, in octets, of this message. @rtype: L{int} Nr r r r r �getSize� r zIMessageIMAPPart.getSizec C r )zV Indicate whether this message has subparts. @rtype: L{bool} Nr r r r r � isMultipart� r z IMessageIMAPPart.isMultipartc C r )a� Retrieve a MIME sub-message @type part: L{int} @param part: The number of the part to retrieve, indexed from 0. @raise IndexError: Raised if the specified part does not exist. @raise TypeError: Raised if this message is not multipart. @rtype: Any object implementing L{IMessageIMAPPart}. @return: The specified sub-part. Nr )�partr r r � getSubPart� r zIMessageIMAPPart.getSubPartN)r r r rF rG rH rI rK r r r r rC � s rC c @ r4 )� IMessageIMAPc C r )zN Retrieve the unique identifier associated with this message. Nr r r r r �getUID� r zIMessageIMAP.getUIDc C r )z� Retrieve the flags associated with this message. @rtype: C{iterable} @return: The flags, represented as strings. Nr r r r r �getFlags� r zIMessageIMAP.getFlagsc C r )z� Retrieve the date internally associated with this message. @rtype: L{bytes} @return: An RFC822-formatted date string. Nr r r r r �getInternalDate� r z IMessageIMAP.getInternalDateN)r r r rM rN rO r r r r rL � s rL c @ r- )�IMessageIMAPFilez� Optional message interface for representing messages as files. If provided by message objects, this interface will be used instead the more complex MIME-based interface. c C r )z� Return a file-like object opened for reading. Reading from the returned file will return all the bytes of which this message consists. Nr r r r r �open� r zIMessageIMAPFile.openN)r r r r rQ r r r r rP � � rP c @ � e Zd Zdd� ZdS )�ISearchableIMAPMailboxc C r )a{ Search for messages that meet the given query criteria. If this interface is not implemented by the mailbox, L{IMailboxIMAP.fetch} and various methods of L{IMessageIMAP} will be used instead. Implementations which wish to offer better performance than the default implementation should implement this interface. @type query: L{list} @param query: The search criteria @type uid: L{bool} @param uid: If true, the IDs specified in the query are UIDs; otherwise they are message sequence IDs. @rtype: L{list} or L{Deferred} @return: A list of message sequence numbers or message UIDs which match the search criteria or a L{Deferred} whose callback will be invoked with such a list. @raise IllegalQueryError: Raised when query is not valid. Nr )�query�uidr r r �search� r z ISearchableIMAPMailbox.searchN)r r r rW r r r r rT � � rT c @ r ) �IMailboxIMAPListenerz< Interface for objects interested in mailbox events c C r )z� Indicates that the write status of a mailbox has changed. @type writeable: L{bool} @param writeable: A true value if write is now allowed, false otherwise. Nr )� writeabler r r � modeChanged r z IMailboxIMAPListener.modeChangedc C r )z� Indicates that the flags of one or more messages have changed. @type newFlags: L{dict} @param newFlags: A mapping of message identifiers to tuples of flags now set on that message. Nr )�newFlagsr r r � flagsChanged r z!IMailboxIMAPListener.flagsChangedc C r )a� Indicates that the number of messages in a mailbox has changed. @type exists: L{int} or L{None} @param exists: The total number of messages now in this mailbox. If the total number of messages has not changed, this should be L{None}. @type recent: L{int} @param recent: The number of messages now flagged C{\Recent}. If the number of recent messages has not changed, this should be L{None}. Nr )r) �recentr r r � newMessages) r z IMailboxIMAPListener.newMessagesN)r r r r r[ r] r_ r r r r rY s rY c @ rS )�IMessageIMAPCopierc C r )aK Copy the given message object into this mailbox. The message object will be one which was previously returned by L{IMailboxIMAP.fetch}. Implementations which wish to offer better performance than the default implementation should implement this interface. If this interface is not implemented by the mailbox, L{IMailboxIMAP.addMessage} will be used instead. @rtype: L{Deferred} or L{int} @return: Either the UID of the message or a Deferred which fires with the UID when the copy finishes. Nr )� messageObjectr r r �copy8 r zIMessageIMAPCopier.copyN)r r r rb r r r r r` 7 rX r` c @ s e Zd ZdZdd� Zdd� ZdS )�IMailboxIMAPInfoz� Interface specifying only the methods required for C{listMailboxes}. Implementations can return objects implementing only these methods for return to C{listMailboxes} if it can allow them to operate more efficiently. c C r )a Return the flags defined in this mailbox Flags with the \ prefix are reserved for use as system flags. @rtype: L{list} of L{str} @return: A list of the flags that can be set on messages in this mailbox. Nr r r r r rN T r zIMailboxIMAPInfo.getFlagsc C r )zl Get the character which delimits namespaces for in this mailbox. @rtype: L{bytes} Nr r r r r �getHierarchicalDelimiter_ r z)IMailboxIMAPInfo.getHierarchicalDelimiterN)r r r r rN rd r r r r rc K s rc c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd S ) � IMailboxIMAPc C r )za Return the unique validity identifier for this mailbox. @rtype: L{int} Nr r r r r �getUIDValidityh r zIMailboxIMAP.getUIDValidityc C r )zk Return the likely UID for the next message added to this mailbox. @rtype: L{int} Nr r r r r � getUIDNexto r zIMailboxIMAP.getUIDNextc C r )z� Return the UID of a message in the mailbox @type message: L{int} @param message: The message sequence number @rtype: L{int} @return: The UID of the message. Nr )�messager r r rM v r zIMailboxIMAP.getUIDc C r )zX Return the number of messages in this mailbox. @rtype: L{int} Nr r r r r �getMessageCount� r z IMailboxIMAP.getMessageCountc C r )z_ Return the number of messages with the 'Recent' flag. @rtype: L{int} Nr r r r r �getRecentCount� r zIMailboxIMAP.getRecentCountc C r )z_ Return the number of messages with the 'Unseen' flag. @rtype: L{int} Nr r r r r �getUnseenCount� r zIMailboxIMAP.getUnseenCountc C r )z� Get the read/write status of the mailbox. @rtype: L{int} @return: A true value if write permission is allowed, a false value otherwise. Nr r r r r � isWriteable� r zIMailboxIMAP.isWriteablec C r )z� Called before this mailbox is deleted, permanently. If necessary, all resources held by this mailbox should be cleaned up here. This function _must_ set the \Noselect flag on this mailbox. Nr r r r r �destroy� r zIMailboxIMAP.destroyc C r )aa Return status information about this mailbox. Mailboxes which do not intend to do any special processing to generate the return value, C{statusRequestHelper} can be used to build the dictionary by calling the other interface methods which return the data for each name. @type names: Any iterable @param names: The status names to return information regarding. The possible values for each name are: MESSAGES, RECENT, UIDNEXT, UIDVALIDITY, UNSEEN. @rtype: L{dict} or L{Deferred} @return: A dictionary containing status information about the requested names is returned. If the process of looking this information up would be costly, a deferred whose callback will eventually be passed this dictionary is returned instead. Nr )rE r r r � requestStatus� r zIMailboxIMAP.requestStatusc C r )a Add a mailbox change listener @type listener: Any object which implements C{IMailboxIMAPListener} @param listener: An object to add to the set of those which will be notified when the contents of this mailbox change. Nr ��listenerr r r � addListener� r zIMailboxIMAP.addListenerc C r )aY Remove a mailbox change listener @type listener: Any object previously added to and not removed from this mailbox as a listener. @param listener: The object to remove from the set of listeners. @raise ValueError: Raised when the given object is not a listener for this mailbox. Nr ro r r r �removeListener� r zIMailboxIMAP.removeListenerc C r )a� Add the given message to this mailbox. @type message: A file-like object @param message: The RFC822 formatted message @type flags: Any iterable of L{bytes} @param flags: The flags to associate with this message @type date: L{bytes} @param date: If specified, the date to associate with this message. @rtype: L{Deferred} @return: A deferred whose callback is invoked with the message id if the message is added successfully and whose errback is invoked otherwise. @raise ReadOnlyMailbox: Raised if this Mailbox is not open for read-write. Nr )rh �flags�dater r r � addMessage� r zIMailboxIMAP.addMessagec C r )aW Remove all messages flagged \Deleted. @rtype: L{list} or L{Deferred} @return: The list of message sequence numbers which were deleted, or a L{Deferred} whose callback will be invoked with such a list. @raise ReadOnlyMailbox: Raised if this Mailbox is not open for read-write. Nr r r r r �expunge� r zIMailboxIMAP.expungec C r )a� Retrieve one or more messages. @type messages: C{MessageSet} @param messages: The identifiers of messages to retrieve information about @type uid: L{bool} @param uid: If true, the IDs specified in the query are UIDs; otherwise they are message sequence IDs. @rtype: Any iterable of two-tuples of message sequence numbers and implementors of C{IMessageIMAP}. Nr )�messagesrV r r r �fetch� r zIMailboxIMAP.fetchc C r )a� Set the flags of one or more messages. @type messages: A MessageSet object with the list of messages requested @param messages: The identifiers of the messages to set the flags of. @type flags: sequence of L{str} @param flags: The flags to set, unset, or add. @type mode: -1, 0, or 1 @param mode: If mode is -1, these flags should be removed from the specified messages. If mode is 1, these flags should be added to the specified messages. If mode is 0, all existing flags should be cleared and these flags should be added. @type uid: L{bool} @param uid: If true, the IDs specified in the query are UIDs; otherwise they are message sequence IDs. @rtype: L{dict} or L{Deferred} @return: A L{dict} mapping message sequence numbers to sequences of L{str} representing the flags set on the message after this operation has been performed, or a L{Deferred} whose callback will be invoked with such a L{dict}. @raise ReadOnlyMailbox: Raised if this mailbox is not open for read-write. Nr )rw rs �moderV r r r �store r zIMailboxIMAP.storeN)r r r rf rg rM ri rj rk rl rm rn rq rr ru rv rx rz r r r r re g s re c @ r- )�ICloseableMailboxIMAPz� A supplementary interface for mailboxes which require cleanup on close. Implementing this interface is optional. If it is implemented, the protocol code will call the close method defined whenever a mailbox is closed. c C r )z� Close this mailbox. @return: A L{Deferred} which fires when this mailbox has been closed, or None if the mailbox can be closed immediately. Nr r r r r �close* r zICloseableMailboxIMAP.closeN)r r r r r| r r r r r{ " rR r{ c @ s\ e Zd ZdZddd�Zdd� Zddd �Zd d � Zd d � Zdd� Z dd� Z dd� Z dd� Z dS )� IAccountIMAPz� Interface for Account classes Implementors of this interface should consider implementing C{INamespacePresenter}. Nc C r )a� Add a new mailbox to this account @type name: L{bytes} @param name: The name associated with this mailbox. It may not contain multiple hierarchical parts. @type mbox: An object implementing C{IMailboxIMAP} @param mbox: The mailbox to associate with this name. If L{None}, a suitable default is created and used. @rtype: L{Deferred} or L{bool} @return: A true value if the creation succeeds, or a deferred whose callback will be invoked when the creation succeeds. @raise MailboxException: Raised if this mailbox cannot be added for some reason. This may also be raised asynchronously, if a L{Deferred} is returned. Nr )�name�mboxr r r � addMailbox; r zIAccountIMAP.addMailboxc C r )a� Create a new mailbox from the given hierarchical name. @type pathspec: L{bytes} @param pathspec: The full hierarchical name of a new mailbox to create. If any of the inferior hierarchical names to this one do not exist, they are created as well. @rtype: L{Deferred} or L{bool} @return: A true value if the creation succeeds, or a deferred whose callback will be invoked when the creation succeeds. @raise MailboxException: Raised if this mailbox cannot be added. This may also be raised asynchronously, if a L{Deferred} is returned. Nr )�pathspecr r r �createP r zIAccountIMAP.createTc C r )aF Acquire a mailbox, given its name. @type name: L{bytes} @param name: The mailbox to acquire @type rw: L{bool} @param rw: If a true value, request a read-write version of this mailbox. If a false value, request a read-only version. @rtype: Any object implementing C{IMailboxIMAP} or L{Deferred} @return: The mailbox object, or a L{Deferred} whose callback will be invoked with the mailbox object. None may be returned if the specified mailbox may not be selected for any reason. Nr )r~ �rwr r r �selecta r zIAccountIMAP.selectc C r )a� Delete the mailbox with the specified name. @type name: L{bytes} @param name: The mailbox to delete. @rtype: L{Deferred} or L{bool} @return: A true value if the mailbox is successfully deleted, or a L{Deferred} whose callback will be invoked when the deletion completes. @raise MailboxException: Raised if this mailbox cannot be deleted. This may also be raised asynchronously, if a L{Deferred} is returned. Nr �r~ r r r �deleter r zIAccountIMAP.deletec C r )ag Rename a mailbox @type oldname: L{bytes} @param oldname: The current name of the mailbox to rename. @type newname: L{bytes} @param newname: The new name to associate with the mailbox. @rtype: L{Deferred} or L{bool} @return: A true value if the mailbox is successfully renamed, or a L{Deferred} whose callback will be invoked when the rename operation is completed. @raise MailboxException: Raised if this mailbox cannot be renamed. This may also be raised asynchronously, if a L{Deferred} is returned. Nr )�oldname�newnamer r r �rename� r zIAccountIMAP.renamec C r )a� Check the subscription status of a mailbox @type name: L{bytes} @param name: The name of the mailbox to check @rtype: L{Deferred} or L{bool} @return: A true value if the given mailbox is currently subscribed to, a false value otherwise. A L{Deferred} may also be returned whose callback will be invoked with one of these values. Nr r� r r r � isSubscribed� r zIAccountIMAP.isSubscribedc C r )a! Subscribe to a mailbox @type name: L{bytes} @param name: The name of the mailbox to subscribe to @rtype: L{Deferred} or L{bool} @return: A true value if the mailbox is subscribed to successfully, or a Deferred whose callback will be invoked with this value when the subscription is successful. @raise MailboxException: Raised if this mailbox cannot be subscribed to. This may also be raised asynchronously, if a L{Deferred} is returned. Nr r� r r r � subscribe� r zIAccountIMAP.subscribec C r )a3 Unsubscribe from a mailbox @type name: L{bytes} @param name: The name of the mailbox to unsubscribe from @rtype: L{Deferred} or L{bool} @return: A true value if the mailbox is unsubscribed from successfully, or a Deferred whose callback will be invoked with this value when the unsubscription is successful. @raise MailboxException: Raised if this mailbox cannot be unsubscribed from. This may also be raised asynchronously, if a L{Deferred} is returned. Nr r� r r r � unsubscribe� r zIAccountIMAP.unsubscribec C r )a� List all the mailboxes that meet a certain criteria @type ref: L{bytes} @param ref: The context in which to apply the wildcard @type wildcard: L{bytes} @param wildcard: An expression against which to match mailbox names. '*' matches any number of characters in a mailbox name, and '%' matches similarly, but will not match across hierarchical boundaries. @rtype: L{list} of L{tuple} @return: A list of C{(mailboxName, mailboxObject)} which meet the given criteria. C{mailboxObject} should implement either C{IMailboxIMAPInfo} or C{IMailboxIMAP}. A Deferred may also be returned. Nr )�ref�wildcardr r r � listMailboxes� r zIAccountIMAP.listMailboxesr% )T) r r r r r� r� r� r� r� r� r� r� r� r r r r r} 3 s r} c @ r4 )�INamespacePresenterc C r )a� Report the available personal namespaces. Typically there should be only one personal namespace. A common name for it is C{""}, and its hierarchical delimiter is usually C{"/"}. @rtype: iterable of two-tuples of strings @return: The personal namespaces and their hierarchical delimiters. If no namespaces of this type exist, None should be returned. Nr r r r r �getPersonalNamespaces� r z)INamespacePresenter.getPersonalNamespacesc C r )a� Report the available shared namespaces. Shared namespaces do not belong to any individual user but are usually to one or more of them. Examples of shared namespaces might be C{"#news"} for a usenet gateway. @rtype: iterable of two-tuples of strings @return: The shared namespaces and their hierarchical delimiters. If no namespaces of this type exist, None should be returned. Nr r r r r �getSharedNamespaces� r z'INamespacePresenter.getSharedNamespacesc C r )a Report the available user namespaces. These are namespaces that contain folders belonging to other users access to which this account has been granted. @rtype: iterable of two-tuples of strings @return: The user namespaces and their hierarchical delimiters. If no namespaces of this type exist, None should be returned. Nr r r r r �getUserNamespaces� r z%INamespacePresenter.getUserNamespacesN)r r r r� r� r� r r r r r� � s r� )r} r{ re rc rY rL r` rP rC rT r� r5 r< r> r& r. r0 r r r N)r �zope.interfacer r r r r r& r. r0 r5 r< r> rC rL rP rT rY r` rc re r{ r} r� �__all__r r r r �<module> s4 %=\(#9 2 % < ' 'PK Mb�ZP �� � mail/_cred.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Credential managers for L{twisted.mail}. """ import hashlib import hmac from zope.interface import implementer from twisted.cred import credentials from twisted.mail._except import IllegalClientResponse from twisted.mail.interfaces import IChallengeResponse, IClientAuthentication from twisted.python.compat import nativeString @implementer(IClientAuthentication) class CramMD5ClientAuthenticator: def __init__(self, user): self.user = user def getName(self): return b"CRAM-MD5" def challengeResponse(self, secret, chal): response = hmac.HMAC(secret, chal, digestmod=hashlib.md5).hexdigest() return self.user + b" " + response.encode("ascii") @implementer(IClientAuthentication) class LOGINAuthenticator: def __init__(self, user): self.user = user self.challengeResponse = self.challengeUsername def getName(self): return b"LOGIN" def challengeUsername(self, secret, chal): # Respond to something like "Username:" self.challengeResponse = self.challengeSecret return self.user def challengeSecret(self, secret, chal): # Respond to something like "Password:" return secret @implementer(IClientAuthentication) class PLAINAuthenticator: def __init__(self, user): self.user = user def getName(self): return b"PLAIN" def challengeResponse(self, secret, chal): return b"\0" + self.user + b"\0" + secret @implementer(IChallengeResponse) class LOGINCredentials(credentials.UsernamePassword): def __init__(self): self.challenges = [b"Password\0", b"User Name\0"] self.responses = [b"password", b"username"] credentials.UsernamePassword.__init__(self, None, None) def getChallenge(self): return self.challenges.pop() def setResponse(self, response): setattr(self, nativeString(self.responses.pop()), response) def moreChallenges(self): return bool(self.challenges) @implementer(IChallengeResponse) class PLAINCredentials(credentials.UsernamePassword): def __init__(self): credentials.UsernamePassword.__init__(self, None, None) def getChallenge(self): return b"" def setResponse(self, response): parts = response.split(b"\0") if len(parts) != 3: raise IllegalClientResponse("Malformed Response - wrong number of parts") useless, self.username, self.password = parts def moreChallenges(self): return False __all__ = [ "CramMD5ClientAuthenticator", "LOGINCredentials", "LOGINAuthenticator", "PLAINCredentials", "PLAINAuthenticator", ] PK Mb�Z)�� � 1 mail/scripts/__pycache__/__init__.cpython-310.pycnu �[��� o �b � @ s d Z dS )z mail scriptsN)�__doc__� r r �?/usr/lib/python3/dist-packages/twisted/mail/scripts/__init__.py�<module> s PK Mb�Z~'v� � 1 mail/scripts/__pycache__/mailmail.cpython-310.pycnu �[��� o �bn( � @ s d Z ddlZddlZddlZddlZddlmZ ddlm Z ddl m Z ddl m Z ddlmZmZ ddlmZ d Zej�d �Zd Zd Zeej�Zeed �ZG dd� d�Z dd� Z e d�Z dd� Z G dd� d�Z!dd� Z"dd� Z#da$dd � Z%d d � Z&d d � Z'd!d"� Z(d#d$� Z)dS )%z4 Implementation module for the I{mailmail} command. � N)� ConfigParser)�StringIO)�version)�reactor)�Logger�textFileLogObserver)�smtpz /etc/mailmailz~/.twisted/mailmailz 127.0.0.1z�Subject: Failed Message Delivery Message delivery failed. The following occurred: %s -- The Twisted sendmail application. )�observerc @ s e Zd ZdZdS )�Optionsat Store the values of the parsed command-line options to the I{mailmail} script. @type to: L{list} of L{str} @ivar to: The addresses to which to deliver this message. @type sender: L{str} @ivar sender: The address from which this message is being sent. @type body: C{file} @ivar body: The object from which the message is to be read. N)�__name__� __module__� __qualname__�__doc__� r r �?/usr/lib/python3/dist-packages/twisted/mail/scripts/mailmail.pyr ( s r c C s& zt �� W S ty t�� Y S w �N)�os�getlogin� BaseException�getpass�getuserr r r r r 8 s �r zUnsupported option.c C s� t � }dd� | D �|_t� |_d| v rtdt� t� �d| v r!t�d| v r't�d| v r<| | �d�d |_|j� |j� d | v sDd | v rFt�d | v rNd |_ nd |_ d| v rYd |_ nd |_ d| v sdd| v rhd |_ nd |_ d| v rqt�d| v r�d |_ |j|_ g |_nd |_ g |_g g g g g d�}t� } d}tj�� }|�� s�nM|�dd�}|d �� }|j r�|dv r�|j�tj�|d �d g� |dkr�d}n|dkr�tj�|d �d |_||v r�|| �|d � |r�|�|� q�|d s�|�d|j� d�� |d �s|j�std ��|�d � d � |j��� |d �s"|�d t � � � d�� |�|� |j �rE|j D ]}z |j� |� W �q. t �yD Y �q.w |�!dd� t|�"� tj�#� �|_$|S )!Nc S s g | ] }|� d �s|�qS )�-)� startswith)�.0�er r r � <listcomp>D s z parseOptions.<locals>.<listcomp>z --versionzmailmail version:z-bpz-bsz-F� z-iz-oiz-odbTFz-odfz-oepz-epz-omz-t)�from�to�cc�bcc�datez: r )r r r r r zFrom: z r zNo recipients specified.zTo: {} z, r! zDate: )%r r r �sender�printr � SystemExit�_unsupportedOption�index�remove� background� printErrors�recipientsFromHeaders�excludeAddresses�exludeAddressesr �sys�stdin�readline�strip�split�lower�extend�email�utils� parseaddr�append�write�format�joinr � rfc822dater �seek�getvalue�read�body) �argv�o�requiredHeaders�bufferr8 �line�hdrs�hdr�ar r r � parseOptionsB s� � � � � rH c @ s e Zd ZdZdd� ZdS )� Configurationa� @ivar allowUIDs: A list of UIDs which are allowed to send mail. @ivar allowGIDs: A list of GIDs which are allowed to send mail. @ivar denyUIDs: A list of UIDs which are not allowed to send mail. @ivar denyGIDs: A list of GIDs which are not allowed to send mail. @type defaultAccess: L{bool} @ivar defaultAccess: L{True} if access will be allowed when no other access control rule matches or L{False} if it will be denied in that case. @ivar useraccess: Either C{'allow'} to check C{allowUID} first or C{'deny'} to check C{denyUID} first. @ivar groupaccess: Either C{'allow'} to check C{allowGID} first or C{'deny'} to check C{denyGID} first. @ivar identities: A L{dict} mapping hostnames to credentials to use when sending mail to that host. @ivar smarthost: L{None} or a hostname through which all outgoing mail will be sent. @ivar domain: L{None} or the hostname with which to identify ourselves when connecting to an MTA. c C s@ g | _ g | _g | _g | _d| _d| _i | _d | _d | _d| _ d S )N�denyT) � allowUIDs�denyUIDs� allowGIDs�denyGIDs� useraccess� groupaccess� identities� smarthost�domain� defaultAccess)�selfr r r �__init__� s zConfiguration.__init__N)r r r r rV r r r r rI � s rI c C s� t � }t�| tj�s |S t� }|�| � |j}|j}|j}|j }d||fd||ffD ]y\}}} |� |�r�d|fd| ffD ]>\} } |� || �rz|� || �rz|� || �� d�D ]$} zt| �} W n tys tjd|d �� || d� Y qUw | �| � qUq<|� |d �} d d � d d � | � d�D �D �} | d dkr�t||d� q*t||d� q*|� d �r�|�d �D ] \}}|� dd�}t|�dkr�tjd|d� q�||j|< q�|� d�r�|� dd�r�|� dd�|_|� dd�r�|� dd�|_|S )NrO rP �allowrJ �,z6Illegal {prefix}ID in [{section}] section: {sectionID}r )�prefix�section� sectionID�orderc S � g | ]}|� � �qS r )r1 �r �sr r r r � z loadConfig.<locals>.<listcomp>c S r] r )r2 r^ r r r r r` �identity�:r � z.Illegal entry in [identity] section: {section})rZ � addressesrR �default_domain)rI r �access�R_OKr r> rK rL rM rN � has_section� has_option�getr1 �int� ValueError�_log�error�upperr7 �setattr�items�lenrQ rR rS )�path�c�p�au�du�ag�dgrZ rG �d�mode�Lr[ r\ �host�up�partsr r r � loadConfig� sZ �� � � r� c C s t �� d S r �r �stop)�resultr r r �success, s r� c C s t �� | ad S r )r r� �failed)�fr r r �failure3 s r� c C s. t �| |j|j|j�}|�tt� t� � d S r ) r �sendmailr" r r? � addCallbacksr� r� r �run)r} �options�identrz r r r r� 9 s r� c C sf |j g}d�tjd tj�d��}t� }| j|d� tt |� � �}t� d|||�}|� dd� � d S )Nz2"Internally Generated Message ({})"<postmaster@{}>r �ascii��file� localhostc S s t �� S r r� )�_r r r �<lambda>H s zsenderror.<locals>.<lambda>) r" r9 r- r@ r �DNSNAME�decoder �printTraceback� ERROR_FMTr= r� �addBoth)r� r� � recipientr" rn r? rz r r r � senderror? s � r� c C s� t �� }t �� }| jdkr || jv rdS || jv rdS n|| jv r#dS || jv r*dS | jdkrA|| jv r6dS || jv r=dS | j S || jv rHdS || jv rOdS | j S )NrJ TF) r �getuid�getgidrO rL rK rP rN rM rT )�conf�uid�gidr r r rJ K s. � � rJ c C s� t tjdd � �} tt�}tt�}t|�st|�r t�d� d S |j p'|j p't }|j � � }|� |j � |jr;|jt_n|jrB|jt_t|| |� tr_| jrXtjtjd� td��tt| � d S d S )Nr zPermission deniedr� )rH r- r@ r� � GLOBAL_CFG� LOCAL_CFGrJ rm rn rR � SMARTHOSTrQ �copy�updaterS r r� r� r� r) r� �stderrr$ r� )rA �gConf�lConfr} r� r r r r� h s( �r� )*r � email.utilsr4 r r r- � configparserr �ior �twisted.copyrightr �twisted.internetr �twisted.loggerr r � twisted.mailr r� rs � expanduserr� r� r� r� � _logObserverrm r r r$ r% rH rI r� r� r� r� r� r� rJ r� r r r r �<module> s< z+E PK Mb�Z��Z5n( n( mail/scripts/mailmail.pynu �[��� # -*- test-case-name: twisted.mail.test.test_mailmail -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Implementation module for the I{mailmail} command. """ import email.utils import getpass import os import sys from configparser import ConfigParser from io import StringIO from twisted.copyright import version from twisted.internet import reactor from twisted.logger import Logger, textFileLogObserver from twisted.mail import smtp GLOBAL_CFG = "/etc/mailmail" LOCAL_CFG = os.path.expanduser("~/.twisted/mailmail") SMARTHOST = "127.0.0.1" ERROR_FMT = """\ Subject: Failed Message Delivery Message delivery failed. The following occurred: %s -- The Twisted sendmail application. """ _logObserver = textFileLogObserver(sys.stderr) _log = Logger(observer=_logObserver) class Options: """ Store the values of the parsed command-line options to the I{mailmail} script. @type to: L{list} of L{str} @ivar to: The addresses to which to deliver this message. @type sender: L{str} @ivar sender: The address from which this message is being sent. @type body: C{file} @ivar body: The object from which the message is to be read. """ def getlogin(): try: return os.getlogin() except BaseException: return getpass.getuser() _unsupportedOption = SystemExit("Unsupported option.") def parseOptions(argv): o = Options() o.to = [e for e in argv if not e.startswith("-")] o.sender = getlogin() # Just be very stupid # Skip -bm -- it is the default # Add a non-standard option for querying the version of this tool. if "--version" in argv: print("mailmail version:", version) raise SystemExit() # -bp lists queue information. Screw that. if "-bp" in argv: raise _unsupportedOption # -bs makes sendmail use stdin/stdout as its transport. Screw that. if "-bs" in argv: raise _unsupportedOption # -F sets who the mail is from, but is overridable by the From header if "-F" in argv: o.sender = argv[argv.index("-F") + 1] o.to.remove(o.sender) # -i and -oi makes us ignore lone "." if ("-i" in argv) or ("-oi" in argv): raise _unsupportedOption # -odb is background delivery if "-odb" in argv: o.background = True else: o.background = False # -odf is foreground delivery if "-odf" in argv: o.background = False else: o.background = True # -oem and -em cause errors to be mailed back to the sender. # It is also the default. # -oep and -ep cause errors to be printed to stderr if ("-oep" in argv) or ("-ep" in argv): o.printErrors = True else: o.printErrors = False # -om causes a copy of the message to be sent to the sender if the sender # appears in an alias expansion. We do not support aliases. if "-om" in argv: raise _unsupportedOption # -t causes us to pick the recipients of the message from # the To, Cc, and Bcc headers, and to remove the Bcc header # if present. if "-t" in argv: o.recipientsFromHeaders = True o.excludeAddresses = o.to o.to = [] else: o.recipientsFromHeaders = False o.exludeAddresses = [] requiredHeaders = { "from": [], "to": [], "cc": [], "bcc": [], "date": [], } buffer = StringIO() while 1: write = 1 line = sys.stdin.readline() if not line.strip(): break hdrs = line.split(": ", 1) hdr = hdrs[0].lower() if o.recipientsFromHeaders and hdr in ("to", "cc", "bcc"): o.to.extend([email.utils.parseaddr(hdrs[1])[1]]) if hdr == "bcc": write = 0 elif hdr == "from": o.sender = email.utils.parseaddr(hdrs[1])[1] if hdr in requiredHeaders: requiredHeaders[hdr].append(hdrs[1]) if write: buffer.write(line) if not requiredHeaders["from"]: buffer.write(f"From: {o.sender}\r\n") if not requiredHeaders["to"]: if not o.to: raise SystemExit("No recipients specified.") buffer.write("To: {}\r\n".format(", ".join(o.to))) if not requiredHeaders["date"]: buffer.write(f"Date: {smtp.rfc822date()}\r\n") buffer.write(line) if o.recipientsFromHeaders: for a in o.excludeAddresses: try: o.to.remove(a) except BaseException: pass buffer.seek(0, 0) o.body = StringIO(buffer.getvalue() + sys.stdin.read()) return o class Configuration: """ @ivar allowUIDs: A list of UIDs which are allowed to send mail. @ivar allowGIDs: A list of GIDs which are allowed to send mail. @ivar denyUIDs: A list of UIDs which are not allowed to send mail. @ivar denyGIDs: A list of GIDs which are not allowed to send mail. @type defaultAccess: L{bool} @ivar defaultAccess: L{True} if access will be allowed when no other access control rule matches or L{False} if it will be denied in that case. @ivar useraccess: Either C{'allow'} to check C{allowUID} first or C{'deny'} to check C{denyUID} first. @ivar groupaccess: Either C{'allow'} to check C{allowGID} first or C{'deny'} to check C{denyGID} first. @ivar identities: A L{dict} mapping hostnames to credentials to use when sending mail to that host. @ivar smarthost: L{None} or a hostname through which all outgoing mail will be sent. @ivar domain: L{None} or the hostname with which to identify ourselves when connecting to an MTA. """ def __init__(self): self.allowUIDs = [] self.denyUIDs = [] self.allowGIDs = [] self.denyGIDs = [] self.useraccess = "deny" self.groupaccess = "deny" self.identities = {} self.smarthost = None self.domain = None self.defaultAccess = True def loadConfig(path): # [useraccess] # allow=uid1,uid2,... # deny=uid1,uid2,... # order=allow,deny # [groupaccess] # allow=gid1,gid2,... # deny=gid1,gid2,... # order=deny,allow # [identity] # host1=username:password # host2=username:password # [addresses] # smarthost=a.b.c.d # default_domain=x.y.z c = Configuration() if not os.access(path, os.R_OK): return c p = ConfigParser() p.read(path) au = c.allowUIDs du = c.denyUIDs ag = c.allowGIDs dg = c.denyGIDs for (section, a, d) in (("useraccess", au, du), ("groupaccess", ag, dg)): if p.has_section(section): for (mode, L) in (("allow", a), ("deny", d)): if p.has_option(section, mode) and p.get(section, mode): for sectionID in p.get(section, mode).split(","): try: sectionID = int(sectionID) except ValueError: _log.error( "Illegal {prefix}ID in " "[{section}] section: {sectionID}", prefix=section[0].upper(), section=section, sectionID=sectionID, ) else: L.append(sectionID) order = p.get(section, "order") order = [s.split() for s in [s.lower() for s in order.split(",")]] if order[0] == "allow": setattr(c, section, "allow") else: setattr(c, section, "deny") if p.has_section("identity"): for (host, up) in p.items("identity"): parts = up.split(":", 1) if len(parts) != 2: _log.error("Illegal entry in [identity] section: {section}", section=up) continue c.identities[host] = parts if p.has_section("addresses"): if p.has_option("addresses", "smarthost"): c.smarthost = p.get("addresses", "smarthost") if p.has_option("addresses", "default_domain"): c.domain = p.get("addresses", "default_domain") return c def success(result): reactor.stop() failed = None def failure(f): global failed reactor.stop() failed = f def sendmail(host, options, ident): d = smtp.sendmail(host, options.sender, options.to, options.body) d.addCallbacks(success, failure) reactor.run() def senderror(failure, options): recipient = [options.sender] sender = '"Internally Generated Message ({})"<postmaster@{}>'.format( sys.argv[0], smtp.DNSNAME.decode("ascii") ) error = StringIO() failure.printTraceback(file=error) body = StringIO(ERROR_FMT % error.getvalue()) d = smtp.sendmail("localhost", sender, recipient, body) d.addBoth(lambda _: reactor.stop()) def deny(conf): uid = os.getuid() gid = os.getgid() if conf.useraccess == "deny": if uid in conf.denyUIDs: return True if uid in conf.allowUIDs: return False else: if uid in conf.allowUIDs: return False if uid in conf.denyUIDs: return True if conf.groupaccess == "deny": if gid in conf.denyGIDs: return True if gid in conf.allowGIDs: return False else: if gid in conf.allowGIDs: return False if gid in conf.denyGIDs: return True return not conf.defaultAccess def run(): o = parseOptions(sys.argv[1:]) gConf = loadConfig(GLOBAL_CFG) lConf = loadConfig(LOCAL_CFG) if deny(gConf) or deny(lConf): _log.error("Permission denied") return host = lConf.smarthost or gConf.smarthost or SMARTHOST ident = gConf.identities.copy() ident.update(lConf.identities) if lConf.domain: smtp.DNSNAME = lConf.domain elif gConf.domain: smtp.DNSNAME = gConf.domain sendmail(host, o, ident) if failed: if o.printErrors: failed.printTraceback(file=sys.stderr) raise SystemExit(1) else: senderror(failed, o) PK Mb�Z H�p mail/scripts/__init__.pynu �[��� "mail scripts" PK Mb�Za Г � mail/relay.pynu �[��� # -*- test-case-name: twisted.mail.test.test_mail -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Support for relaying mail. """ import os import pickle from twisted.internet.address import UNIXAddress from twisted.mail import smtp from twisted.python import log class DomainQueuer: """ An SMTP domain which add messages to a queue intended for relaying. """ def __init__(self, service, authenticated=False): self.service = service self.authed = authenticated def exists(self, user): """ Check whether mail can be relayed to a user. @type user: L{User} @param user: A user. @rtype: no-argument callable which returns L{IMessage <smtp.IMessage>} provider @return: A function which takes no arguments and returns a message receiver for the user. @raise SMTPBadRcpt: When mail cannot be relayed to the user. """ if self.willRelay(user.dest, user.protocol): # The most cursor form of verification of the addresses orig = filter(None, str(user.orig).split("@", 1)) dest = filter(None, str(user.dest).split("@", 1)) if len(orig) == 2 and len(dest) == 2: return lambda: self.startMessage(user) raise smtp.SMTPBadRcpt(user) def willRelay(self, address, protocol): """ Check whether we agree to relay. The default is to relay for all connections over UNIX sockets and all connections from localhost. """ peer = protocol.transport.getPeer() return self.authed or isinstance(peer, UNIXAddress) or peer.host == "127.0.0.1" def startMessage(self, user): """ Create an envelope and a message receiver for the relay queue. @type user: L{User} @param user: A user. @rtype: L{IMessage <smtp.IMessage>} @return: A message receiver. """ queue = self.service.queue envelopeFile, smtpMessage = queue.createNewMessage() with envelopeFile: log.msg(f"Queueing mail {str(user.orig)!r} -> {str(user.dest)!r}") pickle.dump([str(user.orig), str(user.dest)], envelopeFile) return smtpMessage class RelayerMixin: # XXX - This is -totally- bogus # It opens about a -hundred- -billion- files # and -leaves- them open! def loadMessages(self, messagePaths): self.messages = [] self.names = [] for message in messagePaths: with open(message + "-H", "rb") as fp: messageContents = pickle.load(fp) fp = open(message + "-D") messageContents.append(fp) self.messages.append(messageContents) self.names.append(message) def getMailFrom(self): if not self.messages: return None return self.messages[0][0] def getMailTo(self): if not self.messages: return None return [self.messages[0][1]] def getMailData(self): if not self.messages: return None return self.messages[0][2] def sentMail(self, code, resp, numOk, addresses, log): """Since we only use one recipient per envelope, this will be called with 0 or 1 addresses. We probably want to do something with the error message if we failed. """ if code in smtp.SUCCESS: # At least one, i.e. all, recipients successfully delivered os.remove(self.names[0] + "-D") os.remove(self.names[0] + "-H") del self.messages[0] del self.names[0] class SMTPRelayer(RelayerMixin, smtp.SMTPClient): """ A base class for SMTP relayers. """ def __init__(self, messagePaths, *args, **kw): """ @type messagePaths: L{list} of L{bytes} @param messagePaths: The base filename for each message to be relayed. @type args: 1-L{tuple} of (0) L{bytes} or 2-L{tuple} of (0) L{bytes}, (1) L{int} @param args: Positional arguments for L{SMTPClient.__init__} @type kw: L{dict} @param kw: Keyword arguments for L{SMTPClient.__init__} """ smtp.SMTPClient.__init__(self, *args, **kw) self.loadMessages(messagePaths) class ESMTPRelayer(RelayerMixin, smtp.ESMTPClient): """ A base class for ESMTP relayers. """ def __init__(self, messagePaths, *args, **kw): """ @type messagePaths: L{list} of L{bytes} @param messagePaths: The base filename for each message to be relayed. @type args: 3-L{tuple} of (0) L{bytes}, (1) L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>}, (2) L{bytes} or 4-L{tuple} of (0) L{bytes}, (1) L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>}, (2) L{bytes}, (3) L{int} @param args: Positional arguments for L{ESMTPClient.__init__} @type kw: L{dict} @param kw: Keyword arguments for L{ESMTPClient.__init__} """ smtp.ESMTPClient.__init__(self, *args, **kw) self.loadMessages(messagePaths) PK Mb�Z���$" " mail/_except.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Exceptions in L{twisted.mail}. """ from typing import Optional class IMAP4Exception(Exception): pass class IllegalClientResponse(IMAP4Exception): pass class IllegalOperation(IMAP4Exception): pass class IllegalMailboxEncoding(IMAP4Exception): pass class MailboxException(IMAP4Exception): pass class MailboxCollision(MailboxException): def __str__(self) -> str: return "Mailbox named %s already exists" % self.args class NoSuchMailbox(MailboxException): def __str__(self) -> str: return "No mailbox named %s exists" % self.args class ReadOnlyMailbox(MailboxException): def __str__(self) -> str: return "Mailbox open in read-only state" class UnhandledResponse(IMAP4Exception): pass class NegativeResponse(IMAP4Exception): pass class NoSupportedAuthentication(IMAP4Exception): def __init__(self, serverSupports, clientSupports): IMAP4Exception.__init__(self, "No supported authentication schemes available") self.serverSupports = serverSupports self.clientSupports = clientSupports def __str__(self) -> str: return IMAP4Exception.__str__( self ) + ": Server supports {!r}, client supports {!r}".format( self.serverSupports, self.clientSupports, ) class IllegalServerResponse(IMAP4Exception): pass class IllegalIdentifierError(IMAP4Exception): pass class IllegalQueryError(IMAP4Exception): pass class MismatchedNesting(IMAP4Exception): pass class MismatchedQuoting(IMAP4Exception): pass class SMTPError(Exception): pass class SMTPClientError(SMTPError): """ Base class for SMTP client errors. """ def __init__( self, code: int, resp: bytes, log: Optional[bytes] = None, addresses: Optional[object] = None, isFatal: bool = False, retry: bool = False, ): """ @param code: The SMTP response code associated with this error. @param resp: The string response associated with this error. @param log: A string log of the exchange leading up to and including the error. @param isFatal: A boolean indicating whether this connection can proceed or not. If True, the connection will be dropped. @param retry: A boolean indicating whether the delivery should be retried. If True and the factory indicates further retries are desirable, they will be attempted, otherwise the delivery will be failed. """ if isinstance(resp, str): # type: ignore[unreachable] resp = resp.encode("utf-8") # type: ignore[unreachable] if isinstance(log, str): # type: ignore[unreachable] log = log.encode("utf-8") # type: ignore[unreachable] self.code = code self.resp = resp self.log = log self.addresses = addresses self.isFatal = isFatal self.retry = retry def __str__(self) -> str: return self.__bytes__().decode("utf-8") def __bytes__(self) -> bytes: if self.code > 0: res = [f"{self.code:03d} ".encode() + self.resp] else: res = [self.resp] if self.log: res.append(self.log) res.append(b"") return b"\n".join(res) class ESMTPClientError(SMTPClientError): """ Base class for ESMTP client errors. """ class EHLORequiredError(ESMTPClientError): """ The server does not support EHLO. This is considered a non-fatal error (the connection will not be dropped). """ class AUTHRequiredError(ESMTPClientError): """ Authentication was required but the server does not support it. This is considered a non-fatal error (the connection will not be dropped). """ class TLSRequiredError(ESMTPClientError): """ Transport security was required but the server does not support it. This is considered a non-fatal error (the connection will not be dropped). """ class AUTHDeclinedError(ESMTPClientError): """ The server rejected our credentials. Either the username, password, or challenge response given to the server was rejected. This is considered a non-fatal error (the connection will not be dropped). """ class AuthenticationError(ESMTPClientError): """ An error occurred while authenticating. Either the server rejected our request for authentication or the challenge received was malformed. This is considered a non-fatal error (the connection will not be dropped). """ class SMTPTLSError(ESMTPClientError): """ An error occurred while negiotiating for transport security. This is considered a non-fatal error (the connection will not be dropped). """ class SMTPConnectError(SMTPClientError): """ Failed to connect to the mail exchange host. This is considered a fatal error. A retry will be made. """ def __init__(self, code, resp, log=None, addresses=None, isFatal=True, retry=True): SMTPClientError.__init__(self, code, resp, log, addresses, isFatal, retry) class SMTPTimeoutError(SMTPClientError): """ Failed to receive a response from the server in the expected time period. This is considered a fatal error. A retry will be made. """ def __init__(self, code, resp, log=None, addresses=None, isFatal=True, retry=True): SMTPClientError.__init__(self, code, resp, log, addresses, isFatal, retry) class SMTPProtocolError(SMTPClientError): """ The server sent a mangled response. This is considered a fatal error. A retry will not be made. """ def __init__(self, code, resp, log=None, addresses=None, isFatal=True, retry=False): SMTPClientError.__init__(self, code, resp, log, addresses, isFatal, retry) class SMTPDeliveryError(SMTPClientError): """ Indicates that a delivery attempt has had an error. """ class SMTPServerError(SMTPError): def __init__(self, code, resp): self.code = code self.resp = resp def __str__(self) -> str: return "%.3d %s" % (self.code, self.resp) class SMTPAddressError(SMTPServerError): def __init__(self, addr, code, resp): from twisted.mail.smtp import Address SMTPServerError.__init__(self, code, resp) self.addr = Address(addr) def __str__(self) -> str: return "%.3d <%s>... %s" % (self.code, self.addr, self.resp) class SMTPBadRcpt(SMTPAddressError): def __init__(self, addr, code=550, resp="Cannot receive for specified address"): SMTPAddressError.__init__(self, addr, code, resp) class SMTPBadSender(SMTPAddressError): def __init__(self, addr, code=550, resp="Sender not acceptable"): SMTPAddressError.__init__(self, addr, code, resp) class AddressError(SMTPError): """ Parse error in address """ class POP3Error(Exception): """ The base class for POP3 errors. """ pass class _POP3MessageDeleted(Exception): """ An internal control-flow error which indicates that a deleted message was requested. """ class POP3ClientError(Exception): """ The base class for all exceptions raised by POP3Client. """ class InsecureAuthenticationDisallowed(POP3ClientError): """ An error indicating secure authentication was required but no mechanism could be found. """ class TLSError(POP3ClientError): """ An error indicating secure authentication was required but either the transport does not support TLS or no TLS context factory was supplied. """ class TLSNotSupportedError(POP3ClientError): """ An error indicating secure authentication was required but the server does not support TLS. """ class ServerErrorResponse(POP3ClientError): """ An error indicating that the server returned an error response to a request. @ivar consumer: See L{__init__} """ def __init__(self, reason, consumer=None): """ @type reason: L{bytes} @param reason: The server response minus the status indicator. @type consumer: callable that takes L{object} @param consumer: The function meant to handle the values for a multi-line response. """ POP3ClientError.__init__(self, reason) self.consumer = consumer class LineTooLong(POP3ClientError): """ An error indicating that the server sent a line which exceeded the maximum line length (L{LineOnlyReceiver.MAX_LENGTH}). """ PK Mb�Z��jѵ� �� mail/test/test_smtp.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for twisted.mail.smtp module. """ import base64 import inspect import re from io import BytesIO from typing import Any, List, Optional, Tuple, Type from zope.interface import directlyProvides, implementer import twisted.cred.checkers import twisted.cred.credentials import twisted.cred.error import twisted.cred.portal from twisted import cred from twisted.cred.checkers import AllowAnonymousAccess, ICredentialsChecker from twisted.cred.credentials import IAnonymous from twisted.cred.error import UnauthorizedLogin from twisted.cred.portal import IRealm, Portal from twisted.internet import address, defer, error, interfaces, protocol, reactor, task from twisted.mail import smtp from twisted.mail._cred import LOGINCredentials from twisted.protocols import basic, loopback from twisted.python.util import LineLog from twisted.test.proto_helpers import MemoryReactor, StringTransport from twisted.trial.unittest import TestCase sslSkip: Optional[str] try: from twisted.test.ssl_helpers import ClientTLSContext, ServerTLSContext except ImportError: sslSkip = "OpenSSL not present" else: sslSkip = None if not interfaces.IReactorSSL.providedBy(reactor): sslSkip = "Reactor doesn't support SSL" def spameater(*spam, **eggs): return None @implementer(smtp.IMessage) class BrokenMessage: """ L{BrokenMessage} is an L{IMessage} which raises an unexpected exception from its C{eomReceived} method. This is useful for creating a server which can be used to test client retry behavior. """ def __init__(self, user): pass def lineReceived(self, line): pass def eomReceived(self): raise RuntimeError("Some problem, delivery is failing.") def connectionLost(self): pass class DummyMessage: """ L{BrokenMessage} is an L{IMessage} which saves the message delivered to it to its domain object. @ivar domain: A L{DummyDomain} which will be used to store the message once it is received. """ def __init__(self, domain, user): self.domain = domain self.user = user self.buffer = [] def lineReceived(self, line): # Throw away the generated Received: header if not re.match(br"Received: From yyy.com \(\[.*\]\) by localhost;", line): self.buffer.append(line) def eomReceived(self): message = b"\n".join(self.buffer) + b"\n" self.domain.messages[self.user.dest.local].append(message) deferred = defer.Deferred() deferred.callback(b"saved") return deferred class DummyDomain: """ L{DummyDomain} is an L{IDomain} which keeps track of messages delivered to it in memory. """ def __init__(self, names): self.messages = {} for name in names: self.messages[name] = [] def exists(self, user): if user.dest.local in self.messages: return defer.succeed(lambda: DummyMessage(self, user)) return defer.fail(smtp.SMTPBadRcpt(user)) mail = b"""\ Subject: hello Goodbye """ class MyClient: def __init__(self, messageInfo=None): if messageInfo is None: messageInfo = ("moshez@foo.bar", ["moshez@foo.bar"], BytesIO(mail)) self._sender = messageInfo[0] self._recipient = messageInfo[1] self._data = messageInfo[2] def getMailFrom(self): return self._sender def getMailTo(self): return self._recipient def getMailData(self): return self._data def sendError(self, exc): self._error = exc def sentMail(self, code, resp, numOk, addresses, log): # Prevent another mail from being sent. self._sender = None self._recipient = None self._data = None class MySMTPClient(MyClient, smtp.SMTPClient): def __init__(self, messageInfo=None): smtp.SMTPClient.__init__(self, b"foo.baz") MyClient.__init__(self, messageInfo) class MyESMTPClient(MyClient, smtp.ESMTPClient): def __init__(self, secret=b"", contextFactory=None): smtp.ESMTPClient.__init__(self, secret, contextFactory, b"foo.baz") MyClient.__init__(self) class LoopbackMixin: def loopback(self, server, client): return loopback.loopbackTCP(server, client) class FakeSMTPServer(basic.LineReceiver): clientData = [ b"220 hello", b"250 nice to meet you", b"250 great", b"250 great", b"354 go on, lad", ] def connectionMade(self): self.buffer = [] self.clientData = self.clientData[:] self.clientData.reverse() self.sendLine(self.clientData.pop()) def lineReceived(self, line): self.buffer.append(line) if line == b"QUIT": self.transport.write(b"221 see ya around\r\n") self.transport.loseConnection() elif line == b".": self.transport.write(b"250 gotcha\r\n") elif line == b"RSET": self.transport.loseConnection() if self.clientData: self.sendLine(self.clientData.pop()) class SMTPClientTests(TestCase, LoopbackMixin): """ Tests for L{smtp.SMTPClient}. """ def test_timeoutConnection(self): """ L{smtp.SMTPClient.timeoutConnection} calls the C{sendError} hook with a fatal L{SMTPTimeoutError} with the current line log. """ errors = [] client = MySMTPClient() client.sendError = errors.append client.makeConnection(StringTransport()) client.lineReceived(b"220 hello") client.timeoutConnection() self.assertIsInstance(errors[0], smtp.SMTPTimeoutError) self.assertTrue(errors[0].isFatal) self.assertEqual( bytes(errors[0]), b"Timeout waiting for SMTP server response\n" b"<<< 220 hello\n" b">>> HELO foo.baz\n", ) expected_output = [ b"HELO foo.baz", b"MAIL FROM:<moshez@foo.bar>", b"RCPT TO:<moshez@foo.bar>", b"DATA", b"Subject: hello", b"", b"Goodbye", b".", b"RSET", ] def test_messages(self): """ L{smtp.SMTPClient} sends I{HELO}, I{MAIL FROM}, I{RCPT TO}, and I{DATA} commands based on the return values of its C{getMailFrom}, C{getMailTo}, and C{getMailData} methods. """ client = MySMTPClient() server = FakeSMTPServer() d = self.loopback(server, client) d.addCallback(lambda x: self.assertEqual(server.buffer, self.expected_output)) return d def test_transferError(self): """ If there is an error while producing the message body to the connection, the C{sendError} callback is invoked. """ client = MySMTPClient( ("alice@example.com", ["bob@example.com"], BytesIO(b"foo")) ) transport = StringTransport() client.makeConnection(transport) client.dataReceived( b"220 Ok\r\n" # Greeting b"250 Ok\r\n" # EHLO response b"250 Ok\r\n" # MAIL FROM response b"250 Ok\r\n" # RCPT TO response b"354 Ok\r\n" # DATA response ) # Sanity check - a pull producer should be registered now. self.assertNotIdentical(transport.producer, None) self.assertFalse(transport.streaming) # Now stop the producer prematurely, meaning the message was not sent. transport.producer.stopProducing() # The sendError hook should have been invoked as a result. self.assertIsInstance(client._error, Exception) def test_sendFatalError(self): """ If L{smtp.SMTPClient.sendError} is called with an L{SMTPClientError} which is fatal, it disconnects its transport without writing anything more to it. """ client = smtp.SMTPClient(None) transport = StringTransport() client.makeConnection(transport) client.sendError(smtp.SMTPClientError(123, "foo", isFatal=True)) self.assertEqual(transport.value(), b"") self.assertTrue(transport.disconnecting) def test_sendNonFatalError(self): """ If L{smtp.SMTPClient.sendError} is called with an L{SMTPClientError} which is not fatal, it sends C{"QUIT"} and waits for the server to close the connection. """ client = smtp.SMTPClient(None) transport = StringTransport() client.makeConnection(transport) client.sendError(smtp.SMTPClientError(123, "foo", isFatal=False)) self.assertEqual(transport.value(), b"QUIT\r\n") self.assertFalse(transport.disconnecting) def test_sendOtherError(self): """ If L{smtp.SMTPClient.sendError} is called with an exception which is not an L{SMTPClientError}, it disconnects its transport without writing anything more to it. """ client = smtp.SMTPClient(None) transport = StringTransport() client.makeConnection(transport) client.sendError(Exception("foo")) self.assertEqual(transport.value(), b"") self.assertTrue(transport.disconnecting) class DummySMTPMessage: def __init__(self, protocol, users): self.protocol = protocol self.users = users self.buffer = [] def lineReceived(self, line): self.buffer.append(line) def eomReceived(self): message = b"\n".join(self.buffer) + b"\n" helo, origin = self.users[0].helo[0], bytes(self.users[0].orig) recipients = [] for user in self.users: recipients.append(bytes(user)) self.protocol.message[tuple(recipients)] = (helo, origin, recipients, message) return defer.succeed(b"saved") class DummyProto: def connectionMade(self): self.dummyMixinBase.connectionMade(self) self.message = {} def receivedHeader(*spam): return None def validateTo(self, user): self.delivery = SimpleDelivery(None) return lambda: DummySMTPMessage(self, [user]) def validateFrom(self, helo, origin): return origin class DummySMTP(DummyProto, smtp.SMTP): dummyMixinBase = smtp.SMTP class DummyESMTP(DummyProto, smtp.ESMTP): dummyMixinBase = smtp.ESMTP class AnotherTestCase: serverClass: Optional[Type[protocol.Protocol]] = None clientClass: Optional[Type[smtp.SMTPClient]] = None messages = [ ( b"foo.com", b"moshez@foo.com", [b"moshez@bar.com"], b"moshez@foo.com", [b"moshez@bar.com"], b"""\ From: Moshe To: Moshe Hi, how are you? """, ), ( b"foo.com", b"tttt@rrr.com", [b"uuu@ooo", b"yyy@eee"], b"tttt@rrr.com", [b"uuu@ooo", b"yyy@eee"], b"""\ Subject: pass ..rrrr.. """, ), ( b"foo.com", b"@this,@is,@ignored:foo@bar.com", [b"@ignore,@this,@too:bar@foo.com"], b"foo@bar.com", [b"bar@foo.com"], b"""\ Subject: apa To: foo 123 . 456 """, ), ] data: List[Tuple[bytes, bytes, Any, Any]] = [ (b"", b"220.*\r\n$", None, None), (b"HELO foo.com\r\n", b"250.*\r\n$", None, None), (b"RSET\r\n", b"250.*\r\n$", None, None), ] for helo_, from_, to_, realfrom, realto, msg in messages: data.append((b"MAIL FROM:<" + from_ + b">\r\n", b"250.*\r\n", None, None)) for rcpt in to_: data.append((b"RCPT TO:<" + rcpt + b">\r\n", b"250.*\r\n", None, None)) data.append( ( b"DATA\r\n", b"354.*\r\n", msg, (b"250.*\r\n", (helo_, realfrom, realto, msg)), ) ) def test_buffer(self): """ Exercise a lot of the SMTP client code. This is a "shotgun" style unit test. It does a lot of things and hopes that something will go really wrong if it is going to go wrong. This test should be replaced with a suite of nicer tests. """ transport = StringTransport() a = self.serverClass() class fooFactory: domain = b"foo.com" a.factory = fooFactory() a.makeConnection(transport) for (send, expect, msg, msgexpect) in self.data: if send: a.dataReceived(send) data = transport.value() transport.clear() if not re.match(expect, data): raise AssertionError(send, expect, data) if data[:3] == b"354": for line in msg.splitlines(): if line and line[0:1] == b".": line = b"." + line a.dataReceived(line + b"\r\n") a.dataReceived(b".\r\n") # Special case for DATA. Now we want a 250, and then # we compare the messages data = transport.value() transport.clear() resp, msgdata = msgexpect if not re.match(resp, data): raise AssertionError(resp, data) for recip in msgdata[2]: expected = list(msgdata[:]) expected[2] = [recip] self.assertEqual(a.message[(recip,)], tuple(expected)) a.setTimeout(None) class AnotherESMTPTests(AnotherTestCase, TestCase): serverClass = DummyESMTP clientClass = MyESMTPClient class AnotherSMTPTests(AnotherTestCase, TestCase): serverClass = DummySMTP clientClass = MySMTPClient @implementer(cred.checkers.ICredentialsChecker) class DummyChecker: users = {b"testuser": b"testpassword"} credentialInterfaces = ( cred.credentials.IUsernamePassword, cred.credentials.IUsernameHashedPassword, ) def requestAvatarId(self, credentials): return defer.maybeDeferred( credentials.checkPassword, self.users[credentials.username] ).addCallback(self._cbCheck, credentials.username) def _cbCheck(self, result, username): if result: return username raise cred.error.UnauthorizedLogin() @implementer(smtp.IMessageDelivery) class SimpleDelivery: """ L{SimpleDelivery} is a message delivery factory with no interesting behavior. """ def __init__(self, messageFactory): self._messageFactory = messageFactory def receivedHeader(self, helo, origin, recipients): return None def validateFrom(self, helo, origin): return origin def validateTo(self, user): return lambda: self._messageFactory(user) class DummyRealm: def requestAvatar(self, avatarId, mind, *interfaces): return smtp.IMessageDelivery, SimpleDelivery(None), lambda: None class AuthTests(TestCase, LoopbackMixin): def test_crammd5Auth(self): """ L{ESMTPClient} can authenticate using the I{CRAM-MD5} SASL mechanism. @see: U{http://tools.ietf.org/html/rfc2195} """ realm = DummyRealm() p = cred.portal.Portal(realm) p.registerChecker(DummyChecker()) server = DummyESMTP({b"CRAM-MD5": cred.credentials.CramMD5Credentials}) server.portal = p client = MyESMTPClient(b"testpassword") cAuth = smtp.CramMD5ClientAuthenticator(b"testuser") client.registerAuthenticator(cAuth) d = self.loopback(server, client) d.addCallback(lambda x: self.assertEqual(server.authenticated, 1)) return d def test_loginAuth(self): """ L{ESMTPClient} can authenticate using the I{LOGIN} SASL mechanism. @see: U{http://sepp.oetiker.ch/sasl-2.1.19-ds/draft-murchison-sasl-login-00.txt} """ realm = DummyRealm() p = cred.portal.Portal(realm) p.registerChecker(DummyChecker()) server = DummyESMTP({b"LOGIN": LOGINCredentials}) server.portal = p client = MyESMTPClient(b"testpassword") cAuth = smtp.LOGINAuthenticator(b"testuser") client.registerAuthenticator(cAuth) d = self.loopback(server, client) d.addCallback(lambda x: self.assertTrue(server.authenticated)) return d def test_loginAgainstWeirdServer(self): """ When communicating with a server which implements the I{LOGIN} SASL mechanism using C{"Username:"} as the challenge (rather than C{"User Name\\0"}), L{ESMTPClient} can still authenticate successfully using the I{LOGIN} mechanism. """ realm = DummyRealm() p = cred.portal.Portal(realm) p.registerChecker(DummyChecker()) server = DummyESMTP({b"LOGIN": smtp.LOGINCredentials}) server.portal = p client = MyESMTPClient(b"testpassword") cAuth = smtp.LOGINAuthenticator(b"testuser") client.registerAuthenticator(cAuth) d = self.loopback(server, client) d.addCallback(lambda x: self.assertTrue(server.authenticated)) return d class SMTPHelperTests(TestCase): def testMessageID(self): d = {} for i in range(1000): m = smtp.messageid("testcase") self.assertFalse(m in d) d[m] = None def testQuoteAddr(self): cases = [ [b"user@host.name", b"<user@host.name>"], [b'"User Name" <user@host.name>', b"<user@host.name>"], [smtp.Address(b"someguy@someplace"), b"<someguy@someplace>"], [b"", b"<>"], [smtp.Address(b""), b"<>"], ] for (c, e) in cases: self.assertEqual(smtp.quoteaddr(c), e) def testUser(self): u = smtp.User(b"user@host", b"helo.host.name", None, None) self.assertEqual(str(u), "user@host") def testXtextEncoding(self): cases = [ ("Hello world", b"Hello+20world"), ("Hello+world", b"Hello+2Bworld"), ("\0\1\2\3\4\5", b"+00+01+02+03+04+05"), ("e=mc2@example.com", b"e+3Dmc2@example.com"), ] for (case, expected) in cases: self.assertEqual(smtp.xtext_encode(case), (expected, len(case))) self.assertEqual(case.encode("xtext"), expected) self.assertEqual(smtp.xtext_decode(expected), (case, len(expected))) self.assertEqual(expected.decode("xtext"), case) def test_encodeWithErrors(self): """ Specifying an error policy to C{unicode.encode} with the I{xtext} codec should produce the same result as not specifying the error policy. """ text = "Hello world" self.assertEqual( smtp.xtext_encode(text, "strict"), (text.encode("xtext"), len(text)) ) self.assertEqual(text.encode("xtext", "strict"), text.encode("xtext")) def test_decodeWithErrors(self): """ Similar to L{test_encodeWithErrors}, but for C{bytes.decode}. """ bytes = b"Hello world" self.assertEqual( smtp.xtext_decode(bytes, "strict"), (bytes.decode("xtext"), len(bytes)) ) self.assertEqual(bytes.decode("xtext", "strict"), bytes.decode("xtext")) class NoticeTLSClient(MyESMTPClient): tls = False def esmtpState_starttls(self, code, resp): MyESMTPClient.esmtpState_starttls(self, code, resp) self.tls = True class TLSTests(TestCase, LoopbackMixin): skip = sslSkip def testTLS(self): clientCTX = ClientTLSContext() serverCTX = ServerTLSContext() client = NoticeTLSClient(contextFactory=clientCTX) server = DummyESMTP(contextFactory=serverCTX) def check(ignored): self.assertEqual(client.tls, True) self.assertEqual(server.startedTLS, True) return self.loopback(server, client).addCallback(check) class EmptyLineTests(TestCase): def test_emptyLineSyntaxError(self): """ If L{smtp.SMTP} receives an empty line, it responds with a 500 error response code and a message about a syntax error. """ proto = smtp.SMTP() transport = StringTransport() proto.makeConnection(transport) proto.lineReceived(b"") proto.setTimeout(None) out = transport.value().splitlines() self.assertEqual(len(out), 2) self.assertTrue(out[0].startswith(b"220")) self.assertEqual(out[1], b"500 Error: bad syntax") class TimeoutTests(TestCase, LoopbackMixin): """ Check that SMTP client factories correctly use the timeout. """ def _timeoutTest(self, onDone, clientFactory): """ Connect the clientFactory, and check the timeout on the request. """ clock = task.Clock() client = clientFactory.buildProtocol( address.IPv4Address("TCP", "example.net", 25) ) client.callLater = clock.callLater t = StringTransport() client.makeConnection(t) t.protocol = client def check(ign): self.assertEqual(clock.seconds(), 0.5) d = self.assertFailure(onDone, smtp.SMTPTimeoutError).addCallback(check) # The first call should not trigger the timeout clock.advance(0.1) # But this one should clock.advance(0.4) return d def test_SMTPClientRecipientBytes(self): """ Test timeout for L{smtp.SMTPSenderFactory}: the response L{Deferred} should be errback with a L{smtp.SMTPTimeoutError}. """ onDone = defer.Deferred() clientFactory = smtp.SMTPSenderFactory( "source@address", b"recipient@address", BytesIO(b"Message body"), onDone, retries=0, timeout=0.5, ) return self._timeoutTest(onDone, clientFactory) def test_SMTPClientRecipientUnicode(self): """ Use a L{unicode} recipient. """ onDone = defer.Deferred() clientFactory = smtp.SMTPSenderFactory( "source@address", "recipient@address", BytesIO(b"Message body"), onDone, retries=0, timeout=0.5, ) return self._timeoutTest(onDone, clientFactory) def test_SMTPClientRecipientList(self): """ Use a L{list} of recipients. """ onDone = defer.Deferred() clientFactory = smtp.SMTPSenderFactory( "source@address", ("recipient1@address", b"recipient2@address"), BytesIO(b"Message body"), onDone, retries=0, timeout=0.5, ) return self._timeoutTest(onDone, clientFactory) def test_ESMTPClient(self): """ Test timeout for L{smtp.ESMTPSenderFactory}: the response L{Deferred} should be errback with a L{smtp.SMTPTimeoutError}. """ onDone = defer.Deferred() clientFactory = smtp.ESMTPSenderFactory( "username", "password", "source@address", "recipient@address", BytesIO(b"Message body"), onDone, retries=0, timeout=0.5, ) return self._timeoutTest(onDone, clientFactory) def test_resetTimeoutWhileSending(self): """ The timeout is not allowed to expire after the server has accepted a DATA command and the client is actively sending data to it. """ class SlowFile: """ A file-like which returns one byte from each read call until the specified number of bytes have been returned. """ def __init__(self, size): self._size = size def read(self, max=None): if self._size: self._size -= 1 return b"x" return b"" failed = [] onDone = defer.Deferred() onDone.addErrback(failed.append) clientFactory = smtp.SMTPSenderFactory( "source@address", "recipient@address", SlowFile(1), onDone, retries=0, timeout=3, ) clientFactory.domain = b"example.org" clock = task.Clock() client = clientFactory.buildProtocol( address.IPv4Address("TCP", "example.net", 25) ) client.callLater = clock.callLater transport = StringTransport() client.makeConnection(transport) client.dataReceived( b"220 Ok\r\n" # Greet the client b"250 Ok\r\n" # Respond to HELO b"250 Ok\r\n" # Respond to MAIL FROM b"250 Ok\r\n" # Respond to RCPT TO b"354 Ok\r\n" # Respond to DATA ) # Now the client is producing data to the server. Any time # resumeProducing is called on the producer, the timeout should be # extended. First, a sanity check. This test is only written to # handle pull producers. self.assertNotIdentical(transport.producer, None) self.assertFalse(transport.streaming) # Now, allow 2 seconds (1 less than the timeout of 3 seconds) to # elapse. clock.advance(2) # The timeout has not expired, so the failure should not have happened. self.assertEqual(failed, []) # Let some bytes be produced, extending the timeout. Then advance the # clock some more and verify that the timeout still hasn't happened. transport.producer.resumeProducing() clock.advance(2) self.assertEqual(failed, []) # The file has been completely produced - the next resume producing # finishes the upload, successfully. transport.producer.resumeProducing() client.dataReceived(b"250 Ok\r\n") self.assertEqual(failed, []) # Verify that the client actually did send the things expected. self.assertEqual( transport.value(), b"HELO example.org\r\n" b"MAIL FROM:<source@address>\r\n" b"RCPT TO:<recipient@address>\r\n" b"DATA\r\n" b"x\r\n" b".\r\n" # This RSET is just an implementation detail. It's nice, but this # test doesn't really care about it. b"RSET\r\n", ) class MultipleDeliveryFactorySMTPServerFactory(protocol.ServerFactory): """ L{MultipleDeliveryFactorySMTPServerFactory} creates SMTP server protocol instances with message delivery factory objects supplied to it. Each factory is used for one connection and then discarded. Factories are used in the order they are supplied. """ def __init__(self, messageFactories): self._messageFactories = messageFactories def buildProtocol(self, addr): p = protocol.ServerFactory.buildProtocol(self, addr) p.delivery = SimpleDelivery(self._messageFactories.pop(0)) return p class SMTPSenderFactoryTests(TestCase): """ Tests for L{smtp.SMTPSenderFactory}. """ def test_removeCurrentProtocolWhenClientConnectionLost(self): """ L{smtp.SMTPSenderFactory} removes the current protocol when the client connection is lost. """ reactor = MemoryReactor() sentDeferred = defer.Deferred() clientFactory = smtp.SMTPSenderFactory( "source@address", "recipient@address", BytesIO(b"message"), sentDeferred ) connector = reactor.connectTCP("localhost", 25, clientFactory) clientFactory.buildProtocol(None) clientFactory.clientConnectionLost(connector, error.ConnectionDone("Bye.")) self.assertEqual(clientFactory.currentProtocol, None) def test_removeCurrentProtocolWhenClientConnectionFailed(self): """ L{smtp.SMTPSenderFactory} removes the current protocol when the client connection is failed. """ reactor = MemoryReactor() sentDeferred = defer.Deferred() clientFactory = smtp.SMTPSenderFactory( "source@address", "recipient@address", BytesIO(b"message"), sentDeferred ) connector = reactor.connectTCP("localhost", 25, clientFactory) clientFactory.buildProtocol(None) clientFactory.clientConnectionFailed(connector, error.ConnectionDone("Bye.")) self.assertEqual(clientFactory.currentProtocol, None) class SMTPSenderFactoryRetryTests(TestCase): """ Tests for the retry behavior of L{smtp.SMTPSenderFactory}. """ def test_retryAfterDisconnect(self): """ If the protocol created by L{SMTPSenderFactory} loses its connection before receiving confirmation of message delivery, it reconnects and tries to deliver the message again. """ recipient = b"alice" message = b"some message text" domain = DummyDomain([recipient]) class CleanSMTP(smtp.SMTP): """ An SMTP subclass which ensures that its transport will be disconnected before the test ends. """ def makeConnection(innerSelf, transport): self.addCleanup(transport.loseConnection) smtp.SMTP.makeConnection(innerSelf, transport) # Create a server which will fail the first message deliver attempt to # it with a 500 and a disconnect, but which will accept a message # delivered over the 2nd connection to it. serverFactory = MultipleDeliveryFactorySMTPServerFactory( [BrokenMessage, lambda user: DummyMessage(domain, user)] ) serverFactory.protocol = CleanSMTP serverPort = reactor.listenTCP(0, serverFactory, interface="127.0.0.1") serverHost = serverPort.getHost() self.addCleanup(serverPort.stopListening) # Set up a client to try to deliver a message to the above created # server. sentDeferred = defer.Deferred() clientFactory = smtp.SMTPSenderFactory( b"bob@example.org", recipient + b"@example.com", BytesIO(message), sentDeferred, ) clientFactory.domain = b"example.org" clientConnector = reactor.connectTCP( serverHost.host, serverHost.port, clientFactory ) self.addCleanup(clientConnector.disconnect) def cbSent(ignored): """ Verify that the message was successfully delivered and flush the error which caused the first attempt to fail. """ self.assertEqual(domain.messages, {recipient: [b"\n" + message + b"\n"]}) # Flush the RuntimeError that BrokenMessage caused to be logged. self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1) sentDeferred.addCallback(cbSent) return sentDeferred @implementer(IRealm) class SingletonRealm: """ Trivial realm implementation which is constructed with an interface and an avatar and returns that avatar when asked for that interface. """ def __init__(self, interface, avatar): self.interface = interface self.avatar = avatar def requestAvatar(self, avatarId, mind, *interfaces): for iface in interfaces: if iface is self.interface: return iface, self.avatar, lambda: None class NotImplementedDelivery: """ Non-implementation of L{smtp.IMessageDelivery} which only has methods which raise L{NotImplementedError}. Subclassed by various tests to provide the particular behavior being tested. """ def validateFrom(self, helo, origin): raise NotImplementedError("This oughtn't be called in the course of this test.") def validateTo(self, user): raise NotImplementedError("This oughtn't be called in the course of this test.") def receivedHeader(self, helo, origin, recipients): raise NotImplementedError("This oughtn't be called in the course of this test.") class SMTPServerTests(TestCase): """ Test various behaviors of L{twisted.mail.smtp.SMTP} and L{twisted.mail.smtp.ESMTP}. """ def testSMTPGreetingHost(self, serverClass=smtp.SMTP): """ Test that the specified hostname shows up in the SMTP server's greeting. """ s = serverClass() s.host = b"example.com" t = StringTransport() s.makeConnection(t) s.connectionLost(error.ConnectionDone()) self.assertIn(b"example.com", t.value()) def testSMTPGreetingNotExtended(self): """ Test that the string "ESMTP" does not appear in the SMTP server's greeting since that string strongly suggests the presence of support for various SMTP extensions which are not supported by L{smtp.SMTP}. """ s = smtp.SMTP() t = StringTransport() s.makeConnection(t) s.connectionLost(error.ConnectionDone()) self.assertNotIn(b"ESMTP", t.value()) def testESMTPGreetingHost(self): """ Similar to testSMTPGreetingHost, but for the L{smtp.ESMTP} class. """ self.testSMTPGreetingHost(smtp.ESMTP) def testESMTPGreetingExtended(self): """ Test that the string "ESMTP" does appear in the ESMTP server's greeting since L{smtp.ESMTP} does support the SMTP extensions which that advertises to the client. """ s = smtp.ESMTP() t = StringTransport() s.makeConnection(t) s.connectionLost(error.ConnectionDone()) self.assertIn(b"ESMTP", t.value()) def test_SMTPUnknownCommand(self): """ Sending an unimplemented command is responded to with a 500. """ s = smtp.SMTP() t = StringTransport() s.makeConnection(t) s.lineReceived(b"DOAGOODTHING") s.connectionLost(error.ConnectionDone()) self.assertIn(b"500 Command not implemented", t.value()) def test_acceptSenderAddress(self): """ Test that a C{MAIL FROM} command with an acceptable address is responded to with the correct success code. """ class AcceptanceDelivery(NotImplementedDelivery): """ Delivery object which accepts all senders as valid. """ def validateFrom(self, helo, origin): return origin realm = SingletonRealm(smtp.IMessageDelivery, AcceptanceDelivery()) portal = Portal(realm, [AllowAnonymousAccess()]) proto = smtp.SMTP() proto.portal = portal trans = StringTransport() proto.makeConnection(trans) # Deal with the necessary preliminaries proto.dataReceived(b"HELO example.com\r\n") trans.clear() # Try to specify our sender address proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n") # Clean up the protocol before doing anything that might raise an # exception. proto.connectionLost(error.ConnectionLost()) # Make sure that we received exactly the correct response self.assertEqual(trans.value(), b"250 Sender address accepted\r\n") def test_deliveryRejectedSenderAddress(self): """ Test that a C{MAIL FROM} command with an address rejected by a L{smtp.IMessageDelivery} instance is responded to with the correct error code. """ class RejectionDelivery(NotImplementedDelivery): """ Delivery object which rejects all senders as invalid. """ def validateFrom(self, helo, origin): raise smtp.SMTPBadSender(origin) realm = SingletonRealm(smtp.IMessageDelivery, RejectionDelivery()) portal = Portal(realm, [AllowAnonymousAccess()]) proto = smtp.SMTP() proto.portal = portal trans = StringTransport() proto.makeConnection(trans) # Deal with the necessary preliminaries proto.dataReceived(b"HELO example.com\r\n") trans.clear() # Try to specify our sender address proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n") # Clean up the protocol before doing anything that might raise an # exception. proto.connectionLost(error.ConnectionLost()) # Make sure that we received exactly the correct response self.assertEqual( trans.value(), b"550 Cannot receive from specified address " b"<alice@example.com>: Sender not acceptable\r\n", ) @implementer(ICredentialsChecker) def test_portalRejectedSenderAddress(self): """ Test that a C{MAIL FROM} command with an address rejected by an L{smtp.SMTP} instance's portal is responded to with the correct error code. """ class DisallowAnonymousAccess: """ Checker for L{IAnonymous} which rejects authentication attempts. """ credentialInterfaces = (IAnonymous,) def requestAvatarId(self, credentials): return defer.fail(UnauthorizedLogin()) realm = SingletonRealm(smtp.IMessageDelivery, NotImplementedDelivery()) portal = Portal(realm, [DisallowAnonymousAccess()]) proto = smtp.SMTP() proto.portal = portal trans = StringTransport() proto.makeConnection(trans) # Deal with the necessary preliminaries proto.dataReceived(b"HELO example.com\r\n") trans.clear() # Try to specify our sender address proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n") # Clean up the protocol before doing anything that might raise an # exception. proto.connectionLost(error.ConnectionLost()) # Make sure that we received exactly the correct response self.assertEqual( trans.value(), b"550 Cannot receive from specified address " b"<alice@example.com>: Sender not acceptable\r\n", ) def test_portalRejectedAnonymousSender(self): """ Test that a C{MAIL FROM} command issued without first authenticating when a portal has been configured to disallow anonymous logins is responded to with the correct error code. """ realm = SingletonRealm(smtp.IMessageDelivery, NotImplementedDelivery()) portal = Portal(realm, []) proto = smtp.SMTP() proto.portal = portal trans = StringTransport() proto.makeConnection(trans) # Deal with the necessary preliminaries proto.dataReceived(b"HELO example.com\r\n") trans.clear() # Try to specify our sender address proto.dataReceived(b"MAIL FROM:<alice@example.com>\r\n") # Clean up the protocol before doing anything that might raise an # exception. proto.connectionLost(error.ConnectionLost()) # Make sure that we received exactly the correct response self.assertEqual( trans.value(), b"550 Cannot receive from specified address " b"<alice@example.com>: Unauthenticated senders not allowed\r\n", ) class ESMTPAuthenticationTests(TestCase): def assertServerResponse(self, bytes, response): """ Assert that when the given bytes are delivered to the ESMTP server instance, it responds with the indicated lines. @type bytes: str @type response: list of str """ self.transport.clear() self.server.dataReceived(bytes) self.assertEqual(response, self.transport.value().splitlines()) def assertServerAuthenticated( self, loginArgs, username=b"username", password=b"password" ): """ Assert that a login attempt has been made, that the credentials and interfaces passed to it are correct, and that when the login request is satisfied, a successful response is sent by the ESMTP server instance. @param loginArgs: A C{list} previously passed to L{portalFactory}. @param username: The login user. @param password: The login password. """ d, credentials, mind, interfaces = loginArgs.pop() self.assertEqual(loginArgs, []) self.assertTrue( twisted.cred.credentials.IUsernamePassword.providedBy(credentials) ) self.assertEqual(credentials.username, username) self.assertTrue(credentials.checkPassword(password)) self.assertIn(smtp.IMessageDeliveryFactory, interfaces) self.assertIn(smtp.IMessageDelivery, interfaces) d.callback((smtp.IMessageDeliveryFactory, None, lambda: None)) self.assertEqual( [b"235 Authentication successful."], self.transport.value().splitlines() ) def setUp(self): """ Create an ESMTP instance attached to a StringTransport. """ self.server = smtp.ESMTP({b"LOGIN": LOGINCredentials}) self.server.host = b"localhost" self.transport = StringTransport( peerAddress=address.IPv4Address("TCP", "127.0.0.1", 12345) ) self.server.makeConnection(self.transport) def tearDown(self): """ Disconnect the ESMTP instance to clean up its timeout DelayedCall. """ self.server.connectionLost(error.ConnectionDone()) def portalFactory(self, loginList): class DummyPortal: def login(self, credentials, mind, *interfaces): d = defer.Deferred() loginList.append((d, credentials, mind, interfaces)) return d return DummyPortal() def test_authenticationCapabilityAdvertised(self): """ Test that AUTH is advertised to clients which issue an EHLO command. """ self.transport.clear() self.server.dataReceived(b"EHLO\r\n") responseLines = self.transport.value().splitlines() self.assertEqual( responseLines[0], b"250-localhost Hello 127.0.0.1, nice to meet you" ) self.assertEqual(responseLines[1], b"250 AUTH LOGIN") self.assertEqual(len(responseLines), 2) def test_plainAuthentication(self): """ Test that the LOGIN authentication mechanism can be used """ loginArgs = [] self.server.portal = self.portalFactory(loginArgs) self.server.dataReceived(b"EHLO\r\n") self.transport.clear() self.assertServerResponse( b"AUTH LOGIN\r\n", [b"334 " + base64.b64encode(b"User Name\0").strip()] ) self.assertServerResponse( base64.b64encode(b"username") + b"\r\n", [b"334 " + base64.b64encode(b"Password\0").strip()], ) self.assertServerResponse(base64.b64encode(b"password").strip() + b"\r\n", []) self.assertServerAuthenticated(loginArgs) def test_plainAuthenticationEmptyPassword(self): """ Test that giving an empty password for plain auth succeeds. """ loginArgs = [] self.server.portal = self.portalFactory(loginArgs) self.server.dataReceived(b"EHLO\r\n") self.transport.clear() self.assertServerResponse( b"AUTH LOGIN\r\n", [b"334 " + base64.b64encode(b"User Name\0").strip()] ) self.assertServerResponse( base64.b64encode(b"username") + b"\r\n", [b"334 " + base64.b64encode(b"Password\0").strip()], ) self.assertServerResponse(b"\r\n", []) self.assertServerAuthenticated(loginArgs, password=b"") def test_plainAuthenticationInitialResponse(self): """ The response to the first challenge may be included on the AUTH command line. Test that this is also supported. """ loginArgs = [] self.server.portal = self.portalFactory(loginArgs) self.server.dataReceived(b"EHLO\r\n") self.transport.clear() self.assertServerResponse( b"AUTH LOGIN " + base64.b64encode(b"username").strip() + b"\r\n", [b"334 " + base64.b64encode(b"Password\0").strip()], ) self.assertServerResponse(base64.b64encode(b"password").strip() + b"\r\n", []) self.assertServerAuthenticated(loginArgs) def test_abortAuthentication(self): """ Test that a challenge/response sequence can be aborted by the client. """ loginArgs = [] self.server.portal = self.portalFactory(loginArgs) self.server.dataReceived(b"EHLO\r\n") self.server.dataReceived(b"AUTH LOGIN\r\n") self.assertServerResponse(b"*\r\n", [b"501 Authentication aborted"]) def test_invalidBase64EncodedResponse(self): """ Test that a response which is not properly Base64 encoded results in the appropriate error code. """ loginArgs = [] self.server.portal = self.portalFactory(loginArgs) self.server.dataReceived(b"EHLO\r\n") self.server.dataReceived(b"AUTH LOGIN\r\n") self.assertServerResponse( b"x\r\n", [b"501 Syntax error in parameters or arguments"] ) self.assertEqual(loginArgs, []) def test_invalidBase64EncodedInitialResponse(self): """ Like L{test_invalidBase64EncodedResponse} but for the case of an initial response included with the C{AUTH} command. """ loginArgs = [] self.server.portal = self.portalFactory(loginArgs) self.server.dataReceived(b"EHLO\r\n") self.assertServerResponse( b"AUTH LOGIN x\r\n", [b"501 Syntax error in parameters or arguments"] ) self.assertEqual(loginArgs, []) def test_unexpectedLoginFailure(self): """ If the L{Deferred} returned by L{Portal.login} fires with an exception of any type other than L{UnauthorizedLogin}, the exception is logged and the client is informed that the authentication attempt has failed. """ loginArgs = [] self.server.portal = self.portalFactory(loginArgs) self.server.dataReceived(b"EHLO\r\n") self.transport.clear() self.assertServerResponse( b"AUTH LOGIN " + base64.b64encode(b"username").strip() + b"\r\n", [b"334 " + base64.b64encode(b"Password\0").strip()], ) self.assertServerResponse(base64.b64encode(b"password").strip() + b"\r\n", []) d, credentials, mind, interfaces = loginArgs.pop() d.errback(RuntimeError("Something wrong with the server")) self.assertEqual( b"451 Requested action aborted: local error in processing\r\n", self.transport.value(), ) self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1) class SMTPClientErrorTests(TestCase): """ Tests for L{smtp.SMTPClientError}. """ def test_str(self): """ The string representation of a L{SMTPClientError} instance includes the response code and response string. """ err = smtp.SMTPClientError(123, "some text") self.assertEqual(str(err), "123 some text") def test_strWithNegativeCode(self): """ If the response code supplied to L{SMTPClientError} is negative, it is excluded from the string representation. """ err = smtp.SMTPClientError(-1, b"foo bar") self.assertEqual(str(err), "foo bar") def test_strWithLog(self): """ If a line log is supplied to L{SMTPClientError}, its contents are included in the string representation of the exception instance. """ log = LineLog(10) log.append(b"testlog") log.append(b"secondline") err = smtp.SMTPClientError(100, "test error", log=log.str()) self.assertEqual(str(err), "100 test error\n" "testlog\n" "secondline\n") class SenderMixinSentMailTests(TestCase): """ Tests for L{smtp.SenderMixin.sentMail}, used in particular by L{smtp.SMTPSenderFactory} and L{smtp.ESMTPSenderFactory}. """ def test_onlyLogFailedAddresses(self): """ L{smtp.SenderMixin.sentMail} adds only the addresses with failing SMTP response codes to the log passed to the factory's errback. """ onDone = self.assertFailure(defer.Deferred(), smtp.SMTPDeliveryError) onDone.addCallback( lambda e: self.assertEqual( e.log, b"bob@example.com: 199 Error in sending.\n" ) ) clientFactory = smtp.SMTPSenderFactory( "source@address", "recipient@address", BytesIO(b"Message body"), onDone, retries=0, timeout=0.5, ) client = clientFactory.buildProtocol( address.IPv4Address("TCP", "example.net", 25) ) addresses = [ (b"alice@example.com", 200, b"No errors here!"), (b"bob@example.com", 199, b"Error in sending."), ] client.sentMail(199, b"Test response", 1, addresses, client.log) return onDone class ESMTPDowngradeTestCase(TestCase): """ Tests for the ESMTP -> SMTP downgrade functionality in L{smtp.ESMTPClient}. """ def setUp(self): self.clientProtocol = smtp.ESMTPClient(b"testpassword", None, b"testuser") def test_requireHELOFallbackOperates(self): """ If both authentication and transport security are not required, and it is asked for, it will fall back to allowing HELO. """ transport = StringTransport() self.clientProtocol.requireAuthentication = False self.clientProtocol.requireTransportSecurity = False self.clientProtocol.heloFallback = True self.clientProtocol.makeConnection(transport) self.clientProtocol.dataReceived(b"220 localhost\r\n") transport.clear() self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n") self.assertEqual(b"HELO testuser\r\n", transport.value()) def test_requireAuthFailsHELOFallback(self): """ If authentication is required, and HELO fallback is on, HELO fallback must not be honoured, as authentication requires EHLO to succeed. """ transport = StringTransport() self.clientProtocol.requireAuthentication = True self.clientProtocol.requireTransportSecurity = False self.clientProtocol.heloFallback = True self.clientProtocol.makeConnection(transport) self.clientProtocol.dataReceived(b"220 localhost\r\n") transport.clear() self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n") self.assertEqual(b"QUIT\r\n", transport.value()) def test_requireTLSFailsHELOFallback(self): """ If TLS is required and the connection is insecure, HELO fallback must not be honoured, as STARTTLS requires EHLO to succeed. """ transport = StringTransport() self.clientProtocol.requireAuthentication = False self.clientProtocol.requireTransportSecurity = True self.clientProtocol.heloFallback = True self.clientProtocol.makeConnection(transport) self.clientProtocol.dataReceived(b"220 localhost\r\n") transport.clear() self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n") self.assertEqual(b"QUIT\r\n", transport.value()) def test_requireTLSAndHELOFallbackSucceedsIfOverTLS(self): """ If TLS is provided at the transport level, we can honour the HELO fallback if we're set to require TLS. """ transport = StringTransport() directlyProvides(transport, interfaces.ISSLTransport) self.clientProtocol.requireAuthentication = False self.clientProtocol.requireTransportSecurity = True self.clientProtocol.heloFallback = True self.clientProtocol.makeConnection(transport) self.clientProtocol.dataReceived(b"220 localhost\r\n") transport.clear() self.clientProtocol.dataReceived(b"500 not an esmtp server\r\n") self.assertEqual(b"HELO testuser\r\n", transport.value()) class SSLTestCase(TestCase): """ Tests for the TLS negotiation done by L{smtp.ESMTPClient}. """ skip = sslSkip SERVER_GREETING = b"220 localhost NO UCE NO UBE NO RELAY PROBES ESMTP\r\n" EHLO_RESPONSE = b"250-localhost Hello 127.0.0.1, nice to meet you\r\n" def setUp(self): self.clientProtocol = smtp.ESMTPClient( b"testpassword", ClientTLSContext(), b"testuser" ) self.clientProtocol.requireTransportSecurity = True self.clientProtocol.getMailFrom = lambda: "test@example.org" def _requireTransportSecurityOverSSLTest(self, capabilities): """ Verify that when L{smtp.ESMTPClient} connects to a server over a transport providing L{ISSLTransport}, C{requireTransportSecurity} is C{True}, and it is presented with the given capabilities, it will try to send its mail and not first attempt to negotiate TLS using the I{STARTTLS} protocol action. @param capabilities: Bytes to include in the test server's capability response. These must be formatted exactly as required by the protocol, including a line which ends the capability response. @type param: L{bytes} @raise: C{self.failureException} if the behavior of C{self.clientProtocol} is not as described. """ transport = StringTransport() directlyProvides(transport, interfaces.ISSLTransport) self.clientProtocol.makeConnection(transport) # Get the handshake out of the way self.clientProtocol.dataReceived(self.SERVER_GREETING) transport.clear() # Tell the client about the server's capabilities self.clientProtocol.dataReceived(self.EHLO_RESPONSE + capabilities) # The client should now try to send a message - without first trying to # negotiate TLS, since the transport is already secure. self.assertEqual(b"MAIL FROM:<test@example.org>\r\n", transport.value()) def test_requireTransportSecurityOverSSL(self): """ When C{requireTransportSecurity} is C{True} and the client is connected over an SSL transport, mail may be delivered. """ self._requireTransportSecurityOverSSLTest(b"250 AUTH LOGIN\r\n") def test_requireTransportSecurityTLSOffered(self): """ When C{requireTransportSecurity} is C{True} and the client is connected over a non-SSL transport, if the server offers the I{STARTTLS} extension, it is used before mail is delivered. """ transport = StringTransport() self.clientProtocol.makeConnection(transport) # Get the handshake out of the way self.clientProtocol.dataReceived(self.SERVER_GREETING) transport.clear() # Tell the client about the server's capabilities - including STARTTLS self.clientProtocol.dataReceived( self.EHLO_RESPONSE + b"250-AUTH LOGIN\r\n" b"250 STARTTLS\r\n" ) # The client should try to start TLS before sending the message. self.assertEqual(b"STARTTLS\r\n", transport.value()) def test_requireTransportSecurityTLSOfferedOverSSL(self): """ When C{requireTransportSecurity} is C{True} and the client is connected over an SSL transport, if the server offers the I{STARTTLS} extension, it is not used before mail is delivered. """ self._requireTransportSecurityOverSSLTest( b"250-AUTH LOGIN\r\n" b"250 STARTTLS\r\n" ) def test_requireTransportSecurityTLSNotOffered(self): """ When C{requireTransportSecurity} is C{True} and the client is connected over a non-SSL transport, if the server does not offer the I{STARTTLS} extension, mail is not delivered. """ transport = StringTransport() self.clientProtocol.makeConnection(transport) # Get the handshake out of the way self.clientProtocol.dataReceived(self.SERVER_GREETING) transport.clear() # Tell the client about the server's capabilities - excluding STARTTLS self.clientProtocol.dataReceived(self.EHLO_RESPONSE + b"250 AUTH LOGIN\r\n") # The client give up self.assertEqual(b"QUIT\r\n", transport.value()) def test_esmtpClientTlsModeDeprecationGet(self): """ L{smtp.ESMTPClient.tlsMode} is deprecated. """ val = self.clientProtocol.tlsMode del val warningsShown = self.flushWarnings( offendingFunctions=[self.test_esmtpClientTlsModeDeprecationGet] ) self.assertEqual(len(warningsShown), 1) self.assertIdentical(warningsShown[0]["category"], DeprecationWarning) self.assertEqual( warningsShown[0]["message"], "tlsMode attribute of twisted.mail.smtp.ESMTPClient " "is deprecated since Twisted 13.0", ) def test_esmtpClientTlsModeDeprecationGetAttributeError(self): """ L{smtp.ESMTPClient.__getattr__} raises an attribute error for other attribute names which do not exist. """ self.assertRaises(AttributeError, lambda: self.clientProtocol.doesNotExist) def test_esmtpClientTlsModeDeprecationSet(self): """ L{smtp.ESMTPClient.tlsMode} is deprecated. """ self.clientProtocol.tlsMode = False warningsShown = self.flushWarnings( offendingFunctions=[self.test_esmtpClientTlsModeDeprecationSet] ) self.assertEqual(len(warningsShown), 1) self.assertIdentical(warningsShown[0]["category"], DeprecationWarning) self.assertEqual( warningsShown[0]["message"], "tlsMode attribute of twisted.mail.smtp.ESMTPClient " "is deprecated since Twisted 13.0", ) class AbortableStringTransport(StringTransport): """ A version of L{StringTransport} that supports C{abortConnection}. """ # This should be replaced by a common version in #6530. aborting = False def abortConnection(self): """ A testable version of the C{ITCPTransport.abortConnection} method. Since this is a special case of closing the connection, C{loseConnection} is also called. """ self.aborting = True self.loseConnection() class SendmailTests(TestCase): """ Tests for L{twisted.mail.smtp.sendmail}. """ def test_defaultReactorIsGlobalReactor(self): """ The default C{reactor} parameter of L{twisted.mail.smtp.sendmail} is L{twisted.internet.reactor}. """ args, varArgs, keywords, defaults = inspect.getargspec(smtp.sendmail) self.assertEqual(reactor, defaults[2]) def _honorsESMTPArguments(self, username, password): """ L{twisted.mail.smtp.sendmail} creates the ESMTP factory with the ESMTP arguments. """ reactor = MemoryReactor() smtp.sendmail( "localhost", "source@address", "recipient@address", b"message", reactor=reactor, username=username, password=password, requireTransportSecurity=True, requireAuthentication=True, ) factory = reactor.tcpClients[0][2] self.assertEqual(factory._requireTransportSecurity, True) self.assertEqual(factory._requireAuthentication, True) self.assertEqual(factory.username, b"foo") self.assertEqual(factory.password, b"bar") def test_honorsESMTPArgumentsUnicodeUserPW(self): """ L{twisted.mail.smtp.sendmail} should accept C{username} and C{password} which are L{unicode}. """ return self._honorsESMTPArguments(username="foo", password="bar") def test_honorsESMTPArgumentsBytesUserPW(self): """ L{twisted.mail.smtp.sendmail} should accept C{username} and C{password} which are L{bytes}. """ return self._honorsESMTPArguments(username=b"foo", password=b"bar") def test_messageFilePassthrough(self): """ L{twisted.mail.smtp.sendmail} will pass through the message untouched if it is a file-like object. """ reactor = MemoryReactor() messageFile = BytesIO(b"File!") smtp.sendmail( "localhost", "source@address", "recipient@address", messageFile, reactor=reactor, ) factory = reactor.tcpClients[0][2] self.assertIs(factory.file, messageFile) def test_messageStringMadeFile(self): """ L{twisted.mail.smtp.sendmail} will turn non-file-like objects (eg. strings) into file-like objects before sending. """ reactor = MemoryReactor() smtp.sendmail( "localhost", "source@address", "recipient@address", b"message", reactor=reactor, ) factory = reactor.tcpClients[0][2] messageFile = factory.file messageFile.seek(0) self.assertEqual(messageFile.read(), b"message") def test_senderDomainName(self): """ L{twisted.mail.smtp.sendmail} passes through the sender domain name, if provided. """ reactor = MemoryReactor() smtp.sendmail( "localhost", "source@address", "recipient@address", b"message", reactor=reactor, senderDomainName="foo", ) factory = reactor.tcpClients[0][2] self.assertEqual(factory.domain, b"foo") def test_cancelBeforeConnectionMade(self): """ When a user cancels L{twisted.mail.smtp.sendmail} before the connection is made, the connection is closed by L{twisted.internet.interfaces.IConnector.disconnect}. """ reactor = MemoryReactor() d = smtp.sendmail( "localhost", "source@address", "recipient@address", b"message", reactor=reactor, ) d.cancel() self.assertEqual(reactor.connectors[0]._disconnected, True) failure = self.failureResultOf(d) failure.trap(defer.CancelledError) def test_cancelAfterConnectionMade(self): """ When a user cancels L{twisted.mail.smtp.sendmail} after the connection is made, the connection is closed by L{twisted.internet.interfaces.ITransport.abortConnection}. """ reactor = MemoryReactor() transport = AbortableStringTransport() d = smtp.sendmail( "localhost", "source@address", "recipient@address", b"message", reactor=reactor, ) factory = reactor.tcpClients[0][2] p = factory.buildProtocol(None) p.makeConnection(transport) d.cancel() self.assertEqual(transport.aborting, True) self.assertEqual(transport.disconnecting, True) failure = self.failureResultOf(d) failure.trap(defer.CancelledError) PK Mb�Z���� � mail/test/test_scripts.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for the command-line mailer tool provided by Twisted Mail. """ from twisted.scripts.test.test_scripts import ScriptTestsMixin from twisted.trial.unittest import TestCase class ScriptTests(TestCase, ScriptTestsMixin): """ Tests for all one of mail's scripts. """ def test_mailmail(self): self.scriptTest("mail/mailmail") PK Mb�Z,6 � � mail/test/test_imap.pynu �[��� # -*- test-case-name: twisted.mail.test.test_imap -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test case for twisted.mail.imap4 """ import base64 import codecs import functools import locale import os import uuid from collections import OrderedDict from io import BytesIO from itertools import chain from typing import List, Optional, Tuple, Type from unittest import skipIf from zope.interface import implementer from zope.interface.verify import verifyClass, verifyObject from twisted.cred.checkers import InMemoryUsernamePasswordDatabaseDontUse from twisted.cred.credentials import ( CramMD5Credentials, IUsernameHashedPassword, IUsernamePassword, ) from twisted.cred.error import UnauthorizedLogin from twisted.cred.portal import IRealm, Portal from twisted.internet import defer, error, interfaces, reactor from twisted.internet.task import Clock from twisted.mail import imap4 from twisted.mail.imap4 import MessageSet from twisted.mail.interfaces import ( IChallengeResponse, IClientAuthentication, ICloseableMailboxIMAP, ) from twisted.protocols import loopback from twisted.python import failure, log, util from twisted.python.compat import iterbytes, nativeString, networkString from twisted.test.proto_helpers import StringTransport, StringTransportWithDisconnection from twisted.trial.unittest import SynchronousTestCase, TestCase try: from twisted.test.ssl_helpers import ClientTLSContext, ServerTLSContext except ImportError: ClientTLSContext = None # type: ignore[assignment,misc] ServerTLSContext = None # type: ignore[assignment,misc] def strip(f): return lambda result, f=f: f() class IMAP4UTF7Tests(TestCase): tests = [ ["Hello world", b"Hello world"], ["Hello & world", b"Hello &- world"], ["Hello\xffworld", b"Hello&AP8-world"], ["\xff\xfe\xfd\xfc", b"&AP8A,gD9APw-"], [ "~peter/mail/\u65e5\u672c\u8a9e/\u53f0\u5317", b"~peter/mail/&ZeVnLIqe-/&U,BTFw-", ], # example from RFC 2060 ] def test_encodeWithErrors(self): """ Specifying an error policy to C{unicode.encode} with the I{imap4-utf-7} codec should produce the same result as not specifying the error policy. """ text = "Hello world" self.assertEqual( text.encode("imap4-utf-7", "strict"), text.encode("imap4-utf-7") ) def test_decodeWithErrors(self): """ Similar to L{test_encodeWithErrors}, but for C{bytes.decode}. """ bytes = b"Hello world" self.assertEqual( bytes.decode("imap4-utf-7", "strict"), bytes.decode("imap4-utf-7") ) def test_encodeAmpersand(self): """ Unicode strings that contain an ampersand (C{&}) can be encoded to bytes with the I{imap4-utf-7} codec. """ text = "&Hello&\N{VULGAR FRACTION ONE HALF}&" self.assertEqual( text.encode("imap4-utf-7"), b"&-Hello&-&AL0-&-", ) def test_decodeWithoutFinalASCIIShift(self): """ An I{imap4-utf-7} encoded string that does not shift back to ASCII (i.e., it lacks a final C{-}) can be decoded. """ self.assertEqual( b"&AL0".decode("imap4-utf-7"), "\N{VULGAR FRACTION ONE HALF}", ) def test_getreader(self): """ C{codecs.getreader('imap4-utf-7')} returns the I{imap4-utf-7} stream reader class. """ reader = codecs.getreader("imap4-utf-7")(BytesIO(b"Hello&AP8-world")) self.assertEqual(reader.read(), "Hello\xffworld") def test_getwriter(self): """ C{codecs.getwriter('imap4-utf-7')} returns the I{imap4-utf-7} stream writer class. """ output = BytesIO() writer = codecs.getwriter("imap4-utf-7")(output) writer.write("Hello\xffworld") self.assertEqual(output.getvalue(), b"Hello&AP8-world") def test_encode(self): """ The I{imap4-utf-7} can be used to encode a unicode string into a byte string according to the IMAP4 modified UTF-7 encoding rules. """ for (input, output) in self.tests: self.assertEqual(input.encode("imap4-utf-7"), output) def test_decode(self): """ The I{imap4-utf-7} can be used to decode a byte string into a unicode string according to the IMAP4 modified UTF-7 encoding rules. """ for (input, output) in self.tests: self.assertEqual(input, output.decode("imap4-utf-7")) def test_printableSingletons(self): """ The IMAP4 modified UTF-7 implementation encodes all printable characters which are in ASCII using the corresponding ASCII byte. """ # All printables represent themselves for o in chain(range(0x20, 0x26), range(0x27, 0x7F)): charbyte = chr(o).encode() self.assertEqual(charbyte, chr(o).encode("imap4-utf-7")) self.assertEqual(chr(o), charbyte.decode("imap4-utf-7")) self.assertEqual("&".encode("imap4-utf-7"), b"&-") self.assertEqual(b"&-".decode("imap4-utf-7"), "&") class BufferingConsumer: def __init__(self): self.buffer = [] def write(self, bytes): self.buffer.append(bytes) if self.consumer: self.consumer.resumeProducing() def registerProducer(self, consumer, streaming): self.consumer = consumer self.consumer.resumeProducing() def unregisterProducer(self): self.consumer = None class MessageProducerTests(SynchronousTestCase): def testSinglePart(self): body = b"This is body text. Rar." headers = OrderedDict() headers["from"] = "sender@host" headers["to"] = "recipient@domain" headers["subject"] = "booga booga boo" headers["content-type"] = "text/plain" msg = FakeyMessage(headers, (), None, body, 123, None) c = BufferingConsumer() p = imap4.MessageProducer(msg) d = p.beginProducing(c) def cbProduced(result): self.assertIdentical(result, p) self.assertEqual( b"".join(c.buffer), b"{119}\r\n" b"From: sender@host\r\n" b"To: recipient@domain\r\n" b"Subject: booga booga boo\r\n" b"Content-Type: text/plain\r\n" b"\r\n" + body, ) return d.addCallback(cbProduced) def testSingleMultiPart(self): outerBody = b"" innerBody = b"Contained body message text. Squarge." headers = OrderedDict() headers["from"] = "sender@host" headers["to"] = "recipient@domain" headers["subject"] = "booga booga boo" headers["content-type"] = 'multipart/alternative; boundary="xyz"' innerHeaders = OrderedDict() innerHeaders["subject"] = "this is subject text" innerHeaders["content-type"] = "text/plain" msg = FakeyMessage( headers, (), None, outerBody, 123, [FakeyMessage(innerHeaders, (), None, innerBody, None, None)], ) c = BufferingConsumer() p = imap4.MessageProducer(msg) d = p.beginProducing(c) def cbProduced(result): self.failUnlessIdentical(result, p) self.assertEqual( b"".join(c.buffer), b"{239}\r\n" b"From: sender@host\r\n" b"To: recipient@domain\r\n" b"Subject: booga booga boo\r\n" b'Content-Type: multipart/alternative; boundary="xyz"\r\n' b"\r\n" b"\r\n" b"--xyz\r\n" b"Subject: this is subject text\r\n" b"Content-Type: text/plain\r\n" b"\r\n" + innerBody + b"\r\n--xyz--\r\n", ) return d.addCallback(cbProduced) def testMultipleMultiPart(self): outerBody = b"" innerBody1 = b"Contained body message text. Squarge." innerBody2 = b"Secondary <i>message</i> text of squarge body." headers = OrderedDict() headers["from"] = "sender@host" headers["to"] = "recipient@domain" headers["subject"] = "booga booga boo" headers["content-type"] = 'multipart/alternative; boundary="xyz"' innerHeaders = OrderedDict() innerHeaders["subject"] = "this is subject text" innerHeaders["content-type"] = "text/plain" innerHeaders2 = OrderedDict() innerHeaders2["subject"] = "<b>this is subject</b>" innerHeaders2["content-type"] = "text/html" msg = FakeyMessage( headers, (), None, outerBody, 123, [ FakeyMessage(innerHeaders, (), None, innerBody1, None, None), FakeyMessage(innerHeaders2, (), None, innerBody2, None, None), ], ) c = BufferingConsumer() p = imap4.MessageProducer(msg) d = p.beginProducing(c) def cbProduced(result): self.failUnlessIdentical(result, p) self.assertEqual( b"".join(c.buffer), b"{354}\r\n" b"From: sender@host\r\n" b"To: recipient@domain\r\n" b"Subject: booga booga boo\r\n" b'Content-Type: multipart/alternative; boundary="xyz"\r\n' b"\r\n" b"\r\n" b"--xyz\r\n" b"Subject: this is subject text\r\n" b"Content-Type: text/plain\r\n" b"\r\n" + innerBody1 + b"\r\n--xyz\r\n" b"Subject: <b>this is subject</b>\r\n" b"Content-Type: text/html\r\n" b"\r\n" + innerBody2 + b"\r\n--xyz--\r\n", ) return d.addCallback(cbProduced) def test_multiPartNoBoundary(self): """ A boundary is generated if none is provided. """ outerBody = b"" innerBody = b"Contained body message text. Squarge." headers = OrderedDict() headers["from"] = "sender@host" headers["to"] = "recipient@domain" headers["subject"] = "booga booga boo" headers["content-type"] = "multipart/alternative" innerHeaders = OrderedDict() innerHeaders["subject"] = "this is subject text" innerHeaders["content-type"] = "text/plain" msg = FakeyMessage( headers, (), None, outerBody, 123, [FakeyMessage(innerHeaders, (), None, innerBody, None, None)], ) c = BufferingConsumer() p = imap4.MessageProducer(msg) p._uuid4 = lambda: uuid.UUID("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa") d = p.beginProducing(c) def cbProduced(result): self.failUnlessIdentical(result, p) self.assertEqual( b"".join(c.buffer), b"{341}\r\n" b"From: sender@host\r\n" b"To: recipient@domain\r\n" b"Subject: booga booga boo\r\n" b"Content-Type: multipart/alternative; boundary=" b'"----=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"' b"\r\n" b"\r\n" b"\r\n" b"------=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\r\n" b"Subject: this is subject text\r\n" b"Content-Type: text/plain\r\n" b"\r\n" + innerBody + b"\r\n------=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa--\r\n", ) return d.addCallback(cbProduced) def test_multiPartNoQuotes(self): """ A boundary without does not have them added. """ outerBody = b"" innerBody = b"Contained body message text. Squarge." headers = OrderedDict() headers["from"] = "sender@host" headers["to"] = "recipient@domain" headers["subject"] = "booga booga boo" headers["content-type"] = "multipart/alternative; boundary=xyz" innerHeaders = OrderedDict() innerHeaders["subject"] = "this is subject text" innerHeaders["content-type"] = "text/plain" msg = FakeyMessage( headers, (), None, outerBody, 123, [FakeyMessage(innerHeaders, (), None, innerBody, None, None)], ) c = BufferingConsumer() p = imap4.MessageProducer(msg) d = p.beginProducing(c) def cbProduced(result): self.failUnlessIdentical(result, p) self.assertEqual( b"".join(c.buffer), b"{237}\r\n" b"From: sender@host\r\n" b"To: recipient@domain\r\n" b"Subject: booga booga boo\r\n" b"Content-Type: multipart/alternative; boundary=" b"xyz" b"\r\n" b"\r\n" b"\r\n" b"--xyz\r\n" b"Subject: this is subject text\r\n" b"Content-Type: text/plain\r\n" b"\r\n" + innerBody + b"\r\n--xyz--\r\n", ) return d.addCallback(cbProduced) class MessageSetTests(SynchronousTestCase): """ Tests for L{MessageSet}. """ def test_equalityIterationAndAddition(self): """ Test the following properties of L{MessageSet} addition and equality: 1. Two empty L{MessageSet}s are equal to each other; 2. A L{MessageSet} is not equal to any other object; 2. Adding a L{MessageSet} and another L{MessageSet} or an L{int} representing a single message or a sequence of L{int}s representing a sequence of message numbers produces a new L{MessageSet} that: 3. Has a length equal to the number of messages within each sequence of message numbers; 4. Yields each message number in ascending order when iterated over; 6. L{MessageSet.add} with a single message or a start and end message satisfies 3 and 4 above. """ m1 = MessageSet() m2 = MessageSet() self.assertEqual(m1, m2) self.assertNotEqual(m1, ()) m1 = m1 + 1 self.assertEqual(len(m1), 1) self.assertEqual(list(m1), [1]) m1 = m1 + (1, 3) self.assertEqual(len(m1), 3) self.assertEqual(list(m1), [1, 2, 3]) m2 = m2 + (1, 3) self.assertEqual(m1, m2) self.assertEqual(list(m1 + m2), [1, 2, 3]) m1.add(5) self.assertEqual(len(m1), 4) self.assertEqual(list(m1), [1, 2, 3, 5]) self.assertNotEqual(m1, m2) m1.add(6, 8) self.assertEqual(len(m1), 7) self.assertEqual(list(m1), [1, 2, 3, 5, 6, 7, 8]) def test_lengthWithWildcardRange(self): """ A L{MessageSet} that has a range that ends with L{None} raises a L{TypeError} when its length is requested. """ self.assertRaises(TypeError, len, MessageSet(1, None)) def test_reprSanity(self): """ L{MessageSet.__repr__} does not raise an exception """ repr(MessageSet(1, 2)) def test_stringRepresentationWithWildcards(self): """ In a L{MessageSet}, in the presence of wildcards, if the highest message id is known, the wildcard should get replaced by that high value. """ inputs = [ imap4.parseIdList(b"*"), imap4.parseIdList(b"1:*"), imap4.parseIdList(b"3:*", 6), imap4.parseIdList(b"*:2", 6), ] outputs = [ "*", "1:*", "3:6", "2:6", ] for i, o in zip(inputs, outputs): self.assertEqual(str(i), o) def test_stringRepresentationWithInversion(self): """ In a L{MessageSet}, inverting the high and low numbers in a range doesn't affect the meaning of the range. For example, 3:2 displays just like 2:3, because according to the RFC they have the same meaning. """ inputs = [ imap4.parseIdList(b"2:3"), imap4.parseIdList(b"3:2"), ] outputs = [ "2:3", "2:3", ] for i, o in zip(inputs, outputs): self.assertEqual(str(i), o) def test_createWithSingleMessageNumber(self): """ Creating a L{MessageSet} with a single message number adds only that message to the L{MessageSet}; its serialized form includes only that message number, its length is one, and it yields only that message number. """ m = MessageSet(1) self.assertEqual(str(m), "1") self.assertEqual(len(m), 1) self.assertEqual(list(m), [1]) def test_createWithSequence(self): """ Creating a L{MessageSet} with both a start and end message number adds the sequence between to the L{MessageSet}; its serialized form consists that range, its length is the length of the sequence, and it yields the message numbers inclusively between the start and end. """ m = MessageSet(1, 10) self.assertEqual(str(m), "1:10") self.assertEqual(len(m), 10) self.assertEqual(list(m), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) def test_createWithSingleWildcard(self): """ Creating a L{MessageSet} with a single L{None}, representing C{*}, adds C{*} to the range; its serialized form includes only C{*}, its length is one, but it cannot be iterated over because its endpoint is unknown. """ m = MessageSet(None) self.assertEqual(str(m), "*") self.assertEqual(len(m), 1) self.assertRaises(TypeError, list, m) def test_setLastSingleWildcard(self): """ Setting L{MessageSet.last} replaces L{None}, representing C{*}, with that number, making that L{MessageSet} iterable. """ singleMessageReplaced = MessageSet(None) singleMessageReplaced.last = 10 self.assertEqual(list(singleMessageReplaced), [10]) rangeReplaced = MessageSet(3, None) rangeReplaced.last = 1 self.assertEqual(list(rangeReplaced), [1, 2, 3]) def test_setLastWithWildcardRange(self): """ Setting L{MessageSet.last} replaces L{None} in all ranges. """ m = MessageSet(1, None) m.add(2, None) m.last = 5 self.assertEqual(list(m), [1, 2, 3, 4, 5]) def test_setLastTwiceFails(self): """ L{MessageSet.last} cannot be set twice. """ m = MessageSet(1, None) m.last = 2 with self.assertRaises(ValueError): m.last = 3 def test_lastOverridesNoneInAdd(self): """ Adding a L{None}, representing C{*}, or a sequence that includes L{None} to a L{MessageSet} whose L{last<MessageSet.last>} property has been set replaces all occurrences of L{None} with the value of L{last<MessageSet.last>}. """ hasLast = MessageSet(1) hasLast.last = 4 hasLast.add(None) self.assertEqual(list(hasLast), [1, 4]) self.assertEqual(list(hasLast + (None, 5)), [1, 4, 5]) hasLast.add(3, None) self.assertEqual(list(hasLast), [1, 3, 4]) def test_getLast(self): """ Accessing L{MessageSet.last} returns the last value. """ m = MessageSet(1, None) m.last = 2 self.assertEqual(m.last, 2) def test_extend(self): """ L{MessageSet.extend} accepts as its arugment an L{int} or L{None}, or a sequence L{int}s or L{None}s of length two, or another L{MessageSet}, combining its argument with its instance's existing ranges. """ extendWithInt = MessageSet() extendWithInt.extend(1) self.assertEqual(list(extendWithInt), [1]) extendWithNone = MessageSet() extendWithNone.extend(None) self.assertEqual(str(extendWithNone), "*") extendWithSequenceOfInts = MessageSet() extendWithSequenceOfInts.extend((1, 3)) self.assertEqual(list(extendWithSequenceOfInts), [1, 2, 3]) extendWithSequenceOfNones = MessageSet() extendWithSequenceOfNones.extend((None, None)) self.assertEqual(str(extendWithSequenceOfNones), "*") extendWithMessageSet = MessageSet() extendWithMessageSet.extend(MessageSet(1, 3)) self.assertEqual(list(extendWithMessageSet), [1, 2, 3]) def test_contains(self): """ A L{MessageSet} contains a number if the number falls within one of its ranges, and raises L{TypeError} if any range contains L{None}. """ hasFive = MessageSet(1, 7) doesNotHaveFive = MessageSet(1, 4) + MessageSet(6, 7) self.assertIn(5, hasFive) self.assertNotIn(5, doesNotHaveFive) hasFiveButHasNone = hasFive + None with self.assertRaises(TypeError): 5 in hasFiveButHasNone hasFiveButHasNoneInSequence = hasFive + (10, 12) hasFiveButHasNoneInSequence.add(8, None) with self.assertRaises(TypeError): 5 in hasFiveButHasNoneInSequence def test_rangesMerged(self): """ Adding a sequence of message numbers to a L{MessageSet} that begins or ends immediately before or after an existing sequence in that L{MessageSet}, or overlaps one, merges the two. """ mergeAfter = MessageSet(1, 3) mergeBefore = MessageSet(6, 8) mergeBetweenSequence = mergeAfter + mergeBefore mergeBetweenNumber = mergeAfter + MessageSet(5, 7) self.assertEqual(list(mergeAfter + (2, 4)), [1, 2, 3, 4]) self.assertEqual(list(mergeAfter + (3, 5)), [1, 2, 3, 4, 5]) self.assertEqual(list(mergeBefore + (5, 7)), [5, 6, 7, 8]) self.assertEqual(list(mergeBefore + (4, 6)), [4, 5, 6, 7, 8]) self.assertEqual(list(mergeBetweenSequence + (3, 5)), [1, 2, 3, 4, 5, 6, 7, 8]) self.assertEqual( list(mergeBetweenNumber + MessageSet(4)), [1, 2, 3, 4, 5, 6, 7] ) def test_seq_rangeExamples(self): """ Test the C{seq-range} examples from Section 9, "Formal Syntax" of RFC 3501:: Example: 2:4 and 4:2 are equivalent and indicate values 2, 3, and 4. Example: a unique identifier sequence range of 3291:* includes the UID of the last message in the mailbox, even if that value is less than 3291. @see: U{http://tools.ietf.org/html/rfc3501#section-9} """ self.assertEqual(MessageSet(2, 4), MessageSet(4, 2)) self.assertEqual(list(MessageSet(2, 4)), [2, 3, 4]) m = MessageSet(3291, None) m.last = 3290 self.assertEqual(list(m), [3290, 3291]) def test_sequence_setExamples(self): """ Test the C{sequence-set} examples from Section 9, "Formal Syntax" of RFC 3501. In particular, L{MessageSet} reorders and coalesces overlaps:: Example: a message sequence number set of 2,4:7,9,12:* for a mailbox with 15 messages is equivalent to 2,4,5,6,7,9,12,13,14,15 Example: a message sequence number set of *:4,5:7 for a mailbox with 10 messages is equivalent to 10,9,8,7,6,5,4,5,6,7 and MAY be reordered and overlap coalesced to be 4,5,6,7,8,9,10. @see: U{http://tools.ietf.org/html/rfc3501#section-9} """ fromFifteenMessages = ( MessageSet(2) + MessageSet(4, 7) + MessageSet(9) + MessageSet(12, None) ) fromFifteenMessages.last = 15 self.assertEqual( ",".join(str(i) for i in fromFifteenMessages), "2,4,5,6,7,9,12,13,14,15" ) fromTenMessages = MessageSet(None, 4) + MessageSet(5, 7) fromTenMessages.last = 10 self.assertEqual(",".join(str(i) for i in fromTenMessages), "4,5,6,7,8,9,10") class IMAP4HelperTests(TestCase): """ Tests for various helper utilities in the IMAP4 module. """ def test_commandRepr(self): """ L{imap4.Command}'s C{repr} does not raise an exception. """ repr(imap4.Command(b"COMMAND", [b"arg"], (b"extra"))) def test_fileProducer(self): b = ((b"x" * 1) + (b"y" * 1) + (b"z" * 1)) * 10 c = BufferingConsumer() f = BytesIO(b) p = imap4.FileProducer(f) d = p.beginProducing(c) def cbProduced(result): self.failUnlessIdentical(result, p) self.assertEqual(b"{%d}\r\n%b" % (len(b), b), b"".join(c.buffer)) return result def cbResume(result): # Calling resumeProducing after completion does not raise # an exception p.resumeProducing() return result d.addCallback(cbProduced) d.addCallback(cbResume) # The second cbProduced ensures calling resumeProducing after # completion does not change the result. return d.addCallback(cbProduced) def test_wildcard(self): cases = [ [ "foo/%gum/bar", ["foo/bar", "oo/lalagum/bar", "foo/gumx/bar", "foo/gum/baz"], ["foo/xgum/bar", "foo/gum/bar"], ], [ "foo/x%x/bar", ["foo", "bar", "fuz fuz fuz", "foo/*/bar", "foo/xyz/bar", "foo/xx/baz"], ["foo/xyx/bar", "foo/xx/bar", "foo/xxxxxxxxxxxxxx/bar"], ], [ "foo/xyz*abc/bar", ["foo/xyz/bar", "foo/abc/bar", "foo/xyzab/cbar", "foo/xyza/bcbar"], ["foo/xyzabc/bar", "foo/xyz/abc/bar", "foo/xyz/123/abc/bar"], ], ] for (wildcard, fail, succeed) in cases: wildcard = imap4.wildcardToRegexp(wildcard, "/") for x in fail: self.assertFalse(wildcard.match(x)) for x in succeed: self.assertTrue(wildcard.match(x)) def test_wildcardNoDelim(self): cases = [ [ "foo/%gum/bar", ["foo/bar", "oo/lalagum/bar", "foo/gumx/bar", "foo/gum/baz"], ["foo/xgum/bar", "foo/gum/bar", "foo/x/gum/bar"], ], [ "foo/x%x/bar", ["foo", "bar", "fuz fuz fuz", "foo/*/bar", "foo/xyz/bar", "foo/xx/baz"], ["foo/xyx/bar", "foo/xx/bar", "foo/xxxxxxxxxxxxxx/bar", "foo/x/x/bar"], ], [ "foo/xyz*abc/bar", ["foo/xyz/bar", "foo/abc/bar", "foo/xyzab/cbar", "foo/xyza/bcbar"], ["foo/xyzabc/bar", "foo/xyz/abc/bar", "foo/xyz/123/abc/bar"], ], ] for (wildcard, fail, succeed) in cases: wildcard = imap4.wildcardToRegexp(wildcard, None) for x in fail: self.assertFalse(wildcard.match(x), x) for x in succeed: self.assertTrue(wildcard.match(x), x) def test_headerFormatter(self): """ L{imap4._formatHeaders} accepts a C{dict} of header name/value pairs and returns a string representing those headers in the standard multiline, C{":"}-separated format. """ cases = [ ( {"Header1": "Value1", "Header2": "Value2"}, b"Header2: Value2\r\nHeader1: Value1\r\n", ), ] for (input, expected) in cases: output = imap4._formatHeaders(input) self.assertEqual( sorted(output.splitlines(True)), sorted(expected.splitlines(True)) ) def test_quotedSplitter(self): cases = [ b"""Hello World""", b'''Hello "World!"''', b'''World "Hello" "How are you?"''', b'''"Hello world" How "are you?"''', b"""foo bar "baz buz" NIL""", b'''foo bar "baz buz" "NIL"''', b"""foo NIL "baz buz" bar""", b"""foo "NIL" "baz buz" bar""", b""""NIL" bar "baz buz" foo""", b'oo \\"oo\\" oo', b'"oo \\"oo\\" oo"', b"oo \t oo", b'"oo \t oo"', b"oo \\t oo", b'"oo \\t oo"', br"oo \o oo", br'"oo \o oo"', b"oo \\o oo", b'"oo \\o oo"', ] answers = [ [b"Hello", b"World"], [b"Hello", b"World!"], [b"World", b"Hello", b"How are you?"], [b"Hello world", b"How", b"are you?"], [b"foo", b"bar", b"baz buz", None], [b"foo", b"bar", b"baz buz", b"NIL"], [b"foo", None, b"baz buz", b"bar"], [b"foo", b"NIL", b"baz buz", b"bar"], [b"NIL", b"bar", b"baz buz", b"foo"], [b"oo", b'"oo"', b"oo"], [b'oo "oo" oo'], [b"oo", b"oo"], [b"oo \t oo"], [b"oo", b"\\t", b"oo"], [b"oo \\t oo"], [b"oo", br"\o", b"oo"], [br"oo \o oo"], [b"oo", b"\\o", b"oo"], [b"oo \\o oo"], ] errors = [ b'"mismatched quote', b'mismatched quote"', b'mismatched"quote', b'"oops here is" another"', ] for s in errors: self.assertRaises(imap4.MismatchedQuoting, imap4.splitQuoted, s) for (case, expected) in zip(cases, answers): self.assertEqual(imap4.splitQuoted(case), expected) def test_stringCollapser(self): cases = [ [b"a", b"b", b"c", b"d", b"e"], [b"a", b" ", b'"', b"b", b"c", b" ", b'"', b" ", b"d", b"e"], [[b"a", b"b", b"c"], b"d", b"e"], [b"a", [b"b", b"c", b"d"], b"e"], [b"a", b"b", [b"c", b"d", b"e"]], [b'"', b"a", b" ", b'"', [b"b", b"c", b"d"], b'"', b" ", b"e", b'"'], [b"a", [b'"', b" ", b"b", b"c", b" ", b" ", b'"'], b"d", b"e"], ] answers = [ [b"abcde"], [b"a", b"bc ", b"de"], [[b"abc"], b"de"], [b"a", [b"bcd"], b"e"], [b"ab", [b"cde"]], [b"a ", [b"bcd"], b" e"], [b"a", [b" bc "], b"de"], ] for (case, expected) in zip(cases, answers): self.assertEqual(imap4.collapseStrings(case), expected) def test_parenParser(self): s = b"\r\n".join([b"xx"] * 4) def check(case, expected): parsed = imap4.parseNestedParens(case) self.assertEqual(parsed, [expected]) # XXX This code used to work, but changes occurred within the # imap4.py module which made it no longer necessary for *all* of it # to work. In particular, only the part that makes # 'BODY.PEEK[HEADER.FIELDS.NOT (Subject Bcc Cc)]' come out # correctly no longer needs to work. So, I am loathe to delete the # entire section of the test. --exarkun # self.assertEqual(b'(' + imap4.collapseNestedLists(parsed) + b')', # expected) check( b"(BODY.PEEK[HEADER.FIELDS.NOT (subject bcc cc)] {%d}\r\n%b)" % (len(s), s), [b"BODY.PEEK", [b"HEADER.FIELDS.NOT", [b"subject", b"bcc", b"cc"]], s], ) check( b'(FLAGS (\\Seen) INTERNALDATE "17-Jul-1996 02:44:25 -0700" ' b"RFC822.SIZE 4286 ENVELOPE " b'("Wed, 17 Jul 1996 02:23:25 -0700 (PDT)" ' b'"IMAP4rev1 WG mtg summary and minutes" ' b'(("Terry Gray" NIL gray cac.washington.edu)) ' b'(("Terry Gray" NIL gray cac.washington.edu)) ' b'(("Terry Gray" NIL gray cac.washington.edu)) ' b"((NIL NIL imap cac.washington.edu)) " b"((NIL NIL minutes CNRI.Reston.VA.US) " b'("John Klensin" NIL KLENSIN INFOODS.MIT.EDU)) NIL NIL ' b"<B27397-0100000@cac.washington.edu>) " b"BODY (TEXT PLAIN (CHARSET US-ASCII) NIL NIL 7BIT 3028 92))", [ b"FLAGS", [br"\Seen"], b"INTERNALDATE", b"17-Jul-1996 02:44:25 -0700", b"RFC822.SIZE", b"4286", b"ENVELOPE", [ b"Wed, 17 Jul 1996 02:23:25 -0700 (PDT)", b"IMAP4rev1 WG mtg summary and minutes", [[b"Terry Gray", None, b"gray", b"cac.washington.edu"]], [[b"Terry Gray", None, b"gray", b"cac.washington.edu"]], [[b"Terry Gray", None, b"gray", b"cac.washington.edu"]], [[None, None, b"imap", b"cac.washington.edu"]], [ [None, None, b"minutes", b"CNRI.Reston.VA.US"], [b"John Klensin", None, b"KLENSIN", b"INFOODS.MIT.EDU"], ], None, None, b"<B27397-0100000@cac.washington.edu>", ], b"BODY", [ b"TEXT", b"PLAIN", [b"CHARSET", b"US-ASCII"], None, None, b"7BIT", b"3028", b"92", ], ], ) check(b'("oo \\"oo\\" oo")', [b'oo "oo" oo']) check(b'("oo \\\\ oo")', [b"oo \\\\ oo"]) check(b'("oo \\ oo")', [b"oo \\ oo"]) check(b'("oo \\o")', [b"oo \\o"]) check(br'("oo \o")', [br"oo \o"]) check(br"(oo \o)", [b"oo", br"\o"]) check(b"(oo \\o)", [b"oo", b"\\o"]) def test_fetchParserSimple(self): cases = [ ["ENVELOPE", "Envelope", "envelope"], ["FLAGS", "Flags", "flags"], ["INTERNALDATE", "InternalDate", "internaldate"], ["RFC822.HEADER", "RFC822Header", "rfc822.header"], ["RFC822.SIZE", "RFC822Size", "rfc822.size"], ["RFC822.TEXT", "RFC822Text", "rfc822.text"], ["RFC822", "RFC822", "rfc822"], ["UID", "UID", "uid"], ["BODYSTRUCTURE", "BodyStructure", "bodystructure"], ] for (inp, outp, asString) in cases: inp = inp.encode("ascii") p = imap4._FetchParser() p.parseString(inp) self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], getattr(p, outp))) self.assertEqual(str(p.result[0]), asString) def test_fetchParserMacros(self): cases = [ [b"ALL", (4, [b"flags", b"internaldate", b"rfc822.size", b"envelope"])], [ b"FULL", (5, [b"flags", b"internaldate", b"rfc822.size", b"envelope", b"body"]), ], [b"FAST", (3, [b"flags", b"internaldate", b"rfc822.size"])], ] for (inp, outp) in cases: p = imap4._FetchParser() p.parseString(inp) self.assertEqual(len(p.result), outp[0]) expectedResult = [str(token).lower().encode("ascii") for token in p.result] expectedResult.sort() outp[1].sort() self.assertEqual(expectedResult, outp[1]) def test_fetchParserBody(self): P = imap4._FetchParser p = P() p.parseString(b"BODY") self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], p.Body)) self.assertEqual(p.result[0].peek, False) self.assertEqual(p.result[0].header, None) self.assertEqual(str(p.result[0]), "BODY") p = P() p.parseString(b"BODY.PEEK") self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], p.Body)) self.assertEqual(p.result[0].peek, True) self.assertEqual(str(p.result[0]), "BODY") p = P() p.parseString(b"BODY[]") self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], p.Body)) self.assertEqual(p.result[0].empty, True) self.assertEqual(str(p.result[0]), "BODY[]") p = P() p.parseString(b"BODY[HEADER]") self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], p.Body)) self.assertEqual(p.result[0].peek, False) self.assertTrue(isinstance(p.result[0].header, p.Header)) self.assertEqual(p.result[0].header.negate, True) self.assertEqual(p.result[0].header.fields, ()) self.assertEqual(p.result[0].empty, False) self.assertEqual(str(p.result[0]), "BODY[HEADER]") p = P() p.parseString(b"BODY.PEEK[HEADER]") self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], p.Body)) self.assertEqual(p.result[0].peek, True) self.assertTrue(isinstance(p.result[0].header, p.Header)) self.assertEqual(p.result[0].header.negate, True) self.assertEqual(p.result[0].header.fields, ()) self.assertEqual(p.result[0].empty, False) self.assertEqual(str(p.result[0]), "BODY[HEADER]") p = P() p.parseString(b"BODY[HEADER.FIELDS (Subject Cc Message-Id)]") self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], p.Body)) self.assertEqual(p.result[0].peek, False) self.assertTrue(isinstance(p.result[0].header, p.Header)) self.assertEqual(p.result[0].header.negate, False) self.assertEqual(p.result[0].header.fields, [b"SUBJECT", b"CC", b"MESSAGE-ID"]) self.assertEqual(p.result[0].empty, False) self.assertEqual( bytes(p.result[0]), b"BODY[HEADER.FIELDS (Subject Cc Message-Id)]" ) p = P() p.parseString(b"BODY.PEEK[HEADER.FIELDS (Subject Cc Message-Id)]") self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], p.Body)) self.assertEqual(p.result[0].peek, True) self.assertTrue(isinstance(p.result[0].header, p.Header)) self.assertEqual(p.result[0].header.negate, False) self.assertEqual(p.result[0].header.fields, [b"SUBJECT", b"CC", b"MESSAGE-ID"]) self.assertEqual(p.result[0].empty, False) self.assertEqual( bytes(p.result[0]), b"BODY[HEADER.FIELDS (Subject Cc Message-Id)]" ) p = P() p.parseString(b"BODY.PEEK[HEADER.FIELDS.NOT (Subject Cc Message-Id)]") self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], p.Body)) self.assertEqual(p.result[0].peek, True) self.assertTrue(isinstance(p.result[0].header, p.Header)) self.assertEqual(p.result[0].header.negate, True) self.assertEqual(p.result[0].header.fields, [b"SUBJECT", b"CC", b"MESSAGE-ID"]) self.assertEqual(p.result[0].empty, False) self.assertEqual( bytes(p.result[0]), b"BODY[HEADER.FIELDS.NOT (Subject Cc Message-Id)]" ) p = P() p.parseString(b"BODY[1.MIME]<10.50>") self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], p.Body)) self.assertEqual(p.result[0].peek, False) self.assertTrue(isinstance(p.result[0].mime, p.MIME)) self.assertEqual(p.result[0].part, (0,)) self.assertEqual(p.result[0].partialBegin, 10) self.assertEqual(p.result[0].partialLength, 50) self.assertEqual(p.result[0].empty, False) self.assertEqual(bytes(p.result[0]), b"BODY[1.MIME]<10.50>") p = P() p.parseString( b"BODY.PEEK[1.3.9.11.HEADER.FIELDS.NOT (Message-Id Date)]<103.69>" ) self.assertEqual(len(p.result), 1) self.assertTrue(isinstance(p.result[0], p.Body)) self.assertEqual(p.result[0].peek, True) self.assertTrue(isinstance(p.result[0].header, p.Header)) self.assertEqual(p.result[0].part, (0, 2, 8, 10)) self.assertEqual(p.result[0].header.fields, [b"MESSAGE-ID", b"DATE"]) self.assertEqual(p.result[0].partialBegin, 103) self.assertEqual(p.result[0].partialLength, 69) self.assertEqual(p.result[0].empty, False) self.assertEqual( bytes(p.result[0]), b"BODY[1.3.9.11.HEADER.FIELDS.NOT (Message-Id Date)]<103.69>", ) def test_fetchParserQuotedHeader(self): """ Parsing a C{BODY} whose C{HEADER} values require quoting results in a object that perserves that quoting when serialized. """ p = imap4._FetchParser() p.parseString(b"BODY[HEADER.FIELDS ((Quoted)]") self.assertEqual(len(p.result), 1) self.assertEqual(p.result[0].peek, False) self.assertIsInstance(p.result[0], p.Body) self.assertIsInstance(p.result[0].header, p.Header) self.assertEqual(bytes(p.result[0]), b'BODY[HEADER.FIELDS ("(Quoted")]') def test_fetchParserEmptyString(self): """ Parsing an empty string results in no data. """ p = imap4._FetchParser() p.parseString(b"") self.assertFalse(len(p.result)) def test_fetchParserUnknownAttribute(self): """ Parsing a string with an unknown attribute raises an L{Exception}. """ p = imap4._FetchParser() self.assertRaises(Exception, p.parseString, b"UNKNOWN") def test_fetchParserIncompleteStringEndsInWhitespace(self): """ Parsing a string that prematurely ends in whitespace raises an L{Exception}. """ p = imap4._FetchParser() self.assertRaises(Exception, p.parseString, b"BODY[HEADER.FIELDS ") def test_fetchParserExpectedWhitespace(self): """ Parsing a string that contains an unexpected character rather than whitespace raises an L{Exception}. """ p = imap4._FetchParser() self.assertRaises(Exception, p.parseString, b"BODY[HEADER.FIELDS!]") def test_fetchParserTextSection(self): """ A C{BODY} can contain a C{TEXT} section. """ p = imap4._FetchParser() p.parseString(b"BODY[TEXT]") self.assertEqual(len(p.result), 1) self.assertIsInstance(p.result[0], p.Body) self.assertEqual(p.result[0].peek, False) self.assertIsInstance(p.result[0].text, p.Text) self.assertEqual(bytes(p.result[0]), b"BODY[TEXT]") def test_fetchParserUnknownSection(self): """ Parsing a C{BODY} with an unknown section raises an L{Exception}. """ p = imap4._FetchParser() self.assertRaises(Exception, p.parseString, b"BODY[UNKNOWN]") def test_fetchParserMissingSectionClose(self): """ Parsing a C{BODY} with an unterminated section list raises an L{Exception}. """ p = imap4._FetchParser() self.assertRaises(Exception, p.parseString, b"BODY[HEADER") p = imap4._FetchParser() self.assertRaises(Exception, p.parseString, b"BODY[HEADER.FIELDS (SUBJECT)") def test_fetchParserHeaderMissingParentheses(self): """ Parsing a C{BODY} whose C{HEADER.FIELDS} list does not begin with an open parenthesis (C{(}) or end with a close parenthesis (C{)}) raises an L{Exception}. """ p = imap4._FetchParser() self.assertRaises(Exception, p.parseString, b"BODY[HEADER.FIELDS Missing)]") p = imap4._FetchParser() self.assertRaises(Exception, p.parseString, b"BODY[HEADER.FIELDS (Missing]") def test_fetchParserDotlessPartial(self): """ Parsing a C{BODY} with a range that lacks a period (C{.}) raises an L{Exception}. """ p = imap4._FetchParser() self.assertRaises(Exception, p.parseString, b"BODY<01>") def test_fetchParserUnclosedPartial(self): """ Parsing a C{BODY} with a partial range that's missing its closing greater than sign (C{>}) raises an L{EXCEPTION}. """ p = imap4._FetchParser() self.assertRaises(Exception, p.parseString, b"BODY<0") def test_files(self): inputStructure = [ "foo", "bar", "baz", BytesIO(b"this is a file\r\n"), "buz", "biz", ] output = b'"foo" "bar" "baz" {16}\r\nthis is a file\r\n "buz" "biz"' self.assertEqual(imap4.collapseNestedLists(inputStructure), output) def test_quoteAvoider(self): input = [ b"foo", imap4.DontQuoteMe(b"bar"), b"baz", BytesIO(b"this is a file\r\n"), b"this is\r\nquoted", imap4.DontQuoteMe(b"buz"), b"", ] output = ( b'"foo" bar "baz"' b" {16}\r\nthis is a file\r\n " b"{15}\r\nthis is\r\nquoted" b' buz ""' ) self.assertEqual(imap4.collapseNestedLists(input), output) def test_literals(self): cases = [ (b"({10}\r\n0123456789)", [[b"0123456789"]]), ] for (case, expected) in cases: self.assertEqual(imap4.parseNestedParens(case), expected) def test_queryBuilder(self): inputs = [ imap4.Query(flagged=1), imap4.Query(sorted=1, unflagged=1, deleted=1), imap4.Or(imap4.Query(flagged=1), imap4.Query(deleted=1)), imap4.Query(before="today"), imap4.Or(imap4.Query(deleted=1), imap4.Query(unseen=1), imap4.Query(new=1)), imap4.Or( imap4.Not( imap4.Or( imap4.Query(sorted=1, since="yesterday", smaller=1000), imap4.Query(sorted=1, before="tuesday", larger=10000), imap4.Query(sorted=1, unseen=1, deleted=1, before="today"), imap4.Not(imap4.Query(subject="spam")), ), ), imap4.Not(imap4.Query(uid="1:5")), ), ] outputs = [ "FLAGGED", "(DELETED UNFLAGGED)", "(OR FLAGGED DELETED)", '(BEFORE "today")', "(OR DELETED (OR UNSEEN NEW))", '(OR (NOT (OR (SINCE "yesterday" SMALLER 1000) ' # Continuing '(OR (BEFORE "tuesday" LARGER 10000) (OR (BEFORE ' # Some more '"today" DELETED UNSEEN) (NOT (SUBJECT "spam")))))) ' # And more "(NOT (UID 1:5)))", ] for (query, expected) in zip(inputs, outputs): self.assertEqual(query, expected) def test_queryKeywordFlagWithQuotes(self): """ When passed the C{keyword} argument, L{imap4.Query} returns an unquoted string. @see: U{http://tools.ietf.org/html/rfc3501#section-9} @see: U{http://tools.ietf.org/html/rfc3501#section-6.4.4} """ query = imap4.Query(keyword="twisted") self.assertEqual("(KEYWORD twisted)", query) def test_queryUnkeywordFlagWithQuotes(self): """ When passed the C{unkeyword} argument, L{imap4.Query} returns an unquoted string. @see: U{http://tools.ietf.org/html/rfc3501#section-9} @see: U{http://tools.ietf.org/html/rfc3501#section-6.4.4} """ query = imap4.Query(unkeyword="twisted") self.assertEqual("(UNKEYWORD twisted)", query) def test_queryWithMesssageSet(self): """ When passed a L{MessageSet}, L{imap4.Query} returns a query containing a quoted string representing the ID sequence. """ query = imap4.Query(messages=imap4.MessageSet(1, None)) self.assertEqual(query, '(MESSAGES "1:*")') def test_queryWithInteger(self): """ When passed an L{int}, L{imap4.Query} returns a query containing a quoted integer. """ query = imap4.Query(messages=1) self.assertEqual(query, '(MESSAGES "1")') def test_queryOrIllegalQuery(self): """ An L{imap4.Or} query with less than two arguments raises an L{imap4.IllegalQueryError}. """ self.assertRaises(imap4.IllegalQueryError, imap4.Or, imap4.Query(messages=1)) def _keywordFilteringTest(self, keyword): """ Helper to implement tests for value filtering of KEYWORD and UNKEYWORD queries. @param keyword: A native string giving the name of the L{imap4.Query} keyword argument to test. """ # Check all the printable exclusions self.assertEqual( f"({keyword.upper()} twistedrocks)", imap4.Query(**{keyword: r'twisted (){%*"\] rocks'}), ) # Check all the non-printable exclusions self.assertEqual( f"({keyword.upper()} twistedrocks)", imap4.Query( **{ keyword: "twisted %s rocks" % ("".join(chr(ch) for ch in range(33)),) } ), ) def test_queryKeywordFlag(self): r""" When passed the C{keyword} argument, L{imap4.Query} returns an C{atom} that consists of one or more non-special characters. List of the invalid characters: ( ) { % * " \ ] CTL SP @see: U{ABNF definition of CTL and SP<https://tools.ietf.org/html/rfc2234>} @see: U{IMAP4 grammar<http://tools.ietf.org/html/rfc3501#section-9>} @see: U{IMAP4 SEARCH specification<http://tools.ietf.org/html/rfc3501#section-6.4.4>} """ self._keywordFilteringTest("keyword") def test_queryUnkeywordFlag(self): r""" When passed the C{unkeyword} argument, L{imap4.Query} returns an C{atom} that consists of one or more non-special characters. List of the invalid characters: ( ) { % * " \ ] CTL SP @see: U{ABNF definition of CTL and SP<https://tools.ietf.org/html/rfc2234>} @see: U{IMAP4 grammar<http://tools.ietf.org/html/rfc3501#section-9>} @see: U{IMAP4 SEARCH specification<http://tools.ietf.org/html/rfc3501#section-6.4.4>} """ self._keywordFilteringTest("unkeyword") def test_invalidIdListParser(self): """ Trying to parse an invalid representation of a sequence range raises an L{IllegalIdentifierError}. """ inputs = [b"*:*", b"foo", b"4:", b"bar:5"] for input in inputs: self.assertRaises( imap4.IllegalIdentifierError, imap4.parseIdList, input, 12345 ) def test_invalidIdListParserNonPositive(self): """ Zeroes and negative values are not accepted in id range expressions. RFC 3501 states that sequence numbers and sequence ranges consist of non-negative numbers (RFC 3501 section 9, the seq-number grammar item). """ inputs = [b"0:5", b"0:0", b"*:0", b"0", b"-3:5", b"1:-2", b"-1"] for input in inputs: self.assertRaises( imap4.IllegalIdentifierError, imap4.parseIdList, input, 12345 ) def test_parseIdList(self): """ The function to parse sequence ranges yields appropriate L{MessageSet} objects. """ inputs = [ b"1:*", b"5:*", b"1:2,5:*", b"*", b"1", b"1,2", b"1,3,5", b"1:10", b"1:10,11", b"1:5,10:20", b"1,5:10", b"1,5:10,15:20", b"1:10,15,20:25", b"4:2", ] outputs = [ MessageSet(1, None), MessageSet(5, None), MessageSet(5, None) + MessageSet(1, 2), MessageSet(None, None), MessageSet(1), MessageSet(1, 2), MessageSet(1) + MessageSet(3) + MessageSet(5), MessageSet(1, 10), MessageSet(1, 11), MessageSet(1, 5) + MessageSet(10, 20), MessageSet(1) + MessageSet(5, 10), MessageSet(1) + MessageSet(5, 10) + MessageSet(15, 20), MessageSet(1, 10) + MessageSet(15) + MessageSet(20, 25), MessageSet(2, 4), ] lengths = [None, None, None, 1, 1, 2, 3, 10, 11, 16, 7, 13, 17, 3] for (input, expected) in zip(inputs, outputs): self.assertEqual(imap4.parseIdList(input), expected) for (input, expected) in zip(inputs, lengths): if expected is None: self.assertRaises(TypeError, len, imap4.parseIdList(input)) else: L = len(imap4.parseIdList(input)) self.assertEqual(L, expected, f"len({input!r}) = {L!r} != {expected!r}") def test_parseTimeInvalidFormat(self): """ L{imap4.parseTime} raises L{ValueError} when given a a time string whose format is invalid. """ self.assertRaises(ValueError, imap4.parseTime, "invalid") def test_parseTimeInvalidValues(self): """ L{imap4.parseTime} raises L{ValueError} when given a time string composed of invalid values. """ invalidStrings = [ "invalid-July-2017", "2-invalid-2017", "2-July-invalid", ] for invalid in invalidStrings: self.assertRaises(ValueError, imap4.parseTime, invalid) def test_statusRequestHelper(self): """ L{imap4.statusRequestHelper} builds a L{dict} mapping the requested status names to values extracted from the provided L{IMailboxIMAP}'s. """ mbox = SimpleMailbox() expected = { "MESSAGES": mbox.getMessageCount(), "RECENT": mbox.getRecentCount(), "UIDNEXT": mbox.getUIDNext(), "UIDVALIDITY": mbox.getUIDValidity(), "UNSEEN": mbox.getUnseenCount(), } result = imap4.statusRequestHelper(mbox, expected.keys()) self.assertEqual(expected, result) @implementer(imap4.IMailboxInfo, imap4.IMailbox, imap4.ICloseableMailbox) class SimpleMailbox: flags = ("\\Flag1", "Flag2", "\\AnotherSysFlag", "LastFlag") messages: List[Tuple[bytes, list, bytes, int]] = [] mUID = 0 rw = 1 closed = False def __init__(self): self.listeners = [] self.addListener = self.listeners.append self.removeListener = self.listeners.remove def getFlags(self): return self.flags def getUIDValidity(self): return 42 def getUIDNext(self): return len(self.messages) + 1 def getMessageCount(self): return 9 def getRecentCount(self): return 3 def getUnseenCount(self): return 4 def isWriteable(self): return self.rw def destroy(self): pass def getHierarchicalDelimiter(self): return "/" def requestStatus(self, names): r = {} if "MESSAGES" in names: r["MESSAGES"] = self.getMessageCount() if "RECENT" in names: r["RECENT"] = self.getRecentCount() if "UIDNEXT" in names: r["UIDNEXT"] = self.getMessageCount() + 1 if "UIDVALIDITY" in names: r["UIDVALIDITY"] = self.getUID() if "UNSEEN" in names: r["UNSEEN"] = self.getUnseenCount() return defer.succeed(r) def addMessage(self, message, flags, date=None): self.messages.append((message, flags, date, self.mUID)) self.mUID += 1 return defer.succeed(None) def expunge(self): delete = [] for i in self.messages: if "\\Deleted" in i[1]: delete.append(i) for i in delete: self.messages.remove(i) return [i[3] for i in delete] def close(self): self.closed = True def fetch(self, messages, uid): # IMailboxIMAP.fetch pass def getUID(self, message): # IMailboxIMAP.getUID pass def store(self, messages, flags, mode, uid): # IMailboxIMAP.store pass @implementer(imap4.IMailboxInfo, imap4.IMailbox) class UncloseableMailbox: """ A mailbox that cannot be closed. """ flags = ("\\Flag1", "Flag2", "\\AnotherSysFlag", "LastFlag") messages: List[Tuple[bytes, list, bytes, int]] = [] mUID = 0 rw = 1 closed = False def __init__(self): self.listeners = [] self.addListener = self.listeners.append self.removeListener = self.listeners.remove def getFlags(self): """ The flags @return: A sequence of flags. """ return self.flags def getUIDValidity(self): """ The UID validity value. @return: The value. """ return 42 def getUIDNext(self): """ The next UID. @return: The UID. """ return len(self.messages) + 1 def getMessageCount(self): """ The number of messages. @return: The number. """ return 9 def getRecentCount(self): """ The recent messages. @return: The number. """ return 3 def getUnseenCount(self): """ The recent messages. @return: The number. """ return 4 def isWriteable(self): """ The recent messages. @return: Whether or not the mailbox is writable. """ return self.rw def destroy(self): """ Destroy this mailbox. """ pass def getHierarchicalDelimiter(self): """ Return the hierarchical delimiter. @return: The delimiter. """ return "/" def requestStatus(self, names): """ Return the mailbox's status. @param names: The status items to include. @return: A L{dict} of status data. """ r = {} if "MESSAGES" in names: r["MESSAGES"] = self.getMessageCount() if "RECENT" in names: r["RECENT"] = self.getRecentCount() if "UIDNEXT" in names: r["UIDNEXT"] = self.getMessageCount() + 1 if "UIDVALIDITY" in names: r["UIDVALIDITY"] = self.getUID() if "UNSEEN" in names: r["UNSEEN"] = self.getUnseenCount() return defer.succeed(r) def addMessage(self, message, flags, date=None): """ Add a message to the mailbox. @param message: The message body. @param flags: The message flags. @param date: The message date. @return: A L{Deferred} that fires when the message has been added. """ self.messages.append((message, flags, date, self.mUID)) self.mUID += 1 return defer.succeed(None) def expunge(self): """ Delete messages marked for deletion. @return: A L{list} of deleted message IDs. """ delete = [] for i in self.messages: if "\\Deleted" in i[1]: delete.append(i) for i in delete: self.messages.remove(i) return [i[3] for i in delete] def fetch(self, messages, uid): # IMailboxIMAP.fetch pass def getUID(self, message): # IMailboxIMAP.getUID pass def store(self, messages, flags, mode, uid): # IMailboxIMAP.store pass class AccountWithoutNamespaces(imap4.MemoryAccountWithoutNamespaces): """ An in-memory account that does not provide L{INamespacePresenter}. """ mailboxFactory = SimpleMailbox def _emptyMailbox(self, name, id): return self.mailboxFactory() def select(self, name, rw=1): mbox = imap4.MemoryAccount.select(self, name) if mbox is not None: mbox.rw = rw return mbox class Account(AccountWithoutNamespaces, imap4.MemoryAccount): """ An in-memory account that provides L{INamespacePresenter}. """ class SimpleServer(imap4.IMAP4Server): theAccount = Account(b"testuser") def __init__(self, *args, **kw): imap4.IMAP4Server.__init__(self, *args, **kw) realm = TestRealm(accountHolder=self) portal = Portal(realm) c = InMemoryUsernamePasswordDatabaseDontUse() c.addUser(b"testuser", b"password-test") self.checker = c self.portal = portal portal.registerChecker(c) self.timeoutTest = False def lineReceived(self, line): if self.timeoutTest: # Do not send a response return imap4.IMAP4Server.lineReceived(self, line) class SimpleClient(imap4.IMAP4Client): def __init__(self, deferred, contextFactory=None): imap4.IMAP4Client.__init__(self, contextFactory) self.deferred = deferred self.events = [] def serverGreeting(self, caps): self.deferred.callback(None) def modeChanged(self, writeable): self.events.append(["modeChanged", writeable]) self.transport.loseConnection() def flagsChanged(self, newFlags): self.events.append(["flagsChanged", newFlags]) self.transport.loseConnection() def newMessages(self, exists, recent): self.events.append(["newMessages", exists, recent]) self.transport.loseConnection() class IMAP4HelperMixin: serverCTX: Optional[ServerTLSContext] = None clientCTX: Optional[ClientTLSContext] = None def setUp(self): d = defer.Deferred() self.server = SimpleServer(contextFactory=self.serverCTX) self.client = SimpleClient(d, contextFactory=self.clientCTX) self.connected = d SimpleMailbox.messages = [] theAccount = Account(b"testuser") theAccount.mboxType = SimpleMailbox SimpleServer.theAccount = theAccount def tearDown(self): del self.server del self.client del self.connected def _cbStopClient(self, ignore): self.client.transport.loseConnection() def _ebGeneral(self, failure): self.client.transport.loseConnection() self.server.transport.loseConnection() log.err(failure, "Problem with " + str(self)) def loopback(self): return loopback.loopbackAsync(self.server, self.client) def assertClientFailureMessage(self, failure, expected): """ Assert that the provided failure is an L{IMAP4Exception} with the given message. @param failure: A failure whose value L{IMAP4Exception} @type failure: L{failure.Failure} @param expected: The expected failure message. @type expected: L{bytes} """ failure.trap(imap4.IMAP4Exception) message = str(failure.value) expected = repr(expected) self.assertEqual(message, expected) class IMAP4ServerTests(IMAP4HelperMixin, TestCase): def testCapability(self): caps = {} def getCaps(): def gotCaps(c): caps.update(c) self.server.transport.loseConnection() return self.client.getCapabilities().addCallback(gotCaps) d1 = self.connected.addCallback(strip(getCaps)).addErrback(self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) expected = {b"IMAP4rev1": None, b"NAMESPACE": None, b"IDLE": None} return d.addCallback(lambda _: self.assertEqual(expected, caps)) def testCapabilityWithAuth(self): caps = {} self.server.challengers[b"CRAM-MD5"] = CramMD5Credentials def getCaps(): def gotCaps(c): caps.update(c) self.server.transport.loseConnection() return self.client.getCapabilities().addCallback(gotCaps) d1 = self.connected.addCallback(strip(getCaps)).addErrback(self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) expCap = { b"IMAP4rev1": None, b"NAMESPACE": None, b"IDLE": None, b"AUTH": [b"CRAM-MD5"], } return d.addCallback(lambda _: self.assertEqual(expCap, caps)) def testLogout(self): self.loggedOut = 0 def logout(): def setLoggedOut(): self.loggedOut = 1 self.client.logout().addCallback(strip(setLoggedOut)) self.connected.addCallback(strip(logout)).addErrback(self._ebGeneral) d = self.loopback() return d.addCallback(lambda _: self.assertEqual(self.loggedOut, 1)) def testNoop(self): self.responses = None def noop(): def setResponses(responses): self.responses = responses self.server.transport.loseConnection() self.client.noop().addCallback(setResponses) self.connected.addCallback(strip(noop)).addErrback(self._ebGeneral) d = self.loopback() return d.addCallback(lambda _: self.assertEqual(self.responses, [])) def testLogin(self): def login(): d = self.client.login(b"testuser", b"password-test") d.addCallback(self._cbStopClient) d1 = self.connected.addCallback(strip(login)).addErrback(self._ebGeneral) d = defer.gatherResults([d1, self.loopback()]) return d.addCallback(self._cbTestLogin) def _cbTestLogin(self, ignored): self.assertEqual(self.server.account, SimpleServer.theAccount) self.assertEqual(self.server.state, "auth") def testFailedLogin(self): def login(): d = self.client.login(b"testuser", b"wrong-password") d.addBoth(self._cbStopClient) d1 = self.connected.addCallback(strip(login)).addErrback(self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestFailedLogin) def _cbTestFailedLogin(self, ignored): self.assertEqual(self.server.account, None) self.assertEqual(self.server.state, "unauth") def test_loginWithoutPortal(self): """ Attempting to log into a server that has no L{Portal} results in a failed login. """ self.server.portal = None def login(): d = self.client.login(b"testuser", b"wrong-password") d.addBoth(self._cbStopClient) d1 = self.connected.addCallback(strip(login)).addErrback(self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestFailedLogin) def test_nonIAccountAvatar(self): """ The server responds with a C{BAD} response when its portal attempts to log a user in with checker that claims to support L{IAccount} but returns an an avatar interface that is not L{IAccount}. """ def brokenRequestAvatar(*_, **__): return ("Not IAccount", "Not an account", lambda: None) self.server.portal.realm.requestAvatar = brokenRequestAvatar def login(): d = self.client.login(b"testuser", b"password-test") d.addBoth(self._cbStopClient) d1 = self.connected.addCallback(strip(login)).addErrback(self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestFailedLogin) def test_loginException(self): """ Any exception raised by L{IMAP4Server.authenticateLogin} that is not L{UnauthorizedLogin} is logged results in a C{BAD} response. """ class UnexpectedException(Exception): """ An unexpected exception. """ def raisesUnexpectedException(user, passwd): raise UnexpectedException("Whoops") self.server.authenticateLogin = raisesUnexpectedException def login(): return self.client.login(b"testuser", b"password-test") d1 = self.connected.addCallback(strip(login)) d1.addErrback(self.assertClientFailureMessage, b"Server error: Whoops") @d1.addCallback def assertErrorLogged(_): self.assertTrue(self.flushLoggedErrors(UnexpectedException)) d1.addErrback(self._ebGeneral) d1.addBoth(self._cbStopClient) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestFailedLogin) def testLoginRequiringQuoting(self): self.server.checker.users = {b"{test}user": b"{test}password"} def login(): d = self.client.login(b"{test}user", b"{test}password") d.addErrback(log.err, "Problem with " + str(self)) d.addCallback(self._cbStopClient) d1 = self.connected.addCallback(strip(login)).addErrback(self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestLoginRequiringQuoting) def _cbTestLoginRequiringQuoting(self, ignored): self.assertEqual(self.server.account, SimpleServer.theAccount) self.assertEqual(self.server.state, "auth") def testNamespace(self): self.namespaceArgs = None def login(): return self.client.login(b"testuser", b"password-test") def namespace(): def gotNamespace(args): self.namespaceArgs = args self._cbStopClient(None) return self.client.namespace().addCallback(gotNamespace) d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(namespace)) d1.addErrback(self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) @d.addCallback def assertAllPairsNativeStrings(ignored): for namespaces in self.namespaceArgs: for pair in namespaces: for value in pair: self.assertIsInstance(value, str) return self.namespaceArgs d.addCallback(self.assertEqual, [[["", "/"]], [], []]) return d def test_mailboxWithoutNamespace(self): """ A mailbox that does not provide L{INamespacePresenter} returns empty L{list}s for its personal, shared, and user namespaces. """ self.server.theAccount = AccountWithoutNamespaces(b"testuser") self.namespaceArgs = None def login(): return self.client.login(b"testuser", b"password-test") def namespace(): def gotNamespace(args): self.namespaceArgs = args self._cbStopClient(None) return self.client.namespace().addCallback(gotNamespace) d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(namespace)) d1.addErrback(self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) d.addCallback(lambda _: self.namespaceArgs) d.addCallback(self.assertEqual, [[], [], []]) return d def testSelect(self): SimpleServer.theAccount.addMailbox("test-mailbox") self.selectedArgs = None def login(): return self.client.login(b"testuser", b"password-test") def select(): def selected(args): self.selectedArgs = args self._cbStopClient(None) d = self.client.select("test-mailbox") d.addCallback(selected) return d d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(select)) d1.addErrback(self._ebGeneral) d2 = self.loopback() return defer.gatherResults([d1, d2]).addCallback(self._cbTestSelect) def test_selectWithoutMailbox(self): """ A client that selects a mailbox that does not exist receives a C{NO} response. """ def login(): return self.client.login(b"testuser", b"password-test") def select(): return self.client.select("test-mailbox") self.connected.addCallback(strip(login)) self.connected.addCallback(strip(select)) self.connected.addErrback(self.assertClientFailureMessage, b"No such mailbox") self.connected.addCallback(self._cbStopClient) self.connected.addErrback(self._ebGeneral) connectionComplete = defer.gatherResults([self.connected, self.loopback()]) @connectionComplete.addCallback def assertNoMailboxSelected(_): self.assertIsNone(self.server.mbox) return connectionComplete def _cbTestSelect(self, ignored): mbox = SimpleServer.theAccount.mailboxes["TEST-MAILBOX"] self.assertEqual(self.server.mbox, mbox) self.assertEqual( self.selectedArgs, { "EXISTS": 9, "RECENT": 3, "UIDVALIDITY": 42, "FLAGS": ("\\Flag1", "Flag2", "\\AnotherSysFlag", "LastFlag"), "READ-WRITE": True, }, ) def test_examine(self): """ L{IMAP4Client.examine} issues an I{EXAMINE} command to the server and returns a L{Deferred} which fires with a C{dict} with as many of the following keys as the server includes in its response: C{'FLAGS'}, C{'EXISTS'}, C{'RECENT'}, C{'UNSEEN'}, C{'READ-WRITE'}, C{'READ-ONLY'}, C{'UIDVALIDITY'}, and C{'PERMANENTFLAGS'}. Unfortunately the server doesn't generate all of these so it's hard to test the client's handling of them here. See L{IMAP4ClientExamineTests} below. See U{RFC 3501<http://www.faqs.org/rfcs/rfc3501.html>}, section 6.3.2, for details. """ SimpleServer.theAccount.addMailbox("test-mailbox") self.examinedArgs = None def login(): return self.client.login(b"testuser", b"password-test") def examine(): def examined(args): self.examinedArgs = args self._cbStopClient(None) d = self.client.examine("test-mailbox") d.addCallback(examined) return d d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(examine)) d1.addErrback(self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestExamine) def _cbTestExamine(self, ignored): mbox = SimpleServer.theAccount.mailboxes["TEST-MAILBOX"] self.assertEqual(self.server.mbox, mbox) self.assertEqual( self.examinedArgs, { "EXISTS": 9, "RECENT": 3, "UIDVALIDITY": 42, "FLAGS": ("\\Flag1", "Flag2", "\\AnotherSysFlag", "LastFlag"), "READ-WRITE": False, }, ) def testCreate(self): succeed = ("testbox", "test/box", "test/", "test/box/box", "INBOX") fail = ("testbox", "test/box") def cb(): self.result.append(1) def eb(failure): self.result.append(0) def login(): return self.client.login(b"testuser", b"password-test") def create(): for name in succeed + fail: d = self.client.create(name) d.addCallback(strip(cb)).addErrback(eb) d.addCallbacks(self._cbStopClient, self._ebGeneral) self.result = [] d1 = self.connected.addCallback(strip(login)).addCallback(strip(create)) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestCreate, succeed, fail) def _cbTestCreate(self, ignored, succeed, fail): self.assertEqual(self.result, [1] * len(succeed) + [0] * len(fail)) mbox = sorted(SimpleServer.theAccount.mailboxes) answers = sorted(["inbox", "testbox", "test/box", "test", "test/box/box"]) self.assertEqual(mbox, [a.upper() for a in answers]) def testDelete(self): SimpleServer.theAccount.addMailbox("delete/me") def login(): return self.client.login(b"testuser", b"password-test") def delete(): return self.client.delete("delete/me") d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(delete), self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) d.addCallback( lambda _: self.assertEqual(list(SimpleServer.theAccount.mailboxes), []) ) return d def testDeleteWithInferiorHierarchicalNames(self): """ Attempting to delete a mailbox with hierarchically inferior names fails with an informative error. @see: U{https://tools.ietf.org/html/rfc3501#section-6.3.4} @return: A L{Deferred} with assertions. """ SimpleServer.theAccount.addMailbox("delete") SimpleServer.theAccount.addMailbox("delete/me") def login(): return self.client.login(b"testuser", b"password-test") def delete(): return self.client.delete("delete") def assertIMAPException(failure): failure.trap(imap4.IMAP4Exception) self.assertEqual( str(failure.value), str(b'Name "DELETE" has inferior hierarchical names'), ) loggedIn = self.connected.addCallback(strip(login)) loggedIn.addCallbacks(strip(delete), self._ebGeneral) loggedIn.addErrback(assertIMAPException) loggedIn.addCallbacks(self._cbStopClient) loopedBack = self.loopback() d = defer.gatherResults([loggedIn, loopedBack]) d.addCallback( lambda _: self.assertEqual( sorted(SimpleServer.theAccount.mailboxes), ["DELETE", "DELETE/ME"] ) ) return d def testIllegalInboxDelete(self): self.stashed = None def login(): return self.client.login(b"testuser", b"password-test") def delete(): return self.client.delete("inbox") def stash(result): self.stashed = result d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(delete), self._ebGeneral) d1.addBoth(stash) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) d.addCallback( lambda _: self.assertTrue(isinstance(self.stashed, failure.Failure)) ) return d def testNonExistentDelete(self): def login(): return self.client.login(b"testuser", b"password-test") def delete(): return self.client.delete("delete/me") def deleteFailed(failure): self.failure = failure self.failure = None d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(delete)).addErrback(deleteFailed) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) d.addCallback( lambda _: self.assertEqual(str(self.failure.value), str(b"No such mailbox")) ) return d def testIllegalDelete(self): m = SimpleMailbox() m.flags = (r"\Noselect",) SimpleServer.theAccount.addMailbox("delete", m) SimpleServer.theAccount.addMailbox("delete/me") def login(): return self.client.login(b"testuser", b"password-test") def delete(): return self.client.delete("delete") def deleteFailed(failure): self.failure = failure self.failure = None d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(delete)).addErrback(deleteFailed) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) expected = str( b"Hierarchically inferior mailboxes exist " b"and \\Noselect is set" ) d.addCallback(lambda _: self.assertEqual(str(self.failure.value), expected)) return d def testRename(self): SimpleServer.theAccount.addMailbox("oldmbox") def login(): return self.client.login(b"testuser", b"password-test") def rename(): return self.client.rename(b"oldmbox", b"newname") d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(rename), self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) d.addCallback( lambda _: self.assertEqual( list(SimpleServer.theAccount.mailboxes.keys()), ["NEWNAME"] ) ) return d def testIllegalInboxRename(self): self.stashed = None def login(): return self.client.login(b"testuser", b"password-test") def rename(): return self.client.rename("inbox", "frotz") def stash(stuff): self.stashed = stuff d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(rename), self._ebGeneral) d1.addBoth(stash) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) d.addCallback( lambda _: self.assertTrue(isinstance(self.stashed, failure.Failure)) ) return d def testHierarchicalRename(self): SimpleServer.theAccount.create("oldmbox/m1") SimpleServer.theAccount.create("oldmbox/m2") def login(): return self.client.login(b"testuser", b"password-test") def rename(): return self.client.rename("oldmbox", "newname") d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(rename), self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestHierarchicalRename) def _cbTestHierarchicalRename(self, ignored): mboxes = SimpleServer.theAccount.mailboxes.keys() expected = ["newname", "newname/m1", "newname/m2"] mboxes = list(sorted(mboxes)) self.assertEqual(mboxes, [s.upper() for s in expected]) def testSubscribe(self): def login(): return self.client.login(b"testuser", b"password-test") def subscribe(): return self.client.subscribe("this/mbox") d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(subscribe), self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) d.addCallback( lambda _: self.assertEqual( SimpleServer.theAccount.subscriptions, ["THIS/MBOX"] ) ) return d def testUnsubscribe(self): SimpleServer.theAccount.subscriptions = ["THIS/MBOX", "THAT/MBOX"] def login(): return self.client.login(b"testuser", b"password-test") def unsubscribe(): return self.client.unsubscribe("this/mbox") d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(unsubscribe), self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) d.addCallback( lambda _: self.assertEqual( SimpleServer.theAccount.subscriptions, ["THAT/MBOX"] ) ) return d def _listSetup(self, f): SimpleServer.theAccount.addMailbox("root/subthing") SimpleServer.theAccount.addMailbox("root/another-thing") SimpleServer.theAccount.addMailbox("non-root/subthing") def login(): return self.client.login(b"testuser", b"password-test") def listed(answers): self.listed = answers self.listed = None d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(f), self._ebGeneral) d1.addCallbacks(listed, self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() return defer.gatherResults([d1, d2]).addCallback(lambda _: self.listed) def assertListDelimiterAndMailboxAreStrings(self, results): """ Assert a C{LIST} response's delimiter and mailbox are native strings. @param results: A list of tuples as returned by L{IMAP4Client.list} or L{IMAP4Client.lsub}. """ for result in results: self.assertIsInstance(result[1], str, "delimiter %r is not a str") self.assertIsInstance(result[2], str, "mailbox %r is not a str") return results def testList(self): def mailboxList(): return self.client.list("root", "%") d = self._listSetup(mailboxList) @d.addCallback def assertListContents(listed): expectedContents = [ (sorted(SimpleMailbox.flags), "/", "ROOT/SUBTHING"), (sorted(SimpleMailbox.flags), "/", "ROOT/ANOTHER-THING"), ] for _ in range(2): flags, delimiter, mailbox = listed.pop(0) self.assertIn( (sorted(flags), delimiter, mailbox), expectedContents, ) self.assertFalse(listed, f"More results than expected: {listed!r}") return d def testLSub(self): SimpleServer.theAccount.subscribe("ROOT/SUBTHING") def lsub(): return self.client.lsub("root", "%") d = self._listSetup(lsub) d.addCallback(self.assertListDelimiterAndMailboxAreStrings) d.addCallback(self.assertEqual, [(SimpleMailbox.flags, "/", "ROOT/SUBTHING")]) return d def testStatus(self): SimpleServer.theAccount.addMailbox("root/subthing") def login(): return self.client.login(b"testuser", b"password-test") def status(): return self.client.status("root/subthing", "MESSAGES", "UIDNEXT", "UNSEEN") def statused(result): self.statused = result self.statused = None d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(status), self._ebGeneral) d1.addCallbacks(statused, self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) d.addCallback( lambda _: self.assertEqual( self.statused, {"MESSAGES": 9, "UIDNEXT": b"10", "UNSEEN": 4} ) ) return d def testFailedStatus(self): def login(): return self.client.login(b"testuser", b"password-test") def status(): return self.client.status( "root/nonexistent", "MESSAGES", "UIDNEXT", "UNSEEN" ) def statused(result): self.statused = result def failed(failure): self.failure = failure self.statused = self.failure = None d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(status), self._ebGeneral) d1.addCallbacks(statused, failed) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() return defer.gatherResults([d1, d2]).addCallback(self._cbTestFailedStatus) def _cbTestFailedStatus(self, ignored): self.assertEqual(self.statused, None) self.assertEqual(self.failure.value.args, (b"Could not open mailbox",)) def testFullAppend(self): infile = util.sibpath(__file__, "rfc822.message") SimpleServer.theAccount.addMailbox("root/subthing") def login(): return self.client.login(b"testuser", b"password-test") @defer.inlineCallbacks def append(): with open(infile, "rb") as message: result = yield self.client.append( "root/subthing", message, ("\\SEEN", "\\DELETED"), "Tue, 17 Jun 2003 11:22:16 -0600 (MDT)", ) defer.returnValue(result) d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(append), self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestFullAppend, infile) def _cbTestFullAppend(self, ignored, infile): mb = SimpleServer.theAccount.mailboxes["ROOT/SUBTHING"] self.assertEqual(1, len(mb.messages)) self.assertEqual( (["\\SEEN", "\\DELETED"], b"Tue, 17 Jun 2003 11:22:16 -0600 (MDT)", 0), mb.messages[0][1:], ) with open(infile, "rb") as f: self.assertEqual(f.read(), mb.messages[0][0].getvalue()) def testPartialAppend(self): infile = util.sibpath(__file__, "rfc822.message") SimpleServer.theAccount.addMailbox("PARTIAL/SUBTHING") def login(): return self.client.login(b"testuser", b"password-test") @defer.inlineCallbacks def append(): with open(infile, "rb") as message: result = yield self.client.sendCommand( imap4.Command( b"APPEND", # Using networkString is cheating! In this # particular case the mailbox name happens to # be ASCII. In real code, the mailbox would # be encoded with imap4-utf-7. networkString( "PARTIAL/SUBTHING " '(\\SEEN) "Right now" ' "{%d}" % (os.path.getsize(infile),) ), (), self.client._IMAP4Client__cbContinueAppend, message, ) ) defer.returnValue(result) d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(append), self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestPartialAppend, infile) def _cbTestPartialAppend(self, ignored, infile): mb = SimpleServer.theAccount.mailboxes["PARTIAL/SUBTHING"] self.assertEqual(1, len(mb.messages)) self.assertEqual((["\\SEEN"], b"Right now", 0), mb.messages[0][1:]) with open(infile, "rb") as f: self.assertEqual(f.read(), mb.messages[0][0].getvalue()) def _testCheck(self): SimpleServer.theAccount.addMailbox(b"root/subthing") def login(): return self.client.login(b"testuser", b"password-test") def select(): return self.client.select(b"root/subthing") def check(): return self.client.check() d = self.connected.addCallback(strip(login)) d.addCallbacks(strip(select), self._ebGeneral) d.addCallbacks(strip(check), self._ebGeneral) d.addCallbacks(self._cbStopClient, self._ebGeneral) return self.loopback() def test_check(self): """ Trigger the L{imap.IMAP4Server._cbSelectWork} callback by selecting an mbox. """ return self._testCheck() def test_checkFail(self): """ Trigger the L{imap.IMAP4Server._ebSelectWork} errback by failing when we select an mbox. """ def failSelect(self, name, rw=1): raise imap4.IllegalMailboxEncoding("encoding") def checkResponse(ignore): failures = self.flushLoggedErrors() self.assertEqual(failures[1].value.args[0], b"SELECT failed: Server error") self.patch(Account, "select", failSelect) d = self._testCheck() return d.addCallback(checkResponse) def testClose(self): m = SimpleMailbox() m.messages = [ (b"Message 1", ("\\Deleted", "AnotherFlag"), None, 0), (b"Message 2", ("AnotherFlag",), None, 1), (b"Message 3", ("\\Deleted",), None, 2), ] SimpleServer.theAccount.addMailbox("mailbox", m) def login(): return self.client.login(b"testuser", b"password-test") def select(): return self.client.select(b"mailbox") def close(): return self.client.close() d = self.connected.addCallback(strip(login)) d.addCallbacks(strip(select), self._ebGeneral) d.addCallbacks(strip(close), self._ebGeneral) d.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() return defer.gatherResults([d, d2]).addCallback(self._cbTestClose, m) def _cbTestClose(self, ignored, m): self.assertEqual(len(m.messages), 1) self.assertEqual(m.messages[0], (b"Message 2", ("AnotherFlag",), None, 1)) self.assertTrue(m.closed) def testExpunge(self): m = SimpleMailbox() m.messages = [ (b"Message 1", ("\\Deleted", "AnotherFlag"), None, 0), (b"Message 2", ("AnotherFlag",), None, 1), (b"Message 3", ("\\Deleted",), None, 2), ] SimpleServer.theAccount.addMailbox("mailbox", m) def login(): return self.client.login(b"testuser", b"password-test") def select(): return self.client.select("mailbox") def expunge(): return self.client.expunge() def expunged(results): self.assertFalse(self.server.mbox is None) self.results = results self.results = None d1 = self.connected.addCallback(strip(login)) d1.addCallbacks(strip(select), self._ebGeneral) d1.addCallbacks(strip(expunge), self._ebGeneral) d1.addCallbacks(expunged, self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestExpunge, m) def _cbTestExpunge(self, ignored, m): self.assertEqual(len(m.messages), 1) self.assertEqual(m.messages[0], (b"Message 2", ("AnotherFlag",), None, 1)) self.assertEqual(self.results, [0, 2]) class IMAP4ServerParsingTests(SynchronousTestCase): """ Test L{imap4.IMAP4Server}'s command parsing. """ def setUp(self): self.transport = StringTransport() self.server = imap4.IMAP4Server() self.server.makeConnection(self.transport) self.transport.clear() def tearDown(self): self.server.connectionLost(failure.Failure(error.ConnectionDone())) def test_parseMethodExceptionLogged(self): """ L{imap4.IMAP4Server} logs exceptions raised by parse methods. """ class UnhandledException(Exception): """ An unhandled exception. """ def raisesValueError(line): raise UnhandledException self.server.parseState = "command" self.server.parse_command = raisesValueError self.server.lineReceived(b"invalid") self.assertTrue(self.flushLoggedErrors(UnhandledException)) def test_missingCommand(self): """ L{imap4.IMAP4Server.parse_command} sends a C{BAD} response to a line that includes a tag but no command. """ self.server.parse_command(b"001") self.assertEqual(self.transport.value(), b"001 BAD Missing command\r\n") self.server.connectionLost( failure.Failure(error.ConnectionDone("Done")), ) def test_emptyLine(self): """ L{imap4.IMAP4Server.parse_command} sends a C{BAD} response to an empty line. """ self.server.parse_command(b"") self.assertEqual(self.transport.value(), b"* BAD Null command\r\n") def assertParseExceptionResponse(self, exception, tag, expectedResponse): """ Assert that the given exception results in the expected response. @param exception: The exception to raise. @type exception: L{Exception} @param tag: The IMAP tag. @type: L{bytes} @param expectedResponse: The expected bad response. @type expectedResponse: L{bytes} """ def raises(tag, cmd, rest): raise exception self.server.dispatchCommand = raises self.server.parse_command(b" ".join([tag, b"invalid"])) self.assertEqual(self.transport.value(), b" ".join([tag, expectedResponse])) def test_parsingRaisesIllegalClientResponse(self): """ When a parsing method raises L{IllegalClientResponse}, the server sends a C{BAD} response. """ self.assertParseExceptionResponse( imap4.IllegalClientResponse("client response"), b"001", b"BAD Illegal syntax: client response\r\n", ) def test_parsingRaisesIllegalOperationResponse(self): """ When a parsing method raises L{IllegalOperation}, the server sends a C{NO} response. """ self.assertParseExceptionResponse( imap4.IllegalOperation("operation"), b"001", b"NO Illegal operation: operation\r\n", ) def test_parsingRaisesIllegalMailboxEncoding(self): """ When a parsing method raises L{IllegalMailboxEncoding}, the server sends a C{NO} response. """ self.assertParseExceptionResponse( imap4.IllegalMailboxEncoding("encoding"), b"001", b"NO Illegal mailbox name: encoding\r\n", ) def test_unsupportedCommand(self): """ L{imap4.IMAP4Server} responds to an unsupported command with a C{BAD} response. """ self.server.lineReceived(b"001 HULLABALOO") self.assertEqual(self.transport.value(), b"001 BAD Unsupported command\r\n") def test_tooManyArgumentsForCommand(self): """ L{imap4.IMAP4Server} responds with a C{BAD} response to a command with more arguments than expected. """ self.server.lineReceived(b"001 LOGIN A B C") self.assertEqual( self.transport.value(), ( b"001 BAD Illegal syntax:" + b" Too many arguments for command: " + repr(b"C").encode("utf-8") + b"\r\n" ), ) def assertCommandExceptionResponse(self, exception, tag, expectedResponse): """ Assert that the given exception results in the expected response. @param exception: The exception to raise. @type exception: L{Exception} @param: The IMAP tag. @type: L{bytes} @param expectedResponse: The expected bad response. @type expectedResponse: L{bytes} """ def raises(serverInstance, tag, user, passwd): raise exception self.assertEqual(self.server.state, "unauth") self.server.unauth_LOGIN = (raises,) + self.server.unauth_LOGIN[1:] self.server.dispatchCommand(tag, b"LOGIN", b"user passwd") self.assertEqual(self.transport.value(), b" ".join([tag, expectedResponse])) def test_commandRaisesIllegalClientResponse(self): """ When a command raises L{IllegalClientResponse}, the server sends a C{BAD} response. """ self.assertCommandExceptionResponse( imap4.IllegalClientResponse("client response"), b"001", b"BAD Illegal syntax: client response\r\n", ) def test_commandRaisesIllegalOperationResponse(self): """ When a command raises L{IllegalOperation}, the server sends a C{NO} response. """ self.assertCommandExceptionResponse( imap4.IllegalOperation("operation"), b"001", b"NO Illegal operation: operation\r\n", ) def test_commandRaisesIllegalMailboxEncoding(self): """ When a command raises L{IllegalMailboxEncoding}, the server sends a C{NO} response. """ self.assertCommandExceptionResponse( imap4.IllegalMailboxEncoding("encoding"), b"001", b"NO Illegal mailbox name: encoding\r\n", ) def test_commandRaisesUnhandledException(self): """ Wehn a command raises an unhandled exception, the server sends a C{BAD} response and logs the exception. """ class UnhandledException(Exception): """ An unhandled exception. """ self.assertCommandExceptionResponse( UnhandledException("unhandled"), b"001", b"BAD Server error: unhandled\r\n", ) self.assertTrue(self.flushLoggedErrors(UnhandledException)) def test_stringLiteralTooLong(self): """ A string literal whose length exceeds the maximum allowed length results in a C{BAD} response. """ self.server._literalStringLimit = 4 self.server.lineReceived(b"001 LOGIN {5}\r\n") self.assertEqual( self.transport.value(), b"001 BAD Illegal syntax: Literal too long!" b" I accept at most 4 octets\r\n", ) def test_arg_astringEmptyLine(self): """ An empty string argument raises L{imap4.IllegalClientResponse}. """ for empty in [b"", b"\r\n", b" "]: self.assertRaises( imap4.IllegalClientResponse, self.server.arg_astring, empty ) def test_arg_astringUnmatchedQuotes(self): """ An unmatched quote in a string argument raises L{imap4.IllegalClientResponse}. """ self.assertRaises( imap4.IllegalClientResponse, self.server.arg_astring, b'"open' ) def test_arg_astringUnmatchedLiteralBraces(self): """ An unmatched brace in a string literal's size raises L{imap4.IllegalClientResponse}. """ self.assertRaises(imap4.IllegalClientResponse, self.server.arg_astring, b"{0") def test_arg_astringInvalidLiteralSize(self): """ A non-integral string literal size raises L{imap4.IllegalClientResponse}. """ self.assertRaises( imap4.IllegalClientResponse, self.server.arg_astring, b"{[object Object]}" ) def test_arg_atomEmptyLine(self): """ An empty atom raises L{IllegalClientResponse}. """ self.assertRaises(imap4.IllegalClientResponse, self.server.arg_atom, b"") def test_arg_atomMalformedAtom(self): """ A malformed atom raises L{IllegalClientResponse}. """ self.assertRaises( imap4.IllegalClientResponse, self.server.arg_atom, b" not an atom " ) def test_arg_plistEmptyLine(self): """ An empty parenthesized list raises L{IllegalClientResponse}. """ self.assertRaises(imap4.IllegalClientResponse, self.server.arg_plist, b"") def test_arg_plistUnmatchedParentheses(self): """ A parenthesized with unmatched parentheses raises L{IllegalClientResponse}. """ self.assertRaises(imap4.IllegalClientResponse, self.server.arg_plist, b"(foo") self.assertRaises(imap4.IllegalClientResponse, self.server.arg_plist, b"foo)") def test_arg_literalEmptyLine(self): """ An empty file literal raises L{IllegalClientResponse}. """ self.assertRaises(imap4.IllegalClientResponse, self.server.arg_literal, b"") def test_arg_literalUnmatchedBraces(self): """ A literal with unmatched braces raises L{IllegalClientResponse}. """ self.assertRaises(imap4.IllegalClientResponse, self.server.arg_literal, b"{10") self.assertRaises(imap4.IllegalClientResponse, self.server.arg_literal, b"10}") def test_arg_literalInvalidLiteralSize(self): """ A non-integral literal size raises L{imap4.IllegalClientResponse}. """ self.assertRaises( imap4.IllegalClientResponse, self.server.arg_literal, b"{[object Object]}" ) def test_arg_seqsetReturnsRest(self): """ A sequence set returns the unparsed portion of a line. """ sequence = b"1:* blah blah blah" _, rest = self.server.arg_seqset(sequence) self.assertEqual(rest, b"blah blah blah") def test_arg_seqsetInvalidSequence(self): """ An invalid sequence raises L{imap4.IllegalClientResponse}. """ self.assertRaises(imap4.IllegalClientResponse, self.server.arg_seqset, b"x:y") def test_arg_flaglistOneFlag(self): """ A single flag that is not contained in a list is parsed. """ flag = b"flag" parsed, rest = self.server.arg_flaglist(flag) self.assertEqual(parsed, [flag]) self.assertFalse(rest) def test_arg_flaglistMismatchedParentehses(self): """ A list of flags with unmatched parentheses raises L{imap4.IllegalClientResponse}. """ self.assertRaises( imap4.IllegalClientResponse, self.server.arg_flaglist, b"(invalid", ) def test_arg_flaglistMalformedFlag(self): """ A list of flags that contains a malformed flag raises L{imap4.IllegalClientResponse}. """ self.assertRaises( imap4.IllegalClientResponse, self.server.arg_flaglist, b"(first \x00)" ) self.assertRaises( imap4.IllegalClientResponse, self.server.arg_flaglist, b"(first \x00second)" ) def test_opt_plistMissingOpenParenthesis(self): """ A line that does not begin with an open parenthesis (C{(}) is parsed as L{None}, and the remainder is the whole line. """ line = b"not (" plist, remainder = self.server.opt_plist(line) self.assertIsNone(plist) self.assertEqual(remainder, line) def test_opt_datetimeMissingOpenQuote(self): """ A line that does not begin with a double quote (C{"}) is parsed as L{None}, and the remainder is the whole line. """ line = b'not "' dt, remainder = self.server.opt_datetime(line) self.assertIsNone(dt) self.assertEqual(remainder, line) def test_opt_datetimeMissingCloseQuote(self): """ A line that does not have a closing double quote (C{"}) raises L{imap4.IllegalClientResponse}. """ line = b'"21-Jul-2017 19:37:07 -0700' self.assertRaises(imap4.IllegalClientResponse, self.server.opt_datetime, line) def test_opt_charsetMissingIdentifier(self): """ A line that contains C{CHARSET} but no character set identifier raises L{imap4.IllegalClientResponse}. """ line = b"CHARSET" self.assertRaises(imap4.IllegalClientResponse, self.server.opt_charset, line) def test_opt_charsetEndOfLine(self): """ A line that ends with a C{CHARSET} identifier is parsed as that identifier, and the remainder is the empty string. """ line = b"CHARSET UTF-8" identifier, remainder = self.server.opt_charset(line) self.assertEqual(identifier, b"UTF-8") self.assertEqual(remainder, b"") def test_opt_charsetWithRemainder(self): """ A line that has additional data after a C{CHARSET} identifier is parsed as that identifier, and the remainder is that additional data. """ line = b"CHARSET UTF-8 remainder" identifier, remainder = self.server.opt_charset(line) self.assertEqual(identifier, b"UTF-8") self.assertEqual(remainder, b"remainder") class IMAP4ServerSearchTests(IMAP4HelperMixin, TestCase): """ Tests for the behavior of the search_* functions in L{imap4.IMAP4Server}. """ def setUp(self): IMAP4HelperMixin.setUp(self) self.earlierQuery = ["10-Dec-2009"] self.sameDateQuery = ["13-Dec-2009"] self.laterQuery = ["16-Dec-2009"] self.seq = 0 self.msg = FakeyMessage( {"date": "Mon, 13 Dec 2009 21:25:10 GMT"}, [], "13 Dec 2009 00:00:00 GMT", "", 1234, None, ) def test_searchSentBefore(self): """ L{imap4.IMAP4Server.search_SENTBEFORE} returns True if the message date is earlier than the query date. """ self.assertFalse( self.server.search_SENTBEFORE(self.earlierQuery, self.seq, self.msg) ) self.assertTrue( self.server.search_SENTBEFORE(self.laterQuery, self.seq, self.msg) ) def test_searchWildcard(self): """ L{imap4.IMAP4Server.search_UID} returns True if the message UID is in the search range. """ self.assertFalse( self.server.search_UID([b"2:3"], self.seq, self.msg, (1, 1234)) ) # 2:* should get translated to 2:<max UID> and then to 1:2 self.assertTrue(self.server.search_UID([b"2:*"], self.seq, self.msg, (1, 1234))) self.assertTrue(self.server.search_UID([b"*"], self.seq, self.msg, (1, 1234))) def test_searchWildcardHigh(self): """ L{imap4.IMAP4Server.search_UID} should return True if there is a wildcard, because a wildcard means "highest UID in the mailbox". """ self.assertTrue( self.server.search_UID([b"1235:*"], self.seq, self.msg, (1234, 1)) ) def test_reversedSearchTerms(self): """ L{imap4.IMAP4Server.search_SENTON} returns True if the message date is the same as the query date. """ msgset = imap4.parseIdList(b"4:2") self.assertEqual(list(msgset), [2, 3, 4]) def test_searchSentOn(self): """ L{imap4.IMAP4Server.search_SENTON} returns True if the message date is the same as the query date. """ self.assertFalse( self.server.search_SENTON(self.earlierQuery, self.seq, self.msg) ) self.assertTrue( self.server.search_SENTON(self.sameDateQuery, self.seq, self.msg) ) self.assertFalse(self.server.search_SENTON(self.laterQuery, self.seq, self.msg)) def test_searchSentSince(self): """ L{imap4.IMAP4Server.search_SENTSINCE} returns True if the message date is later than the query date. """ self.assertTrue( self.server.search_SENTSINCE(self.earlierQuery, self.seq, self.msg) ) self.assertFalse( self.server.search_SENTSINCE(self.laterQuery, self.seq, self.msg) ) def test_searchOr(self): """ L{imap4.IMAP4Server.search_OR} returns true if either of the two expressions supplied to it returns true and returns false if neither does. """ self.assertTrue( self.server.search_OR( ["SENTSINCE"] + self.earlierQuery + ["SENTSINCE"] + self.laterQuery, self.seq, self.msg, (None, None), ) ) self.assertTrue( self.server.search_OR( ["SENTSINCE"] + self.laterQuery + ["SENTSINCE"] + self.earlierQuery, self.seq, self.msg, (None, None), ) ) self.assertFalse( self.server.search_OR( ["SENTON"] + self.laterQuery + ["SENTSINCE"] + self.laterQuery, self.seq, self.msg, (None, None), ) ) def test_searchNot(self): """ L{imap4.IMAP4Server.search_NOT} returns the negation of the result of the expression supplied to it. """ self.assertFalse( self.server.search_NOT( ["SENTSINCE"] + self.earlierQuery, self.seq, self.msg, (None, None) ) ) self.assertTrue( self.server.search_NOT( ["SENTON"] + self.laterQuery, self.seq, self.msg, (None, None) ) ) def test_searchBefore(self): """ L{imap4.IMAP4Server.search_BEFORE} returns True if the internal message date is before the query date. """ self.assertFalse( self.server.search_BEFORE(self.earlierQuery, self.seq, self.msg) ) self.assertFalse( self.server.search_BEFORE(self.sameDateQuery, self.seq, self.msg) ) self.assertTrue(self.server.search_BEFORE(self.laterQuery, self.seq, self.msg)) def test_searchOn(self): """ L{imap4.IMAP4Server.search_ON} returns True if the internal message date is the same as the query date. """ self.assertFalse(self.server.search_ON(self.earlierQuery, self.seq, self.msg)) self.assertFalse(self.server.search_ON(self.sameDateQuery, self.seq, self.msg)) self.assertFalse(self.server.search_ON(self.laterQuery, self.seq, self.msg)) def test_searchSince(self): """ L{imap4.IMAP4Server.search_SINCE} returns True if the internal message date is greater than the query date. """ self.assertTrue(self.server.search_SINCE(self.earlierQuery, self.seq, self.msg)) self.assertTrue( self.server.search_SINCE(self.sameDateQuery, self.seq, self.msg) ) self.assertFalse(self.server.search_SINCE(self.laterQuery, self.seq, self.msg)) @implementer(IRealm) class TestRealm: """ A L{IRealm} for tests. @cvar theAccount: An C{Account} instance. Tests can set this to ensure predictable account retrieval. """ theAccount = None def __init__(self, accountHolder=None): """ Create a realm for testing. @param accountHolder: (optional) An object whose C{theAccount} attribute will be returned instead of L{TestRealm.theAccount}. Attribute access occurs on every avatar request, so any modifications to C{accountHolder.theAccount} will be reflected here. """ if accountHolder: self._getAccount = lambda: accountHolder.theAccount else: self._getAccount = lambda: self.theAccount def requestAvatar(self, avatarId, mind, *interfaces): return imap4.IAccount, self._getAccount(), lambda: None class TestChecker: credentialInterfaces = (IUsernameHashedPassword, IUsernamePassword) users = {b"testuser": b"secret"} def requestAvatarId(self, credentials): if credentials.username in self.users: return defer.maybeDeferred( credentials.checkPassword, self.users[credentials.username] ).addCallback(self._cbCheck, credentials.username) def _cbCheck(self, result, username): if result: return username raise UnauthorizedLogin() class AuthenticatorTests(IMAP4HelperMixin, TestCase): def setUp(self): IMAP4HelperMixin.setUp(self) realm = TestRealm() realm.theAccount = Account(b"testuser") self.portal = Portal(realm) self.portal.registerChecker(TestChecker()) self.server.portal = self.portal self.authenticated = 0 self.account = realm.theAccount def test_customChallengers(self): """ L{imap4.IMAP4Server} accepts a L{dict} mapping challenge type names to L{twisted.mail.interfaces.IChallengeResponse} providers. """ @implementer(IChallengeResponse, IUsernamePassword) class SPECIALAuth: def getChallenge(self): return b"SPECIAL" def setResponse(self, response): self.username, self.password = response.split(None, 1) def moreChallenges(self): return False def checkPassword(self, password): self.password = self.password special = SPECIALAuth() verifyObject(IChallengeResponse, special) server = imap4.IMAP4Server({b"SPECIAL": SPECIALAuth}) server.portal = self.portal transport = StringTransport() server.makeConnection(transport) self.addCleanup(server.connectionLost, error.ConnectionDone("Connection done.")) self.assertIn(b"AUTH=SPECIAL", transport.value()) transport.clear() server.dataReceived(b"001 AUTHENTICATE SPECIAL\r\n") self.assertIn(base64.b64encode(special.getChallenge()), transport.value()) transport.clear() server.dataReceived(base64.b64encode(b"username password") + b"\r\n") self.assertEqual(transport.value(), b"001 OK Authentication successful\r\n") def test_unsupportedMethod(self): """ An unsupported C{AUTHENTICATE} method results in a negative response. """ server = imap4.IMAP4Server() server.portal = self.portal transport = StringTransport() server.makeConnection(transport) self.addCleanup(server.connectionLost, error.ConnectionDone("Connection done.")) transport.clear() server.dataReceived(b"001 AUTHENTICATE UNKNOWN\r\n") self.assertEqual( transport.value(), b"001 NO AUTHENTICATE method unsupported\r\n" ) def test_missingPortal(self): """ An L{imap4.IMAP4Server} that is missing a L{Portal} responds negatively to an authentication """ self.server.challengers[b"LOGIN"] = imap4.LOGINCredentials cAuth = imap4.LOGINAuthenticator(b"testuser") self.client.registerAuthenticator(cAuth) self.server.portal = None def auth(): return self.client.authenticate(b"secret") d = self.connected.addCallback(strip(auth)) d.addErrback( self.assertClientFailureMessage, b"Temporary authentication failure" ) d.addCallbacks(self._cbStopClient, self._ebGeneral) return defer.gatherResults([d, self.loopback()]) def test_challengerRaisesException(self): """ When a challenger's L{getChallenge<IChallengeResponse.getChallenge>} method raises any exception, a C{NO} response is sent. """ @implementer(IChallengeResponse) class ValueErrorAuthChallenge: message = b"A challenge failure" def getChallenge(self): raise ValueError(self.message) def setResponse(self, response): """ Never called. @param response: See L{IChallengeResponse.setResponse} """ def moreChallenges(self): """ Never called. """ @implementer(IClientAuthentication) class ValueErrorAuthenticator: def getName(self): return b"ERROR" def challengeResponse(self, secret, chal): return b"IGNORED" bad = ValueErrorAuthChallenge() verifyObject(IChallengeResponse, bad) self.server.challengers[b"ERROR"] = ValueErrorAuthChallenge self.client.registerAuthenticator(ValueErrorAuthenticator()) def auth(): return self.client.authenticate(b"secret") d = self.connected.addCallback(strip(auth)) d.addErrback( self.assertClientFailureMessage, ("Server error: " + str(ValueErrorAuthChallenge.message)).encode("ascii"), ) d.addCallbacks(self._cbStopClient, self._ebGeneral) return defer.gatherResults([d, self.loopback()]) def test_authNotBase64(self): """ A client that responds with a challenge that cannot be decoded as Base 64 receives an L{IllegalClientResponse}. """ @implementer(IChallengeResponse) class NotBase64AuthChallenge: message = b"Malformed Response - not base64" def getChallenge(self): return b"SomeChallenge" def setResponse(self, response): """ Never called. @param response: See L{IChallengeResponse.setResponse} """ def moreChallenges(self): """ Never called. """ notBase64 = NotBase64AuthChallenge() verifyObject(IChallengeResponse, notBase64) server = imap4.IMAP4Server() server.portal = self.portal server.challengers[b"NOTBASE64"] = NotBase64AuthChallenge transport = StringTransport() server.makeConnection(transport) self.addCleanup(server.connectionLost, error.ConnectionDone("Connection done.")) self.assertIn(b"AUTH=NOTBASE64", transport.value()) transport.clear() server.dataReceived(b"001 AUTHENTICATE NOTBASE64\r\n") self.assertIn(base64.b64encode(notBase64.getChallenge()), transport.value()) transport.clear() server.dataReceived(b"\x00 Not base64\r\n") self.assertEqual( transport.value(), b"".join([b"001 NO Authentication failed: ", notBase64.message, b"\r\n"]), ) def test_unhandledCredentials(self): """ A challenger that causes the login to fail L{UnhandledCredentials} results in an C{NO} response. @return: A L{Deferred} that fires when the authorization has failed. """ realm = TestRealm() portal = Portal(realm) # This portal has no checkers, so all logins will fail with # UnhandledCredentials self.server.portal = portal self.server.challengers[b"LOGIN"] = loginCred = imap4.LOGINCredentials verifyClass(IChallengeResponse, loginCred) cAuth = imap4.LOGINAuthenticator(b"testuser") self.client.registerAuthenticator(cAuth) def auth(): return self.client.authenticate(b"secret") d1 = self.connected.addCallback(strip(auth)) d1.addErrback( self.assertClientFailureMessage, b"Authentication failed: server misconfigured", ) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d def test_unexpectedLoginFailure(self): """ If the portal raises an exception other than L{UnauthorizedLogin} or L{UnhandledCredentials}, the server responds with a C{BAD} response and the exception is logged. """ class UnexpectedException(Exception): """ An unexpected exception. """ class FailingChecker: """ A credentials checker whose L{requestAvatarId} method raises L{UnexpectedException}. """ credentialInterfaces = (IUsernameHashedPassword, IUsernamePassword) def requestAvatarId(self, credentials): raise UnexpectedException("Unexpected error.") realm = TestRealm() portal = Portal(realm) portal.registerChecker(FailingChecker()) self.server.portal = portal self.server.challengers[b"LOGIN"] = loginCred = imap4.LOGINCredentials verifyClass(IChallengeResponse, loginCred) cAuth = imap4.LOGINAuthenticator(b"testuser") self.client.registerAuthenticator(cAuth) def auth(): return self.client.authenticate(b"secret") def assertUnexpectedExceptionLogged(): self.assertTrue(self.flushLoggedErrors(UnexpectedException)) d1 = self.connected.addCallback(strip(auth)) d1.addErrback( self.assertClientFailureMessage, b"Server error: login failed unexpectedly" ) d1.addCallback(strip(assertUnexpectedExceptionLogged)) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d def testCramMD5(self): self.server.challengers[b"CRAM-MD5"] = CramMD5Credentials cAuth = imap4.CramMD5ClientAuthenticator(b"testuser") self.client.registerAuthenticator(cAuth) def auth(): return self.client.authenticate(b"secret") def authed(): self.authenticated = 1 d1 = self.connected.addCallback(strip(auth)) d1.addCallbacks(strip(authed), self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d2 = self.loopback() d = defer.gatherResults([d1, d2]) return d.addCallback(self._cbTestCramMD5) def _cbTestCramMD5(self, ignored): self.assertEqual(self.authenticated, 1) self.assertEqual(self.server.account, self.account) def testFailedCramMD5(self): self.server.challengers[b"CRAM-MD5"] = CramMD5Credentials cAuth = imap4.CramMD5ClientAuthenticator(b"testuser") self.client.registerAuthenticator(cAuth) def misauth(): return self.client.authenticate(b"not the secret") def authed(): self.authenticated = 1 def misauthed(): self.authenticated = -1 d1 = self.connected.addCallback(strip(misauth)) d1.addCallbacks(strip(authed), strip(misauthed)) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestFailedCramMD5) def _cbTestFailedCramMD5(self, ignored): self.assertEqual(self.authenticated, -1) self.assertEqual(self.server.account, None) def testLOGIN(self): self.server.challengers[b"LOGIN"] = loginCred = imap4.LOGINCredentials verifyClass(IChallengeResponse, loginCred) cAuth = imap4.LOGINAuthenticator(b"testuser") self.client.registerAuthenticator(cAuth) def auth(): return self.client.authenticate(b"secret") def authed(): self.authenticated = 1 d1 = self.connected.addCallback(strip(auth)) d1.addCallbacks(strip(authed), self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestLOGIN) def _cbTestLOGIN(self, ignored): self.assertEqual(self.authenticated, 1) self.assertEqual(self.server.account, self.account) def testFailedLOGIN(self): self.server.challengers[b"LOGIN"] = imap4.LOGINCredentials cAuth = imap4.LOGINAuthenticator(b"testuser") self.client.registerAuthenticator(cAuth) def misauth(): return self.client.authenticate(b"not the secret") def authed(): self.authenticated = 1 def misauthed(): self.authenticated = -1 d1 = self.connected.addCallback(strip(misauth)) d1.addCallbacks(strip(authed), strip(misauthed)) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestFailedLOGIN) def _cbTestFailedLOGIN(self, ignored): self.assertEqual(self.authenticated, -1) self.assertEqual(self.server.account, None) def testPLAIN(self): self.server.challengers[b"PLAIN"] = plainCred = imap4.PLAINCredentials verifyClass(IChallengeResponse, plainCred) cAuth = imap4.PLAINAuthenticator(b"testuser") self.client.registerAuthenticator(cAuth) def auth(): return self.client.authenticate(b"secret") def authed(): self.authenticated = 1 d1 = self.connected.addCallback(strip(auth)) d1.addCallbacks(strip(authed), self._ebGeneral) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestPLAIN) def _cbTestPLAIN(self, ignored): self.assertEqual(self.authenticated, 1) self.assertEqual(self.server.account, self.account) def testFailedPLAIN(self): self.server.challengers[b"PLAIN"] = imap4.PLAINCredentials cAuth = imap4.PLAINAuthenticator(b"testuser") self.client.registerAuthenticator(cAuth) def misauth(): return self.client.authenticate(b"not the secret") def authed(): self.authenticated = 1 def misauthed(): self.authenticated = -1 d1 = self.connected.addCallback(strip(misauth)) d1.addCallbacks(strip(authed), strip(misauthed)) d1.addCallbacks(self._cbStopClient, self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestFailedPLAIN) def _cbTestFailedPLAIN(self, ignored): self.assertEqual(self.authenticated, -1) self.assertEqual(self.server.account, None) class SASLPLAINTests(TestCase): """ Tests for I{SASL PLAIN} authentication, as implemented by L{imap4.PLAINAuthenticator} and L{imap4.PLAINCredentials}. @see: U{http://www.faqs.org/rfcs/rfc2595.html} @see: U{http://www.faqs.org/rfcs/rfc4616.html} """ def test_authenticatorChallengeResponse(self): """ L{PLAINAuthenticator.challengeResponse} returns challenge strings of the form:: NUL<authn-id>NUL<secret> """ username = b"testuser" secret = b"secret" chal = b"challenge" cAuth = imap4.PLAINAuthenticator(username) response = cAuth.challengeResponse(secret, chal) self.assertEqual(response, b"\0" + username + b"\0" + secret) def test_credentialsSetResponse(self): """ L{PLAINCredentials.setResponse} parses challenge strings of the form:: NUL<authn-id>NUL<secret> """ cred = imap4.PLAINCredentials() cred.setResponse(b"\0testuser\0secret") self.assertEqual(cred.username, b"testuser") self.assertEqual(cred.password, b"secret") def test_credentialsInvalidResponse(self): """ L{PLAINCredentials.setResponse} raises L{imap4.IllegalClientResponse} when passed a string not of the expected form. """ cred = imap4.PLAINCredentials() self.assertRaises(imap4.IllegalClientResponse, cred.setResponse, b"hello") self.assertRaises( imap4.IllegalClientResponse, cred.setResponse, b"hello\0world" ) self.assertRaises( imap4.IllegalClientResponse, cred.setResponse, b"hello\0world\0Zoom!\0" ) class UnsolicitedResponseTests(IMAP4HelperMixin, TestCase): def testReadWrite(self): def login(): return self.client.login(b"testuser", b"password-test") def loggedIn(): self.server.modeChanged(1) d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(loggedIn)).addErrback(self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestReadWrite) def _cbTestReadWrite(self, ignored): E = self.client.events self.assertEqual(E, [["modeChanged", 1]]) def testReadOnly(self): def login(): return self.client.login(b"testuser", b"password-test") def loggedIn(): self.server.modeChanged(0) d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(loggedIn)).addErrback(self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestReadOnly) def _cbTestReadOnly(self, ignored): E = self.client.events self.assertEqual(E, [["modeChanged", 0]]) def testFlagChange(self): flags = {1: ["\\Answered", "\\Deleted"], 5: [], 10: ["\\Recent"]} def login(): return self.client.login(b"testuser", b"password-test") def loggedIn(): self.server.flagsChanged(flags) d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(loggedIn)).addErrback(self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestFlagChange, flags) def _cbTestFlagChange(self, ignored, flags): E = self.client.events expect = [["flagsChanged", {x[0]: x[1]}] for x in flags.items()] E.sort(key=lambda o: o[0]) expect.sort(key=lambda o: o[0]) self.assertEqual(E, expect) def testNewMessages(self): def login(): return self.client.login(b"testuser", b"password-test") def loggedIn(): self.server.newMessages(10, None) d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(loggedIn)).addErrback(self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestNewMessages) def _cbTestNewMessages(self, ignored): E = self.client.events self.assertEqual(E, [["newMessages", 10, None]]) def testNewRecentMessages(self): def login(): return self.client.login(b"testuser", b"password-test") def loggedIn(): self.server.newMessages(None, 10) d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(loggedIn)).addErrback(self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestNewRecentMessages) def _cbTestNewRecentMessages(self, ignored): E = self.client.events self.assertEqual(E, [["newMessages", None, 10]]) def testNewMessagesAndRecent(self): def login(): return self.client.login(b"testuser", b"password-test") def loggedIn(): self.server.newMessages(20, 10) d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(loggedIn)).addErrback(self._ebGeneral) d = defer.gatherResults([self.loopback(), d1]) return d.addCallback(self._cbTestNewMessagesAndRecent) def _cbTestNewMessagesAndRecent(self, ignored): E = self.client.events self.assertEqual(E, [["newMessages", 20, None], ["newMessages", None, 10]]) class ClientCapabilityTests(TestCase): """ Tests for issuance of the CAPABILITY command and handling of its response. """ def setUp(self): """ Create an L{imap4.IMAP4Client} connected to a L{StringTransport}. """ self.transport = StringTransport() self.protocol = imap4.IMAP4Client() self.protocol.makeConnection(self.transport) self.protocol.dataReceived(b"* OK [IMAP4rev1]\r\n") def test_simpleAtoms(self): """ A capability response consisting only of atoms without C{'='} in them should result in a dict mapping those atoms to L{None}. """ capabilitiesResult = self.protocol.getCapabilities(useCache=False) self.protocol.dataReceived(b"* CAPABILITY IMAP4rev1 LOGINDISABLED\r\n") self.protocol.dataReceived(b"0001 OK Capability completed.\r\n") def gotCapabilities(capabilities): self.assertEqual(capabilities, {b"IMAP4rev1": None, b"LOGINDISABLED": None}) capabilitiesResult.addCallback(gotCapabilities) return capabilitiesResult def test_categoryAtoms(self): """ A capability response consisting of atoms including C{'='} should have those atoms split on that byte and have capabilities in the same category aggregated into lists in the resulting dictionary. (n.b. - I made up the word "category atom"; the protocol has no notion of structure here, but rather allows each capability to define the semantics of its entry in the capability response in a freeform manner. If I had realized this earlier, the API for capabilities would look different. As it is, we can hope that no one defines any crazy semantics which are incompatible with this API, or try to figure out a better API when someone does. -exarkun) """ capabilitiesResult = self.protocol.getCapabilities(useCache=False) self.protocol.dataReceived(b"* CAPABILITY IMAP4rev1 AUTH=LOGIN AUTH=PLAIN\r\n") self.protocol.dataReceived(b"0001 OK Capability completed.\r\n") def gotCapabilities(capabilities): self.assertEqual( capabilities, {b"IMAP4rev1": None, b"AUTH": [b"LOGIN", b"PLAIN"]} ) capabilitiesResult.addCallback(gotCapabilities) return capabilitiesResult def test_mixedAtoms(self): """ A capability response consisting of both simple and category atoms of the same type should result in a list containing L{None} as well as the values for the category. """ capabilitiesResult = self.protocol.getCapabilities(useCache=False) # Exercise codepath for both orderings of =-having and =-missing # capabilities. self.protocol.dataReceived( b"* CAPABILITY IMAP4rev1 FOO FOO=BAR BAR=FOO BAR\r\n" ) self.protocol.dataReceived(b"0001 OK Capability completed.\r\n") def gotCapabilities(capabilities): self.assertEqual( capabilities, {b"IMAP4rev1": None, b"FOO": [None, b"BAR"], b"BAR": [b"FOO", None]}, ) capabilitiesResult.addCallback(gotCapabilities) return capabilitiesResult class StillSimplerClient(imap4.IMAP4Client): """ An IMAP4 client which keeps track of unsolicited flag changes. """ def __init__(self): imap4.IMAP4Client.__init__(self) self.flags = {} def flagsChanged(self, newFlags): self.flags.update(newFlags) class HandCraftedTests(IMAP4HelperMixin, TestCase): def testTrailingLiteral(self): transport = StringTransport() c = imap4.IMAP4Client() c.makeConnection(transport) c.lineReceived(b"* OK [IMAP4rev1]") def cbCheckTransport(ignored): self.assertEqual( transport.value().splitlines()[-1], b"0003 FETCH 1 (RFC822)", ) def cbSelect(ignored): d = c.fetchMessage("1") c.dataReceived( b"* 1 FETCH (RFC822 {10}\r\n0123456789\r\n RFC822.SIZE 10)\r\n" ) c.dataReceived(b"0003 OK FETCH\r\n") d.addCallback(cbCheckTransport) return d def cbLogin(ignored): d = c.select("inbox") c.lineReceived(b"0002 OK SELECT") d.addCallback(cbSelect) return d d = c.login(b"blah", b"blah") c.dataReceived(b"0001 OK LOGIN\r\n") d.addCallback(cbLogin) return d def test_fragmentedStringLiterals(self): """ String literals whose data is not immediately available are parsed. """ self.server.checker.addUser(b"testuser", b"password-test") transport = StringTransport() self.server.makeConnection(transport) transport.clear() self.server.dataReceived(b"01 LOGIN {8}\r\n") self.assertEqual(transport.value(), b"+ Ready for 8 octets of text\r\n") transport.clear() self.server.dataReceived(b"testuser {13}\r\n") self.assertEqual(transport.value(), b"+ Ready for 13 octets of text\r\n") transport.clear() self.server.dataReceived(b"password") self.assertNot(transport.value()) self.server.dataReceived(b"-test\r\n") self.assertEqual(transport.value(), b"01 OK LOGIN succeeded\r\n") self.assertEqual(self.server.state, "auth") self.server.connectionLost(error.ConnectionDone("Connection done.")) def test_emptyStringLiteral(self): """ Empty string literals are parsed. """ self.server.checker.users = {b"": b""} transport = StringTransport() self.server.makeConnection(transport) transport.clear() self.server.dataReceived(b"01 LOGIN {0}\r\n") self.assertEqual(transport.value(), b"+ Ready for 0 octets of text\r\n") transport.clear() self.server.dataReceived(b"{0}\r\n") self.assertEqual(transport.value(), b"01 OK LOGIN succeeded\r\n") self.assertEqual(self.server.state, "auth") self.server.connectionLost(error.ConnectionDone("Connection done.")) def test_unsolicitedResponseMixedWithSolicitedResponse(self): """ If unsolicited data is received along with solicited data in the response to a I{FETCH} command issued by L{IMAP4Client.fetchSpecific}, the unsolicited data is passed to the appropriate callback and not included in the result with which the L{Deferred} returned by L{IMAP4Client.fetchSpecific} fires. """ transport = StringTransport() c = StillSimplerClient() c.makeConnection(transport) c.lineReceived(b"* OK [IMAP4rev1]") def login(): d = c.login(b"blah", b"blah") c.dataReceived(b"0001 OK LOGIN\r\n") return d def select(): d = c.select("inbox") c.lineReceived(b"0002 OK SELECT") return d def fetch(): d = c.fetchSpecific( "1:*", headerType="HEADER.FIELDS", headerArgs=["SUBJECT"] ) c.dataReceived(b'* 1 FETCH (BODY[HEADER.FIELDS ("SUBJECT")] {38}\r\n') c.dataReceived(b"Subject: Suprise for your woman...\r\n") c.dataReceived(b"\r\n") c.dataReceived(b")\r\n") c.dataReceived(b"* 1 FETCH (FLAGS (\\Seen))\r\n") c.dataReceived(b'* 2 FETCH (BODY[HEADER.FIELDS ("SUBJECT")] {75}\r\n') c.dataReceived( b"Subject: What you been doing. Order your meds here . ,. handcuff madsen\r\n" ) c.dataReceived(b"\r\n") c.dataReceived(b")\r\n") c.dataReceived(b"0003 OK FETCH completed\r\n") return d def test(res): self.assertEqual( transport.value().splitlines()[-1], b"0003 FETCH 1:* BODY[HEADER.FIELDS (SUBJECT)]", ) self.assertEqual( res, { 1: [ [ "BODY", ["HEADER.FIELDS", ["SUBJECT"]], "Subject: Suprise for your woman...\r\n\r\n", ] ], 2: [ [ "BODY", ["HEADER.FIELDS", ["SUBJECT"]], "Subject: What you been doing. Order your meds here . ,. handcuff madsen\r\n\r\n", ] ], }, ) self.assertEqual(c.flags, {1: ["\\Seen"]}) return ( login() .addCallback(strip(select)) .addCallback(strip(fetch)) .addCallback(test) ) def test_literalWithoutPrecedingWhitespace(self): """ Literals should be recognized even when they are not preceded by whitespace. """ transport = StringTransport() protocol = imap4.IMAP4Client() protocol.makeConnection(transport) protocol.lineReceived(b"* OK [IMAP4rev1]") def login(): d = protocol.login(b"blah", b"blah") protocol.dataReceived(b"0001 OK LOGIN\r\n") return d def select(): d = protocol.select(b"inbox") protocol.lineReceived(b"0002 OK SELECT") return d def fetch(): d = protocol.fetchSpecific( "1:*", headerType="HEADER.FIELDS", headerArgs=["SUBJECT"] ) protocol.dataReceived( b'* 1 FETCH (BODY[HEADER.FIELDS ({7}\r\nSUBJECT)] "Hello")\r\n' ) protocol.dataReceived(b"0003 OK FETCH completed\r\n") return d def test(result): self.assertEqual( transport.value().splitlines()[-1], b"0003 FETCH 1:* BODY[HEADER.FIELDS (SUBJECT)]", ) self.assertEqual( result, {1: [["BODY", ["HEADER.FIELDS", ["SUBJECT"]], "Hello"]]} ) d = login() d.addCallback(strip(select)) d.addCallback(strip(fetch)) d.addCallback(test) return d def test_nonIntegerLiteralLength(self): """ If the server sends a literal length which cannot be parsed as an integer, L{IMAP4Client.lineReceived} should cause the protocol to be disconnected by raising L{imap4.IllegalServerResponse}. """ transport = StringTransport() protocol = imap4.IMAP4Client() protocol.makeConnection(transport) protocol.lineReceived(b"* OK [IMAP4rev1]") def login(): d = protocol.login(b"blah", b"blah") protocol.dataReceived(b"0001 OK LOGIN\r\n") return d def select(): d = protocol.select("inbox") protocol.lineReceived(b"0002 OK SELECT") return d def fetch(): protocol.fetchSpecific( "1:*", headerType="HEADER.FIELDS", headerArgs=["SUBJECT"] ) self.assertEqual( transport.value().splitlines()[-1], b"0003 FETCH 1:* BODY[HEADER.FIELDS (SUBJECT)]", ) self.assertRaises( imap4.IllegalServerResponse, protocol.dataReceived, b"* 1 FETCH {xyz}\r\n...", ) d = login() d.addCallback(strip(select)) d.addCallback(strip(fetch)) return d def test_flagsChangedInsideFetchSpecificResponse(self): """ Any unrequested flag information received along with other requested information in an untagged I{FETCH} received in response to a request issued with L{IMAP4Client.fetchSpecific} is passed to the C{flagsChanged} callback. """ transport = StringTransport() c = StillSimplerClient() c.makeConnection(transport) c.lineReceived(b"* OK [IMAP4rev1]") def login(): d = c.login(b"blah", b"blah") c.dataReceived(b"0001 OK LOGIN\r\n") return d def select(): d = c.select("inbox") c.lineReceived(b"0002 OK SELECT") return d def fetch(): d = c.fetchSpecific( b"1:*", headerType="HEADER.FIELDS", headerArgs=["SUBJECT"] ) # This response includes FLAGS after the requested data. c.dataReceived(b'* 1 FETCH (BODY[HEADER.FIELDS ("SUBJECT")] {22}\r\n') c.dataReceived(b"Subject: subject one\r\n") c.dataReceived(b" FLAGS (\\Recent))\r\n") # And this one includes it before! Either is possible. c.dataReceived( b'* 2 FETCH (FLAGS (\\Seen) BODY[HEADER.FIELDS ("SUBJECT")] {22}\r\n' ) c.dataReceived(b"Subject: subject two\r\n") c.dataReceived(b")\r\n") c.dataReceived(b"0003 OK FETCH completed\r\n") return d def test(res): self.assertEqual( res, { 1: [ [ "BODY", ["HEADER.FIELDS", ["SUBJECT"]], "Subject: subject one\r\n", ] ], 2: [ [ "BODY", ["HEADER.FIELDS", ["SUBJECT"]], "Subject: subject two\r\n", ] ], }, ) self.assertEqual(c.flags, {1: ["\\Recent"], 2: ["\\Seen"]}) return ( login() .addCallback(strip(select)) .addCallback(strip(fetch)) .addCallback(test) ) def test_flagsChangedInsideFetchMessageResponse(self): """ Any unrequested flag information received along with other requested information in an untagged I{FETCH} received in response to a request issued with L{IMAP4Client.fetchMessage} is passed to the C{flagsChanged} callback. """ transport = StringTransport() c = StillSimplerClient() c.makeConnection(transport) c.lineReceived(b"* OK [IMAP4rev1]") def login(): d = c.login(b"blah", b"blah") c.dataReceived(b"0001 OK LOGIN\r\n") return d def select(): d = c.select("inbox") c.lineReceived(b"0002 OK SELECT") return d def fetch(): d = c.fetchMessage("1:*") c.dataReceived(b"* 1 FETCH (RFC822 {24}\r\n") c.dataReceived(b"Subject: first subject\r\n") c.dataReceived(b" FLAGS (\\Seen))\r\n") c.dataReceived(b"* 2 FETCH (FLAGS (\\Recent \\Seen) RFC822 {25}\r\n") c.dataReceived(b"Subject: second subject\r\n") c.dataReceived(b")\r\n") c.dataReceived(b"0003 OK FETCH completed\r\n") return d def test(res): self.assertEqual( transport.value().splitlines()[-1], b"0003 FETCH 1:* (RFC822)", ) self.assertEqual( res, { 1: {"RFC822": "Subject: first subject\r\n"}, 2: {"RFC822": "Subject: second subject\r\n"}, }, ) self.assertEqual(c.flags, {1: ["\\Seen"], 2: ["\\Recent", "\\Seen"]}) return ( login() .addCallback(strip(select)) .addCallback(strip(fetch)) .addCallback(test) ) def test_authenticationChallengeDecodingException(self): """ When decoding a base64 encoded authentication message from the server, decoding errors are logged and then the client closes the connection. """ transport = StringTransportWithDisconnection() protocol = imap4.IMAP4Client() transport.protocol = protocol protocol.makeConnection(transport) protocol.lineReceived( b"* OK [CAPABILITY IMAP4rev1 IDLE NAMESPACE AUTH=CRAM-MD5] " b"Twisted IMAP4rev1 Ready" ) cAuth = imap4.CramMD5ClientAuthenticator(b"testuser") protocol.registerAuthenticator(cAuth) d = protocol.authenticate("secret") # Should really be something describing the base64 decode error. See # #6021. self.assertFailure(d, error.ConnectionDone) protocol.dataReceived(b"+ Something bad! and bad\r\n") # This should not really be logged. See #6021. logged = self.flushLoggedErrors(imap4.IllegalServerResponse) self.assertEqual(len(logged), 1) self.assertEqual(logged[0].value.args[0], b"Something bad! and bad") return d class PreauthIMAP4ClientMixin: """ Mixin for L{SynchronousTestCase} subclasses which provides a C{setUp} method which creates an L{IMAP4Client} connected to a L{StringTransport} and puts it into the I{authenticated} state. @ivar transport: A L{StringTransport} to which C{client} is connected. @ivar client: An L{IMAP4Client} which is connected to C{transport}. """ clientProtocol: Type[imap4.IMAP4Client] = imap4.IMAP4Client def setUp(self): """ Create an IMAP4Client connected to a fake transport and in the authenticated state. """ self.transport = StringTransport() self.client = self.clientProtocol() self.client.makeConnection(self.transport) self.client.dataReceived(b"* PREAUTH Hello unittest\r\n") class SelectionTestsMixin(PreauthIMAP4ClientMixin): """ Mixin for test cases which defines tests which apply to both I{EXAMINE} and I{SELECT} support. """ def _examineOrSelect(self): """ Issue either an I{EXAMINE} or I{SELECT} command (depending on C{self.method}), assert that the correct bytes are written to the transport, and return the L{Deferred} returned by whichever method was called. """ d = getattr(self.client, self.method)("foobox") self.assertEqual( self.transport.value(), b"0001 " + self.command + b" foobox\r\n" ) return d def _response(self, *lines): """ Deliver the given (unterminated) response lines to C{self.client} and then deliver a tagged SELECT or EXAMINE completion line to finish the SELECT or EXAMINE response. """ for line in lines: self.client.dataReceived(line + b"\r\n") self.client.dataReceived( b"0001 OK [READ-ONLY] " + self.command + b" completed\r\n" ) def test_exists(self): """ If the server response to a I{SELECT} or I{EXAMINE} command includes an I{EXISTS} response, the L{Deferred} return by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'EXISTS'} key. """ d = self._examineOrSelect() self._response(b"* 3 EXISTS") self.assertEqual(self.successResultOf(d), {"READ-WRITE": False, "EXISTS": 3}) def test_nonIntegerExists(self): """ If the server returns a non-integer EXISTS value in its response to a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fails with L{IllegalServerResponse}. """ d = self._examineOrSelect() self._response(b"* foo EXISTS") self.failureResultOf(d, imap4.IllegalServerResponse) def test_recent(self): """ If the server response to a I{SELECT} or I{EXAMINE} command includes an I{RECENT} response, the L{Deferred} return by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'RECENT'} key. """ d = self._examineOrSelect() self._response(b"* 5 RECENT") self.assertEqual(self.successResultOf(d), {"READ-WRITE": False, "RECENT": 5}) def test_nonIntegerRecent(self): """ If the server returns a non-integer RECENT value in its response to a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fails with L{IllegalServerResponse}. """ d = self._examineOrSelect() self._response(b"* foo RECENT") self.failureResultOf(d, imap4.IllegalServerResponse) def test_unseen(self): """ If the server response to a I{SELECT} or I{EXAMINE} command includes an I{UNSEEN} response, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'UNSEEN'} key. """ d = self._examineOrSelect() self._response(b"* OK [UNSEEN 8] Message 8 is first unseen") self.assertEqual(self.successResultOf(d), {"READ-WRITE": False, "UNSEEN": 8}) def test_nonIntegerUnseen(self): """ If the server returns a non-integer UNSEEN value in its response to a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fails with L{IllegalServerResponse}. """ d = self._examineOrSelect() self._response(b"* OK [UNSEEN foo] Message foo is first unseen") self.failureResultOf(d, imap4.IllegalServerResponse) def test_uidvalidity(self): """ If the server response to a I{SELECT} or I{EXAMINE} command includes an I{UIDVALIDITY} response, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'UIDVALIDITY'} key. """ d = self._examineOrSelect() self._response(b"* OK [UIDVALIDITY 12345] UIDs valid") self.assertEqual( self.successResultOf(d), {"READ-WRITE": False, "UIDVALIDITY": 12345} ) def test_nonIntegerUIDVALIDITY(self): """ If the server returns a non-integer UIDVALIDITY value in its response to a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fails with L{IllegalServerResponse}. """ d = self._examineOrSelect() self._response(b"* OK [UIDVALIDITY foo] UIDs valid") self.failureResultOf(d, imap4.IllegalServerResponse) def test_uidnext(self): """ If the server response to a I{SELECT} or I{EXAMINE} command includes an I{UIDNEXT} response, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'UIDNEXT'} key. """ d = self._examineOrSelect() self._response(b"* OK [UIDNEXT 4392] Predicted next UID") self.assertEqual( self.successResultOf(d), {"READ-WRITE": False, "UIDNEXT": 4392} ) def test_nonIntegerUIDNEXT(self): """ If the server returns a non-integer UIDNEXT value in its response to a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fails with L{IllegalServerResponse}. """ d = self._examineOrSelect() self._response(b"* OK [UIDNEXT foo] Predicted next UID") self.failureResultOf(d, imap4.IllegalServerResponse) def test_flags(self): """ If the server response to a I{SELECT} or I{EXAMINE} command includes an I{FLAGS} response, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'FLAGS'} key. """ d = self._examineOrSelect() self._response(b"* FLAGS (\\Answered \\Flagged \\Deleted \\Seen \\Draft)") self.assertEqual( self.successResultOf(d), { "READ-WRITE": False, "FLAGS": ("\\Answered", "\\Flagged", "\\Deleted", "\\Seen", "\\Draft"), }, ) def test_permanentflags(self): """ If the server response to a I{SELECT} or I{EXAMINE} command includes an I{FLAGS} response, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'FLAGS'} key. """ d = self._examineOrSelect() self._response( b"* OK [PERMANENTFLAGS (\\Starred)] Just one permanent flag in " b"that list up there" ) self.assertEqual( self.successResultOf(d), {"READ-WRITE": False, "PERMANENTFLAGS": ("\\Starred",)}, ) def test_unrecognizedOk(self): """ If the server response to a I{SELECT} or I{EXAMINE} command includes an I{OK} with unrecognized response code text, parsing does not fail. """ d = self._examineOrSelect() self._response(b"* OK [X-MADE-UP] I just made this response text up.") # The value won't show up in the result. It would be okay if it did # someday, perhaps. This shouldn't ever happen, though. self.assertEqual(self.successResultOf(d), {"READ-WRITE": False}) def test_bareOk(self): """ If the server response to a I{SELECT} or I{EXAMINE} command includes an I{OK} with no response code text, parsing does not fail. """ d = self._examineOrSelect() self._response(b"* OK") self.assertEqual(self.successResultOf(d), {"READ-WRITE": False}) class IMAP4ClientExamineTests(SelectionTestsMixin, SynchronousTestCase): """ Tests for the L{IMAP4Client.examine} method. An example of usage of the EXAMINE command from RFC 3501, section 6.3.2:: S: * 17 EXISTS S: * 2 RECENT S: * OK [UNSEEN 8] Message 8 is first unseen S: * OK [UIDVALIDITY 3857529045] UIDs valid S: * OK [UIDNEXT 4392] Predicted next UID S: * FLAGS (\\Answered \\Flagged \\Deleted \\Seen \\Draft) S: * OK [PERMANENTFLAGS ()] No permanent flags permitted S: A932 OK [READ-ONLY] EXAMINE completed """ method = "examine" command = b"EXAMINE" class IMAP4ClientSelectTests(SelectionTestsMixin, SynchronousTestCase): r""" Tests for the L{IMAP4Client.select} method. An example of usage of the SELECT command from RFC 3501, section 6.3.1:: C: A142 SELECT INBOX S: * 172 EXISTS S: * 1 RECENT S: * OK [UNSEEN 12] Message 12 is first unseen S: * OK [UIDVALIDITY 3857529045] UIDs valid S: * OK [UIDNEXT 4392] Predicted next UID S: * FLAGS (\Answered \Flagged \Deleted \Seen \Draft) S: * OK [PERMANENTFLAGS (\Deleted \Seen \*)] Limited S: A142 OK [READ-WRITE] SELECT completed """ method = "select" command = b"SELECT" class IMAP4ClientExpungeTests(PreauthIMAP4ClientMixin, SynchronousTestCase): """ Tests for the L{IMAP4Client.expunge} method. An example of usage of the EXPUNGE command from RFC 3501, section 6.4.3:: C: A202 EXPUNGE S: * 3 EXPUNGE S: * 3 EXPUNGE S: * 5 EXPUNGE S: * 8 EXPUNGE S: A202 OK EXPUNGE completed """ def _expunge(self): d = self.client.expunge() self.assertEqual(self.transport.value(), b"0001 EXPUNGE\r\n") self.transport.clear() return d def _response(self, sequenceNumbers): for number in sequenceNumbers: self.client.lineReceived(networkString(f"* {number} EXPUNGE")) self.client.lineReceived(b"0001 OK EXPUNGE COMPLETED") def test_expunge(self): """ L{IMAP4Client.expunge} sends the I{EXPUNGE} command and returns a L{Deferred} which fires with a C{list} of message sequence numbers given by the server's response. """ d = self._expunge() self._response([3, 3, 5, 8]) self.assertEqual(self.successResultOf(d), [3, 3, 5, 8]) def test_nonIntegerExpunged(self): """ If the server responds with a non-integer where a message sequence number is expected, the L{Deferred} returned by L{IMAP4Client.expunge} fails with L{IllegalServerResponse}. """ d = self._expunge() self._response([3, 3, "foo", 8]) self.failureResultOf(d, imap4.IllegalServerResponse) class IMAP4ClientSearchTests(PreauthIMAP4ClientMixin, SynchronousTestCase): """ Tests for the L{IMAP4Client.search} method. An example of usage of the SEARCH command from RFC 3501, section 6.4.4:: C: A282 SEARCH FLAGGED SINCE 1-Feb-1994 NOT FROM "Smith" S: * SEARCH 2 84 882 S: A282 OK SEARCH completed C: A283 SEARCH TEXT "string not in mailbox" S: * SEARCH S: A283 OK SEARCH completed C: A284 SEARCH CHARSET UTF-8 TEXT {6} C: XXXXXX S: * SEARCH 43 S: A284 OK SEARCH completed """ def _search(self): d = self.client.search(imap4.Query(text="ABCDEF")) self.assertEqual(self.transport.value(), b'0001 SEARCH (TEXT "ABCDEF")\r\n') return d def _response(self, messageNumbers): self.client.lineReceived( b"* SEARCH " + networkString(" ".join(map(str, messageNumbers))) ) self.client.lineReceived(b"0001 OK SEARCH completed") def test_search(self): """ L{IMAP4Client.search} sends the I{SEARCH} command and returns a L{Deferred} which fires with a C{list} of message sequence numbers given by the server's response. """ d = self._search() self._response([2, 5, 10]) self.assertEqual(self.successResultOf(d), [2, 5, 10]) def test_nonIntegerFound(self): """ If the server responds with a non-integer where a message sequence number is expected, the L{Deferred} returned by L{IMAP4Client.search} fails with L{IllegalServerResponse}. """ d = self._search() self._response([2, "foo", 10]) self.failureResultOf(d, imap4.IllegalServerResponse) class IMAP4ClientFetchTests(PreauthIMAP4ClientMixin, SynchronousTestCase): """ Tests for the L{IMAP4Client.fetch} method. See RFC 3501, section 6.4.5. """ def test_fetchUID(self): """ L{IMAP4Client.fetchUID} sends the I{FETCH UID} command and returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{dict}s mapping C{'UID'} to that message's I{UID} in the server's response. """ d = self.client.fetchUID("1:7") self.assertEqual(self.transport.value(), b"0001 FETCH 1:7 (UID)\r\n") self.client.lineReceived(b"* 2 FETCH (UID 22)") self.client.lineReceived(b"* 3 FETCH (UID 23)") self.client.lineReceived(b"* 4 FETCH (UID 24)") self.client.lineReceived(b"* 5 FETCH (UID 25)") self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual( self.successResultOf(d), {2: {"UID": "22"}, 3: {"UID": "23"}, 4: {"UID": "24"}, 5: {"UID": "25"}}, ) def test_fetchUIDNonIntegerFound(self): """ If the server responds with a non-integer where a message sequence number is expected, the L{Deferred} returned by L{IMAP4Client.fetchUID} fails with L{IllegalServerResponse}. """ d = self.client.fetchUID("1") self.assertEqual(self.transport.value(), b"0001 FETCH 1 (UID)\r\n") self.client.lineReceived(b"* foo FETCH (UID 22)") self.client.lineReceived(b"0001 OK FETCH completed") self.failureResultOf(d, imap4.IllegalServerResponse) def test_incompleteFetchUIDResponse(self): """ If the server responds with an incomplete I{FETCH} response line, the L{Deferred} returned by L{IMAP4Client.fetchUID} fails with L{IllegalServerResponse}. """ d = self.client.fetchUID("1:7") self.assertEqual(self.transport.value(), b"0001 FETCH 1:7 (UID)\r\n") self.client.lineReceived(b"* 2 FETCH (UID 22)") self.client.lineReceived(b"* 3 FETCH (UID)") self.client.lineReceived(b"* 4 FETCH (UID 24)") self.client.lineReceived(b"0001 OK FETCH completed") self.failureResultOf(d, imap4.IllegalServerResponse) def test_fetchBody(self): """ L{IMAP4Client.fetchBody} sends the I{FETCH BODY} command and returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{dict}s mapping C{'RFC822.TEXT'} to that message's body as given in the server's response. """ d = self.client.fetchBody("3") self.assertEqual(self.transport.value(), b"0001 FETCH 3 (RFC822.TEXT)\r\n") self.client.lineReceived(b'* 3 FETCH (RFC822.TEXT "Message text")') self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual(self.successResultOf(d), {3: {"RFC822.TEXT": "Message text"}}) def test_fetchSpecific(self): """ L{IMAP4Client.fetchSpecific} sends the I{BODY[]} command if no parameters beyond the message set to retrieve are given. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. """ d = self.client.fetchSpecific("7") self.assertEqual(self.transport.value(), b"0001 FETCH 7 BODY[]\r\n") self.client.lineReceived(b'* 7 FETCH (BODY[] "Some body")') self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual(self.successResultOf(d), {7: [["BODY", [], "Some body"]]}) def test_fetchSpecificPeek(self): """ L{IMAP4Client.fetchSpecific} issues a I{BODY.PEEK[]} command if passed C{True} for the C{peek} parameter. """ d = self.client.fetchSpecific("6", peek=True) self.assertEqual(self.transport.value(), b"0001 FETCH 6 BODY.PEEK[]\r\n") # BODY.PEEK responses are just BODY self.client.lineReceived(b'* 6 FETCH (BODY[] "Some body")') self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual(self.successResultOf(d), {6: [["BODY", [], "Some body"]]}) def test_fetchSpecificNumbered(self): """ L{IMAP4Client.fetchSpecific}, when passed a sequence for C{headerNumber}, sends the I{BODY[N.M]} command. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. """ d = self.client.fetchSpecific("7", headerNumber=(1, 2, 3)) self.assertEqual(self.transport.value(), b"0001 FETCH 7 BODY[1.2.3]\r\n") self.client.lineReceived(b'* 7 FETCH (BODY[1.2.3] "Some body")') self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual( self.successResultOf(d), {7: [["BODY", ["1.2.3"], "Some body"]]} ) def test_fetchSpecificText(self): """ L{IMAP4Client.fetchSpecific}, when passed C{'TEXT'} for C{headerType}, sends the I{BODY[TEXT]} command. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. """ d = self.client.fetchSpecific("8", headerType="TEXT") self.assertEqual(self.transport.value(), b"0001 FETCH 8 BODY[TEXT]\r\n") self.client.lineReceived(b'* 8 FETCH (BODY[TEXT] "Some body")') self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual( self.successResultOf(d), {8: [["BODY", ["TEXT"], "Some body"]]} ) def test_fetchSpecificNumberedText(self): """ If passed a value for the C{headerNumber} parameter and C{'TEXT'} for the C{headerType} parameter, L{IMAP4Client.fetchSpecific} sends a I{BODY[number.TEXT]} request and returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of message data given by the server's response. """ d = self.client.fetchSpecific("4", headerType="TEXT", headerNumber=7) self.assertEqual(self.transport.value(), b"0001 FETCH 4 BODY[7.TEXT]\r\n") self.client.lineReceived(b'* 4 FETCH (BODY[7.TEXT] "Some body")') self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual( self.successResultOf(d), {4: [["BODY", ["7.TEXT"], "Some body"]]} ) def test_incompleteFetchSpecificTextResponse(self): """ If the server responds to a I{BODY[TEXT]} request with a I{FETCH} line which is truncated after the I{BODY[TEXT]} tokens, the L{Deferred} returned by L{IMAP4Client.fetchUID} fails with L{IllegalServerResponse}. """ d = self.client.fetchSpecific("8", headerType="TEXT") self.assertEqual(self.transport.value(), b"0001 FETCH 8 BODY[TEXT]\r\n") self.client.lineReceived(b"* 8 FETCH (BODY[TEXT])") self.client.lineReceived(b"0001 OK FETCH completed") self.failureResultOf(d, imap4.IllegalServerResponse) def test_fetchSpecificMIME(self): """ L{IMAP4Client.fetchSpecific}, when passed C{'MIME'} for C{headerType}, sends the I{BODY[MIME]} command. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. """ d = self.client.fetchSpecific("8", headerType="MIME") self.assertEqual(self.transport.value(), b"0001 FETCH 8 BODY[MIME]\r\n") self.client.lineReceived(b'* 8 FETCH (BODY[MIME] "Some body")') self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual( self.successResultOf(d), {8: [["BODY", ["MIME"], "Some body"]]} ) def test_fetchSpecificPartial(self): """ L{IMAP4Client.fetchSpecific}, when passed C{offset} and C{length}, sends a partial content request (like I{BODY[TEXT]<offset.length>}). It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. """ d = self.client.fetchSpecific("9", headerType="TEXT", offset=17, length=3) self.assertEqual(self.transport.value(), b"0001 FETCH 9 BODY[TEXT]<17.3>\r\n") self.client.lineReceived(b'* 9 FETCH (BODY[TEXT]<17> "foo")') self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual( self.successResultOf(d), {9: [["BODY", ["TEXT"], "<17>", "foo"]]} ) def test_incompleteFetchSpecificPartialResponse(self): """ If the server responds to a I{BODY[TEXT]} request with a I{FETCH} line which is truncated after the I{BODY[TEXT]<offset>} tokens, the L{Deferred} returned by L{IMAP4Client.fetchUID} fails with L{IllegalServerResponse}. """ d = self.client.fetchSpecific("8", headerType="TEXT") self.assertEqual(self.transport.value(), b"0001 FETCH 8 BODY[TEXT]\r\n") self.client.lineReceived(b"* 8 FETCH (BODY[TEXT]<17>)") self.client.lineReceived(b"0001 OK FETCH completed") self.failureResultOf(d, imap4.IllegalServerResponse) def test_fetchSpecificHTML(self): """ If the body of a message begins with I{<} and ends with I{>} (as, for example, HTML bodies typically will), this is still interpreted as the body by L{IMAP4Client.fetchSpecific} (and particularly, not as a length indicator for a response to a request for a partial body). """ d = self.client.fetchSpecific("7") self.assertEqual(self.transport.value(), b"0001 FETCH 7 BODY[]\r\n") self.client.lineReceived(b'* 7 FETCH (BODY[] "<html>test</html>")') self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual( self.successResultOf(d), {7: [["BODY", [], "<html>test</html>"]]} ) def assertFetchSpecificFieldsWithEmptyList(self, section): """ Assert that the provided C{BODY} section, when invoked with no arguments, produces an empty list, and that it returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. @param section: The C{BODY} section to test: either C{'HEADER.FIELDS'} or C{'HEADER.FIELDS.NOT'} @type section: L{str} """ d = self.client.fetchSpecific("10", headerType=section) self.assertEqual( self.transport.value(), b"0001 FETCH 10 BODY[" + section.encode("ascii") + b" ()]\r\n", ) # It's unclear what the response would look like - would it be # an empty string? No IMAP server parses an empty list of headers self.client.lineReceived( b"* 10 FETCH (BODY[" + section.encode("ascii") + b' ()] "")' ) self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual(self.successResultOf(d), {10: [["BODY", [section, []], ""]]}) def test_fetchSpecificHeaderFieldsWithoutHeaders(self): """ L{IMAP4Client.fetchSpecific}, when passed C{'HEADER.FIELDS'} for C{headerType} but no C{headerArgs}, sends the I{BODY[HEADER.FIELDS]} command with no arguments. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. """ self.assertFetchSpecificFieldsWithEmptyList("HEADER.FIELDS") def test_fetchSpecificHeaderFieldsNotWithoutHeaders(self): """ L{IMAP4Client.fetchSpecific}, when passed C{'HEADER.FIELDS.NOT'} for C{headerType} but no C{headerArgs}, sends the I{BODY[HEADER.FIELDS.NOT]} command with no arguments. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. """ self.assertFetchSpecificFieldsWithEmptyList("HEADER.FIELDS.NOT") def test_fetchSpecificHeader(self): """ L{IMAP4Client.fetchSpecific}, when passed C{'HEADER'} for C{headerType}, sends the I{BODY[HEADER]} command. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. """ d = self.client.fetchSpecific("11", headerType="HEADER") self.assertEqual(self.transport.value(), b"0001 FETCH 11 BODY[HEADER]\r\n") self.client.lineReceived( b"* 11 FETCH (BODY[HEADER]" b' "From: someone@localhost\r\nSubject: Some subject")' ) self.client.lineReceived(b"0001 OK FETCH completed") self.assertEqual( self.successResultOf(d), { 11: [ [ "BODY", ["HEADER"], "From: someone@localhost\r\nSubject: Some subject", ] ] }, ) class IMAP4ClientStoreTests(PreauthIMAP4ClientMixin, TestCase): r""" Tests for the L{IMAP4Client.setFlags}, L{IMAP4Client.addFlags}, and L{IMAP4Client.removeFlags} methods. An example of usage of the STORE command, in terms of which these three methods are implemented, from RFC 3501, section 6.4.6:: C: A003 STORE 2:4 +FLAGS (\Deleted) S: * 2 FETCH (FLAGS (\Deleted \Seen)) S: * 3 FETCH (FLAGS (\Deleted)) S: * 4 FETCH (FLAGS (\Deleted \Flagged \Seen)) S: A003 OK STORE completed """ clientProtocol = StillSimplerClient def _flagsTest(self, method, item): """ Test a non-silent flag modifying method. Call the method, assert that the correct bytes are sent, deliver a I{FETCH} response, and assert that the result of the Deferred returned by the method is correct. @param method: The name of the method to test. @param item: The data item which is expected to be specified. """ d = getattr(self.client, method)("3", ("\\Read", "\\Seen"), False) self.assertEqual( self.transport.value(), b"0001 STORE 3 " + item + b" (\\Read \\Seen)\r\n" ) self.client.lineReceived(b"* 3 FETCH (FLAGS (\\Read \\Seen))") self.client.lineReceived(b"0001 OK STORE completed") self.assertEqual(self.successResultOf(d), {3: {"FLAGS": ["\\Read", "\\Seen"]}}) def _flagsSilentlyTest(self, method, item): """ Test a silent flag modifying method. Call the method, assert that the correct bytes are sent, deliver an I{OK} response, and assert that the result of the Deferred returned by the method is correct. @param method: The name of the method to test. @param item: The data item which is expected to be specified. """ d = getattr(self.client, method)("3", ("\\Read", "\\Seen"), True) self.assertEqual( self.transport.value(), b"0001 STORE 3 " + item + b" (\\Read \\Seen)\r\n" ) self.client.lineReceived(b"0001 OK STORE completed") self.assertEqual(self.successResultOf(d), {}) def _flagsSilentlyWithUnsolicitedDataTest(self, method, item): """ Test unsolicited data received in response to a silent flag modifying method. Call the method, assert that the correct bytes are sent, deliver the unsolicited I{FETCH} response, and assert that the result of the Deferred returned by the method is correct. @param method: The name of the method to test. @param item: The data item which is expected to be specified. """ d = getattr(self.client, method)("3", ("\\Read", "\\Seen"), True) self.assertEqual( self.transport.value(), b"0001 STORE 3 " + item + b" (\\Read \\Seen)\r\n" ) self.client.lineReceived(b"* 2 FETCH (FLAGS (\\Read \\Seen))") self.client.lineReceived(b"0001 OK STORE completed") self.assertEqual(self.successResultOf(d), {}) self.assertEqual(self.client.flags, {2: ["\\Read", "\\Seen"]}) def test_setFlags(self): """ When passed a C{False} value for the C{silent} parameter, L{IMAP4Client.setFlags} sends the I{STORE} command with a I{FLAGS} data item and returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{dict}s mapping C{'FLAGS'} to the new flags of those messages. """ self._flagsTest("setFlags", b"FLAGS") def test_setFlagsSilently(self): """ When passed a C{True} value for the C{silent} parameter, L{IMAP4Client.setFlags} sends the I{STORE} command with a I{FLAGS.SILENT} data item and returns a L{Deferred} which fires with an empty dictionary. """ self._flagsSilentlyTest("setFlags", b"FLAGS.SILENT") def test_setFlagsSilentlyWithUnsolicitedData(self): """ If unsolicited flag data is received in response to a I{STORE} I{FLAGS.SILENT} request, that data is passed to the C{flagsChanged} callback. """ self._flagsSilentlyWithUnsolicitedDataTest("setFlags", b"FLAGS.SILENT") def test_addFlags(self): """ L{IMAP4Client.addFlags} is like L{IMAP4Client.setFlags}, but sends I{+FLAGS} instead of I{FLAGS}. """ self._flagsTest("addFlags", b"+FLAGS") def test_addFlagsSilently(self): """ L{IMAP4Client.addFlags} with a C{True} value for C{silent} behaves like L{IMAP4Client.setFlags} with a C{True} value for C{silent}, but it sends I{+FLAGS.SILENT} instead of I{FLAGS.SILENT}. """ self._flagsSilentlyTest("addFlags", b"+FLAGS.SILENT") def test_addFlagsSilentlyWithUnsolicitedData(self): """ L{IMAP4Client.addFlags} behaves like L{IMAP4Client.setFlags} when used in silent mode and unsolicited data is received. """ self._flagsSilentlyWithUnsolicitedDataTest("addFlags", b"+FLAGS.SILENT") def test_removeFlags(self): """ L{IMAP4Client.removeFlags} is like L{IMAP4Client.setFlags}, but sends I{-FLAGS} instead of I{FLAGS}. """ self._flagsTest("removeFlags", b"-FLAGS") def test_removeFlagsSilently(self): """ L{IMAP4Client.removeFlags} with a C{True} value for C{silent} behaves like L{IMAP4Client.setFlags} with a C{True} value for C{silent}, but it sends I{-FLAGS.SILENT} instead of I{FLAGS.SILENT}. """ self._flagsSilentlyTest("removeFlags", b"-FLAGS.SILENT") def test_removeFlagsSilentlyWithUnsolicitedData(self): """ L{IMAP4Client.removeFlags} behaves like L{IMAP4Client.setFlags} when used in silent mode and unsolicited data is received. """ self._flagsSilentlyWithUnsolicitedDataTest("removeFlags", b"-FLAGS.SILENT") class IMAP4ClientStatusTests(PreauthIMAP4ClientMixin, SynchronousTestCase): """ Tests for the L{IMAP4Client.status} method. An example of usage of the STATUS command from RFC 3501, section 5.1.2:: C: A042 STATUS blurdybloop (UIDNEXT MESSAGES) S: * STATUS blurdybloop (MESSAGES 231 UIDNEXT 44292) S: A042 OK STATUS completed @see: U{https://tools.ietf.org/html/rfc3501#section-5.1.2} """ def testUnknownName(self): """ Only allow sending the C{STATUS} names defined in RFC 3501. @see: U{https://tools.ietf.org/html/rfc3501#section-5.1.2} """ exc = self.assertRaises( ValueError, self.client.status, "ignored", "IMPOSSIBLE?!", ) self.assertEqual(str(exc), "Unknown names: " + repr({"IMPOSSIBLE?!"})) def testUndecodableName(self): """ C{STATUS} names that cannot be decoded as ASCII cause the status Deferred to fail with L{IllegalServerResponse} """ d = self.client.status("blurdybloop", "MESSAGES") self.assertEqual( self.transport.value(), b"0001 STATUS blurdybloop (MESSAGES)\r\n", ) self.client.lineReceived( b"* STATUS blurdybloop " b'(MESSAGES 1 ASCIINAME "OK" NOT\xffASCII "NO")' ) self.client.lineReceived(b"0001 OK STATUS completed") self.failureResultOf(d, imap4.IllegalServerResponse) class IMAP4ClientCopyTests(PreauthIMAP4ClientMixin, SynchronousTestCase): """ Tests for the L{IMAP4Client.copy} method. An example of the C{COPY} command, which this method implements, from RFC 3501, section 6.4.7:: C: A003 COPY 2:4 MEETING S: A003 OK COPY completed """ clientProtocol = StillSimplerClient def test_copySequenceNumbers(self): """ L{IMAP4Client.copy} copies the messages identified by their sequence numbers to the mailbox, returning a L{Deferred} that succeeds with a true value. """ d = self.client.copy("2:3", "MEETING", uid=False) self.assertEqual( self.transport.value(), b"0001 COPY 2:3 MEETING\r\n", ) self.client.lineReceived(b"0001 OK COPY completed") self.assertEqual(self.successResultOf(d), ([], b"OK COPY completed")) def test_copySequenceNumbersFails(self): """ L{IMAP4Client.copy} returns a L{Deferred} that fails with an L{IMAP4Exception} when the messages specified by the given sequence numbers could not be copied to the mailbox. """ d = self.client.copy("2:3", "MEETING", uid=False) self.assertEqual( self.transport.value(), b"0001 COPY 2:3 MEETING\r\n", ) self.client.lineReceived(b"0001 BAD COPY failed") self.assertIsInstance(self.failureResultOf(d).value, imap4.IMAP4Exception) def test_copyUIDs(self): """ L{IMAP4Client.copy} copies the messages identified by their UIDs to the mailbox, returning a L{Deferred} that succeeds with a true value. """ d = self.client.copy("2:3", "MEETING", uid=True) self.assertEqual( self.transport.value(), b"0001 UID COPY 2:3 MEETING\r\n", ) self.client.lineReceived(b"0001 OK COPY completed") self.assertEqual(self.successResultOf(d), ([], b"OK COPY completed")) def test_copyUIDsFails(self): """ L{IMAP4Client.copy} returns a L{Deferred} that fails with an L{IMAP4Exception} when the messages specified by the given UIDs could not be copied to the mailbox. """ d = self.client.copy("2:3", "MEETING", uid=True) self.assertEqual( self.transport.value(), b"0001 UID COPY 2:3 MEETING\r\n", ) self.client.lineReceived(b"0001 BAD COPY failed") self.assertIsInstance(self.failureResultOf(d).value, imap4.IMAP4Exception) class FakeyServer(imap4.IMAP4Server): state = "select" timeout = None def sendServerGreeting(self): pass @implementer(imap4.IMessage) class FakeyMessage(util.FancyStrMixin): showAttributes = ("headers", "flags", "date", "_body", "uid") def __init__(self, headers, flags, date, body, uid, subpart): self.headers = headers self.flags = flags self._body = body self.size = len(body) self.date = date self.uid = uid self.subpart = subpart def getHeaders(self, negate, *names): self.got_headers = negate, names return self.headers def getFlags(self): return self.flags def getInternalDate(self): return self.date def getBodyFile(self): return BytesIO(self._body) def getSize(self): return self.size def getUID(self): return self.uid def isMultipart(self): return self.subpart is not None def getSubPart(self, part): self.got_subpart = part return self.subpart[part] class NewStoreTests(TestCase, IMAP4HelperMixin): result = None storeArgs = None def setUp(self): self.received_messages = self.received_uid = None self.server = imap4.IMAP4Server() self.server.state = "select" self.server.mbox = self self.connected = defer.Deferred() self.client = SimpleClient(self.connected) def addListener(self, x): pass def removeListener(self, x): pass def store(self, *args, **kw): self.storeArgs = args, kw return self.response def _storeWork(self): def connected(): return self.function(self.messages, self.flags, self.silent, self.uid) def result(R): self.result = R self.connected.addCallback(strip(connected)).addCallback(result).addCallback( self._cbStopClient ).addErrback(self._ebGeneral) def check(ignored): self.assertEqual(self.result, self.expected) self.assertEqual(self.storeArgs, self.expectedArgs) d = loopback.loopbackTCP(self.server, self.client, noisy=False) d.addCallback(check) return d def testSetFlags(self, uid=0): self.function = self.client.setFlags self.messages = "1,5,9" self.flags = ["\\A", "\\B", "C"] self.silent = False self.uid = uid self.response = { 1: ["\\A", "\\B", "C"], 5: ["\\A", "\\B", "C"], 9: ["\\A", "\\B", "C"], } self.expected = { 1: {"FLAGS": ["\\A", "\\B", "C"]}, 5: {"FLAGS": ["\\A", "\\B", "C"]}, 9: {"FLAGS": ["\\A", "\\B", "C"]}, } msg = imap4.MessageSet() msg.add(1) msg.add(5) msg.add(9) self.expectedArgs = ((msg, ["\\A", "\\B", "C"], 0), {"uid": 0}) return self._storeWork() class GetBodyStructureTests(TestCase): """ Tests for L{imap4.getBodyStructure}, a helper for constructing a list which directly corresponds to the wire information needed for a I{BODY} or I{BODYSTRUCTURE} response. """ def test_singlePart(self): """ L{imap4.getBodyStructure} accepts a L{IMessagePart} provider and returns a list giving the basic fields for the I{BODY} response for that message. """ body = b"hello, world" major = "image" minor = "jpeg" charset = "us-ascii" identifier = "some kind of id" description = "great justice" encoding = "maximum" msg = FakeyMessage( { "content-type": major + "/" + minor + "; charset=" + charset + "; x=y", "content-id": identifier, "content-description": description, "content-transfer-encoding": encoding, }, (), b"", body, 123, None, ) structure = imap4.getBodyStructure(msg) self.assertEqual( [ major, minor, ["charset", charset, "x", "y"], identifier, description, encoding, len(body), ], structure, ) def test_emptyContentType(self): """ L{imap4.getBodyStructure} returns L{None} for the major and minor MIME types of a L{IMessagePart} provider whose headers lack a C{Content-Type}, or have an empty value for it. """ missing = FakeyMessage({}, (), b"", b"", 123, None) missingContentTypeStructure = imap4.getBodyStructure(missing) missingMajor, missingMinor = missingContentTypeStructure[:2] self.assertIs(None, missingMajor) self.assertIs(None, missingMinor) empty = FakeyMessage({"content-type": ""}, (), b"", b"", 123, None) emptyContentTypeStructure = imap4.getBodyStructure(empty) emptyMajor, emptyMinor = emptyContentTypeStructure[:2] self.assertIs(None, emptyMajor) self.assertIs(None, emptyMinor) newline = FakeyMessage({"content-type": "\n"}, (), b"", b"", 123, None) newlineContentTypeStructure = imap4.getBodyStructure(newline) newlineMajor, newlineMinor = newlineContentTypeStructure[:2] self.assertIs(None, newlineMajor) self.assertIs(None, newlineMinor) def test_onlyMajorContentType(self): """ L{imap4.getBodyStructure} returns only a non-L{None} major MIME type for a L{IMessagePart} provider whose headers only have a main a C{Content-Type}. """ main = FakeyMessage({"content-type": "main"}, (), b"", b"", 123, None) mainStructure = imap4.getBodyStructure(main) mainMajor, mainMinor = mainStructure[:2] self.assertEqual(mainMajor, "main") self.assertIs(mainMinor, None) def test_singlePartExtended(self): """ L{imap4.getBodyStructure} returns a list giving the basic and extended fields for a I{BODYSTRUCTURE} response if passed C{True} for the C{extended} parameter. """ body = b"hello, world" major = "image" minor = "jpeg" charset = "us-ascii" identifier = "some kind of id" description = "great justice" encoding = "maximum" md5 = "abcdefabcdef" msg = FakeyMessage( { "content-type": major + "/" + minor + "; charset=" + charset + "; x=y", "content-id": identifier, "content-description": description, "content-transfer-encoding": encoding, "content-md5": md5, "content-disposition": "attachment; name=foo; size=bar", "content-language": "fr", "content-location": "France", }, (), "", body, 123, None, ) structure = imap4.getBodyStructure(msg, extended=True) self.assertEqual( [ major, minor, ["charset", charset, "x", "y"], identifier, description, encoding, len(body), md5, ["attachment", ["name", "foo", "size", "bar"]], "fr", "France", ], structure, ) def test_singlePartWithMissing(self): """ For fields with no information contained in the message headers, L{imap4.getBodyStructure} fills in L{None} values in its result. """ major = "image" minor = "jpeg" body = b"hello, world" msg = FakeyMessage( {"content-type": major + "/" + minor}, (), b"", body, 123, None ) structure = imap4.getBodyStructure(msg, extended=True) self.assertEqual( [major, minor, None, None, None, None, len(body), None, None, None, None], structure, ) def test_textPart(self): """ For a I{text/*} message, the number of lines in the message body are included after the common single-part basic fields. """ body = b"hello, world\nhow are you?\ngoodbye\n" major = "text" minor = "jpeg" charset = "us-ascii" identifier = "some kind of id" description = "great justice" encoding = "maximum" msg = FakeyMessage( { "content-type": major + "/" + minor + "; charset=" + charset + "; x=y", "content-id": identifier, "content-description": description, "content-transfer-encoding": encoding, }, (), b"", body, 123, None, ) structure = imap4.getBodyStructure(msg) self.assertEqual( [ major, minor, ["charset", charset, "x", "y"], identifier, description, encoding, len(body), len(body.splitlines()), ], structure, ) def test_rfc822Message(self): """ For a I{message/rfc822} message, the common basic fields are followed by information about the contained message. """ body = b"hello, world\nhow are you?\ngoodbye\n" major = "text" minor = "jpeg" charset = "us-ascii" identifier = "some kind of id" description = "great justice" encoding = "maximum" msg = FakeyMessage( { "content-type": major + "/" + minor + "; charset=" + charset + "; x=y", "from": "Alice <alice@example.com>", "to": "Bob <bob@example.com>", "content-id": identifier, "content-description": description, "content-transfer-encoding": encoding, }, (), "", body, 123, None, ) container = FakeyMessage( { "content-type": "message/rfc822", }, (), b"", b"", 123, [msg], ) structure = imap4.getBodyStructure(container) self.assertEqual( [ "message", "rfc822", None, None, None, None, 0, imap4.getEnvelope(msg), imap4.getBodyStructure(msg), 3, ], structure, ) def test_multiPart(self): """ For a I{multipart/*} message, L{imap4.getBodyStructure} returns a list containing the body structure information for each part of the message followed by an element giving the MIME subtype of the message. """ oneSubPart = FakeyMessage( { "content-type": "image/jpeg; x=y", "content-id": "some kind of id", "content-description": "great justice", "content-transfer-encoding": "maximum", }, (), b"", b"hello world", 123, None, ) anotherSubPart = FakeyMessage( { "content-type": "text/plain; charset=us-ascii", }, (), b"", b"some stuff", 321, None, ) container = FakeyMessage( { "content-type": "multipart/related", }, (), b"", b"", 555, [oneSubPart, anotherSubPart], ) self.assertEqual( [ imap4.getBodyStructure(oneSubPart), imap4.getBodyStructure(anotherSubPart), "related", ], imap4.getBodyStructure(container), ) def test_multiPartExtended(self): """ When passed a I{multipart/*} message and C{True} for the C{extended} argument, L{imap4.getBodyStructure} includes extended structure information from the parts of the multipart message and extended structure information about the multipart message itself. """ oneSubPart = FakeyMessage( { b"content-type": b"image/jpeg; x=y", b"content-id": b"some kind of id", b"content-description": b"great justice", b"content-transfer-encoding": b"maximum", }, (), b"", b"hello world", 123, None, ) anotherSubPart = FakeyMessage( { b"content-type": b"text/plain; charset=us-ascii", }, (), b"", b"some stuff", 321, None, ) container = FakeyMessage( { "content-type": "multipart/related; foo=bar", "content-language": "es", "content-location": "Spain", "content-disposition": "attachment; name=monkeys", }, (), b"", b"", 555, [oneSubPart, anotherSubPart], ) self.assertEqual( [ imap4.getBodyStructure(oneSubPart, extended=True), imap4.getBodyStructure(anotherSubPart, extended=True), "related", ["foo", "bar"], ["attachment", ["name", "monkeys"]], "es", "Spain", ], imap4.getBodyStructure(container, extended=True), ) class NewFetchTests(TestCase, IMAP4HelperMixin): def setUp(self): self.received_messages = self.received_uid = None self.result = None self.server = imap4.IMAP4Server() self.server.state = "select" self.server.mbox = self self.connected = defer.Deferred() self.client = SimpleClient(self.connected) def addListener(self, x): pass def removeListener(self, x): pass def fetch(self, messages, uid): self.received_messages = messages self.received_uid = uid return iter(zip(range(len(self.msgObjs)), self.msgObjs)) def _fetchWork(self, uid): if uid: for (i, msg) in zip(range(len(self.msgObjs)), self.msgObjs): self.expected[i]["UID"] = str(msg.getUID()) def result(R): self.result = R self.connected.addCallback( lambda _: self.function(self.messages, uid) ).addCallback(result).addCallback(self._cbStopClient).addErrback( self._ebGeneral ) d = loopback.loopbackTCP(self.server, self.client, noisy=False) d.addCallback(lambda x: self.assertEqual(self.result, self.expected)) return d def testFetchUID(self): self.function = lambda m, u: self.client.fetchUID(m) self.messages = "7" self.msgObjs = [ FakeyMessage({}, (), b"", b"", 12345, None), FakeyMessage({}, (), b"", b"", 999, None), FakeyMessage({}, (), b"", b"", 10101, None), ] self.expected = { 0: {"UID": "12345"}, 1: {"UID": "999"}, 2: {"UID": "10101"}, } return self._fetchWork(0) def testFetchFlags(self, uid=0): self.function = self.client.fetchFlags self.messages = "9" self.msgObjs = [ FakeyMessage({}, ["FlagA", "FlagB", "\\FlagC"], b"", b"", 54321, None), FakeyMessage({}, ["\\FlagC", "FlagA", "FlagB"], b"", b"", 12345, None), ] self.expected = { 0: {"FLAGS": ["FlagA", "FlagB", "\\FlagC"]}, 1: {"FLAGS": ["\\FlagC", "FlagA", "FlagB"]}, } return self._fetchWork(uid) def testFetchFlagsUID(self): return self.testFetchFlags(1) def testFetchInternalDate(self, uid=0): self.function = self.client.fetchInternalDate self.messages = "13" self.msgObjs = [ FakeyMessage({}, (), b"Fri, 02 Nov 2003 21:25:10 GMT", b"", 23232, None), FakeyMessage({}, (), b"Thu, 29 Dec 2013 11:31:52 EST", b"", 101, None), FakeyMessage({}, (), b"Mon, 10 Mar 1992 02:44:30 CST", b"", 202, None), FakeyMessage({}, (), b"Sat, 11 Jan 2000 14:40:24 PST", b"", 303, None), ] self.expected = { 0: {"INTERNALDATE": "02-Nov-2003 21:25:10 +0000"}, 1: {"INTERNALDATE": "29-Dec-2013 11:31:52 -0500"}, 2: {"INTERNALDATE": "10-Mar-1992 02:44:30 -0600"}, 3: {"INTERNALDATE": "11-Jan-2000 14:40:24 -0800"}, } return self._fetchWork(uid) def testFetchInternalDateUID(self): return self.testFetchInternalDate(1) # if alternate locale is not available, the previous test will be skipped, # please install this locale for it to run. Avoid using locale.getlocale # to learn the current locale; its values don't round-trip well on all # platforms. Fortunately setlocale returns a value which does round-trip # well. currentLocale = locale.setlocale(locale.LC_ALL, None) try: locale.setlocale(locale.LC_ALL, "es_AR.UTF8") except locale.Error: noEsARLocale = True else: locale.setlocale(locale.LC_ALL, currentLocale) noEsARLocale = False @skipIf(noEsARLocale, "The es_AR.UTF8 locale is not installed.") def test_fetchInternalDateLocaleIndependent(self): """ The month name in the date is locale independent. """ # Fake that we're in a language where December is not Dec currentLocale = locale.setlocale(locale.LC_ALL, None) locale.setlocale(locale.LC_ALL, "es_AR.UTF8") self.addCleanup(locale.setlocale, locale.LC_ALL, currentLocale) return self.testFetchInternalDate(1) def testFetchEnvelope(self, uid=0): self.function = self.client.fetchEnvelope self.messages = "15" self.msgObjs = [ FakeyMessage( { "from": "user@domain", "to": "resu@domain", "date": "thursday", "subject": "it is a message", "message-id": "id-id-id-yayaya", }, (), b"", b"", 65656, None, ), ] self.expected = { 0: { "ENVELOPE": [ "thursday", "it is a message", [[None, None, "user", "domain"]], [[None, None, "user", "domain"]], [[None, None, "user", "domain"]], [[None, None, "resu", "domain"]], None, None, None, "id-id-id-yayaya", ] } } return self._fetchWork(uid) def testFetchEnvelopeUID(self): return self.testFetchEnvelope(1) def test_fetchBodyStructure(self, uid=0): """ L{IMAP4Client.fetchBodyStructure} issues a I{FETCH BODYSTRUCTURE} command and returns a Deferred which fires with a structure giving the result of parsing the server's response. The structure is a list reflecting the parenthesized data sent by the server, as described by RFC 3501, section 7.4.2. """ self.function = self.client.fetchBodyStructure self.messages = "3:9,10:*" self.msgObjs = [ FakeyMessage( { "content-type": 'text/plain; name=thing; key="value"', "content-id": "this-is-the-content-id", "content-description": "describing-the-content-goes-here!", "content-transfer-encoding": "8BIT", "content-md5": "abcdef123456", "content-disposition": "attachment; filename=monkeys", "content-language": "es", "content-location": "http://example.com/monkeys", }, (), "", b"Body\nText\nGoes\nHere\n", 919293, None, ) ] self.expected = { 0: { "BODYSTRUCTURE": [ "text", "plain", ["key", "value", "name", "thing"], "this-is-the-content-id", "describing-the-content-goes-here!", "8BIT", "20", "4", "abcdef123456", ["attachment", ["filename", "monkeys"]], "es", "http://example.com/monkeys", ] } } return self._fetchWork(uid) def testFetchBodyStructureUID(self): """ If passed C{True} for the C{uid} argument, C{fetchBodyStructure} can also issue a I{UID FETCH BODYSTRUCTURE} command. """ return self.test_fetchBodyStructure(1) def test_fetchBodyStructureMultipart(self, uid=0): """ L{IMAP4Client.fetchBodyStructure} can also parse the response to a I{FETCH BODYSTRUCTURE} command for a multipart message. """ self.function = self.client.fetchBodyStructure self.messages = "3:9,10:*" innerMessage = FakeyMessage( { "content-type": 'text/plain; name=thing; key="value"', "content-id": "this-is-the-content-id", "content-description": "describing-the-content-goes-here!", "content-transfer-encoding": "8BIT", "content-language": "fr", "content-md5": "123456abcdef", "content-disposition": "inline", "content-location": "outer space", }, (), b"", b"Body\nText\nGoes\nHere\n", 919293, None, ) self.msgObjs = [ FakeyMessage( { "content-type": 'multipart/mixed; boundary="xyz"', "content-language": "en", "content-location": "nearby", }, (), b"", b"", 919293, [innerMessage], ) ] self.expected = { 0: { "BODYSTRUCTURE": [ [ "text", "plain", ["key", "value", "name", "thing"], "this-is-the-content-id", "describing-the-content-goes-here!", "8BIT", "20", "4", "123456abcdef", ["inline", None], "fr", "outer space", ], "mixed", ["boundary", "xyz"], None, "en", "nearby", ] } } return self._fetchWork(uid) def testFetchSimplifiedBody(self, uid=0): self.function = self.client.fetchSimplifiedBody self.messages = "21" self.msgObjs = [ FakeyMessage( {}, (), b"", b"Yea whatever", 91825, [ FakeyMessage( {"content-type": "image/jpg"}, (), b"", b"Body Body Body", None, None, ) ], ) ] self.expected = {0: {"BODY": [None, None, None, None, None, None, "12"]}} return self._fetchWork(uid) def testFetchSimplifiedBodyUID(self): return self.testFetchSimplifiedBody(1) def testFetchSimplifiedBodyText(self, uid=0): self.function = self.client.fetchSimplifiedBody self.messages = "21" self.msgObjs = [ FakeyMessage( {"content-type": "text/plain"}, (), b"", b"Yea whatever", 91825, None ) ] self.expected = { 0: {"BODY": ["text", "plain", None, None, None, None, "12", "1"]} } return self._fetchWork(uid) def testFetchSimplifiedBodyTextUID(self): return self.testFetchSimplifiedBodyText(1) def testFetchSimplifiedBodyRFC822(self, uid=0): self.function = self.client.fetchSimplifiedBody self.messages = "21" self.msgObjs = [ FakeyMessage( {"content-type": "message/rfc822"}, (), b"", b"Yea whatever", 91825, [ FakeyMessage( {"content-type": "image/jpg"}, (), "", b"Body Body Body", None, None, ) ], ) ] self.expected = { 0: { "BODY": [ "message", "rfc822", None, None, None, None, "12", [ None, None, [[None, None, None]], [[None, None, None]], None, None, None, None, None, None, ], ["image", "jpg", None, None, None, None, "14"], "1", ] } } return self._fetchWork(uid) def testFetchSimplifiedBodyRFC822UID(self): return self.testFetchSimplifiedBodyRFC822(1) def test_fetchSimplifiedBodyMultipart(self): """ L{IMAP4Client.fetchSimplifiedBody} returns a dictionary mapping message sequence numbers to fetch responses for the corresponding messages. In particular, for a multipart message, the value in the dictionary maps the string C{"BODY"} to a list giving the body structure information for that message, in the form of a list of subpart body structure information followed by the subtype of the message (eg C{"alternative"} for a I{multipart/alternative} message). This structure is self-similar in the case where a subpart is itself multipart. """ self.function = self.client.fetchSimplifiedBody self.messages = "21" # A couple non-multipart messages to use as the inner-most payload singles = [ FakeyMessage( {"content-type": "text/plain"}, (), b"date", b"Stuff", 54321, None ), FakeyMessage( {"content-type": "text/html"}, (), b"date", b"Things", 32415, None ), ] # A multipart/alternative message containing the above non-multipart # messages. This will be the payload of the outer-most message. alternative = FakeyMessage( {"content-type": "multipart/alternative"}, (), b"", b"Irrelevant", 12345, singles, ) # The outer-most message, also with a multipart type, containing just # the single middle message. mixed = FakeyMessage( # The message is multipart/mixed {"content-type": "multipart/mixed"}, (), b"", b"RootOf", 98765, [alternative], ) self.msgObjs = [mixed] self.expected = { 0: { "BODY": [ [ ["text", "plain", None, None, None, None, "5", "1"], ["text", "html", None, None, None, None, "6", "1"], "alternative", ], "mixed", ] } } return self._fetchWork(False) def testFetchMessage(self, uid=0): self.function = self.client.fetchMessage self.messages = "1,3,7,10101" self.msgObjs = [ FakeyMessage({"Header": "Value"}, (), b"", b"BODY TEXT\r\n", 91, None), ] self.expected = {0: {"RFC822": "Header: Value\r\n\r\nBODY TEXT\r\n"}} return self._fetchWork(uid) def testFetchMessageUID(self): return self.testFetchMessage(1) def testFetchHeaders(self, uid=0): self.function = self.client.fetchHeaders self.messages = "9,6,2" self.msgObjs = [ FakeyMessage({"H1": "V1", "H2": "V2"}, (), b"", b"", 99, None), ] headers = nativeString(imap4._formatHeaders({"H1": "V1", "H2": "V2"})) self.expected = { 0: {"RFC822.HEADER": headers}, } return self._fetchWork(uid) def testFetchHeadersUID(self): return self.testFetchHeaders(1) def testFetchBody(self, uid=0): self.function = self.client.fetchBody self.messages = "1,2,3,4,5,6,7" self.msgObjs = [ FakeyMessage({"Header": "Value"}, (), "", b"Body goes here\r\n", 171, None), ] self.expected = { 0: {"RFC822.TEXT": "Body goes here\r\n"}, } return self._fetchWork(uid) def testFetchBodyUID(self): return self.testFetchBody(1) def testFetchBodyParts(self): """ Test the server's handling of requests for specific body sections. """ self.function = self.client.fetchSpecific self.messages = "1" outerBody = "" innerBody1 = b"Contained body message text. Squarge." innerBody2 = b"Secondary <i>message</i> text of squarge body." headers = OrderedDict() headers["from"] = "sender@host" headers["to"] = "recipient@domain" headers["subject"] = "booga booga boo" headers["content-type"] = 'multipart/alternative; boundary="xyz"' innerHeaders = OrderedDict() innerHeaders["subject"] = "this is subject text" innerHeaders["content-type"] = "text/plain" innerHeaders2 = OrderedDict() innerHeaders2["subject"] = "<b>this is subject</b>" innerHeaders2["content-type"] = "text/html" self.msgObjs = [ FakeyMessage( headers, (), None, outerBody, 123, [ FakeyMessage(innerHeaders, (), None, innerBody1, None, None), FakeyMessage(innerHeaders2, (), None, innerBody2, None, None), ], ) ] self.expected = {0: [["BODY", ["1"], "Contained body message text. Squarge."]]} def result(R): self.result = R self.connected.addCallback( lambda _: self.function(self.messages, headerNumber=1) ) self.connected.addCallback(result) self.connected.addCallback(self._cbStopClient) self.connected.addErrback(self._ebGeneral) d = loopback.loopbackTCP(self.server, self.client, noisy=False) d.addCallback(lambda ign: self.assertEqual(self.result, self.expected)) return d def test_fetchBodyPartOfNonMultipart(self): """ Single-part messages have an implicit first part which clients should be able to retrieve explicitly. Test that a client requesting part 1 of a text/plain message receives the body of the text/plain part. """ self.function = self.client.fetchSpecific self.messages = "1" parts = [1] outerBody = b"DA body" headers = OrderedDict() headers["from"] = "sender@host" headers["to"] = "recipient@domain" headers["subject"] = "booga booga boo" headers["content-type"] = "text/plain" self.msgObjs = [FakeyMessage(headers, (), None, outerBody, 123, None)] self.expected = {0: [["BODY", ["1"], "DA body"]]} def result(R): self.result = R self.connected.addCallback( lambda _: self.function(self.messages, headerNumber=parts) ) self.connected.addCallback(result) self.connected.addCallback(self._cbStopClient) self.connected.addErrback(self._ebGeneral) d = loopback.loopbackTCP(self.server, self.client, noisy=False) d.addCallback(lambda ign: self.assertEqual(self.result, self.expected)) return d def testFetchSize(self, uid=0): self.function = self.client.fetchSize self.messages = "1:100,2:*" self.msgObjs = [ FakeyMessage({}, (), b"", b"x" * 20, 123, None), ] self.expected = { 0: {"RFC822.SIZE": "20"}, } return self._fetchWork(uid) def testFetchSizeUID(self): return self.testFetchSize(1) def testFetchFull(self, uid=0): self.function = self.client.fetchFull self.messages = "1,3" self.msgObjs = [ FakeyMessage( {}, ("\\XYZ", "\\YZX", "Abc"), b"Sun, 25 Jul 2010 06:20:30 -0400 (EDT)", b"xyz" * 2, 654, None, ), FakeyMessage( {}, ("\\One", "\\Two", "Three"), b"Mon, 14 Apr 2003 19:43:44 -0400", b"abc" * 4, 555, None, ), ] self.expected = { 0: { "FLAGS": ["\\XYZ", "\\YZX", "Abc"], "INTERNALDATE": "25-Jul-2010 06:20:30 -0400", "RFC822.SIZE": "6", "ENVELOPE": [ None, None, [[None, None, None]], [[None, None, None]], None, None, None, None, None, None, ], "BODY": [None, None, None, None, None, None, "6"], }, 1: { "FLAGS": ["\\One", "\\Two", "Three"], "INTERNALDATE": "14-Apr-2003 19:43:44 -0400", "RFC822.SIZE": "12", "ENVELOPE": [ None, None, [[None, None, None]], [[None, None, None]], None, None, None, None, None, None, ], "BODY": [None, None, None, None, None, None, "12"], }, } return self._fetchWork(uid) def testFetchFullUID(self): return self.testFetchFull(1) def testFetchAll(self, uid=0): self.function = self.client.fetchAll self.messages = "1,2:3" self.msgObjs = [ FakeyMessage( {}, (), b"Mon, 14 Apr 2003 19:43:44 +0400", b"Lalala", 10101, None ), FakeyMessage( {}, (), b"Tue, 15 Apr 2003 19:43:44 +0200", b"Alalal", 20202, None ), ] self.expected = { 0: { "ENVELOPE": [ None, None, [[None, None, None]], [[None, None, None]], None, None, None, None, None, None, ], "RFC822.SIZE": "6", "INTERNALDATE": "14-Apr-2003 19:43:44 +0400", "FLAGS": [], }, 1: { "ENVELOPE": [ None, None, [[None, None, None]], [[None, None, None]], None, None, None, None, None, None, ], "RFC822.SIZE": "6", "INTERNALDATE": "15-Apr-2003 19:43:44 +0200", "FLAGS": [], }, } return self._fetchWork(uid) def testFetchAllUID(self): return self.testFetchAll(1) def testFetchFast(self, uid=0): self.function = self.client.fetchFast self.messages = "1" self.msgObjs = [ FakeyMessage({}, ("\\X",), b"19 Mar 2003 19:22:21 -0500", b"", 9, None), ] self.expected = { 0: { "FLAGS": ["\\X"], "INTERNALDATE": "19-Mar-2003 19:22:21 -0500", "RFC822.SIZE": "0", }, } return self._fetchWork(uid) def testFetchFastUID(self): return self.testFetchFast(1) class DefaultSearchTests(IMAP4HelperMixin, TestCase): """ Test the behavior of the server's SEARCH implementation, particularly in the face of unhandled search terms. """ def setUp(self): self.server = imap4.IMAP4Server() self.server.state = "select" self.server.mbox = self self.connected = defer.Deferred() self.client = SimpleClient(self.connected) self.msgObjs = [ FakeyMessage({}, (), b"", b"", 999, None), FakeyMessage({}, (), b"", b"", 10101, None), FakeyMessage({}, (), b"", b"", 12345, None), FakeyMessage({}, (), b"", b"", 20001, None), FakeyMessage({}, (), b"", b"", 20002, None), ] def fetch(self, messages, uid): """ Pretend to be a mailbox and let C{self.server} lookup messages on me. """ return list(zip(range(1, len(self.msgObjs) + 1), self.msgObjs)) def _messageSetSearchTest(self, queryTerms, expectedMessages): """ Issue a search with given query and verify that the returned messages match the given expected messages. @param queryTerms: A string giving the search query. @param expectedMessages: A list of the message sequence numbers expected as the result of the search. @return: A L{Deferred} which fires when the test is complete. """ def search(): return self.client.search(queryTerms) d = self.connected.addCallback(strip(search)) def searched(results): self.assertEqual(results, expectedMessages) d.addCallback(searched) d.addCallback(self._cbStopClient) d.addErrback(self._ebGeneral) self.loopback() return d def test_searchMessageSet(self): """ Test that a search which starts with a message set properly limits the search results to messages in that set. """ return self._messageSetSearchTest("1", [1]) def test_searchMessageSetWithStar(self): """ If the search filter ends with a star, all the message from the starting point are returned. """ return self._messageSetSearchTest("2:*", [2, 3, 4, 5]) def test_searchMessageSetWithStarFirst(self): """ If the search filter starts with a star, the result should be identical with if the filter would end with a star. """ return self._messageSetSearchTest("*:2", [2, 3, 4, 5]) def test_searchMessageSetUIDWithStar(self): """ If the search filter ends with a star, all the message from the starting point are returned (also for the SEARCH UID case). """ return self._messageSetSearchTest("UID 10000:*", [2, 3, 4, 5]) def test_searchMessageSetUIDWithStarFirst(self): """ If the search filter starts with a star, the result should be identical with if the filter would end with a star (also for the SEARCH UID case). """ return self._messageSetSearchTest("UID *:10000", [2, 3, 4, 5]) def test_searchMessageSetUIDWithStarAndHighStart(self): """ A search filter of 1234:* should include the UID of the last message in the mailbox, even if its UID is less than 1234. """ # in our fake mbox the highest message UID is 20002 return self._messageSetSearchTest("UID 30000:*", [5]) def test_searchMessageSetWithList(self): """ If the search filter contains nesting terms, one of which includes a message sequence set with a wildcard, IT ALL WORKS GOOD. """ # 6 is bigger than the biggest message sequence number, but that's # okay, because N:* includes the biggest message sequence number even # if N is bigger than that (read the rfc nub). return self._messageSetSearchTest("(6:*)", [5]) def test_searchOr(self): """ If the search filter contains an I{OR} term, all messages which match either subexpression are returned. """ return self._messageSetSearchTest("OR 1 2", [1, 2]) def test_searchOrMessageSet(self): """ If the search filter contains an I{OR} term with a subexpression which includes a message sequence set wildcard, all messages in that set are considered for inclusion in the results. """ return self._messageSetSearchTest("OR 2:* 2:*", [2, 3, 4, 5]) def test_searchNot(self): """ If the search filter contains a I{NOT} term, all messages which do not match the subexpression are returned. """ return self._messageSetSearchTest("NOT 3", [1, 2, 4, 5]) def test_searchNotMessageSet(self): """ If the search filter contains a I{NOT} term with a subexpression which includes a message sequence set wildcard, no messages in that set are considered for inclusion in the result. """ return self._messageSetSearchTest("NOT 2:*", [1]) def test_searchAndMessageSet(self): """ If the search filter contains multiple terms implicitly conjoined with a message sequence set wildcard, only the intersection of the results of each term are returned. """ return self._messageSetSearchTest("2:* 3", [3]) def test_searchInvalidCriteria(self): """ If the search criteria is not a valid key, a NO result is returned to the client (resulting in an error callback), and an IllegalQueryError is logged on the server side. """ queryTerms = "FOO" def search(): return self.client.search(queryTerms) d = self.connected.addCallback(strip(search)) d = self.assertFailure(d, imap4.IMAP4Exception) def errorReceived(results): """ Verify that the server logs an IllegalQueryError and the client raises an IMAP4Exception with 'Search failed:...' """ self.client.transport.loseConnection() self.server.transport.loseConnection() # Check what the server logs errors = self.flushLoggedErrors(imap4.IllegalQueryError) self.assertEqual(len(errors), 1) # Verify exception given to client has the correct message self.assertEqual( str(b"SEARCH failed: Invalid search command FOO"), str(results), ) d.addCallback(errorReceived) d.addErrback(self._ebGeneral) self.loopback() return d @implementer(imap4.ISearchableMailbox) class FetchSearchStoreTests(TestCase, IMAP4HelperMixin): def setUp(self): self.expected = self.result = None self.server_received_query = None self.server_received_uid = None self.server_received_parts = None self.server_received_messages = None self.server = imap4.IMAP4Server() self.server.state = "select" self.server.mbox = self self.connected = defer.Deferred() self.client = SimpleClient(self.connected) def search(self, query, uid): # Look for a specific bad query, so we can verify we handle it properly if query == [b"FOO"]: raise imap4.IllegalQueryError("FOO is not a valid search criteria") self.server_received_query = query self.server_received_uid = uid return self.expected def addListener(self, *a, **kw): pass removeListener = addListener def _searchWork(self, uid): def search(): return self.client.search(self.query, uid=uid) def result(R): self.result = R self.connected.addCallback(strip(search)).addCallback(result).addCallback( self._cbStopClient ).addErrback(self._ebGeneral) def check(ignored): # Ensure no short-circuiting weirdness is going on self.assertFalse(self.result is self.expected) self.assertEqual(self.result, self.expected) self.assertEqual(self.uid, self.server_received_uid) self.assertEqual( # Queries should be decoded as ASCII unless a charset # identifier is provided. See #9201. imap4.parseNestedParens(self.query.encode("charmap")), self.server_received_query, ) d = loopback.loopbackTCP(self.server, self.client, noisy=False) d.addCallback(check) return d def testSearch(self): self.query = imap4.Or( imap4.Query(header=("subject", "substring")), imap4.Query(larger=1024, smaller=4096), ) self.expected = [1, 4, 5, 7] self.uid = 0 return self._searchWork(0) def testUIDSearch(self): self.query = imap4.Or( imap4.Query(header=("subject", "substring")), imap4.Query(larger=1024, smaller=4096), ) self.uid = 1 self.expected = [1, 2, 3] return self._searchWork(1) def getUID(self, msg): try: return self.expected[msg]["UID"] except (TypeError, IndexError): return self.expected[msg - 1] except KeyError: return 42 def fetch(self, messages, uid): self.server_received_uid = uid self.server_received_messages = str(messages) return self.expected def _fetchWork(self, fetch): def result(R): self.result = R self.connected.addCallback(strip(fetch)).addCallback(result).addCallback( self._cbStopClient ).addErrback(self._ebGeneral) def check(ignored): # Ensure no short-circuiting weirdness is going on self.assertFalse(self.result is self.expected) self.parts and self.parts.sort() self.server_received_parts and self.server_received_parts.sort() if self.uid: for (k, v) in self.expected.items(): v["UID"] = str(k) self.assertEqual(self.result, self.expected) self.assertEqual(self.uid, self.server_received_uid) self.assertEqual(self.parts, self.server_received_parts) self.assertEqual( imap4.parseIdList(self.messages), imap4.parseIdList(self.server_received_messages), ) d = loopback.loopbackTCP(self.server, self.client, noisy=False) d.addCallback(check) return d def test_invalidTerm(self): """ If, as part of a search, an ISearchableMailbox raises an IllegalQueryError (e.g. due to invalid search criteria), client sees a failure response, and an IllegalQueryError is logged on the server. """ query = "FOO" def search(): return self.client.search(query) d = self.connected.addCallback(strip(search)) d = self.assertFailure(d, imap4.IMAP4Exception) def errorReceived(results): """ Verify that the server logs an IllegalQueryError and the client raises an IMAP4Exception with 'Search failed:...' """ self.client.transport.loseConnection() self.server.transport.loseConnection() # Check what the server logs errors = self.flushLoggedErrors(imap4.IllegalQueryError) self.assertEqual(len(errors), 1) # Verify exception given to client has the correct message self.assertEqual( str(b"SEARCH failed: FOO is not a valid search criteria"), str(results) ) d.addCallback(errorReceived) d.addErrback(self._ebGeneral) self.loopback() return d class FakeMailbox: def __init__(self): self.args = [] def addMessage(self, body, flags, date): self.args.append((body, flags, date)) return defer.succeed(None) @implementer(imap4.IMessageFile) class FeaturefulMessage: def getFlags(self): return "flags" def getInternalDate(self): return "internaldate" def open(self): return BytesIO(b"open") @implementer(imap4.IMessageCopier) class MessageCopierMailbox: def __init__(self): self.msgs = [] def copy(self, msg): self.msgs.append(msg) return len(self.msgs) class CopyWorkerTests(TestCase): def testFeaturefulMessage(self): s = imap4.IMAP4Server() # Yes. I am grabbing this uber-non-public method to test it. # It is complex. It needs to be tested directly! # Perhaps it should be refactored, simplified, or split up into # not-so-private components, but that is a task for another day. # Ha ha! Addendum! Soon it will be split up, and this test will # be re-written to just use the default adapter for IMailbox to # IMessageCopier and call .copy on that adapter. f = s._IMAP4Server__cbCopy m = FakeMailbox() d = f([(i, FeaturefulMessage()) for i in range(1, 11)], "tag", m) def cbCopy(results): for a in m.args: self.assertEqual(a[0].read(), b"open") self.assertEqual(a[1], "flags") self.assertEqual(a[2], "internaldate") for (status, result) in results: self.assertTrue(status) self.assertEqual(result, None) return d.addCallback(cbCopy) def testUnfeaturefulMessage(self): s = imap4.IMAP4Server() # See above comment f = s._IMAP4Server__cbCopy m = FakeMailbox() msgs = [ FakeyMessage( {"Header-Counter": str(i)}, (), b"Date", b"Body %d" % (i,), i + 10, None ) for i in range(1, 11) ] d = f([im for im in zip(range(1, 11), msgs)], "tag", m) def cbCopy(results): seen = [] for a in m.args: seen.append(a[0].read()) self.assertEqual(a[1], ()) self.assertEqual(a[2], b"Date") seen.sort() exp = sorted( b"Header-Counter: %d\r\n\r\nBody %d" % (i, i) for i in range(1, 11) ) self.assertEqual(seen, exp) for (status, result) in results: self.assertTrue(status) self.assertEqual(result, None) return d.addCallback(cbCopy) def testMessageCopier(self): s = imap4.IMAP4Server() # See above comment f = s._IMAP4Server__cbCopy m = MessageCopierMailbox() msgs = [object() for i in range(1, 11)] d = f([im for im in zip(range(1, 11), msgs)], b"tag", m) def cbCopy(results): self.assertEqual(results, list(zip([1] * 10, range(1, 11)))) for (orig, new) in zip(msgs, m.msgs): self.assertIdentical(orig, new) return d.addCallback(cbCopy) @skipIf(not ClientTLSContext, "OpenSSL not present") @skipIf(not interfaces.IReactorSSL(reactor, None), "Reactor doesn't support SSL") class TLSTests(IMAP4HelperMixin, TestCase): serverCTX = None clientCTX = None if ServerTLSContext: serverCTX = ServerTLSContext() if ClientTLSContext: clientCTX = ClientTLSContext() def loopback(self): return loopback.loopbackTCP(self.server, self.client, noisy=False) def testAPileOfThings(self): SimpleServer.theAccount.addMailbox(b"inbox") called = [] def login(): called.append(None) return self.client.login(b"testuser", b"password-test") def list(): called.append(None) return self.client.list(b"inbox", b"%") def status(): called.append(None) return self.client.status(b"inbox", "UIDNEXT") def examine(): called.append(None) return self.client.examine(b"inbox") def logout(): called.append(None) return self.client.logout() self.client.requireTransportSecurity = True methods = [login, list, status, examine, logout] for method in methods: self.connected.addCallback(strip(method)) self.connected.addCallbacks(self._cbStopClient, self._ebGeneral) def check(ignored): self.assertEqual(self.server.startedTLS, True) self.assertEqual(self.client.startedTLS, True) self.assertEqual(len(called), len(methods)) d = self.loopback() d.addCallback(check) return d def testLoginLogin(self): self.server.checker.addUser(b"testuser", b"password-test") success = [] self.client.registerAuthenticator(imap4.LOGINAuthenticator(b"testuser")) self.connected.addCallback( lambda _: self.client.authenticate(b"password-test") ).addCallback(lambda _: self.client.logout()).addCallback( success.append ).addCallback( self._cbStopClient ).addErrback( self._ebGeneral ) d = self.loopback() d.addCallback(lambda x: self.assertEqual(len(success), 1)) return d def startTLSAndAssertSession(self): """ Begin a C{STARTTLS} sequence and assert that it results in a TLS session. @return: A L{Deferred} that fires when the underlying connection between the client and server has been terminated. """ success = [] self.connected.addCallback(strip(self.client.startTLS)) def checkSecure(ignored): self.assertTrue(interfaces.ISSLTransport.providedBy(self.client.transport)) self.connected.addCallback(checkSecure) self.connected.addCallback(success.append) d = self.loopback() d.addCallback(lambda x: self.assertTrue(success)) return defer.gatherResults([d, self.connected]) def test_startTLS(self): """ L{IMAP4Client.startTLS} triggers TLS negotiation and returns a L{Deferred} which fires after the client's transport is using encryption. """ disconnected = self.startTLSAndAssertSession() self.connected.addCallback(self._cbStopClient) self.connected.addErrback(self._ebGeneral) return disconnected def test_doubleSTARTTLS(self): """ A server that receives a second C{STARTTLS} sends a C{NO} response. """ class DoubleSTARTTLSClient(SimpleClient): def startTLS(self): if not self.startedTLS: return SimpleClient.startTLS(self) return self.sendCommand(imap4.Command(b"STARTTLS")) self.client = DoubleSTARTTLSClient( self.connected, contextFactory=self.clientCTX ) disconnected = self.startTLSAndAssertSession() self.connected.addCallback(strip(self.client.startTLS)) self.connected.addErrback( self.assertClientFailureMessage, b"TLS already negotiated" ) self.connected.addCallback(self._cbStopClient) self.connected.addErrback(self._ebGeneral) return disconnected def test_startTLSWithExistingChallengers(self): """ Starting a TLS negotiation with an L{IMAP4Server} that already has C{LOGIN} and C{PLAIN} L{IChallengeResponse} factories uses those factories. """ self.server.challengers = { b"LOGIN": imap4.LOGINCredentials, b"PLAIN": imap4.PLAINCredentials, } @defer.inlineCallbacks def assertLOGINandPLAIN(): capabilities = yield self.client.getCapabilities() self.assertIn(b"AUTH", capabilities) self.assertIn(b"LOGIN", capabilities[b"AUTH"]) self.assertIn(b"PLAIN", capabilities[b"AUTH"]) self.connected.addCallback(strip(assertLOGINandPLAIN)) disconnected = self.startTLSAndAssertSession() self.connected.addCallback(strip(assertLOGINandPLAIN)) self.connected.addCallback(self._cbStopClient) self.connected.addErrback(self._ebGeneral) return disconnected def test_loginBeforeSTARTTLS(self): """ A client that attempts to log in before issuing the C{STARTTLS} command receives a C{NO} response. """ # Prevent the client from issuing STARTTLS. self.client.startTLS = lambda: defer.succeed( ([], "OK Begin TLS negotiation now") ) self.connected.addCallback( lambda _: self.client.login(b"wrong", b"time"), ) self.connected.addErrback( self.assertClientFailureMessage, b"LOGIN is disabled before STARTTLS", ) self.connected.addCallback(self._cbStopClient) self.connected.addErrback(self._ebGeneral) return defer.gatherResults([self.loopback(), self.connected]) def testFailedStartTLS(self): failures = [] def breakServerTLS(ign): self.server.canStartTLS = False self.connected.addCallback(breakServerTLS) self.connected.addCallback(lambda ign: self.client.startTLS()) self.connected.addErrback( lambda err: failures.append(err.trap(imap4.IMAP4Exception)) ) self.connected.addCallback(self._cbStopClient) self.connected.addErrback(self._ebGeneral) def check(ignored): self.assertTrue(failures) self.assertIdentical(failures[0], imap4.IMAP4Exception) return self.loopback().addCallback(check) class SlowMailbox(SimpleMailbox): howSlow = 2 callLater = None fetchDeferred = None # Not a very nice implementation of fetch(), but it'll # do for the purposes of testing. def fetch(self, messages, uid): d = defer.Deferred() self.callLater(self.howSlow, d.callback, ()) self.fetchDeferred.callback(None) return d class TimeoutTests(IMAP4HelperMixin, TestCase): def test_serverTimeout(self): """ The *client* has a timeout mechanism which will close connections that are inactive for a period. """ c = Clock() self.server.timeoutTest = True self.client.timeout = 5 # seconds self.client.callLater = c.callLater self.selectedArgs = None def login(): d = self.client.login(b"testuser", b"password-test") c.advance(5) d.addErrback(timedOut) return d def timedOut(failure): self._cbStopClient(None) failure.trap(error.TimeoutError) d = self.connected.addCallback(strip(login)) d.addErrback(self._ebGeneral) return defer.gatherResults([d, self.loopback()]) def test_serverTimesOut(self): """ The server times out a connection. """ c = Clock() self.server.callLater = c.callLater def login(): return self.client.login(b"testuser", b"password-test") def expireTime(): c.advance(self.server.POSTAUTH_TIMEOUT * 2) d = self.connected.addCallback(strip(login)) d.addCallback(strip(expireTime)) # The loopback method's Deferred fires the connection is # closed, and the server closes the connection as a result of # expireTime. return defer.gatherResults([d, self.loopback()]) def test_serverUnselectsMailbox(self): """ The server unsets the selected mailbox when timing out a connection. """ self.patch(SimpleServer.theAccount, "mailboxFactory", UncloseableMailbox) SimpleServer.theAccount.addMailbox("mailbox-test") mbox = SimpleServer.theAccount.mailboxes["MAILBOX-TEST"] self.assertFalse(ICloseableMailboxIMAP.providedBy(mbox)) c = Clock() self.server.callLater = c.callLater def login(): return self.client.login(b"testuser", b"password-test") def select(): return self.client.select("mailbox-test") def assertSet(): self.assertIs(mbox, self.server.mbox) def expireTime(): c.advance(self.server.POSTAUTH_TIMEOUT * 2) def assertUnset(): self.assertFalse(self.server.mbox) d = self.connected.addCallback(strip(login)) d.addCallback(strip(select)) d.addCallback(strip(assertSet)) d.addCallback(strip(expireTime)) d.addCallback(strip(assertUnset)) # The loopback method's Deferred fires the connection is # closed, and the server closes the connection as a result of # expireTime. return defer.gatherResults([d, self.loopback()]) def test_serverTimesOutAndClosesMailbox(self): """ The server closes the selected, closeable mailbox when timing out a connection. """ SimpleServer.theAccount.addMailbox("mailbox-test") mbox = SimpleServer.theAccount.mailboxes["MAILBOX-TEST"] verifyObject(ICloseableMailboxIMAP, mbox) c = Clock() self.server.callLater = c.callLater def login(): return self.client.login(b"testuser", b"password-test") def select(): return self.client.select("mailbox-test") def assertMailboxOpen(): self.assertFalse(mbox.closed) def expireTime(): c.advance(self.server.POSTAUTH_TIMEOUT * 2) def assertMailboxClosed(): self.assertTrue(mbox.closed) d = self.connected.addCallback(strip(login)) d.addCallback(strip(select)) d.addCallback(strip(assertMailboxOpen)) d.addCallback(strip(expireTime)) d.addCallback(strip(assertMailboxClosed)) # The loopback method's Deferred fires the connection is # closed, and the server closes the connection as a result of # expireTime. return defer.gatherResults([d, self.loopback()]) def test_longFetchDoesntTimeout(self): """ The connection timeout does not take effect during fetches. """ c = Clock() SlowMailbox.callLater = c.callLater SlowMailbox.fetchDeferred = defer.Deferred() self.server.callLater = c.callLater SimpleServer.theAccount.mailboxFactory = SlowMailbox SimpleServer.theAccount.addMailbox("mailbox-test") self.server.setTimeout(1) def login(): return self.client.login(b"testuser", b"password-test") def select(): self.server.setTimeout(1) return self.client.select("mailbox-test") def fetch(): return self.client.fetchUID("1:*") def stillConnected(): self.assertNotEqual(self.server.state, "timeout") def cbAdvance(ignored): for i in range(4): c.advance(0.5) SlowMailbox.fetchDeferred.addCallback(cbAdvance) d1 = self.connected.addCallback(strip(login)) d1.addCallback(strip(select)) d1.addCallback(strip(fetch)) d1.addCallback(strip(stillConnected)) d1.addCallback(self._cbStopClient) d1.addErrback(self._ebGeneral) d = defer.gatherResults([d1, self.loopback()]) return d def test_idleClientDoesDisconnect(self): """ The *server* has a timeout mechanism which will close connections that are inactive for a period. """ c = Clock() # Hook up our server protocol transport = StringTransportWithDisconnection() transport.protocol = self.server self.server.callLater = c.callLater self.server.makeConnection(transport) # Make sure we can notice when the connection goes away lost = [] connLost = self.server.connectionLost self.server.connectionLost = lambda reason: ( lost.append(None), connLost(reason), )[1] # 2/3rds of the idle timeout elapses... c.pump([0.0] + [self.server.timeOut / 3.0] * 2) self.assertFalse(lost, lost) # Now some more c.pump([0.0, self.server.timeOut / 2.0]) self.assertTrue(lost) class DisconnectionTests(TestCase): def testClientDisconnectFailsDeferreds(self): c = imap4.IMAP4Client() t = StringTransportWithDisconnection() c.makeConnection(t) d = self.assertFailure( c.login(b"testuser", "example.com"), error.ConnectionDone ) c.connectionLost(error.ConnectionDone("Connection closed")) return d class SynchronousMailbox: """ Trivial, in-memory mailbox implementation which can produce a message synchronously. """ def __init__(self, messages): self.messages = messages def fetch(self, msgset, uid): assert not uid, "Cannot handle uid requests." for msg in msgset: yield msg, self.messages[msg - 1] class PipeliningTests(TestCase): """ Tests for various aspects of the IMAP4 server's pipelining support. """ messages = [ FakeyMessage({}, [], b"", b"0", None, None), FakeyMessage({}, [], b"", b"1", None, None), FakeyMessage({}, [], b"", b"2", None, None), ] def setUp(self): self.iterators = [] self.transport = StringTransport() self.server = imap4.IMAP4Server(None, None, self.iterateInReactor) self.server.makeConnection(self.transport) mailbox = SynchronousMailbox(self.messages) # Skip over authentication and folder selection self.server.state = "select" self.server.mbox = mailbox # Get rid of any greeting junk self.transport.clear() def iterateInReactor(self, iterator): """ A fake L{imap4.iterateInReactor} that records the iterators it receives. @param iterator: An iterator. @return: A L{Deferred} associated with this iterator. """ d = defer.Deferred() self.iterators.append((iterator, d)) return d def flushPending(self, asLongAs=lambda: True): """ Advance pending iterators enqueued with L{iterateInReactor} in a round-robin fashion, resuming the transport's producer until it has completed. This ensures bodies are flushed. @param asLongAs: (optional) An optional predicate function. Flushing iterators continues as long as there are iterators and this returns L{True}. """ while self.iterators and asLongAs(): for e in self.iterators[0][0]: while self.transport.producer: self.transport.producer.resumeProducing() else: self.iterators.pop(0)[1].callback(None) def tearDown(self): self.server.connectionLost(failure.Failure(error.ConnectionDone())) def test_synchronousFetch(self): """ Test that pipelined FETCH commands which can be responded to synchronously are responded to correctly. """ # Here's some pipelined stuff self.server.dataReceived( b"01 FETCH 1 BODY[]\r\n" b"02 FETCH 2 BODY[]\r\n" b"03 FETCH 3 BODY[]\r\n" ) self.flushPending() self.assertEqual( self.transport.value(), b"".join( [ b"* 1 FETCH (BODY[] )\r\n", networkString( "01 OK FETCH completed\r\n{5}\r\n\r\n\r\n%s" % (nativeString(self.messages[0].getBodyFile().read()),) ), b"* 2 FETCH (BODY[] )\r\n", networkString( "02 OK FETCH completed\r\n{5}\r\n\r\n\r\n%s" % (nativeString(self.messages[1].getBodyFile().read()),) ), b"* 3 FETCH (BODY[] )\r\n", networkString( "03 OK FETCH completed\r\n{5}\r\n\r\n\r\n%s" % (nativeString(self.messages[2].getBodyFile().read()),) ), ] ), ) def test_bufferedServerStatus(self): """ When a server status change occurs during an ongoing FETCH command, the server status is buffered until the FETCH completes. """ self.server.dataReceived(b"01 FETCH 1,2 BODY[]\r\n") # Two iterations yields the untagged response and the first # fetched message's body twice = functools.partial(next, iter([True, True, False])) self.flushPending(asLongAs=twice) self.assertEqual( self.transport.value(), b"".join( [ # The untagged response... b"* 1 FETCH (BODY[] )\r\n", # ...and its body networkString( "{5}\r\n\r\n\r\n%s" % (nativeString(self.messages[0].getBodyFile().read()),) ), ] ), ) self.transport.clear() # A server status change... self.server.modeChanged(writeable=True) # ...remains buffered... self.assertFalse(self.transport.value()) self.flushPending() self.assertEqual( self.transport.value(), b"".join( [ # The untagged response... b"* 2 FETCH (BODY[] )\r\n", # ...the status change... b"* [READ-WRITE]\r\n", # ...and the completion status and final message's body networkString( "01 OK FETCH completed\r\n{5}\r\n\r\n\r\n%s" % (nativeString(self.messages[1].getBodyFile().read()),) ), ] ), ) class IMAP4ServerFetchTests(TestCase): """ This test case is for the FETCH tests that require a C{StringTransport}. """ def setUp(self): self.transport = StringTransport() self.server = imap4.IMAP4Server() self.server.state = "select" self.server.makeConnection(self.transport) def test_fetchWithPartialValidArgument(self): """ If by any chance, extra bytes got appended at the end of a valid FETCH arguments, the client should get a BAD - arguments invalid response. See U{RFC 3501<http://tools.ietf.org/html/rfc3501#section-6.4.5>}, section 6.4.5, """ # We need to clear out the welcome message. self.transport.clear() # Let's send out the faulty command. self.server.dataReceived(b"0001 FETCH 1 FULLL\r\n") expected = b"0001 BAD Illegal syntax: Invalid Argument\r\n" self.assertEqual(self.transport.value(), expected) self.transport.clear() self.server.connectionLost(error.ConnectionDone("Connection closed")) class LiteralTestsMixin: """ Shared tests for literal classes. @ivar literalFactory: A callable that returns instances of the literal under test. """ def setUp(self): """ Shared setup. """ self.deferred = defer.Deferred() def test_partialWrite(self): """ The literal returns L{None} when given less data than the literal requires. """ literal = self.literalFactory(1024, self.deferred) self.assertIs(None, literal.write(b"incomplete")) self.assertNoResult(self.deferred) def test_exactWrite(self): """ The literal returns an empty L{bytes} instance when given exactly the data the literal requires. """ data = b"complete" literal = self.literalFactory(len(data), self.deferred) leftover = literal.write(data) self.assertIsInstance(leftover, bytes) self.assertFalse(leftover) self.assertNoResult(self.deferred) def test_overlongWrite(self): """ The literal returns any left over L{bytes} when given more data than the literal requires. """ data = b"completeleftover" literal = self.literalFactory(len(b"complete"), self.deferred) leftover = literal.write(data) self.assertEqual(leftover, b"leftover") def test_emptyLiteral(self): """ The literal returns an empty L{bytes} instance when given an empty L{bytes} instance. """ literal = self.literalFactory(0, self.deferred) data = b"leftover" leftover = literal.write(data) self.assertEqual(leftover, data) class LiteralStringTests(LiteralTestsMixin, SynchronousTestCase): """ Tests for L{self.literalFactory}. """ literalFactory = imap4.LiteralString def test_callback(self): """ Calling L{imap4.LiteralString.callback} with a line fires the instance's L{Deferred} with a 2-L{tuple} whose first element is the collected data and whose second is the provided line. """ data = b"data" extra = b"extra" literal = imap4.LiteralString(len(data), self.deferred) for c in iterbytes(data): literal.write(c) literal.callback(b"extra") result = self.successResultOf(self.deferred) self.assertEqual(result, (data, extra)) class LiteralFileTests(LiteralTestsMixin, TestCase): """ Tests for L{imap4.LiteralFile}. """ literalFactory = imap4.LiteralFile def test_callback(self): """ Calling L{imap4.LiteralFile.callback} with a line fires the instance's L{Deferred} with a 2-L{tuple} whose first element is the file and whose second is the provided line. """ data = b"data" extra = b"extra" literal = imap4.LiteralFile(len(data), self.deferred) for c in iterbytes(data): literal.write(c) literal.callback(b"extra") result = self.successResultOf(self.deferred) self.assertEqual(len(result), 2) dataFile, extra = result self.assertEqual(dataFile.read(), b"data") def test_callbackSpooledToDisk(self): """ A L{imap4.LiteralFile} whose size exceeds the maximum in-memory size spools its content to disk, and invoking its L{callback} with a line fires the instance's L{Deferred} with a 2-L{tuple} whose first element is the spooled file and whose second is the provided line. """ data = b"data" extra = b"extra" self.patch(imap4.LiteralFile, "_memoryFileLimit", 1) literal = imap4.LiteralFile(len(data), self.deferred) for c in iterbytes(data): literal.write(c) literal.callback(b"extra") result = self.successResultOf(self.deferred) self.assertEqual(len(result), 2) dataFile, extra = result self.assertEqual(dataFile.read(), b"data") class WriteBufferTests(SynchronousTestCase): """ Tests for L{imap4.WriteBuffer}. """ def setUp(self): self.transport = StringTransport() def test_partialWrite(self): """ L{imap4.WriteBuffer} buffers writes that are smaller than its buffer size. """ buf = imap4.WriteBuffer(self.transport) data = b"x" * buf.bufferSize buf.write(data) self.assertFalse(self.transport.value()) def test_overlongWrite(self): """ L{imap4.WriteBuffer} writes data without buffering it when the size of the data exceeds the size of its buffer. """ buf = imap4.WriteBuffer(self.transport) data = b"x" * (buf.bufferSize + 1) buf.write(data) self.assertEqual(self.transport.value(), data) def test_writesImplyFlush(self): """ L{imap4.WriteBuffer} buffers writes until its buffer's size exceeds its maximum value. """ buf = imap4.WriteBuffer(self.transport) firstData = b"x" * buf.bufferSize secondData = b"y" buf.write(firstData) self.assertFalse(self.transport.value()) buf.write(secondData) self.assertEqual(self.transport.value(), firstData + secondData) def test_explicitFlush(self): """ L{imap4.WriteBuffer.flush} flushes the buffer even when its size is smaller than the buffer size. """ buf = imap4.WriteBuffer(self.transport) data = b"x" * (buf.bufferSize) buf.write(data) self.assertFalse(self.transport.value()) buf.flush() self.assertEqual(self.transport.value(), data) def test_explicitFlushEmptyBuffer(self): """ L{imap4.WriteBuffer.flush} has no effect if when the buffer is empty. """ buf = imap4.WriteBuffer(self.transport) buf.flush() self.assertFalse(self.transport.value()) PK Mb�ZCJ�[� � 4 mail/test/__pycache__/pop3testserver.cpython-310.pycnu �[��� o 5�@g# � @ s� d dl Z d dlmZ d dlmZ d dlmZ dZdZdZ da da d a d a d ad ad ad ad ad ad a d Zg d �Zd Zd ZdZdZdZdZ dZ dZ dZ dZ dZ!dZ"dZ#G dd� dej$�Z%dZ&d d � Z'd d � Z(d d!� Z)e*d"krse)� dS dS )#� N)�reactor)�Factory)�basic�test�twistediL TFs( +OK POP3 localhost v2003.83 server ready)s TOPs LOGIN-DELAY 180� USERs SASL LOGIN� STLS� UIDLs -ERR Unknown requests +OK Command Completeds -ERR LOGIN faileds +OK Mailbox open, 0 messagess* -ERR server side error start TLS handshakes +OK quit completeds' -ERR Unknown AUHORIZATION state commands +OK 0 0s +OK Unique-ID listing follows .s# +OK Mailbox scan listing follows .s +OK Capability list follows:c @ sf e Zd Zddd�Zdd� Zdd� Zdd � Zd d � Zd d � Zdd� Z dd� Z dd� Z dd� Z dd� Z dS )�POP3TestServerNc C s d| _ d | _d | _|| _d S )NF)�loggedIn�caps�tmpUser�ctx)�self�contextFactory� r �B/usr/lib/python3/dist-packages/twisted/mail/test/pop3testserver.py�__init__6 s zPOP3TestServer.__init__c C � | � t� d S �N)�sendLine�STAT�r �reqr r r � sendSTATResp< � zPOP3TestServer.sendSTATRespc C r r )r �UIDLr r r r � sendUIDLResp? r zPOP3TestServer.sendUIDLRespc C r r )r �LISTr r r r � sendLISTRespB r zPOP3TestServer.sendLISTRespc C sj | j d u r tg| _ tr| j �t� tr| j �t� tD ]}| j �|� qd�| j �}|d7 }| � |� d S )Ns s .) r � CAP_START� UIDL_SUPPORT�append�CAPABILITIES_UIDL� SSL_SUPPORT�CAPABILITIES_SSL� CAPABILITIES�joinr )r �cap�respr r r �sendCapabilitiesE s z POP3TestServer.sendCapabilitiesc C s2 t r| �� d S trt�d| j� d S | �� d S )N� )�DENY_CONNECTION� disconnect� SLOW_GREETINGr � callLater� sendGreeting�r r r r �connectionMadeV s z POP3TestServer.connectionMadec C r r )r �CONNECTION_MADEr1 r r r r0 a r zPOP3TestServer.sendGreetingc s |� � � � fdd�}trdS tr| �� dS |d�r)tr#| �t� dS | �� dS |d�r5tr5| � � dS |d�rct rB| �t� dS d}z |� d�d | _ t }W n ty[ t}Y nw | �|� dS |d �r�d}z&|� d�d }| j du sz|du r}t}n| j tkr�|tkr�t}d | _nt}W n ty� t}Y nw | �|� dS |d �r�d | _| �t� | �� dS tr�| �t� dS | js�| �t� dS |d �r�| �t � dS |d�r�tr�dS | �t� dS |d�r�tr�dS | �t� dS |d��r tr�dS t�s| �t� dS | �t� dS dS )zError Conditionsc s � � | �dkS )N���)�find)�s��uliner r �<lambda>h s z-POP3TestServer.lineReceived.<locals>.<lambda>Ns CAPAr r � � s PASSTs QUITFs NOOPs STATs LISTr ) �upper�TIMEOUT_RESPONSE�DROP_CONNECTIONr- �INVALID_CAPABILITY_RESPONSEr �INVALID_RESPONSEr* r$ �startTLS�INVALID_LOGIN_RESPONSE�splitr �VALID_RESPONSE� BaseException� AUTH_DECLINED�USER�PASS� AUTH_ACCEPTEDr �LOGOUT_COMPLETE�INVALID_SERVER_RESPONSE� NOT_LOGGED_IN�TIMEOUT_DEFERREDr r r! r )r �liner5 r) �pwdr r7 r � lineReceivedd s� �� � �zPOP3TestServer.lineReceivedc C sJ | j d u r | �� tr | j d ur | �d� | j�| j � d S | �d� d S )Ns +OK Begin TLS negotiation nows -ERR TLS not available)r � getContextr$ r � transportrA r1 r r r rA � s zPOP3TestServer.startTLSc C s | j �� d S r )rR �loseConnectionr1 r r r r- � r zPOP3TestServer.disconnectc C sF zddl m} W n ty d | _Y d S w |�� | _|jj| j_d S )Nr )�ssl)�twisted.internetrT � ImportErrorr �ClientContextFactory�SSL� TLSv1_METHOD�method)r rT r r r rQ � s � zPOP3TestServer.getContextr )�__name__� __module__� __qualname__r r r r r* r2 r0 rP rA r- rQ r r r r r 5 s W r a� popServer.py [arg] (default is Standard POP Server with no messages) no_ssl - Start with no SSL support no_uidl - Start with no UIDL support bad_resp - Send a non-RFC compliant response to the Client bad_cap_resp - send a non-RFC compliant response when the Client sends a 'CAPABILITY' request bad_login_resp - send a non-RFC compliant response when the Client sends a 'LOGIN' request deny - Deny the connection drop - Drop the connection after sending the greeting bad_tls - Send a bad response to a STARTTLS timeout - Do not return a response to a Client request to_deferred - Do not return a response on a 'Select' request. This will test Deferred callback handling slow - Wait 20 seconds after the connection is made to return a Server Greeting c C s t d| � d S )NzServer Starting in %s mode)�print)�msgr r r � printMessage� s r` c C sh | � � dkrdatd� d S | � � dkr datd� d S | � � dkr*datd� d S | � � d kr8datd � d S | � � d krFdatd � d S | � � d krTdatd � d S | � � dkrbdatd� d S | � � dkrpda td� d S | � � dkr~da td� d S | � � dkr�da td� d S | � � dkr�da td� d S | � � dkr�t t� t�� d S t t� t�� d S )N�no_sslFzNON-SSL�no_uidlzNON-UIDL�bad_respTzInvalid Server Response� bad_cap_respzInvalid Capability Response�bad_login_resp�denyzDeny Connection�dropzDrop Connection�bad_tlszBad TLS Response�timeoutzTimeout Response� to_deferredzTimeout Deferred Response�slowz Slow Greetingz--help)�lowerr$ r` r! rK r? rB r, r> �BAD_TLS_RESPONSEr= rM r. r^ �usage�sys�exit)�argr r r � processArg� sL rr c C s\ t tj�dk r td� ntjdd � } | D ]}t|� qt� }t|_t� t |� t� � d S )N� zPOP3 with no messagesr; ) �lenro �argvr` rr r r �protocolr � listenTCP�PORT�run)�argsrq �fr r r �main( s r| �__main__)+ro rU r �twisted.internet.protocolr �twisted.protocolsr rG rH rx r$ r! rK r? rB r, r> rm r= rM r. r3 r& r% r# r@ rD rF rI � TLS_ERRORrJ rL r r r r � LineReceiverr rn r` rr r| r[ r r r r �<module> sV B �PK Mb�Z�f� �a �a 5 mail/test/__pycache__/test_pop3client.cpython-310.pycnu �[��� o �bTU � @ s� d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlZ d dl m Z m Z m Z mZmZ d dlmZmZmZ d dlmZ d dlmZmZ d d lmZ d d l m Z d d l m Z z d d l m!Z!m"Z" W n e#ym dZ!dZ"Y nw G d d� de �Z$ddddddd�Z%d0dd�Z&dd� Z'G dd� de �Z(G dd� d�Z)G dd � d �Z*G d d � d e �Z+G d d � d e �Z,G d!d"� d"e �Z-G d#d$� d$e�Z.G d%d&� d&�Z/G d'd(� d(ej0�Z1ee! d)�ee �2ed� d)�G d*d+� d+e ���Z3G d,d-� d-e/e �Z4G d.d/� d/e �Z5dS )1� N)�List)�skipIf)�directlyProvides)�defer�error� interfaces�protocol�reactor)�AdvancedPOP3Client� InsecureAuthenticationDisallowed�ServerErrorResponse)�pop3testserver)�basic�loopback)�log)�StringTransport)�TestCase)�ClientTLSContext�ServerTLSContextc @ � e Zd Zdd� ZdS )�#StringTransportWithConnectionLosingc C s | j �t�� � d S �N)r �connectionLostr �ConnectionDone��self� r �C/usr/lib/python3/dist-packages/twisted/mail/test/test_pop3client.py�loseConnection! � z2StringTransportWithConnectionLosing.loseConnectionN)�__name__� __module__� __qualname__r r r r r r � r s 180s LOGIN)s TOPs LOGIN-DELAYs UIDL� STLSs USERs SASLTc C s8 t � }t|_t� }||_|�|� | r|�d� ||fS )Ns +OK Hello! )� POP3Client�capCache� _capCacher r �makeConnection� dataReceived)�greet�p�tr r r �setUp/ s r- c C s | fdd�S )Nc S s |� S r r )�result�fr r r �<lambda>A s zstrip.<locals>.<lambda>r )r/ r r r �strip@ s r1 c @ st e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� ZdS ) �POP3ClientLoginTestsc sD t dd�\}}d|_|�dd�}|�d� � �|t��� fdd��S ) NF�r* T� username� passwords -ERR Offline for maintenance c � � � | jd d�S )Nr s Offline for maintenance�� assertEqual�args��excr r r r0 K � z;POP3ClientLoginTests.testNegativeGreeting.<locals>.<lambda>)r- �allowInsecureLogin�loginr) � assertFailurer � addCallback�r r+ r, �dr r r �testNegativeGreetingE s �z)POP3ClientLoginTests.testNegativeGreetingc C �< t � \}}|�d�}| �|�� d� |�d� |�| jd�S )Nr4 � USER username s +OK send password s send password)r- �userr8 �valuer) r@ rA r r r � testOkUserN � z POP3ClientLoginTests.testOkUserc �H t � \}}|�d�}� �|�� d� |�d� � �|t��� fdd��S )Nr4 rE s -ERR account suspended c r6 )Nr s account suspendedr7 r: r r r r0 [ r< z2POP3ClientLoginTests.testBadUser.<locals>.<lambda>)r- rF r8 rG r) r? r r@ rA r r r � testBadUserU � �z POP3ClientLoginTests.testBadUserc C rD )Nr5 � PASS password s +OK you're in! s you're in!)r- �passwordr8 rG r) r@ rA r r r � testOkPass^ rI z POP3ClientLoginTests.testOkPassc rJ )Nr5 rM s -ERR go away c r6 )Nr s go awayr7 r: r r r r0 k r< z2POP3ClientLoginTests.testBadPass.<locals>.<lambda>)r- rN r8 rG r) r? r r@ rA r r r � testBadPasse rL z POP3ClientLoginTests.testBadPassc C s^ t � \}}d|_|�dd�}| �|�� d� |�d� | �|�� d� |�d� |�| jd�S ) NTr4 r5 rE s +OK go ahead � USER username PASS password s +OK password accepted s password accepted)r- r= r> r8 rG r) r@ rA r r r � testOkLoginn s z POP3ClientLoginTests.testOkLoginc sj t � \}}d|_|�dd�}� �|�� d� |�d� � �|�� d� |�d� � �|t��� fdd ��S ) NTr4 r5 rE s +OK waiting on you rQ � -ERR bogus login c r6 �Nr s bogus loginr7 r: r r r r0 � r< z;POP3ClientLoginTests.testBadPasswordLogin.<locals>.<lambda>� r- r= r> r8 rG r) r? r r@ rA r r r �testBadPasswordLoginx s �z)POP3ClientLoginTests.testBadPasswordLoginc sP t � \}}d|_|�dd�}� �|�� d� |�d� � �|t��� fdd��S )NTr4 r5 rE rS c r6 rT r7 r: r r r r0 � r< z;POP3ClientLoginTests.testBadUsernameLogin.<locals>.<lambda>rU rA r r r �testBadUsernameLogin� s �z)POP3ClientLoginTests.testBadUsernameLoginc C s* t dd�\}}|�d� | �|jd � d S )NFr3 s" +OK lalala this has no challenge �r- r) r8 �serverChallenge�r r+ r, r r r �testServerGreeting� � z'POP3ClientLoginTests.testServerGreetingc C s* t dd�\}}|�d� | �|jd� d S )NFr3 s +OK <here is the challenge> s <here is the challenge>rX rZ r r r � testServerGreetingWithChallenge� r\ z4POP3ClientLoginTests.testServerGreetingWithChallengec C sL t dd�\}}|�d� |�dd�}| �|�� d� |�d� |�| jd�S ) NFr3 s" +OK <challenge string goes here> r4 r5 s0 APOP username f34f1e464d0d7927607753129cabe39a s +OK Welcome! s Welcome!)r- r) r> r8 rG r@ rA r r r �testAPOP� s � z POP3ClientLoginTests.testAPOPc C s> t dd�\}}|�d� |�dd�}| �|�� � | �|t�S )NFr3 � +OK Howdy r4 r5 )r- r) r> � assertFalserG r? r rA r r r � testInsecureLoginRaisesException� s z5POP3ClientLoginTests.testInsecureLoginRaisesExceptionc C sp t dd�\}}t|tj� |�d� |�dd�}| �|�� d� |�� |�d� | �|�� d� |�d� |S ) z� If a server doesn't offer APOP but the transport is secured using SSL or TLS, a plaintext login should be allowed, not rejected with an InsecureAuthenticationDisallowed exception. Fr3 r_ r4 r5 rE s +OK rM ) r- r r � ISSLTransportr) r> r8 rG �clearrA r r r � testSSLTransportConsideredSecure� s z5POP3ClientLoginTests.testSSLTransportConsideredSecureN)r r! r" rC rH rK rO rP rR rV rW r[ r] r^ ra rd r r r r r2 D s r2 c @ � e Zd Zdd� Zdd� ZdS )� ListConsumerc C s i | _ d S r ��datar r r r �__init__� � zListConsumer.__init__c C s |\}}| j �|g ��|� d S r )rh � setdefault�append)r r. �itemrG r r r �consume� s zListConsumer.consumeN�r r! r" ri rn r r r r rf � � rf c @ re )�MessageConsumerc C s g | _ d S r rg r r r r ri � rj zMessageConsumer.__init__c C s | j �|� d S r )rh rl �r �liner r r rn � � zMessageConsumer.consumeNro r r r r rq � rp rq c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd S )�POP3ClientListTestsc C �H t � \}}|�� }| �|�� d� |�d� |�d� |�| jg d��S )N� LIST � +OK Here it comes s 1 3 2 2 3 1 . )� � � )r- �listSizer8 rG r) r@ rA r r r � testListSize� � z POP3ClientListTests.testListSizec C s� t � \}}t� }|j}|�|�}| �|�� d� |�d� |�d� | �|jdgdgdgd�� |�d� | �|jdgdgdgdgdgdgd �� |�d � |�| j |�S ) Nrw rx s 1 3 2 2 3 1 ry rz r{ )r r{ rz s 5 3 6 2 7 1 )r r{ rz � � � � . ) r- rf rn r| r8 rG r) rh r@ �assertIdentical�r r+ r, �cr/ rB r r r �testListSizeWithConsumer� s ( z,POP3ClientListTests.testListSizeWithConsumerc �F t � \}}|�� }� �|�� d� |�d� � �|t��� fdd��S )Nrw �! -ERR Fatal doom server exploded c r6 �Nr s Fatal doom server explodedr7 r: r r r r0 � r< z8POP3ClientListTests.testFailedListSize.<locals>.<lambda>)r- r| r8 rG r) r? r r@ rA r r r �testFailedListSize� � �z&POP3ClientListTests.testFailedListSizec C rv )N� UIDL rx s 1 abc 2 def 3 ghi . )� abcs defs ghi)r- �listUIDr8 rG r) r@ rA r r r � testListUID� r~ z POP3ClientListTests.testListUIDc C sx t � \}}t� }|j}|�|�}| �|�� d� |�d� |�d� | �|jdgdgdgd�� |�d� |�| j |�S ) Nr� rx s 1 xyz 2 abc 5 mno s xyzr� s mno)r r{ r r� ) r- rf rn r� r8 rG r) rh r@ r� r� r r r �testListUIDWithConsumer� s z+POP3ClientListTests.testListUIDWithConsumerc r� )Nr� r� c r6 r� r7 r: r r r r0 r< z7POP3ClientListTests.testFailedListUID.<locals>.<lambda>)r- r� r8 rG r) r? r r@ rA r r r �testFailedListUID r� z%POP3ClientListTests.testFailedListUIDN) r r! r" r} r� r� r� r� r� r r r r ru � s ru c @ sL e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dS )�POP3ClientMessageTestsc C s^ t � \}}|�d�}| �|�� d� |�d� |�d� |�d� |�d� |�| jddg�S ) N� � RETR 8 � +OK Message incoming � La la la here is message text s" ..Further message text tra la la r� � La la la here is message texts .Further message text tra la la�r- �retriever8 rG r) r@ rA r r r � testRetrieve s �z#POP3ClientMessageTests.testRetrievec C s` t � \}}t� }|j}|�d|�}| �|�� d� |�d� |�d� |�d� |�| j||�S )Nr� r� r� r� s ..Further message text . ) r- rq rn r� r8 rG r) r@ �_cbTestRetrieveWithConsumerr� r r r �testRetrieveWithConsumer s z/POP3ClientMessageTests.testRetrieveWithConsumerc C �" | � ||� | �|jddg� d S )Nr� s .Further message text�r� r8 rh �r r. r/ r� r r r r� # s �z2POP3ClientMessageTests._cbTestRetrieveWithConsumerc C sb t � \}}|jddd�}| �|�� d� |�d� |�d� |�d� |�d� |�| jd d g�S ) Nr� rz ��lines� TOP 8 2 � +OK 2 lines on the way � Line the first! Woop � Line the last! Bye r� � Line the first! Woop� Line the last! Byer� rA r r r �testPartialRetrieve) s �z*POP3ClientMessageTests.testPartialRetrievec C sn t � \}}t� }|j}|jd|dd�}| �|�� d� |�d� |�d� |�d� |�d� |�| j||�S ) Nr� rz r� r� r� r� r� r� ) r- rq rn r� r8 rG r) r@ �"_cbTestPartialRetrieveWithConsumerr� r r r � testPartialRetrieveWithConsumer5 s z6POP3ClientMessageTests.testPartialRetrieveWithConsumerc C r� )Nr� r� r� r� r r r r� A s z9POP3ClientMessageTests._cbTestPartialRetrieveWithConsumerc rJ )Nr s RETR 1 r� c r6 r� r7 r: r r r r0 K r< z;POP3ClientMessageTests.testFailedRetrieve.<locals>.<lambda>)r- r� r8 rG r) r? r r@ rA r r r �testFailedRetrieveE rL z)POP3ClientMessageTests.testFailedRetrievec s� t � \� }� �fdd�td�D �}tdd�D ]3}��|�� d|f � |�� � �d� � �d|f � � �d |f � ��|�� d � � �d � qtj|d d �S )z� Issue three retrieve calls immediately without waiting for any to succeed and make sure they all do succeed eventually. c s8 g | ]}� � |���jd |d f d|d f g��qS )s First line of %d.r{ s Second line of %d.)r� r@ r8 )�.0�i�r+ r r r � <listcomp>T s ���zCPOP3ClientMessageTests.test_concurrentRetrieves.<locals>.<listcomp>ry r{ r s RETR %d r� s First line of %d. s Second line of %d. � r� T)�fireOnOneErrback)r- �ranger8 rG rc r) r � DeferredList)r r, �messagesr� r r� r �test_concurrentRetrievesN s � z/POP3ClientMessageTests.test_concurrentRetrievesN) r r! r" r� r� r� r� r� r� r� r� r r r r r� s r� c @ s\ e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dS )�POP3ClientMiscTestsc C s` t � \}}|jdd�}| �|�� d� |�d� |�d� |�| jd d d g d�ddgdgd ��S ) Nr ��useCache� CAPA s +OK Capabilities on the way s! X Y Z A 1 2 3 B 1 2 C 1 . )� 1� 2� 3r� r� )� X� Y� Z� A� B� C�r- � capabilitiesr8 rG r) r@ rA r r r �testCapabilityi s ��z"POP3ClientMiscTests.testCapabilityc C s> t � \}}|jdd�}| �|�� d� |�d� |�| ji �S )Nr r� r� � -ERR This server is lame! r� rA r r r �testCapabilityError{ s z'POP3ClientMiscTests.testCapabilityErrorc C �: t � \}}|�� }| �|�� d� |�d� |�| jd�S )N� STAT s +OK 1 1212 )r{ i� )r- �statr8 rG r) r@ rA r r r �testStat� � z POP3ClientMiscTests.testStatc r� )Nr� r� c r6 �Nr s This server is lame!r7 r: r r r r0 � r< z3POP3ClientMiscTests.testStatError.<locals>.<lambda>)r- r� r8 rG r) r? r r@ rA r r r � testStatError� r� z!POP3ClientMiscTests.testStatErrorc C r� )N� NOOP s +OK No-op to you too! s No-op to you too!)r- �noopr8 rG r) r@ rA r r r �testNoop� r� z POP3ClientMiscTests.testNoopc r� )Nr� r� c r6 r� r7 r: r r r r0 � r< z3POP3ClientMiscTests.testNoopError.<locals>.<lambda>)r- r� r8 rG r) r? r r@ rA r r r � testNoopError� r� z!POP3ClientMiscTests.testNoopErrorc C r� )N� RSET s +OK Reset state s Reset state)r- �resetr8 rG r) r@ rA r r r �testRset� r� z POP3ClientMiscTests.testRsetc r� )Nr� r� c r6 r� r7 r: r r r r0 � r< z3POP3ClientMiscTests.testRsetError.<locals>.<lambda>)r- r� r8 rG r) r? r r@ rA r r r � testRsetError� r� z!POP3ClientMiscTests.testRsetErrorc C rD )Nry � DELE 4 s +OK Hasta la vista s Hasta la vista)r- �deleter8 rG r) r@ rA r r r � testDelete� rI z POP3ClientMiscTests.testDeletec rJ )Nry r� s -ERR Winner is not you. c r6 )Nr s Winner is not you.r7 r: r r r r0 � r< z5POP3ClientMiscTests.testDeleteError.<locals>.<lambda>)r- r� r8 rG r) r? r r@ rA r r r �testDeleteError� rL z#POP3ClientMiscTests.testDeleteErrorN) r r! r" r� r� r� r� r� r� r� r� r� r� r r r r r� h s r� c @ s e Zd Zddd�Zdd� ZdS )� SimpleClientNc C s || _ d| _d S )NT)�deferredr= )r r� �contextFactoryr r r ri � s zSimpleClient.__init__c C s | j �d � d S r )r� �callback)r � challenger r r �serverGreeting� rt zSimpleClient.serverGreetingr )r r! r" ri r� r r r r r� � s r� c @ s< e Zd ZdZdZdd� Zdd� Zdd� Zdd � Zd d � Z dS ) �POP3HelperMixinNc C s: t �� }tj| jd�| _t|| jd�| _d| j_ || _ d S )N)r� � ) r �Deferredr �POP3TestServer� serverCTX�serverr� � clientCTX�client�timeout� connected)r rB r r r r- � s zPOP3HelperMixin.setUpc C s | ` | `| `d S r )r� r� r� r r r r �tearDown� s zPOP3HelperMixin.tearDownc C s | j j�� d S r )r� � transportr )r �ignorer r r � _cbStopClient� rt z POP3HelperMixin._cbStopClientc C s | j j�� | jj�� |S r )r� r� r r� )r �failurer r r � _ebGeneral� s zPOP3HelperMixin._ebGeneralc C s t j| j| jdd�S )NF)�noisy)r � loopbackTCPr� r� r r r r r � r zPOP3HelperMixin.loopback) r r! r" r� r� r- r� r� r� r r r r r r� � s r� c @ s e Zd ZG dd� dej�ZdS )�TLSServerFactoryc @ s2 e Zd ZU dZg Zee ed< dd� Zdd� Z dS )zTLSServerFactory.protocolN�outputc C s8 g | j _| jd d � | _| j�d�D ]}| �|� qd S )Nr )�factory�inputr� �pop�sendLinerr r r r �connectionMade� s �z(TLSServerFactory.protocol.connectionMadec sF � j j�|� � fdd�� j�d�D � |dkr!� j�� j� d S d S )Nc s g | ]}� � |��qS r )r� )r� �lr r r r� � s z:TLSServerFactory.protocol.lineReceived.<locals>.<listcomp>r r$ )r� r� rl r� r� r� �startTLS�contextrr r r r � lineReceived� s �z&TLSServerFactory.protocol.lineReceived) r r! r" r� r� r �bytes�__annotations__r� r� r r r r r � s r N)r r! r" r � LineReceiverr r r r r r� � s r� zOpenSSL not presentc @ s e Zd ZdZdd� ZdS )� POP3TLSTestsz= Tests for POP3Client's support for TLS connections. c s t � �dgg d�dgddgdgg�j_t� �j_tjd�dd�}��|j� |� � j }|� � j }t � � �tt � � t� ����fdd�}|�_t�� }�fd d �|_t�|||�� �fd d �}�fd d�}��fdd�}� �fdd�} �j�|� �j�|� �j�|� �j�| � �jS )zd POP3Client.startTLS starts a TLS session over its existing TCP connection. � +OK)r r$ � .r r z 127.0.0.1)� interfacec s t ��| � � �d � d S r )r� r r� )�reason)�connLostDeferred�cpr r r � z2POP3TLSTests.test_startTLS.<locals>.connectionLostc s � S r r r �r r r r0 s z,POP3TLSTests.test_startTLS.<locals>.<lambda>c � t �d� � �� S )Nz!Connected to server; starting TLS)r �msgr� ��ignoredr r r � cbConnected! � z/POP3TLSTests.test_startTLS.<locals>.cbConnectedc r )NzStarted TLS; disconnecting)r r �quitr r r r � cbStartedTLS% r z0POP3TLSTests.test_startTLS.<locals>.cbStartedTLSc s t �d� � ��jg d�� d S )Nz.Disconnected; asserting correct input received)� CAPAr$ r s QUIT)r r r8 r� )�ign)r �sfr r �cbDisconnected) s z2POP3TLSTests.test_startTLS.<locals>.cbDisconnectedc s t �d� � �� �S )NzEAsserted correct input; disconnecting client and shutting down server)r r � disconnect�r. )�connr r r �cleanup- s �z+POP3TLSTests.test_startTLS.<locals>.cleanup)r� r r� r r� r � listenTCP� addCleanup� stopListening�getHost�host�portr r� r� r r � ClientFactory� connectTCPr� r@ �addBoth) r r �H�Pr �cfr r r r r )r r r r r r � test_startTLS s8 � zPOP3TLSTests.test_startTLSN)r r! r" �__doc__r& r r r r r � s r c @ r )�POP3TimeoutTestsc s� � ��fdd�}�fdd�� �fdd���fdd�}d �j _d t_||g}t�jjtt|�� �j��j� �j� �j � �� � S ) Nc s& �j �dd�} | �� � | ��� | S )N�test�twisted)r� r> r@ � addErrback)rB ��loggedInr �timedOutr r r> ? s z+POP3TimeoutTests.testTimeout.<locals>.loginc s � � d� d S )Nz%Successfully logged in!? Impossible!)�failr r r r r- E s z.POP3TimeoutTests.testTimeout.<locals>.loggedInc s | � tj� � �d � d S r )�trapr � TimeoutErrorr� )r� r r r r. H r z.POP3TimeoutTests.testTimeout.<locals>.timedOutc s � j �� S r )r� r r r r r r L rj z*POP3TimeoutTests.testTimeout.<locals>.quitg{�G�z�?T) r� r� r �TIMEOUT_RESPONSE�mapr� r@ r1 r� r+ r� r )r r> r �methodsr r, r � testTimeout> s z POP3TimeoutTests.testTimeoutN)r r! r" r5 r r r r r( = r# r( c @ s e Zd ZdZdd� Zdd� ZdS )� POP3ClientModuleStructureTestszt Miscellaneous tests more to do with module/package structure than anything to do with the POP3 client. c C s | � tjjjg � dS )z� twisted.mail._pop3client.__all__ should be empty because all classes should be imported through twisted.mail.pop3. N)r8 r* �mail� _pop3client�__all__r r r r �test_allb s z'POP3ClientModuleStructureTests.test_allc C s� dd� t �tjd t j�D �}|D ]-}tjdk r |dkr q|dks4| �ttj j |�|� dtj j � �� q| �ttj j d�� qd S ) a Every public class in twisted.mail._pop3client should be available as a member of twisted.mail.pop3 with the exception of twisted.mail._pop3client.POP3Client which should be available as twisted.mail.pop3.AdvancedClient. c S s$ g | ]}|d d dks|d �qS )r �_r )r� r� r r r r� p s �z>POP3ClientModuleStructureTests.test_import.<locals>.<listcomp>ztwisted.mail._pop3client)ry r� r r% z not in r N) �inspect� getmembers�sys�modules�isclass� version_info� assertTrue�hasattrr* r7 �pop3)r � publicClasses�pcr r r � test_importi s �� ��z*POP3ClientModuleStructureTests.test_importN)r r! r" r' r: rG r r r r r6 \ s r6 )T)6r< r> �typingr �unittestr �zope.interfacer �twisted.mail._pop3clientr* �twisted.internetr r r r r �twisted.mail.pop3r r% r r �twisted.mail.testr �twisted.protocolsr r �twisted.pythonr �twisted.test.proto_helpersr �twisted.trial.unittestr �twisted.test.ssl_helpersr r � ImportErrorr r& r- r1 r2 rf rq ru r� r� r� r� � ServerFactoryr� � IReactorSSLr r( r6 r r r r �<module> sV �� w >^[ A PK Mb�ZWܬ�� �� / mail/test/__pycache__/test_pop3.cpython-310.pycnu �[��� o �b�� � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl m Z ddl Z ddlZ ddlZ ddlZ ddlZ ddlZ ddl mZmZmZ ddlmZ dd lmZ dd lmZ dd l m Z dd l m Z dd l m!Z!m"Z" G dd� de!j#�Z$G dd� dej%j&�Z'G dd� d�Z(G dd� d�Z)G dd� dej*�Z+G dd� de!j#�Z,G dd� dej-�Z.G d d � d e.�Z/G d d � d ej0�Z1G d d!� d!e!j#�Z2e ej3�G d"d#� d#��Z4G d$d%� d%�Z5d&d'� Z6G d(d)� d)e!j#�Z7G d*d+� d+e!j#�Z8G d,d-� d-�Z9G d.d/� d/e!j#�Z:G d0d1� d1�Z;d2Z<e"j=e<e>d3�Z?d4Z@e"j=e@e>d3�ZAG d5d6� d6e;e!j#�ZBG d7d8� d8e;e!j#�ZCG d9d:� d:e1�ZDG d;d<� d<eB�ZEG d=d>� d>eC�ZFG d?d@� d@e1�ZGG dAdB� dBeB�ZHG dCdD� dDeC�ZIG dEdF� dFe!j#�ZJG dGdH� dHe!j#�ZKdS )Iz- Test cases for L{twisted.mail.pop3} module. � N)� OrderedDict)�md5)�BytesIO)� implementer)�cred�internet�mail)�defer)�pop3)�loopback)�failure)�LineSendingProtocol)�unittest�utilc @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� UtilityTestszl Test the various helper functions and classes used by the POP3 server protocol implementation. c C s� g }t t�g d���}t�|j|d�}t |�}| �|g � t|� | �|g � t|� | �|g � t|� | �|g d�� td�D ]}t|� qA| �|g d�� dS )z� Test creating a LineBuffer and feeding it some lines. The lines should build up in its internal buffer for a while and then get spat out to the writer. )�012�345�6�7�8�9� )r r r � )r r r r r r r r N) �iter� itertools�cycler �_IteratorBuffer�extend� assertEqual�next�range)�self�output�input�c�i�n� r' �=/usr/lib/python3/dist-packages/twisted/mail/test/test_pop3.py�test_LineBuffering' s z UtilityTests.test_LineBufferingc C s> g }t g d��}t�|j|d�}|D ]}q| �|g d�� dS )z� Test that a LineBuffer flushes everything when its iterator is exhausted, and itself raises StopIteration. )�a�br$ r N)r r r r r )r! r" r# r$ r% r' r' r( �test_FinishLineBuffering< s z%UtilityTests.test_FinishLineBufferingc C s | � t�d�d� dS )zb Test that the thing that spits out POP3 'success responses' works right. s Great.s +OK Great. N)r r �successResponse�r! r' r' r( � test_SuccessResponseFormatterH s z*UtilityTests.test_SuccessResponseFormatterc C sD t t�g ��d }| �|d� t t�g d���d }| �|d� dS )zX Test that the function which formats stat lines does so appropriately. ���s +OK 0 0 )� � r iu' s +OK 4 10142 N)�listr �formatStatResponser )r! �statLiner' r' r( �test_StatLineFormatterO s z#UtilityTests.test_StatLineFormatterc C sD t t�g ��}| �|ddg� t t�g d���}| �|g d�� dS )z} Test that the function which formats the lines in response to a LIST command does so appropriately. � +OK 0 � . )� � � �d )s +OK 4 s 1 1 s 2 2 s 3 3 s 4 100 r8 N)r3 r �formatListResponser )r! � listLinesr' r' r( �test_ListLineFormatterY s �z#UtilityTests.test_ListLineFormatterc C sz g d�}t t�g |j��}| �|ddg� t t�g d�|j��}| �|g d�� t t�g d�|j��}| �|g d�� dS ) zy Test that the function which formats lines in response to a UIDL command does so appropriately. )�abc�def�ghi� +OK r8 )�{ i� �O )rC � 1 abc s 2 def � 3 ghi r8 )r NrE )rC rF rG r8 N)r3 r �formatUIDListResponse� __getitem__r )r! �uidsr> r' r' r( �test_UIDListLineFormatterg s �z&UtilityTests.test_UIDListLineFormatterN) �__name__� __module__� __qualname__�__doc__r) r, r/ r6 r? rK r' r' r' r( r ! s r c @ � e Zd ZdZdZdd� ZdS )� MyVirtualPOP3z2 A virtual-domain-supporting POP3 server. � <moshez>c C s( | � |�\}}| jjd �||| j|�S )a7 Authenticate against a user against a virtual domain. @param user: The username. @param digest: The digested password. @return: A three-tuple like the one returned by L{IRealm.requestAvatar}. The mailbox will be for the user given by C{user}. � baz.com)� lookupDomain�service�domains�authenticateUserAPOP�magic)r! �user�digest�domainr' r' r( rW � s �z"MyVirtualPOP3.authenticateUserAPOPN�rL rM rN rO rX rW r' r' r' r( rQ y � rQ c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � DummyDomainz- A virtual domain for a POP3 server. c C s i | _ d S �N��usersr. r' r' r( �__init__� s zDummyDomain.__init__c C s g | j |< dS )zV Create a mailbox for a new user. @param name: The username. Nr` )r! �namer' r' r( �addUser� � zDummyDomain.addUserc C s | j | �|� dS )z� Add a message to the mailbox of the named user. @param name: The username. @param message: The contents of the message. N)ra �append)r! rc �messager' r' r( � addMessage� s zDummyDomain.addMessagec C s t jt| j| �dd� fS )ae Succeed with a L{ListMailbox}. @param name: The name of the user authenticating. @param digest: ignored @param magic: ignored @param domain: ignored @return: A three-tuple like the one returned by L{IRealm.requestAvatar}. The mailbox will be for the user given by C{name}. c S � d S r_ r' r' r' r' r( �<lambda>� � z2DummyDomain.authenticateUserAPOP.<locals>.<lambda>)r �IMailbox� ListMailboxra )r! rc rZ rX r[ r' r' r( rW � s z DummyDomain.authenticateUserAPOPN)rL rM rN rO rb rd rh rW r' r' r' r( r^ � s r^ c @ sB e Zd ZdZdd� Zddd�Zdd� Zd d � Zd d � Zd d� Z dS )rm z@ A simple in-memory list implementation of L{IMailbox}. c C s || _ dS )z, @param list: The messages. N�r3 )r! r3 r' r' r( rb � � zListMailbox.__init__Nc C s& |du r dd� | j D �S t| j | �S )�� Get some message information. @param i: See L{pop3.IMailbox.listMessages}. @return: See L{pop3.IMailbox.listMessages}. Nc S � g | ]}t |��qS r' ��len)�.0�lr' r' r( � <listcomp>� � z,ListMailbox.listMessages.<locals>.<listcomp>)r3 rs �r! r% r' r' r( � listMessages� s zListMailbox.listMessagesc C � t | j| �S �z� Get the message content. @param i: See L{pop3.IMailbox.getMessage}. @return: See L{pop3.IMailbox.getMessage}. )r r3 rx r' r' r( � getMessage� � zListMailbox.getMessagec C s |S )z� Construct a UID by using the given index value. @param i: See L{pop3.IMailbox.getUidl}. @return: See L{pop3.IMailbox.getUidl}. r' rx r' r' r( �getUidl� s zListMailbox.getUidlc C � d| j |< dS �zm Wipe the message at the given index. @param i: See L{pop3.IMailbox.deleteMessage}. � Nrn rx r' r' r( � deleteMessage� re zListMailbox.deleteMessagec C � dS )z= No-op. @see: L{pop3.IMailbox.sync} Nr' r. r' r' r( �sync� rk zListMailbox.syncr_ ) rL rM rN rO rb ry r| r~ r� r� r' r' r' r( rm � s rm c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �MyPOP3DownloaderzE A POP3 client which downloads all messages from the server. c C s t j�| |� | �dd� dS )zK Authenticate. @param line: The welcome response. s hello@baz.coms worldN)r � POP3Client�handle_WELCOME�apop�r! �liner' r' r( r� � s z MyPOP3Downloader.handle_WELCOMEc C sB |� � }|d }|dkrtd|� d|� d���g | _| �d� dS )zc Require an I{OK} response to I{APOP}. @param line: The I{APOP} response. r � +OKz code is: z , parts is: � r9 N)�split�AssertionError�lines�retr)r! r� �parts�coder' r' r( � handle_APOP s z MyPOP3Downloader.handle_APOPc C s | j �|� dS )zh Record one line of message information. @param line: A I{RETR} response line. N)r� rf r� r' r' r( �handle_RETR_continue � z%MyPOP3Downloader.handle_RETR_continuec C s d� | j�d | _| �� dS )z: Record the received message information. � N)�joinr� rg �quitr. r' r' r( �handle_RETR_end s z MyPOP3Downloader.handle_RETR_endc C s |dd� dkrt d| ��dS )zc Require an I{OK} response to I{QUIT}. @param line: The I{QUIT} response. Nr; r� s code is )r� r� r' r' r( � handle_QUIT s �z MyPOP3Downloader.handle_QUITN) rL rM rN rO r� r� r� r� r� r' r' r' r( r� � s r� c @ sR e Zd ZdZdZdee�f Zdd� Zdd� Zdd � Z e j d d �ge _ d d � Z dS )� POP3Testsz! Tests for L{pop3.POP3}. s- Subject: urgent Someone set up us the bomb! s{ +OK <moshez> +OK Authentication succeeded +OK 1 0 . +OK %d Subject: urgent Someone set up us the bomb! . +OK c C sN t j�� | _i | j_t� | jjd< | jjd �d� | jjd �d| j� dS )zC Set up a POP3 server with virtual domain support. rS s helloN) r �protocol�Factory�factoryrV r^ rd rh rg r. r' r' r( �setUpA s zPOP3Tests.setUpc s: t g d��� t� }�j|_� �fdd�}t�|� ��|�S )zL Messages can be downloaded over a loopback TCP connection. )s APOP hello@baz.com world� UIDL� RETR 1� QUITc s" d� � j�d }��|�j� d S )N� )r� �responser �expectedOutput)�ignoredr" ��clientr! r' r( �checkZ s z&POP3Tests.test_messages.<locals>.check)r rQ r� rU r � loopbackTCP� addCallback)r! �serverr� r' r� r( � test_messagesK s �zPOP3Tests.test_messagesc s: t � ��j�_t� � � ��fdd�}t��� �}|�|�S )zH Messages can be downloaded over a loopback connection. c s( �� � j�j� ��t�td��� d S )N�Test harness disconnect)r rg �connectionLostr �Failure� Exception)r� ��clientProtocolr� r! r' r( r� h s �z&POP3Tests.test_loopback.<locals>.check)rQ r� rU r� r � loopbackAsyncr� )r! r� �dr' r� r( � test_loopback` s zPOP3Tests.test_loopbackz*twisted.mail.pop3.POP3Client is deprecated)rg c C sR t j�� }i |_t� |jd< t� }||_| �tj |j dd�}| � |j d d� dS )zP Look up a user in a domain which this server does not support. s twistedmatrix.coms nobody@baz.coms passwordr zno such domain baz.comN) r r� r� rV r^ rQ rU � assertRaisesr � POP3ErrorrW r �args)r! r� r� �excr' r' r( �test_incorrectDomainu s �z POP3Tests.test_incorrectDomainN) rL rM rN rO rg rs r� r� r� r� r �suppressr� r' r' r' r( r� & s �� � r� c @ rP )� DummyPOP3zF A simple POP3 server with a hard-coded mailbox for any user. rR c C s t jtt�dd� fS )z� Succeed with a L{DummyMailbox}. @param user: ignored @param password: ignored @return: A three-tuple like the one returned by L{IRealm.requestAvatar}. c S ri r_ r' r' r' r' r( rj � rk z0DummyPOP3.authenticateUserAPOP.<locals>.<lambda>�r rl � DummyMailbox� ValueError)r! rY �passwordr' r' r( rW � s z DummyPOP3.authenticateUserAPOPNr\ r' r' r' r( r� � r] r� c @ � e Zd ZdZdd� ZdS )� DummyPOP3AuthzL Class to test successful authentication in twisted.mail.pop3.POP3. c C s6 t j�t� �| _t j�� }|�||� | j�|� d S r_ )r �portal�Portal� TestRealm�checkers�'InMemoryUsernamePasswordDatabaseDontUserd �registerChecker)r! rY r� �chr' r' r( rb � s zDummyPOP3Auth.__init__N)rL rM rN rO rb r' r' r' r( r� � � r� c @ s@ e Zd ZdZdgZdd� Zddd�Zdd � Zd d � Zd d � Z dS )r� z� An in-memory L{pop3.IMailbox} implementation. @ivar messages: A sequence of L{bytes} defining the messages in this mailbox. @ivar exceptionType: The type of exception to raise when an out-of-bounds index is addressed. s, From: moshe To: moshe How are you, friend? c C s t jd d � | _|| _d S r_ )r� �messages� exceptionType)r! r� r' r' r( rb � s zDummyMailbox.__init__Nc C s< |du r dd� | j D �S |t| j �kr| �� �t| j | �S )rp Nc S rq r' rr )rt �mr' r' r( rv � rw z-DummyMailbox.listMessages.<locals>.<listcomp>)r� rs r� rx r' r' r( ry � s zDummyMailbox.listMessagesc C rz r{ )r r� rx r' r' r( r| � r} zDummyMailbox.getMessagec C s |t | j�kr | �� �d|f S )z� Construct a UID which is simply the string representation of the given index. @param i: See L{pop3.IMailbox.getUidl}. @return: See L{pop3.IMailbox.getUidl}. s %d)rs r� r� rx r' r' r( r~ � s zDummyMailbox.getUidlc C r r� )r� rx r' r' r( r� � re zDummyMailbox.deleteMessager_ ) rL rM rN rO r� rb ry r| r~ r� r' r' r' r( r� � s r� c @ s� e Zd ZdZd5dd�Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z ddg g fdd�Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Z dS )6�AnotherPOP3Testsz( Additional L{pop3.POP3} tests. Nc C s4 |r|nt � }t|�}t�||�}|�| j|||�S )aO Assert that when C{lines} are delivered to L{pop3.POP3} it responds with C{expectedOutput}. @param lines: A sequence of L{bytes} representing lines to deliver to the server. @param expectedOutput: A sequence of L{bytes} representing the expected response from the server. @param protocolInstance: Instance of L{twisted.mail.pop3.POP3} or L{None}. If L{None}, a new DummyPOP3 will be used. @return: A L{Deferred} that fires when the lines have been delivered and the output checked. )r� r r r� r� � _cbRunTest)r! r� r� �protocolInstance�dummyr� r� r' r' r( �runTest� s zAnotherPOP3Tests.runTestc C s2 | � d�|�d�|j�� |�t�td��� |S )Nr� r� )r r� r� r� r r� r� )r! r� r� r� r� r' r' r( r� � s zAnotherPOP3Tests._cbRunTestc C � | � g d�g d��S )a4 Test a lot of different POP3 commands in an extremely pipelined scenario. This test may cover legitimate behavior, but the intent and granularity are not very good. It would likely be an improvement to split it into a number of smaller, more focused tests. )s APOP moshez dummy� LISTr� r� � RETR 2s DELE 1r� r� )� +OK <moshez>� +OK Authentication succeededs +OK 1s 1 44� .� +OK s 1 0r� s +OK 44s From: moshes To: mosher� s How are you, friend?r� s -ERR Bad message number argumentr� s -ERR message deletedr� �r� r. r' r' r( � test_buffer s �z AnotherPOP3Tests.test_bufferc C r� )z) Test the no-op command. )s APOP spiv dummys NOOPr� )r� r� r� r� r� r. r' r' r( � test_noop+ s �zAnotherPOP3Tests.test_noopc C s> d}| � ddgdd| dg�}| �tj�}| �t|�d� |S )zi Sending a command with invalid UTF-8 characters will raise a L{pop3.POP3Error}. s& not authenticated yet: cannot do �PASSs �PASSr� r� s( -ERR bad protocol or server: POP3Error: r� r9 )r� �flushLoggedErrorsr r� r rs )r! �errorr� �errorsr' r' r( � test_badUTF8CharactersInCommand4 s �� z0AnotherPOP3Tests.test_badUTF8CharactersInCommandc C sH t � }tj�� |_dddd�|j_tddg�}t�||�}|� | j |�S )z� L{pop3.POP3} responds to an I{AUTH} command with a list of supported authentication types based on its factory's C{challengers}. N)s Auth1s secondAuths authLasts AUTHr� ) r� r r� r� r� � challengersr r r� r� �_cbTestAuthListing)r! �pr� r� r' r' r( �test_authListingF s �� z!AnotherPOP3Tests.test_authListingc C sJ | � |jd �d�� | �t|jdd� �g d�� | �|jd d� d S )Nr9 r� r: r )s AUTH1s AUTHLASTs SECONDAUTHr� )� assertTruer� � startswithr �sorted)r! r� r� r' r' r( r� X s �z#AnotherPOP3Tests._cbTestAuthListingc C s~ |s|}|s|}g d�}||kr||krg d�}d� d|g�d� d|g�g}||dg 7 }||dg 7 }| j||t||�d�S ) a� Test a login with PASS. If L{real_user} matches L{tried_user} and L{real_password} matches L{tried_password}, a successful login will be expected. Otherwise an unsuccessful login will be expected. @type real_user: L{bytes} @param real_user: The user to test. @type real_password: L{bytes} @param real_password: The password of the test user. @type tried_user: L{bytes} or L{None} @param tried_user: The user to call USER with. If None, real_user will be used. @type tried_password: L{bytes} or L{None} @param tried_password: The password to call PASS with. If None, real_password will be used. @type after_auth_input: L{list} of l{bytes} @param after_auth_input: Extra protocol input after authentication. @type after_auth_output: L{list} of l{bytes} @param after_auth_output: Extra protocol output after authentication. )r� � +OK USER accepted, send PASSs -ERR Authentication failed)r� r� r� � � USER� PASSr� r� )r� )r� r� r� ) r! � real_user� real_password� tried_user�tried_password�after_auth_input�after_auth_outputr� � fullInputr' r' r( �run_PASS_ s" $ ��zAnotherPOP3Tests.run_PASSc C s | � d�d|g�dgg d��S )z� Test protocol violation produced by calling PASS before USER. @type password: L{bytes} @param password: A password to test. r� r� r� )r� s -ERR USER required before PASSr� )r� r� )r! r� r' r' r( �run_PASS_before_USER� s �z%AnotherPOP3Tests.run_PASS_before_USERc C � | � d�S )z> Test PASS before USER with a wrong password. � fooz�r� r. r' r' r( � test_illegal_PASS_before_USER� ro z.AnotherPOP3Tests.test_illegal_PASS_before_USERc C r� )z? Test PASS before USER with an empty password. r� r� r. r' r' r( �test_empty_PASS_before_USER� ro z,AnotherPOP3Tests.test_empty_PASS_before_USERc C r� )zI Test PASS before USER with an password that is a space. r� r� r. r' r' r( � test_one_space_PASS_before_USER� ro z0AnotherPOP3Tests.test_one_space_PASS_before_USERc C r� )zK Test PASS before USER with a password containing a space. � fooz barzr� r. r' r' r( �test_space_PASS_before_USER� ro z,AnotherPOP3Tests.test_space_PASS_before_USERc C r� )zS Test PASS before USER with a password containing multiple spaces. � fooz barz asdfr� r. r' r' r( �%test_multiple_spaces_PASS_before_USER� ro z6AnotherPOP3Tests.test_multiple_spaces_PASS_before_USERc C r� )zS Test PASS before USER with a password containing tabs and spaces. � fooz barz crazy@! r� r. r' r' r( �&test_other_whitespace_PASS_before_USER� ro z7AnotherPOP3Tests.test_other_whitespace_PASS_before_USERc C � | � dd�S )z1 Test PASS with a good password. � testuserr� �r� r. r' r' r( �test_good_PASS� � z AnotherPOP3Tests.test_good_PASSc C r )�? Test PASS with a password containing a space. r r� r r. r' r' r( �test_space_PASS� r z AnotherPOP3Tests.test_space_PASSc C r )r r r� r r. r' r' r( �test_multiple_spaces_PASS� r z*AnotherPOP3Tests.test_multiple_spaces_PASSc C r �zG Test PASS with a password containing tabs and spaces. r r r r. r' r' r( �test_other_whitespace_PASS� r z+AnotherPOP3Tests.test_other_whitespace_PASSc C � | j dddd�S )z. Test PASS with a wrong user. r r� s wronguser)r� r r. r' r' r( �test_pass_wrong_user� � z%AnotherPOP3Tests.test_pass_wrong_userc C r )z2 Test PASS with a wrong password. r r� s barz�r� r r. r' r' r( �test_wrong_PASS� r z AnotherPOP3Tests.test_wrong_PASSc C r )r r r� s foozbarz r r r. r' r' r( �test_wrong_space_PASS� r z&AnotherPOP3Tests.test_wrong_space_PASSc C r )r r r� s foozbarz r r r. r' r' r( � test_wrong_multiple_spaces_PASS� s �z0AnotherPOP3Tests.test_wrong_multiple_spaces_PASSc C r r r r. r' r' r( � test_wrong_other_whitespace_PASS r z1AnotherPOP3Tests.test_wrong_other_whitespace_PASSc C s4 dg}d� ddg�g}| jdd||d��| jtj�S )zM After logging in, test a dummy command that is not defined. s DUMMY COMMANDr� s' -ERR bad protocol or server: POP3Error:s Unknown protocol command: DUMMYr � testpassword)r� r� )r� r� r� r� r r� )r! � extra_input� extra_outputr' r' r( �test_wrong_command s ��� � �z#AnotherPOP3Tests.test_wrong_commandr_ ) rL rM rN rO r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r r r' r' r' r( r� � s> * �A r� c @ sL e Zd ZdZdd� Zdd� Zeddg�Zdd � Zd Z d d � Z d Z d d� Z dS )�TestServerFactoryz� A L{pop3.IServerFactory} implementation, for use by the test suite, with some behavior controlled by the values of (settable) public attributes and other behavior based on values hard-coded both here and in some test methods. c C r� )�W Return the hard-coded value. @return: L{pop3.IServerFactory} zTest Implementation Stringr' r. r' r' r( �cap_IMPLEMENTATION& � z$TestServerFactory.cap_IMPLEMENTATIONc C r� )r �< r' r. r' r' r( � cap_EXPIRE. r z TestServerFactory.cap_EXPIRE)s SCHEME_1N)s SCHEME_2Nc C r� )r �x r' r. r' r' r( �cap_LOGIN_DELAY8 r z!TestServerFactory.cap_LOGIN_DELAYTc C � | j S �r )�puer. r' r' r( �perUserExpirationB � z#TestServerFactory.perUserExpirationc C r r! )�puldr. r' r' r( �perUserLoginDelayL r$ z#TestServerFactory.perUserLoginDelayN) rL rM rN rO r r r r� r r" r# r% r& r' r' r' r( r s r c @ s e Zd ZdZdZdZdS )� TestMailboxz� An incomplete L{IMailbox} implementation with certain per-user values hard-coded and known by tests in this module. This is useful for testing the server's per-user capability implementation. r< � N)rL rM rN rO � loginDelay�messageExpirationr' r' r' r( r' U s r' c G s |D ]}| � ||� qdS )aG Assert that the given capability is included in all of the capability sets. @param testcase: A L{unittest.TestCase} to use to make assertions. @param s: The capability for which to check. @type s: L{bytes} @param caps: The capability sets in which to check. @type caps: L{tuple} of iterable N)�assertIn)�testcase�s�capsr$ r' r' r( � containedc s �r/ c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )�CapabilityTestsz@ Tests for L{pop3.POP3}'s per-user capability handling. c C s� t � }t�� }t� |_tj�|�|_|� � |� � |� � | _ |� � �� | _t � }t� |_tj�|�|_|� � |� � �� | _|�t�td��� dS )�> Create a POP3 server with some capabilities. r� N)r r �POP3r r� r r� � FileWrapper� transport�connectionMade�do_CAPA�listCapabilitiesr. �getvalue� splitlines�pcapsr' �mbox�lpcapsr� r r� r� �r! r- r� r' r' r( r� y s zCapabilityTests.setUpc C � t | d| j| j| j� dS )zB The server can advertise the I{UIDL} capability. r� N�r/ r. r: r< r. r' r' r( � test_UIDL� � zCapabilityTests.test_UIDLc C r> )zA The server can advertise the I{TOP} capability. s TOPNr? r. r' r' r( �test_TOP� rA zCapabilityTests.test_TOPc C r> )zB The server can advertise the I{USER} capability. r� Nr? r. r' r' r( � test_USER� rA zCapabilityTests.test_USERc C s$ t | d| j| j� t | d| j� dS )zj The server can advertise its per-user expiration as well as a global expiration. s EXPIRE 60 USERs EXPIRE 25Nr? r. r' r' r( � test_EXPIRE� � zCapabilityTests.test_EXPIREc C r> )zE The server can advertise its implementation string. s) IMPLEMENTATION Test Implementation StringNr? r. r' r' r( �test_IMPLEMENTATION� s �z#CapabilityTests.test_IMPLEMENTATIONc C r> )zH The server can advertise the SASL schemes it supports. s SASL SCHEME_1 SCHEME_2Nr? r. r' r' r( � test_SASL� rA zCapabilityTests.test_SASLc C s$ t | d| j| j� | �d| j� dS )zc The can advertise a per-user login delay as well as a global login delay. s LOGIN-DELAY 120 USERs LOGIN-DELAY 100N)r/ r. r: r+ r< r. r' r' r( �test_LOGIN_DELAY� rE z CapabilityTests.test_LOGIN_DELAYN) rL rM rN rO r� r@ rB rC rD rF rG rH r' r' r' r( r0 t s r0 c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �GlobalCapabilitiesTestsz> Tests for L{pop3.POP3}'s global capability handling. c C s� t � }t�� }t� |_d |j_|j_tj� |�|_ |� � |� � |� � | _|�� �� | _t � }t� |_tj� |�|_ |� � |�� �� | _|�t�td��� dS )r1 Fr� N)r r r2 r r� r" r% r r� r3 r4 r5 r6 r7 r. r8 r9 r: r' r; r< r� r r� r� r= r' r' r( r� � s z GlobalCapabilitiesTests.setUpc C r> )zG I{EXPIRE} is in the server's advertised capabilities. s EXPIRE 60Nr? r. r' r' r( rD � rA z#GlobalCapabilitiesTests.test_EXPIREc C r> )zL I{LOGIN-DELAY} is in the server's advertised capabilities. s LOGIN-DELAY 120Nr? r. r' r' r( rH � rA z(GlobalCapabilitiesTests.test_LOGIN_DELAYN)rL rM rN rO r� rD rH r' r' r' r( rI � s rI c @ r� )r� zI An L{IRealm} which knows about a single test account's mailbox. c G s |dkrt jtt�dd� fS J �)aE Retrieve a mailbox for I{testuser} or fail. @param avatarId: See L{IRealm.requestAvatar}. @param mind: See L{IRealm.requestAvatar}. @param interfaces: See L{IRealm.requestAvatar}. @raises: L{AssertionError} when requesting an C{avatarId} other than I{testuser}. r c S ri r_ r' r' r' r' r( rj � rk z)TestRealm.requestAvatar.<locals>.<lambda>r� )r! �avatarId�mind� interfacesr' r' r( � requestAvatar� s zTestRealm.requestAvatarN)rL rM rN rO rM r' r' r' r( r� � r� r� c @ r� )� SASLTestsz7 Tests for L{pop3.POP3}'s SASL implementation. c C s. t �� }t� |_dtjji|j_tj� t � �|_tj � � }|� dd� |j�|� t� }tj�|�|_|�� |�d� | �|�� �d�dk� |�d� |�� �� d d d � }t�|�}t j d|t d �� � � d �}|�t�!d | �� | �|j"� | �|�� �� d �d�dk� |�#t$�%t&d��� d S )z� A CRAM-MD5-based SASL login attempt succeeds if it uses a username and a hashed password known to the server's credentials checker. s CRAM-MD5r r s CAPAs SASL CRAM-MD5r s AUTH CRAM-MD5r0 r: N)� digestmod�asciis testuser r� r� )'r r2 r r� r � credentials�CramMD5Credentialsr� r� r� r� r� r� rd r� r r r� r3 r4 r5 � lineReceivedr� r8 �findr9 �base64� b64decode�hmac�HMACr � hexdigest�encode� b64encoder; r� r r� r� )r! r� r� r- �chalr� r' r' r( �test_ValidLogin s* � zSASLTests.test_ValidLoginN)rL rM rN rO r] r' r' r' r( rN r� rN c @ s� e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%S )&� CommandMixinzI Tests for all the commands a POP3 server is allowed to receive. s1 From: guy To: fellow More message text for you. c C s\ t �� }| �| j�|_t|_|| _t� }t j � |�|_ |� � |�d� |�d� || _dS )z� Make a POP3 server protocol instance hooked up to a simple mailbox and a transport that buffers output to a BytesIO. r N)r r2 � mailboxTyper� r; r3 �schedule� pop3Serverr r r� r3 r4 r5 �seek�truncate� pop3Transport�r! r� r- r' r' r( r� 4 s zCommandMixin.setUpc C s | j �t�td��� dS )zo Disconnect the server protocol so it can clean up anything it might need to clean up. r� N)ra r� r r� r� r. r' r' r( �tearDownE s �zCommandMixin.tearDownc C s | j j�� dS )zz Do some of the things that the reactor would take care of, if the reactor were actually running. N)ra r4 �_checkProducerr. r' r' r( �_flushN r� zCommandMixin._flushc C sh | j }| j}|�d� | �� | �|�� d� |�d� |�d� |�d� | �� | �|�� d� dS )z� Test the two forms of list: with a message index number, which should return a short-form response, and without a message index number, which should return a long-form response, one line per message. s LIST 1� +OK 1 44 r r� s +OK 1 1 44 . N�ra rd rS rh r r8 rb rc re r' r' r( � test_LISTV s zCommandMixin.test_LISTc C s� | j }| j}|�d� | �|�� d� |�d� |�d� |�d� | �|�� d� |�d� |�d� |�d� | �|�� d� |�d� |�d� dS ) zo Test that non-integers and out-of-bound integers produce appropriate error responses. s LIST as -ERR Invalid message-number: a r s LIST 0s -ERR Invalid message-number: 0 s LIST 2s -ERR Invalid message-number: 2 N�ra rd rS r r8 rb rc re r' r' r( �test_LISTWithBadArgumenti � z%CommandMixin.test_LISTWithBadArgumentc C s` | j }| j}|�d� | �|�� d� |�d� |�d� |�d� | �� | �|�� d� dS )zy Test the two forms of the UIDL command. These are just like the two forms of the LIST command. s UIDL 1r7 r r� s +OK 1 0 . N)ra rd rS r r8 rb rc rh re r' r' r( r@ � s zCommandMixin.test_UIDLc C � | j }| j}|�d� | �|�� d� |�d� |�d� |�d� | �|�� d� |�d� |�d� |�d� | �|�� d� |�d� |�d� dS )z� Test that UIDL with a non-integer or an out-of-bounds integer produces the appropriate error response. s UIDL a�" -ERR Bad message number argument r s UIDL 0s UIDL 2Nrl re r' r' r( �test_UIDLWithBadArgument� rn z%CommandMixin.test_UIDLWithBadArgumentc C s2 | j }| j}|�d� | �� | �|�� d� dS )z� Test the single form of the STAT command, which returns a short-form response of the number of messages in the mailbox and their total size. s STATri N)ra rd rS rh r r8 re r' r' r( � test_STAT� s zCommandMixin.test_STATc C sF | j }| j}|�d� | �� | �|�� d� |�d� |�d� dS )z- Test downloading a message. r� s; +OK 44 From: moshe To: moshe How are you, friend? . r Nrj re r' r' r( � test_RETR� s � zCommandMixin.test_RETRc C ro )z� Test that trying to download a message with a bad argument, either not an integer or an out-of-bounds integer, fails with the appropriate error response. s RETR arp r s RETR 0r� Nrl re r' r' r( �test_RETRWithBadArgument� s z%CommandMixin.test_RETRWithBadArgumentc C sB | j }| j}|jj�| j� |�d� | �� | �|� � d� dS )zQ Test downloading the headers and part of the body of a message. s TOP 1 0s9 +OK Top of message follows From: moshe To: moshe . N) ra rd r; r� rf � extraMessagerS rh r r8 re r' r' r( rB � s �zCommandMixin.test_TOPc C s | j }| j}|jj�| j� |�d� | �|�� d� |� d� |� d� |�d� | �|�� d� |� d� |� d� |�d� | �|�� d� |� d� |� d� |�d� | �|�� d� |� d� |� d� |�d� | �|�� d� |� d� |� d� d S ) a$ Test that trying to download a message with a bad argument, either a message number which isn't an integer or is an out-of-bounds integer or a number of lines which isn't an integer or is a negative integer, fails with the appropriate error response. s TOP 1 as -ERR Bad line count argument r s TOP 1 -1s TOP a 1rp s TOP 0 1s TOP 3 1N� ra rd r; r� rf ru rS r r8 rb rc re r' r' r( �test_TOPWithBadArgument� s. z$CommandMixin.test_TOPWithBadArgumentc C sN | j }| j}|jj�| j� |�d� | �|�� d� |� d� |� d� dS )z� Test the exceedingly pointless LAST command, which tells you the highest message index which you have already downloaded. � LASTr7 r Nrv re r' r' r( � test_LAST s zCommandMixin.test_LASTc C st | j }| j}|jj�| j� |�d� | �� |�d� |� d� |�d� | � |� � d� |�d� |� d� dS )zM Test that issuing a RETR command updates the LAST response. r� r rx � +OK 2 N� ra rd r; r� rf ru rS rh rb rc r r8 re r' r' r( �test_RetrieveUpdatesHighest& s z(CommandMixin.test_RetrieveUpdatesHighestc C s` | j }| j}|jj�| j� |�d� | �� |�d� |� d� |�d� | � |� � d� dS )zL Test that issuing a TOP command updates the LAST response. s TOP 2 10r rx rz Nr{ re r' r' r( �test_TopUpdatesHighest7 s z#CommandMixin.test_TopUpdatesHighestc C sr | j }| j}|jj�| j� |�d� | �� |�d� | �� |�d� |� d� |�d� | � |� � d� dS )z� Test that downloading a message with a smaller index than the current LAST response doesn't change the LAST response. r� s TOP 1 10r rx rz Nr{ re r' r' r( �test_HighestOnlyProgressesF s z'CommandMixin.test_HighestOnlyProgressesc C sj | j }| j}|jj�| j� |�d� | �� |�d� |�d� |� d� |�d� | � |� � d� dS )zH Test that issuing RSET changes the LAST response to 0. r� s RSETr rx r7 Nr{ re r' r' r( �test_ResetClearsHighestX s z$CommandMixin.test_ResetClearsHighestN)rL rM rN rO ru r� rf rh rk rm r@ rq rr rs rt rB rw ry r| r} r~ r r' r' r' r( r^ ( s( $ r^ z}twisted.mail.pop3.IMailbox.listMessages may not raise IndexError for out-of-bounds message numbers: raise ValueError instead.)rg �categoryzxtwisted.mail.pop3.IMailbox.getUidl may not raise IndexError for out-of-bounds message numbers: raise ValueError instead.c @ sX e Zd ZdZeZeZdd� Ze ge_ dd� Z e ge _ dd� Z e ge _ dd � Ze ge_ d S ) �IndexErrorCommandTestsz� Run all of the command tests against a mailbox which raises IndexError when an out of bounds request is made. This behavior will be deprecated shortly and then removed. c C � t �| �S )z� An attempt to get metadata about a message with a bad argument fails with an I{ERR} response even if the mailbox implementation raises L{IndexError}. )r^ rm r. r' r' r( rm � � z/IndexErrorCommandTests.test_LISTWithBadArgumentc C r� )z� An attempt to look up the UID of a message with a bad argument fails with an I{ERR} response even if the mailbox implementation raises L{IndexError}. )r^ rq r. r' r' r( rq � r� z/IndexErrorCommandTests.test_UIDLWithBadArgumentc C r� )z� An attempt to download some of a message with a bad argument fails with an I{ERR} response even if the mailbox implementation raises L{IndexError}. )r^ rw r. r' r' r( rw � r� z.IndexErrorCommandTests.test_TOPWithBadArgumentc C r� )z� An attempt to download a message with a bad argument fails with an I{ERR} response even if the mailbox implementation raises L{IndexError}. )r^ rt r. r' r' r( rt � r� z/IndexErrorCommandTests.test_RETRWithBadArgumentN)rL rM rN rO � IndexErrorr� r� r_ rm �_listMessageSuppressionr� rq �_getUidlSuppressionrw rt r' r' r' r( r� | s r� c @ s e Zd ZdZeZeZdS )�ValueErrorCommandTestsa Run all of the command tests against a mailbox which raises ValueError when an out of bounds request is made. This is the correct behavior and after support for mailboxes which raise IndexError is removed, this will become just C{CommandTestCase}. N)rL rM rN rO r� r� r� r_ r' r' r' r( r� � s r� c @ s e Zd ZdZddd�ZdS )�SyncDeferredMailboxzo Mailbox which has a listMessages implementation which returns a Deferred which has already fired. Nc C s t �t�| |��S )z� Synchronously list messages. @type n: L{int} or L{None} @param n: The 0-based index of the message. @return: A L{Deferred} which already has a message list result. )r �succeedr� ry )r! r& r' r' r( ry � s z SyncDeferredMailbox.listMessagesr_ )rL rM rN rO ry r' r' r' r( r� � s r� c @ � e Zd ZdZeZdS )�"IndexErrorSyncDeferredCommandTestsz{ Run all of the L{IndexErrorCommandTests} tests with a synchronous-Deferred returning IMailbox implementation. N�rL rM rN rO r� r_ r' r' r' r( r� � � r� c @ r� )�"ValueErrorSyncDeferredCommandTestsz{ Run all of the L{ValueErrorCommandTests} tests with a synchronous-Deferred returning IMailbox implementation. Nr� r' r' r' r( r� � r� r� c @ s" e Zd ZdZdd� Zddd�ZdS )�AsyncDeferredMailboxzo Mailbox which has a listMessages implementation which returns a Deferred which has not yet fired. c O s" g | _ tj| g|�R i |�� d S r_ )�waitingr� rb )r! r* �kwr' r' r( rb � s z AsyncDeferredMailbox.__init__Nc C s$ t �� }| j�|t�| |�f� |S )z� Record a new unfired L{Deferred} in C{self.waiting} and return it. @type n: L{int} or L{None} @param n: The 0-based index of the message. @return: The L{Deferred} )r �Deferredr� rf r� ry )r! r& r� r' r' r( ry � s z!AsyncDeferredMailbox.listMessagesr_ )rL rM rN rO rb ry r' r' r' r( r� � s r� c @ � e Zd ZdZeZdd� ZdS )�#IndexErrorAsyncDeferredCommandTests�} Run all of the L{IndexErrorCommandTests} tests with an asynchronous-Deferred returning IMailbox implementation. c C �> | j jjr| j jj�� \}}|�|� | j jjst�| � dS �zH Fire whatever Deferreds we've built up in our mailbox. N)ra r; r� �pop�callbackr� rh �r! r� r* r' r' r( rh � �z*IndexErrorAsyncDeferredCommandTests._flushN�rL rM rN rO r� r_ rh r' r' r' r( r� � � r� c @ r� )�#ValueErrorAsyncDeferredCommandTestsr� c C r� r� )ra r; r� r� r� r� rh r� r' r' r( rh r� z*ValueErrorAsyncDeferredCommandTests._flushNr� r' r' r' r( r� r� r� c @ r� )� POP3MiscTestsz} Miscellaneous tests more to do with module/package structure than anything to do with the Post Office Protocol. c C s( t jj}|jD ] }| �t||�� qdS )z� This test checks that all names listed in twisted.mail.pop3.__all__ are actually present in the module. N)�twistedr r �__all__r� �hasattr)r! �mod�attrr' r' r( �test_all" s �zPOP3MiscTests.test_allN)rL rM rN rO r� r' r' r' r( r� s r� c @ r� )�POP3ClientDeprecationTestszI Tests for the now deprecated L{twisted.mail.pop3client} module. c C s\ ddl m} | j| jgd�}| �|d d t� | �|d d d� | �t|�d� | dS ) z� A deprecation warning is emitted when directly importing the now deprected pop3client module. This test might fail is some other code has already imported it. No code should use the deprected module. r )� pop3client)�offendingFunctionsr� rg zXtwisted.mail.pop3client was deprecated in Twisted 21.2.0. Use twisted.mail.pop3 instead.r9 N)� twisted.mailr� � flushWarnings�test_deprecationr �DeprecationWarningrs )r! r� � warningsShownr' r' r( r� 1 s �z+POP3ClientDeprecationTests.test_deprecationN)rL rM rN rO r� r' r' r' r( r� , r� r� )LrO rU rW r � collectionsr �hashlibr �ior �zope.interfacer �twisted.cred.checkersr� �twisted.cred.credentials�twisted.cred.portal�twisted.internet.protocol�twisted.mail.pop3�twisted.mail.protocolsr r r �twisted.internetr r� r �twisted.protocolsr �twisted.pythonr �twisted.test.proto_helpersr � twisted.trialr r �TestCaser � protocols� VirtualPOP3rQ r^ rm r� r� r� r2 r� r� �Mailboxr� r� �IServerFactoryr r' r/ r0 rI r� rN r^ �_listMessageDeprecationr� �PendingDeprecationWarningr� �_getUidlDeprecationr� r� r� r� r� r� r� r� r� r� r� r' r' r' r( �<module> s� X)84_ < >7P)& D����3 PK Mb�Z��,� ^ ^ / mail/test/__pycache__/test_mail.cpython-310.pycnu �[��� o �b \ � @ s� d Z ddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZ ddlmZ ddlmZmZ ddlmZ ddlZddlZddlZddlZddl Zddl Zddl Zddl Zddl Zddlm!Z!m"Z" ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) dd l*m+Z+ dd l,m-Z-m.Z.m/Z/m0Z0 dd l1m2Z2m3Z3 dd l m4Z4 dd l5m6Z6 ddl7m8Z8m9Z9m:Z: ddl;m<Z< ddl=m>Z>m?Z? ddl@mAZA ddlBmCZC ddlDmEZEmFZFmGZG ddlHmIZI eeCdkd�G dd� deI��ZJeeCdkd�G dd� deI��ZKeeCdkd�G dd � d eI��ZLeeCdkd�G d d � d eI��ZMeeCdkd�G d d � d eI��ZNeeCdkd�G d!d"� d"eI��ZOeeCdkd�G d#d$� d$e"jPjQ��ZRG d%d&� d&�ZSeeCdkd�G d'd(� d(eIeS��ZTeeCdkd�G d)d*� d*eIeS��ZUeeCdkd�G d+d,� d,eI��ZVeeCdkd�G d-d.� d.eI��ZWeeCdkd�G d/d0� d0eI��ZXee"j"jY�G d1d2� d2��ZZeeCdkd�G d3d4� d4eI��Z[eeCdkd�G d5d6� d6eI��Z\G d7d8� d8e3j]�Z^eeCdkd�G d9d:� d:eI��Z_eeCdkd�G d;d<� d<eI��Z`G d=d>� d>�ZaeeCdkd�G d?d@� d@eI��ZbeeCdkd�G dAdB� dBeI��ZcddCl5mdZdmeZemfZf G dDdE� dEeejg�ZhdFdG� ZidHdI� ZjeeCdkd�G dJdK� dKeI��ZkeeCdkd�G dLdM� dMeI��ZlG dNdO� dO�ZmeeCdkd�G dPdQ� dQeI��ZnG dRdS� dS�ZoeeCdkd�G dTdU� dUeI��ZpG dVdW� dW�ZqG dXdY� dYe"jrjs�ZtG dZd[� d[e"jrju�ZvG d\d]� d]�ZweeCdkd�G d^d_� d_eI��ZxG d`da� da�ZyG dbdc� dc�ZzG ddde� de�Z{eeCdkd�G dfdg� dgeI��Z|dS )hz. Tests for large portions of L{twisted.mail}. � N)�md5)�skipIf)� Interface� implementer)� verifyClass)�cred�mail)�address�defer� interfaces�protocol�reactor�task)�Deferred)�CannotListenError�DNSLookupError� ProcessDone�ProcessTerminated)�pop3�smtp)�_AttemptManager)�dns)� Record_CNAME� Record_MX�RRHeader)� DNSNameError)�failure�log)�FilePath)� platformType)�LineSendingProtocol�MemoryReactorClock�StringTransport)�TestCase�posixz twisted.mail only works on posixc @ sD e Zd Zeejdkd�dd� �Zdd� Zdd� Zd d � Z d d � Z d S )�DomainWithDefaultsTests�� �not ported to Python 3c C s� dd� t d�D �}tj�|d�}| �t|�d� | �tt|��tt d��� | �t|�� �tt|��� t|�� �}|� � | �|dd� t d�D �� t|� � �}|� � | �|tt dd��� |� � }|� � | �|dd� t d�D �� |� � }|� � | �|tt dd��� t d�D ] }| �|| |d � | �|� |�|d � | �||v � q�|d = |d = |d = | �t|�d � | �|d d� | �|d d� | �|d d� |�d d dd�� | �t|�d� | �|d d � | �|d d � | �|d d� |�� | �t|�d� | �|�dd�d� | �|d d� | �|�� d� | �t|�d� |�� }| �|j|j� | �|j|j� d S )Nc S s i | ]}||d �qS �� � ��.0�xr+ r+ �=/usr/lib/python3/dist-packages/twisted/mail/test/test_mail.py� <dictcomp>@ � z7DomainWithDefaultsTests.testMethods.<locals>.<dictcomp>r* �Defaultc S � g | ]}||d f�qS r) r+ r, r+ r+ r/ � <listcomp>I � z7DomainWithDefaultsTests.testMethods.<locals>.<listcomp>� c S r3 r) r+ r, r+ r+ r/ r4 Q r5 � � � � r+ �*)�a�b�cr< r= r> r �key�value)r? r@ )�ranger �DomainWithDefaultDict� assertEqual�len�list�iter�iterkeys� iteritems�sort� itervalues�items�values�get� assertTrue�update�clear� setdefault�popitem�copy�domains�default)�self�drK rL r. �dcopyr+ r+ r/ � testMethods> sP z#DomainWithDefaultsTests.testMethodsc C sF t j �i d�}| �|jj||�� d|d< | �tddi�||�� dS )a� Assert that the class name of a L{mail.mail.DomainWithDefaultDict} instance and the string-formatted underlying domain dictionary both appear in the string produced by the given string-returning function. @type stringifier: one-argument callable @param stringifier: either C{str} or C{repr}, to be used to get a string to make assertions against. r2 r@ r? N)r rB �assertIn� __class__�__name__�str)rV � stringifier�domainr+ r+ r/ �_stringificationTestv s z,DomainWithDefaultsTests._stringificationTestc C � | � t� dS )z� L{DomainWithDefaultDict.__str__} should return a string including the class name and the domain mapping held by the instance. N)r` r] �rV r+ r+ r/ �test_str� � z DomainWithDefaultsTests.test_strc C ra )z� L{DomainWithDefaultDict.__repr__} should return a string including the class name and the domain mapping held by the instance. N)r` �reprrb r+ r+ r/ � test_repr� rd z!DomainWithDefaultsTests.test_reprc C sf t j �i d�}|�d� d}| �| jg�}| �dt|�� | �t|d d � | �||d d � dS ) z, has_key is now deprecated. r2 �anythingzotwisted.mail.mail.DomainWithDefaultDict.has_key was deprecated in Twisted 16.3.0. Use the `in` keyword instead.� r �category�messageN)r rB �has_key� flushWarnings�test_has_keyDeprecationrC rD �DeprecationWarning)rV �sutrj �warningsr+ r+ r/ rm � s �z/DomainWithDefaultsTests.test_has_keyDeprecationN) r\ � __module__� __qualname__r �sys� version_inforY r` rc rf rm r+ r+ r+ r/ r% < s 7 r% c @ �, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) � BounceTestsc C � t j �� | _d S �N)r � BounceDomainr_ rb r+ r+ r/ �setUp� � zBounceTests.setUpc C s | � tj| jjd� d S )Nzany user)� assertRaisesr � AddressErrorr_ �existsrb r+ r+ r/ � testExists� s zBounceTests.testExistsc C s | � | j�dd�d� d S )Nzrandom q emailerr F)rC r_ � willRelayrb r+ r+ r/ � testRelay� s zBounceTests.testRelayc C s& | j �dd� | �tj| j jd� d S )N�bob�password)r_ �addUserr| r � SMTPBadRcptr~ rb r+ r+ r/ � testAddUser� s zBounceTests.testAddUserN)r\ rq rr rz r r� r� r+ r+ r+ r/ rv � s rv c @ � e Zd ZdZdd� ZdS )�BounceWithSMTPServerTestsz_ Tests for L{twisted.mail.mail.BounceDomain} with L{twisted.mail.smtp.SMTPServer}. c C s� t j �� }t j �� }|�d|� t j�|�}|�d�}t j�|dd�}||_t � }|� |� |� d� |� d� |� d� |� d� | � |j � |�d� | �|�� �� �d�d d � dS ) zo Incoming emails to a SMTP server with L{twisted.mail.mail.BounceDomain} are rejected. s foo.comNs HELO baz.nets MAIL FROM:<a@baz.net>s RCPT TO:<any@foo.com>s QUITs ���s( 550 Cannot receive for specified address)r � MailServicery � addDomain� protocols� SMTPFactory� buildProtocol�SMTPDomainDelivery�deliveryr" �makeConnection� lineReceivedrN � disconnecting�connectionLostrC r@ �strip�split)rV �servicer_ �factoryr � deliverer� transportr+ r+ r/ � test_rejected� s& �z'BounceWithSMTPServerTests.test_rejectedN)r\ rq rr �__doc__r� r+ r+ r+ r/ r� � s r� c @ s\ e Zd Zdd� Zdd� Zdd� Zdd� Zeej d kd �d d � �Z eej d kd �d d� �Z dS )�FileMessageTestsc C s6 d| _ d| _t| j d�| _tj�| j| j | j�| _d S )NzfileMessage.testFilezfinal.fileMessage.testFile�w)�name�final�open�fr � FileMessage�fprb r+ r+ r/ rz � s zFileMessageTests.setUpc C sn z| j �� W n ty Y nw zt�| j� W n ty" Y nw z t�| j� W d S ty6 Y d S w rx )r� �close� BaseException�os�remover� r� rb r+ r+ r/ �tearDown� s � � �zFileMessageTests.tearDownc C s | j �� �| j�S rx )r� � eomReceived� addCallback� _cbFinalNamerb r+ r+ r/ � testFinalName� � z FileMessageTests.testFinalNamec C s4 | � || j� | �| jj� | �tj�| j �� d S rx ) rC r� rN r� �closed� assertFalser� �pathr~ r� �rV �resultr+ r+ r/ r� � s z FileMessageTests._cbFinalNamer& r( c C sh d}|� � D ]}| j�|� q| j�� t| j��}| �|�� |� W d � d S 1 s-w Y d S )Nz"first line second line third line )� splitlinesr� r� r� r� r� rC �read)rV �contents�liner� r+ r+ r/ � testContents� s "�z FileMessageTests.testContentsc C sT d}|� � D ]}| j�|� q| j�� | �tj�| j�� | �tj�| j �� d S )Nzfirst line second line ) r� r� r� r� r� r� r� r~ r� r� )rV r� r� r+ r+ r/ �testInterrupted s z FileMessageTests.testInterruptedN) r\ rq rr rz r� r� r� r rs rt r� r� r+ r+ r+ r/ r� � s r� c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�MailServiceTestsc C rw rx )r r� r� rb r+ r+ r/ rz r{ zMailServiceTests.setUpc C s� | j �� }| �t|tj�� | �|�d�tj� | j � � }| �t|tj�� | �|�d�t j � | j � � }| �t|tj�� | �|�d�t j � d S )N)� 127.0.0.1�90 )r� �getPOP3FactoryrN � isinstancer � ServerFactoryr� r �POP3�getSMTPFactoryr �SMTP�getESMTPFactory�ESMTP)rV r� r+ r+ r/ � testFactories s z MailServiceTests.testFactoriesc C sR t � }t � }|| jjd< || jjd< | �| j�d�|u � | �| j�� |u � d S )Nr_ � )�objectr� �portalsrN � lookupPortal� defaultPortal)rV �o1�o2r+ r+ r/ � testPortals s z MailServiceTests.testPortalsN)r\ rq rr rz r� r� r+ r+ r+ r/ r� s r� c @ sh e Zd ZdZdd� Zdd� Zeejdkd�dd � �Z eejdkd�d d � �Z d d � Z dd� Z dd� Z dS )�StringListMailboxTestszc Tests for L{StringListMailbox}, an in-memory only implementation of L{pop3.IMailbox}. c C sJ t j�g d��}| �|�d�d� | �|�d�d� | �|�d�d� dS )z� L{StringListMailbox.listMessages} returns the length of the message at the offset into the mailbox passed to it. )�abc�abr< r r' rh r7 N�r �maildir�StringListMailboxrC � listMessages�rV �mailboxr+ r+ r/ �test_listOneMessage0 s z*StringListMailboxTests.test_listOneMessagec C s( t j�g d��}| �|�� g d�� dS )z� L{StringListMailbox.listMessages} returns a list of the lengths of all messages if not passed an index. )r< r� r� )rh r' r7 Nr� r� r+ r+ r/ �test_listAllMessages: s z+StringListMailboxTests.test_listAllMessagesr& r( c C s* t j�ddg�}| �|�d��� d� dS )z� L{StringListMailbox.getMessage} returns a file-like object from which the contents of the message at the given offset into the mailbox can be read. �fooz real contentsrh N)r r� r� rC � getMessager� r� r+ r+ r/ �test_getMessageB s z&StringListMailboxTests.test_getMessagec C s, t j�ddg�}| �|�d�|�d�� dS )z� L{StringListMailbox.getUidl} returns a unique identifier for the message at the given offset into the mailbox. r� �barr rh N)r r� r� �assertNotEqual�getUidlr� r+ r+ r/ � test_getUidlL s z#StringListMailboxTests.test_getUidlc C s@ t j�dg�}|�d� | �|�d�d� | �|�� dg� dS )z� L{StringListMailbox.deleteMessage} marks a message for deletion causing further requests for its length to return 0. r� r N)r r� r� � deleteMessagerC r� r� r+ r+ r/ �test_deleteMessageU s z)StringListMailboxTests.test_deleteMessagec C sH t j�dg�}|�d� |�� | �|�d�d� | �|�� dg� dS )z� L{StringListMailbox.undeleteMessages} causes any messages marked for deletion to be returned to their original state. r� r r' N)r r� r� r� �undeleteMessagesrC r� r� r+ r+ r/ �test_undeleteMessages_ s z,StringListMailboxTests.test_undeleteMessagesc C sP t j�dg�}|�d� |�� |�� | �|�d�d� | �|�� dg� dS )zy L{StringListMailbox.sync} causes any messages as marked for deletion to be permanently deleted. r� r N)r r� r� r� �syncr� rC r� r� r+ r+ r/ � test_syncj s z StringListMailboxTests.test_syncN)r\ rq rr r� r� r� r rs rt r� r� r� r� r� r+ r+ r+ r/ r� ) s r� c @ s0 e Zd ZdZdZdZdd� Zdd� Zdd� ZdS ) �&FailingMaildirMailboxAppendMessageTaskTc C s | j r t�|||�S ttjd���NzFaked Permission Problem)� _openstater� r� �OSError�errno�EPERM)rV �fn�attr�moder+ r+ r/ �osopen s z-FailingMaildirMailboxAppendMessageTask.osopenc C � | j r t�||�S ttjd��)NzFaked Space problem)� _writestater� �writer� r� �ENOSPC)rV �fh�datar+ r+ r/ �oswrite� � z.FailingMaildirMailboxAppendMessageTask.oswritec C r� r� )� _renamestater� �renamer� r� r� )rV �oldname�newnamer+ r+ r/ �osrename� r� z/FailingMaildirMailboxAppendMessageTask.osrenameN) r\ rq rr r� r� r� r� r� r� r+ r+ r+ r/ r� w s r� c @ r� )�_AppendTestMixinz� Mixin for L{MaildirMailbox.appendMessage} test cases which defines a helper for serially appending multiple messages to a mailbox. c s: g �� ��fdd�}t �|� ��� }|��fdd�� |S )z� Deliver the given messages one at a time. Delivery is serialized to guarantee a predictable order in the mailbox (overlapped message deliver makes no guarantees about which message which appear first). c 3 s, � �D ]} � � | �}|��j� |V qd S rx )� appendMessager� �append)�mrW ��mbox�messages�resultsr+ r/ r� � s � �z0_AppendTestMixin._appendMessages.<locals>.appendc � � S rx r+ ��ignored)r r+ r/ �<lambda>� � z2_AppendTestMixin._appendMessages.<locals>.<lambda>)r � cooperate�whenDoner� )rV r r r� rW r+ r r/ �_appendMessages� s z _AppendTestMixin._appendMessagesN)r\ rq rr r� r r+ r+ r+ r/ r� � s r� c @ sJ e Zd ZdZdd� Zdd� Zddd�Zeej d kd �d d � �Z d d� Z dS )�MaildirAppendStringTests�O Tests for L{MaildirMailbox.appendMessage} when invoked with a C{str}. c C � | � � | _tj�| j� d S rx ��mktemprW r r� �initializeMaildirrb r+ r+ r/ rz � � z MaildirAppendStringTests.setUpc C s |� d�}| �|t�S )N�TEST)r� � assertFailure� Exception�rV r r rW r+ r+ r/ �_append� s z MaildirAppendStringTests._appendNc C sz |dur| � t|jd|jj� ||j_|dur&| � t|jd|jj� ||j_|dur;| � t|jd|jj� ||j_dS dS )a� Change the behavior of future C{rename}, C{write}, or C{open} calls made by the mailbox C{mbox}. @param rename: If not L{None}, a new value for the C{_renamestate} attribute of the mailbox's append factory. The original value will be restored at the end of the test. @param write: Like C{rename}, but for the C{_writestate} attribute. @param open: Like C{rename}, but for the C{_openstate} attribute. Nr� r� r� )� addCleanup�setattr� AppendFactoryr� r� r� )rV r r r� r� r� r+ r+ r/ � _setState� s, ��� �z"MaildirAppendStringTests._setStater& r( c C sV t j�| j�}t|_| �|dd� tdd�D ��}|�| j dgd � |�| j |� |S )�� L{MaildirMailbox.appendMessage} returns a L{Deferred} which fires when the message has been added to the end of the mailbox. c S s g | ]}d | �qS )�Xr+ �r- �ir+ r+ r/ r4 � s z8MaildirAppendStringTests.test_append.<locals>.<listcomp>rh � Nr* ) r r� �MaildirMailboxrW r� r r rA r� rC � _cbTestAppend)rV r rW r+ r+ r/ � test_append� s z$MaildirAppendStringTests.test_appendc s� | � t� �� �d� | � � fdd�td�D �ttdd��� | jd� dd� | �d� �}|j| j� d dd � |�| j� � |j| j� d dd � |�| j� � |j| j� d d � |S ) �� Check that the mailbox has the expected number (ten) of messages in it, and that each has the expected contents, and that they are in the same order as that in which they were appended. r* c � g | ] }t � �|��� ��qS r+ �rD r� r� r �r r+ r/ r4 � � z:MaildirAppendStringTests._cbTestAppend.<locals>.<listcomp>rh r! NF)r� T)r� r� )r� r� )r� )rC rD r� rA rE r r r� r r+ r( r/ r# � s � z&MaildirAppendStringTests._cbTestAppend)NNN) r\ rq rr r� rz r r r rs rt r$ r# r+ r+ r+ r/ r � s # r c @ s8 e Zd ZdZdd� Zeejdkd�dd� �Zdd � Z d S ) �MaildirAppendFileTestsr c C r rx r rb r+ r+ r/ rz r z MaildirAppendFileTests.setUpr& r( c C sx t j�| j�}g }tdd�D ] }t�� }|�d| � |�dd� |� |� | � |j � q| � ||�}|� | j|� |S )r rh r! r r )r r� r" rW rA �tempfile� TemporaryFiler� �seekr� r r� r r� r# )rV r r r �temprW r+ r+ r/ r$ s z"MaildirAppendFileTests.test_appendc s@ | � t� �� �d� | � � fdd�td�D �ttdd��� dS )r% r* c r& r+ r' r r( r+ r/ r4 $ r) z8MaildirAppendFileTests._cbTestAppend.<locals>.<listcomp>rh r! N)rC rD r� rA rE )rV r� r r+ r( r/ r# s �z$MaildirAppendFileTests._cbTestAppendN) r\ rq rr r� rz r rs rt r$ r# r+ r+ r+ r/ r* � s r* c @ sD e Zd Zdd� Zdd� Zdd� Zdd� Zeej d kd �d d � �Z d S )� MaildirTestsc C r rx r rb r+ r+ r/ rz * r zMaildirTests.setUpc C � t �| j� d S rx )�shutil�rmtreerW rb r+ r+ r/ r� . r{ zMaildirTests.tearDownc C s� | j }tj�|d�}| �tj�|�otj�|�� | �tj�tj�|d��� | �tj�tj�|d��� | �tj�tj�|d��� | �tj�tj�|d��� | �tj�tj�|d��� | �tj�tj�|d��� | �tj�tj�|d��� | �tj�tj�|d��� | �tj�tj�|d��� | �tj�tj�|d��� | �tj�tj�|d��� | �tj�tj�|d��� d S )N�.Trash�new�cur�tmp)rW r� r� �joinrN r~ �isdir)rV rW �trashr+ r+ r/ �testInitializer1 s z MaildirTests.testInitializerc C sJ t �� }|�d� tj�|�}|�� }|�d� |�� }| �||k � dS )a Each call to L{_MaildirNameGenerator.generate} returns a unique string suitable for use as the basename of a new message file. The names are ordered such that those generated earlier sort less than those generated later. g�������?N)r �Clock�advancer r� �_MaildirNameGenerator�generaterN )rV �clock� generator� firstName� secondNamer+ r+ r/ �test_nameGeneratorD s z MaildirTests.test_nameGeneratorr& r( c s� t jj� tjj�� �fdd�dD �}d}|D ]&}t� | j|�d��}|�d| � W d � n1 s3w Y |d }qtj� | j�}| � |� � t t dd��� | � |� d�d � | � |� d �d � | � |�d ��� d � | � |�d��� d � i }t d�D ]}|�|�}| �||v � d||< qt j�|d �\}}|�d � | � |� d �d� | �t j�� | jdd|��� | �t j�� | j|d ��� |�� | � |� d �d � | �t j�� | jdd|��� | �t j�� | j|d ��� dS )zb Exercise the methods of L{IMailbox} as implemented by L{MaildirMailbox}. c s& g | ]}t d �D ]}� |�� ��qqS )� )rA )r- r= r. ��j�nr+ r/ r4 ] s & z-MaildirTests.test_mailbox.<locals>.<listcomp>)r5 r4 rh r� r. Nr! r7 rD r9 �xxxxxxx�xxr* r r3 r5 )r� r� r7 r r� �_generateMaildirNamer� rW r� r" rC r� rE rA r� r� r� r� r� r� rN r~ r� ) rV �msgsr r� �fObj�mbrW �u�pr+ rE r/ � test_mailboxU s: � "zMaildirTests.test_mailboxN) r\ rq rr rz r� r: rC r rs rt rP r+ r+ r+ r/ r/ ( s r/ c @ r� )�AbstractMaildirDomainTestszB Tests for L{twisted.mail.maildir.AbstractMaildirDomain}. c C s t tjjtjj� dS )zW L{maildir.AbstractMaildirDomain} implements L{mail.IAliasableDomain}. N)r r �IAliasableDomainr� �AbstractMaildirDomainrb r+ r+ r/ �test_interface� � z)AbstractMaildirDomainTests.test_interfaceN)r\ rq rr r� rT r+ r+ r+ r/ rQ � s rQ c @ s� e Zd ZdZdd� Zdd� Zeejdkd�dd � �Z d d � Z eejdkd�d d � �Z eejdkd�dd� �Z eejdkd�dd� �Z dS )�MaildirDirdbmDomainTestsz+ Tests for L{MaildirDirdbmDomain}. c C s. | � � | _tj�� | _tj�| j| j�| _dS )zw Create a temporary L{MaildirDirdbmDomain} and parent L{MailService} before running each test. N)r �Pr r� �Sr� �MaildirDirdbmDomain�Drb r+ r+ r/ rz � s z MaildirDirdbmDomainTests.setUpc C s t �| j� dS )z_ Remove the temporary C{maildir} directory when the test has finished. N)r1 r2 rW rb r+ r+ r/ r� � s z!MaildirDirdbmDomainTests.tearDownr& r( c C sv d}|D ] \}}| j �||� q|D ]&\}}| �|| j jv � | �| j j| |� | �tj�tj�| j |��� qdS )z� L{MaildirDirdbmDomain.addUser} accepts a user and password argument. It stores those in a C{dbm} dictionary attribute and creates a directory for each user. ))�user1�pwd1)�user2�pwd2)�user3�pwd3N) rZ r� rN �dbmrC r� r� r~ r7 rW )rV �toAddrN rO r+ r+ r/ � test_addUser� s �z%MaildirDirdbmDomainTests.test_addUserc C sN | j �� }| �t|�d� | �tjj�|d �� | �tj j |d j v � dS )z� L{MaildirDirdbmDomain.getCredentialsCheckers} initializes and returns one L{ICredentialsChecker} checker by default. rh r N) rZ �getCredentialsCheckersrC rD rN r �checkers�ICredentialsChecker� providedBy� credentials�IUsernamePassword�credentialInterfaces)rV �credsr+ r+ r/ �test_credentials� s �z)MaildirDirdbmDomainTests.test_credentialsc C s� G dd� dt �}| j�dd� | �t| jjdd|� | j�ddtj�}| �t |�d� | � |d tju � | � tj� |d �� |d � dS ) a? L{MaildirDirdbmDomain.requestAvatar} raises L{NotImplementedError} unless it is supplied with an L{pop3.IMailbox} interface. When called with an L{pop3.IMailbox}, it returns a 3-tuple containing L{pop3.IMailbox}, an implementation of that interface and a NOOP callable. c @ s e Zd ZdS )z?MaildirDirdbmDomainTests.test_requestAvatar.<locals>.ISomethingN)r\ rq rr r+ r+ r+ r/ � ISomething� s rm �userr� Nr' r rh r7 ) r rZ r� r| �NotImplementedError� requestAvatarr �IMailboxrC rD rN rg )rV rm �tr+ r+ r/ �test_requestAvatar� s �z+MaildirDirdbmDomainTests.test_requestAvatarc C sb | j �dd� | j �� d }tj�dd�}| �tjj|j |� tj�dd�}| � |� |�d� dS )a L{DirdbmDatabase.requestAvatarId} raises L{UnauthorizedLogin} if supplied with invalid user credentials. When called with valid credentials, L{requestAvatarId} returns the username associated with the supplied credentials. rn r� r �wrong passwordN) rZ r� rd r rh �UsernamePasswordr| �error�UnauthorizedLogin�requestAvatarIdrC )rV �databaserk r+ r+ r/ �test_requestAvatarId� s z-MaildirDirdbmDomainTests.test_requestAvatarIdc C sz | j �dd� | �| j �d�tj�| j jd�� d| j _| � | j �d�d� d| j _| �| j �d�tj�| j jd�� dS )a] L{MaildirDirdbmDomain.userDirectory} is supplied with a user name and returns the path to that user's maildir subdirectory. Calling L{MaildirDirdbmDomain.userDirectory} with a non-existent user returns the 'postmaster' directory if there is a postmaster or returns L{None} if there is no postmaster. rn r� F�nouserNT� postmaster) rZ r� rC � userDirectoryr� r� r7 �rootr| �assertIdenticalrb r+ r+ r/ �test_userDirectory� s ��z+MaildirDirdbmDomainTests.test_userDirectoryN)r\ rq rr r� rz r� r rs rt rc rl rs rz r� r+ r+ r+ r/ rV � s rV c @ s2 e Zd ZdZd dd�Zdd� Zdd� Zd d � ZdS ) �StubAliasableDomainz> Minimal testable implementation of IAliasableDomain. Nc C � t � ��z{ No test coverage for invocations of this method on domain objects, so we just won't implement it. �ro �rV rn �memor+ r+ r/ r~ � zStubAliasableDomain.existsc C r� r� r� )rV rn r� r+ r+ r/ r� r� zStubAliasableDomain.addUserc C s g S )a! This needs to succeed in order for other tests to complete successfully, but we don't actually assert anything about its behavior. Return an empty list. Sometime later we should return something else and assert that a portal got set up properly. r+ rb r+ r+ r/ rd � z*StubAliasableDomain.getCredentialsCheckersc C � || _ dS )zG Just record the value so the test can check it later. N)� aliasGroup)rV �aliasesr+ r+ r/ � setAliasGroup s z!StubAliasableDomain.setAliasGrouprx )r\ rq rr r� r~ r� rd r� r+ r+ r+ r/ r� s r� c @ st e Zd Zdd� Zdd� Zdd� Zeejdkd�d d � �Z eejdkd�d d � �Z d d� Z dd� Z dd� Z dd� ZdS )�ServiceDomainTestsc C sr t j �� | _t j�| jd �| _| j| j_d| j_d| j_| � � | _ t j � | j| j �}|� dd� | j�d|� d S )Nr �hostname� user� password� test.domain)r r� rX r� �DomainDeliveryBaserZ r� � protocolName�hostr �tmpdirr� rY r� r� �rV r_ r+ r+ r/ rz ( s zServiceDomainTests.setUpc C r0 rx �r1 r2 r� rb r+ r+ r/ r� 4 r{ zServiceDomainTests.tearDownc C s4 t � }t� }|| j_| j�d|� | �|j|� dS )z� Test that adding an IAliasableDomain to a mail service properly sets up alias group references and such. � example.comN)r� r� rX r� r� r r� )rV r� r_ r+ r+ r/ �testAddAliasableDomain7 s z)ServiceDomainTests.testAddAliasableDomainr& r( c C sZ | j �dt�d�dg�}t�|�}tj�� }|� |�}| � t |� � �d� | � d|� d S )N)� remotehostz123.232.101.234z<someguy@someplace>zuser@host.namerh �Received)rZ �receivedHeaderr �Address�io�BytesIO�email�parser�Parser�parserC rD rK rZ )rV �hdrr� � emailParserr r+ r+ r/ �testReceivedHeaderB s � z%ServiceDomainTests.testReceivedHeaderc C s( t �ddd d�}t�| jj|��| j�S )Nzuser@test.domain�helo�wherever@whatever)r �Userr � maybeDeferredrZ � validateTor� � _cbValidateTo�rV rn r+ r+ r/ �testValidateToO s �z!ServiceDomainTests.testValidateToc C s | � t|�� d S rx )rN �callabler� r+ r+ r/ r� V r� z ServiceDomainTests._cbValidateToc C �* t �ddd d�}| �t�| jj|�t j�S )Nzresu@test.domainr� r� �r r� r r r� rZ r� r� r� r+ r+ r/ �testValidateToBadUsernameY � �z,ServiceDomainTests.testValidateToBadUsernamec C r� )Nzuser@domain.testr� r� r� r� r+ r+ r/ �testValidateToBadDomain_ r� z*ServiceDomainTests.testValidateToBadDomainc C s� d}t �d�}| �| j�||�|u � d}t �d�}| �| j�||�|u � d}t �d�}| �| j�||�|u � | �t j| jjd |� d S )N)r� r� z<user@hostname>)r� �1.2.3.4z<>)r r� rN rZ � validateFromr| � SMTPBadSender)rV r� �originr+ r+ r/ �testValidateFrome s z#ServiceDomainTests.testValidateFromN)r\ rq rr rz r� r� r rs rt r� r� r� r� r� r� r+ r+ r+ r/ r� & s r� c @ s� e Zd Zdd� Zdd� Zeejdkd�dd� �Zd d � Z eejdkd�d d � �Z eejdkd�d d� �Z eejdkd�dd� �Z dd� Z eejdkd�dd� �Zeejdkd�dd� �ZdS )�VirtualPOP3Testsc C s� | � � | _tj�� | _tj�| j| j�| _| j�dd� | j� d| j� t j � | j�}t |j| j�� � | | jjd< | jjd< tj�� | _| j| j_d| j_d S )Nr� r� r� r� z<unit test magic>)r r� r r� rX r� rY rZ r� r� r �portal�Portal�map�registerCheckerrd r� r� � VirtualPOP3rW r� �magic)rV r� r+ r+ r/ rz w s zVirtualPOP3Tests.setUpc C r0 rx r� rb r+ r+ r/ r� � r{ zVirtualPOP3Tests.tearDownr& r( c C s* t | jjd ��� }| j�d|��| j�S )Nr� rn )r rW r� � hexdigest�authenticateUserAPOPr� �_cbAuthenticateAPOP�rV �respr+ r+ r/ �testAuthenticateAPOP� s �z%VirtualPOP3Tests.testAuthenticateAPOPc C �F | � t|�d� | � |d tj� | �tj�|d �� |d � d S �Nr' r rh r7 �rC rD r rq rN rg r� r+ r+ r/ r� � � z$VirtualPOP3Tests._cbAuthenticateAPOPc C s. t | jjd ��� }| �| j�d|�tjj�S )Nr� �resu) r rW r� r� r r� r rv rw r� r+ r+ r/ �!testAuthenticateIncorrectUserAPOP� s �z2VirtualPOP3Tests.testAuthenticateIncorrectUserAPOPc C s& t d��� }| �| j�d|�tjj�S )Nz wrong digestrn )r r� r rW r� r rv rw r� r+ r+ r/ �%testAuthenticateIncorrectResponseAPOP� s �z6VirtualPOP3Tests.testAuthenticateIncorrectResponseAPOPc C s | j �dd��| j�S )Nrn r� )rW �authenticateUserPASSr� �_cbAuthenticatePASSrb r+ r+ r/ �testAuthenticatePASS� s �z%VirtualPOP3Tests.testAuthenticatePASSc C r� r� r� r� r+ r+ r/ r� � r� z$VirtualPOP3Tests._cbAuthenticatePASSc C � | � | j�dd�tjj�S )Nr� r� �r rW r� r rv rw rb r+ r+ r/ �testAuthenticateBadUserPASS� � �z,VirtualPOP3Tests.testAuthenticateBadUserPASSc C r� )Nrn rt r� rb r+ r+ r/ � testAuthenticateBadPasswordPASS� r� z0VirtualPOP3Tests.testAuthenticateBadPasswordPASSN)r\ rq rr rz r� r rs rt r� r� r� r� r� r� r� r� r+ r+ r+ r/ r� u s" r� c @ s e Zd Zdd� ZdS )�emptyc C s d S rx r+ rb r+ r+ r/ �__init__� s zempty.__init__N)r\ rq rr r� r+ r+ r+ r/ r� � s r� c @ s$ e Zd Zeejdkd�dd� �ZdS )� RelayTestsr& r( c s� t j �� }t j�|�}t�d�t�ddd�g}t�ddd�t�ddd�g}|D ]'� t� }d |_d |_ t� |_ t� |j _ � fd d �|j j _ | � t|�|��� q'|D ]&� t� }d |_t� |_ t� |j _ � fdd �|j j _ d|_ | �tj|j|� qQd S )Nz/var/run/mail-relay�TCPr� r� z 192.168.2.1�> r� i� z user@hostz tsoh@resuc r rx r+ r+ ��peerr+ r/ r � r z'RelayTests.testExists.<locals>.<lambda>z some@placec r rx r+ r+ r� r+ r/ r � r z who@cares)r r� �relay� DomainQueuerr � UNIXAddress� IPv4Addressr� �orig�destr r� �getPeerrN r� r~ r| r r� )rV r� r_ �doRelay� dontRelayrn r+ r� r/ r � s2 � � �zRelayTests.testExistsN)r\ rq rr r rs rt r r+ r+ r+ r/ r� � s r� c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) � RelayerTestsc C s� | � � | _t�| j� g | _td�D ]J}tj�| jd|f �}t|d d��}t � d|f d|f g|� W d � n1 s?w Y t|d d�}|� |� |� d d � | j� |� qtj�� | _| j�| j� d S ) Nr* �body-%d�-H�wb�from-%d�to-%d�-Dr� r )r r� r� �mkdir� messageFilesrA r� r7 r� �pickle�dumpr� r- r� r r� � RelayerMixin�R� loadMessages)rV r r� r� r+ r+ r/ rz � s � zRelayerTests.setUpc C r0 rx r� rb r+ r+ r/ r� � r{ zRelayerTests.tearDownc C sP t d�D ]}| �| j�� d|f � | j�dd d d d � q| �| j�� d � d S )Nr* r� � )rA rC r� � getMailFrom�sentMail�rV r r+ r+ r/ � testMailFrom s zRelayerTests.testMailFromc C sR t d�D ]}| �| j�� d|f g� | j�dd d d d � q| �| j�� d � d S )Nr* r� r� )rA rC r� � getMailTor� r� r+ r+ r/ � testMailTo s zRelayerTests.testMailToc C sd t d�D ]"}tj�| jd|f �}| �| j�� �� |� | j� dd d d d � q| �| j�� d � d S )Nr* r� r� ) rA r� r� r7 r� rC r� � getMailDatar� r� )rV r r� r+ r+ r/ � testMailData s zRelayerTests.testMailDataN)r\ rq rr rz r� r� r� r� r+ r+ r+ r/ r� � s r� c @ ru ) �Managerc C s g | _ g | _g | _d S rx )�successr �donerb r+ r+ r/ r� � zManager.__init__c C � | j �||f� d S rx )r� r� �rV r� rj r+ r+ r/ � notifySuccess � zManager.notifySuccessc C r rx )r r� r r+ r+ r/ � notifyFailure r zManager.notifyFailurec C � | j �|� d S rx )r� r� )rV r� r+ r+ r/ � notifyDone r{ zManager.notifyDoneN)r\ rq rr r� r r r r+ r+ r+ r/ r� s r� c @ ru ) �ManagedRelayerTestsc C sd t � | _ttddd��| _t� | _tj� | j�| _ | jd d � | j _| jd d � | j _ | j| j _d S )Nr r6 r7 ) r� �managerrE rA r r� r� r � relaymanager�ManagedRelayerMixinr� �namesrb r+ r+ r/ rz & s zManagedRelayerTests.setUpc �D � j D ] }� j�dd d d d � q� �� jj� fdd�� j D �� d S )Nr� c � g | ]}� j |f�qS r+ �r� �r- r rb r+ r/ r4 4 r1 z>ManagedRelayerTests.testSuccessfulSentMail.<locals>.<listcomp>)r r� r� rC r r� r� r+ rb r/ �testSuccessfulSentMail/ � �z*ManagedRelayerTests.testSuccessfulSentMailc r )Ni& c r r+ r r rb r+ r/ r4 < r1 z:ManagedRelayerTests.testFailedSentMail.<locals>.<listcomp>)r r� r� rC r r r� r+ rb r/ �testFailedSentMail7 r z&ManagedRelayerTests.testFailedSentMailc C s, | j �t�t� �� | �| jj| jg� d S rx ) r� r� r �Failurer rC r r� r� rb r+ r+ r/ �testConnectionLost? s z&ManagedRelayerTests.testConnectionLostN)r\ rq rr rz r r r r+ r+ r+ r/ r $ s r c @ sl e Zd Zdd� Zdd� Zeejdkd�dd� �Zeejdkd�d d � �Z eejdkd�d d � �Z d d� Z dS )�DirectoryQueueTestsc C s� | � � | _t�| j� tj�| j�| _d| j_t d�D ]/}| j� � \}}|� t � d|g|� W d � n1 s9w Y |� d|f � |�� q| j�� d S )NF� �headers body: %d)r r� r� r� r r �Queue�queue�noisyrA �createNewMessager� r� r� r� � readDirectory)rV r �hdrF�msgFr+ r+ r/ rz F s � zDirectoryQueueTests.setUpc C r0 rx r� rb r+ r+ r/ r� T r{ z DirectoryQueueTests.tearDownr& r( c C s� | � | j�� � | �t| j�� �d� | j�� }| j�|d � | �t| j�� �d� | j�|d � | �t| j�� �d� d S )Nr r � )rN r � hasWaitingrC rD � getWaiting� setRelaying� setWaiting)rV �waitingr+ r+ r/ � testWaitingW s z DirectoryQueueTests.testWaitingc C s� | j �� D ]}| j �|� | �t| j �� �dt| j �� � � q| �| j �� � | j �� }| j �|d � | �t| j �� �d� | �t| j �� �d� d S )Nr r rh r ) r r" r# rC rD � getRelayedr� r! r$ )rV r �relayedr+ r+ r/ � testRelayingc s � z DirectoryQueueTests.testRelayingc C s~ | j �� d }| j �|� | j �|� | �t| j �� �d� | �t| j �� �d� | �|| j �� v � | �|| j �� v � d S )Nr r )r r" r# r� rC rD r' r� )rV �msgr+ r+ r/ �testDoner s z DirectoryQueueTests.testDonec C sV g }| j �� D ] }|�| j �|�� q|�� td�D ] }| �|�d�d|g� qd S )Nr r r )r r" r� � getEnveloperI rA rC �pop)rV � envelopesr* r r+ r+ r/ � testEnvelope~ s �z DirectoryQueueTests.testEnvelopeN) r\ rq rr rz r� r rs rt r& r) r+ r/ r+ r+ r+ r/ r D s r )�client�common�serverc @ � e Zd Zdd� Zddd�ZdS )� TestAuthorityc C s t j�| � i | _d S rx )r1 � ResolverBaser� � addressesrb r+ r+ r/ r� � s zTestAuthority.__init__Nc C sv || j v r0|tjkr0g }| j | D ]}t�|tjtjdt�d|��}|�|� qt�|g g f�S t� t � t� |���S )N�< r ) r6 r �MXr �INr r� r �succeed�failr r � DomainError)rV r� �cls�type�timeoutr r< r� r+ r+ r/ �_lookup� s zTestAuthority._lookuprx )r\ rq rr r� r@ r+ r+ r+ r/ r4 � � r4 c C s� t � | _t�| jg�}t�|�} tjd|dd�| _| j� � j}z tj ||dd�| _ W n t y9 | j� � Y nw nqtjd|fgd�| _d S )Nrh r r� �� interface)�servers)r4 �authr2 �DNSServerFactoryr �DNSDatagramProtocolr � listenTCP�port�getHost� listenUDP�udpPortr � stopListeningr0 �Resolver�resolver)rV r� r � portNumberr+ r+ r/ �setUpDNS� s � �� rQ c C sZ g }|� t�| jj�� |� t�| jj�� z| jj�� W n t y' Y nw t� |�S rx ) r� r r� rI rM rL rO � _parseCall�cancelr� � DeferredList)rV �dlr+ r+ r/ � tearDownDNS� s � rV c @ s� e Zd ZdZdd� Zdd� Zdd� Zeej dkd �d d � �Z d d � Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zeej dkd �d*d+� �Zd,d-� Zd.d/� Z d0d1� Z d2d3� Z d4S )5�MXTestsz6 Tests for L{mail.relaymanager.MXCalculator}. c C s* t | � t�� | _tj�| j| j�| _d S rx ) rQ r r; r? r r � MXCalculatorrO �mxrb r+ r+ r/ rz � s z MXTests.setUpc C s t | �S rx )rV rb r+ r+ r/ r� � s zMXTests.tearDownc C s | � tj�| j�jt� dS )zQ L{MXCalculator}'s default clock is C{twisted.internet.reactor}. N)r r r rX rO r? r rb r+ r+ r/ �test_defaultClock� s �zMXTests.test_defaultClockr& r( c C s" dg| j jd< | j�d��| j�S )N�the.email.test.domainr� )rE r6 rY �getMXr� �_cbSimpleSuccessrb r+ r+ r/ �testSimpleSuccess� s zMXTests.testSimpleSuccessc C s$ | � |jd� | � t|j�d� d S )Nr r[ )rC � preferencer] r� �rV rY r+ r+ r/ r] � s zMXTests._cbSimpleSuccessc C s d| j _| �| j �d�t�S )NFr� )rY �fallbackToDomainr r\ �IOErrorrb r+ r+ r/ �testSimpleFailure� s zMXTests.testSimpleFailurec C s | � | j�d�t�S �Nr� )r rY r\ r rb r+ r+ r/ � testSimpleFailureWithFallback� r z%MXTests.testSimpleFailureWithFallbackc sF G ��fdd�d�}|� �j _�j ���}� �fdd�}|�|� |S )aZ Issue an MX request for the given domain and arrange for it to be responded to with the given records. Verify that the resulting mail exchange is the indicated host. @type domain: C{str} @type records: C{list} of L{RRHeader} @type correctMailExchange: C{str} @rtype: L{Deferred} c � e Zd Z� �fdd�ZdS )z,MXTests._exchangeTest.<locals>.DummyResolverc s& |� kr t ��g g f�S t �t� ��S rx )r r: r; r )rV r� �r_ �recordsr+ r/ �lookupMailExchange� s z?MXTests._exchangeTest.<locals>.DummyResolver.lookupMailExchangeN�r\ rq rr ri r+ rg r+ r/ � DummyResolver� � rk c s �� t| j�� � d S rx �rC r] r� )�record)�correctMailExchangerV r+ r/ �gotMailExchange� s z.MXTests._exchangeTest.<locals>.gotMailExchange)rY rO r\ r� )rV r_ rh ro rk rW rp r+ )ro r_ rh rV r/ � _exchangeTest� s zMXTests._exchangeTestc C sZ d}d}d}t |tjtd|�d�t |tjtd|�d�t |tjtd|�d�g}| �|||�S )zh The MX record with the lowest preference is returned by L{MXCalculator.getMX}. r� �good.example.com�bad.example.comrh �r� r> �payloadr r7 )r r �TYPErq �rV r_ �good�badrh r+ r+ r/ �test_mailExchangePreference� s �z#MXTests.test_mailExchangePreferencec C sR d}d}d}t |tjtd|�d�t |tjtd|�d�g}| j�|� | �|||�S )z� L{MXCalculator.getMX} returns the MX record with the lowest preference which is not also marked as bad. r� rr rs r rt rh �r r rv rY �markBadrq rw r+ r+ r/ �test_badExchangeExcluded s � z MXTests.test_badExchangeExcludedc C s^ d}d}d}t |tjtd|�d�t |tjtd|�d�g}| j�|� | j�|� | �|||�S )z� L{MXCalculator.getMX} returns the MX record with the lowest preference if all the MX records in the response have been marked bad. r� rs zworse.example.comr rt rh r{ )rV r_ ry �worserh r+ r+ r/ � test_fallbackForAllBadExchanges s � z'MXTests.test_fallbackForAllBadExchangesc C sb d}d}d}t |tjtd|�d�t |tjtd|�d�g}| j�|� | j�| jj� | �|||�S )z� L{MXCalculator.getMX} returns the MX record with the lowest preference if it was last marked bad longer than L{MXCalculator.timeOutBadMX} seconds ago. r� rr rs r rt rh ) r r rv rY r| r? r< � timeOutBadMXrq �rV r_ rx � previouslyBadrh r+ r+ r/ �test_badExchangeExpires+ s �� z MXTests.test_badExchangeExpiresc C sn d}d}d}t |tjtd|�d�t |tjtd|�d�g}| j�|� | j�|� | j�| jj� | � |||�S )z� L{MXCalculator.getMX} returns the MX record with the lowest preference if it was marked good after it was marked bad. r� rr rs r rt rh ) r r rv rY r| �markGoodr? r< r� rq r� r+ r+ r/ �test_goodExchangeUsed? s �� z MXTests.test_goodExchangeUsedc sJ d�d� G � �fdd�d�}|� | j _| j �� �}|�| jt�d�� |S )z� If an MX lookup succeeds but the result set is empty, L{MXCalculator.getMX} should try to look up an I{A} record for the requested name and call back its returned Deferred with that address. r� z example.orgc s6 e Zd ZdZ� g g g fiZ� �iZdd� Zdd� ZdS )z9MXTests.test_successWithoutResults.<locals>.DummyResolverah Fake resolver which will respond to an MX lookup with an empty result set. @ivar mx: A dictionary mapping hostnames to three-tuples of results to be returned from I{MX} lookups. @ivar a: A dictionary mapping hostnames to addresses to be returned from I{A} lookups. c S � t �| j| �S rx )r r: rY r� r+ r+ r/ ri l r{ zLMXTests.test_successWithoutResults.<locals>.DummyResolver.lookupMailExchangec S r� rx )r r: r< r� r+ r+ r/ � getHostByNameo r{ zGMXTests.test_successWithoutResults.<locals>.DummyResolver.getHostByNameN)r\ rq rr r� rY r< ri r� r+ �r_ �ipr+ r/ rk ] s rk �r� �rY rO r\ r� rC r �rV rk rW r+ r� r/ �test_successWithoutResultsS s z"MXTests.test_successWithoutResultsc C s< G dd� d�}|� | j _| j �d�}|�| jtdd�� |S )a' Test that if the MX record lookup fails, fallback is enabled, and an A record is available for the name, then the Deferred returned by L{MXCalculator.getMX} ultimately fires with a Record_MX instance which gives the address in the A record for the name. c @ s e Zd ZdZdd� Zdd� ZdS )zAMXTests.test_failureWithSuccessfulFallback.<locals>.DummyResolverzw Fake resolver which will fail an MX lookup but then succeed a getHostByName call. c S s t �t� �S rx )r r; r r� r+ r+ r/ ri � s zTMXTests.test_failureWithSuccessfulFallback.<locals>.DummyResolver.lookupMailExchangec S s t �d�S )Nr� )r r: r� r+ r+ r/ r� � � zOMXTests.test_failureWithSuccessfulFallback.<locals>.DummyResolver.getHostByNameN)r\ rq rr r� ri r� r+ r+ r+ r/ rk s rk r_ r� r� r� r� r+ r+ r/ �"test_failureWithSuccessfulFallbackw s z*MXTests.test_failureWithSuccessfulFallbackc sP d� d�d�G � ��fdd�d�}|� | j _| j �� �}|�| jt�d�� |S )z� If an MX lookup returns a single CNAME record as a result, MXCalculator will perform an MX lookup for the canonical name indicated and return the MX record which results. �alias.example.com�canonical.example.com�mail.example.comc s e Zd ZdZ� ��fdd�ZdS )z;MXTests.test_cnameWithoutGlueRecords.<locals>.DummyResolverz� Fake resolver which will return a CNAME for an MX lookup of a name which is an alias and an MX for an MX lookup of the canonical name. c sd |� krt �t|tjt��d�gg g f�S |�kr+t �t|tjtd��d�gg g f�S t �t|��S )Nrt r )r r: r r rv r r; r r� ��alias� canonical�exchanger+ r/ ri � s2 ���� ����zNMXTests.test_cnameWithoutGlueRecords.<locals>.DummyResolver.lookupMailExchangeN)r\ rq rr r� ri r+ r� r+ r/ rk � s rk r� r� r� r+ r� r/ � test_cnameWithoutGlueRecords� s & z$MXTests.test_cnameWithoutGlueRecordsc sX G dd� d�}d� |� �j _�j �d� �}��|tjjj� � �fdd�}|�|� |S )z� If L{MXCalculator.getMX} encounters a CNAME chain which is longer than the length specified, the returned L{Deferred} should errback with L{CanonicalNameChainTooLong}. c @ s e Zd ZdZdZdd� ZdS )z.MXTests.test_cnameChain.<locals>.DummyResolverz Fake resolver which generates a CNAME chain of infinite length in response to MX lookups. r c S s< | j d7 _ d| j f }t�t|tjt|�d�gg g f�S )Nrh �x-%d.example.comrt )� chainCounterr r: r r rv )rV r_ r� r+ r+ r/ ri � s ����zAMXTests.test_cnameChain.<locals>.DummyResolver.lookupMailExchangeN)r\ rq rr r� r� ri r+ r+ r+ r/ rk � s rk r' r� c s: �� | jd td� d f �� �� �jjj� d � d S )Nr r� rh )rC �argsr rY rO r� )rv �� cnameLimitrV r+ r/ �cbChainTooLong� s �z/MXTests.test_cnameChain.<locals>.cbChainTooLong) rY rO r\ r �twistedr r �CanonicalNameChainTooLongr� )rV rk rW r� r+ r� r/ �test_cnameChain� s zMXTests.test_cnameChainc sV g �d� d�d�G � ���fdd�d�}|� | j _| j �� �}|�| jt�d�� |S )z� If an MX lookup returns a CNAME and the MX record for the CNAME, the L{Deferred} returned by L{MXCalculator.getMX} should be called back with the name from the MX record without further lookups being attempted. r� r� r� c s e Zd Z� ���fdd�ZdS )z8MXTests.test_cnameWithGlueRecords.<locals>.DummyResolverc sL |� ks�r g g g fS t �t� tjt��d�t�tjt�d�d�gg g f�S )Nrt r� )r r: r r rv r r� �r� r� r� �lookedUpr+ r/ ri s$ ��� ��zKMXTests.test_cnameWithGlueRecords.<locals>.DummyResolver.lookupMailExchangeNrj r+ r� r+ r/ rk � s rk r� r� r� r+ r� r/ �test_cnameWithGlueRecords� s z!MXTests.test_cnameWithGlueRecordsc sH d� d�G � �fdd�d�}|� | j _| j �� �}| �|tjjj� |S )z� If an MX lookup returns two CNAME records which point to each other, the loop should be detected and the L{Deferred} returned by L{MXCalculator.getMX} should be errbacked with L{CanonicalNameLoop}. zcname1.example.comzcname2.example.comc rf )z<MXTests.test_cnameLoopWithGlueRecords.<locals>.DummyResolverc s4 t �t� tjt��d�t�tjt� �d�gg g f�S )Nrt )r r: r r rv r� �� firstAlias� secondAliasr+ r/ ri ' s ��� ��zOMXTests.test_cnameLoopWithGlueRecords.<locals>.DummyResolver.lookupMailExchangeNrj r+ r� r+ r/ rk & rl rk )rY rO r\ r r� r r �CanonicalNameLoopr� r+ r� r/ � test_cnameLoopWithGlueRecords s z%MXTests.test_cnameLoopWithGlueRecordsc C s$ g d�| j jd< | j�d��| j�S )N)zmx1.test.domainzmx2.test.domainzmx3.test.domainr� )rE r6 rY r\ r� � _cbManyRecordsSuccessfulLookuprb r+ r+ r/ �testManyRecords@ s �zMXTests.testManyRecordsc C sH | � t|j��dd�d dv � | j�t|j�� | j�d��| j|�S )N�.rh r )�mx1�mx2�mx3r� ) rN r] r� r� rY r| r\ r� � _cbManyRecordsDifferentResultr` r+ r+ r/ r� K s �z&MXTests._cbManyRecordsSuccessfulLookupc C sB | � t|j�t|j�� | j�t|j�� | j�d��| j||�S rd )r� r] r� rY r| r\ r� �_cbManyRecordsLastResult)rV �nextMXrY r+ r+ r/ r� R s �z%MXTests._cbManyRecordsDifferentResultc C sj | � t|j�t|j�� | � t|j�t|j�� | j�t|j�� | j�t|j�� | j�d��| j|�S rd ) r� r] r� rY r| r� r\ r� �"_cbManyRecordsRepeatSpecificResult)rV �lastMXrY r� r+ r+ r/ r� Z s �z MXTests._cbManyRecordsLastResultc C s | � t|j�t|j�� d S rx rm )rV �againMXr� r+ r+ r/ r� e s z*MXTests._cbManyRecordsRepeatSpecificResultN) r\ rq rr r� rz r� rZ r rs rt r^ r] rc re rq rz r} r r� r� r� r� r� r� r� r� r� r� r� r� r� r+ r+ r+ r/ rW � s8 $5.*# rW c @ s` e Zd Ze�ed�du rdZdd� Zdd� Ze e j dkd�d d � �Z e e j dkd�d d � �Z dS ) �LiveFireExerciseTestsNz1UDP support is required to determining MX recordsc C s t | � g d�| _d S )N)� domainDir�insertionDomain�insertionQueue�destinationDomain�destinationQueue)rQ �tmpdirsrb r+ r+ r/ rz n s zLiveFireExerciseTests.setUpc C s* | j D ] }tj�|�rt�|� qt| �S rx )r� r� r� r~ r1 r2 rV )rV rW r+ r+ r/ r� x s �z LiveFireExerciseTests.tearDownr& r( c s� t j �� }|j�tj�� � t j�|d���� dd� |� d�� |j d |j d< t |j d j�� � � |�t j�|�� |�� }tjd|dd��_tg d ��� t� �t�� }� fd d �|_�fd d �|_t�d�j�� j |� ��fd d�}�� |� �S )Nr� rn r� r� r� r r� rB )� HELO mesonzMAIL FROM: <user@hostname>zRCPT TO: <user@test.domain>�DATA�This is the messager� �QUITc r rx r+ r+ �r0 r+ r/ r � r z9LiveFireExerciseTests.testLocalDelivery.<locals>.<lambda>c � � � d �S rx ��callback�r� �r� r+ r/ r � � c s> � � dd tj�d }|�d��� }��|�d�d� �j�� S �Nrn rh r r� ���) rp r rq r� r� r� �find� smtpServerrM ��ignr r* )r_ rV r+ r/ �finished� s z9LiveFireExerciseTests.testLocalDelivery.<locals>.finished) r r� � smtpPortalr� r re �AllowAnonymousAccessr� rY r� r� r� r� rd �setQueuer� r� r� r rH r� r r r � ClientFactory�clientConnectionLost� connectTCPrJ rI r� )rV r� r� r� r+ )r0 r_ r� rV r/ �testLocalDelivery~ s* � z'LiveFireExerciseTests.testLocalDeliveryc s� t j �� }|j�tj�� � t j�|d��|� d�� t � d� |� t j �d�� |j�t j�|�� t j �|j��� jd7 _t j ��d��t j ��j��_dg�jjd< |� � }t j d|dd ��_ t j �� }|j�tj�� � t j�|d ���� d d � |� d�� t � d � |� t j �d �� t j ��d����!� |� � }t j d|dd ��_"�j"�#� j$�_%t&g d��� t'� �t(�)� }� fdd�|_(�fdd�|_*t �+d�j �#� j$|� ����fdd�}��,|� �S )Nr� zinsertion.domainr� )ztest.identity.hostnamerh r� zdestination.domainr rB r� rn r� r� )r� zMAIL FROM: <user@wherever>z"RCPT TO: <user@destination.domain>r� r� r� r� c r rx r+ r+ r� r+ r/ r � r z9LiveFireExerciseTests.testRelayDelivery.<locals>.<lambda>c r� rx r� r� r� r+ r/ r � r� c s& �� � }� ��fdd�}|�|� |S )Nc sT � � dd tj�d }|�d��� }��|�d�d� �j�� �j �� �� � d S r� ) rp r rq r� r� r� r� � insServerrM � destServer� stopServicer� )r_ �helperrV r+ r/ � delivered� s zLLiveFireExerciseTests.testRelayDelivery.<locals>.finished.<locals>.delivered)� checkStater� )r� r� r� )r_ r� r rV r+ r/ r� � s z9LiveFireExerciseTests.testRelayDelivery.<locals>.finished)-r r� r� r� r re r� r� rY r� r� r� r� r r rT �setDefaultDomainr� r� � SmartHostSMTPRelayingManagerr �fArgs�RelayStateHelperrX rO �mxcalcrE r6 r� r rH r� r� � startServicer� rJ rI �PORTr r r r� r� r� r� )rV �insServr� �destServr� r+ )r0 r_ r� r� r rV r/ �testRelayDelivery� sJ � z'LiveFireExerciseTests.testRelayDelivery)r\ rq rr r � IReactorUDPr �skiprz r� r rs rt r� r� r+ r+ r+ r/ r� i s +r� c @ ru ) �LineBufferMessagec C s g | _ d| _d| _d S )NF)�lines�eom�lostrb r+ r+ r/ r� � r zLineBufferMessage.__init__c C r rx )r� r� )rV r� r+ r+ r/ r� � r{ z LineBufferMessage.lineReceivedc C s d| _ t�d�S )NTz <Whatever>)r� r r: rb r+ r+ r/ r� � z LineBufferMessage.eomReceivedc C s d| _ d S )NT)r� rb r+ r+ r/ r� r� z LineBufferMessage.connectionLostN)r\ rq rr r� r� r� r� r+ r+ r+ r/ r� � s r� c @ sd e Zd Zg d�Zdd� Zeejdkd�dd� �Zdd � Z d d � Z eejdkd�d d � �Z dd� Z dS )� AliasTests�z First linez Next liner� zAfter a blank linez Last linec C sx i }g d�}|D ] }t j�||dd � q| �|d ddg� | �|d dg� | �|d d g� | �|d g d �� d S ) N)zuser: another@host znextuser: |/bin/program zuser: me@again z"moreusers: :/etc/include/filename z3multiuser: first@host, second@host,last@anotherhostr# rn z another@hostzme@again�nextuserz |/bin/program� moreusersz:/etc/include/filename� multiuser)z first@hostz second@hostzlast@anotherhost)r r� �handlerC )rV r� r� �lr+ r+ r/ � testHandle s �zAliasTests.testHandler& r( c C s dt � i}tjj|t�t�d��� �d�}| � t |�d� |d }t |�}dD ] }| � |� |�d� q'| � t |�d� |d }t |�}d D ] }| � |� |�d� qE| � t |�d� |d }t |�}| � |� d �d� d D ]}| � |� |�dd| � ql| � t |�d� d S )Nr� a� # Here's a comment # woop another one testuser: address1,address2, address3, continuation@address, |/bin/process/this usertwo:thisaddress,thataddress, lastaddress lastuser: :/includable, /filename, |/program, address )r� r' �testuser)�address1�address2�address3zcontinuation@addressz/bin/process/thisr� rD �usertwo)� thisaddress� thataddress� lastaddress�lastuserz /includable)z /filename�programr z %s not found)r� r r� � loadAliasFiler� r� �textwrap�dedent�encoderC rD r] r� r� )rV rT r� �group�sr< r+ r+ r/ �testFileLoader" s6 � ��zAliasTests.testFileLoaderc C sD t � t � t � f}tj�|�}| jD ]}|�|� q|�� �| j|�S rx ) r� r r� � MultiWrapperr� r� r� r� �_cbMultiWrapper)rV rK r* �Lr+ r+ r/ �testMultiWrapperQ s zAliasTests.testMultiWrapperc C s6 |D ]}| � |j� | �|j� | �| j|j� qd S rx )rN r� r� r� rC r� )rV r rK r r+ r+ r/ r Y s �zAliasTests._cbMultiWrapperc C sH | � � }tj�|d d �}|�� }| jD ]}|�|� q|�� �| j |�S rx ) r r r� � FileAlias�createMessageReceiverr� r� r� r� �_cbTestFileAlias)rV �tmpfiler< r r� r+ r+ r/ � testFileAlias_ s zAliasTests.testFileAliasc C sL t |�� }|�� }W d � n1 sw Y | �dd� |D �| j� d S )Nc S � g | ]}|d d� �qS �Nr� r+ �r- r r+ r+ r/ r4 l r5 z/AliasTests._cbTestFileAlias.<locals>.<listcomp>�r� � readlinesrC r� )rV r r r� r� r+ r+ r/ r i � � zAliasTests._cbTestFileAliasN) r\ rq rr r� r� r rs rt r r r r r r+ r+ r+ r/ r� s . r� c @ s" e Zd ZdZdd� Zddd�ZdS )� DummyDomainz/ Test domain for L{AddressAliasTests}. c C s || _ d S rx )r )rV r r+ r+ r/ r� t r� zDummyDomain.__init__Nc s |rt j�d��� �fdd�S )a @returns: When a C{memo} is passed in this will raise a L{smtp.SMTPBadRcpt} exception, otherwise a boolean indicating if the C{user} and string version of L{self.address} are equal or not. @rtype: C{bool} �hamc s �t � j�kS rx )r] r r+ r� r+ r/ r � s z$DummyDomain.exists.<locals>.<lambda>)r r r� r� r+ r� r/ r~ w s zDummyDomain.existsrx )r\ rq rr r� r� r~ r+ r+ r+ r/ r o s r c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �AddressAliasTestsz7 Tests for L{twisted.mail.alias.AddressAlias}. c C s: t j�d�| _| jjt| j�i}t j�| j|| j�| _dS )z+ Setup an L{AddressAlias}. zfoo@barN)r r r� r r_ r r� � AddressAlias)rV rT r+ r+ r/ rz � s zAddressAliasTests.setUpc C s | � | j�� � dS )z� L{createMessageReceiever} calls C{exists()} on the domain object which key matches the C{alias} passed to L{AddressAlias}. N)rN r� r rb r+ r+ r/ �test_createMessageReceiver� s z,AddressAliasTests.test_createMessageReceiverc C s | � t| j�d� dS )zP The string presentation of L{AddressAlias} includes the alias. z<Address foo@bar>N)rC r] r� rb r+ r+ r/ rc � rU zAddressAliasTests.test_strc C s | � | j�| jdi�d� dS )z� L{resolve} will look for additional aliases when an C{aliasmap} dictionary is passed, and returns L{None} if none were found. r� N)rC r� �resolver rb r+ r+ r/ � test_resolve� s z AddressAliasTests.test_resolvec C s | � | j�i �d� dS )z� L{resolve} returns L{None} when the alias could not be found in the C{aliasmap} and no L{mail.smtp.User} with this alias exists either. N)rC r� r rb r+ r+ r/ �test_resolveWithoutAliasmap� s z-AddressAliasTests.test_resolveWithoutAliasmapN) r\ rq rr r� rz r rc r r r+ r+ r+ r/ r � s r c @ s e Zd ZdgZdS )� DummyProcess�onEndN)r\ rq rr � __slots__r+ r+ r+ r/ r � s r c @ r� )�MockProcessAliaszD An alias processor that doesn't actually launch processes. c C � dS )z( Don't spawn a process. Nr+ )rV �protor� r� r+ r+ r/ � spawnProcess� r z MockProcessAlias.spawnProcessN)r\ rq rr r� r" r+ r+ r+ r/ r � s r c @ s e Zd ZdZeZdS )�MockAliasGroupz3 An alias group using C{MockProcessAlias}. N)r\ rq rr r� r �processAliasFactoryr+ r+ r+ r/ r# � s r# c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � StubProcessz� Fake implementation of L{IProcessTransport}. @ivar signals: A list of all the signals which have been sent to this fake process. c C s g | _ d S rx )�signalsrb r+ r+ r/ r� � r� zStubProcess.__init__c C r )z8 No-op implementation of disconnection. Nr+ rb r+ r+ r/ �loseConnection� r zStubProcess.loseConnectionc C s | j �|� dS )zL Record a signal sent to this process for later inspection. N)r& r� )rV �signalr+ r+ r/ � signalProcess� s zStubProcess.signalProcessN)r\ rq rr r� r� r' r) r+ r+ r+ r/ r% � s r% c @ s� e Zd ZdZe�ed�du rdZg d�Zdd� Z dd� Z d d � Z d d � Z e ejd kd�dd� �Zdd� Zdd� Zdd� Zdd� Zdd� Ze ejd kd�dd � �Ze ejd kd�d d � �ZdS ) �ProcessAliasTestsz% Tests for alias resolution. Nz IReactorProcess not supportedr� c C sB |d> dB }| � t�|�� | �t�|�|� | �t�|�� |S )a Construct a status from the given exit code. @type code: L{int} between 0 and 255 inclusive. @param code: The exit status which the code will represent. @rtype: L{int} @return: A status integer for the given exit code. � r )rN r� � WIFEXITEDrC � WEXITSTATUSr� � WIFSIGNALED)rV �code�statusr+ r+ r/ � exitStatus� s z ProcessAliasTests.exitStatusc C s: |}| � t�|�� | �t�|�|� | �t�|�� |S )a Construct a status from the given signal. @type signal: L{int} between 0 and 255 inclusive. @param signal: The signal number which the status will represent. @rtype: L{int} @return: A status integer for the given signal. )rN r� r. rC �WTERMSIGr� r, )rV r( r0 r+ r+ r/ � signalStatus� s z ProcessAliasTests.signalStatusc C s t j| _dt _dS )zB Replace L{smtp.DNSNAME} with a well-known value. r� N)r �DNSNAMErb r+ r+ r/ rz s zProcessAliasTests.setUpc C s | j t_ dS )z@ Restore the original value of L{smtp.DNSNAME}. N)r4 r rb r+ r+ r/ r� s zProcessAliasTests.tearDownr& r( c sn t � �� �}|�d� t�|jd� tj�|jdd�}|� � }� j D ]}|� |� q"� fdd�}|� � � |�S )z� Standard call to C{mail.alias.ProcessAlias}: check that the specified script is called, and that the input is correctly transferred to it. zX#!/bin/sh rm -f process.alias.out while read i; do echo $i >> process.alias.out donei� Nc sL t d�� }|�� }W d � n1 sw Y � �dd� |D �� j� d S )Nzprocess.alias.outc S r r r+ r r+ r+ r/ r4 ; r5 zPProcessAliasTests.test_processAlias.<locals>._cbProcessAlias.<locals>.<listcomp>r )r r� r� rb r+ r/ �_cbProcessAlias8 r z<ProcessAliasTests.test_processAlias.<locals>._cbProcessAlias)r r � setContentr� �chmodr� r r� � ProcessAliasr r� r� r� r� )rV �shr< r r� r5 r+ rb r/ �test_processAlias" s � z#ProcessAliasTests.test_processAliasc st t �� }t� �tj�� � � ��� tj�� d|�}|�� }|� |j � � ��fdd�}�� |tjj � |� |� |S )a If the alias child process does not exit within a particular period of time, the L{Deferred} returned by L{MessageWrapper.eomReceived} should fail with L{ProcessAliasTimeout} and send the I{KILL} signal to the child process.. Nc s* �� �jdg� � �t��tj��� d S )N�KILL)rC r& � processEndedr r3 r( �SIGKILLr �r! rV r� r+ r/ �timedOutO s z<ProcessAliasTests.test_processAliasTimeout.<locals>.timedOut)r r; r% r r� �ProcessAliasProtocolr� �MessageWrapperr� r< �completionTimeoutr �ProcessAliasTimeoutr� )rV r �receiverrW r? r+ r> r/ �test_processAliasTimeout? s z*ProcessAliasTests.test_processAliasTimeoutc C sN t � }tj�� }|�|� tj�|dd�}|�t�t d��� | � |� � t �S )z� If the process associated with an L{mail.alias.MessageWrapper} exits before I{eomReceived} is called, the L{Deferred} returned by I{eomReceived} should fail. Nr ) r% r r� r@ r� rA r< r r r r r� )rV r� r rD r+ r+ r/ � test_earlyProcessTerminationY � z.ProcessAliasTests.test_earlyProcessTerminationc C sN t � }tj�� }|�|� tj�|dd�}|�t�t |��� | � |� � t �S )z� Verify that if the process associated with an L{mail.alias.MessageWrapper} exits with the given status, the L{Deferred} returned by I{eomReceived} fails with L{ProcessTerminated}. N) r% r r� r@ r� rA r< r r r r r� )rV r0 r� r rD r+ r+ r/ �_terminationTestf rG z"ProcessAliasTests._terminationTestc C s | � | �d��S )z� If the process associated with an L{mail.alias.MessageWrapper} exits with a non-zero exit code, the L{Deferred} returned by I{eomReceived} should fail. rh )rH r1 rb r+ r+ r/ � test_errorProcessTerminations s z.ProcessAliasTests.test_errorProcessTerminationc C s | � | �tj��S )z� If the process associated with an L{mail.alias.MessageWrapper} exits because it received a signal, the L{Deferred} returned by I{eomReceived} should fail. )rH r3 r( �SIGHUPrb r+ r+ r/ � test_signalProcessTermination{ s z/ProcessAliasTests.test_signalProcessTerminationc C sx i }dt |g d��i}tg d�|d�}tddg|d�}tj�d|d�}|�|||d �� |�|�}tt|j �}|� � tttj�d d d �tj� t � d �tj� d �g�}|� � | �||� |�|�} tt| j �} | � � tttj�dd d �tj�dd d �g�}|� � | �| |� |�|�} tt| j �} | � � tttj�d d d �tj� t � d �tj� d �g�}|� � | �| |� d S )a� Check that the C{resolve} method of alias processors produce the correct set of objects: - direct alias with L{mail.alias.AddressAlias} if a simple input is passed - aliases in a file with L{mail.alias.FileWrapper} if an input in the format '/file' is given - aliases resulting of a process call wrapped by L{mail.alias.MessageWrapper} if the format is '|process' r� )r[ r] r_ )r[ �|echo�/file�alias1r] r_ �alias2�alias3�rN rO rP r[ N�echorM )� TestDomainr# r r� r rO r r� r] �objsrI rA r � FileWrapperrC ) rV r� r_ �A1�A2�A3�res1�r1�expected�res2�r2�res3�r3r+ r+ r/ �test_aliasResolution� s\ �� �� �� ��z&ProcessAliasTests.test_aliasResolutionc C s� i }dt |g �i}tj�d|d�}tj�d|d�}tj�d|d�}|�|||d�� | �|d �|�d� | �|d �|�d� | �|d �|�d� tddg|d�}||d< |�|�}tt |j �}|� � tt tj� t � d �g�} | � � | �|| � dS ) zN Check that a cycle in alias resolution is correctly handled. r� rO rN rP rQ NrL �alias4rR )rS r r� r rO rC r r# r� r] rT rI rA r ) rV r� r_ rV rW rX �A4�res�rr[ r+ r+ r/ �test_cyclicAlias� s" z"ProcessAliasTests.test_cyclicAlias)r\ rq rr r� r �IReactorProcessr r� r� r1 r3 rz r� r rs rt r: rE rF rH rI rK r` re r+ r+ r+ r/ r* � s( @r* c @ r3 )rS c C s || _ || _d S rx )r� �users)rV r� rg r+ r+ r/ r� � r� zTestDomain.__init__Nc sn �j j��| jv r�fdd�S z| j� }W n ty" t����w |�| j|�� � r2� fdd�S t����)Nc s t j�� d d �S rx )r r� r r+ )rn r+ r/ r � s z#TestDomain.exists.<locals>.<lambda>c r rx r+ r+ )r� r+ r/ r � r )r� �localrg r� r� r r� r )rV rn r� r< r+ )r� rn r/ r~ � s � zTestDomain.existsrx )r\ rq rr r� r~ r+ r+ r+ r/ rS � rA rS c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� DummyQueuez� A fake relay queue to use for testing. This queue doesn't keep track of which messages are waiting to be relayed or are in the process of being relayed. @ivar directory: See L{__init__}. c C r� )z� @type directory: L{bytes} @param directory: The pathname of the directory holding messages in the queue. N)� directory)rV rj r+ r+ r/ r� � s zDummyQueue.__init__c C s8 t j�|�}t �| �|�d � t �| �|�d � dS )z� Remove a message from the queue. @type message: L{bytes} @param message: The base filename of a message. r� r� N)r� r� �basenamer� �getPath�rV rj r+ r+ r/ r� s zDummyQueue.donec C s t tj�| j|d �d�S )z� Get the envelope file for a message in the queue. @type message: L{bytes} @param message: The base filename of a message. @rtype: L{file} @return: The envelope file for the message. r� �rb)r� r� r� r7 rj rm r+ r+ r/ �getEnvelopeFile s zDummyQueue.getEnvelopeFilec C s t j�| j|�S )z� Return the full base pathname of a message in the queue. @type message: L{bytes} @param message: The base filename of a message. @rtype: L{bytes} @return: The full base pathname of the message. )r� r� r7 rj rm r+ r+ r/ rl s zDummyQueue.getPathc C sv t � � � dt| �� �}ttj�| j|d �d�}tj�| j|d �}tj�| j|d �}t|d�}|tj�|||�fS )z� Create a new message in the queue. @rtype: 2-L{tuple} of (E{1}) L{file}, (E{2}) L{FileMessage} @return: The envelope file and a message receiver for a new message in the queue. �_r� r� z-Cr� ) �time�idr� r� r� r7 rj r r� )rV �fname� headerFile� tempFilename� finalFilename� messageFiler+ r+ r/ r ( s �zDummyQueue.createNewMessagec C r )z� Ignore the request to mark a message as waiting to be relayed. @type message: L{bytes} @param message: The base filename of a message. Nr+ rm r+ r+ r/ r$ : r� zDummyQueue.setWaitingN) r\ rq rr r� r� r� ro rl r r$ r+ r+ r+ r/ ri � s ri c @ r� )�!DummySmartHostSMTPRelayingManagera4 A fake smart host to use for testing. @type managed: L{dict} of L{bytes} -> L{list} of L{list} of L{bytes} @ivar managed: A mapping of a string identifying a managed relayer to filenames of messages the managed relayer is responsible for. @ivar queue: See L{__init__}. c C s i | _ || _dS )z� Initialize the minimum necessary members of a smart host. @type queue: L{DummyQueue} @param queue: A queue that can be used for testing purposes. N)�managedr )rV r r+ r+ r/ r� P s z*DummySmartHostSMTPRelayingManager.__init__N)r\ rq rr r� r� r+ r+ r+ r/ rx D s rx c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z eejdkd�dd� �Zeejdkd�dd� �Zd d � Zd d � Zd d!� Zd"d#� Zd$S )%�_AttemptManagerTestsa Test the behavior of L{_AttemptManager}. @type tmpdir: L{bytes} @ivar tmpdir: The path to a temporary directory holding the message files. @type reactor: L{MemoryReactorClock} @ivar reactor: The reactor used for test purposes. @type eventLog: L{None} or L{dict} of L{bytes} -> L{object} @ivar eventLog: Information about the last informational log message generated or none if no log message has been generated. @type noisyAttemptMgr: L{_AttemptManager} @ivar noisyAttemptMgr: An attempt manager which generates informational log messages. @type quietAttemptMgr: L{_AttemptManager} @ivar quietAttemptMgr: An attempt manager which does not generate informational log messages. @type noisyMessage: L{bytes} @ivar noisyMessage: The full base pathname of the message to be used with the noisy attempt manager. @type quietMessage: L{bytes} @ivar quietMessage: The full base pathname of the message to be used with the quiet. c C s^ | � � | _t�| j� t� | _d| _t�| j � t t t | j��d| j�| _ t t t | j��d| j�| _d}d}tj�| j|�| _tj�| j|�| _t| jd d��� t| jd d��� |g| j jjd< |g| jjjd < t| jd d ��}t�d d g|� W d � n1 s�w Y t| jd d ��}t�ddg|� W d � dS 1 s�w Y dS )a Set up a temporary directory for the queue, attempt managers with the noisy flag on and off, message files for use with each attempt manager, and a reactor. Also, register to be notified when log messages are generated. NTF� noisyMessage� quietMessager� r� � noisyRelayer� quietRelayerr� r� zfrom-noisy@domainzto-noisy@domainzfrom-quiet@domainzto-quiet@domain)r r� r� r� r! r �eventLogr � addObserver� _logObserverr rx ri �noisyAttemptMgr�quietAttemptMgrr� r7 r{ r| r� r� r ry r� r� )rV � noisyBaseName� quietBaseName�enveloper+ r+ r/ rz { s: � � �"�z_AttemptManagerTests.setUpc C s t �| j� t�| j� dS )zO Unregister for log events and remove the temporary directory. N)r �removeObserverr� r1 r2 r� rb r+ r+ r/ r� � s z _AttemptManagerTests.tearDownc C r� )z� A log observer. @type eventDict: L{dict} of L{bytes} -> L{object} @param eventDict: Information about the last informational log message generated. N)r )rV � eventDictr+ r+ r/ r� � s z!_AttemptManagerTests._logObserverc C s" t tt| j���}| �|j� dS )z� When an attempt manager is created without the noisy parameter, the noisy instance variable should default to true. N)r rx ri r� rN r �rV �amr+ r+ r/ �test_initNoisyDefault� s z*_AttemptManagerTests.test_initNoisyDefaultc C � | � | jj� dS )z� When an attempt manager is created with the noisy parameter set to true, the noisy instance variable should be set to true. N)rN r� r rb r+ r+ r/ �test_initNoisy� � z#_AttemptManagerTests.test_initNoisyc C r� )z� When an attempt manager is created with the noisy parameter set to false, the noisy instance variable should be set to false. N)r� r� r rb r+ r+ r/ �test_initQuiet� r� z#_AttemptManagerTests.test_initQuietc C s$ t tt| j���}| �|jt� dS )z� When an attempt manager is created without the reactor parameter, the reactor instance variable should default to the global reactor. N)r rx ri r� rC r r� r+ r+ r/ �test_initReactorDefault� s z,_AttemptManagerTests.test_initReactorDefaultc C s | � | jj| j� dS )z� When an attempt manager is created with a reactor provided, the reactor instance variable should default to that reactor. N)rC r� r rb r+ r+ r/ �test_initReactor� s z%_AttemptManagerTests.test_initReactorc C � | j �d| j� | �| j� dS )zw For an attempt manager with the noisy flag set, notifySuccess should result in a log message. r} N)r� r r{ rN r rb r+ r+ r/ �test_notifySuccessNoisy� � z,_AttemptManagerTests.test_notifySuccessNoisyc C r� )z| For an attempt manager with the noisy flag not set, notifySuccess should result in no log message. r~ N)r� r r| r� r rb r+ r+ r/ �test_notifySuccessQuiet� r� z,_AttemptManagerTests.test_notifySuccessQuietr& r( c C r� )zw For an attempt manager with the noisy flag set, notifyFailure should result in a log message. r} N)r� r r{ rN r rb r+ r+ r/ �test_notifyFailureNoisy� � z,_AttemptManagerTests.test_notifyFailureNoisyc C r� )z| For an attempt manager with the noisy flag not set, notifyFailure should result in no log message. r~ N)r� r r| r� r rb r+ r+ r/ �test_notifyFailureQuiet� r� z,_AttemptManagerTests.test_notifyFailureQuietc C � | j �d� | �| j� dS )zt For an attempt manager with the noisy flag set, notifyDone should result in a log message. r} N)r� r rN r rb r+ r+ r/ �test_notifyDoneNoisy � z)_AttemptManagerTests.test_notifyDoneNoisyc C r� )zy For an attempt manager with the noisy flag not set, notifyDone should result in no log message. r~ N)r� r r� r rb r+ r+ r/ �test_notifyDoneQuiet r� z)_AttemptManagerTests.test_notifyDoneQuietc C �( | j �d� | �| j� | j�d� dS )z| For an attempt manager with the noisy flag set, notifyNoConnection should result in a log message. r} r7 N)r� �notifyNoConnectionrN r r r< rb r+ r+ r/ � test_notifyNoConnectionNoisy � z1_AttemptManagerTests.test_notifyNoConnectionNoisyc C r� )z� For an attempt manager with the noisy flag not set, notifyNoConnection should result in no log message. r~ r7 N)r� r� r� r r r< rb r+ r+ r/ � test_notifyNoConnectionQuiet r� z1_AttemptManagerTests.test_notifyNoConnectionQuietN)r\ rq rr r� rz r� r� r� r� r� r� r� r� r� r rs rt r� r� r� r� r� r� r+ r+ r+ r/ rz [ s( - rz )}r� � email.messager� � email.parserr� r� r� r� r1 r( rs r+ r� rq �hashlibr �unittestr �zope.interfacer r �zope.interface.verifyr �twisted.cred.checkersr� �twisted.cred.credentials�twisted.cred.portal�twisted.mail.alias�twisted.mail.mail�twisted.mail.maildir�twisted.mail.protocols�twisted.mail.relay�twisted.mail.relaymanagerr r �twisted.internetr r r r r r �twisted.internet.deferr �twisted.internet.errorr r r r � twisted.mailr r r � twisted.namesr �twisted.names.dnsr r r �twisted.names.errorr �twisted.pythonr r �twisted.python.filepathr �twisted.python.runtimer �twisted.test.proto_helpersr r! r" �twisted.trial.unittestr# r% rv r� r� r� r� r� � _MaildirMailboxAppendMessageTaskr� r� r r* r/ rQ rV rR r� r� r� r� r� r� r� r� r r r0 r1 r2 r5 r4 rQ rV rW r� r� r� r r r r� r8 r � AliasGroupr# r% r* rS ri rx rz r+ r+ r+ r/ �<module> s� h & 0 M � S ( X s # NI %) D 2 d ) Q PK Mb�ZK�7� � 2 mail/test/__pycache__/test_options.cpython-310.pycnu �[��� o �b � @ sz d Z ddlmZmZ ddlmZ ddlmZmZ ddl m Z ddl m Z G dd� de �Z G d d � d �ZG d d � d e �Zd S )z Tests for L{twisted.mail.tap}. � )�defer� endpoints)� protocols)�Options� makeService)� UsageError)�TestCasec @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )� OptionsTestszK Tests for the command line option parser used for I{twistd mail}. c C sF | � � | _t| jd��}|�d� W d � d S 1 s w Y d S )N�wzsomeuser: differentuser )�mktemp� aliasFilename�open�write)�self� aliasFile� r �@/usr/lib/python3/dist-packages/twisted/mail/test/test_options.py�setUp s "�zOptionsTests.setUpc C s | � tt� jd| jg� dS )zi Test that adding an aliases(5) file before adding a domain raises a UsageError. � --aliasesN)� assertRaisesr r � parseOptionsr �r r r r �testAliasesWithoutDomain s �z%OptionsTests.testAliasesWithoutDomainc C s t � �ddd| jg� dS )z� Test that adding an aliases(5) file to an IAliasableDomain at least doesn't raise an unhandled exception. z--maildirdbmdomainzexample.com=example.comr N)r r r r r r r � testAliases" s ��zOptionsTests.testAliasesc C sF t � }|�d| dg� | �t|| �d� | �|| d tj� dS )z� Use L{Options} to parse a single service configuration parameter and verify that an endpoint of the correct type is added to the list for that service. z--ztcp:1234� r N�r r � assertEqual�len�assertIsInstancer �TCP4ServerEndpoint)r �service�optionsr r r � _endpointTest0 s zOptionsTests._endpointTestc C � | � d� dS )z� When I{--smtp} is given a TCP endpoint description as an argument, a TCPServerEndpoint is added to the list of SMTP endpoints. �smtpN�r" r r r r �test_endpointSMTP; � z OptionsTests.test_endpointSMTPc C r# )z� When I{--pop3} is given a TCP endpoint description as an argument, a TCPServerEndpoint is added to the list of POP3 endpoints. �pop3Nr% r r r r �test_endpointPOP3B r' z OptionsTests.test_endpointPOP3c C sh t � }|�g � | �t|d �d� | �|d d tj� | �t|d �d� | �|d d tj� dS )zO POP3 and SMTP each listen on a TCP4ServerEndpoint by default. r( r r r$ Nr �r r! r r r �test_protoDefaultsI s z OptionsTests.test_protoDefaultsc C sx t � }|�dg� | �|�dd�g � | �|�dd�g � t � }|�dg� | �|�dd�g � | �|�dd�g � dS )zg The I{--no-pop3} and I{--no-smtp} options disable POP3 and SMTP respectively. � --no-pop3Nr( r$ � --no-smtp)r r r � _getEndpoints�assertNotEqualr* r r r �test_protoDisableV s z OptionsTests.test_protoDisablec C s t � }| �t|jddg� dS )zI If all protocols are disabled, L{UsageError} is raised. r, r- N)r r r r r* r r r �test_allProtosDisabledErrore s �z(OptionsTests.test_allProtosDisabledErrorc C s, t � }| �t|jdg�}| �dt|�� dS )zu If I{--esmtp} is given without I{--hostname}, L{Options.parseOptions} raises L{UsageError}. z--esmtpz--esmtp requires --hostnameN)r r r r r �str)r r! �excr r r �test_esmtpWithoutHostnamen s z&OptionsTests.test_esmtpWithoutHostnamec C sb t � }|�ddg� | �t|d �d� |d d }|j}|jjj}|D ] }| �||| � q$dS )zC Tests that the --auth option registers a checker. z--authz memory:admin:admin:bob:password� credCheckersr r N)r r r r �credentialInterfacesr � smtpPortal�checkers)r r! �checker� interfaces�registered_checkers�ifacer r r � test_authw s �zOptionsTests.test_authN)�__name__� __module__� __qualname__�__doc__r r r r" r& r) r+ r0 r1 r4 r= r r r r r s r c @ s e Zd ZdZdZdd� ZdS )� SpyEndpointzG SpyEndpoint remembers what factory it is told to listen with. Nc C s || _ t�d �S )N)� listeningWithr �succeed)r �factoryr r r �listen� s zSpyEndpoint.listen)r> r? r@ rA rC rF r r r r rB � s rB c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �MakeServiceTestsz3 Tests for L{twisted.mail.tap.makeService} c C sb t � }t � }t� }||g||< t|�}|�� |�� | �|j� | �|j|� | �|j|� dS )z� Configure a service with two endpoints for the protocol associated with C{key} and verify that when the service is started a factory of type C{factoryClass} is used to listen on each of them. N) rB r r �privilegedStartService� startService� addCleanup� stopServicer rC )r �key� factoryClass� cleartext�secure�configr r r r �_endpointServerTest� s z$MakeServiceTests._endpointServerTestc C � | � dtj� dS )z� If one or more endpoints is included in the configuration passed to L{makeService} for the C{"pop3"} key, a service for starting a POP3 server is constructed for each of them and attached to the returned service. r( N)rQ r � POP3Factoryr r r r � test_pop3� � zMakeServiceTests.test_pop3c C rR )z� If one or more endpoints is included in the configuration passed to L{makeService} for the C{"smtp"} key, a service for starting an SMTP server is constructed for each of them and attached to the returned service. r$ N)rQ r � SMTPFactoryr r r r � test_smtp� rU zMakeServiceTests.test_smtpN)r> r? r@ rA rQ rT rW r r r r rG � s rG N)rA �twisted.internetr r � twisted.mailr �twisted.mail.tapr r �twisted.python.usager �twisted.trial.unittestr r rB rG r r r r �<module> s v PK Mb�Zp���� � . mail/test/__pycache__/__init__.cpython-310.pycnu �[��� o �b � @ s d Z dS )zTests for twistd.mailN)�__doc__� r r �</usr/lib/python3/dist-packages/twisted/mail/test/__init__.py�<module> s PK Mb�Z��M5�� �� / mail/test/__pycache__/test_smtp.cpython-310.pycnu �[��� o �b�� � @ s U d Z ddlZddlZddlZddlmZ ddlmZmZm Z m Z m Z ddl m Z mZ ddlZddlZddlZddlZddlmZ ddlmZmZ ddlmZ dd lmZ dd lmZmZ dd lm Z m Z m Z m Z m Z m!Z!m"Z" dd l#m$Z$ dd l%m&Z& ddl'm(Z(m)Z) ddl*m+Z+ ddl,m-Z-m.Z. ddl/m0Z0 e e1 e2d< z ddl3m4Z4m5Z5 W n e6y� dZ7Y nw dZ7e j8�9e!�s�dZ7dd� Z:ee$j;�G dd� d��Z<G dd� d�Z=G d d � d �Z>d Z?G d d � d �Z@G d!d"� d"e@e$jA�ZBG d#d$� d$e@e$jC�ZDG d%d&� d&�ZEG d'd(� d(e(jF�ZGG d)d*� d*e0eE�ZHG d+d,� d,�ZIG d-d.� d.�ZJG d/d0� d0eJe$jK�ZLG d1d2� d2eJe$jM�ZNG d3d4� d4�ZOG d5d6� d6eOe0�ZPG d7d8� d8eOe0�ZQeejRj�G d9d:� d:��ZSee$jT�G d;d<� d<��ZUG d=d>� d>�ZVG d?d@� d@e0eE�ZWG dAdB� dBe0�ZXG dCdD� dDeD�ZYG dEdF� dFe0eE�ZZG dGdH� dHe0�Z[G dIdJ� dJe0eE�Z\G dKdL� dLe j]�Z^G dMdN� dNe0�Z_G dOdP� dPe0�Z`ee�G dQdR� dR��ZaG dSdT� dT�ZbG dUdV� dVe0�ZcG dWdX� dXe0�ZdG dYdZ� dZe0�ZeG d[d\� d\e0�ZfG d]d^� d^e0�ZgG d_d`� d`e0�ZhG dadb� dbe.�ZiG dcdd� dde0�ZjdS )ez* Test cases for twisted.mail.smtp module. � N)�BytesIO)�Any�List�Optional�Tuple�Type)�directlyProvides� implementer)�cred)�AllowAnonymousAccess�ICredentialsChecker)� IAnonymous)�UnauthorizedLogin)�IRealm�Portal)�address�defer�error� interfaces�protocol�reactor�task)�smtp)�LOGINCredentials)�basic�loopback)�LineLog)� MemoryReactor�StringTransport)�TestCase�sslSkip)�ClientTLSContext�ServerTLSContextzOpenSSL not presentzReactor doesn't support SSLc O � d S �N� )�spam�eggsr% r% �=/usr/lib/python3/dist-packages/twisted/mail/test/test_smtp.py� spameater/ � r) c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � BrokenMessagez� L{BrokenMessage} is an L{IMessage} which raises an unexpected exception from its C{eomReceived} method. This is useful for creating a server which can be used to test client retry behavior. c C r# r$ r% ��self�userr% r% r( �__init__; r* zBrokenMessage.__init__c C r# r$ r% �r. �liner% r% r( � lineReceived> r* zBrokenMessage.lineReceivedc C � t d��)Nz"Some problem, delivery is failing.)� RuntimeError�r. r% r% r( � eomReceivedA � zBrokenMessage.eomReceivedc C r# r$ r% r6 r% r% r( �connectionLostD r* z BrokenMessage.connectionLostN)�__name__� __module__� __qualname__�__doc__r0 r3 r7 r9 r% r% r% r( r, 3 s r, c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) � DummyMessagez� L{BrokenMessage} is an L{IMessage} which saves the message delivered to it to its domain object. @ivar domain: A L{DummyDomain} which will be used to store the message once it is received. c C � || _ || _g | _d S r$ )�domainr/ �buffer)r. rA r/ r% r% r( r0 Q � zDummyMessage.__init__c C s t �d|�s| j�|� d S d S )Ns/ Received: From yyy.com \(\[.*\]\) by localhost;)�re�matchrB �appendr1 r% r% r( r3 V s �zDummyMessage.lineReceivedc C s> d� | j�d }| jj| jjj �|� t� � }|� d� |S )N� � saved) �joinrB rA �messagesr/ �dest�localrF r �Deferred�callback)r. �message�deferredr% r% r( r7 [ s zDummyMessage.eomReceivedN)r: r; r< r= r0 r3 r7 r% r% r% r( r? H s r? c @ � e Zd ZdZdd� Zdd� ZdS )� DummyDomainzf L{DummyDomain} is an L{IDomain} which keeps track of messages delivered to it in memory. c C s i | _ |D ]}g | j |< qd S r$ )rJ )r. �names�namer% r% r( r0 i s �zDummyDomain.__init__c s2 �j j� jv rt�� �fdd��S t�t����S )Nc s t � ��S r$ �r? r% r- r% r( �<lambda>p � z$DummyDomain.exists.<locals>.<lambda>)rK rL rJ r �succeed�failr � SMTPBadRcptr- r% r- r( �existsn s zDummyDomain.existsN)r: r; r< r= r0 r[ r% r% r% r( rR c s rR s Subject: hello Goodbye c @ s> e Zd Zddd�Zdd� Zdd� Zdd � Zd d � Zd d � ZdS )�MyClientNc C s: |d u r ddgt t�f}|d | _|d | _|d | _d S )Nzmoshez@foo.barr � � )r �mail�_sender� _recipient�_data�r. � messageInfor% r% r( r0 | s zMyClient.__init__c C � | j S r$ )r` r6 r% r% r( � getMailFrom� � zMyClient.getMailFromc C re r$ )ra r6 r% r% r( � getMailTo� rg zMyClient.getMailToc C re r$ )rb r6 r% r% r( � getMailData� rg zMyClient.getMailDatac C � || _ d S r$ )�_error)r. �excr% r% r( � sendError� � zMyClient.sendErrorc C s d | _ d | _d | _d S r$ )r` ra rb )r. �code�resp�numOk� addresses�logr% r% r( �sentMail� s zMyClient.sentMailr$ ) r: r; r< r0 rf rh ri rm rt r% r% r% r( r\ { s r\ c @ s e Zd Zddd�ZdS )� MySMTPClientNc C s t j�| d� t�| |� d S �Ns foo.baz)r � SMTPClientr0 r\ rc r% r% r( r0 � s zMySMTPClient.__init__r$ �r: r; r< r0 r% r% r% r( ru � � ru c @ s e Zd Zddd�ZdS )� MyESMTPClient� Nc C s t j�| ||d� t�| � d S rv )r � ESMTPClientr0 r\ )r. �secret�contextFactoryr% r% r( r0 � s zMyESMTPClient.__init__)r{ Nrx r% r% r% r( rz � ry rz c @ � e Zd Zdd� ZdS )� LoopbackMixinc C s t �||�S r$ )r � loopbackTCP)r. �server�clientr% r% r( r � � zLoopbackMixin.loopbackN)r: r; r< r r% r% r% r( r� � � r� c @ s$ e Zd Zg d�Zdd� Zdd� ZdS )�FakeSMTPServer)� 220 hellos 250 nice to meet you� 250 greatr� s 354 go on, ladc C s4 g | _ | jd d � | _| j�� | �| j�� � d S r$ )rB � clientData�reverse�sendLine�popr6 r% r% r( �connectionMade� s z FakeSMTPServer.connectionMadec C sr | j �|� |dkr| j�d� | j�� n|dkr!| j�d� n |dkr*| j�� | jr7| �| j�� � d S d S )Ns QUITs 221 see ya around � .s 250 gotcha � RSET)rB rF � transport�write�loseConnectionr� r� r� r1 r% r% r( r3 � s �zFakeSMTPServer.lineReceivedN)r: r; r< r� r� r3 r% r% r% r( r� � s r� c @ sH e Zd ZdZdd� Zg d�Zdd� Zdd� Zd d � Zd d � Z d d� Z dS )�SMTPClientTestsz' Tests for L{smtp.SMTPClient}. c C sj g }t � }|j|_|�t� � |�d� |�� | �|d tj � | � |d j � | � t |d �d� dS )z� L{smtp.SMTPClient.timeoutConnection} calls the C{sendError} hook with a fatal L{SMTPTimeoutError} with the current line log. r� r sH Timeout waiting for SMTP server response <<< 220 hello >>> HELO foo.baz N)ru rF rm �makeConnectionr r3 �timeoutConnection�assertIsInstancer �SMTPTimeoutError� assertTrue�isFatal� assertEqual�bytes)r. �errorsr� r% r% r( �test_timeoutConnection� s �z&SMTPClientTests.test_timeoutConnection) s HELO foo.bazs MAIL FROM:<moshez@foo.bar>s RCPT TO:<moshez@foo.bar>s DATAs Subject: hellor{ s Goodbyer� r� c s0 t � }t� �� ��|�}|�� �fdd�� |S )z� L{smtp.SMTPClient} sends I{HELO}, I{MAIL FROM}, I{RCPT TO}, and I{DATA} commands based on the return values of its C{getMailFrom}, C{getMailTo}, and C{getMailData} methods. c s � � �j� j�S r$ )r� rB �expected_output��x�r. r� r% r( rV � s z/SMTPClientTests.test_messages.<locals>.<lambda>)ru r� r � addCallback)r. r� �dr% r� r( � test_messages� s z SMTPClientTests.test_messagesc C sd t ddgtd�f�}t� }|�|� |�d� | �|jd� | �|j� |j� � | � |j t � dS )z� If there is an error while producing the message body to the connection, the C{sendError} callback is invoked. zalice@example.comzbob@example.com� foo�( 220 Ok 250 Ok 250 Ok 250 Ok 354 Ok N) ru r r r� � dataReceived�assertNotIdentical�producer� assertFalse� streaming� stopProducingr� rk � Exception�r. r� r� r% r% r( �test_transferError� s � � z"SMTPClientTests.test_transferErrorc C �P t �d�}t� }|�|� |�t jdddd�� | �|�� d� | �|j � dS )z� If L{smtp.SMTPClient.sendError} is called with an L{SMTPClientError} which is fatal, it disconnects its transport without writing anything more to it. N�{ �fooT�r� r{ ) r rw r r� rm �SMTPClientErrorr� �valuer� � disconnectingr� r% r% r( �test_sendFatalError � z#SMTPClientTests.test_sendFatalErrorc C r� )z� If L{smtp.SMTPClient.sendError} is called with an L{SMTPClientError} which is not fatal, it sends C{"QUIT"} and waits for the server to close the connection. Nr� r� Fr� � QUIT ) r rw r r� rm r� r� r� r� r� r� r% r% r( �test_sendNonFatalError r� z&SMTPClientTests.test_sendNonFatalErrorc C sH t �d�}t� }|�|� |�td�� | �|�� d� | �|j � dS )z� If L{smtp.SMTPClient.sendError} is called with an exception which is not an L{SMTPClientError}, it disconnects its transport without writing anything more to it. Nr� r{ ) r rw r r� rm r� r� r� r� r� r� r% r% r( �test_sendOtherError, s z#SMTPClientTests.test_sendOtherErrorN) r: r; r< r= r� r� r� r� r� r� r� r% r% r% r( r� � s r� c @ �$ e Zd Zdd� Zdd� Zdd� ZdS )�DummySMTPMessagec C r@ r$ )r �usersrB )r. r r� r% r% r( r0 ; rC zDummySMTPMessage.__init__c C s | j �|� d S r$ )rB rF r1 r% r% r( r3 @ s z DummySMTPMessage.lineReceivedc C sr d� | j�d }| jd jd t| jd j�}}g }| jD ] }|�t|�� q ||||f| jjt |�< t � d�S )NrG r rH ) rI rB r� �helor� �origrF r rO �tupler rX )r. rO r� �origin� recipientsr/ r% r% r( r7 C s " z DummySMTPMessage.eomReceivedN)r: r; r< r0 r3 r7 r% r% r% r( r� : s r� c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) � DummyProtoc C s | j �| � i | _d S r$ )�dummyMixinBaser� rO r6 r% r% r( r� N s zDummyProto.connectionMadec G r# r$ r% )r& r% r% r( �receivedHeaderR r* zDummyProto.receivedHeaderc s t d �� _� �fdd�S )Nc s t � �g�S r$ )r� r% r- r% r( rV W � z'DummyProto.validateTo.<locals>.<lambda>)�SimpleDelivery�deliveryr- r% r- r( � validateToU s zDummyProto.validateToc C � |S r$ r% �r. r� r� r% r% r( � validateFromY r* zDummyProto.validateFromN)r: r; r< r� r� r� r� r% r% r% r( r� M s r� c @ � e Zd ZejZdS )� DummySMTPN)r: r; r< r �SMTPr� r% r% r% r( r� ] � r� c @ r� )� DummyESMTPN)r: r; r< r �ESMTPr� r% r% r% r( r� a r� r� c @ s e Zd ZU dZeeej ed< dZ eee j ed< dddgddgdfddd d gdd d gd fdd d gddgdfgZ g d�Z eeeeeef ed< e D ]6\ZZZZZZe �de d dddf� eD ]Ze �de d dddf� qce �ddedeeeefff� qLdd� ZdS )�AnotherTestCaseN� serverClass� clientClass� foo.coms moshez@foo.coms moshez@bar.coms( From: Moshe To: Moshe Hi, how are you? s tttt@rrr.coms uuu@ooos yyy@eees Subject: pass ..rrrr.. s @this,@is,@ignored:foo@bar.coms @ignore,@this,@too:bar@foo.coms foo@bar.coms bar@foo.coms Subject: apa To: foo 123 . 456 ))r{ s 220.* $NN)s HELO foo.com � 250.* $NN)s RSET r� NN�datas MAIL FROM:<s > s 250.* s RCPT TO:<s DATA s 354.* c C sF t � }| �� }G dd� d�}|� |_|�|� | jD ]�\}}}}|r'|�|� |�� }|�� t� ||�s;t |||��|dd� dkr�|� � D ]} | rW| dd� dkrWd| } |�| d � qG|�d � |�� }|�� |\} } t� | |�s{t | |��| d D ]} t | dd� �} | g| d < | � |j| f t| �� qq|�d� dS ) a Exercise a lot of the SMTP client code. This is a "shotgun" style unit test. It does a lot of things and hopes that something will go really wrong if it is going to go wrong. This test should be replaced with a suite of nicer tests. c @ s e Zd ZdZdS )z/AnotherTestCase.test_buffer.<locals>.fooFactoryr� N)r: r; r< rA r% r% r% r( � fooFactory� s r� N� s 354r r] r� � s . r^ )r r� �factoryr� r� r� r� �clearrD rE �AssertionError� splitlines�listr� rO r� � setTimeout)r. r� �ar� �send�expect�msg� msgexpectr� r2 rp �msgdata�recip�expectedr% r% r( � test_buffer� s: �zAnotherTestCase.test_buffer)r: r; r< r� r r r �Protocol�__annotations__r� r rw rJ r� r r r� r �helo_�from_�to_�realfrom�realtor� rF �rcptr� r% r% r% r( r� e sL �� �� , �� r� c @ � e Zd ZeZeZdS )�AnotherESMTPTestsN)r: r; r< r� r� rz r� r% r% r% r( r� � � r� c @ r� )�AnotherSMTPTestsN)r: r; r< r� r� ru r� r% r% r% r( r� � r� r� c @ s4 e Zd ZddiZejjejjfZdd� Z dd� Z dS )� DummyChecker� testuser� testpasswordc C s" t �|j| j|j ��| j|j�S r$ )r � maybeDeferred� checkPasswordr� �usernamer� �_cbCheck�r. � credentialsr% r% r( �requestAvatarId� s � �z DummyChecker.requestAvatarIdc C s |r|S t j�� �r$ )r r r )r. �resultr� r% r% r( r� � s zDummyChecker._cbCheckN) r: r; r< r� r r �IUsernamePassword�IUsernameHashedPassword�credentialInterfacesr r� r% r% r% r( r� � s � r� c @ r+ ) r� z[ L{SimpleDelivery} is a message delivery factory with no interesting behavior. c C rj r$ ��_messageFactory)r. �messageFactoryr% r% r( r0 � rn zSimpleDelivery.__init__c C r# r$ r% �r. r� r� r� r% r% r( r� � r* z SimpleDelivery.receivedHeaderc C r� r$ r% r� r% r% r( r� � r* zSimpleDelivery.validateFromc s � �fdd�S )Nc s � � ��S r$ r r% r- r% r( rV rW z+SimpleDelivery.validateTo.<locals>.<lambda>r% r- r% r- r( r� s zSimpleDelivery.validateToN)r: r; r< r= r0 r� r� r� r% r% r% r( r� � s r� c @ r )� DummyRealmc G s t jtd �dd� fS )Nc S r# r$ r% r% r% r% r( rV � z*DummyRealm.requestAvatar.<locals>.<lambda>)r �IMessageDeliveryr� )r. �avatarId�mindr r% r% r( � requestAvatar � zDummyRealm.requestAvatarN)r: r; r< r r% r% r% r( r r� r c @ r� )� AuthTestsc st t � }tj�|�}|�t� � tdtjji��|�_t d�}t � d�}|� |� � � �|�}|�� �fdd�� |S )z� L{ESMTPClient} can authenticate using the I{CRAM-MD5} SASL mechanism. @see: U{http://tools.ietf.org/html/rfc2195} s CRAM-MD5r� r� c s � � �jd�S )Nr] )r� � authenticatedr� r� r% r( rV s z,AuthTests.test_crammd5Auth.<locals>.<lambda>)r r �portalr �registerCheckerr� r� r �CramMD5Credentialsrz r �CramMD5ClientAuthenticator�registerAuthenticatorr r� �r. �realm�pr� �cAuthr� r% r� r( �test_crammd5Auth s zAuthTests.test_crammd5Authc sp t � }tj�|�}|�t� � tdti��|�_td�}t � d�}|� |� � � �|�}|� � �fdd�� |S )z� L{ESMTPClient} can authenticate using the I{LOGIN} SASL mechanism. @see: U{http://sepp.oetiker.ch/sasl-2.1.19-ds/draft-murchison-sasl-login-00.txt} � LOGINr� r� c � � � �j�S r$ �r� r r� r� r% r( rV 1 r� z*AuthTests.test_loginAuth.<locals>.<lambda>)r r r r r r� r� r rz r �LOGINAuthenticatorr r r� r r% r� r( �test_loginAuth s zAuthTests.test_loginAuthc sr t � }tj�|�}|�t� � tdtji��|�_t d�}t� d�}|� |� � � �|�}|� � �fdd�� |S )a When communicating with a server which implements the I{LOGIN} SASL mechanism using C{"Username:"} as the challenge (rather than C{"User Name\0"}), L{ESMTPClient} can still authenticate successfully using the I{LOGIN} mechanism. r r� r� c r r$ r r� r� r% r( rV G r� z8AuthTests.test_loginAgainstWeirdServer.<locals>.<lambda>)r r r r r r� r� r r rz r r r r� r r% r� r( � test_loginAgainstWeirdServer4 s z&AuthTests.test_loginAgainstWeirdServerN)r: r; r< r r! r" r% r% r% r( r s r c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd S )�SMTPHelperTestsc C s6 i }t d�D ]}t�d�}| �||v � d ||< qd S )Ni� �testcase)�ranger � messageidr� )r. r� �i�mr% r% r( � testMessageIDL s �z SMTPHelperTests.testMessageIDc C sR ddgddgt �d�dgddgt �d�dgg}|D ] \}}| �t �|�|� qd S )Ns user@host.names <user@host.name>s "User Name" <user@host.name>s someguy@someplaces <someguy@someplace>r{ s <>)r �Addressr� � quoteaddr)r. �cases�c�er% r% r( � testQuoteAddrS s � �z SMTPHelperTests.testQuoteAddrc C s$ t �ddd d �}| �t|�d� d S )Ns user@hosts helo.host.namez user@host)r �Userr� �str)r. �ur% r% r( �testUser_ s zSMTPHelperTests.testUserc C sr g d�}|D ]0\}}| � t�|�|t|�f� | � |�d�|� | � t�|�|t|�f� | � |�d�|� qd S )N))� Hello worlds Hello+20world)z Hello+worlds Hello+2Bworld)z s +00+01+02+03+04+05)ze=mc2@example.coms e+3Dmc2@example.com�xtext)r� r � xtext_encode�len�encode� xtext_decode�decode)r. r, �caser� r% r% r( �testXtextEncodingc s �z!SMTPHelperTests.testXtextEncodingc C �D d}| � t�|d�|�d�t|�f� | � |�dd�|�d�� dS )z� Specifying an error policy to C{unicode.encode} with the I{xtext} codec should produce the same result as not specifying the error policy. r4 �strictr5 N)r� r r6 r8 r7 )r. �textr% r% r( �test_encodeWithErrorsq s � z%SMTPHelperTests.test_encodeWithErrorsc C r= )zO Similar to L{test_encodeWithErrors}, but for C{bytes.decode}. s Hello worldr> r5 N)r� r r9 r: r7 )r. r� r% r% r( �test_decodeWithErrors} s � z%SMTPHelperTests.test_decodeWithErrorsN) r: r; r< r) r/ r3 r< r@ rA r% r% r% r( r# K s r# c @ � e Zd ZdZdd� ZdS )�NoticeTLSClientFc C s t �| ||� d| _d S �NT)rz �esmtpState_starttls�tls)r. ro rp r% r% r( rE � s z#NoticeTLSClient.esmtpState_starttlsN)r: r; r< rF rE r% r% r% r( rC � � rC c @ s e Zd ZeZdd� ZdS )�TLSTestsc sB t � }t� }t|d�� t|d��� ��fdd�}���� ��|�S )N)r~ c s �� � jd� �� �jd� d S rD )r� rF � startedTLS��ignored�r� r. r� r% r( �check� s z TLSTests.testTLS.<locals>.check)r! r" rC r� r r� )r. � clientCTX� serverCTXrM r% rL r( �testTLS� s zTLSTests.testTLSN)r: r; r< r �skiprP r% r% r% r( rH � rG rH c @ r )�EmptyLineTestsc C sp t �� }t� }|�|� |�d� |�d� |�� �� }| �t |�d� | � |d � d�� | �|d d� dS )z� If L{smtp.SMTP} receives an empty line, it responds with a 500 error response code and a message about a syntax error. r{ Nr^ r s 220r] s 500 Error: bad syntax) r r� r r� r3 r� r� r� r� r7 r� � startswith)r. �protor� �outr% r% r( �test_emptyLineSyntaxError� s z(EmptyLineTests.test_emptyLineSyntaxErrorN)r: r; r< rV r% r% r% r( rR � r� rR c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� TimeoutTestszE Check that SMTP client factories correctly use the timeout. c st t �� � |�t�ddd��}� j|_t� }|�|� ||_� �fdd�}�� |t j �� |�}� � d� � � d� |S )zR Connect the clientFactory, and check the timeout on the request. �TCP� example.net� c s �� � �� d� d S )N� �?)r� �seconds)�ign��clockr. r% r( rM � r z(TimeoutTests._timeoutTest.<locals>.checkg�������?g�������?)r �Clock� buildProtocolr � IPv4Address� callLaterr r� r � assertFailurer r� r� �advance)r. �onDone� clientFactoryr� �trM r� r% r^ r( � _timeoutTest� s � zTimeoutTests._timeoutTestc C �. t �� }tjddtd�|ddd�}| �||�S )z� Test timeout for L{smtp.SMTPSenderFactory}: the response L{Deferred} should be errback with a L{smtp.SMTPTimeoutError}. �source@addresss recipient@address� Message bodyr r[ ��retries�timeout�r rM r �SMTPSenderFactoryr ri �r. rf rg r% r% r( � test_SMTPClientRecipientBytes� s � z*TimeoutTests.test_SMTPClientRecipientBytesc C rj )z- Use a L{unicode} recipient. rk �recipient@addressrl r r[ rm rp rr r% r% r( � test_SMTPClientRecipientUnicode� � � z,TimeoutTests.test_SMTPClientRecipientUnicodec C rj )z. Use a L{list} of recipients. rk )zrecipient1@addresss recipient2@addressrl r r[ rm rp rr r% r% r( � test_SMTPClientRecipientList� rv z)TimeoutTests.test_SMTPClientRecipientListc C s2 t �� }tjddddtd�|ddd�}| �||�S ) z� Test timeout for L{smtp.ESMTPSenderFactory}: the response L{Deferred} should be errback with a L{smtp.SMTPTimeoutError}. r� �passwordrk rt rl r r[ rm )r rM r �ESMTPSenderFactoryr ri rr r% r% r( �test_ESMTPClient� s � z TimeoutTests.test_ESMTPClientc C s G dd� d�}g }t �� }|�|j� tjdd|d�|ddd�}d |_t�� }|� t � d d d ��}|j |_ t � }|�|� |�d � | �|jd� | �|j� |�d� | �|g � |j�� |�d� | �|g � |j�� |�d� | �|g � | �|�� d� dS )z� The timeout is not allowed to expire after the server has accepted a DATA command and the client is actively sending data to it. c @ s" e Zd ZdZdd� Zddd�ZdS )z<TimeoutTests.test_resetTimeoutWhileSending.<locals>.SlowFilez� A file-like which returns one byte from each read call until the specified number of bytes have been returned. c S rj r$ ��_size)r. �sizer% r% r( r0 rn zETimeoutTests.test_resetTimeoutWhileSending.<locals>.SlowFile.__init__Nc S s | j r | j d8 _ dS dS )Nr] � xr{ r{ )r. �maxr% r% r( �read s zATimeoutTests.test_resetTimeoutWhileSending.<locals>.SlowFile.readr$ )r: r; r< r= r0 r� r% r% r% r( �SlowFile s r� rk rt r] r r� rm � example.orgrX rY rZ r� Nr^ s 250 Ok s] HELO example.org MAIL FROM:<source@address> RCPT TO:<recipient@address> DATA x . RSET )r rM � addErrbackrF r rq rA r r` ra r rb rc r r� r� r� r� r� r� re r� �resumeProducingr� )r. r� �failedrf rg r_ r� r� r% r% r( � test_resetTimeoutWhileSending sJ � � � �z*TimeoutTests.test_resetTimeoutWhileSendingN) r: r; r< r= ri rs ru rw rz r� r% r% r% r( rW � s rW c @ rQ )�(MultipleDeliveryFactorySMTPServerFactorya L{MultipleDeliveryFactorySMTPServerFactory} creates SMTP server protocol instances with message delivery factory objects supplied to it. Each factory is used for one connection and then discarded. Factories are used in the order they are supplied. c C rj r$ )�_messageFactories)r. �messageFactoriesr% r% r( r0 q rn z1MultipleDeliveryFactorySMTPServerFactory.__init__c C s$ t j�| |�}t| j�d��|_|S )Nr )r � ServerFactoryra r� r� r� r� )r. �addrr r% r% r( ra t s z6MultipleDeliveryFactorySMTPServerFactory.buildProtocolN)r: r; r< r= r0 ra r% r% r% r( r� i s r� c @ rQ )�SMTPSenderFactoryTestsz. Tests for L{smtp.SMTPSenderFactory}. c C �^ t � }t�� }t�ddtd�|�}|�dd|�}|�d� |�|t � d�� | � |j d� dS )zt L{smtp.SMTPSenderFactory} removes the current protocol when the client connection is lost. rk rt � message� localhostrZ N�Bye.) r r rM r rq r � connectTCPra �clientConnectionLostr �ConnectionDoner� �currentProtocol�r. r � sentDeferredrg � connectorr% r% r( �2test_removeCurrentProtocolWhenClientConnectionLost � � zISMTPSenderFactoryTests.test_removeCurrentProtocolWhenClientConnectionLostc C r� )zv L{smtp.SMTPSenderFactory} removes the current protocol when the client connection is failed. rk rt r� r� rZ Nr� ) r r rM r rq r r� ra �clientConnectionFailedr r� r� r� r� r% r% r( �4test_removeCurrentProtocolWhenClientConnectionFailed� r� zKSMTPSenderFactoryTests.test_removeCurrentProtocolWhenClientConnectionFailedN)r: r; r< r= r� r� r% r% r% r( r� z s r� c @ rB )�SMTPSenderFactoryRetryTestszD Tests for the retry behavior of L{smtp.SMTPSenderFactory}. c s� d�d�t �g�� G �fdd�dtj�}tt� fdd�g�}||_tjd|dd �}|�� }�� |j � t � � }t� d �d t��|�}d |_t�|j|j|�}�� |j� � ���fd d�}|�|� |S )z� If the protocol created by L{SMTPSenderFactory} loses its connection before receiving confirmation of message delivery, it reconnects and tries to deliver the message again. s alices some message textc s e Zd ZdZ� fdd�ZdS )zHSMTPSenderFactoryRetryTests.test_retryAfterDisconnect.<locals>.CleanSMTPz� An SMTP subclass which ensures that its transport will be disconnected before the test ends. c s � � |j� tj�| |� d S r$ )� addCleanupr� r r� r� )� innerSelfr� r6 r% r( r� � s zWSMTPSenderFactoryRetryTests.test_retryAfterDisconnect.<locals>.CleanSMTP.makeConnectionN)r: r; r< r= r� r% r6 r% r( � CleanSMTP� s r� c s t � | �S r$ rU )r/ )rA r% r( rV � rW zGSMTPSenderFactoryRetryTests.test_retryAfterDisconnect.<locals>.<lambda>r � 127.0.0.1)� interfaces bob@example.orgs @example.comr� c s6 �� � j�d� d gi� �� t��t��d� dS )z� Verify that the message was successfully delivered and flush the error which caused the first attempt to fail. rG r] N)r� rJ r7 �flushLoggedErrorsr5 rJ �rA rO � recipientr. r% r( �cbSent� s zESMTPSenderFactoryRetryTests.test_retryAfterDisconnect.<locals>.cbSent)rR r r� r� r, r r � listenTCP�getHostr� � stopListeningr rM rq r rA r� �host�port� disconnectr� ) r. r� � serverFactory� serverPort� serverHostr� rg �clientConnectorr� r% r� r( �test_retryAfterDisconnect� s4 � � � z5SMTPSenderFactoryRetryTests.test_retryAfterDisconnectN)r: r; r< r= r� r% r% r% r( r� � � r� c @ rQ )�SingletonRealmz� Trivial realm implementation which is constructed with an interface and an avatar and returns that avatar when asked for that interface. c C s || _ || _d S r$ �r� �avatar)r. r� r� r% r% r( r0 � s zSingletonRealm.__init__c G s, |D ]}|| j u r|| jdd� f S qd S )Nc S r# r$ r% r% r% r% r( rV � r z.SingletonRealm.requestAvatar.<locals>.<lambda>r� )r. r r r �ifacer% r% r( r � s ��z SingletonRealm.requestAvatarN)r: r; r< r= r0 r r% r% r% r( r� � s r� c @ r> ) �NotImplementedDeliveryz� Non-implementation of L{smtp.IMessageDelivery} which only has methods which raise L{NotImplementedError}. Subclassed by various tests to provide the particular behavior being tested. c C r4 �Nz3This oughtn't be called in the course of this test.��NotImplementedErrorr� r% r% r( r� � r8 z#NotImplementedDelivery.validateFromc C r4 r� r� r- r% r% r( r� � r8 z!NotImplementedDelivery.validateToc C r4 r� r� r r% r% r( r� � r8 z%NotImplementedDelivery.receivedHeaderN)r: r; r< r= r� r� r� r% r% r% r( r� � s r� c @ sf e Zd ZdZejfdd�Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z e e�dd� �Zdd� ZdS )�SMTPServerTestsza Test various behaviors of L{twisted.mail.smtp.SMTP} and L{twisted.mail.smtp.ESMTP}. c C s> |� }d|_ t� }|�|� |�t�� � | �d|�� � dS )zb Test that the specified hostname shows up in the SMTP server's greeting. s example.comN)r� r r� r9 r r� �assertInr� )r. r� �srh r% r% r( �testSMTPGreetingHost s z$SMTPServerTests.testSMTPGreetingHostc C �: t �� }t� }|�|� |�t�� � | �d|�� � dS )z� Test that the string "ESMTP" does not appear in the SMTP server's greeting since that string strongly suggests the presence of support for various SMTP extensions which are not supported by L{smtp.SMTP}. � ESMTPN) r r� r r� r9 r r� � assertNotInr� �r. r� rh r% r% r( �testSMTPGreetingNotExtended � z+SMTPServerTests.testSMTPGreetingNotExtendedc C s | � tj� dS )zS Similar to testSMTPGreetingHost, but for the L{smtp.ESMTP} class. N)r� r r� r6 r% r% r( �testESMTPGreetingHost s z%SMTPServerTests.testESMTPGreetingHostc C r� )z� Test that the string "ESMTP" does appear in the ESMTP server's greeting since L{smtp.ESMTP} does support the SMTP extensions which that advertises to the client. r� N) r r� r r� r9 r r� r� r� r� r% r% r( �testESMTPGreetingExtended$ r� z)SMTPServerTests.testESMTPGreetingExtendedc C sD t �� }t� }|�|� |�d� |�t�� � | �d|� � � dS )zN Sending an unimplemented command is responded to with a 500. s DOAGOODTHINGs 500 Command not implementedN) r r� r r� r3 r9 r r� r� r� r� r% r% r( �test_SMTPUnknownCommand0 s z'SMTPServerTests.test_SMTPUnknownCommandc C � G dd� dt �}ttj|� �}t|t� g�}t�� }||_t� }|� |� |� d� |� � |� d� |� t �� � | �|�� d� dS )z� Test that a C{MAIL FROM} command with an acceptable address is responded to with the correct success code. c @ rB )zDSMTPServerTests.test_acceptSenderAddress.<locals>.AcceptanceDeliveryzM Delivery object which accepts all senders as valid. c S r� r$ r% r� r% r% r( r� F r* zQSMTPServerTests.test_acceptSenderAddress.<locals>.AcceptanceDelivery.validateFromN�r: r; r< r= r� r% r% r% r( �AcceptanceDeliveryA r� r� � HELO example.com � MAIL FROM:<alice@example.com> s 250 Sender address accepted N�r� r� r r r r r� r r r� r� r� r9 r �ConnectionLostr� r� )r. r� r r rT �transr% r% r( �test_acceptSenderAddress; s z(SMTPServerTests.test_acceptSenderAddressc C r� )z� Test that a C{MAIL FROM} command with an address rejected by a L{smtp.IMessageDelivery} instance is responded to with the correct error code. c @ rB )zMSMTPServerTests.test_deliveryRejectedSenderAddress.<locals>.RejectionDeliveryzO Delivery object which rejects all senders as invalid. c S s t �|��r$ )r � SMTPBadSenderr� r% r% r( r� j rn zZSMTPServerTests.test_deliveryRejectedSenderAddress.<locals>.RejectionDelivery.validateFromNr� r% r% r% r( �RejectionDeliverye r� r� r� r� �V 550 Cannot receive from specified address <alice@example.com>: Sender not acceptable Nr� )r. r� r r rT r� r% r% r( �"test_deliveryRejectedSenderAddress^ s �z2SMTPServerTests.test_deliveryRejectedSenderAddressc C s� G dd� d�}t tjt� �}t||� g�}t�� }||_t� }|�|� |� d� |� � |� d� |� t � � � | �|�� d� dS )z� Test that a C{MAIL FROM} command with an address rejected by an L{smtp.SMTP} instance's portal is responded to with the correct error code. c @ s e Zd ZdZefZdd� ZdS )zQSMTPServerTests.test_portalRejectedSenderAddress.<locals>.DisallowAnonymousAccesszZ Checker for L{IAnonymous} which rejects authentication attempts. c S s t �t� �S r$ )r rY r r� r% r% r( r � r� zaSMTPServerTests.test_portalRejectedSenderAddress.<locals>.DisallowAnonymousAccess.requestAvatarIdN)r: r; r< r= r r r r% r% r% r( �DisallowAnonymousAccess� s r� r� r� r� N�r� r r r� r r� r r r� r� r� r9 r r� r� r� )r. r� r r rT r� r% r% r( � test_portalRejectedSenderAddress� s �z0SMTPServerTests.test_portalRejectedSenderAddressc C st t tjt� �}t|g �}t�� }||_t� }|�|� |� d� |� � |� d� |� t � � � | �|�� d� dS )z� Test that a C{MAIL FROM} command issued without first authenticating when a portal has been configured to disallow anonymous logins is responded to with the correct error code. r� r� sd 550 Cannot receive from specified address <alice@example.com>: Unauthenticated senders not allowed Nr� )r. r r rT r� r% r% r( �"test_portalRejectedAnonymousSender� s �z2SMTPServerTests.test_portalRejectedAnonymousSenderN)r: r; r< r= r r� r� r� r� r� r� r� r� r r r� r� r% r% r% r( r� s #( *r� c @ sx e Zd Zdd� Z d dd�Zdd� Zd d � Zd d � Zd d� Zdd� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd � Zd S ) �ESMTPAuthenticationTestsc C s0 | j �� | j�|� | �|| j �� �� � dS )z� Assert that when the given bytes are delivered to the ESMTP server instance, it responds with the indicated lines. @type bytes: str @type response: list of str N)r� r� r� r� r� r� r� )r. r� �responser% r% r( �assertServerResponse� s z-ESMTPAuthenticationTests.assertServerResponse� username� passwordc C s� |� � \}}}}| �|g � | �tjjj�|�� | �|j|� | �|� |�� | � t j |� | � t j |� |�t j ddd� f� | �dg| j�� �� � dS )a� Assert that a login attempt has been made, that the credentials and interfaces passed to it are correct, and that when the login request is satisfied, a successful response is sent by the ESMTP server instance. @param loginArgs: A C{list} previously passed to L{portalFactory}. @param username: The login user. @param password: The login password. Nc S r# r$ r% r% r% r% r( rV � r zDESMTPAuthenticationTests.assertServerAuthenticated.<locals>.<lambda>s 235 Authentication successful.)r� r� r� �twistedr r r � providedByr� r� r� r �IMessageDeliveryFactoryr rN r� r� r� )r. � loginArgsr� rx r� r r r r% r% r( �assertServerAuthenticated� s ��z2ESMTPAuthenticationTests.assertServerAuthenticatedc C s@ t �dti�| _d| j_tt�ddd�d�| _| j� | j� dS )zI Create an ESMTP instance attached to a StringTransport. r s localhostrX r� i90 )� peerAddressN) r r� r r� r� r r rb r� r� r6 r% r% r( �setUp� s �z ESMTPAuthenticationTests.setUpc C s | j �t�� � dS )zT Disconnect the ESMTP instance to clean up its timeout DelayedCall. N)r� r9 r r� r6 r% r% r( �tearDown s z!ESMTPAuthenticationTests.tearDownc s G � fdd�d�}|� S )Nc s e Zd Z� fdd�ZdS )z;ESMTPAuthenticationTests.portalFactory.<locals>.DummyPortalc s t �� }� �||||f� |S r$ )r rM rF )r. r r r r� �� loginListr% r( �login s zAESMTPAuthenticationTests.portalFactory.<locals>.DummyPortal.loginN)r: r; r< r� r% r� r% r( � DummyPortal s r� r% )r. r� r� r% r� r( � portalFactory s z&ESMTPAuthenticationTests.portalFactoryc C sX | j �� | j�d� | j �� �� }| �|d d� | �|d d� | �t|�d� dS )zV Test that AUTH is advertised to clients which issue an EHLO command. � EHLO r s/ 250-localhost Hello 127.0.0.1, nice to meet your] s 250 AUTH LOGINr^ N)r� r� r� r� r� r� r� r7 )r. � responseLinesr% r% r( �'test_authenticationCapabilityAdvertised s �z@ESMTPAuthenticationTests.test_authenticationCapabilityAdvertisedc C s� g }| � |�| j_| j�d� | j�� | �ddt�d�� � g� | �t�d�d dt�d�� � g� | �t�d�� � d g � | � |� d S ) zJ Test that the LOGIN authentication mechanism can be used r� � AUTH LOGIN � 334 � User Name r� r� � Password r� N� r� r� r r� r� r� r� �base64� b64encode�stripr� �r. r� r% r% r( �test_plainAuthentication! s � �z1ESMTPAuthenticationTests.test_plainAuthenticationc C s� g }| � |�| j_| j�d� | j�� | �ddt�d�� � g� | �t�d�d dt�d�� � g� | �dg � | j |dd � d S ) zM Test that giving an empty password for plain auth succeeds. r� r� r� r� r� r� r� r{ )rx Nr� r� r% r% r( �%test_plainAuthenticationEmptyPassword8 s � � z>ESMTPAuthenticationTests.test_plainAuthenticationEmptyPasswordc C s~ g }| � |�| j_| j�d� | j�� | �dt�d�� � d dt�d�� � g� | �t�d�� � d g � | � |� dS ) z� The response to the first challenge may be included on the AUTH command line. Test that this is also supported. r� � AUTH LOGIN r� r� r� r� r� Nr� r� r% r% r( �'test_plainAuthenticationInitialResponseN s �z@ESMTPAuthenticationTests.test_plainAuthenticationInitialResponsec C s< g }| � |�| j_| j�d� | j�d� | �ddg� dS )zW Test that a challenge/response sequence can be aborted by the client. r� r� s * s 501 Authentication abortedN)r� r� r r� r� r� r% r% r( �test_abortAuthenticationb s z1ESMTPAuthenticationTests.test_abortAuthenticationc C sH g }| � |�| j_| j�d� | j�d� | �ddg� | �|g � dS )zz Test that a response which is not properly Base64 encoded results in the appropriate error code. r� r� s x �+ 501 Syntax error in parameters or argumentsN�r� r� r r� r� r� r� r% r% r( �!test_invalidBase64EncodedResponsen s �z:ESMTPAuthenticationTests.test_invalidBase64EncodedResponsec C s< g }| � |�| j_| j�d� | �ddg� | �|g � dS )z� Like L{test_invalidBase64EncodedResponse} but for the case of an initial response included with the C{AUTH} command. r� s AUTH LOGIN x r� Nr� r� r% r% r( �(test_invalidBase64EncodedInitialResponse s �zAESMTPAuthenticationTests.test_invalidBase64EncodedInitialResponsec C s� g }| � |�| j_| j�d� | j�� | �dt�d�� � d dt�d�� � g� | �t�d�� � d g � |� � \}}}}|� t d�� | � d | j�� � | � t| �t ��d � d S ) z� If the L{Deferred} returned by L{Portal.login} fires with an exception of any type other than L{UnauthorizedLogin}, the exception is logged and the client is informed that the authentication attempt has failed. r� r� r� r� r� r� r� z Something wrong with the servers9 451 Requested action aborted: local error in processing r] N)r� r� r r� r� r� r� r� r� r� r� �errbackr5 r� r� r7 r� )r. r� r� r r r r% r% r( �test_unexpectedLoginFailure� s ��z4ESMTPAuthenticationTests.test_unexpectedLoginFailureN)r� r� )r: r; r< r� r� r� r� r� r� r� r� r� r� r� r� r r% r% r% r( r� � s � r� c @ r> ) �SMTPClientErrorTestsz, Tests for L{smtp.SMTPClientError}. c C � t �dd�}| �t|�d� dS )z� The string representation of a L{SMTPClientError} instance includes the response code and response string. r� z some textz 123 some textN�r r� r� r1 �r. �errr% r% r( �test_str� � z SMTPClientErrorTests.test_strc C r )z� If the response code supplied to L{SMTPClientError} is negative, it is excluded from the string representation. ���s foo barzfoo barNr r r% r% r( �test_strWithNegativeCode� r z-SMTPClientErrorTests.test_strWithNegativeCodec C sD t d�}|�d� |�d� tjdd|�� d�}| �t|�d� dS ) z� If a line log is supplied to L{SMTPClientError}, its contents are included in the string representation of the exception instance. � s testlogs secondline�d z test error)rs z"100 test error testlog secondline N)r rF r r� r1 r� )r. rs r r% r% r( �test_strWithLog� s z$SMTPClientErrorTests.test_strWithLogN)r: r; r< r= r r r r% r% r% r( r � s r c @ rB )�SenderMixinSentMailTestsz� Tests for L{smtp.SenderMixin.sentMail}, used in particular by L{smtp.SMTPSenderFactory} and L{smtp.ESMTPSenderFactory}. c sr � � t�� tj�}|�� fdd�� tjddtd�|ddd�}|�t � d d d ��}d d g}|� ddd||j � |S )z� L{smtp.SenderMixin.sentMail} adds only the addresses with failing SMTP response codes to the log passed to the factory's errback. c s � � | jd�S )Ns' bob@example.com: 199 Error in sending. )r� rs )r. r6 r% r( rV � s �zFSenderMixinSentMailTests.test_onlyLogFailedAddresses.<locals>.<lambda>rk rt rl r r[ rm rX rY rZ )s alice@example.com�� s No errors here!)s bob@example.com�� s Error in sending.r s Test responser] ) rd r rM r �SMTPDeliveryErrorr� rq r ra r rb rt rs )r. rf rg r� rr r% r6 r( �test_onlyLogFailedAddresses� s( �� ��z4SenderMixinSentMailTests.test_onlyLogFailedAddressesN)r: r; r< r= r r% r% r% r( r � s r c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �ESMTPDowngradeTestCasezU Tests for the ESMTP -> SMTP downgrade functionality in L{smtp.ESMTPClient}. c C s t �dd d�| _d S )Nr� r� )r r| �clientProtocolr6 r% r% r( r� � r z ESMTPDowngradeTestCase.setUpc C s^ t � }d| j_d| j_d| j_| j�|� | j�d� |�� | j�d� | �d|� � � dS )z� If both authentication and transport security are not required, and it is asked for, it will fall back to allowing HELO. FT� 220 localhost � 500 not an esmtp server � HELO testuser N� r r �requireAuthentication�requireTransportSecurity� heloFallbackr� r� r� r� r� �r. r� r% r% r( � test_requireHELOFallbackOperates� � z7ESMTPDowngradeTestCase.test_requireHELOFallbackOperatesc C s^ t � }d| j_d| j_d| j_| j�|� | j�d� |�� | j�d� | �d|� � � dS )z� If authentication is required, and HELO fallback is on, HELO fallback must not be honoured, as authentication requires EHLO to succeed. TFr r r� Nr r r% r% r( �!test_requireAuthFailsHELOFallback r z8ESMTPDowngradeTestCase.test_requireAuthFailsHELOFallbackc C s^ t � }d| j_d| j_d| j_| j�|� | j�d� |�� | j�d� | �d|� � � dS )z� If TLS is required and the connection is insecure, HELO fallback must not be honoured, as STARTTLS requires EHLO to succeed. FTr r r� Nr r r% r% r( � test_requireTLSFailsHELOFallback r z7ESMTPDowngradeTestCase.test_requireTLSFailsHELOFallbackc C sj t � }t|tj� d| j_d| j_d| j_| j�|� | j� d� |� � | j� d� | � d|� � � dS )z� If TLS is provided at the transport level, we can honour the HELO fallback if we're set to require TLS. FTr r r N) r r r � ISSLTransportr r r r r� r� r� r� r� r r% r% r( �/test_requireTLSAndHELOFallbackSucceedsIfOverTLS- s zFESMTPDowngradeTestCase.test_requireTLSAndHELOFallbackSucceedsIfOverTLSN) r: r; r< r= r� r r r r! r% r% r% r( r � s r c @ sd e Zd ZdZeZdZdZdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� ZdS )� SSLTestCasezD Tests for the TLS negotiation done by L{smtp.ESMTPClient}. s3 220 localhost NO UCE NO UBE NO RELAY PROBES ESMTP s1 250-localhost Hello 127.0.0.1, nice to meet you c C s* t �dt� d�| _d| j_dd� | j_d S )Nr� r� Tc S s dS )Nztest@example.orgr% r% r% r% r( rV N r z#SSLTestCase.setUp.<locals>.<lambda>)r r| r! r r rf r6 r% r% r( r� I s �zSSLTestCase.setUpc C sZ t � }t|tj� | j�|� | j�| j� |�� | j�| j | � | � d|� � � dS )a� Verify that when L{smtp.ESMTPClient} connects to a server over a transport providing L{ISSLTransport}, C{requireTransportSecurity} is C{True}, and it is presented with the given capabilities, it will try to send its mail and not first attempt to negotiate TLS using the I{STARTTLS} protocol action. @param capabilities: Bytes to include in the test server's capability response. These must be formatted exactly as required by the protocol, including a line which ends the capability response. @type param: L{bytes} @raise: C{self.failureException} if the behavior of C{self.clientProtocol} is not as described. s MAIL FROM:<test@example.org> N) r r r r r r� r� �SERVER_GREETINGr� � EHLO_RESPONSEr� r� )r. � capabilitiesr� r% r% r( �$_requireTransportSecurityOverSSLTestP s z0SSLTestCase._requireTransportSecurityOverSSLTestc C � | � d� dS )z� When C{requireTransportSecurity} is C{True} and the client is connected over an SSL transport, mail may be delivered. � 250 AUTH LOGIN N�r& r6 r% r% r( �$test_requireTransportSecurityOverSSLo � z0SSLTestCase.test_requireTransportSecurityOverSSLc C �N t � }| j�|� | j�| j� |�� | j�| jd � | �d|�� � dS )z� When C{requireTransportSecurity} is C{True} and the client is connected over a non-SSL transport, if the server offers the I{STARTTLS} extension, it is used before mail is delivered. � 250-AUTH LOGIN 250 STARTTLS s STARTTLS N� r r r� r� r# r� r$ r� r� r r% r% r( �'test_requireTransportSecurityTLSOfferedv s �z3SSLTestCase.test_requireTransportSecurityTLSOfferedc C r' )z� When C{requireTransportSecurity} is C{True} and the client is connected over an SSL transport, if the server offers the I{STARTTLS} extension, it is not used before mail is delivered. r- Nr) r6 r% r% r( �.test_requireTransportSecurityTLSOfferedOverSSL� s �z:SSLTestCase.test_requireTransportSecurityTLSOfferedOverSSLc C r, )z� When C{requireTransportSecurity} is C{True} and the client is connected over a non-SSL transport, if the server does not offer the I{STARTTLS} extension, mail is not delivered. r( r� Nr. r r% r% r( �*test_requireTransportSecurityTLSNotOffered� s z6SSLTestCase.test_requireTransportSecurityTLSNotOfferedc C sV | j j}~| j| jgd�}| �t|�d� | �|d d t� | �|d d d� dS )�< L{smtp.ESMTPClient.tlsMode} is deprecated. ��offendingFunctionsr] r �categoryrO �StlsMode attribute of twisted.mail.smtp.ESMTPClient is deprecated since Twisted 13.0N)r �tlsMode� flushWarnings�%test_esmtpClientTlsModeDeprecationGetr� r7 �assertIdentical�DeprecationWarning)r. �val� warningsShownr% r% r( r9 � s � �z1SSLTestCase.test_esmtpClientTlsModeDeprecationGetc s � � t� fdd�� dS )z� L{smtp.ESMTPClient.__getattr__} raises an attribute error for other attribute names which do not exist. c s � j jS r$ )r � doesNotExistr% r6 r% r( rV � s zQSSLTestCase.test_esmtpClientTlsModeDeprecationGetAttributeError.<locals>.<lambda>N)� assertRaises�AttributeErrorr6 r% r6 r( �3test_esmtpClientTlsModeDeprecationGetAttributeError� s z?SSLTestCase.test_esmtpClientTlsModeDeprecationGetAttributeErrorc C sT d| j _| j| jgd�}| �t|�d� | �|d d t� | �|d d d� dS ) r2 Fr3 r] r r5 rO r6 N)r r7 r8 �%test_esmtpClientTlsModeDeprecationSetr� r7 r: r; )r. r= r% r% r( rB � s � �z1SSLTestCase.test_esmtpClientTlsModeDeprecationSetN)r: r; r< r= r rQ r# r$ r� r& r* r/ r0 r1 r9 rA rB r% r% r% r( r" ? s r" c @ s e Zd ZdZdZdd� ZdS )�AbortableStringTransportzK A version of L{StringTransport} that supports C{abortConnection}. Fc C s d| _ | �� dS )z� A testable version of the C{ITCPTransport.abortConnection} method. Since this is a special case of closing the connection, C{loseConnection} is also called. TN)�abortingr� r6 r% r% r( �abortConnection� s z(AbortableStringTransport.abortConnectionN)r: r; r< r= rD rE r% r% r% r( rC � s rC c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )� SendmailTestsz2 Tests for L{twisted.mail.smtp.sendmail}. c C s( t �tj�\}}}}| �t|d � dS )z{ The default C{reactor} parameter of L{twisted.mail.smtp.sendmail} is L{twisted.internet.reactor}. r^ N)�inspect� getargspecr �sendmailr� r )r. �args�varArgs�keywords�defaultsr% r% r( �"test_defaultReactorIsGlobalReactor� s z0SendmailTests.test_defaultReactorIsGlobalReactorc C sl t � }tjdddd|||ddd� |jd d }| �|jd� | �|jd� | �|jd � | �|jd � d S ) zk L{twisted.mail.smtp.sendmail} creates the ESMTP factory with the ESMTP arguments. r� rk rt r� T)r r� rx r r r r^ r� � barN) r r rI � tcpClientsr� �_requireTransportSecurity�_requireAuthenticationr� rx )r. r� rx r r� r% r% r( �_honorsESMTPArguments� s" � z#SendmailTests._honorsESMTPArgumentsc C � | j ddd�S )zw L{twisted.mail.smtp.sendmail} should accept C{username} and C{password} which are L{unicode}. r� �bar�r� rx �rS r6 r% r% r( �&test_honorsESMTPArgumentsUnicodeUserPW r+ z4SendmailTests.test_honorsESMTPArgumentsUnicodeUserPWc C rT )zu L{twisted.mail.smtp.sendmail} should accept C{username} and C{password} which are L{bytes}. r� rO rV rW r6 r% r% r( �$test_honorsESMTPArgumentsBytesUserPW r+ z2SendmailTests.test_honorsESMTPArgumentsBytesUserPWc C sB t � }td�}tjddd||d� |jd d }| �|j|� dS ) z| L{twisted.mail.smtp.sendmail} will pass through the message untouched if it is a file-like object. s File!r� rk rt �r r r^ N)r r r rI rP �assertIs�file)r. r � messageFiler� r% r% r( �test_messageFilePassthrough s �z)SendmailTests.test_messageFilePassthroughc C sL t � }tjdddd|d� |jd d }|j}|�d� | �|�� d� dS ) z� L{twisted.mail.smtp.sendmail} will turn non-file-like objects (eg. strings) into file-like objects before sending. r� rk rt r� rZ r r^ N)r r rI rP r\ �seekr� r� )r. r r� r] r% r% r( �test_messageStringMadeFile( s � z(SendmailTests.test_messageStringMadeFilec C s< t � }tjdddd|dd� |jd d }| �|jd � d S ) zk L{twisted.mail.smtp.sendmail} passes through the sender domain name, if provided. r� rk rt r� r� )r �senderDomainNamer r^ r� N)r r rI rP r� rA )r. r r� r% r% r( �test_senderDomainName: s �z#SendmailTests.test_senderDomainNamec C sP t � }tjdddd|d�}|�� | �|jd jd� | �|�}|�t j � dS ) z� When a user cancels L{twisted.mail.smtp.sendmail} before the connection is made, the connection is closed by L{twisted.internet.interfaces.IConnector.disconnect}. r� rk rt r� rZ r TN) r r rI �cancelr� � connectors� _disconnected�failureResultOf�trapr �CancelledError)r. r r� �failurer% r% r( � test_cancelBeforeConnectionMadeK s � z-SendmailTests.test_cancelBeforeConnectionMadec C s� t � }t� }tjdddd|d�}|jd d }|�d�}|�|� |�� | �|j d � | �|j d � | � |�}|� t j� dS ) z� When a user cancels L{twisted.mail.smtp.sendmail} after the connection is made, the connection is closed by L{twisted.internet.interfaces.ITransport.abortConnection}. r� rk rt r� rZ r r^ NT)r rC r rI rP ra r� rc r� rD r� rf rg r rh )r. r r� r� r� r ri r% r% r( � test_cancelAfterConnectionMade^ s" � z,SendmailTests.test_cancelAfterConnectionMadeN) r: r; r< r= rN rS rX rY r^ r` rb rj rk r% r% r% r( rF � s rF )kr= r� rG rD �ior �typingr r r r r �zope.interfacer r �twisted.cred.checkersr� �twisted.cred.credentials�twisted.cred.error�twisted.cred.portalr r r r r r r �twisted.internetr r r r r r r � twisted.mailr �twisted.mail._credr �twisted.protocolsr r �twisted.python.utilr �twisted.test.proto_helpersr r �twisted.trial.unittestr r1 r� �twisted.test.ssl_helpersr! r" � ImportErrorr � IReactorSSLr� r) �IMessager, r? rR r_ r\ rw ru r| rz r� � LineReceiverr� r� r� r� r� r� r� r� r� r� r� �checkersr� r r� r r r# rC rH rR rW r� r� r� r� r� r� r� r� r r r r" rC rF r% r% r% r( �<module> s� $ � um B= 7$@ R \!(J PK Mb�Z�3�� � 2 mail/test/__pycache__/test_scripts.cpython-310.pycnu �[��� o �b� � @ s2 d Z ddlmZ ddlmZ G dd� dee�ZdS )zB Tests for the command-line mailer tool provided by Twisted Mail. � )�ScriptTestsMixin)�TestCasec @ s e Zd ZdZdd� ZdS )� ScriptTestsz. Tests for all one of mail's scripts. c C s | � d� d S )Nz mail/mailmail)� scriptTest)�self� r �@/usr/lib/python3/dist-packages/twisted/mail/test/test_scripts.py� test_mailmail s zScriptTests.test_mailmailN)�__name__� __module__� __qualname__�__doc__r r r r r r s r N)r �!twisted.scripts.test.test_scriptsr �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z�*���+ �+ 3 mail/test/__pycache__/test_mailmail.cpython-310.pycnu �[��� o �bk2 � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZ dd lmZ dd lmZ dd lmZ dd lmZ dd lmZ G dd� de�ZdS )zi Tests for L{twisted.mail.scripts.mailmail}, the implementation of the command line program I{mailmail}. � N)�StringIO)�skipIf)�version)�Deferred)�smtp)�mailmail)� parseOptions)�Failure)� platformType)� MemoryReactor)�TestCasec @ s� e Zd ZdZe� Zdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zeedkd�d d � �Zeedkd�d d � �Zd d!� Zd"d#� Zd$d%� Zd&S )'� OptionsTestsz� Tests for L{parseOptions} which parses command line arguments and reads message text from stdin to produce an L{Options} instance which can be used to send a message. c sf t � � _ddlm}m} |� j�}� �td||d�� d� _d� _d� _ � fdd�}� �td|� dS ) zz Override some things in mailmail, so that we capture C{stdout}, and do not call L{reactor.stop}. r )�Logger�textFileLogObserver�_log)�observerNc s. | � _ |� _|� _tj| |j|j|j� jd�S )N)�reactor) �host�options�identr �sendmail�sender�to�body� memoryReactor)r r r ��self� �A/usr/lib/python3/dist-packages/twisted/mail/test/test_mailmail.pyr 3 s �z$OptionsTests.setUp.<locals>.sendmailr ) r �out�twisted.loggerr r �patchr r r r )r r r � logObserverr r r r �setUp# s zOptionsTests.setUpc C s2 | � tdtd�� | �ttg �}| �|jd� dS )z� If no recipients are given in the argument list and there is no recipient header in the message text, L{parseOptions} raises L{SystemExit} with a string describing the problem. �stdinz Subject: foo Hello, goodbye. )zNo recipients specified.N)r! �sysr � assertRaises� SystemExitr � assertEqual�args�r �excr r r �test_unspecifiedRecipientsA s z'OptionsTests.test_unspecifiedRecipientsc C �" | � ttdg�}| �|jd� dS )z� The I{-bp} option for listing queue information is unsupported and if it is passed to L{parseOptions}, L{SystemExit} is raised. z-bp�zUnsupported option.N�r& r' r r( r) r* r r r �test_listQueueInformationK s z&OptionsTests.test_listQueueInformationc C r- )z� The I{-bs} option for using stdin and stdout as the SMTP transport is unsupported and if it is passed to L{parseOptions}, L{SystemExit} is raised. z-bsr. Nr/ r* r r r �test_stdioTransportS � z OptionsTests.test_stdioTransportc C s@ | � ttdg�}| �|jd� | � ttdg�}| �|jd� dS )z� The I{-i} and I{-oi} options for ignoring C{"."} by itself on a line are unsupported and if either is passed to L{parseOptions}, L{SystemExit} is raised. z-ir. z-oiNr/ r* r r r �test_ignoreFullStop\ s z OptionsTests.test_ignoreFullStopc C r- )z� The I{-om} option for copying the sender if they appear in an alias expansion is unsupported and if it is passed to L{parseOptions}, L{SystemExit} is raised. z-omr. Nr/ r* r r r �test_copyAliasedSenderg r2 z#OptionsTests.test_copyAliasedSenderc C sP t � }| �td|� | �ttd�}| �|jd� |�� }| �|dt � d�� dS )z~ The I{--version} option displays the version and raises L{SystemExit} with L{None} as the exit code. �stdoutz --versionNzmailmail version: � ) r r! r% r& r' r r( �code�getvaluer )r r �systemExitCode�datar r r � test_versionp s zOptionsTests.test_versionc C �. t d�}| �td|� td�}| �|j� dS )zA The I{-odb} flag specifies background delivery. r6 r$ z-odbN)r r! r% r � assertTrue� background�r r$ �or r r �test_backgroundDelivery} � z$OptionsTests.test_backgroundDeliveryc C r< )zB The I{-odf} flags specifies foreground delivery. r6 r$ z-odfN)r r! r% r � assertFalser> r? r r r �test_foregroundDelivery� rB z$OptionsTests.test_foregroundDeliveryc C s4 t d�}| �td|� td�}| �t|j�d� dS )zd The I{-t} flags specifies that recipients should be obtained from headers. zTo: Curly <invaliduser2@example.com> Cc: Larry <invaliduser1@example.com> Bcc: Moe <invaliduser3@example.com> Oh, a wise guy? r$ �-t� N)r r! r% r r( �lenr r? r r r �test_recipientsFromHeaders� s �z'OptionsTests.test_recipientsFromHeadersc C �4 t d�}| �td|� tg d��}| �|jd� dS )zw When a message has no I{From:} header, a I{From:} value can be specified with the I{-F} flag. z3To: invaliduser2@example.com Subject: A wise guy? r$ )�-F� Larry <invaliduser1@example.com>rE rK N�r r! r% r r( r r? r r r � test_setFrom� s zOptionsTests.test_setFromc C rI )z� The I{-F} flag specifies the From: value. However, I{-F} flag is overriden by the value of From: in the e-mail header. zLTo: Curly <invaliduser4@example.com> From: Shemp <invaliduser4@example.com> r$ )rJ z"Groucho <invaliduser5@example.com>rE zinvaliduser4@example.comNrL r? r r r �!test_overrideFromFlagByFromHeader� s � z.OptionsTests.test_overrideFromFlagByFromHeader�win32zImailmail.run() does not work on win32 due to lack of support for getuid()c C st d}t d�}| �td|� | �td|� t�� | �| jjt�� � | �| jj dg� | � | jj � | � tj � dS )z� Call L{mailmail.run}, and specify I{-oep} to print errors to stderr. The sender, to, and printErrors options should be set and there should be no failure. �ztest_mailmail.py�invaliduser2@example.comz-oepr6 �argvr$ rQ N)r r! r% r �runr( r r �getloginr r= � printErrors� assertIsNone�failed)r rR r$ r r r �test_runErrorsToStderr� s z#OptionsTests.test_runErrorsToStderrc C s� t d�}| �td|� | �� }t�� }t�� }t|d��}|�d� ||�� W d � n1 s0w Y | �t d|� d}| �td|� t � � | � | j �� d � | � | j �� d � | � | j �� d � dS ) z� Error messages for illegal UID value, illegal GID value, and illegal identity entry will be sent to stderr. r6 r$ �wa [useraccess] allow=invaliduser2,invaliduser1 deny=invaliduser3,invaliduser4,{} order=allow,deny [groupaccess] allow=invalidgid1,invalidgid2 deny=invalidgid1,invalidgid2,{} order=deny,allow [identity] localhost=funny [addresses] smarthost=localhost default_domain=example.com N� LOCAL_CFGrP rR z3Illegal UID in \[useraccess\] section: invaliduser1z3Illegal GID in \[groupaccess\] section: invalidgid1z,Illegal entry in \[identity\] section: funny)r r! r% �mktemp�os�getuid�getgid�open�write�formatr rS � assertRegexr r8 )r r$ �filename�myUid�myGid�frR r r r �test_readInvalidConfig� s4 � ��� �z#OptionsTests.test_readInvalidConfigc C sV ddl m} | �� }t|d��}|�|� W d � ||�S 1 s"w Y ||�S )a� Read a mailmail configuration file. The mailmail script checks the twisted.mail.scripts.mailmail.GLOBAL_CFG variable and then the twisted.mail.scripts.mailmail.LOCAL_CFG variable for the path to its config file. @param config: path to config file @type config: L{str} @return: A parsed config. @rtype: L{twisted.mail.scripts.mailmail.Configuration} r )� loadConfigrY N)� twisted.mail.scripts.mailmailrh r[ r_ r` )r �configrh rc rf r r r �getConfigFromFile s ��z OptionsTests.getConfigFromFilec C sN | � d�}| �|jd� | � d�}| �|jd� | � d�}| �|jd� | �|jd� | � d�}| �d|j� | �|jd d d g� | � d �}| �|jd g� | � d �}| �|jd dg� | � d�}| �|jd dg� | �|jddg� | � d�}| �|jdg� | � d�}| �|j dg� | � d�}| �|jddg� | �|j ddg� dS )zj L{twisted.mail.scripts.mailmail.loadConfig} parses the config file for mailmail. z [addresses] smarthost=localhost� localhostz' [addresses] default_domain=example.comz example.comz; [addresses] smarthost=localhost default_domain=example.comz1 [identity] host1=invalid host2=username:password�host1�host2�username�passwordz+ [useraccess] allow=invalid1,35 order=allow�# z# [useraccess] deny=35,36 order=deny�$ z/ [useraccess] allow=35,36 deny=37,38 order=deny�% �& z( [groupaccess] allow=gid1,41 order=allow�) z! [groupaccess] deny=41 order=denyz6 [groupaccess] allow=41,42 deny=43,44 order=allow,deny�* �+ �, N) rk r( � smarthost�domain� assertNotIn� identities� allowUIDs�denyUIDs� allowGIDs�denyGIDs)r rj r r r �test_loadConfig sX ����������z OptionsTests.test_loadConfigc sB � fdd�}� � td|� t�� }d|_tt� �}t�||� dS )z� L{twisted.mail.scripts.mailmail.senderror} sends mail back to the sender if an error occurs while sending mail to the recipient. c s0 � � |d� � �|dg� � � |�� d� t� S )Nz postmaster@� testsender� ValueError)rb r( r8 r )r r � recipientr r r r r } s z-OptionsTests.test_senderror.<locals>.sendmailr r� N)r! r r �Optionsr r r� � senderror)r r �opts�failr r r �test_senderrorw s zOptionsTests.test_senderrorN)�__name__� __module__� __qualname__�__doc__r r r# r, r0 r1 r3 r4 r; rA rD rH rM rN r r rX rg rk r� r� r r r r r s8 � � 6 Yr )r� r\ r% �ior �unittestr �twisted.copyrightr �twisted.internet.deferr � twisted.mailr �twisted.mail.scriptsr ri r �twisted.python.failurer �twisted.python.runtimer �twisted.test.proto_helpersr �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z��ܑ�� �� / mail/test/__pycache__/test_imap.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl m Z ddl m Z ddl mZmZmZmZ ddlmZ ddlmZ dd lmZmZ dd lmZ dd lm Z m Z m Z dd l m Z dd l!m"Z"m#Z# ddl$m%Z%m&Z&m'Z'm(Z( ddl)m*Z* ddl+m,Z, ddl-m.Z. ddl/m0Z0m1Z1m2Z2 ddl3m4Z4 ddl5m6Z6m7Z7m8Z8 ddl9m:Z:m;Z;m<Z< ddl=m>Z>m?Z? ddl@mAZAmBZB z ddlCmDZDmEZE W n eFy� dZDdZEY nw dd� ZGG dd � d eB�ZHG d d � d �ZIG d d � d eA�ZJG d!d"� d"eA�ZKG d#d$� d$eB�ZLee,jMe,jNe,jO�G d%d&� d&��ZPee,jMe,jN�G d'd(� d(��ZQG d)d*� d*e,jR�ZSG d+d,� d,eSe,jT�ZUG d-d.� d.e,jV�ZWG d/d0� d0e,jX�ZYG d1d2� d2�ZZG d3d4� d4eZeB�Z[G d5d6� d6eA�Z\G d7d8� d8eZeB�Z]ee"�G d9d:� d:��Z^G d;d<� d<�Z_G d=d>� d>eZeB�Z`G d?d@� d@eB�ZaG dAdB� dBeZeB�ZbG dCdD� dDeB�ZcG dEdF� dFe,jX�ZdG dGdH� dHeZeB�ZeG dIdJ� dJ�ZfG dKdL� dLef�ZgG dMdN� dNegeA�ZhG dOdP� dPegeA�ZiG dQdR� dRefeA�ZjG dSdT� dTefeA�ZkG dUdV� dVefeA�ZlG dWdX� dXefeB�ZmG dYdZ� dZefeA�ZnG d[d\� d\efeA�ZoG d]d^� d^e,jV�Zpee,jq�G d_d`� d`e8jr��ZsG dadb� dbeBeZ�ZtG dcdd� ddeB�ZuG dedf� dfeBeZ�ZvG dgdh� dheZeB�Zwee,jx�G didj� djeBeZ��ZyG dkdl� dl�Zzee,j{�G dmdn� dn��Z|ee,j}�G dodp� dp��Z~G dqdr� dreB�ZeeD ds�ee'��e(d� dt�G dudv� dveZeB���Z�G dwdx� dxeP�Z�G dydz� dzeZeB�Z�G d{d|� d|eB�Z�G d}d~� d~�Z�G dd�� d�eB�Z�G d�d�� d�eB�Z�G d�d�� d��Z�G d�d�� d�e�eA�Z�G d�d�� d�e�eB�Z�G d�d�� d�eA�Z�dS )�z" Test case for twisted.mail.imap4 � N)� OrderedDict��BytesIO)�chain)�List�Optional�Tuple�Type)�skipIf)� implementer)� verifyClass� verifyObject)�'InMemoryUsernamePasswordDatabaseDontUse)�CramMD5Credentials�IUsernameHashedPassword�IUsernamePassword��UnauthorizedLogin)�IRealm�Portal)�defer�error� interfaces�reactor)�Clock)�imap4)� MessageSet)�IChallengeResponse�IClientAuthentication�ICloseableMailboxIMAP)�loopback)�failure�log�util)� iterbytes� nativeString� networkString)�StringTransport� StringTransportWithDisconnection)�SynchronousTestCase�TestCase)�ClientTLSContext�ServerTLSContextc C s | fdd�S )Nc S s |� S �N� )�result�fr. r. �=/usr/lib/python3/dist-packages/twisted/mail/test/test_imap.py�<lambda>8 � zstrip.<locals>.<lambda>r. )r0 r. r. r1 �strip7 � r4 c @ sv e Zd Zddgddgddgddgd d ggZd d � Zd d� Zdd� Zdd� Zdd� Zdd� Z dd� Z dd� Z dd � Z d S ) �IMAP4UTF7Tests� Hello world� Hello worldz Hello & worlds Hello &- world� Helloÿworld� Hello&AP8-worldu ÿþýüs &AP8A,gD9APw-u ~peter/mail/日本語/台北s ~peter/mail/&ZeVnLIqe-/&U,BTFw-c C �" d}| � |�dd�|�d�� dS )z� Specifying an error policy to C{unicode.encode} with the I{imap4-utf-7} codec should produce the same result as not specifying the error policy. r7 � imap4-utf-7�strictN�� assertEqual�encode��self�textr. r. r1 �test_encodeWithErrorsG s �z$IMAP4UTF7Tests.test_encodeWithErrorsc C r; )zO Similar to L{test_encodeWithErrors}, but for C{bytes.decode}. r8 r< r= N�r? �decode�rB �bytesr. r. r1 �test_decodeWithErrorsR s �z$IMAP4UTF7Tests.test_decodeWithErrorsc C s d}| � |�d�d� dS )z� Unicode strings that contain an ampersand (C{&}) can be encoded to bytes with the I{imap4-utf-7} codec. u &Hello&½&r< s &-Hello&-&AL0-&-Nr> rA r. r. r1 �test_encodeAmpersand[ s �z#IMAP4UTF7Tests.test_encodeAmpersandc C s | � d�d�d� dS )z� An I{imap4-utf-7} encoded string that does not shift back to ASCII (i.e., it lacks a final C{-}) can be decoded. s &AL0r< � ½NrE �rB r. r. r1 �!test_decodeWithoutFinalASCIIShiftf s �z0IMAP4UTF7Tests.test_decodeWithoutFinalASCIIShiftc C s& t �d�td��}| �|�� d� dS )zl C{codecs.getreader('imap4-utf-7')} returns the I{imap4-utf-7} stream reader class. r< r: r9 N)�codecs� getreaderr r? �read)rB �readerr. r. r1 �test_getreaderp s z IMAP4UTF7Tests.test_getreaderc C s2 t � }t�d�|�}|�d� | �|�� d� dS )zl C{codecs.getwriter('imap4-utf-7')} returns the I{imap4-utf-7} stream writer class. r< r9 r: N)r rN � getwriter�writer? �getvalue)rB �output�writerr. r. r1 �test_getwriterx s z IMAP4UTF7Tests.test_getwriterc C s& | j D ] \}}| �|�d�|� qdS )z� The I{imap4-utf-7} can be used to encode a unicode string into a byte string according to the IMAP4 modified UTF-7 encoding rules. r< N)�testsr? r@ �rB �inputrV r. r. r1 � test_encode� � �zIMAP4UTF7Tests.test_encodec C s& | j D ] \}}| �||�d�� qdS )z� The I{imap4-utf-7} can be used to decode a byte string into a unicode string according to the IMAP4 modified UTF-7 encoding rules. r< N)rY r? rF rZ r. r. r1 � test_decode� r] zIMAP4UTF7Tests.test_decodec C s| t tdd�tdd��D ] }t|��� }| �|t|��d�� | �t|�|�d�� q | �d�d�d� | �d�d�d� dS ) z� The IMAP4 modified UTF-7 implementation encodes all printable characters which are in ASCII using the corresponding ASCII byte. � �& �' � r< �&s &-N)r �range�chrr@ r? rF )rB �o�charbyter. r. r1 �test_printableSingletons� s z'IMAP4UTF7Tests.test_printableSingletonsN) �__name__� __module__� __qualname__rY rD rI rJ rM rR rX r\ r^ rh r. r. r. r1 r6 ; s$ �� r6 c @ �, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �BufferingConsumerc C � g | _ d S r- )�bufferrL r. r. r1 �__init__� � zBufferingConsumer.__init__c C s$ | j �|� | jr| j�� d S d S r- )ro �append�consumer�resumeProducingrG r. r. r1 rT � s �zBufferingConsumer.writec C s || _ | j �� d S r- )rs rt )rB rs � streamingr. r. r1 �registerProducer� � z"BufferingConsumer.registerProducerc C s d | _ d S r- )rs rL r. r. r1 �unregisterProducer� rq z$BufferingConsumer.unregisterProducerN)ri rj rk rp rT rv rx r. r. r. r1 rm � s rm c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �MessageProducerTestsc sr d� t � }d|d< d|d< d|d< d|d < t|d d � d d �}t� �t�|������}� ���fd d �}|�|�S )Ns This is body text. Rar.� sender@host�from�recipient@domain�to�booga booga boo�subject� text/plain� content-typer. �{ c s( �� | �� ��d��j�d� � d S )N� sf {119} From: sender@host To: recipient@domain Subject: booga booga boo Content-Type: text/plain )�assertIdenticalr? �joinro �r/ ��body�c�prB r. r1 � cbProduced� s ��z7MessageProducerTests.testSinglePart.<locals>.cbProduced�r � FakeyMessagerm r �MessageProducer�beginProducing� addCallback)rB �headers�msg�dr� r. r� r1 �testSinglePart� s z#MessageProducerTests.testSinglePartc s� d}d�t � }d|d< d|d< d|d< d |d < t � }d |d< d |d < t|d d |dt|d d �d d �g�}t� � t�|����� �}� ���fdd�}|�|�S )Nr� �& Contained body message text. Squarge.rz r{ r| r} r~ r �%multipart/alternative; boundary="xyz"r� �this is subject textr� r. r� c �, �� | �� ��d�� j�d� d � d S )Nr� s� {239} From: sender@host To: recipient@domain Subject: booga booga boo Content-Type: multipart/alternative; boundary="xyz" --xyz Subject: this is subject text Content-Type: text/plain � --xyz-- ��failUnlessIdenticalr? r� ro r� �r� � innerBodyr� rB r. r1 r� � s � ��z<MessageProducerTests.testSingleMultiPart.<locals>.cbProducedr� �rB � outerBodyr� � innerHeadersr� r� r� r. r� r1 �testSingleMultiPart� s. � z(MessageProducerTests.testSingleMultiPartc s� d}d�d�t � }d|d< d|d< d|d < d |d < t � }d |d < d |d < t � }d|d < d|d < t|dd |dt|dd �d d �t|dd �d d �g�}t� � t�|����� �}� ����fdd�}|�|�S )Nr� r� �. Secondary <i>message</i> text of squarge body.rz r{ r| r} r~ r r� r� r� r� �<b>this is subject</b>� text/htmlr. r� c s4 �� | �� ��d�� j�d� d � d � d S )Nr� s� {354} From: sender@host To: recipient@domain Subject: booga booga boo Content-Type: multipart/alternative; boundary="xyz" --xyz Subject: this is subject text Content-Type: text/plain sE --xyz Subject: <b>this is subject</b> Content-Type: text/html r� r� r� �r� � innerBody1� innerBody2r� rB r. r1 r� s � � � ��z>MessageProducerTests.testMultipleMultiPart.<locals>.cbProducedr� )rB r� r� r� � innerHeaders2r� r� r� r. r� r1 �testMultipleMultiPart� s: �� z*MessageProducerTests.testMultipleMultiPartc s� d}d�t � }d|d< d|d< d|d< d |d < t � }d |d< d |d < t|d d|dt|d d�dd�g�}t� � t�|��dd� �_��� �}� ���fdd�}|�|�S )z> A boundary is generated if none is provided. r� r� rz r{ r| r} r~ r �multipart/alternativer� r� r� r. Nr� c S s t �d�S )Nz$aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa)�uuid�UUIDr. r. r. r1 r2 K � z?MessageProducerTests.test_multiPartNoBoundary.<locals>.<lambda>c r� )Nr� s {341} From: sender@host To: recipient@domain Subject: booga booga boo Content-Type: multipart/alternative; boundary="----=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" ------=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Subject: this is subject text Content-Type: text/plain s- ------=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-- r� r� r� r. r1 r� O s ���zAMessageProducerTests.test_multiPartNoBoundary.<locals>.cbProduced)r r� rm r r� �_uuid4r� r� r� r. r� r1 �test_multiPartNoBoundary1 s0 � z-MessageProducerTests.test_multiPartNoBoundaryc s� d}d�t � }d|d< d|d< d|d< d |d < t � }d |d< d |d < t|d d|dt|d d�dd�g�}t� � t�|����� �}� ���fdd�}|�|�S )z> A boundary without does not have them added. r� r� rz r{ r| r} r~ r z#multipart/alternative; boundary=xyzr� r� r� r. Nr� c r� )Nr� s� {237} From: sender@host To: recipient@domain Subject: booga booga boo Content-Type: multipart/alternative; boundary=xyz --xyz Subject: this is subject text Content-Type: text/plain r� r� r� r� r. r1 r� � s � ��z?MessageProducerTests.test_multiPartNoQuotes.<locals>.cbProducedr� r� r. r� r1 �test_multiPartNoQuotesf s. � z+MessageProducerTests.test_multiPartNoQuotesN)ri rj rk r� r� r� r� r� r. r. r. r1 ry � s -6 5ry c @ � e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&S )'�MessageSetTestsz" Tests for L{MessageSet}. c C s t � }t � }| �||� | �|d� |d }| �t|�d� | �t|�dg� |d }| �t|�d� | �t|�g d�� |d }| �||� | �t|| �g d�� |�d� | �t|�d� | �t|�g d�� | �||� |�d d � | �t|�d � | �t|�g d �� d S )a4 Test the following properties of L{MessageSet} addition and equality: 1. Two empty L{MessageSet}s are equal to each other; 2. A L{MessageSet} is not equal to any other object; 2. Adding a L{MessageSet} and another L{MessageSet} or an L{int} representing a single message or a sequence of L{int}s representing a sequence of message numbers produces a new L{MessageSet} that: 3. Has a length equal to the number of messages within each sequence of message numbers; 4. Yields each message number in ascending order when iterated over; 6. L{MessageSet.add} with a single message or a start and end message satisfies 3 and 4 above. r. � �r� � r� �r� � r� � � )r� r� r� r� � � � )r� r� r� r� r� r� r� N)r r? �assertNotEqual�len�list�add)rB �m1�m2r. r. r1 �!test_equalityIterationAndAddition� s( z1MessageSetTests.test_equalityIterationAndAdditionc C s | � tttdd�� dS )z� A L{MessageSet} that has a range that ends with L{None} raises a L{TypeError} when its length is requested. r� N)� assertRaises� TypeErrorr� r rL r. r. r1 � test_lengthWithWildcardRange� � z,MessageSetTests.test_lengthWithWildcardRangec C s t tdd�� dS )zD L{MessageSet.__repr__} does not raise an exception r� r� N)�reprr rL r. r. r1 �test_reprSanity� s z MessageSetTests.test_reprSanityc C sX t �d�t �d�t �dd�t �dd�g}g d�}t||�D ] \}}| �t|�|� q dS )z� In a L{MessageSet}, in the presence of wildcards, if the highest message id is known, the wildcard should get replaced by that high value. � *� 1:*s 3:*r� s *:2)�*�1:*z3:6z2:6N�r � parseIdList�zipr? �str�rB �inputs�outputs�irf r. r. r1 �&test_stringRepresentationWithWildcards� s ��z6MessageSetTests.test_stringRepresentationWithWildcardsc C sD t �d�t �d�g}ddg}t||�D ] \}}| �t|�|� qdS )z� In a L{MessageSet}, inverting the high and low numbers in a range doesn't affect the meaning of the range. For example, 3:2 displays just like 2:3, because according to the RFC they have the same meaning. � 2:3s 3:2�2:3Nr� r� r. r. r1 �&test_stringRepresentationWithInversion� s ���z6MessageSetTests.test_stringRepresentationWithInversionc C s> t d�}| �t|�d� | �t|�d� | �t|�dg� dS )z� Creating a L{MessageSet} with a single message number adds only that message to the L{MessageSet}; its serialized form includes only that message number, its length is one, and it yields only that message number. r� �1N�r r? r� r� r� �rB �mr. r. r1 �"test_createWithSingleMessageNumber s z2MessageSetTests.test_createWithSingleMessageNumberc C sB t dd�}| �t|�d� | �t|�d� | �t|�g d�� dS )a? Creating a L{MessageSet} with both a start and end message number adds the sequence between to the L{MessageSet}; its serialized form consists that range, its length is the length of the sequence, and it yields the message numbers inclusively between the start and end. r� � z1:10) r� r� r� r� r� r� r� r� � r� Nr� r� r. r. r1 �test_createWithSequence s z'MessageSetTests.test_createWithSequencec C s: t d�}| �t|�d� | �t|�d� | �tt|� dS )z� Creating a L{MessageSet} with a single L{None}, representing C{*}, adds C{*} to the range; its serialized form includes only C{*}, its length is one, but it cannot be iterated over because its endpoint is unknown. Nr� r� )r r? r� r� r� r� r� r� r. r. r1 � test_createWithSingleWildcard! s z-MessageSetTests.test_createWithSingleWildcardc C sH t d�}d|_| �t|�dg� t dd�}d|_| �t|�g d�� dS )z� Setting L{MessageSet.last} replaces L{None}, representing C{*}, with that number, making that L{MessageSet} iterable. Nr� r� r� r� )r �lastr? r� )rB �singleMessageReplaced� rangeReplacedr. r. r1 �test_setLastSingleWildcard- s z*MessageSetTests.test_setLastSingleWildcardc C s4 t dd�}|�dd� d|_| �t|�g d�� dS )zL Setting L{MessageSet.last} replaces L{None} in all ranges. r� Nr� r� �r� r� r� r� r� )r r� r� r? r� r� r. r. r1 � test_setLastWithWildcardRange: s z-MessageSetTests.test_setLastWithWildcardRangec C sF t dd�}d|_| �t�� d|_W d � dS 1 s w Y dS )z9 L{MessageSet.last} cannot be set twice. r� Nr� r� )r r� r� � ValueErrorr� r. r. r1 �test_setLastTwiceFailsC s "�z&MessageSetTests.test_setLastTwiceFailsc C sh t d�}d|_|�d� | �t|�ddg� | �t|d �g d�� |�dd� | �t|�g d�� dS )a Adding a L{None}, representing C{*}, or a sequence that includes L{None} to a L{MessageSet} whose L{last<MessageSet.last>} property has been set replaces all occurrences of L{None} with the value of L{last<MessageSet.last>}. r� r� N)Nr� )r� r� r� r� )r� r� r� )r r� r� r? r� )rB �hasLastr. r. r1 �test_lastOverridesNoneInAddL s z+MessageSetTests.test_lastOverridesNoneInAddc C s" t dd�}d|_| �|jd� dS )zF Accessing L{MessageSet.last} returns the last value. r� Nr� )r r� r? r� r. r. r1 � test_getLast_ s z MessageSetTests.test_getLastc C s� t � }|�d� | �t|�dg� t � }|�d� | �t|�d� t � }|�d� | �t|�g d�� t � }|�d� | �t|�d� t � }|�t dd�� | �t|�g d�� dS )z� L{MessageSet.extend} accepts as its arugment an L{int} or L{None}, or a sequence L{int}s or L{None}s of length two, or another L{MessageSet}, combining its argument with its instance's existing ranges. r� Nr� r� r� �NNr� )r �extendr? r� r� )rB � extendWithInt�extendWithNone�extendWithSequenceOfInts�extendWithSequenceOfNones�extendWithMessageSetr. r. r1 � test_extendg s zMessageSetTests.test_extendc C s� t dd�}t dd�t dd� }| �d|� | �d|� |d }| �t�� d|v W d � n1 s3w Y |d }|�dd� | �t�� d|v W d � dS 1 sWw Y dS ) z� A L{MessageSet} contains a number if the number falls within one of its ranges, and raises L{TypeError} if any range contains L{None}. r� r� r� r� r� N)r� � r� )r �assertIn� assertNotInr� r� r� )rB �hasFive�doesNotHaveFive�hasFiveButHasNone�hasFiveButHasNoneInSequencer. r. r1 � test_contains� s � "�z MessageSetTests.test_containsc C s� t dd�}t dd�}|| }|t dd� }| �t|d �g d�� | �t|d �g d �� | �t|d �g d �� | �t|d �g d�� | �t|d �g d�� | �t|t d� �g d�� dS )z� Adding a sequence of message numbers to a L{MessageSet} that begins or ends immediately before or after an existing sequence in that L{MessageSet}, or overlaps one, merges the two. r� r� r� r� r� r� )r� r� )r� r� r� r� )r� r� r� )r� r� )r� r� r� r� )r� r� )r� r� r� r� r� )r� r� r� r� r� r� r� r� r� )r� r� r� r� r� r� r� N)r r? r� )rB � mergeAfter� mergeBefore�mergeBetweenSequence�mergeBetweenNumberr. r. r1 �test_rangesMerged� s �z!MessageSetTests.test_rangesMergedc C sZ | � tdd�tdd�� | � ttdd��g d�� tdd�}d|_| � t|�ddg� dS )a� Test the C{seq-range} examples from Section 9, "Formal Syntax" of RFC 3501:: Example: 2:4 and 4:2 are equivalent and indicate values 2, 3, and 4. Example: a unique identifier sequence range of 3291:* includes the UID of the last message in the mailbox, even if that value is less than 3291. @see: U{http://tools.ietf.org/html/rfc3501#section-9} r� r� �r� r� r� i� Ni� )r? r r� r� r� r. r. r1 �test_seq_rangeExamples� s z&MessageSetTests.test_seq_rangeExamplesc C s� t d�t dd� t d� t dd� }d|_| �d�d d � |D ��d � t dd�t d d� }d |_| �d�dd � |D ��d� dS )a� Test the C{sequence-set} examples from Section 9, "Formal Syntax" of RFC 3501. In particular, L{MessageSet} reorders and coalesces overlaps:: Example: a message sequence number set of 2,4:7,9,12:* for a mailbox with 15 messages is equivalent to 2,4,5,6,7,9,12,13,14,15 Example: a message sequence number set of *:4,5:7 for a mailbox with 10 messages is equivalent to 10,9,8,7,6,5,4,5,6,7 and MAY be reordered and overlap coalesced to be 4,5,6,7,8,9,10. @see: U{http://tools.ietf.org/html/rfc3501#section-9} r� r� r� r� r� N� �,c s � � | ]}t |�V qd S r- �r� ��.0r� r. r. r1 � <genexpr>� � � z<MessageSetTests.test_sequence_setExamples.<locals>.<genexpr>z2,4,5,6,7,9,12,13,14,15r� r� c s r r- r r r. r. r1 r � r z4,5,6,7,8,9,10)r r� r? r� )rB �fromFifteenMessages�fromTenMessagesr. r. r1 �test_sequence_setExamples� s "�� z)MessageSetTests.test_sequence_setExamplesN)ri rj rk �__doc__r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r. r. r. r1 r� � s( 3 r� c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@dA� Z#dBdC� Z$dDdE� Z%dFdG� Z&dHdI� Z'dJdK� Z(dLdM� Z)dNdO� Z*dPdQ� Z+dRS )S�IMAP4HelperTestszA Tests for various helper utilities in the IMAP4 module. c C s t t�ddgd�� dS )zI L{imap4.Command}'s C{repr} does not raise an exception. s COMMANDs arg� extraN)r� r �CommandrL r. r. r1 �test_commandRepr� � z!IMAP4HelperTests.test_commandReprc sb d� t � �t� �}t�|������}� ���fdd�}�fdd�}|�|� |�|� |�|�S )Ns xyzxyzxyzxyzxyzxyzxyzxyzxyzxyzc s0 �� | �� ��dt� �� f d��j�� | S )Ns {%d} %br� )r� r? r� r� ro r� ��br� r� rB r. r1 r� � s z6IMAP4HelperTests.test_fileProducer.<locals>.cbProducedc s � � � | S r- )rt r� )r� r. r1 �cbResume� s z4IMAP4HelperTests.test_fileProducer.<locals>.cbResume)rm r r � FileProducerr� r� )rB r0 r� r� r r. r r1 �test_fileProducer� s z"IMAP4HelperTests.test_fileProducerc C s� dg d�ddggdg d�g d�gdg d �g d �gg}|D ]%\}}}t �|d �}|D ] }| �|�|�� q)|D ] }| �|�|�� q6q d S ) N� foo/%gum/bar�zfoo/barzoo/lalagum/barz foo/gumx/barz foo/gum/baz� foo/xgum/bar� foo/gum/bar� foo/x%x/bar��foo�barz fuz fuz fuzz foo/*/bar� foo/xyz/barz foo/xx/baz)� foo/xyx/bar� foo/xx/bar�foo/xxxxxxxxxxxxxx/bar�foo/xyz*abc/bar�r# z foo/abc/barzfoo/xyzab/cbarzfoo/xyza/bcbar�zfoo/xyzabc/barzfoo/xyz/abc/barzfoo/xyz/123/abc/bar�/�r �wildcardToRegexp� assertFalse�match� assertTrue�rB �cases�wildcard�fail�succeed�xr. r. r1 � test_wildcard s* ���� ��z IMAP4HelperTests.test_wildcardc C s� dg d�g d�gdg d�g d�gdg d�g d �gg}|D ]'\}}}t �|d �}|D ] }| �|�|�|� q)|D ] }| �|�|�|� q7q d S ) Nr r )r r z foo/x/gum/barr r )r$ r% r& z foo/x/x/barr' r( r) r+ r0 r. r. r1 �test_wildcardNoDelim s* ���� ��z%IMAP4HelperTests.test_wildcardNoDelimc C sL ddd�dfg}|D ]\}}t �|�}| �t|�d��t|�d��� q dS )z� L{imap4._formatHeaders} accepts a C{dict} of header name/value pairs and returns a string representing those headers in the standard multiline, C{":"}-separated format. �Value1�Value2)�Header1�Header2s" Header2: Value2 Header1: Value1 TN)r �_formatHeadersr? �sorted� splitlines)rB r1 r[ �expectedrV r. r. r1 �test_headerFormatter: s �� ��z%IMAP4HelperTests.test_headerFormatterc C s� g d�}ddgddgg d�g d�g d�g d�g d �g d �g d �g d �d gddgdgg d�dgg d�dgg d�dgg}g d�}|D ] }| � tjtj|� q@t||�D ] \}}| �t�|�|� qQd S )N)s Hello Worlds Hello "World!"s World "Hello" "How are you?"s "Hello world" How "are you?"s foo bar "baz buz" NILs foo bar "baz buz" "NIL"s foo NIL "baz buz" bars foo "NIL" "baz buz" bars "NIL" bar "baz buz" foos oo \"oo\" oos "oo \"oo\" oo"� oo oos "oo oo"� oo \t oos "oo \t oo"� oo \o oo� "oo \o oo"rC rD � Hello� Worlds World!)rF rE s How are you?)r8 s Hows are you?)� foo� bar� baz buzN)rG rH rI � NIL)rG NrI rH )rG rJ rI rH )rJ rH rI rG )� oos "oo"rK � oo "oo" oorK rA )rK s \trK rB )rK � \orK rC )s "mismatched quotes mismatched quote"s mismatched"quotes "oops here is" another")r� r �MismatchedQuoting� splitQuotedr� r? )rB r1 �answers�errors�s�caser? r. r. r1 �test_quotedSplitterM s6 ��z$IMAP4HelperTests.test_quotedSplitterc C s� g d�g d�g d�ddgdg d�dgddg d �gd dd d g d�d d dd g dg d �ddgg}d gg d�dgdgddgdgddggddgdgddgdgg}t ||�D ] \}}| �t�|�|� qPd S )N)� a� b� c� d� e) rU � � "rV rW rZ r[ rZ rX rY )rU rV rW rX rY rU )rV rW rX rV )rW rX rY r[ rZ )r[ rZ rV rW rZ rZ r[ s abcde)rU s bc � des abcr\ s bcds abs cdes a s es bc )r� r? r �collapseStrings)rB r1 rP rS r? r. r. r1 �test_stringCollapser� s& � � �z%IMAP4HelperTests.test_stringCollapserc s d� dgd �}� fdd�}|dt|�|f ddg d �g|g� |d d d gd ddddddg d�gg d�gg d�gg d�gg d�g d�gd d dg dddd d gd d d d d gg � |d!d"g� |d#d$g� |d%d&g� |d'd(g� |d'd(g� |d)d*d+g� |d)d*d+g� d S ),N� s xxr� c s t �| �}� �||g� d S r- )r �parseNestedParensr? )rS r? �parsedrL r. r1 �check� s z0IMAP4HelperTests.test_parenParser.<locals>.checks8 (BODY.PEEK[HEADER.FIELDS.NOT (subject bcc cc)] {%d} %b)� BODY.PEEKs HEADER.FIELDS.NOT)s subjects bccs ccs (FLAGS (\Seen) INTERNALDATE "17-Jul-1996 02:44:25 -0700" RFC822.SIZE 4286 ENVELOPE ("Wed, 17 Jul 1996 02:23:25 -0700 (PDT)" "IMAP4rev1 WG mtg summary and minutes" (("Terry Gray" NIL gray cac.washington.edu)) (("Terry Gray" NIL gray cac.washington.edu)) (("Terry Gray" NIL gray cac.washington.edu)) ((NIL NIL imap cac.washington.edu)) ((NIL NIL minutes CNRI.Reston.VA.US) ("John Klensin" NIL KLENSIN INFOODS.MIT.EDU)) NIL NIL <B27397-0100000@cac.washington.edu>) BODY (TEXT PLAIN (CHARSET US-ASCII) NIL NIL 7BIT 3028 92))� FLAGSs \Seens INTERNALDATEs 17-Jul-1996 02:44:25 -0700s RFC822.SIZEs 4286s ENVELOPEs% Wed, 17 Jul 1996 02:23:25 -0700 (PDT)s$ IMAP4rev1 WG mtg summary and minutes)s Terry GrayNs gray� cac.washington.edu)NNs imapre )NNs minutess CNRI.Reston.VA.US)s John KlensinNs KLENSINs INFOODS.MIT.EDUs# <B27397-0100000@cac.washington.edu>� BODYs TEXT� PLAIN� CHARSETs US-ASCIIs 7BITs 3028s 92s ("oo \"oo\" oo")rL s ("oo \\ oo")s oo \\ oos ("oo \ oo")s oo \ oos ("oo \o")s oo \os (oo \o)rK rM )r� r� )rB rR rb r. rL r1 �test_parenParser� s^ � ����� 2 z!IMAP4HelperTests.test_parenParserc C s� g d�g d�g d�g d�g d�g d�g d�g d�g d �g }|D ]5\}}}|� d �}t�� }|�|� | �t|j�d � | �t|jd t ||��� | �t |jd �|� q d S ) N)�ENVELOPE�Envelope�envelope)�FLAGS�Flags�flags)� INTERNALDATE� InternalDate� internaldate)� RFC822.HEADER� RFC822Headerz rfc822.header)� RFC822.SIZE� RFC822Sizez rfc822.size)� RFC822.TEXT� RFC822Textz rfc822.text)�RFC822ry �rfc822)�UIDr{ �uid)� BODYSTRUCTURE� BodyStructure� bodystructure�asciir� r ) r@ r � _FetchParser� parseStringr? r� r/ r/ � isinstance�getattrr� )rB r1 �inp�outp�asStringr� r. r. r1 �test_fetchParserSimple� s$ � �z'IMAP4HelperTests.test_fetchParserSimplec C s� ddg d�fgddg d�fgddg d �fgg}|D ]2\}}t �� }|�|� | �t|j�|d � d d � |jD �}|�� |d �� | �||d � qd S )Ns ALLr� )� flags� internaldate� rfc822.size� envelopes FULLr� )r� r� r� r� s bodys FASTr� )r� r� r� r c S s g | ] }t |��� �d ��qS )r� )r� �lowerr@ )r �tokenr. r. r1 � <listcomp> s z;IMAP4HelperTests.test_fetchParserMacros.<locals>.<listcomp>r� )r r� r� r? r� r/ �sort)rB r1 r� r� r� �expectedResultr. r. r1 �test_fetchParserMacros s �� �z'IMAP4HelperTests.test_fetchParserMacrosc C s� t j}|� }|�d� | �t|j�d� | �t|jd |j�� | �|jd j d� | �|jd j d � | �t |jd �d� |� }|�d� | �t|j�d� | �t|jd |j�� | �|jd j d� | �t |jd �d� |� }|�d� | �t|j�d� | �t|jd |j�� | �|jd j d� | �t |jd �d � |� }|�d � | �t|j�d� | �t|jd |j�� | �|jd j d� | �t|jd j |j �� | �|jd j jd� | �|jd j jd � | �|jd j d� | �t |jd �d � |� }|�d � | �t|j�d� | �t|jd |j�� | �|jd j d� | �t|jd j |j �� | �|jd j jd� | �|jd j jd � | �|jd j d� | �t |jd �d � |� }|�d� | �t|j�d� | �t|jd |j�� | �|jd j d� | �t|jd j |j �� | �|jd j jd� | �|jd j jg d�� | �|jd j d� | �t|jd �d� |� }|�d� | �t|j�d� | �t|jd |j�� | �|jd j d� | �t|jd j |j �� | �|jd j jd� | �|jd j jg d�� | �|jd j d� | �t|jd �d� |� }|�d� | �t|j�d� | �t|jd |j�� | �|jd j d� | �t|jd j |j �� | �|jd j jd� | �|jd j jg d�� | �|jd j d� | �t|jd �d� |� }|�d� | �t|j�d� | �t|jd |j�� | �|jd j d� | �t|jd j|j�� | �|jd jd� | �|jd jd� | �|jd jd� | �|jd j d� | �t|jd �d� |� }|�d� | �t|j�d� | �t|jd |j�� | �|jd j d� | �t|jd j |j �� | �|jd jd� | �|jd j jddg� | �|jd jd� | �|jd jd � | �|jd j d� | �t|jd �d � d S ) Nrf r� r F�BODYrc Ts BODY[]zBODY[]s BODY[HEADER]r. z BODY[HEADER]s BODY.PEEK[HEADER]s+ BODY[HEADER.FIELDS (Subject Cc Message-Id)])s SUBJECTs CC� MESSAGE-IDs0 BODY.PEEK[HEADER.FIELDS (Subject Cc Message-Id)]s4 BODY.PEEK[HEADER.FIELDS.NOT (Subject Cc Message-Id)]s/ BODY[HEADER.FIELDS.NOT (Subject Cc Message-Id)]s BODY[1.MIME]<10.50>�r r� �2 s? BODY.PEEK[1.3.9.11.HEADER.FIELDS.NOT (Message-Id Date)]<103.69>)r r� r� r� r� s DATE�g �E s: BODY[1.3.9.11.HEADER.FIELDS.NOT (Message-Id Date)]<103.69>)r r� r� r? r� r/ r/ r� �Body�peek�headerr� �empty�Header�negate�fieldsrH �mime�MIME�part� partialBegin� partialLength)rB �Pr� r. r. r1 �test_fetchParserBody s� � � � � �z%IMAP4HelperTests.test_fetchParserBodyc C s| t �� }|�d� | �t|j�d� | �|jd jd� | �|jd |j� | �|jd j |j � | �t |jd �d� dS )z� Parsing a C{BODY} whose C{HEADER} values require quoting results in a object that perserves that quoting when serialized. s BODY[HEADER.FIELDS ((Quoted)]r� r Fs BODY[HEADER.FIELDS ("(Quoted")]N) r r� r� r? r� r/ r� �assertIsInstancer� r� r� rH �rB r� r. r. r1 � test_fetchParserQuotedHeader� s z-IMAP4HelperTests.test_fetchParserQuotedHeaderc C s& t �� }|�d� | �t|j�� dS )z= Parsing an empty string results in no data. r� N)r r� r� r- r� r/ r� r. r. r1 �test_fetchParserEmptyString� s z,IMAP4HelperTests.test_fetchParserEmptyStringc C � t �� }| �t|jd� dS )z\ Parsing a string with an unknown attribute raises an L{Exception}. s UNKNOWNN�r r� r� � Exceptionr� r� r. r. r1 � test_fetchParserUnknownAttribute� � z1IMAP4HelperTests.test_fetchParserUnknownAttributec C r� )zf Parsing a string that prematurely ends in whitespace raises an L{Exception}. s BODY[HEADER.FIELDS Nr� r� r. r. r1 �0test_fetchParserIncompleteStringEndsInWhitespace� r� zAIMAP4HelperTests.test_fetchParserIncompleteStringEndsInWhitespacec C r� )z Parsing a string that contains an unexpected character rather than whitespace raises an L{Exception}. s BODY[HEADER.FIELDS!]Nr� r� r. r. r1 �"test_fetchParserExpectedWhitespace� r� z3IMAP4HelperTests.test_fetchParserExpectedWhitespacec C s| t �� }|�d� | �t|j�d� | �|jd |j� | �|jd jd� | �|jd j |j � | �t |jd �d� dS )z: A C{BODY} can contain a C{TEXT} section. s BODY[TEXT]r� r FN) r r� r� r? r� r/ r� r� r� rC �TextrH r� r. r. r1 �test_fetchParserTextSection� s z,IMAP4HelperTests.test_fetchParserTextSectionc C r� )z[ Parsing a C{BODY} with an unknown section raises an L{Exception}. s BODY[UNKNOWN]Nr� r� r. r. r1 � test_fetchParserUnknownSection� r� z/IMAP4HelperTests.test_fetchParserUnknownSectionc C �4 t �� }| �t|jd� t �� }| �t|jd� dS )ze Parsing a C{BODY} with an unterminated section list raises an L{Exception}. s BODY[HEADERs BODY[HEADER.FIELDS (SUBJECT)Nr� r� r. r. r1 �#test_fetchParserMissingSectionClose� s z4IMAP4HelperTests.test_fetchParserMissingSectionClosec C r� )z� Parsing a C{BODY} whose C{HEADER.FIELDS} list does not begin with an open parenthesis (C{(}) or end with a close parenthesis (C{)}) raises an L{Exception}. s BODY[HEADER.FIELDS Missing)]s BODY[HEADER.FIELDS (Missing]Nr� r� r. r. r1 �(test_fetchParserHeaderMissingParentheses� s z9IMAP4HelperTests.test_fetchParserHeaderMissingParenthesesc C r� )zk Parsing a C{BODY} with a range that lacks a period (C{.}) raises an L{Exception}. s BODY<01>Nr� r� r. r. r1 � test_fetchParserDotlessPartial� r� z/IMAP4HelperTests.test_fetchParserDotlessPartialc C r� )z� Parsing a C{BODY} with a partial range that's missing its closing greater than sign (C{>}) raises an L{EXCEPTION}. s BODY<0Nr� r� r. r. r1 � test_fetchParserUnclosedPartial� r� z0IMAP4HelperTests.test_fetchParserUnclosedPartialc C s. dddt d�ddg}d}| �t�|�|� d S )Nr! r" �baz� this is a file �buz�bizs4 "foo" "bar" "baz" {16} this is a file "buz" "biz")r r? r �collapseNestedLists)rB �inputStructurerV r. r. r1 � test_files� s � zIMAP4HelperTests.test_filesc C s< dt �d�dtd�dt �d�dg}d}| �t �|�|� d S ) NrG rH s bazr� s this is quoteds buzr� sC "foo" bar "baz" {16} this is a file {15} this is quoted buz "")r � DontQuoteMer r? r� rZ r. r. r1 �test_quoteAvoider� s � �z"IMAP4HelperTests.test_quoteAvoiderc C s2 ddggfg}|D ] \}}| � t�|�|� q d S )Ns ({10} 0123456789)s 0123456789)r? r r` )rB r1 rS r? r. r. r1 � test_literals s � �z IMAP4HelperTests.test_literalsc C s� t jdd�t jdddd�t �t jdd�t jdd��t jdd�t �t jdd�t jdd�t jdd��t �t �t �t jdd d d �t jdd d d�t jddddd�t �t jdd����t �t jdd���g}g d�}t||�D ] \}}| �||� qjd S )Nr� )�flagged)r= � unflagged�deleted)r� �today)�before)�unseen)�new� yesterdayi� )r= �since�smaller�tuesdayi' )r= r� �larger)r= r� r� r� �spam)r z1:5�r| )�FLAGGEDz(DELETED UNFLAGGED)z(OR FLAGGED DELETED)z(BEFORE "today")z (OR DELETED (OR UNSEEN NEW))z�(OR (NOT (OR (SINCE "yesterday" SMALLER 1000) (OR (BEFORE "tuesday" LARGER 10000) (OR (BEFORE "today" DELETED UNSEEN) (NOT (SUBJECT "spam")))))) (NOT (UID 1:5))))r �Query�Or�Notr� r? )rB r� r� �queryr? r. r. r1 �test_queryBuilder s* $���� �z"IMAP4HelperTests.test_queryBuilderc C � t jdd�}| �d|� dS )z� When passed the C{keyword} argument, L{imap4.Query} returns an unquoted string. @see: U{http://tools.ietf.org/html/rfc3501#section-9} @see: U{http://tools.ietf.org/html/rfc3501#section-6.4.4} �twisted)�keywordz(KEYWORD twisted)N�r r� r? �rB r� r. r. r1 � test_queryKeywordFlagWithQuotes> � z0IMAP4HelperTests.test_queryKeywordFlagWithQuotesc C r� )z� When passed the C{unkeyword} argument, L{imap4.Query} returns an unquoted string. @see: U{http://tools.ietf.org/html/rfc3501#section-9} @see: U{http://tools.ietf.org/html/rfc3501#section-6.4.4} r� )� unkeywordz(UNKEYWORD twisted)Nr� r� r. r. r1 �!test_queryUnkeywordFlagWithQuotesI r� z2IMAP4HelperTests.test_queryUnkeywordFlagWithQuotesc C s$ t jt �dd�d�}| �|d� dS )z� When passed a L{MessageSet}, L{imap4.Query} returns a query containing a quoted string representing the ID sequence. r� N��messagesz(MESSAGES "1:*"))r r� r r? r� r. r. r1 �test_queryWithMesssageSetT s z*IMAP4HelperTests.test_queryWithMesssageSetc C s t jdd�}| �|d� dS )zl When passed an L{int}, L{imap4.Query} returns a query containing a quoted integer. r� r� z(MESSAGES "1")Nr� r� r. r. r1 �test_queryWithInteger\ s z&IMAP4HelperTests.test_queryWithIntegerc C s | � tjtjtjdd�� dS )zq An L{imap4.Or} query with less than two arguments raises an L{imap4.IllegalQueryError}. r� r� N)r� r �IllegalQueryErrorr� r� rL r. r. r1 �test_queryOrIllegalQueryd s z)IMAP4HelperTests.test_queryOrIllegalQueryc C sn | � d|�� � d�tjd i |di��� | � d|�� � d�tjd i |dd�dd� td�D ��f i��� d S ) z� Helper to implement tests for value filtering of KEYWORD and UNKEYWORD queries. @param keyword: A native string giving the name of the L{imap4.Query} keyword argument to test. �(z twistedrocks)ztwisted (){%*"\] rocksztwisted %s rocks� c s r r- )re )r �chr. r. r1 r r z9IMAP4HelperTests._keywordFilteringTest.<locals>.<genexpr>�! Nr. )r? �upperr r� r� rd )rB r� r. r. r1 �_keywordFilteringTestk s �����z&IMAP4HelperTests._keywordFilteringTestc C � | � d� dS )a� When passed the C{keyword} argument, L{imap4.Query} returns an C{atom} that consists of one or more non-special characters. List of the invalid characters: ( ) { % * " \ ] CTL SP @see: U{ABNF definition of CTL and SP<https://tools.ietf.org/html/rfc2234>} @see: U{IMAP4 grammar<http://tools.ietf.org/html/rfc3501#section-9>} @see: U{IMAP4 SEARCH specification<http://tools.ietf.org/html/rfc3501#section-6.4.4>} r� N�r� rL r. r. r1 �test_queryKeywordFlag� � z&IMAP4HelperTests.test_queryKeywordFlagc C r� )a� When passed the C{unkeyword} argument, L{imap4.Query} returns an C{atom} that consists of one or more non-special characters. List of the invalid characters: ( ) { % * " \ ] CTL SP @see: U{ABNF definition of CTL and SP<https://tools.ietf.org/html/rfc2234>} @see: U{IMAP4 grammar<http://tools.ietf.org/html/rfc3501#section-9>} @see: U{IMAP4 SEARCH specification<http://tools.ietf.org/html/rfc3501#section-6.4.4>} r� Nr� rL r. r. r1 �test_queryUnkeywordFlag� r� z(IMAP4HelperTests.test_queryUnkeywordFlagc C �* g d�}|D ] }| � tjtj|d� qdS )z| Trying to parse an invalid representation of a sequence range raises an L{IllegalIdentifierError}. )s *:*rG s 4:s bar:5�90 N�r� r �IllegalIdentifierErrorr� �rB r� r[ r. r. r1 �test_invalidIdListParser� s ��z)IMAP4HelperTests.test_invalidIdListParserc C r� )z� Zeroes and negative values are not accepted in id range expressions. RFC 3501 states that sequence numbers and sequence ranges consist of non-negative numbers (RFC 3501 section 9, the seq-number grammar item). )s 0:5s 0:0s *:0� 0s -3:5s 1:-2s -1r� Nr� r� r. r. r1 �#test_invalidIdListParserNonPositive� s ��z4IMAP4HelperTests.test_invalidIdListParserNonPositivec C sZ g d�}t dd�t dd�t dd�t dd� t dd�t d�t dd�t d�t d� t d� t dd�t dd�t dd�t dd � t d�t dd� t d�t dd� t d d � t dd�t d � t d d � t dd �g}g d �}t||�D ] \}}| �t�|�|� qmt||�D ]*\}}|du r�| �ttt�|�� q�tt�|��}| �||d|�d|�d|��� q�dS )zi The function to parse sequence ranges yields appropriate L{MessageSet} objects. )r� s 5:*s 1:2,5:*r� � 1s 1,2s 1,3,5s 1:10s 1:10,11s 1:5,10:20s 1,5:10s 1,5:10,15:20s 1:10,15,20:25� 4:2r� Nr� r� r� r� � � r � r� )NNNr� r� r� r� r� r� � r� � � r� zlen(z) = z != )r r� r? r r� r� r� r� )rB r� r� �lengthsr[ r? �Lr. r. r1 �test_parseIdList� s2 �"�z!IMAP4HelperTests.test_parseIdListc C s | � ttjd� dS )zu L{imap4.parseTime} raises L{ValueError} when given a a time string whose format is invalid. �invalidN�r� r� r � parseTimerL r. r. r1 �test_parseTimeInvalidFormat� s z,IMAP4HelperTests.test_parseTimeInvalidFormatc C s& g d�}|D ] }| � ttj|� qdS )zv L{imap4.parseTime} raises L{ValueError} when given a time string composed of invalid values. )zinvalid-July-2017z2-invalid-2017z2-July-invalidNr )rB �invalidStringsr r. r. r1 �test_parseTimeInvalidValues� s �z,IMAP4HelperTests.test_parseTimeInvalidValuesc C sJ t � }|�� |�� |�� |�� |�� d�}t�||�� �}| � ||� dS )z� L{imap4.statusRequestHelper} builds a L{dict} mapping the requested status names to values extracted from the provided L{IMailboxIMAP}'s. )�MESSAGES�RECENT�UIDNEXT� UIDVALIDITY�UNSEENN) � SimpleMailbox�getMessageCount�getRecentCount� getUIDNext�getUIDValidity�getUnseenCountr �statusRequestHelper�keysr? )rB �mboxr? r/ r. r. r1 �test_statusRequestHelper s �z)IMAP4HelperTests.test_statusRequestHelperN),ri rj rk r r r r6 r7 r@ rT r^ ri r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r. r. r. r1 r � sT :Ot # 3 r c @ s� e Zd ZU dZg Zeeeeee f e d< dZ dZ dZ dd� Zdd � Zd d � Zd d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd)d d �Zd d � Zd!d"� Zd#d$� Z d%d&� Z d'd(� Z d S )*r �z\Flag1�Flag2z\AnotherSysFlag�LastFlagr� r r� Fc C � g | _ | j j| _| j j| _d S r- �� listenersrr � addListener�remove�removeListenerrL r. r. r1 rp � zSimpleMailbox.__init__c C � | j S r- �ro rL r. r. r1 �getFlags$ � zSimpleMailbox.getFlagsc C � dS )N�* r. rL r. r. r1 r ' � z SimpleMailbox.getUIDValidityc C � t | j�d S �Nr� �r� r� rL r. r. r1 r * � zSimpleMailbox.getUIDNextc C r( )Nr� r. rL r. r. r1 r - r* z SimpleMailbox.getMessageCountc C r( )Nr� r. rL r. r. r1 r 0 r* z SimpleMailbox.getRecentCountc C r( )Nr� r. rL r. r. r1 r 3 r* z SimpleMailbox.getUnseenCountc C r$ r- ��rwrL r. r. r1 � isWriteable6 r' zSimpleMailbox.isWriteablec C � d S r- r. rL r. r. r1 �destroy9 r* zSimpleMailbox.destroyc C r( )Nr* r. rL r. r. r1 �getHierarchicalDelimiter< r* z&SimpleMailbox.getHierarchicalDelimiterc C �v i }d|v r | � � |d< d|v r| �� |d< d|v r"| � � d |d< d|v r,| �� |d< d|v r6| �� |d< t�|�S )Nr r r r� r r �r r �getUIDr r r4 �rB �names�rr. r. r1 � requestStatus? s zSimpleMailbox.requestStatusNc C s. | j �|||| jf� | jd7 _t�d �S r, �r� rr �mUIDr r4 �rB �messagero �dater. r. r1 � addMessageM s zSimpleMailbox.addMessagec C �J g }| j D ] }d|d v r|�|� q|D ]}| j �|� qdd� |D �S )N�\Deletedr� c S � g | ]}|d �qS �r� r. r r. r. r1 r� Y � z)SimpleMailbox.expunge.<locals>.<listcomp>�r� rr r! �rB �deleter� r. r. r1 �expungeR s �zSimpleMailbox.expungec C s d| _ d S �NT)�closedrL r. r. r1 �close[ rq zSimpleMailbox.closec C r2 r- r. �rB r� r| r. r. r1 �fetch^ � zSimpleMailbox.fetchc C r2 r- r. �rB r? r. r. r1 r7 b rP zSimpleMailbox.getUIDc C r2 r- r. �rB r� ro �moder| r. r. r1 �storef rP zSimpleMailbox.storer- ) ri rj rk ro r� r r rH r� �int�__annotations__r= r0 rL rp r& r r r r r r1 r3 r4 r; rA rJ rM rO r7 rT r. r. r. r1 r s. r c @ s� e Zd ZU dZdZg Zeeee ee f e d< dZ dZ dZdd� Zd d � Zd d � Zd d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd(d d �Zd d!� Zd"d#� Z d$d%� Z d&d'� Z d S ))�UncloseableMailboxz* A mailbox that cannot be closed. r r� r r� Fc C r r- r rL r. r. r1 rp w r# zUncloseableMailbox.__init__c C r$ )zB The flags @return: A sequence of flags. r% rL r. r. r1 r& | � zUncloseableMailbox.getFlagsc C r( )zF The UID validity value. @return: The value. r) r. rL r. r. r1 r � � z!UncloseableMailbox.getUIDValidityc C r+ )z: The next UID. @return: The UID. r� r- rL r. r. r1 r � � z UncloseableMailbox.getUIDNextc C r( )zG The number of messages. @return: The number. r� r. rL r. r. r1 r � rY z"UncloseableMailbox.getMessageCountc C r( )�D The recent messages. @return: The number. r� r. rL r. r. r1 r � rY z!UncloseableMailbox.getRecentCountc C r( )r[ r� r. rL r. r. r1 r � rY z!UncloseableMailbox.getUnseenCountc C r$ )z` The recent messages. @return: Whether or not the mailbox is writable. r/ rL r. r. r1 r1 � rX z UncloseableMailbox.isWriteablec C r( )z' Destroy this mailbox. Nr. rL r. r. r1 r3 � s zUncloseableMailbox.destroyc C r( )zU Return the hierarchical delimiter. @return: The delimiter. r* r. rL r. r. r1 r4 � rY z+UncloseableMailbox.getHierarchicalDelimiterc C r5 )z� Return the mailbox's status. @param names: The status items to include. @return: A L{dict} of status data. r r r r� r r r6 r8 r. r. r1 r; � s z UncloseableMailbox.requestStatusNc C s. | j �|||| jf� | jd7 _t�d�S )a Add a message to the mailbox. @param message: The message body. @param flags: The message flags. @param date: The message date. @return: A L{Deferred} that fires when the message has been added. r� Nr< r> r. r. r1 rA � s z UncloseableMailbox.addMessagec C rB )zj Delete messages marked for deletion. @return: A L{list} of deleted message IDs. rC r� c S rD rE r. r r. r. r1 r� � rF z.UncloseableMailbox.expunge.<locals>.<listcomp>rG rH r. r. r1 rJ � s �zUncloseableMailbox.expungec C r2 r- r. rN r. r. r1 rO � rP zUncloseableMailbox.fetchc C r2 r- r. rQ r. r. r1 r7 � rP zUncloseableMailbox.getUIDc C r2 r- r. rR r. r. r1 rT � rP zUncloseableMailbox.storer- ) ri rj rk r ro r� r r rH r� rU rV r= r0 rL rp r& r r r r r r1 r3 r4 r; rA rJ rO r7 rT r. r. r. r1 rW k s. rW c @ s& e Zd ZdZeZdd� Zddd�ZdS ) �AccountWithoutNamespaceszL An in-memory account that does not provide L{INamespacePresenter}. c C � | � � S r- )�mailboxFactory)rB �name�idr. r. r1 � _emptyMailbox � z&AccountWithoutNamespaces._emptyMailboxr� c C s t j�| |�}|d ur||_|S r- )r � MemoryAccount�selectr0 )rB r_ r0 r r. r. r1 rd s z AccountWithoutNamespaces.selectN�r� )ri rj rk r r r^ ra rd r. r. r. r1 r\ s r\ c @ � e Zd ZdZdS )�AccountzD An in-memory account that provides L{INamespacePresenter}. N�ri rj rk r r. r. r. r1 rg � rg c @ s$ e Zd Zed�Zdd� Zdd� ZdS )� SimpleServer� testuserc O s^ t jj| g|�R i |�� t| d�}t|�}t� }|�dd� || _|| _|� |� d| _ d S )N�� accountHolderrk � password-testF) r � IMAP4Serverrp � TestRealmr r �addUser�checker�portal�registerChecker� timeoutTest)rB �args�kw�realmrs r� r. r. r1 rp s zSimpleServer.__init__c C s | j rd S tj�| |� d S r- )ru r ro � lineReceived�rB �liner. r. r1 ry ( s zSimpleServer.lineReceivedN)ri rj rk rg � theAccountrp ry r. r. r. r1 rj s rj c @ s6 e Zd Zd dd�Zdd� Zdd� Zdd � Zd d � ZdS ) � SimpleClientNc C s t j�| |� || _g | _d S r- )r � IMAP4Clientrp �deferred�events)rB r �contextFactoryr. r. r1 rp 1 s zSimpleClient.__init__c C s | j �d � d S r- )r �callback)rB �capsr. r. r1 �serverGreeting6 � zSimpleClient.serverGreetingc C � | j �d|g� | j�� d S )N� modeChanged�r� rr � transport�loseConnection)rB � writeabler. r. r1 r� 9 � zSimpleClient.modeChangedc C r� )N� flagsChangedr� �rB �newFlagsr. r. r1 r� = r� zSimpleClient.flagsChangedc C s | j �d||g� | j�� d S )N� newMessagesr� )rB �exists�recentr. r. r1 r� A s zSimpleClient.newMessagesr- )ri rj rk rp r� r� r� r� r. r. r. r1 r} 0 s r} c @ s^ e Zd ZU dZee ed< dZee ed< dd� Z dd� Z dd � Z d d � Z d d � Z dd� ZdS )�IMAP4HelperMixinN� serverCTX� clientCTXc C sJ t �� }t| jd�| _t|| jd�| _|| _g t _ t d�}t |_ |t_ d S )N�r� rk )r �Deferredrj r� �serverr} r� �client� connectedr r� rg �mboxTyper| )rB r� r| r. r. r1 �setUpK s zIMAP4HelperMixin.setUpc C s | ` | `| `d S r- )r� r� r� rL r. r. r1 �tearDownV s zIMAP4HelperMixin.tearDownc C s | j j�� d S r- )r� r� r� )rB �ignorer. r. r1 � _cbStopClient[ r� z IMAP4HelperMixin._cbStopClientc C s0 | j j�� | jj�� t�|dt| � � d S )N� Problem with )r� r� r� r� r" �errr� )rB r! r. r. r1 � _ebGeneral^ s zIMAP4HelperMixin._ebGeneralc C s t �| j| j�S r- )r � loopbackAsyncr� r� rL r. r. r1 r c r� zIMAP4HelperMixin.loopbackc C s. |� tj� t|j�}t|�}| �||� dS )a. Assert that the provided failure is an L{IMAP4Exception} with the given message. @param failure: A failure whose value L{IMAP4Exception} @type failure: L{failure.Failure} @param expected: The expected failure message. @type expected: L{bytes} N)�trapr �IMAP4Exceptionr� �valuer� r? )rB r! r? r? r. r. r1 �assertClientFailureMessagef s z+IMAP4HelperMixin.assertClientFailureMessage)ri rj rk r� r r, rV r� r+ r� r� r� r� r r� r. r. r. r1 r� F s r� c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Z d5d6� Z d7d8� Z d9d:� Z d;d<� Z d=d>� Z!d?d@� Z"dAdB� Z#dCdD� Z$dEdF� Z%dGdH� Z&dIdJ� Z'dKdL� Z(dMdN� Z)dOdP� Z*dQdR� Z+dSdT� Z,dUdV� Z-dWdX� Z.dYdZ� Z/d[d\� Z0d]d^� Z1d_d`� Z2dadb� Z3dcdd� Z4dedf� Z5dgS )h�IMAP4ServerTestsc s^ i � � �fdd�}�j �t|����j�}t���� |g�}d d d d��|�� ��fdd��S )Nc � � �fdd�} �j �� �| �S )Nc � � � | � �jj�� d S r- ��updater� r� r� �r� �r� rB r. r1 �gotCaps} � zAIMAP4ServerTests.testCapability.<locals>.getCaps.<locals>.gotCaps�r� �getCapabilitiesr� �r� r� r. r1 �getCaps| � z0IMAP4ServerTests.testCapability.<locals>.getCaps)� IMAP4rev1� NAMESPACE� IDLEc � �� �� �S r- �r? ��_�r� r? rB r. r1 r2 � � z1IMAP4ServerTests.testCapability.<locals>.<lambda>)r� r� r4 � addErrbackr� r � gatherResultsr �rB r� �d1r� r. r� r1 �testCapabilityy s z IMAP4ServerTests.testCapabilityc sn i � t �jjd< � �fdd�}�j�t|����j�}t� �� � |g�}d d d dgd��|�� ��fdd��S )N� CRAM-MD5c r� )Nc r� r- r� r� r� r. r1 r� � r� zIIMAP4ServerTests.testCapabilityWithAuth.<locals>.getCaps.<locals>.gotCapsr� r� r� r. r1 r� � r� z8IMAP4ServerTests.testCapabilityWithAuth.<locals>.getCaps)r� r� r� � AUTHc r� r- r� r� �r� �expCaprB r. r1 r2 � r� z9IMAP4ServerTests.testCapabilityWithAuth.<locals>.<lambda>) r r� � challengersr� r� r4 r� r� r r� r r� r. r� r1 �testCapabilityWithAuth� s �z'IMAP4ServerTests.testCapabilityWithAuthc sD d� _ � fdd�}� j�t|���� j� � �� }|�� fdd��S )Nr c s$ � fdd�} � j �� �t| �� d S )Nc � d� _ d S r, )� loggedOutr. rL r. r1 � setLoggedOut� rq zAIMAP4ServerTests.testLogout.<locals>.logout.<locals>.setLoggedOut)r� �logoutr� r4 )r� rL r. r1 r� � s z+IMAP4ServerTests.testLogout.<locals>.logoutc s � � � jd�S r, )r? r� r� rL r. r1 r2 � � z-IMAP4ServerTests.testLogout.<locals>.<lambda>)r� r� r� r4 r� r� r )rB r� r� r. rL r1 � testLogout� s zIMAP4ServerTests.testLogoutc sD d � _ � fdd�}� j�t|���� j� � �� }|�� fdd��S )Nc s � fdd�} � j �� �| � d S )Nc s | � _ � jj�� d S r- )� responsesr� r� r� )r� rL r. r1 � setResponses� s z=IMAP4ServerTests.testNoop.<locals>.noop.<locals>.setResponses)r� �noopr� )r� rL r. r1 r� � s z'IMAP4ServerTests.testNoop.<locals>.noopc s � � � jg �S r- )r? r� r� rL r. r1 r2 � r� z+IMAP4ServerTests.testNoop.<locals>.<lambda>)r� r� r� r4 r� r� r )rB r� r� r. rL r1 �testNoop� s zIMAP4ServerTests.testNoopc sB � fdd�}� j �t|���� j�}t�|� �� g�}|�� j�S )Nc � � j �dd�} | �� j� d S �Nrk rn )r� �loginr� r� �r� rL r. r1 r� � � z)IMAP4ServerTests.testLogin.<locals>.login) r� r� r4 r� r� r r� r � _cbTestLogin�rB r� r� r� r. rL r1 � testLogin� s zIMAP4ServerTests.testLoginc C �& | � | jjtj� | � | jjd� d S �N�auth�r? r� �accountrj r| �state�rB �ignoredr. r. r1 r� � � z IMAP4ServerTests._cbTestLoginc sF � fdd�}� j �t|���� j�}� �� }t�||g�}|�� j�S )Nc r� �Nrk s wrong-password�r� r� �addBothr� r� rL r. r1 r� � r� z/IMAP4ServerTests.testFailedLogin.<locals>.login) r� r� r4 r� r� r r r� �_cbTestFailedLogin�rB r� r� �d2r� r. rL r1 �testFailedLogin� s z IMAP4ServerTests.testFailedLoginc C s$ | � | jjd � | � | jjd� d S )N�unauth)r? r� r� r� r� r. r. r1 r� � � z#IMAP4ServerTests._cbTestFailedLoginc sN d� j _� fdd�}� j�t|���� j�}� �� }t� ||g�}|�� j �S )zj Attempting to log into a server that has no L{Portal} results in a failed login. Nc r� r� r� r� rL r. r1 r� � r� z7IMAP4ServerTests.test_loginWithoutPortal.<locals>.login) r� rs r� r� r4 r� r� r r r� r� r� r. rL r1 �test_loginWithoutPortal� s z(IMAP4ServerTests.test_loginWithoutPortalc sZ dd� }|� j jj_� fdd�}� j�t|���� j�}� � � }t � ||g�}|�� j �S )z� The server responds with a C{BAD} response when its portal attempts to log a user in with checker that claims to support L{IAccount} but returns an an avatar interface that is not L{IAccount}. c _ s dddd� fS )Nz Not IAccountzNot an accountc S r2 r- r. r. r. r. r1 r2 � � zVIMAP4ServerTests.test_nonIAccountAvatar.<locals>.brokenRequestAvatar.<locals>.<lambda>r. )r� �__r. r. r1 �brokenRequestAvatar� r. zDIMAP4ServerTests.test_nonIAccountAvatar.<locals>.brokenRequestAvatarc r� r� r� r� rL r. r1 r� � r� z6IMAP4ServerTests.test_nonIAccountAvatar.<locals>.login) r� rs rx � requestAvatarr� r� r4 r� r� r r r� r� )rB r� r� r� r� r� r. rL r1 �test_nonIAccountAvatar� s z'IMAP4ServerTests.test_nonIAccountAvatarc s� G dd� dt �� � fdd�}|�j_�fdd�}�j�t|��}|��jd� |j� �fdd ��}|��j� |� �j � �� � }t � ||g�}|��j�S ) z� Any exception raised by L{IMAP4Server.authenticateLogin} that is not L{UnauthorizedLogin} is logged results in a C{BAD} response. c @ rf )zAIMAP4ServerTests.test_loginException.<locals>.UnexpectedException�2 An unexpected exception. Nrh r. r. r. r1 �UnexpectedException ri r� c � � d��)N�Whoopsr. )�user�passwd�r� r. r1 �raisesUnexpectedException rb zGIMAP4ServerTests.test_loginException.<locals>.raisesUnexpectedExceptionc � � j �dd�S r� �r� r� r. rL r. r1 r� r. z3IMAP4ServerTests.test_loginException.<locals>.logins Server error: Whoopsc � �� ��� �� d S r- �r/ �flushLoggedErrorsr� �r� rB r. r1 �assertErrorLogged s z?IMAP4ServerTests.test_loginException.<locals>.assertErrorLogged)r� r� �authenticateLoginr� r� r4 r� r� r� r� r� r r r� r� )rB r� r� r� r r� r� r. r r1 �test_loginException� s z$IMAP4ServerTests.test_loginExceptionc sP ddi� j j_� fdd�}� j�t|���� j�}t� � � � |g�}|�� j �S )N� {test}user� {test}passwordc s4 � j �dd�} | �tjdt� � � | �� j� d S )Nr r r� )r� r� r� r" r� r� r� r� r� rL r. r1 r� ! s z9IMAP4ServerTests.testLoginRequiringQuoting.<locals>.login) r� rr �usersr� r� r4 r� r� r r� r � _cbTestLoginRequiringQuotingr� r. rL r1 �testLoginRequiringQuoting s z*IMAP4ServerTests.testLoginRequiringQuotingc C r� r� r� r� r. r. r1 r * r� z-IMAP4ServerTests._cbTestLoginRequiringQuotingc s� d � _ � fdd�}� fdd�}� j�t|��}|�t|�� |�� j� � �� }t�||g�}|j� fdd��}|�� j ddggg g g� |S ) Nc r� r� r� r. rL r. r1 r� 1 r. z-IMAP4ServerTests.testNamespace.<locals>.loginc � � fdd�} � j �� �| �S )Nc � | � _ � �d � d S r- �� namespaceArgsr� �rv rL r. r1 � gotNamespace5 rw zGIMAP4ServerTests.testNamespace.<locals>.namespace.<locals>.gotNamespace�r� � namespacer� �r rL r. r1 r 4 � z1IMAP4ServerTests.testNamespace.<locals>.namespacec s2 � j D ]}|D ] }|D ]}� �|t� q qq� j S r- )r r� r� )r� � namespaces�pairr� rL r. r1 �assertAllPairsNativeStringsA s ��zCIMAP4ServerTests.testNamespace.<locals>.assertAllPairsNativeStringsr� r* ) r r� r� r4 r� r� r r r� r? )rB r� r r� r� r� r r. rL r1 � testNamespace. s z IMAP4ServerTests.testNamespacec s� t d�� j_d� _� fdd�}� fdd�}� j�t|��}|�t|�� |�� j� � � � }t � ||g�}|�� fdd�� |�� j g g g g� |S ) z� A mailbox that does not provide L{INamespacePresenter} returns empty L{list}s for its personal, shared, and user namespaces. rk Nc r� r� r� r. rL r. r1 r� T r. z<IMAP4ServerTests.test_mailboxWithoutNamespace.<locals>.loginc r )Nc r r- r r rL r. r1 r X rw zVIMAP4ServerTests.test_mailboxWithoutNamespace.<locals>.namespace.<locals>.gotNamespacer r rL r. r1 r W r z@IMAP4ServerTests.test_mailboxWithoutNamespace.<locals>.namespacec � � j S r- )r r� rL r. r1 r2 c r3 z?IMAP4ServerTests.test_mailboxWithoutNamespace.<locals>.<lambda>) r\ r� r| r r� r� r4 r� r� r r r� r? )rB r� r r� r� r� r. rL r1 � test_mailboxWithoutNamespaceL s z-IMAP4ServerTests.test_mailboxWithoutNamespacec sr t j�d� d � _� fdd�}� fdd�}� j�t|��}|�t|�� |�� j� � � � }t � ||g��� j �S )N� test-mailboxc r� r� r� r. rL r. r1 r� k r. z*IMAP4ServerTests.testSelect.<locals>.loginc �& � fdd�} � j �d�}|�| � |S )Nc r r- )� selectedArgsr� r rL r. r1 �selectedo rw z=IMAP4ServerTests.testSelect.<locals>.select.<locals>.selectedr )r� rd r� )r r� rL r. r1 rd n � z+IMAP4ServerTests.testSelect.<locals>.select) rj r| � addMailboxr r� r� r4 r� r� r r r� � _cbTestSelect)rB r� rd r� r� r. rL r1 � testSelectg s zIMAP4ServerTests.testSelectc s� � fdd�}� fdd�}� j �t|�� � j �t|�� � j �� jd� � j �� j� � j �� j� t�� j � � � g�}|j� fdd��}|S )zh A client that selects a mailbox that does not exist receives a C{NO} response. c r� r� r� r. rL r. r1 r� � r. z9IMAP4ServerTests.test_selectWithoutMailbox.<locals>.loginc � � j �d�S )Nr �r� rd r. rL r. r1 rd � r5 z:IMAP4ServerTests.test_selectWithoutMailbox.<locals>.select� No such mailboxc � � � � jj� d S r- )� assertIsNoner� r r� rL r. r1 �assertNoMailboxSelected� s zKIMAP4ServerTests.test_selectWithoutMailbox.<locals>.assertNoMailboxSelected) r� r� r4 r� r� r� r� r r� r )rB r� rd �connectionCompleter' r. rL r1 �test_selectWithoutMailbox} s z*IMAP4ServerTests.test_selectWithoutMailboxc C �: t jjd }| �| jj|� | �| jdddddd�� d S )N� TEST-MAILBOXr� r� r) r T��EXISTSr r rm � READ-WRITE)rj r| � mailboxesr? r� r r �rB r� r r. r. r1 r � � ��z IMAP4ServerTests._cbTestSelectc sv t j�d� d� _� fdd�}� fdd�}� j�t|��}|�t|�� |�� j� � � � }t � ||g�}|�� j �S )a� L{IMAP4Client.examine} issues an I{EXAMINE} command to the server and returns a L{Deferred} which fires with a C{dict} with as many of the following keys as the server includes in its response: C{'FLAGS'}, C{'EXISTS'}, C{'RECENT'}, C{'UNSEEN'}, C{'READ-WRITE'}, C{'READ-ONLY'}, C{'UIDVALIDITY'}, and C{'PERMANENTFLAGS'}. Unfortunately the server doesn't generate all of these so it's hard to test the client's handling of them here. See L{IMAP4ClientExamineTests} below. See U{RFC 3501<http://www.faqs.org/rfcs/rfc3501.html>}, section 6.3.2, for details. r Nc r� r� r� r. rL r. r1 r� � r. z,IMAP4ServerTests.test_examine.<locals>.loginc r )Nc r r- )� examinedArgsr� r rL r. r1 �examined� rw z@IMAP4ServerTests.test_examine.<locals>.examine.<locals>.examinedr )r� �examiner� )r3 r� rL r. r1 r4 � r z.IMAP4ServerTests.test_examine.<locals>.examine) rj r| r r2 r� r� r4 r� r� r r r� �_cbTestExamine)rB r� r4 r� r� r� r. rL r1 � test_examine� s z IMAP4ServerTests.test_examinec C r* )Nr+ r� r� r) r Fr, )rj r| r/ r? r� r r2 r0 r. r. r1 r5 � r1 z IMAP4ServerTests._cbTestExaminec s� d�d��fdd�� �fdd���fdd�}� ����fd d �}g �_ �j�t|���t|��}��� }t�||g�}|��j���S ) N)�testbox�test/boxztest/� test/box/box�INBOX)r7 r8 c � � j �d� d S r, �r/ rr r. rL r. r1 �cb� r� z'IMAP4ServerTests.testCreate.<locals>.cbc r; �Nr r< �r! rL r. r1 �eb� r� z'IMAP4ServerTests.testCreate.<locals>.ebc r� r� r� r. rL r. r1 r� � r. z*IMAP4ServerTests.testCreate.<locals>.loginc sB �� D ]} �j �| �}|�t� ����� q|��j�j� d S r- )r� �creater� r4 r� � addCallbacksr� r� )r_ r� �r= r@ r3 rB r4 r. r1 rA � s z+IMAP4ServerTests.testCreate.<locals>.create)r/ r� r� r4 r r r� � _cbTestCreate)rB r� rA r� r� r� r. rC r1 � testCreate� s zIMAP4ServerTests.testCreatec C sX | � | jdgt|� dgt|� � ttjj�}tg d��}| � |dd� |D �� d S )Nr� r )�inboxr7 r8 �testr9 c S � g | ]}|� � �qS r. �r� )r �ar. r. r1 r� � rF z2IMAP4ServerTests._cbTestCreate.<locals>.<listcomp>)r? r/ r� r= rj r| r/ )rB r� r4 r3 r rP r. r. r1 rD � s & z IMAP4ServerTests._cbTestCreatec � t j�d� � fdd�}� fdd�}� j�t|��}|�t|�� j� |�� j� j� � � � }t � ||g�}|�� fdd�� |S )N� delete/mec r� r� r� r. rL r. r1 r� � r. z*IMAP4ServerTests.testDelete.<locals>.loginc r" �NrL �r� rI r. rL r. r1 rI � r5 z+IMAP4ServerTests.testDelete.<locals>.deletec s � � ttjj�g �S r- )r? r� rj r| r/ r� rL r. r1 r2 rF z-IMAP4ServerTests.testDelete.<locals>.<lambda>� rj r| r r� r� r4 rB r� r� r r r� )rB r� rI r� r� r� r. rL r1 � testDelete� s �zIMAP4ServerTests.testDeletec s� t j�d� t j�d� � fdd�}� fdd�}� fdd�}� j�t|��}|�t|�� j� |�|� |�� j � � � � }t � ||g�}|�� fd d �� |S ) z� Attempting to delete a mailbox with hierarchically inferior names fails with an informative error. @see: U{https://tools.ietf.org/html/rfc3501#section-6.3.4} @return: A L{Deferred} with assertions. rI rL c r� r� r� r. rL r. r1 r� r. zGIMAP4ServerTests.testDeleteWithInferiorHierarchicalNames.<locals>.loginc r" �NrI rN r. rL r. r1 rI r5 zHIMAP4ServerTests.testDeleteWithInferiorHierarchicalNames.<locals>.deletec s& | � tj� � �t| j�td�� d S )Ns- Name "DELETE" has inferior hierarchical names)r� r r� r? r� r� r? rL r. r1 �assertIMAPException s �zUIMAP4ServerTests.testDeleteWithInferiorHierarchicalNames.<locals>.assertIMAPExceptionc s � � ttjj�ddg�S )N�DELETEz DELETE/ME)r? r= rj r| r/ r� rL r. r1 r2 + s �zJIMAP4ServerTests.testDeleteWithInferiorHierarchicalNames.<locals>.<lambda>) rj r| r r� r� r4 rB r� r� r� r r r� )rB r� rI rR �loggedIn� loopedBackr� r. rL r1 �'testDeleteWithInferiorHierarchicalNames s �z8IMAP4ServerTests.testDeleteWithInferiorHierarchicalNamesc � d � _ � fdd�}� fdd�}� fdd�}� j�t|��}|�t|�� j� |�|� |�� j� j� � �� }t � ||g�}|�� fdd�� |S ) Nc r� r� r� r. rL r. r1 r� 4 r. z6IMAP4ServerTests.testIllegalInboxDelete.<locals>.loginc r" )NrF rN r. rL r. r1 rI 7 r5 z7IMAP4ServerTests.testIllegalInboxDelete.<locals>.deletec � | � _ d S r- ��stashedr� rL r. r1 �stash: rq z6IMAP4ServerTests.testIllegalInboxDelete.<locals>.stashc � � � t� jtj��S r- �r/ r� rZ r! �Failurer� rL r. r1 r2 D rF z9IMAP4ServerTests.testIllegalInboxDelete.<locals>.<lambda>� rZ r� r� r4 rB r� r� r� r r r� )rB r� rI r[ r� r� r� r. rL r1 �testIllegalInboxDelete1 � �z'IMAP4ServerTests.testIllegalInboxDeletec s� � fdd�}� fdd�}� fdd�}d � _ � j�t|��}|�t|���|� |�� j� j� � �� }t � ||g�}|�� fdd�� |S ) Nc r� r� r� r. rL r. r1 r� I r. z5IMAP4ServerTests.testNonExistentDelete.<locals>.loginc r" rM rN r. rL r. r1 rI L r5 z6IMAP4ServerTests.testNonExistentDelete.<locals>.deletec rX r- r? r? rL r. r1 � deleteFailedO rq z<IMAP4ServerTests.testNonExistentDelete.<locals>.deleteFailedc s � � t� jj�td��S )Nr$ �r? r� r! r� r� rL r. r1 r2 Y s z8IMAP4ServerTests.testNonExistentDelete.<locals>.<lambda>) r! r� r� r4 r� rB r� r� r r r� )rB r� rI rb r� r� r� r. rL r1 �testNonExistentDeleteH s �z&IMAP4ServerTests.testNonExistentDeletec s� t � }d|_tj�d|� tj�d� �fdd�}�fdd�}�fdd �}d �_�j�t|��}|�t|��� |� |� �j �j � �� � }t�||g�}td �� |�� �fd d �� |S ) N)z \NoselectrI rL c r� r� r� r. rL r. r1 r� c r. z1IMAP4ServerTests.testIllegalDelete.<locals>.loginc r" rQ rN r. rL r. r1 rI f r5 z2IMAP4ServerTests.testIllegalDelete.<locals>.deletec rX r- r? r? rL r. r1 rb i rq z8IMAP4ServerTests.testIllegalDelete.<locals>.deleteFaileds< Hierarchically inferior mailboxes exist and \Noselect is setc s �� t�jj�� �S r- rc r� �r? rB r. r1 r2 u rF z4IMAP4ServerTests.testIllegalDelete.<locals>.<lambda>)r ro rj r| r r! r� r� r4 r� rB r� r� r r r� r� )rB r� r� rI rb r� r� r� r. re r1 �testIllegalDelete] s$ �z"IMAP4ServerTests.testIllegalDeletec rK )N�oldmboxc r� r� r� r. rL r. r1 r� { r. z*IMAP4ServerTests.testRename.<locals>.loginc r� )Ns oldmboxs newname�r� �renamer. rL r. r1 ri ~ r. z+IMAP4ServerTests.testRename.<locals>.renamec s � � ttjj�� �dg�S )N�NEWNAME)r? r� rj r| r/ r r� rL r. r1 r2 � s �z-IMAP4ServerTests.testRename.<locals>.<lambda>rO �rB r� ri r� r� r� r. rL r1 � testRenamex � �zIMAP4ServerTests.testRenamec rW ) Nc r� r� r� r. rL r. r1 r� � r. z6IMAP4ServerTests.testIllegalInboxRename.<locals>.loginc r� )NrF �frotzrh r. rL r. r1 ri � r. z7IMAP4ServerTests.testIllegalInboxRename.<locals>.renamec rX r- rY )�stuffrL r. r1 r[ � rq z6IMAP4ServerTests.testIllegalInboxRename.<locals>.stashc r\ r- r] r� rL r. r1 r2 � rF z9IMAP4ServerTests.testIllegalInboxRename.<locals>.<lambda>r_ )rB r� ri r[ r� r� r� r. rL r1 �testIllegalInboxRename� ra z'IMAP4ServerTests.testIllegalInboxRenamec s� t j�d� t j�d� � fdd�}� fdd�}� j�t|��}|�t|�� j� |�� j� j� � � � }t � ||g�}|�� j �S )Nz oldmbox/m1z oldmbox/m2c r� r� r� r. rL r. r1 r� � r. z6IMAP4ServerTests.testHierarchicalRename.<locals>.loginc r� )Nrg �newnamerh r. rL r. r1 ri � r. z7IMAP4ServerTests.testHierarchicalRename.<locals>.rename) rj r| rA r� r� r4 rB r� r� r r r� �_cbTestHierarchicalRenamerk r. rL r1 �testHierarchicalRename� s z'IMAP4ServerTests.testHierarchicalRenamec C s: t jj�� }g d�}tt|��}| �|dd� |D �� d S )N)rq z newname/m1z newname/m2c S rH r. rI )r rR r. r. r1 r� � rF z>IMAP4ServerTests._cbTestHierarchicalRename.<locals>.<listcomp>)rj r| r/ r r� r= r? )rB r� �mboxesr? r. r. r1 rr � s z*IMAP4ServerTests._cbTestHierarchicalRenamec sv � fdd�}� fdd�}� j �t|��}|�t|�� j� |�� j� j� � �� }t�||g�}|�� fdd�� |S )Nc r� r� r� r. rL r. r1 r� � r. z-IMAP4ServerTests.testSubscribe.<locals>.loginc r" �Nz this/mbox)r� � subscriber. rL r. r1 rv � r5 z1IMAP4ServerTests.testSubscribe.<locals>.subscribec � � � tjjdg�S )N� THIS/MBOX�r? rj r| � subscriptionsr� rL r. r1 r2 � � �z0IMAP4ServerTests.testSubscribe.<locals>.<lambda>) r� r� r4 rB r� r� r r r� )rB r� rv r� r� r� r. rL r1 � testSubscribe� s �z IMAP4ServerTests.testSubscribec s� ddgt j_� fdd�}� fdd�}� j�t|��}|�t|�� j� |�� j� j� � � � }t � ||g�}|�� fdd�� |S ) Nrx � THAT/MBOXc r� r� r� r. rL r. r1 r� � r. z/IMAP4ServerTests.testUnsubscribe.<locals>.loginc r" ru )r� � unsubscriber. rL r. r1 r~ � r5 z5IMAP4ServerTests.testUnsubscribe.<locals>.unsubscribec rw )Nr} ry r� rL r. r1 r2 � r{ z2IMAP4ServerTests.testUnsubscribe.<locals>.<lambda>) rj r| rz r� r� r4 rB r� r� r r r� )rB r� r~ r� r� r� r. rL r1 �testUnsubscribe� rm z IMAP4ServerTests.testUnsubscribec s� t j�d� t j�d� t j�d� � fdd�}� fdd�}d � _� j�t|��}|�t|�� j� |�|� j� |�� j � j� � � � }t � ||g��� fdd ��S ) N� root/subthingzroot/another-thingznon-root/subthingc r� r� r� r. rL r. r1 r� � r. z*IMAP4ServerTests._listSetup.<locals>.loginc rX r- ��listed)rP rL r. r1 r� � rq z+IMAP4ServerTests._listSetup.<locals>.listedc r r- r� r� rL r. r1 r2 � r3 z-IMAP4ServerTests._listSetup.<locals>.<lambda>) rj r| r r� r� r� r4 rB r� r� r r r� )rB r0 r� r� r� r� r. rL r1 � _listSetup� s zIMAP4ServerTests._listSetupc C s2 |D ]}| � |d td� | � |d td� q|S )z� Assert a C{LIST} response's delimiter and mailbox are native strings. @param results: A list of tuples as returned by L{IMAP4Client.list} or L{IMAP4Client.lsub}. r� zdelimiter %r is not a strr� zmailbox %r is not a str)r� r� )rB �resultsr/ r. r. r1 �'assertListDelimiterAndMailboxAreStrings� s z8IMAP4ServerTests.assertListDelimiterAndMailboxAreStringsc s, � fdd�}� � |�}|j� fdd��}|S )Nc r� �N�root�%)r� r� r. rL r. r1 � mailboxList r. z.IMAP4ServerTests.testList.<locals>.mailboxListc sj t tj�ddft tj�ddfg}td�D ]}| �d�\}}}� �t |�||f|� q� �| d| ��� d S )Nr* � ROOT/SUBTHINGzROOT/ANOTHER-THINGr� r z More results than expected: )r= r ro rd �popr� r- )r� �expectedContentsr� ro � delimiter�mailboxrL r. r1 �assertListContents s � �z5IMAP4ServerTests.testList.<locals>.assertListContents)r� r� )rB r� r� r� r. rL r1 �testList s zIMAP4ServerTests.testListc sJ t j�d� � fdd�}� �|�}|�� j� |�� jtjddfg� |S )Nr� c r� r� )r� �lsubr. rL r. r1 r� r. z'IMAP4ServerTests.testLSub.<locals>.lsubr* ) rj r| rv r� r� r� r? r ro )rB r� r� r. rL r1 �testLSub s zIMAP4ServerTests.testLSubc s� t j�d� � fdd�}� fdd�}� fdd�}d � _� j�t|��}|�t|�� j� |�|� j� |�� j � j� � � � }t � ||g�}|�� fdd �� |S ) Nr� c r� r� r� r. rL r. r1 r� ) r. z*IMAP4ServerTests.testStatus.<locals>.loginc � � j �dddd�S )Nr� r r r �r� �statusr. rL r. r1 r� , � z+IMAP4ServerTests.testStatus.<locals>.statusc rX r- ��statusedr� rL r. r1 r� / rq z-IMAP4ServerTests.testStatus.<locals>.statusedc s � � � jdddd��S )Nr� s 10r� )r r r )r? r� r� rL r. r1 r2 : s �z-IMAP4ServerTests.testStatus.<locals>.<lambda>) rj r| r r� r� r� r4 rB r� r� r r r� )rB r� r� r� r� r� r� r. rL r1 � testStatus& s �zIMAP4ServerTests.testStatusc s� � fdd�}� fdd�}� fdd�}� fdd�}d � _ � _� j�t|��}|�t|�� j� |�||� |�� j� j� � �� }t � ||g��� j �S ) Nc r� r� r� r. rL r. r1 r� A r. z0IMAP4ServerTests.testFailedStatus.<locals>.loginc r� )Nzroot/nonexistentr r r r� r. rL r. r1 r� D s �z1IMAP4ServerTests.testFailedStatus.<locals>.statusc rX r- r� r� rL r. r1 r� I rq z3IMAP4ServerTests.testFailedStatus.<locals>.statusedc rX r- r? r? rL r. r1 �failedL rq z1IMAP4ServerTests.testFailedStatus.<locals>.failed) r� r! r� r� r4 rB r� r� r r r� �_cbTestFailedStatus)rB r� r� r� r� r� r� r. rL r1 �testFailedStatus@ s z!IMAP4ServerTests.testFailedStatusc C s$ | � | jd � | � | jjjd� d S )N)s Could not open mailbox)r? r� r! r� rv r� r. r. r1 r� W � z$IMAP4ServerTests._cbTestFailedStatusc � t �td�� tj�d� �fdd�}tj� �fdd��}�j� t |��}|� t |��j � |� �j �j � ��� }t�||g�}|� �j� �S )N�rfc822.messager� c r� r� r� r. rL r. r1 r� _ r. z.IMAP4ServerTests.testFullAppend.<locals>.loginc 3 sP � t � d��} �j�d| dd�V }t�|� W d � d S 1 s!w Y d S )N�rbr� )�\SEEN�\DELETEDz%Tue, 17 Jun 2003 11:22:16 -0600 (MDT))�openr� rr r � returnValue�r? r/ ��infilerB r. r1 rr b s � � "�z/IMAP4ServerTests.testFullAppend.<locals>.append)r# �sibpath�__file__rj r| r r �inlineCallbacksr� r� r4 rB r� r� r r� �_cbTestFullAppend�rB r� rr r� r� r� r. r� r1 �testFullAppend[ s z IMAP4ServerTests.testFullAppendc C s� t jjd }| �dt|j�� | �ddgddf|jd dd � � t|d��}| �|�� |jd d �� � W d � d S 1 sAw Y d S )Nr� r� r� r� s% Tue, 17 Jun 2003 11:22:16 -0600 (MDT)r r� � rj r| r/ r? r� r� r� rP rU �rB r� r� �mbr0 r. r. r1 r� v s � "�z"IMAP4ServerTests._cbTestFullAppendc r� )Nr� �PARTIAL/SUBTHINGc r� r� r� r. rL r. r1 r� � r. z1IMAP4ServerTests.testPartialAppend.<locals>.loginc 3 sn � t � d��'} �j�t�dtdtj�� �f �d�jj | ��V }t � |� W d � d S 1 s0w Y d S )Nr� s APPENDz)PARTIAL/SUBTHING (\SEEN) "Right now" {%d}r. ) r� r� � sendCommandr r r& �os�path�getsize� _IMAP4Client__cbContinueAppendr r� r� r� r. r1 rr � s" � ���� "�z2IMAP4ServerTests.testPartialAppend.<locals>.append)r# r� r� rj r| r r r� r� r� r4 rB r� r� r r� �_cbTestPartialAppendr� r. r� r1 �testPartialAppend� s z"IMAP4ServerTests.testPartialAppendc C s� t jjd }| �dt|j�� | �dgddf|jd dd � � t|d��}| �|�� |jd d �� � W d � d S 1 s@w Y d S )Nr� r� r� s Right nowr r� r� r� r. r. r1 r� � s " "�z%IMAP4ServerTests._cbTestPartialAppendc s| t j�d� � fdd�}� fdd�}� fdd�}� j�t|��}|�t|�� j� |�t|�� j� |�� j� j� � � � S )N� root/subthingc r� r� r� r. rL r. r1 r� � r. z*IMAP4ServerTests._testCheck.<locals>.loginc r" )Nr� r# r. rL r. r1 rd � r5 z+IMAP4ServerTests._testCheck.<locals>.selectc � � j �� S r- )r� rb r. rL r. r1 rb � rq z*IMAP4ServerTests._testCheck.<locals>.check) rj r| r r� r� r4 rB r� r� r )rB r� rd rb r� r. rL r1 � _testCheck� s zIMAP4ServerTests._testCheckc C r] )zf Trigger the L{imap.IMAP4Server._cbSelectWork} callback by selecting an mbox. )r� rL r. r. r1 � test_check� s zIMAP4ServerTests.test_checkc s6 ddd�}� fdd�}� � td|� � �� }|�|�S ) zr Trigger the L{imap.IMAP4Server._ebSelectWork} errback by failing when we select an mbox. r� c S s t �d��)N�encoding)r �IllegalMailboxEncoding)rB r_ r0 r. r. r1 � failSelect� rq z3IMAP4ServerTests.test_checkFail.<locals>.failSelectc s$ � � � }� �|d jjd d� d S )Nr� r s SELECT failed: Server error)r r? r� rv )r� �failuresrL r. r1 � checkResponse� � z6IMAP4ServerTests.test_checkFail.<locals>.checkResponserd Nre )�patchrg r� r� )rB r� r� r� r. rL r1 �test_checkFail� s z IMAP4ServerTests.test_checkFailc s� t � }g d�|_tj�d|� � fdd�}� fdd�}� fdd�}� j�t|��}|�t|�� j � |�t|�� j � |�� j � j � � � � }t � ||g��� j|�S ) N�)s Message 1)rC � AnotherFlagNr �s Message 2)r� Nr� )s Message 3)rC Nr� r� c r� r� r� r. rL r. r1 r� � r. z)IMAP4ServerTests.testClose.<locals>.loginc r" )Ns mailboxr# r. rL r. r1 rd � r5 z*IMAP4ServerTests.testClose.<locals>.selectc r� r- )r� rM r. rL r. r1 rM � rq z)IMAP4ServerTests.testClose.<locals>.close)r r� rj r| r r� r� r4 rB r� r� r r r� � _cbTestClose)rB r� r� rd rM r� r� r. rL r1 � testClose� s zIMAP4ServerTests.testClosec C s4 | � t|j�d� | � |jd d� | �|j� d S )Nr� r r� )r? r� r� r/ rL �rB r� r� r. r. r1 r� � s z IMAP4ServerTests._cbTestClosec s� t � }g d�|_tj�d|� � fdd�}� fdd�}� fdd�}� fd d �}d � _� j�t|��}|� t|�� j � |� t|�� j � |� |� j � |� � j � j � � � � }t �||g�}|�� j|�S ) Nr� r� c r� r� r� r. rL r. r1 r� � r. z+IMAP4ServerTests.testExpunge.<locals>.loginc r" )Nr� r# r. rL r. r1 rd � r5 z,IMAP4ServerTests.testExpunge.<locals>.selectc r� r- )r� rJ r. rL r. r1 rJ rq z-IMAP4ServerTests.testExpunge.<locals>.expungec s � � � jjd u � | � _d S r- )r- r� r r� �r� rL r. r1 �expunged � z.IMAP4ServerTests.testExpunge.<locals>.expunged)r r� rj r| r r� r� r� r4 rB r� r� r r r� �_cbTestExpunge) rB r� r� rd rJ r� r� r� r� r. rL r1 � testExpunge� s z IMAP4ServerTests.testExpungec C s: | � t|j�d� | � |jd d� | � | jddg� d S )Nr� r r� r� )r? r� r� r� r� r. r. r1 r� s z IMAP4ServerTests._cbTestExpungeN)6ri rj rk r� r� r� r� r� r� r� r� r� r� r r r r r r! r) r r6 r5 rE rD rP rV r` rd rf rl rp rs rr r| r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r. r. r. r1 r� x sh # %' $ r� c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@dA� Z#dBdC� Z$dDdE� Z%dFdG� Z&dHdI� Z'dJdK� Z(dLdM� Z)dNdO� Z*dPS )Q�IMAP4ServerParsingTestsz6 Test L{imap4.IMAP4Server}'s command parsing. c C s. t � | _t�� | _| j�| j� | j�� d S r- )r' r� r ro r� �makeConnection�clearrL r. r. r1 r� s z IMAP4ServerParsingTests.setUpc C � | j �t�t�� �� d S r- �r� �connectionLostr! r^ r �ConnectionDonerL r. r. r1 r� % � z IMAP4ServerParsingTests.tearDownc sL G dd� dt �� � fdd�}d| j_|| j_| j�d� | �| �� �� dS )zO L{imap4.IMAP4Server} logs exceptions raised by parse methods. c @ rf )zSIMAP4ServerParsingTests.test_parseMethodExceptionLogged.<locals>.UnhandledException�1 An unhandled exception. Nrh r. r. r. r1 �UnhandledException- ri r� c � � �r- r. )r{ �r� r. r1 �raisesValueError2 r* zQIMAP4ServerParsingTests.test_parseMethodExceptionLogged.<locals>.raisesValueError�command� invalidN)r� r� � parseState� parse_commandry r/ r )rB r� r. r� r1 � test_parseMethodExceptionLogged( s z7IMAP4ServerParsingTests.test_parseMethodExceptionLoggedc C s: | j �d� | �| j�� d� | j �t�t� d��� dS )z� L{imap4.IMAP4Server.parse_command} sends a C{BAD} response to a line that includes a tag but no command. � 001s 001 BAD Missing command �DoneN) r� r� r? r� r� r� r! r^ r r� rL r. r. r1 �test_missingCommand< s �z+IMAP4ServerParsingTests.test_missingCommandc C �" | j �d� | �| j�� d� dS )zf L{imap4.IMAP4Server.parse_command} sends a C{BAD} response to an empty line. r� s * BAD Null command N)r� r� r? r� r� rL r. r. r1 �test_emptyLineI s z&IMAP4ServerParsingTests.test_emptyLinec sJ � fdd�}|| j _| j �d�|dg�� | �| j�� d�||g�� dS )aV Assert that the given exception results in the expected response. @param exception: The exception to raise. @type exception: L{Exception} @param tag: The IMAP tag. @type: L{bytes} @param expectedResponse: The expected bad response. @type expectedResponse: L{bytes} c r� r- r. )�tag�cmd�rest�� exceptionr. r1 �raisesb r* zDIMAP4ServerParsingTests.assertParseExceptionResponse.<locals>.raisesrZ r� N)r� �dispatchCommandr� r� r? r� r� �rB r� r� �expectedResponser� r. r� r1 � assertParseExceptionResponseR s z4IMAP4ServerParsingTests.assertParseExceptionResponsec C � | � t�d�dd� dS )zt When a parsing method raises L{IllegalClientResponse}, the server sends a C{BAD} response. �client responser� �% BAD Illegal syntax: client response N)r� r �IllegalClientResponserL r. r. r1 �'test_parsingRaisesIllegalClientResponsek � �z?IMAP4ServerParsingTests.test_parsingRaisesIllegalClientResponsec C r� )zn When a parsing method raises L{IllegalOperation}, the server sends a C{NO} response. � operationr� �! NO Illegal operation: operation N)r� r �IllegalOperationrL r. r. r1 �*test_parsingRaisesIllegalOperationResponsev r� zBIMAP4ServerParsingTests.test_parsingRaisesIllegalOperationResponsec C r� )zt When a parsing method raises L{IllegalMailboxEncoding}, the server sends a C{NO} response. r� r� �# NO Illegal mailbox name: encoding N)r� r r� rL r. r. r1 �(test_parsingRaisesIllegalMailboxEncoding� r� z@IMAP4ServerParsingTests.test_parsingRaisesIllegalMailboxEncodingc C r� )zi L{imap4.IMAP4Server} responds to an unsupported command with a C{BAD} response. s 001 HULLABALOOs 001 BAD Unsupported command N)r� ry r? r� r� rL r. r. r1 �test_unsupportedCommand� s z/IMAP4ServerParsingTests.test_unsupportedCommandc C s4 | j �d� | �| j�� dtd��d� d � dS )z~ L{imap4.IMAP4Server} responds with a C{BAD} response to a command with more arguments than expected. s 001 LOGIN A B Cs8 001 BAD Illegal syntax: Too many arguments for command: � Czutf-8r_ N)r� ry r? r� r� r� r@ rL r. r. r1 � test_tooManyArgumentsForCommand� s ���z7IMAP4ServerParsingTests.test_tooManyArgumentsForCommandc sf � fdd�}| � | jjd� |f| jjdd� | j_| j�|dd� | � | j�� d�||g�� dS ) aR Assert that the given exception results in the expected response. @param exception: The exception to raise. @type exception: L{Exception} @param: The IMAP tag. @type: L{bytes} @param expectedResponse: The expected bad response. @type expectedResponse: L{bytes} c r� r- r. )�serverInstancer� r� r� r� r. r1 r� � r* zFIMAP4ServerParsingTests.assertCommandExceptionResponse.<locals>.raisesr� r� N� LOGINs user passwdrZ )r? r� r� � unauth_LOGINr� r� r� r� r� r. r� r1 � assertCommandExceptionResponse� s z6IMAP4ServerParsingTests.assertCommandExceptionResponsec C r� )zm When a command raises L{IllegalClientResponse}, the server sends a C{BAD} response. r� r� r� N)r r r� rL r. r. r1 �'test_commandRaisesIllegalClientResponse� r� z?IMAP4ServerParsingTests.test_commandRaisesIllegalClientResponsec C r� )zg When a command raises L{IllegalOperation}, the server sends a C{NO} response. r� r� r� N)r r r� rL r. r. r1 �*test_commandRaisesIllegalOperationResponse� r� zBIMAP4ServerParsingTests.test_commandRaisesIllegalOperationResponsec C r� )zm When a command raises L{IllegalMailboxEncoding}, the server sends a C{NO} response. r� r� r� N)r r r� rL r. r. r1 �(test_commandRaisesIllegalMailboxEncoding� r� z@IMAP4ServerParsingTests.test_commandRaisesIllegalMailboxEncodingc C s6 G dd� dt �}| �|d�dd� | �| �|�� dS )z� Wehn a command raises an unhandled exception, the server sends a C{BAD} response and logs the exception. c @ rf )zXIMAP4ServerParsingTests.test_commandRaisesUnhandledException.<locals>.UnhandledExceptionr� Nrh r. r. r. r1 r� � ri r� � unhandledr� s BAD Server error: unhandled N)r� r r/ r )rB r� r. r. r1 �$test_commandRaisesUnhandledException� s �z<IMAP4ServerParsingTests.test_commandRaisesUnhandledExceptionc C s* d| j _| j �d� | �| j�� d� dS )zx A string literal whose length exceeds the maximum allowed length results in a C{BAD} response. r� s 001 LOGIN {5} sE 001 BAD Illegal syntax: Literal too long! I accept at most 4 octets N)r� �_literalStringLimitry r? r� r� rL r. r. r1 �test_stringLiteralTooLong� s �z1IMAP4ServerParsingTests.test_stringLiteralTooLongc C s" dD ] }| � tj| jj|� qdS )zQ An empty string argument raises L{imap4.IllegalClientResponse}. )r� r_ rZ N�r� r r� r� � arg_astring)rB r� r. r. r1 �test_arg_astringEmptyLine s ��z1IMAP4ServerParsingTests.test_arg_astringEmptyLinec C � | � tj| jjd� dS )zh An unmatched quote in a string argument raises L{imap4.IllegalClientResponse}. s "openNr rL r. r. r1 � test_arg_astringUnmatchedQuotes � �z7IMAP4ServerParsingTests.test_arg_astringUnmatchedQuotesc C r )zn An unmatched brace in a string literal's size raises L{imap4.IllegalClientResponse}. s {0Nr rL r. r. r1 �&test_arg_astringUnmatchedLiteralBraces r� z>IMAP4ServerParsingTests.test_arg_astringUnmatchedLiteralBracesc C r )zc A non-integral string literal size raises L{imap4.IllegalClientResponse}. � {[object Object]}Nr rL r. r. r1 �"test_arg_astringInvalidLiteralSize r z:IMAP4ServerParsingTests.test_arg_astringInvalidLiteralSizec C r )z@ An empty atom raises L{IllegalClientResponse}. r� N�r� r r� r� �arg_atomrL r. r. r1 �test_arg_atomEmptyLine# r z.IMAP4ServerParsingTests.test_arg_atomEmptyLinec C r )zC A malformed atom raises L{IllegalClientResponse}. s not an atom Nr rL r. r. r1 �test_arg_atomMalformedAtom) s �z2IMAP4ServerParsingTests.test_arg_atomMalformedAtomc C r )zN An empty parenthesized list raises L{IllegalClientResponse}. r� N�r� r r� r� � arg_plistrL r. r. r1 �test_arg_plistEmptyLine1 r z/IMAP4ServerParsingTests.test_arg_plistEmptyLinec C �, | � tj| jjd� | � tj| jjd� dS )ze A parenthesized with unmatched parentheses raises L{IllegalClientResponse}. s (foos foo)Nr rL r. r. r1 �"test_arg_plistUnmatchedParentheses7 � z:IMAP4ServerParsingTests.test_arg_plistUnmatchedParenthesesc C r )zH An empty file literal raises L{IllegalClientResponse}. r� N�r� r r� r� � arg_literalrL r. r. r1 �test_arg_literalEmptyLine? r z1IMAP4ServerParsingTests.test_arg_literalEmptyLinec C r )zZ A literal with unmatched braces raises L{IllegalClientResponse}. s {10s 10}Nr rL r. r. r1 � test_arg_literalUnmatchedBracesE r z7IMAP4ServerParsingTests.test_arg_literalUnmatchedBracesc C r )z\ A non-integral literal size raises L{imap4.IllegalClientResponse}. r Nr rL r. r. r1 �"test_arg_literalInvalidLiteralSizeM r z:IMAP4ServerParsingTests.test_arg_literalInvalidLiteralSizec C s$ d}| j �|�\}}| �|d� dS )zH A sequence set returns the unparsed portion of a line. s 1:* blah blah blahs blah blah blahN)r� � arg_seqsetr? )rB �sequencer� r� r. r. r1 �test_arg_seqsetReturnsRestV s z2IMAP4ServerParsingTests.test_arg_seqsetReturnsRestc C r )zL An invalid sequence raises L{imap4.IllegalClientResponse}. s x:yN)r� r r� r� r# rL r. r. r1 � test_arg_seqsetInvalidSequence^ r z6IMAP4ServerParsingTests.test_arg_seqsetInvalidSequencec C s0 d}| j �|�\}}| �||g� | �|� dS )zJ A single flag that is not contained in a list is parsed. s flagN)r� � arg_flaglistr? r- )rB �flagra r� r. r. r1 �test_arg_flaglistOneFlagd s z0IMAP4ServerParsingTests.test_arg_flaglistOneFlagc C r )zk A list of flags with unmatched parentheses raises L{imap4.IllegalClientResponse}. s (invalidN�r� r r� r� r' rL r. r. r1 �&test_arg_flaglistMismatchedParentehsesm s �z>IMAP4ServerParsingTests.test_arg_flaglistMismatchedParentehsesc C r )zo A list of flags that contains a malformed flag raises L{imap4.IllegalClientResponse}. s (first )s (first second)Nr* rL r. r. r1 � test_arg_flaglistMalformedFlagx s � �z6IMAP4ServerParsingTests.test_arg_flaglistMalformedFlagc C �. d}| j �|�\}}| �|� | �||� dS )z� A line that does not begin with an open parenthesis (C{(}) is parsed as L{None}, and the remainder is the whole line. s not (N)r� � opt_plistr& r? )rB r{ �plist� remainderr. r. r1 �$test_opt_plistMissingOpenParenthesis� � z<IMAP4ServerParsingTests.test_opt_plistMissingOpenParenthesisc C r- )z� A line that does not begin with a double quote (C{"}) is parsed as L{None}, and the remainder is the whole line. s not "N)r� � opt_datetimer& r? )rB r{ �dtr0 r. r. r1 �!test_opt_datetimeMissingOpenQuote� r2 z9IMAP4ServerParsingTests.test_opt_datetimeMissingOpenQuotec C � d}| � tj| jj|� dS )zx A line that does not have a closing double quote (C{"}) raises L{imap4.IllegalClientResponse}. s "21-Jul-2017 19:37:07 -0700N)r� r r� r� r3 rz r. r. r1 �"test_opt_datetimeMissingCloseQuote� � z:IMAP4ServerParsingTests.test_opt_datetimeMissingCloseQuotec C r6 )z� A line that contains C{CHARSET} but no character set identifier raises L{imap4.IllegalClientResponse}. rh N)r� r r� r� � opt_charsetrz r. r. r1 �!test_opt_charsetMissingIdentifier� r8 z9IMAP4ServerParsingTests.test_opt_charsetMissingIdentifierc C �0 d}| j �|�\}}| �|d� | �|d� dS )z� A line that ends with a C{CHARSET} identifier is parsed as that identifier, and the remainder is the empty string. s CHARSET UTF-8� UTF-8r� N�r� r9 r? �rB r{ � identifierr0 r. r. r1 �test_opt_charsetEndOfLine� s z1IMAP4ServerParsingTests.test_opt_charsetEndOfLinec C r; )z� A line that has additional data after a C{CHARSET} identifier is parsed as that identifier, and the remainder is that additional data. s CHARSET UTF-8 remainderr< s remainderNr= r> r. r. r1 � test_opt_charsetWithRemainder� s z5IMAP4ServerParsingTests.test_opt_charsetWithRemainderN)+ri rj rk r r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r r r r r r r! r" r% r& r) r+ r, r1 r5 r7 r: r@ rA r. r. r. r1 r� sR r� c @ sp e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� ZdS )�IMAP4ServerSearchTestszS Tests for the behavior of the search_* functions in L{imap4.IMAP4Server}. c C sD t �| � dg| _dg| _dg| _d| _tddig ddd d �| _d S ) Nz 10-Dec-2009z 13-Dec-2009z 16-Dec-2009r r@ z Mon, 13 Dec 2009 21:25:10 GMTz13 Dec 2009 00:00:00 GMTr� �� )r� r� � earlierQuery� sameDateQuery� laterQuery�seqr� r� rL r. r. r1 r� � s �z IMAP4ServerSearchTests.setUpc C �< | � | j�| j| j| j�� | �| j�| j| j| j�� dS )z� L{imap4.IMAP4Server.search_SENTBEFORE} returns True if the message date is earlier than the query date. N)r- r� �search_SENTBEFORErD rG r� r/ rF rL r. r. r1 �test_searchSentBefore� � ��z,IMAP4ServerSearchTests.test_searchSentBeforec C s^ | � | j�dg| j| jd�� | �| j�dg| j| jd�� | �| j�dg| j| jd�� dS )zq L{imap4.IMAP4Server.search_UID} returns True if the message UID is in the search range. r� )r� rC s 2:*r� N)r- r� � search_UIDrG r� r/ rL r. r. r1 �test_searchWildcard� s � "z*IMAP4ServerSearchTests.test_searchWildcardc C s" | � | j�dg| j| jd�� dS )z� L{imap4.IMAP4Server.search_UID} should return True if there is a wildcard, because a wildcard means "highest UID in the mailbox". s 1235:*)rC r� N)r/ r� rL rG r� rL r. r. r1 �test_searchWildcardHigh� s �z.IMAP4ServerSearchTests.test_searchWildcardHighc C s" t �d�}| �t|�g d�� dS )�| L{imap4.IMAP4Server.search_SENTON} returns True if the message date is the same as the query date. r� r N)r r� r? r� )rB �msgsetr. r. r1 �test_reversedSearchTerms� s z/IMAP4ServerSearchTests.test_reversedSearchTermsc C sX | � | j�| j| j| j�� | �| j�| j| j| j�� | � | j�| j| j| j�� dS )rO N) r- r� � search_SENTONrD rG r� r/ rE rF rL r. r. r1 �test_searchSentOn� � �� z(IMAP4ServerSearchTests.test_searchSentOnc C rH )z~ L{imap4.IMAP4Server.search_SENTSINCE} returns True if the message date is later than the query date. N)r/ r� �search_SENTSINCErD rG r� r- rF rL r. r. r1 �test_searchSentSince rK z+IMAP4ServerSearchTests.test_searchSentSincec C s� | � | j�dg| j dg | j | j| jd�� | � | j�dg| j dg | j | j| jd�� | �| j�dg| j dg | j | j| jd�� dS )z� L{imap4.IMAP4Server.search_OR} returns true if either of the two expressions supplied to it returns true and returns false if neither does. � SENTSINCEr� �SENTONN)r/ r� � search_ORrD rF rG r� r- rL r. r. r1 � test_searchOr s0 ������z$IMAP4ServerSearchTests.test_searchOrc C sL | � | j�dg| j | j| jd�� | �| j�dg| j | j| jd�� dS )z~ L{imap4.IMAP4Server.search_NOT} returns the negation of the result of the expression supplied to it. rW r� rX N)r- r� � search_NOTrD rG r� r/ rF rL r. r. r1 �test_searchNot3 s ����z%IMAP4ServerSearchTests.test_searchNotc C �X | � | j�| j| j| j�� | � | j�| j| j| j�� | �| j�| j| j| j�� dS )z� L{imap4.IMAP4Server.search_BEFORE} returns True if the internal message date is before the query date. N) r- r� � search_BEFORErD rG r� rE r/ rF rL r. r. r1 �test_searchBeforeC rT z(IMAP4ServerSearchTests.test_searchBeforec C sX | � | j�| j| j| j�� | � | j�| j| j| j�� | � | j�| j| j| j�� dS )z� L{imap4.IMAP4Server.search_ON} returns True if the internal message date is the same as the query date. N)r- r� � search_ONrD rG r� rE rF rL r. r. r1 � test_searchOnP s z$IMAP4ServerSearchTests.test_searchOnc C r] )z� L{imap4.IMAP4Server.search_SINCE} returns True if the internal message date is greater than the query date. N) r/ r� � search_SINCErD rG r� rE r- rF rL r. r. r1 �test_searchSinceY s � z'IMAP4ServerSearchTests.test_searchSinceN)ri rj rk r r� rJ rM rN rQ rS rV rZ r\ r_ ra rc r. r. r. r1 rB � s rB c @ s& e Zd ZdZdZddd�Zdd� ZdS )rp z� A L{IRealm} for tests. @cvar theAccount: An C{Account} instance. Tests can set this to ensure predictable account retrieval. Nc s( � r � fdd��_ dS �fdd��_ dS )ab Create a realm for testing. @param accountHolder: (optional) An object whose C{theAccount} attribute will be returned instead of L{TestRealm.theAccount}. Attribute access occurs on every avatar request, so any modifications to C{accountHolder.theAccount} will be reflected here. c r r- �r| r. rl r. r1 r2 { r3 z$TestRealm.__init__.<locals>.<lambda>c r r- rd r. rL r. r1 r2 } r3 N)� _getAccount)rB rm r. )rm rB r1 rp p s zTestRealm.__init__c G s t j| �� dd� fS )Nc S r2 r- r. r. r. r. r1 r2 � r� z)TestRealm.requestAvatar.<locals>.<lambda>)r �IAccountre )rB �avatarId�mindr r. r. r1 r� � zTestRealm.requestAvatarr- )ri rj rk r r| rp r� r. r. r. r1 rp e s rp c @ s, e Zd ZeefZddiZdd� Zdd� ZdS )� TestCheckerrk � secretc C s2 |j | jv rt�|j| j|j ��| j|j �S d S r- )�usernamer r � maybeDeferred� checkPasswordr� �_cbCheck�rB � credentialsr. r. r1 �requestAvatarId� s � ��zTestChecker.requestAvatarIdc C s |r|S t � �r- r )rB r/ rl r. r. r1 ro � s zTestChecker._cbCheckN) ri rj rk r r �credentialInterfacesr rr ro r. r. r. r1 rj � s rj c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)S )*�AuthenticatorTestsc C sN t �| � t� }td�|_t|�| _| j�t� � | j| j _d| _ |j| _ d S )Nrk r ) r� r� rp rg r| r rs rt rj r� � authenticatedr� )rB rx r. r. r1 r� � s zAuthenticatorTests.setUpc C s� t tt�G dd� d��}|� }tt|� t�d|i�}| j|_t� }|�|� | � |j t � d�� | � d|�� � |�� |�d� | � t�|�� �|�� � |�� |�t�d�d � | �|�� d � d S ) z� L{imap4.IMAP4Server} accepts a L{dict} mapping challenge type names to L{twisted.mail.interfaces.IChallengeResponse} providers. c @ rl ) z>AuthenticatorTests.test_customChallengers.<locals>.SPECIALAuthc S r( )N� SPECIALr. rL r. r. r1 � getChallenge� r* zKAuthenticatorTests.test_customChallengers.<locals>.SPECIALAuth.getChallengec S s |� d d�\| _| _d S r, )�splitrl �password�rB �responser. r. r1 � setResponse� � zJAuthenticatorTests.test_customChallengers.<locals>.SPECIALAuth.setResponsec S r( �NFr. rL r. r. r1 �moreChallenges� r* zMAuthenticatorTests.test_customChallengers.<locals>.SPECIALAuth.moreChallengesc S s | j | _ d S r- )ry )rB ry r. r. r1 rn � r5 zLAuthenticatorTests.test_customChallengers.<locals>.SPECIALAuth.checkPasswordN)ri rj rk rw r| r rn r. r. r. r1 � SPECIALAuth� s r� rv �Connection done.s AUTH=SPECIALs 001 AUTHENTICATE SPECIAL s username passwordr_ s" 001 OK Authentication successful N)r r r r r ro rs r' r� � addCleanupr� r r� r� r� r� � dataReceived�base64� b64encoderw r? )rB r� �specialr� r� r. r. r1 �test_customChallengers� s z)AuthenticatorTests.test_customChallengersc C sZ t �� }| j|_t� }|�|� | �|jt�d�� |� � |� d� | � |� � d� dS )z_ An unsupported C{AUTHENTICATE} method results in a negative response. r� s 001 AUTHENTICATE UNKNOWN s( 001 NO AUTHENTICATE method unsupported N) r ro rs r' r� r� r� r r� r� r� r? r� )rB r� r� r. r. r1 �test_unsupportedMethod� s �z)AuthenticatorTests.test_unsupportedMethodc sx t j� jjd< t �d�}� j�|� d� j_� fdd�}� j� t |��}|� � j d� |� � j� j� t�|� �� g�S )zv An L{imap4.IMAP4Server} that is missing a L{Portal} responds negatively to an authentication r rk Nc r" �Nrk �r� � authenticater. rL r. r1 r� � r5 z3AuthenticatorTests.test_missingPortal.<locals>.auths Temporary authentication failure)r �LOGINCredentialsr� r� �LOGINAuthenticatorr� �registerAuthenticatorrs r� r� r4 r� r� rB r� r� r r� r )rB �cAuthr� r� r. rL r1 �test_missingPortal� s �z%AuthenticatorTests.test_missingPortalc s� t t�G dd� d��}t t�G dd� d��}|� }tt|� |� jjd< � j�|� � � fdd�}� j� t |��}|� � j dt |j� �d �� |�� j� j� t�|� �� g�S ) z� When a challenger's L{getChallenge<IChallengeResponse.getChallenge>} method raises any exception, a C{NO} response is sent. c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) zRAuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthChallenges A challenge failurec S s t | j��r- )r� r? rL r. r. r1 rw rq z_AuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthChallenge.getChallengec S r( �zw Never called. @param response: See L{IChallengeResponse.setResponse} Nr. rz r. r. r1 r| r� z^AuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthChallenge.setResponsec S r( �z/ Never called. Nr. rL r. r. r1 r r� zaAuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthChallenge.moreChallengesN�ri rj rk r? rw r| r r. r. r. r1 �ValueErrorAuthChallenge� � r� c @ � e Zd Zdd� Zdd� ZdS )zRAuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthenticatorc S r( )N� ERRORr. rL r. r. r1 �getName r* zZAuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthenticator.getNamec S r( )Ns IGNOREDr. )rB �secret�chalr. r. r1 �challengeResponse r* zdAuthenticatorTests.test_challengerRaisesException.<locals>.ValueErrorAuthenticator.challengeResponseN)ri rj rk r� r� r. r. r. r1 �ValueErrorAuthenticator � r� r� c r" r� r� r. rL r. r1 r� r5 z?AuthenticatorTests.test_challengerRaisesException.<locals>.authzServer error: r� )r r r r r� r� r� r� r� r� r4 r� r� r� r? r@ rB r� r� r r� r )rB r� r� �badr� r� r. rL r1 � test_challengerRaisesException� s �z1AuthenticatorTests.test_challengerRaisesExceptionc C s� t t�G dd� d��}|� }tt|� t�� }| j|_||jd< t� }|�|� | � |j t � d�� | � d|�� � |�� |�d� | � t�|�� �|�� � |�� |�d� | �|�� d�d |jd g�� d S ) z� A client that responds with a challenge that cannot be decoded as Base 64 receives an L{IllegalClientResponse}. c @ r� ) zEAuthenticatorTests.test_authNotBase64.<locals>.NotBase64AuthChallenges Malformed Response - not base64c S r( )Ns SomeChallenger. rL r. r. r1 rw 4 r* zRAuthenticatorTests.test_authNotBase64.<locals>.NotBase64AuthChallenge.getChallengec S r( r� r. rz r. r. r1 r| 7 r� zQAuthenticatorTests.test_authNotBase64.<locals>.NotBase64AuthChallenge.setResponsec S r( r� r. rL r. r. r1 r > r� zTAuthenticatorTests.test_authNotBase64.<locals>.NotBase64AuthChallenge.moreChallengesNr� r. r. r. r1 �NotBase64AuthChallenge0 r� r� s NOTBASE64r� s AUTH=NOTBASE64s 001 AUTHENTICATE NOTBASE64 s Not base64 r� s 001 NO Authentication failed: r_ N)r r r r ro rs r� r' r� r� r� r r� r� r� r� r� r� r� rw r? r� r? )rB r� � notBase64r� r� r. r. r1 �test_authNotBase64* s( �z%AuthenticatorTests.test_authNotBase64c s� t � }t|�}|� j_tj � jjd< }tt|� t� d�}� j � |� � fdd�}� j � t|��}|�� jd� |�� j� j� t�� �� |g�}|S )z� A challenger that causes the login to fail L{UnhandledCredentials} results in an C{NO} response. @return: A L{Deferred} that fires when the authorization has failed. r rk c r" r� r� r. rL r. r1 r� r r5 z:AuthenticatorTests.test_unhandledCredentials.<locals>.auths+ Authentication failed: server misconfigured)rp r r� rs r r� r� r r r� r� r� r� r� r4 r� r� rB r� r� r r� r )rB rx rs � loginCredr� r� r� r� r. rL r1 �test_unhandledCredentials] s �z,AuthenticatorTests.test_unhandledCredentialsc s� G dd� dt �� G � fdd�d�}t� }t|�}|�|� � |�j_tj �jjd< }t t |� t� d�}�j � |� �fdd�}� �fd d �}�j�t|��}|��jd � |�t|�� |��j�j� t���� |g�} | S ) z� If the portal raises an exception other than L{UnauthorizedLogin} or L{UnhandledCredentials}, the server responds with a C{BAD} response and the exception is logged. c @ rf )zKAuthenticatorTests.test_unexpectedLoginFailure.<locals>.UnexpectedExceptionr� Nrh r. r. r. r1 r� � ri r� c s$ e Zd ZdZeefZ� fdd�ZdS )zFAuthenticatorTests.test_unexpectedLoginFailure.<locals>.FailingCheckerzz A credentials checker whose L{requestAvatarId} method raises L{UnexpectedException}. c r� )NzUnexpected error.r. rp r� r. r1 rr � rb zVAuthenticatorTests.test_unexpectedLoginFailure.<locals>.FailingChecker.requestAvatarIdN)ri rj rk r r r rs rr r. r� r. r1 �FailingChecker� s r� r rk c r" r� r� r. rL r. r1 r� � r5 z<AuthenticatorTests.test_unexpectedLoginFailure.<locals>.authc r� r- r� r. r r. r1 � assertUnexpectedExceptionLogged� ri zWAuthenticatorTests.test_unexpectedLoginFailure.<locals>.assertUnexpectedExceptionLoggeds' Server error: login failed unexpectedly)r� rp r rt r� rs r r� r� r r r� r� r� r� r� r4 r� r� rB r� r� r r� r ) rB r� rx rs r� r� r� r� r� r� r. r r1 �test_unexpectedLoginFailure~ s( �z.AuthenticatorTests.test_unexpectedLoginFailurec s� t � jjd< t�d�}� j�|� � fdd�}� fdd�}� j�t |��}|� t |�� j � |� � j � j � � � � }t�||g�}|�� j�S )Nr� rk c r" r� r� r. rL r. r1 r� � r5 z,AuthenticatorTests.testCramMD5.<locals>.authc r� r, �ru r. rL r. r1 �authed� rq z.AuthenticatorTests.testCramMD5.<locals>.authed)r r� r� r �CramMD5ClientAuthenticatorr� r� r� r� r4 rB r� r� r r r� �_cbTestCramMD5)rB r� r� r� r� r� r� r. rL r1 � testCramMD5� s z AuthenticatorTests.testCramMD5c C �$ | � | jd� | � | jj| j� d S r, �r? ru r� r� r� r. r. r1 r� � r� z!AuthenticatorTests._cbTestCramMD5c s� t � jjd< t�d�}� j�|� � fdd�}� fdd�}� fdd�}� j�t |��}|� t |�t |�� |� � j � j � t �� �� |g�}|�� j�S ) Nr� rk c r" �Ns not the secretr� r. rL r. r1 �misauth� r5 z5AuthenticatorTests.testFailedCramMD5.<locals>.misauthc r� r, r� r. rL r. r1 r� � rq z4AuthenticatorTests.testFailedCramMD5.<locals>.authedc r� �N���r� r. rL r. r1 � misauthed� rq z7AuthenticatorTests.testFailedCramMD5.<locals>.misauthed)r r� r� r r� r� r� r� r� r4 rB r� r� r r� r �_cbTestFailedCramMD5�rB r� r� r� r� r� r� r. rL r1 �testFailedCramMD5� s z$AuthenticatorTests.testFailedCramMD5c C �" | � | jd� | � | jjd � d S r� r� r� r. r. r1 r� � � z'AuthenticatorTests._cbTestFailedCramMD5c � t j � jjd< }tt|� t �d�}� j�|� � fdd�}� fdd�}� j � t |��}|� t |�� j � |� � j� j � t�� �� |g�}|� � j�S )Nr rk c r" r� r� r. rL r. r1 r� � r5 z*AuthenticatorTests.testLOGIN.<locals>.authc r� r, r� r. rL r. r1 r� � rq z,AuthenticatorTests.testLOGIN.<locals>.authed)r r� r� r� r r r� r� r� r� r� r4 rB r� r� r r� r � _cbTestLOGIN)rB r� r� r� r� r� r� r. rL r1 � testLOGIN� � z AuthenticatorTests.testLOGINc C r� r, r� r� r. r. r1 r� � r� z AuthenticatorTests._cbTestLOGINc � t j� jjd< t �d�}� j�|� � fdd�}� fdd�}� fdd�}� j�t |��}|� t |�t |�� |� � j � j � t �� �� |g�}|�� j�S ) Nr rk c r" r� r� r. rL r. r1 r� � r5 z3AuthenticatorTests.testFailedLOGIN.<locals>.misauthc r� r, r� r. rL r. r1 r� � rq z2AuthenticatorTests.testFailedLOGIN.<locals>.authedc r� r� r� r. rL r. r1 r� rq z5AuthenticatorTests.testFailedLOGIN.<locals>.misauthed)r r� r� r� r� r� r� r� r� r4 rB r� r� r r� r �_cbTestFailedLOGINr� r. rL r1 �testFailedLOGIN� � z"AuthenticatorTests.testFailedLOGINc C r� r� r� r� r. r. r1 r� r� z%AuthenticatorTests._cbTestFailedLOGINc r� )Nrg rk c r" r� r� r. rL r. r1 r� r5 z*AuthenticatorTests.testPLAIN.<locals>.authc r� r, r� r. rL r. r1 r� rq z,AuthenticatorTests.testPLAIN.<locals>.authed)r �PLAINCredentialsr� r� r r �PLAINAuthenticatorr� r� r� r� r4 rB r� r� r r� r � _cbTestPLAIN)rB � plainCredr� r� r� r� r� r. rL r1 � testPLAIN r� z AuthenticatorTests.testPLAINc C r� r, r� r� r. r. r1 r� " r� z AuthenticatorTests._cbTestPLAINc r� ) Nrg rk c r" r� r� r. rL r. r1 r� + r5 z3AuthenticatorTests.testFailedPLAIN.<locals>.misauthc r� r, r� r. rL r. r1 r� . rq z2AuthenticatorTests.testFailedPLAIN.<locals>.authedc r� r� r� r. rL r. r1 r� 1 rq z5AuthenticatorTests.testFailedPLAIN.<locals>.misauthed)r r� r� r� r� r� r� r� r� r4 rB r� r� r r� r �_cbTestFailedPLAINr� r. rL r1 �testFailedPLAIN& r� z"AuthenticatorTests.testFailedPLAINc C r� r� r� r� r. r. r1 r� : r� z%AuthenticatorTests._cbTestFailedPLAINN)ri rj rk r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r. r. r. r1 rt � s* +43!2 rt c @ r� ) �SASLPLAINTestsz� Tests for I{SASL PLAIN} authentication, as implemented by L{imap4.PLAINAuthenticator} and L{imap4.PLAINCredentials}. @see: U{http://www.faqs.org/rfcs/rfc2595.html} @see: U{http://www.faqs.org/rfcs/rfc4616.html} c C s> d}d}d}t �|�}|�||�}| �|d| d | � dS )z� L{PLAINAuthenticator.challengeResponse} returns challenge strings of the form:: NUL<authn-id>NUL<secret> rk rk s challenge� N)r r� r� r? )rB rl r� r� r� r{ r. r. r1 �#test_authenticatorChallengeResponseH s z2SASLPLAINTests.test_authenticatorChallengeResponsec C s2 t �� }|�d� | �|jd� | �|jd� dS )z� L{PLAINCredentials.setResponse} parses challenge strings of the form:: NUL<authn-id>NUL<secret> s testuser secretrk rk N)r r� r| r? rl ry �rB �credr. r. r1 �test_credentialsSetResponseV s z*SASLPLAINTests.test_credentialsSetResponsec C sB t �� }| �t j|jd� | �t j|jd� | �t j|jd� dS )z� L{PLAINCredentials.setResponse} raises L{imap4.IllegalClientResponse} when passed a string not of the expected form. s hellos hello worlds hello world Zoom! N)r r� r� r� r| r� r. r. r1 � test_credentialsInvalidResponseb s � �z.SASLPLAINTests.test_credentialsInvalidResponseN)ri rj rk r r� r� r� r. r. r. r1 r� ? s r� c @ sl e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�UnsolicitedResponseTestsc �\ � fdd�}� fdd�}� j �t|��}|�t|���� j� t�� �� |g�}|�� j�S )Nc r� r� r� r. rL r. r1 r� s r. z5UnsolicitedResponseTests.testReadWrite.<locals>.loginc r; r, �r� r� r. rL r. r1 rT v r� z8UnsolicitedResponseTests.testReadWrite.<locals>.loggedIn) r� r� r4 r� r� r r� r �_cbTestReadWrite�rB r� rT r� r� r. rL r1 � testReadWriter � z&UnsolicitedResponseTests.testReadWritec C � | j j}| �|ddgg� d S )Nr� r� �r� r� r? �rB r� �Er. r. r1 r� ~ � z)UnsolicitedResponseTests._cbTestReadWritec r� )Nc r� r� r� r. rL r. r1 r� � r. z4UnsolicitedResponseTests.testReadOnly.<locals>.loginc r; r> r� r. rL r. r1 rT � r� z7UnsolicitedResponseTests.testReadOnly.<locals>.loggedIn) r� r� r4 r� r� r r� r �_cbTestReadOnlyr� r. rL r1 � testReadOnly� r� z%UnsolicitedResponseTests.testReadOnlyc C r� )Nr� r r� r� r. r. r1 r� � r� z(UnsolicitedResponseTests._cbTestReadOnlyc sr ddgg dgd�� �fdd�}� �fdd�}�j �t|��}|�t|����j� t���� |g�}|��j� �S ) N� \AnsweredrC �\Recent)r� r� r� c r� r� r� r. rL r. r1 r� � r. z6UnsolicitedResponseTests.testFlagChange.<locals>.loginc s �j �� � d S r- )r� r� r. �ro rB r. r1 rT � r� z9UnsolicitedResponseTests.testFlagChange.<locals>.loggedIn) r� r� r4 r� r� r r� r �_cbTestFlagChanger� r. r� r1 �testFlagChange� s z'UnsolicitedResponseTests.testFlagChangec C sJ | j j}dd� |�� D �}|jdd� d� |jdd� d� | �||� d S )Nc S s g | ] }d |d |d ig�qS )r� r r� r. )r r5 r. r. r1 r� � s z>UnsolicitedResponseTests._cbTestFlagChange.<locals>.<listcomp>c S � | d S r> r. �rf r. r. r1 r2 � � z<UnsolicitedResponseTests._cbTestFlagChange.<locals>.<lambda>)�keyc S r� r> r. r� r. r. r1 r2 � r� )r� r� �itemsr� r? )rB r� ro r� �expectr. r. r1 r� � s z*UnsolicitedResponseTests._cbTestFlagChangec r� )Nc r� r� r� r. rL r. r1 r� � r. z7UnsolicitedResponseTests.testNewMessages.<locals>.loginc s � j �dd � d S �Nr� �r� r� r. rL r. r1 rT � r� z:UnsolicitedResponseTests.testNewMessages.<locals>.loggedIn) r� r� r4 r� r� r r� r �_cbTestNewMessagesr� r. rL r1 �testNewMessages� r� z(UnsolicitedResponseTests.testNewMessagesc C � | j j}| �|g d�g� d S )N)r� r� Nr� r� r. r. r1 r� � r� z+UnsolicitedResponseTests._cbTestNewMessagesc r� )Nc r� r� r� r. rL r. r1 r� � r. z=UnsolicitedResponseTests.testNewRecentMessages.<locals>.loginc s � j �d d� d S r� r� r. rL r. r1 rT � r� z@UnsolicitedResponseTests.testNewRecentMessages.<locals>.loggedIn) r� r� r4 r� r� r r� r �_cbTestNewRecentMessagesr� r. rL r1 �testNewRecentMessages� r� z.UnsolicitedResponseTests.testNewRecentMessagesc C r� )N�r� Nr� r� r� r. r. r1 r� � r� z1UnsolicitedResponseTests._cbTestNewRecentMessagesc r� )Nc r� r� r� r. rL r. r1 r� � r. z@UnsolicitedResponseTests.testNewMessagesAndRecent.<locals>.loginc s � j �dd� d S )Nr� r� r� r. rL r. r1 rT � r� zCUnsolicitedResponseTests.testNewMessagesAndRecent.<locals>.loggedIn) r� r� r4 r� r� r r� r �_cbTestNewMessagesAndRecentr� r. rL r1 �testNewMessagesAndRecent� r� z1UnsolicitedResponseTests.testNewMessagesAndRecentc C s$ | j j}| �|g d�g d�g� d S )N)r� r� Nr� r� r� r. r. r1 r� � r� z4UnsolicitedResponseTests._cbTestNewMessagesAndRecentN)ri rj rk r� r� r� r� r� r� r� r� r� r� r� r� r. r. r. r1 r� q s r� c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �ClientCapabilityTestszT Tests for issuance of the CAPABILITY command and handling of its response. c C s0 t � | _t�� | _| j�| j� | j�d� dS )zS Create an L{imap4.IMAP4Client} connected to a L{StringTransport}. s * OK [IMAP4rev1] N)r' r� r r~ �protocolr� r� rL r. r. r1 r� � s zClientCapabilityTests.setUpc �@ � j jdd�}� j �d� � j �d� � fdd�}|�|� |S )z� A capability response consisting only of atoms without C{'='} in them should result in a dict mapping those atoms to L{None}. F��useCaches& * CAPABILITY IMAP4rev1 LOGINDISABLED � 0001 OK Capability completed. c s � � | d d d�� d S )N)r� s LOGINDISABLEDr� �� capabilitiesrL r. r1 �gotCapabilities� � z?ClientCapabilityTests.test_simpleAtoms.<locals>.gotCapabilities�r� r� r� r� �rB �capabilitiesResultr� r. rL r1 �test_simpleAtoms� s z&ClientCapabilityTests.test_simpleAtomsc r� )a� A capability response consisting of atoms including C{'='} should have those atoms split on that byte and have capabilities in the same category aggregated into lists in the resulting dictionary. (n.b. - I made up the word "category atom"; the protocol has no notion of structure here, but rather allows each capability to define the semantics of its entry in the capability response in a freeform manner. If I had realized this earlier, the API for capabilities would look different. As it is, we can hope that no one defines any crazy semantics which are incompatible with this API, or try to figure out a better API when someone does. -exarkun) Fr� s. * CAPABILITY IMAP4rev1 AUTH=LOGIN AUTH=PLAIN r� c s � � | d ddgd�� d S )Nr rg )r� r� r� r� rL r. r1 r� s �zAClientCapabilityTests.test_categoryAtoms.<locals>.gotCapabilitiesr� r� r. rL r1 �test_categoryAtoms� s z(ClientCapabilityTests.test_categoryAtomsc r� )z� A capability response consisting of both simple and category atoms of the same type should result in a list containing L{None} as well as the values for the category. Fr� s0 * CAPABILITY IMAP4rev1 FOO FOO=BAR BAR=FOO BAR r� c s � � | d d dgdd gd�� d S )N� BAR� FOO)r� r r r� r� rL r. r1 r� s �z>ClientCapabilityTests.test_mixedAtoms.<locals>.gotCapabilitiesr� r� r. rL r1 �test_mixedAtoms s � z%ClientCapabilityTests.test_mixedAtomsN)ri rj rk r r� r r r r. r. r. r1 r� � s r� c @ � e Zd ZdZdd� Zdd� ZdS )�StillSimplerClientzH An IMAP4 client which keeps track of unsolicited flag changes. c C s t j�| � i | _d S r- )r r~ rp ro rL r. r. r1 rp , � zStillSimplerClient.__init__c C s | j �|� d S r- )ro r� r� r. r. r1 r� 0 r� z StillSimplerClient.flagsChangedN)ri rj rk r rp r� r. r. r. r1 r ' s r c @ sT e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dS )�HandCraftedTestsc sp t � �t�� � � ��� � �d� ��fdd��� �fdd��� �fdd�}� �dd�}� �d � |�|� |S ) N� * OK [IMAP4rev1]c s � � ��� �� d d� d S )Nr� s 0003 FETCH 1 (RFC822)�r? r� r> �r� �rB r� r. r1 �cbCheckTransport; s �z>HandCraftedTests.testTrailingLiteral.<locals>.cbCheckTransportc s, � � d�}� �d� � �d� |��� |S )Nr� s6 * 1 FETCH (RFC822 {10} 0123456789 RFC822.SIZE 10) s 0003 OK FETCH )� fetchMessager� r� �r� r� )r� r r. r1 �cbSelectA s � z6HandCraftedTests.testTrailingLiteral.<locals>.cbSelectc s" � � d�}� �d� |��� |S �NrF � 0002 OK SELECT)rd ry r� r )r� r r. r1 �cbLoginJ s z5HandCraftedTests.testTrailingLiteral.<locals>.cbLogin� blah� 0001 OK LOGIN )r' r r~ r� ry r� r� r� )rB r r� r. )r� r r rB r� r1 �testTrailingLiteral5 s z$HandCraftedTests.testTrailingLiteralc C s� | j j�dd� t� }| j �|� |�� | j �d� | �|�� d� |�� | j �d� | �|�� d� |�� | j �d� | � |�� � | j �d� | �|�� d � | �| j j d � | j � t � d �� d S ) z] String literals whose data is not immediately available are parsed. rk rn s 01 LOGIN {8} s + Ready for 8 octets of text s testuser {13} s + Ready for 13 octets of text s passwords -test � 01 OK LOGIN succeeded r� r� N)r� rr rq r' r� r� r� r? r� � assertNotr� r� r r� r r. r. r1 � test_fragmentedStringLiteralsU s z.HandCraftedTests.test_fragmentedStringLiteralsc C s� ddi| j j_t� }| j �|� |�� | j �d� | �|�� d� |�� | j �d� | �|�� d� | �| j j d� | j � t � d�� dS ) z3 Empty string literals are parsed. r� s 01 LOGIN {0} s + Ready for 0 octets of text s {0} r r� r� N) r� rr r r' r� r� r� r? r� r� r� r r� r r. r. r1 �test_emptyStringLiteralo s z(HandCraftedTests.test_emptyStringLiteralc �t t � �t� � � ��� � �d� � fdd�}� fdd�}� fdd�}� ��fdd �}|� �t|���t|���|�S ) a^ If unsolicited data is received along with solicited data in the response to a I{FETCH} command issued by L{IMAP4Client.fetchSpecific}, the unsolicited data is passed to the appropriate callback and not included in the result with which the L{Deferred} returned by L{IMAP4Client.fetchSpecific} fires. r c � � � dd�} � �d� | S �Nr r �r� r� r� r� r. r1 r� � � zRHandCraftedTests.test_unsolicitedResponseMixedWithSolicitedResponse.<locals>.loginc � � � d�} � �d� | S r �rd ry r� r� r. r1 rd � � zSHandCraftedTests.test_unsolicitedResponseMixedWithSolicitedResponse.<locals>.selectc sz � j dddgd�} � �d� � �d� � �d� � �d� � �d � � �d � � �d � � �d� � �d� � �d � | S ) Nr� � HEADER.FIELDS�SUBJECT�� headerType� headerArgss1 * 1 FETCH (BODY[HEADER.FIELDS ("SUBJECT")] {38} s$ Subject: Suprise for your woman... r_ � ) s * 1 FETCH (FLAGS (\Seen)) s1 * 2 FETCH (BODY[HEADER.FIELDS ("SUBJECT")] {75} sI Subject: What you been doing. Order your meds here . ,. handcuff madsen � 0003 OK FETCH completed �� fetchSpecificr� r� r� r. r1 rO � s � � zRHandCraftedTests.test_unsolicitedResponseMixedWithSolicitedResponse.<locals>.fetchc s^ �� ��� �� d d� �� | dddggdggdddggdggd�� �� � jd d gi� d S ) Nr� �, 0003 FETCH 1:* BODY[HEADER.FIELDS (SUBJECT)]r� r$ r% z&Subject: Suprise for your woman... zKSubject: What you been doing. Order your meds here . ,. handcuff madsen �r� r� r� �\Seen�r? r� r> ro ��res�r� rB r� r. r1 rG � s& ��� ����zQHandCraftedTests.test_unsolicitedResponseMixedWithSolicitedResponse.<locals>.test�r' r r� ry r� r4 �rB r� rd rO rG r. r3 r1 �2test_unsolicitedResponseMixedWithSolicitedResponse� s �zCHandCraftedTests.test_unsolicitedResponseMixedWithSolicitedResponsec s� t � �t�� � � ��� � �d� � fdd�}� fdd�}� fdd�}��fdd �}|� }|�t|�� |�t|�� |�|� |S ) zf Literals should be recognized even when they are not preceded by whitespace. r c r r r r� �r� r. r1 r� � r zFHandCraftedTests.test_literalWithoutPrecedingWhitespace.<locals>.loginc r! )N� inboxr r" r� r7 r. r1 rd � r# zGHandCraftedTests.test_literalWithoutPrecedingWhitespace.<locals>.selectc s* � j dddgd�} � �d� � �d� | S )Nr� r$ r% r& s8 * 1 FETCH (BODY[HEADER.FIELDS ({7} SUBJECT)] "Hello") r* r+ r� r7 r. r1 rO � s �� zFHandCraftedTests.test_literalWithoutPrecedingWhitespace.<locals>.fetchc s: � � ��� �� d d� � � | ddddggdggi� d S )Nr� r- r� r� r$ r% �Hellor r� r r. r1 rG � s ��zEHandCraftedTests.test_literalWithoutPrecedingWhitespace.<locals>.test�r' r r~ r� ry r� r4 )rB r� rd rO rG r� r. �r� rB r� r1 �&test_literalWithoutPrecedingWhitespace� s z7HandCraftedTests.test_literalWithoutPrecedingWhitespacec sp t � �t�� � � ��� � �d� � fdd�}� fdd�}� ��fdd�}|� }|�t|�� |�t|�� |S )z� If the server sends a literal length which cannot be parsed as an integer, L{IMAP4Client.lineReceived} should cause the protocol to be disconnected by raising L{imap4.IllegalServerResponse}. r c r r r r� r7 r. r1 r� r z<HandCraftedTests.test_nonIntegerLiteralLength.<locals>.loginc r! r r" r� r7 r. r1 rd r# z=HandCraftedTests.test_nonIntegerLiteralLength.<locals>.selectc s@ � j dddgd� ����� �� d d� ��tj� jd� d S )Nr� r$ r% r& r� r- s * 1 FETCH {xyz} ...)r, r? r� r> r� r �IllegalServerResponser� r. r; r. r1 rO s ���z<HandCraftedTests.test_nonIntegerLiteralLength.<locals>.fetchr: )rB r� rd rO r� r. r; r1 � test_nonIntegerLiteralLength� s z-HandCraftedTests.test_nonIntegerLiteralLengthc sr t � }t� � � �|� � �d� � fdd�}� fdd�}� fdd�}� �fdd �}|� �t|���t|���|�S ) a Any unrequested flag information received along with other requested information in an untagged I{FETCH} received in response to a request issued with L{IMAP4Client.fetchSpecific} is passed to the C{flagsChanged} callback. r c r r r r� r� r. r1 r� 3 r zLHandCraftedTests.test_flagsChangedInsideFetchSpecificResponse.<locals>.loginc r! r r" r� r� r. r1 rd 8 r# zMHandCraftedTests.test_flagsChangedInsideFetchSpecificResponse.<locals>.selectc s\ � j dddgd�} � �d� � �d� � �d� � �d� � �d � � �d � � �d � | S ) Nr� r$ r% r& s1 * 1 FETCH (BODY[HEADER.FIELDS ("SUBJECT")] {22} s Subject: subject one s FLAGS (\Recent)) s? * 2 FETCH (FLAGS (\Seen) BODY[HEADER.FIELDS ("SUBJECT")] {22} s Subject: subject two r) r* r+ r� r� r. r1 rO = s � � zLHandCraftedTests.test_flagsChangedInsideFetchSpecificResponse.<locals>.fetchc sJ �� | dddggdggdddggdggd�� �� � jdgdgd�� d S ) Nr� r$ r% zSubject: subject one zSubject: subject two r. r� r/ )r? ro r1 �r� rB r. r1 rG N s �� ���� zKHandCraftedTests.test_flagsChangedInsideFetchSpecificResponse.<locals>.testr4 )rB r� r� rd rO rG r. r? r1 �,test_flagsChangedInsideFetchSpecificResponse' s �z=HandCraftedTests.test_flagsChangedInsideFetchSpecificResponsec r ) a Any unrequested flag information received along with other requested information in an untagged I{FETCH} received in response to a request issued with L{IMAP4Client.fetchMessage} is passed to the C{flagsChanged} callback. r c r r r r� r� r. r1 r� x r zKHandCraftedTests.test_flagsChangedInsideFetchMessageResponse.<locals>.loginc r! r r" r� r� r. r1 rd } r# zLHandCraftedTests.test_flagsChangedInsideFetchMessageResponse.<locals>.selectc sT � � d�} � �d� � �d� � �d� � �d� � �d� � �d� � �d� | S ) Nr� s * 1 FETCH (RFC822 {24} s Subject: first subject s FLAGS (\Seen)) s. * 2 FETCH (FLAGS (\Recent \Seen) RFC822 {25} s Subject: second subject r) r* )r r� r� r� r. r1 rO � s zKHandCraftedTests.test_flagsChangedInsideFetchMessageResponse.<locals>.fetchc sP �� ��� �� d d� �� | ddiddid�� �� � jdgddgd�� d S ) Nr� s 0003 FETCH 1:* (RFC822)ry zSubject: first subject zSubject: second subject r. r/ r� r0 r1 r3 r. r1 rG � s ��� zJHandCraftedTests.test_flagsChangedInsideFetchMessageResponse.<locals>.testr4 r5 r. r3 r1 �+test_flagsChangedInsideFetchMessageResponsel s �z<HandCraftedTests.test_flagsChangedInsideFetchMessageResponsec C s� t � }t�� }||_|�|� |�d� t�d�}|�|� |�d�}| � |t j � |� d� | � tj�}| �t|�d� | �|d jjd d� |S )z� When decoding a base64 encoded authentication message from the server, decoding errors are logged and then the client closes the connection. sP * OK [CAPABILITY IMAP4rev1 IDLE NAMESPACE AUTH=CRAM-MD5] Twisted IMAP4rev1 Readyrk r� s + Something bad! and bad r� r s Something bad! and bad)r( r r~ r� r� ry r� r� r� � assertFailurer r� r� r r= r? r� r� rv )rB r� r� r� r� �loggedr. r. r1 �-test_authenticationChallengeDecodingException� s � z>HandCraftedTests.test_authenticationChallengeDecodingExceptionN) ri rj rk r r r r6 r< r> r@ rA rD r. r. r. r1 r 4 s L.+E 8r c @ s. e Zd ZU dZejZeej ed< dd� Z dS )�PreauthIMAP4ClientMixinav Mixin for L{SynchronousTestCase} subclasses which provides a C{setUp} method which creates an L{IMAP4Client} connected to a L{StringTransport} and puts it into the I{authenticated} state. @ivar transport: A L{StringTransport} to which C{client} is connected. @ivar client: An L{IMAP4Client} which is connected to C{transport}. �clientProtocolc C s0 t � | _| �� | _| j�| j� | j�d� dS )zm Create an IMAP4Client connected to a fake transport and in the authenticated state. s * PREAUTH Hello unittest N)r' r� rF r� r� r� rL r. r. r1 r� � s z PreauthIMAP4ClientMixin.setUpN) ri rj rk r r r~ rF r rV r� r. r. r. r1 rE � s rE c @ � e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�SelectionTestsMixinzl Mixin for test cases which defines tests which apply to both I{EXAMINE} and I{SELECT} support. c C s2 t | j| j�d�}| �| j�� d| j d � |S )z� Issue either an I{EXAMINE} or I{SELECT} command (depending on C{self.method}), assert that the correct bytes are written to the transport, and return the L{Deferred} returned by whichever method was called. �fooboxs 0001 s foobox )r� r� �methodr? r� r� r� �rB r� r. r. r1 �_examineOrSelect� s �z$SelectionTestsMixin._examineOrSelectc G s4 |D ] }| j �|d � q| j �d| j d � dS )z� Deliver the given (unterminated) response lines to C{self.client} and then deliver a tagged SELECT or EXAMINE completion line to finish the SELECT or EXAMINE response. r_ s 0001 OK [READ-ONLY] s completed N)r� r� r� )rB �linesr{ r. r. r1 � _response� s �z SelectionTestsMixin._responsec C �. | � � }| �d� | �| �|�ddd�� dS )a If the server response to a I{SELECT} or I{EXAMINE} command includes an I{EXISTS} response, the L{Deferred} return by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'EXISTS'} key. s * 3 EXISTSFr� )r. r- N�rL rN r? �successResultOfrK r. r. r1 � test_exists� � z SelectionTestsMixin.test_existsc C �$ | � � }| �d� | �|tj� dS )a If the server returns a non-integer EXISTS value in its response to a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fails with L{IllegalServerResponse}. s * foo EXISTSN�rL rN �failureResultOfr r= rK r. r. r1 �test_nonIntegerExists � z)SelectionTestsMixin.test_nonIntegerExistsc C rO )a If the server response to a I{SELECT} or I{EXAMINE} command includes an I{RECENT} response, the L{Deferred} return by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'RECENT'} key. s * 5 RECENTFr� )r. r NrP rK r. r. r1 � test_recent rS z SelectionTestsMixin.test_recentc C rT )a If the server returns a non-integer RECENT value in its response to a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fails with L{IllegalServerResponse}. s * foo RECENTNrU rK r. r. r1 �test_nonIntegerRecent rX z)SelectionTestsMixin.test_nonIntegerRecentc C rO )a If the server response to a I{SELECT} or I{EXAMINE} command includes an I{UNSEEN} response, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'UNSEEN'} key. s) * OK [UNSEEN 8] Message 8 is first unseenFr� )r. r NrP rK r. r. r1 � test_unseen) rS z SelectionTestsMixin.test_unseenc C rT )a If the server returns a non-integer UNSEEN value in its response to a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fails with L{IllegalServerResponse}. s- * OK [UNSEEN foo] Message foo is first unseenNrU rK r. r. r1 �test_nonIntegerUnseen4 rX z)SelectionTestsMixin.test_nonIntegerUnseenc C rO )a) If the server response to a I{SELECT} or I{EXAMINE} command includes an I{UIDVALIDITY} response, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'UIDVALIDITY'} key. s# * OK [UIDVALIDITY 12345] UIDs validFr� )r. r NrP rK r. r. r1 �test_uidvalidity? � �z$SelectionTestsMixin.test_uidvalidityc C rT )a If the server returns a non-integer UIDVALIDITY value in its response to a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fails with L{IllegalServerResponse}. s! * OK [UIDVALIDITY foo] UIDs validNrU rK r. r. r1 �test_nonIntegerUIDVALIDITYL rX z.SelectionTestsMixin.test_nonIntegerUIDVALIDITYc C rO )a! If the server response to a I{SELECT} or I{EXAMINE} command includes an I{UIDNEXT} response, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'UIDNEXT'} key. s& * OK [UIDNEXT 4392] Predicted next UIDFi( )r. r NrP rK r. r. r1 � test_uidnextW r^ z SelectionTestsMixin.test_uidnextc C rT )a If the server returns a non-integer UIDNEXT value in its response to a I{SELECT} or I{EXAMINE} command, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fails with L{IllegalServerResponse}. s% * OK [UIDNEXT foo] Predicted next UIDNrU rK r. r. r1 �test_nonIntegerUIDNEXTd rX z*SelectionTestsMixin.test_nonIntegerUIDNEXTc C rO )� If the server response to a I{SELECT} or I{EXAMINE} command includes an I{FLAGS} response, the L{Deferred} returned by L{IMAP4Client.select} or L{IMAP4Client.examine} fires with a C{dict} including the value associated with the C{'FLAGS'} key. s2 * FLAGS (\Answered \Flagged \Deleted \Seen \Draft)F)r� z\FlaggedrC r/ z\Draft)r. rm NrP rK r. r. r1 � test_flagso s ��z SelectionTestsMixin.test_flagsc C rO )rb sN * OK [PERMANENTFLAGS (\Starred)] Just one permanent flag in that list up thereF)z\Starred)r. �PERMANENTFLAGSNrP rK r. r. r1 �test_permanentflags� s ��z'SelectionTestsMixin.test_permanentflagsc C �, | � � }| �d� | �| �|�ddi� dS )z� If the server response to a I{SELECT} or I{EXAMINE} command includes an I{OK} with unrecognized response code text, parsing does not fail. s3 * OK [X-MADE-UP] I just made this response text up.r. FNrP rK r. r. r1 �test_unrecognizedOk� s z'SelectionTestsMixin.test_unrecognizedOkc C rf )z� If the server response to a I{SELECT} or I{EXAMINE} command includes an I{OK} with no response code text, parsing does not fail. s * OKr. FNrP rK r. r. r1 � test_bareOk� s z SelectionTestsMixin.test_bareOkN)ri rj rk r rL rN rR rW rY rZ r[ r\ r] r_ r` ra rc re rg rh r. r. r. r1 rH � s$ rH c @ � e Zd ZdZdZdZdS )�IMAP4ClientExamineTestsa� Tests for the L{IMAP4Client.examine} method. An example of usage of the EXAMINE command from RFC 3501, section 6.3.2:: S: * 17 EXISTS S: * 2 RECENT S: * OK [UNSEEN 8] Message 8 is first unseen S: * OK [UIDVALIDITY 3857529045] UIDs valid S: * OK [UIDNEXT 4392] Predicted next UID S: * FLAGS (\Answered \Flagged \Deleted \Seen \Draft) S: * OK [PERMANENTFLAGS ()] No permanent flags permitted S: A932 OK [READ-ONLY] EXAMINE completed r4 s EXAMINEN�ri rj rk r rJ r� r. r. r. r1 rj � s rj c @ ri )�IMAP4ClientSelectTestsa Tests for the L{IMAP4Client.select} method. An example of usage of the SELECT command from RFC 3501, section 6.3.1:: C: A142 SELECT INBOX S: * 172 EXISTS S: * 1 RECENT S: * OK [UNSEEN 12] Message 12 is first unseen S: * OK [UIDVALIDITY 3857529045] UIDs valid S: * OK [UIDNEXT 4392] Predicted next UID S: * FLAGS (\Answered \Flagged \Deleted \Seen \Draft) S: * OK [PERMANENTFLAGS (\Deleted \Seen \*)] Limited S: A142 OK [READ-WRITE] SELECT completed rd s SELECTNrk r. r. r. r1 rl � s rl c @ r� ) �IMAP4ClientExpungeTestsa Tests for the L{IMAP4Client.expunge} method. An example of usage of the EXPUNGE command from RFC 3501, section 6.4.3:: C: A202 EXPUNGE S: * 3 EXPUNGE S: * 3 EXPUNGE S: * 5 EXPUNGE S: * 8 EXPUNGE S: A202 OK EXPUNGE completed c C s* | j �� }| �| j�� d� | j�� |S )Ns 0001 EXPUNGE )r� rJ r? r� r� r� rK r. r. r1 �_expunge� s z IMAP4ClientExpungeTests._expungec C s2 |D ]}| j �td|� d��� q| j �d� d S )Nz* z EXPUNGEs 0001 OK EXPUNGE COMPLETED)r� ry r& )rB �sequenceNumbers�numberr. r. r1 rN � s z!IMAP4ClientExpungeTests._responsec C �0 | � � }| �g d�� | �| �|�g d�� dS )z� L{IMAP4Client.expunge} sends the I{EXPUNGE} command and returns a L{Deferred} which fires with a C{list} of message sequence numbers given by the server's response. )r� r� r� r� N)rn rN r? rQ rK r. r. r1 � test_expunge� � z$IMAP4ClientExpungeTests.test_expungec C �( | � � }| �g d�� | �|tj� dS )z� If the server responds with a non-integer where a message sequence number is expected, the L{Deferred} returned by L{IMAP4Client.expunge} fails with L{IllegalServerResponse}. )r� r� r! r� N)rn rN rV r r= rK r. r. r1 �test_nonIntegerExpunged� � z/IMAP4ClientExpungeTests.test_nonIntegerExpungedN)ri rj rk r rn rN rr ru r. r. r. r1 rm � s rm c @ r� ) �IMAP4ClientSearchTestsa� Tests for the L{IMAP4Client.search} method. An example of usage of the SEARCH command from RFC 3501, section 6.4.4:: C: A282 SEARCH FLAGGED SINCE 1-Feb-1994 NOT FROM "Smith" S: * SEARCH 2 84 882 S: A282 OK SEARCH completed C: A283 SEARCH TEXT "string not in mailbox" S: * SEARCH S: A283 OK SEARCH completed C: A284 SEARCH CHARSET UTF-8 TEXT {6} C: XXXXXX S: * SEARCH 43 S: A284 OK SEARCH completed c C s* | j �tjdd��}| �| j�� d� |S )N�ABCDEF)rC s 0001 SEARCH (TEXT "ABCDEF") )r� �searchr r� r? r� r� rK r. r. r1 �_search s z IMAP4ClientSearchTests._searchc C s0 | j �dtd�tt|��� � | j �d� d S )Ns * SEARCH � s 0001 OK SEARCH completed)r� ry r& r� �mapr� )rB �messageNumbersr. r. r1 rN s �z IMAP4ClientSearchTests._responsec C rq )z� L{IMAP4Client.search} sends the I{SEARCH} command and returns a L{Deferred} which fires with a C{list} of message sequence numbers given by the server's response. )r� r� r� N)rz rN r? rQ rK r. r. r1 � test_search rs z"IMAP4ClientSearchTests.test_searchc C rt )z� If the server responds with a non-integer where a message sequence number is expected, the L{Deferred} returned by L{IMAP4Client.search} fails with L{IllegalServerResponse}. )r� r! r� N)rz rN rV r r= rK r. r. r1 �test_nonIntegerFound$ rv z+IMAP4ClientSearchTests.test_nonIntegerFoundN)ri rj rk r rz rN r~ r r. r. r. r1 rw � s rw c @ r� )'�IMAP4ClientFetchTestszV Tests for the L{IMAP4Client.fetch} method. See RFC 3501, section 6.4.5. c C s� | j �d�}| �| j�� d� | j �d� | j �d� | j �d� | j �d� | j �d� | �| �|�dd idd idd idd id �� dS )a L{IMAP4Client.fetchUID} sends the I{FETCH UID} command and returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{dict}s mapping C{'UID'} to that message's I{UID} in the server's response. �1:7� 0001 FETCH 1:7 (UID) � * 2 FETCH (UID 22)s * 3 FETCH (UID 23)� * 4 FETCH (UID 24)s * 5 FETCH (UID 25)� 0001 OK FETCH completedr{ �22�23�24�25�r� r� r� r� N)r� �fetchUIDr? r� r� ry rQ rK r. r. r1 � test_fetchUID6 s �z#IMAP4ClientFetchTests.test_fetchUIDc C sH | j �d�}| �| j�� d� | j �d� | j �d� | �|tj� dS )z� If the server responds with a non-integer where a message sequence number is expected, the L{Deferred} returned by L{IMAP4Client.fetchUID} fails with L{IllegalServerResponse}. r� s 0001 FETCH 1 (UID) s * foo FETCH (UID 22)r� N� r� r� r? r� r� ry rV r r= rK r. r. r1 � test_fetchUIDNonIntegerFoundI s z2IMAP4ClientFetchTests.test_fetchUIDNonIntegerFoundc C s` | j �d�}| �| j�� d� | j �d� | j �d� | j �d� | j �d� | �|tj� dS )z� If the server responds with an incomplete I{FETCH} response line, the L{Deferred} returned by L{IMAP4Client.fetchUID} fails with L{IllegalServerResponse}. r� r� r� s * 3 FETCH (UID)r� r� Nr� rK r. r. r1 � test_incompleteFetchUIDResponseU s z5IMAP4ClientFetchTests.test_incompleteFetchUIDResponsec C sT | j �d�}| �| j�� d� | j �d� | j �d� | �| �|�dddii� dS ) a L{IMAP4Client.fetchBody} sends the I{FETCH BODY} command and returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{dict}s mapping C{'RFC822.TEXT'} to that message's body as given in the server's response. �3s 0001 FETCH 3 (RFC822.TEXT) s& * 3 FETCH (RFC822.TEXT "Message text")r� r� rw z Message textN)r� � fetchBodyr? r� r� ry rQ rK r. r. r1 �test_fetchBodyc s z$IMAP4ClientFetchTests.test_fetchBodyc C �X | j �d�}| �| j�� d� | j �d� | j �d� | �| �|�ddg dggi� dS ) aI L{IMAP4Client.fetchSpecific} sends the I{BODY[]} command if no parameters beyond the message set to retrieve are given. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. �7� 0001 FETCH 7 BODY[] s * 7 FETCH (BODY[] "Some body")r� r� r� � Some bodyN�r� r, r? r� r� ry rQ rK r. r. r1 �test_fetchSpecificp s "z(IMAP4ClientFetchTests.test_fetchSpecificc C s\ | j jddd�}| �| j�� d� | j �d� | j �d� | �| �|�ddg d ggi� d S ) z� L{IMAP4Client.fetchSpecific} issues a I{BODY.PEEK[]} command if passed C{True} for the C{peek} parameter. �6T)r� s 0001 FETCH 6 BODY.PEEK[] s * 6 FETCH (BODY[] "Some body")r� r� r� r� Nr� rK r. r. r1 �test_fetchSpecificPeek~ s "z,IMAP4ClientFetchTests.test_fetchSpecificPeekc C s^ | j jddd�}| �| j�� d� | j �d� | j �d� | �| �|�ddd gd ggi� d S ) a; L{IMAP4Client.fetchSpecific}, when passed a sequence for C{headerNumber}, sends the I{BODY[N.M]} command. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. r� r� �� headerNumbers 0001 FETCH 7 BODY[1.2.3] s# * 7 FETCH (BODY[1.2.3] "Some body")r� r� r� z1.2.3r� Nr� rK r. r. r1 �test_fetchSpecificNumbered� s �z0IMAP4ClientFetchTests.test_fetchSpecificNumberedc C �^ | j jddd�}| �| j�� d� | j �d� | j �d� | �| �|�dddgd ggi� d S ) a1 L{IMAP4Client.fetchSpecific}, when passed C{'TEXT'} for C{headerType}, sends the I{BODY[TEXT]} command. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. �8�TEXT�r' � 0001 FETCH 8 BODY[TEXT] s" * 8 FETCH (BODY[TEXT] "Some body")r� r� r� r� Nr� rK r. r. r1 �test_fetchSpecificText� � �z,IMAP4ClientFetchTests.test_fetchSpecificTextc C s` | j jdddd�}| �| j�� d� | j �d� | j �d� | �| �|�dd d gd ggi� d S ) ah If passed a value for the C{headerNumber} parameter and C{'TEXT'} for the C{headerType} parameter, L{IMAP4Client.fetchSpecific} sends a I{BODY[number.TEXT]} request and returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of message data given by the server's response. �4r� r� )r' r� s 0001 FETCH 4 BODY[7.TEXT] s$ * 4 FETCH (BODY[7.TEXT] "Some body")r� r� r� z7.TEXTr� Nr� rK r. r. r1 � test_fetchSpecificNumberedText� s �z4IMAP4ClientFetchTests.test_fetchSpecificNumberedTextc C �L | j jddd�}| �| j�� d� | j �d� | j �d� | �|tj� dS )z� If the server responds to a I{BODY[TEXT]} request with a I{FETCH} line which is truncated after the I{BODY[TEXT]} tokens, the L{Deferred} returned by L{IMAP4Client.fetchUID} fails with L{IllegalServerResponse}. r� r� r� r� s * 8 FETCH (BODY[TEXT])r� N� r� r, r? r� r� ry rV r r= rK r. r. r1 �(test_incompleteFetchSpecificTextResponse� � z>IMAP4ClientFetchTests.test_incompleteFetchSpecificTextResponsec C r� ) a1 L{IMAP4Client.fetchSpecific}, when passed C{'MIME'} for C{headerType}, sends the I{BODY[MIME]} command. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. r� r� r� s 0001 FETCH 8 BODY[MIME] s" * 8 FETCH (BODY[MIME] "Some body")r� r� r� r� Nr� rK r. r. r1 �test_fetchSpecificMIME� r� z,IMAP4ClientFetchTests.test_fetchSpecificMIMEc C sd | j jddddd�}| �| j�� d� | j �d� | j �d� | �| �|�d d dgd d ggi� d S )aX L{IMAP4Client.fetchSpecific}, when passed C{offset} and C{length}, sends a partial content request (like I{BODY[TEXT]<offset.length>}). It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. �9r� r r� )r' �offset�lengths 0001 FETCH 9 BODY[TEXT]<17.3> s * 9 FETCH (BODY[TEXT]<17> "foo")r� r� r� z<17>r! Nr� rK r. r. r1 �test_fetchSpecificPartial� s �z/IMAP4ClientFetchTests.test_fetchSpecificPartialc C r� )a If the server responds to a I{BODY[TEXT]} request with a I{FETCH} line which is truncated after the I{BODY[TEXT]<offset>} tokens, the L{Deferred} returned by L{IMAP4Client.fetchUID} fails with L{IllegalServerResponse}. r� r� r� r� s * 8 FETCH (BODY[TEXT]<17>)r� Nr� rK r. r. r1 �+test_incompleteFetchSpecificPartialResponse� r� zAIMAP4ClientFetchTests.test_incompleteFetchSpecificPartialResponsec C r� ) aA If the body of a message begins with I{<} and ends with I{>} (as, for example, HTML bodies typically will), this is still interpreted as the body by L{IMAP4Client.fetchSpecific} (and particularly, not as a length indicator for a response to a request for a partial body). r� r� s& * 7 FETCH (BODY[] "<html>test</html>")r� r� r� z<html>test</html>Nr� rK r. r. r1 �test_fetchSpecificHTML� s �z,IMAP4ClientFetchTests.test_fetchSpecificHTMLc C s| | j jd|d�}| �| j�� d|�d� d � | j �d|�d� d � | j �d� | �| �|�d d |g gd ggi� d S ) a� Assert that the provided C{BODY} section, when invoked with no arguments, produces an empty list, and that it returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. @param section: The C{BODY} section to test: either C{'HEADER.FIELDS'} or C{'HEADER.FIELDS.NOT'} @type section: L{str} �10r� s 0001 FETCH 10 BODY[r� s ()] s * 10 FETCH (BODY[s ()] "")r� r� r� r� N)r� r, r? r� r� r@ ry rQ )rB �sectionr� r. r. r1 �&assertFetchSpecificFieldsWithEmptyList s �� &z<IMAP4ClientFetchTests.assertFetchSpecificFieldsWithEmptyListc C r� )az L{IMAP4Client.fetchSpecific}, when passed C{'HEADER.FIELDS'} for C{headerType} but no C{headerArgs}, sends the I{BODY[HEADER.FIELDS]} command with no arguments. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. r$ N�r� rL r. r. r1 �,test_fetchSpecificHeaderFieldsWithoutHeaders � zBIMAP4ClientFetchTests.test_fetchSpecificHeaderFieldsWithoutHeadersc C r� )a� L{IMAP4Client.fetchSpecific}, when passed C{'HEADER.FIELDS.NOT'} for C{headerType} but no C{headerArgs}, sends the I{BODY[HEADER.FIELDS.NOT]} command with no arguments. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. zHEADER.FIELDS.NOTNr� rL r. r. r1 �/test_fetchSpecificHeaderFieldsNotWithoutHeaders& r� zEIMAP4ClientFetchTests.test_fetchSpecificHeaderFieldsNotWithoutHeadersc C r� ) a= L{IMAP4Client.fetchSpecific}, when passed C{'HEADER'} for C{headerType}, sends the I{BODY[HEADER]} command. It returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{list}s of corresponding message data given by the server's response. �11�HEADERr� s 0001 FETCH 11 BODY[HEADER] sJ * 11 FETCH (BODY[HEADER] "From: someone@localhost Subject: Some subject")r� r� r� z.From: someone@localhost Subject: Some subjectNr� rK r. r. r1 �test_fetchSpecificHeader1 s � ����z.IMAP4ClientFetchTests.test_fetchSpecificHeaderN)ri rj rk r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r. r. r. r1 r� / s( r� c @ st e Zd ZdZeZdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� ZdS )�IMAP4ClientStoreTestsa� Tests for the L{IMAP4Client.setFlags}, L{IMAP4Client.addFlags}, and L{IMAP4Client.removeFlags} methods. An example of usage of the STORE command, in terms of which these three methods are implemented, from RFC 3501, section 6.4.6:: C: A003 STORE 2:4 +FLAGS (\Deleted) S: * 2 FETCH (FLAGS (\Deleted \Seen)) S: * 3 FETCH (FLAGS (\Deleted)) S: * 4 FETCH (FLAGS (\Deleted \Flagged \Seen)) S: A003 OK STORE completed c C sh t | j|�ddd�}| �| j�� d| d � | j�d� | j�d� | �| �|�dd d d gii� d S ) am Test a non-silent flag modifying method. Call the method, assert that the correct bytes are sent, deliver a I{FETCH} response, and assert that the result of the Deferred returned by the method is correct. @param method: The name of the method to test. @param item: The data item which is expected to be specified. r� ��\Readr/ F� 0001 STORE 3 � (\Read \Seen) s * 3 FETCH (FLAGS (\Read \Seen))� 0001 OK STORE completedr� rm r� r/ N�r� r� r? r� r� ry rQ �rB rJ �itemr� r. r. r1 � _flagsTest_ s � "z IMAP4ClientStoreTests._flagsTestc C sP t | j|�ddd�}| �| j�� d| d � | j�d� | �| �|�i � dS )ag Test a silent flag modifying method. Call the method, assert that the correct bytes are sent, deliver an I{OK} response, and assert that the result of the Deferred returned by the method is correct. @param method: The name of the method to test. @param item: The data item which is expected to be specified. r� r� Tr� r� r� Nr� r� r. r. r1 �_flagsSilentlyTestp s � z(IMAP4ClientStoreTests._flagsSilentlyTestc C st t | j|�ddd�}| �| j�� d| d � | j�d� | j�d� | �| �|�i � | �| jjdd d gi� d S ) a� Test unsolicited data received in response to a silent flag modifying method. Call the method, assert that the correct bytes are sent, deliver the unsolicited I{FETCH} response, and assert that the result of the Deferred returned by the method is correct. @param method: The name of the method to test. @param item: The data item which is expected to be specified. r� r� Tr� r� s * 2 FETCH (FLAGS (\Read \Seen))r� r� r� r/ N)r� r� r? r� r� ry rQ ro r� r. r. r1 �%_flagsSilentlyWithUnsolicitedDataTest� s � z;IMAP4ClientStoreTests._flagsSilentlyWithUnsolicitedDataTestc C � | � dd� dS )aQ When passed a C{False} value for the C{silent} parameter, L{IMAP4Client.setFlags} sends the I{STORE} command with a I{FLAGS} data item and returns a L{Deferred} which fires with a C{dict} mapping message sequence numbers to C{dict}s mapping C{'FLAGS'} to the new flags of those messages. �setFlagsrd N�r� rL r. r. r1 � test_setFlags� s z#IMAP4ClientStoreTests.test_setFlagsc C r� )z� When passed a C{True} value for the C{silent} parameter, L{IMAP4Client.setFlags} sends the I{STORE} command with a I{FLAGS.SILENT} data item and returns a L{Deferred} which fires with an empty dictionary. r� � FLAGS.SILENTN�r� rL r. r. r1 �test_setFlagsSilently� � z+IMAP4ClientStoreTests.test_setFlagsSilentlyc C r� )z� If unsolicited flag data is received in response to a I{STORE} I{FLAGS.SILENT} request, that data is passed to the C{flagsChanged} callback. r� r� N�r� rL r. r. r1 �(test_setFlagsSilentlyWithUnsolicitedData� � z>IMAP4ClientStoreTests.test_setFlagsSilentlyWithUnsolicitedDatac C r� )z{ L{IMAP4Client.addFlags} is like L{IMAP4Client.setFlags}, but sends I{+FLAGS} instead of I{FLAGS}. �addFlagss +FLAGSNr� rL r. r. r1 � test_addFlags� � z#IMAP4ClientStoreTests.test_addFlagsc C r� )z� L{IMAP4Client.addFlags} with a C{True} value for C{silent} behaves like L{IMAP4Client.setFlags} with a C{True} value for C{silent}, but it sends I{+FLAGS.SILENT} instead of I{FLAGS.SILENT}. r� � +FLAGS.SILENTNr� rL r. r. r1 �test_addFlagsSilently� r� z+IMAP4ClientStoreTests.test_addFlagsSilentlyc C r� )z� L{IMAP4Client.addFlags} behaves like L{IMAP4Client.setFlags} when used in silent mode and unsolicited data is received. r� r� Nr� rL r. r. r1 �(test_addFlagsSilentlyWithUnsolicitedData� r� z>IMAP4ClientStoreTests.test_addFlagsSilentlyWithUnsolicitedDatac C r� )z~ L{IMAP4Client.removeFlags} is like L{IMAP4Client.setFlags}, but sends I{-FLAGS} instead of I{FLAGS}. � removeFlagss -FLAGSNr� rL r. r. r1 �test_removeFlags� r� z&IMAP4ClientStoreTests.test_removeFlagsc C r� )z� L{IMAP4Client.removeFlags} with a C{True} value for C{silent} behaves like L{IMAP4Client.setFlags} with a C{True} value for C{silent}, but it sends I{-FLAGS.SILENT} instead of I{FLAGS.SILENT}. r� � -FLAGS.SILENTNr� rL r. r. r1 �test_removeFlagsSilently� r� z.IMAP4ClientStoreTests.test_removeFlagsSilentlyc C r� )z� L{IMAP4Client.removeFlags} behaves like L{IMAP4Client.setFlags} when used in silent mode and unsolicited data is received. r� r� Nr� rL r. r. r1 �+test_removeFlagsSilentlyWithUnsolicitedData� r� zAIMAP4ClientStoreTests.test_removeFlagsSilentlyWithUnsolicitedDataN)ri rj rk r r rF r� r� r� r� r� r� r� r� r� r� r� r� r. r. r. r1 r� N s r� c @ r )�IMAP4ClientStatusTestsa_ Tests for the L{IMAP4Client.status} method. An example of usage of the STATUS command from RFC 3501, section 5.1.2:: C: A042 STATUS blurdybloop (UIDNEXT MESSAGES) S: * STATUS blurdybloop (MESSAGES 231 UIDNEXT 44292) S: A042 OK STATUS completed @see: U{https://tools.ietf.org/html/rfc3501#section-5.1.2} c C s2 | � t| jjdd�}| �t|�dtdh� � dS )z� Only allow sending the C{STATUS} names defined in RFC 3501. @see: U{https://tools.ietf.org/html/rfc3501#section-5.1.2} r� z IMPOSSIBLE?!zUnknown names: N)r� r� r� r� r? r� r� )rB �excr. r. r1 �testUnknownName� s � z&IMAP4ClientStatusTests.testUnknownNamec C sJ | j �dd�}| �| j�� d� | j �d� | j �d� | �|tj� dS )z� C{STATUS} names that cannot be decoded as ASCII cause the status Deferred to fail with L{IllegalServerResponse} � blurdybloopr s$ 0001 STATUS blurdybloop (MESSAGES) s? * STATUS blurdybloop (MESSAGES 1 ASCIINAME "OK" NOT�ASCII "NO")s 0001 OK STATUS completedN) r� r� r? r� r� ry rV r r= rK r. r. r1 �testUndecodableName� s �� z*IMAP4ClientStatusTests.testUndecodableNameN)ri rj rk r r� r� r. r. r. r1 r� � s r� c @ s4 e Zd ZdZeZdd� Zdd� Zdd� Zdd � Z d S ) �IMAP4ClientCopyTestsz� Tests for the L{IMAP4Client.copy} method. An example of the C{COPY} command, which this method implements, from RFC 3501, section 6.4.7:: C: A003 COPY 2:4 MEETING S: A003 OK COPY completed c C �J | j jdddd�}| �| j�� d� | j �d� | �| �|�g df� dS ) z� L{IMAP4Client.copy} copies the messages identified by their sequence numbers to the mailbox, returning a L{Deferred} that succeeds with a true value. r� �MEETINGFr� � 0001 COPY 2:3 MEETING � 0001 OK COPY completed� OK COPY completedN�r� �copyr? r� r� ry rQ rK r. r. r1 �test_copySequenceNumbers � � z-IMAP4ClientCopyTests.test_copySequenceNumbersc C �J | j jdddd�}| �| j�� d� | j �d� | �| �|�jtj � dS )z� L{IMAP4Client.copy} returns a L{Deferred} that fails with an L{IMAP4Exception} when the messages specified by the given sequence numbers could not be copied to the mailbox. r� r� Fr� r� � 0001 BAD COPY failedN� r� r� r? r� r� ry r� rV r r� rK r. r. r1 � test_copySequenceNumbersFails' r� z2IMAP4ClientCopyTests.test_copySequenceNumbersFailsc C r� ) z� L{IMAP4Client.copy} copies the messages identified by their UIDs to the mailbox, returning a L{Deferred} that succeeds with a true value. r� r� Tr� � 0001 UID COPY 2:3 MEETING r� r� Nr� rK r. r. r1 � test_copyUIDs7 r� z"IMAP4ClientCopyTests.test_copyUIDsc C r� )z� L{IMAP4Client.copy} returns a L{Deferred} that fails with an L{IMAP4Exception} when the messages specified by the given UIDs could not be copied to the mailbox. r� r� Tr� r� r� Nr� rK r. r. r1 �test_copyUIDsFailsG r� z'IMAP4ClientCopyTests.test_copyUIDsFailsN) ri rj rk r r rF r� r� r� r� r. r. r. r1 r� s r� c @ s e Zd ZdZdZdd� ZdS )� FakeyServerrd Nc C r2 r- r. rL r. r. r1 �sendServerGreeting\ r* z FakeyServer.sendServerGreeting)ri rj rk r� �timeoutr� r. r. r. r1 r� X s r� c @ �X e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )r� )r� ro r@ �_bodyr| c C s2 || _ || _|| _t|�| _|| _|| _|| _d S r- )r� ro r� r� �sizer@ r| �subpart)rB r� ro r@ r� r| r� r. r. r1 rp d s zFakeyMessage.__init__c G � ||f| _ | jS r- )� got_headersr� )rB r� r9 r. r. r1 � getHeadersm � zFakeyMessage.getHeadersc C r$ r- r% rL r. r. r1 r& q r' zFakeyMessage.getFlagsc C r$ r- )r@ rL r. r. r1 �getInternalDatet r' z FakeyMessage.getInternalDatec C s t | j�S r- )r r� rL r. r. r1 � getBodyFilew rq zFakeyMessage.getBodyFilec C r$ r- )r� rL r. r. r1 �getSizez r' zFakeyMessage.getSizec C r$ r- r� rL r. r. r1 r7 } r' zFakeyMessage.getUIDc C s | j d uS r- )r� rL r. r. r1 � isMultipart� rq zFakeyMessage.isMultipartc C s || _ | j| S r- )� got_subpartr� )rB r� r. r. r1 � getSubPart� s zFakeyMessage.getSubPartN) ri rj rk �showAttributesrp r� r& r� r r r7 r r r. r. r. r1 r� ` s r� c @ sF e Zd ZdZdZdd� Zdd� Zdd� Zdd � Zd d � Z dd d�Z dS )� NewStoreTestsNc C s@ d | _ | _t�� | _d| j_| | j_t�� | _ t | j �| _ d S �Nrd ) �received_messages� received_uidr ro r� r� r r r� r� r} r� rL r. r. r1 r� � s zNewStoreTests.setUpc C r2 r- r. �rB r5 r. r. r1 r � r* zNewStoreTests.addListenerc C r2 r- r. r r. r. r1 r" � r* z NewStoreTests.removeListenerc O r� r- )� storeArgsr{ )rB rv rw r. r. r1 rT � r� zNewStoreTests.storec sl � fdd�}� fdd�}� j �t|���|��� j��� j� � fdd�}tj� j� j dd�}|�|� |S ) Nc s � � � j� j� j� j�S r- )�functionr� ro �silentr| r. rL r. r1 r� � r} z+NewStoreTests._storeWork.<locals>.connectedc rX r- r� ��RrL r. r1 r/ � rq z(NewStoreTests._storeWork.<locals>.resultc s$ � � � j� j� � � � j� j� d S r- )r? r/ r? r � expectedArgsr rL r. r1 rb � r� z'NewStoreTests._storeWork.<locals>.checkF��noisy� r� r� r4 r� r� r� r � loopbackTCPr� r� )rB r� r/ rb r� r. rL r1 � _storeWork� s � zNewStoreTests._storeWorkr c C s� | j j| _d| _g d�| _d| _|| _g d�g d�g d�d�| _dg d�idg d�idg d�id�| _t � � }|� d� |� d� |� d� |g d�d fd d if| _ | � � S ) Nz1,5,9)z\Az\B�CF)r� r� r� rm r� r� r� r r| )r� r� r r� ro r r| r{ r? r r r� r r )rB r| r� r. r. r1 � testSetFlags� s& � � zNewStoreTests.testSetFlagsr� ) ri rj rk r/ r r� r r" rT r r r. r. r. r1 r � s r c @ r� )�GetBodyStructureTestsz� Tests for L{imap4.getBodyStructure}, a helper for constructing a list which directly corresponds to the wire information needed for a I{BODY} or I{BODYSTRUCTURE} response. c C s� d}d}d}d}d}d}d}t |d | d | d |||d �d d |dd�}t�|�} | �||d|ddg|||t|�g| � dS )z� L{imap4.getBodyStructure} accepts a L{IMessagePart} provider and returns a list giving the basic fields for the I{BODY} response for that message. � hello, world�image�jpeg�us-ascii�some kind of id� great justice�maximumr* � ; charset=�; x=y�r� � content-id�content-description�content-transfer-encodingr. r� r� N�charsetr5 �y�r� r �getBodyStructurer? r� � rB r� �major�minorr& r? � descriptionr� r� � structurer. r. r1 �test_singlePart� s> �� � �z%GetBodyStructureTests.test_singlePartc C s� t i ddddd�}t�|�}|dd� \}}| �d|� | �d|� t ddiddddd�}t�|�}|dd� \}}| �d|� | �d|� t ddiddddd�} t�| �} | dd� \} } | �d| � | �d| � dS ) z� L{imap4.getBodyStructure} returns L{None} for the major and minor MIME types of a L{IMessagePart} provider whose headers lack a C{Content-Type}, or have an empty value for it. r. r� r� Nr� r� r� � )r� r r) �assertIs) rB �missing�missingContentTypeStructure� missingMajor� missingMinorr� �emptyContentTypeStructure� emptyMajor� emptyMinor�newline�newlineContentTypeStructure� newlineMajor� newlineMinorr. r. r1 �test_emptyContentType� s z+GetBodyStructureTests.test_emptyContentTypec C sL t ddiddddd�}t�|�}|dd� \}}| �|d� | �|d� dS )z� L{imap4.getBodyStructure} returns only a non-L{None} major MIME type for a L{IMessagePart} provider whose headers only have a main a C{Content-Type}. r� �mainr. r� r� Nr� )r� r r) r? r1 )rB r> � mainStructure� mainMajor� mainMinorr. r. r1 �test_onlyMajorContentType s z/GetBodyStructureTests.test_onlyMajorContentTypec C s� d}d}d}d}d}d}d}d}t |d | d | d ||||d d dd�dd|dd�} tj| dd�} | �||d|ddg|||t|�|dg d�gd dg | � dS )z� L{imap4.getBodyStructure} returns a list giving the basic and extended fields for a I{BODYSTRUCTURE} response if passed C{True} for the C{extended} parameter. r r r r r r r � abcdefabcdefr* r r! z attachment; name=foo; size=bar�fr�France�r� r# r$ r% � content-md5�content-disposition�content-language�content-locationr. r� r� NT��extendedr& r5 r' � attachment)r_ r! r� r" r( ) rB r� r+ r, r& r? r- r� �md5r� r. r. r. r1 �test_singlePartExtended sP � � � �z-GetBodyStructureTests.test_singlePartExtendedc C sb d}d}d}t d|d | idd|dd �}tj|d d �}| �||d d d d t|�d d d d g |� d S ) z� For fields with no information contained in the message headers, L{imap4.getBodyStructure} fills in L{None} values in its result. r r r r� r* r. r� r� NTrK r( )rB r+ r, r� r� r. r. r. r1 �test_singlePartWithMissingN s � �z0GetBodyStructureTests.test_singlePartWithMissingc C s� d}d}d}d}d}d}d}t |d | d | d |||d �d d |dd�}t�|�} | �||d|ddg|||t|�t|�� �g| � dS )z� For a I{text/*} message, the number of lines in the message body are included after the common single-part basic fields. �" hello, world how are you? goodbye rC r r r r r r* r r! r" r. r� r� Nr& r5 r' )r� r r) r? r� r> r* r. r. r1 � test_textPart_ s@ �� � �z#GetBodyStructureTests.test_textPartc C s� d}d}d}d}d}d}d}t |d | d | d d d |||d �dd|dd�}t ddidddd|g�} t�| �} | �dddddddt�|�t�|�dg | � dS )z� For a I{message/rfc822} message, the common basic fields are followed by information about the contained message. rQ rC r r r r r r* r r! zAlice <alice@example.com>zBob <bob@example.com>)r� r{ r} r# r$ r% r. r� r� Nr� �message/rfc822r� r? rz r r� )r� r r) r? � getEnvelope) rB r� r+ r, r& r? r- r� r� � containerr. r. r. r1 �test_rfc822Message� sZ ���� � �z(GetBodyStructureTests.test_rfc822Messagec C st t ddddd�dddd d �}t d d iddd dd �}t d didddd||g�}| �t�|�t�|�dgt�|�� d S )z� For a I{multipart/*} message, L{imap4.getBodyStructure} returns a list containing the body structure information for each part of the message followed by an element giving the MIME subtype of the message. zimage/jpeg; x=yr r r r" r. r� � hello worldr� Nr� z text/plain; charset=us-ascii� some stuff�A zmultipart/related�+ �related�r� r? r r) �rB � oneSubPart�anotherSubPartrU r. r. r1 �test_multiPart� sJ ���� �� ��z$GetBodyStructureTests.test_multiPartc C s� t ddddd�dddd d �}t d d iddd dd �}t ddddd�dddd||g�}| �tj|dd�tj|dd�dddgddd ggddgtj|dd�� d S ) a) When passed a I{multipart/*} message and C{True} for the C{extended} argument, L{imap4.getBodyStructure} includes extended structure information from the parts of the multipart message and extended structure information about the multipart message itself. s image/jpeg; x=ys some kind of ids great justices maximum)� content-types content-ids content-descriptions content-transfer-encodingr. r� rW r� Nra s text/plain; charset=us-asciirX rY zmultipart/related; foo=bar�es�Spainzattachment; name=monkeys)r� rI rJ rH rZ TrK r[ r! r" rM r_ �monkeysr\ r] r. r. r1 �test_multiPartExtended� sX ���� �� � �z,GetBodyStructureTests.test_multiPartExtendedN) ri rj rk r r/ r= rB rO rP rR rV r` re r. r. r. r1 r � s ( 1(8 3r c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � ZdUdd�Z dd� Z dUdd�Z dd� Z e �e jd�Zz e �e jd� W n e jyJ dZY n w e �e je� dZeed�dd � �ZdUd d �Zd d � ZdUd!d"�Zd#d$� ZdUd%d&�ZdUd'd(�Zd)d*� ZdUd+d,�Z d-d.� Z dUd/d0�Z d1d2� Z d3d4� Z dUd5d6�Z!d7d8� Z"dUd9d:�Z#d;d<� Z$dUd=d>�Z%d?d@� Z&dAdB� Z'dCdD� Z(dUdEdF�Z)dGdH� Z*dUdIdJ�Z+dKdL� Z,dUdMdN�Z-dOdP� Z.dUdQdR�Z/dSdT� Z0dS )V� NewFetchTestsc C sF d | _ | _d | _t�� | _d| j_| | j_t� � | _ t | j �| _ d S r ) r r r/ r ro r� r� r r r� r� r} r� rL r. r. r1 r� / s zNewFetchTests.setUpc C r2 r- r. r r. r. r1 r 9 r* zNewFetchTests.addListenerc C r2 r- r. r r. r. r1 r" < r* z NewFetchTests.removeListenerc C s& || _ || _tttt| j��| j��S r- )r r �iterr� rd r� �msgObjsrN r. r. r1 rO ? s zNewFetchTests.fetchc s� �r t tt� j��� j�D ]\}}t|�� �� j| d< q � fdd�}� j�� �fdd���|��� j �� � j � t j � j� jdd�}|�� fdd�� |S ) Nr{ c rX r- r� r rL r. r1 r/ I rq z(NewFetchTests._fetchWork.<locals>.resultc s � � � j��S r- �r r� r� �rB r| r. r1 r2 M r� z*NewFetchTests._fetchWork.<locals>.<lambda>Fr c � � � � j� j�S r- �r? r/ r? �r5 rL r. r1 r2 S � )r� rd r� rh r� r7 r? r� r� r� r� r� r r r� r� )rB r| r� r� r/ r� r. rj r1 � _fetchWorkD s ��zNewFetchTests._fetchWorkc sn � fdd�� _ d� _ti ddddd �ti ddddd �ti ddddd �g� _d d id d id d id �� _� �d�S )Nc s � j �| �S r- �r� r� )r� �urL r. r1 r2 W r� z,NewFetchTests.testFetchUID.<locals>.<lambda>r� r. r� r� �� �u' r{ �12345�999�10101)r r� r� r )r r� r� rh r? ro rL r. rL r1 � testFetchUIDV s �� zNewFetchTests.testFetchUIDr c C sd | j j| _d| _ti g d�dddd �ti g d�dddd �g| _dg d�idg d�id�| _| �|�S ) Nr� )�FlagA�FlagB�\FlagCr� �1� )rz rx ry r� rm �r r� )r� � fetchFlagsr r� r� rh r? ro rj r. r. r1 �testFetchFlagsf s � � z NewFetchTests.testFetchFlagsc C � | � d�S r, )r~ rL r. r. r1 �testFetchFlagsUIDs rq z NewFetchTests.testFetchFlagsUIDc C s� | j j| _d| _ti ddddd �ti ddddd �ti dddd d �ti dd dd d �g| _d d id did did did�| _| �|�S )N�13r. s Fri, 02 Nov 2003 21:25:10 GMTr� i�Z s Thu, 29 Dec 2013 11:31:52 EST�e s Mon, 10 Mar 1992 02:44:30 CST�� s Sat, 11 Jan 2000 14:40:24 PSTi/ rp z02-Nov-2003 21:25:10 +0000z29-Dec-2013 11:31:52 -0500z10-Mar-1992 02:44:30 -0600z11-Jan-2000 14:40:24 -0800)r r� r� r� )r� �fetchInternalDater r� r� rh r? ro rj r. r. r1 �testFetchInternalDatev s �� z#NewFetchTests.testFetchInternalDatec C r r, )r� rL r. r. r1 �testFetchInternalDateUID� rq z&NewFetchTests.testFetchInternalDateUIDN� es_AR.UTF8TFz'The es_AR.UTF8 locale is not installed.c C s8 t �t jd�}t �t jd� | �t jt j|� | �d�S )zC The month name in the date is locale independent. Nr� r� )�locale� setlocale�LC_ALLr� r� )rB � currentLocaler. r. r1 �'test_fetchInternalDateLocaleIndependent� s z5NewFetchTests.test_fetchInternalDateLocaleIndependentc C sv | j j| _d| _tdddddd�dd d d d �g| _d d ddg d �gg d �gg d �gg d�gd d d dg ii| _| �|�S )N�15z user@domainz resu@domain�thursdayzit is a messagezid-id-id-yayaya)r{ r} r@ r z message-idr. r� ix r rj )NNr� �domain)NN�resur� )r� � fetchEnveloper r� r� rh r? ro rj r. r. r1 �testFetchEnvelope� s@ ������ z NewFetchTests.testFetchEnvelopec C r r, )r� rL r. r. r1 �testFetchEnvelopeUID� rq z"NewFetchTests.testFetchEnvelopeUIDc C st | j j| _d| _tdddddddd d �d d d dd�g| _ddddg d�dddddddddggdd g ii| _| �|�S )a[ L{IMAP4Client.fetchBodyStructure} issues a I{FETCH BODYSTRUCTURE} command and returns a Deferred which fires with a structure giving the result of parsing the server's response. The structure is a list reflecting the parenthesized data sent by the server, as described by RFC 3501, section 7.4.2. �3:9,10:*�#text/plain; name=thing; key="value"�this-is-the-content-id�!describing-the-content-goes-here!�8BIT� abcdef123456z attachment; filename=monkeysrb zhttp://example.com/monkeysrF r. r� � Body Text Goes Here � Nr r} rC �plain�r� r� r_ �thing�20r� rM �filenamerd �r� �fetchBodyStructurer r� r� rh r? ro rj r. r. r1 �test_fetchBodyStructure� sJ � �� ��� z%NewFetchTests.test_fetchBodyStructurec C r )z� If passed C{True} for the C{uid} argument, C{fetchBodyStructure} can also issue a I{UID FETCH BODYSTRUCTURE} command. r� )r� rL r. r. r1 �testFetchBodyStructureUID� s z'NewFetchTests.testFetchBodyStructureUIDc C s� | j j| _d| _tdddddddd d �d d d dd�}tdddd�d d d d|g�g| _ddddg d�ddddddddgdd g dd d gdddgii| _| �|�S ) z� L{IMAP4Client.fetchBodyStructure} can also parse the response to a I{FETCH BODYSTRUCTURE} command for a multipart message. r� r� r� r� r� rD � 123456abcdef�inlinez outer space)r� r# r$ r% rI rG rH rJ r. r� r� r� Nz multipart/mixed; boundary="xyz"�en�nearby)r� rI rJ r r} rC r� r� r� r� �mixed�boundary�xyzr� )rB r| � innerMessager. r. r1 � test_fetchBodyStructureMultipart sl � �������� z.NewFetchTests.test_fetchBodyStructureMultipartc C sV | j j| _d| _ti ddddtddidddd d �g�g| _d d g d �ii| _| �|�S ) N�21r. r� � Yea whatever�f r� � image/jpg� Body Body Bodyr r� �NNNNNN�12�r� �fetchSimplifiedBodyr r� r� rh r? ro rj r. r. r1 �testFetchSimplifiedBodyD s* ���� z%NewFetchTests.testFetchSimplifiedBodyc C r r, )r� rL r. r. r1 �testFetchSimplifiedBodyUID^ rq z(NewFetchTests.testFetchSimplifiedBodyUIDc C sF | j j| _d| _tddiddddd �g| _dd g d �ii| _| �|�S ) Nr� r� r� r. r� r� r� r r� )rC r� NNNNr� r� r� rj r. r. r1 �testFetchSimplifiedBodyTexta s �� � z)NewFetchTests.testFetchSimplifiedBodyTextc C r r, )r� rL r. r. r1 � testFetchSimplifiedBodyTextUIDo rq z,NewFetchTests.testFetchSimplifiedBodyTextUIDc C s� | j j| _d| _tddiddddtddidd d d d �g�g| _d d d dd d d d dd d g d�gg d�gd d d d d d g g d�dg ii| _| �|�S )Nr� r� rS r. r� r� r� r� r� r� r r� r? rz r� �NNN)r �jpgNNNN�14r� r� rj r. r. r1 � testFetchSimplifiedBodyRFC822r sZ ����� ��� z+NewFetchTests.testFetchSimplifiedBodyRFC822c C r r, )r� rL r. r. r1 � testFetchSimplifiedBodyRFC822UID� rq z.NewFetchTests.testFetchSimplifiedBodyRFC822UIDc C s� | j j| _d| _tddiddddd�tdd iddd d d�g}tdd idd dd|�}tddidd dd|g�}|g| _ddg d�g d�dgdgii| _| �d�S )ah L{IMAP4Client.fetchSimplifiedBody} returns a dictionary mapping message sequence numbers to fetch responses for the corresponding messages. In particular, for a multipart message, the value in the dictionary maps the string C{"BODY"} to a list giving the body structure information for that message, in the form of a list of subpart body structure information followed by the subtype of the message (eg C{"alternative"} for a I{multipart/alternative} message). This structure is self-similar in the case where a subpart is itself multipart. r� r� r� r. s dates Stuffr{ Nr� s Thingsi�~ r� r� s Irrelevantr� zmultipart/mixeds RootOfí r r� )rC r� NNNN�5r� )rC �htmlNNNNr� r� � alternativer� Fr� )rB �singlesr� r� r. r. r1 �!test_fetchSimplifiedBodyMultipart� sJ ��� � � ���� z/NewFetchTests.test_fetchSimplifiedBodyMultipartc C �B | j j| _d| _tddiddddd �g| _dd d ii| _| �|�S ) Nz 1,3,7,10101r� �Valuer. r� s BODY TEXT �[ r ry z Header: Value BODY TEXT )r� r r r� r� rh r? ro rj r. r. r1 �testFetchMessage� s � z NewFetchTests.testFetchMessagec C r r, )r� rL r. r. r1 �testFetchMessageUID� rq z!NewFetchTests.testFetchMessageUIDc C sX | j j| _d| _tddd�ddddd �g| _tt�ddd���}dd |ii| _ | � |�S ) Nz9,6,2�V1�V2)�H1�H2r. r� �c r rs ) r� � fetchHeadersr r� r� rh r% r r< r? ro )rB r| r� r. r. r1 �testFetchHeaders� s �� z NewFetchTests.testFetchHeadersc C r r, )r� rL r. r. r1 �testFetchHeadersUID rq z!NewFetchTests.testFetchHeadersUIDc C r� ) Nz 1,2,3,4,5,6,7r� r� r. r� s Body goes here � r rw zBody goes here )r� r� r r� r� rh r? ro rj r. r. r1 � testFetchBody s �� zNewFetchTests.testFetchBodyc C r r, )r� rL r. r. r1 �testFetchBodyUID rq z NewFetchTests.testFetchBodyUIDc s* � j j� _d� _d}d}d}t� }d|d< d|d< d |d < d |d < t� }d |d < d|d < t� }d|d < d|d < t|dd|dt|dd|dd�t|dd|dd�g�g� _dddgdggi� _� fdd�}� j� � fdd�� � j� |� � j� � j � � j� � j � t j� j� j dd �}|� � fd d�� |S ) zT Test the server's handling of requests for specific body sections. r� r� r� r� rz r{ r| r} r~ r r� r� r� r� r� r� r. Nr� r r� z&Contained body message text. Squarge.c rX r- r� r rL r. r1 r/ 7 rq z0NewFetchTests.testFetchBodyParts.<locals>.resultc s � j � jdd�S )Nr� r� ri r� rL r. r1 r2 ; rn z2NewFetchTests.testFetchBodyParts.<locals>.<lambda>Fr c rk r- rl ��ignrL r. r1 r2 B rn �r� r, r r� r r� rh r? r� r� r� r� r� r r r� ) rB r� r� r� r� r� r� r/ r� r. rL r1 �testFetchBodyParts sL ��� � z NewFetchTests.testFetchBodyPartsc s� �j j�_d�_dg� d}t� }d|d< d|d< d|d < d |d < t|d d |dd �g�_dddgdggi�_�fdd�}�j� � �fdd�� �j� |� �j� �j � �j� �j � t j�j�j dd�}|� �fdd�� |S )z� Single-part messages have an implicit first part which clients should be able to retrieve explicitly. Test that a client requesting part 1 of a text/plain message receives the body of the text/plain part. r� r� s DA bodyrz r{ r| r} r~ r r� r� r. Nr� r r� zDA bodyc rX r- r� r rL r. r1 r/ Y rq z>NewFetchTests.test_fetchBodyPartOfNonMultipart.<locals>.resultc s �j �j� d�S )Nr� ri r� ��partsrB r. r1 r2 ] rn z@NewFetchTests.test_fetchBodyPartOfNonMultipart.<locals>.<lambda>Fr c rk r- rl r� rL r. r1 r2 d rn r� )rB r� r� r/ r� r. r� r1 � test_fetchBodyPartOfNonMultipartE s* � z.NewFetchTests.test_fetchBodyPartOfNonMultipartc C s> | j j| _d| _ti ddddd �g| _dddii| _| �|�S ) Nz 1:100,2:*r. r� s xxxxxxxxxxxxxxxxxxxxr� r ru r� )r� � fetchSizer r� r� rh r? ro rj r. r. r1 � testFetchSizeg s �� zNewFetchTests.testFetchSizec C r r, )r� rL r. r. r1 �testFetchSizeUIDr rq z NewFetchTests.testFetchSizeUIDc C s� | j j| _d| _ti ddddd �ti dddd d �g| _g d�d d d d g d �gg d �gd d d d d d g g d �d�g d�ddd d g d �gg d �gd d d d d d g g d�d�d�| _| �|�S )Nz1,3)z\XYZz\YZX�Abcs% Sun, 25 Jul 2010 06:20:30 -0400 (EDT)s xyzxyzi� )z\Onez\Two�Threes Mon, 14 Apr 2003 19:43:44 -0400s abcabcabcabcrZ z25-Jul-2010 06:20:30 -0400r� r� )NNNNNNr� )rm rp ru rj r� z14-Apr-2003 19:43:44 -0400r� r� r| )r� � fetchFullr r� r� rh r? ro rj r. r. r1 � testFetchFullu sj ���� �� �� &zNewFetchTests.testFetchFullc C r r, )r� rL r. r. r1 �testFetchFullUID� rq z NewFetchTests.testFetchFullUIDc C s� | j j| _d| _ti ddddd �ti ddddd �g| _d d g d �gg d �gd d d d d d g d d g d �d d g d �gg d �gd d d d d d g d d g d �d�| _| �|�S )Nz1,2:3r. s Mon, 14 Apr 2003 19:43:44 +0400s Lalalars s Tue, 15 Apr 2003 19:43:44 +0200s Alalali�N r� r� z14-Apr-2003 19:43:44 +0400)rj ru rp rm z15-Apr-2003 19:43:44 +0200r| )r� �fetchAllr r� r� rh r? ro rj r. r. r1 � testFetchAll� sR � �� � �� �� $zNewFetchTests.testFetchAllc C r r, )r� rL r. r. r1 �testFetchAllUID� rq z NewFetchTests.testFetchAllUIDc C sD | j j| _d| _ti ddddd �g| _ddgdd d �i| _| �|�S ) Nr� )�\Xs 19 Mar 2003 19:22:21 -0500r� r� r r� z19-Mar-2003 19:22:21 -0500�0)rm rp ru )r� � fetchFastr r� r� rh r? ro rj r. r. r1 � testFetchFast� s ��� zNewFetchTests.testFetchFastc C r r, )r� rL r. r. r1 �testFetchFastUID� rq z NewFetchTests.testFetchFastUIDr� )1ri rj rk r� r r" rO ro rw r~ r� r� r� r� r� r� r� �Error� noEsARLocaler r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r. r. r. r1 rf . sb � % 1 A 4 @ 1 " = 1 rf c @ rG )#�DefaultSearchTestszz Test the behavior of the server's SEARCH implementation, particularly in the face of unhandled search terms. c C s� t �� | _d| j_| | j_t�� | _t| j�| _ t i ddddd �t i ddddd �t i ddddd �t i ddddd �t i ddddd �g| _ d S ) Nrd r. r� rr rs r� i!N i"N ) r ro r� r� r r r� r� r} r� r� rh rL r. r. r1 r� s �zDefaultSearchTests.setUpc C s t ttdt| j�d �| j��S )zW Pretend to be a mailbox and let C{self.server} lookup messages on me. r� )r� r� rd r� rh rN r. r. r1 rO s zDefaultSearchTests.fetchc sZ ��fdd�}�j �t|��}� �fdd�}|�|� |��j� |��j� ��� |S )a� Issue a search with given query and verify that the returned messages match the given expected messages. @param queryTerms: A string giving the search query. @param expectedMessages: A list of the message sequence numbers expected as the result of the search. @return: A L{Deferred} which fires when the test is complete. c � �j �� �S r- �r� ry r. �� queryTermsrB r. r1 ry ! r5 z8DefaultSearchTests._messageSetSearchTest.<locals>.searchc s �� | � � d S r- r� r� )�expectedMessagesrB r. r1 �searched& r� z:DefaultSearchTests._messageSetSearchTest.<locals>.searched)r� r� r4 r� r� r� r )rB r� r� ry r� r� r. )r� r� rB r1 �_messageSetSearchTest s z(DefaultSearchTests._messageSetSearchTestc C � | � ddg�S )z� Test that a search which starts with a message set properly limits the search results to messages in that set. r� r� �r� rL r. r. r1 �test_searchMessageSet/ s z(DefaultSearchTests.test_searchMessageSetc C � | � dg d��S )zv If the search filter ends with a star, all the message from the starting point are returned. z2:*r� r� rL r. r. r1 � test_searchMessageSetWithStar6 r� z0DefaultSearchTests.test_searchMessageSetWithStarc C r� )z� If the search filter starts with a star, the result should be identical with if the filter would end with a star. z*:2r� r� rL r. r. r1 �"test_searchMessageSetWithStarFirst= r� z5DefaultSearchTests.test_searchMessageSetWithStarFirstc C r� )z� If the search filter ends with a star, all the message from the starting point are returned (also for the SEARCH UID case). z UID 10000:*r� r� rL r. r. r1 � test_searchMessageSetUIDWithStarD r� z3DefaultSearchTests.test_searchMessageSetUIDWithStarc C r� )z� If the search filter starts with a star, the result should be identical with if the filter would end with a star (also for the SEARCH UID case). z UID *:10000r� r� rL r. r. r1 �%test_searchMessageSetUIDWithStarFirstK r� z8DefaultSearchTests.test_searchMessageSetUIDWithStarFirstc C r� )z� A search filter of 1234:* should include the UID of the last message in the mailbox, even if its UID is less than 1234. z UID 30000:*r� r� rL r. r. r1 �,test_searchMessageSetUIDWithStarAndHighStartR rZ z?DefaultSearchTests.test_searchMessageSetUIDWithStarAndHighStartc C r� )z� If the search filter contains nesting terms, one of which includes a message sequence set with a wildcard, IT ALL WORKS GOOD. z(6:*)r� r� rL r. r. r1 � test_searchMessageSetWithListZ s z0DefaultSearchTests.test_searchMessageSetWithListc C s | � dddg�S )z� If the search filter contains an I{OR} term, all messages which match either subexpression are returned. zOR 1 2r� r� r� rL r. r. r1 rZ d r� z DefaultSearchTests.test_searchOrc C r� )z� If the search filter contains an I{OR} term with a subexpression which includes a message sequence set wildcard, all messages in that set are considered for inclusion in the results. z OR 2:* 2:*r� r� rL r. r. r1 �test_searchOrMessageSetk r� z*DefaultSearchTests.test_searchOrMessageSetc C r� )z� If the search filter contains a I{NOT} term, all messages which do not match the subexpression are returned. zNOT 3)r� r� r� r� r� rL r. r. r1 r\ t r� z!DefaultSearchTests.test_searchNotc C r� )z� If the search filter contains a I{NOT} term with a subexpression which includes a message sequence set wildcard, no messages in that set are considered for inclusion in the result. zNOT 2:*r� r� rL r. r. r1 �test_searchNotMessageSet{ s z+DefaultSearchTests.test_searchNotMessageSetc C r� )z� If the search filter contains multiple terms implicitly conjoined with a message sequence set wildcard, only the intersection of the results of each term are returned. z2:* 3r� r� rL r. r. r1 �test_searchAndMessageSet� rZ z+DefaultSearchTests.test_searchAndMessageSetc �^ d� � �fdd�}�j �t|��}��|tj�}�fdd�}|�|� |��j� ��� |S )z� If the search criteria is not a valid key, a NO result is returned to the client (resulting in an error callback), and an IllegalQueryError is logged on the server side. �FOOc r� r- r� r. r� r. r1 ry � r5 z=DefaultSearchTests.test_searchInvalidCriteria.<locals>.searchc �L � j j�� � jj�� � �tj�}� �t|�d� � �t d�t | �� dS )�� Verify that the server logs an IllegalQueryError and the client raises an IMAP4Exception with 'Search failed:...' r� s) SEARCH failed: Invalid search command FOON� r� r� r� r� r r r� r? r� r� �r� rQ rL r. r1 � errorReceived� s �zDDefaultSearchTests.test_searchInvalidCriteria.<locals>.errorReceived� r� r� r4 rB r r� r� r� r �rB ry r� r r. r� r1 �test_searchInvalidCriteria� s z-DefaultSearchTests.test_searchInvalidCriteriaN)ri rj rk r r� rO r� r� r� r� r� r� r� r� rZ r r\ r r r r. r. r. r1 r� � s$ r� c @ s` e Zd Zdd� Zdd� Zdd� ZeZdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dS )�FetchSearchStoreTestsc C sX d | _ | _d | _d | _d | _d | _t�� | _d| j_ | | j_ t � � | _ t| j �| _d S r )r? r/ �server_received_query�server_received_uid�server_received_parts�server_received_messagesr ro r� r� r r r� r� r} r� rL r. r. r1 r� � s zFetchSearchStoreTests.setUpc C s& |dgkr t �d��|| _|| _| jS )Nr z"FOO is not a valid search criteria)r r� r r r? )rB r� r| r. r. r1 ry � s z FetchSearchStoreTests.searchc O r2 r- r. )rB rJ rw r. r. r1 r � r* z!FetchSearchStoreTests.addListenerc sn � �fdd�}� fdd�}� j �t|���|��� j��� j� � fdd�}tj� j� j dd�}|�|� |S ) Nc s � j j� j�d�S )Nr� )r� ry r� r. rj r. r1 ry � r� z1FetchSearchStoreTests._searchWork.<locals>.searchc rX r- r� r rL r. r1 r/ � rq z1FetchSearchStoreTests._searchWork.<locals>.resultc sR � � � j� ju � � �� j� j� � �� j� j� � �t�� j� d��� j � d S )N�charmap) r- r/ r? r? r| r r r` r� r@ r r rL r. r1 rb � s �z0FetchSearchStoreTests._searchWork.<locals>.checkFr r )rB r| ry r/ rb r� r. rj r1 � _searchWork� s � z!FetchSearchStoreTests._searchWorkc C s: t �t jdd�t jddd��| _g d�| _d| _| �d�S )N�r � substring�r� � � �r� r� )r� r� r� r� r )r r� r� r� r? r| r rL r. r. r1 � testSearch� s � z FetchSearchStoreTests.testSearchc C s: t �t jdd�t jddd��| _d| _g d�| _| �d�S )Nr r r r r r� r� )r r� r� r� r| r? r rL r. r. r1 � testUIDSearch� s � z#FetchSearchStoreTests.testUIDSearchc C sH z| j | d W S ttfy | j |d Y S ty# Y dS w )Nr{ r� r) )r? r� � IndexError�KeyError�rB r� r. r. r1 r7 � s �z FetchSearchStoreTests.getUIDc C s || _ t|�| _| jS r- )r r� r r? rN r. r. r1 rO s zFetchSearchStoreTests.fetchc s` � fdd�}� j �t|���|��� j��� j� � fdd�}tj� j� j dd�}|�|� |S )Nc rX r- r� r rL r. r1 r/ rq z0FetchSearchStoreTests._fetchWork.<locals>.resultc s� � � � j� ju � � jo� j�� � jo� j�� � jr,� j�� D ] \}}t|�|d< q!� � � j� j� � � � j� j � � � � j� j� � � t � � j �t � � j�� d S )Nr{ )r- r/ r? r� r� r r| r� r� r? r r r� r� r )r� �k�vrL r. r1 rb s �� �z/FetchSearchStoreTests._fetchWork.<locals>.checkFr r )rB rO r/ rb r� r. rL r1 ro s � z FetchSearchStoreTests._fetchWorkc r )z� If, as part of a search, an ISearchableMailbox raises an IllegalQueryError (e.g. due to invalid search criteria), client sees a failure response, and an IllegalQueryError is logged on the server. r c r� r- r� r. �r� rB r. r1 ry 1 r5 z6FetchSearchStoreTests.test_invalidTerm.<locals>.searchc r )r r� s1 SEARCH failed: FOO is not a valid search criteriaNr r rL r. r1 r 7 s �z=FetchSearchStoreTests.test_invalidTerm.<locals>.errorReceivedr r r. r! r1 �test_invalidTerm) s z&FetchSearchStoreTests.test_invalidTermN)ri rj rk r� ry r r" r r r r7 rO ro r" r. r. r. r1 r � s r c @ r� )� FakeMailboxc C rn r- r rL r. r. r1 rp O rq zFakeMailbox.__init__c C s | j �|||f� t�d �S r- )rv rr r r4 )rB r� ro r@ r. r. r1 rA R r� zFakeMailbox.addMessageN)ri rj rk rp rA r. r. r. r1 r# N s r# c @ �$ e Zd Zdd� Zdd� Zdd� ZdS )�FeaturefulMessagec C r( )Nro r. rL r. r. r1 r& Y r* zFeaturefulMessage.getFlagsc C r( )Nrr r. rL r. r. r1 r� \ r* z!FeaturefulMessage.getInternalDatec C s t d�S )N� openr rL r. r. r1 r� _ rb zFeaturefulMessage.openN)ri rj rk r& r� r� r. r. r. r1 r% W s r% c @ r� )�MessageCopierMailboxc C rn r- )�msgsrL r. r. r1 rp e rq z MessageCopierMailbox.__init__c C s | j �|� t| j �S r- )r( rr r� r r. r. r1 r� h r zMessageCopierMailbox.copyN)ri rj rk rp r� r. r. r. r1 r' c r� r' c @ r$ )�CopyWorkerTestsc sH t �� }|j}t� � |dd� tdd�D �d� �}� �fdd�}|�|�S )Nc S s g | ]}|t � f�qS r. )r% r r. r. r1 r� | s z9CopyWorkerTests.testFeaturefulMessage.<locals>.<listcomp>r� r� r� c sh � j D ] }��|d �� d� ��|d d� ��|d d� q| D ]\}}��|� ��|d � q"d S )Nr r& r� ro r� rr )rv r? rP r/ )r� rJ r� r/ �r� rB r. r1 �cbCopy~ s �z5CopyWorkerTests.testFeaturefulMessage.<locals>.cbCopy)r ro �_IMAP4Server__cbCopyr# rd r� �rB rR r0 r� r+ r. r* r1 �testFeaturefulMessagen s z%CopyWorkerTests.testFeaturefulMessagec sb t �� }|j}t� � dd� tdd�D �}|dd� ttdd�|�D �d� �}� �fdd�}|�|�S ) Nc S s0 g | ]}t d t|�iddd|f |d d��qS )zHeader-Counterr. � Dates Body %dr� N)r� r� r r. r. r1 r� � s � ��z;CopyWorkerTests.testUnfeaturefulMessage.<locals>.<listcomp>r� r� c S � g | ]}|�qS r. r. �r �imr. r. r1 r� � rn r� c s� g }� j D ]}|�|d �� � ��|d d� ��|d d� q|�� tdd� tdd�D ��}��||� | D ]\}}��|� ��|d � q9d S ) Nr r� r. r� r/ c s s � | ] }d ||f V qdS )s Header-Counter: %d Body %dNr. r r. r. r1 r � s � �zJCopyWorkerTests.testUnfeaturefulMessage.<locals>.cbCopy.<locals>.<genexpr>r� )rv rr rP r? r� r= rd r/ )r� �seenrJ �expr� r/ r* r. r1 r+ � s � �z7CopyWorkerTests.testUnfeaturefulMessage.<locals>.cbCopy)r ro r, r# rd r� r� )rB rR r0 r( r� r+ r. r* r1 �testUnfeaturefulMessage� s �" z'CopyWorkerTests.testUnfeaturefulMessagec sd t �� }|j}t� � dd� tdd�D ��|dd� ttdd���D �d� �}� ��fdd�}|�|�S ) Nc S s g | ]}t � �qS r. )�objectr r. r. r1 r� � � z5CopyWorkerTests.testMessageCopier.<locals>.<listcomp>r� r� c S r0 r. r. r1 r. r. r1 r� � rn s tagc sH �� | ttdgd tdd���� t�� j�D ] \}}��||� qd S )Nr� r� r� )r? r� r� rd r( r� )r� �origr� �r� r( rB r. r1 r+ � s "�z1CopyWorkerTests.testMessageCopier.<locals>.cbCopy)r ro r, r' rd r� r� r- r. r9 r1 �testMessageCopier� s " z!CopyWorkerTests.testMessageCopierN)ri rj rk r. r5 r: r. r. r. r1 r) m s "r) zOpenSSL not presentzReactor doesn't support SSLc @ sp e Zd ZdZdZer e� Zere� Zdd� Zdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� ZdS )�TLSTestsNc C s t j| j| jdd�S )NFr )r r r� r� rL r. r. r1 r � ri zTLSTests.loopbackc s� t j�d� g � � �fdd�}� �fdd�}� �fdd�}� �fdd �}� �fd d �}d �j_|||||g��D ] }�j�t|�� q8�j��j �j � � ��fd d�}�� � }|�|� |S )Nr8 c � � � d � �j�dd�S r� )rr r� r� r. ��calledrB r. r1 r� � � z)TLSTests.testAPileOfThings.<locals>.loginc r< )Nr8 � %)rr r� r� r. r= r. r1 r� � r? z(TLSTests.testAPileOfThings.<locals>.listc r< )Nr8 r )rr r� r� r. r= r. r1 r� � r? z*TLSTests.testAPileOfThings.<locals>.statusc s � � d � �j�d�S )Nr8 )rr r� r4 r. r= r. r1 r4 � s z+TLSTests.testAPileOfThings.<locals>.examinec s � � d � �j�� S r- )rr r� r� r. r= r. r1 r� � s z*TLSTests.testAPileOfThings.<locals>.logoutTc s8 �� �jjd� �� �jjd� �� t� �t��� d S rK )r? r� � startedTLSr� r� r �r> �methodsrB r. r1 rb � s z)TLSTests.testAPileOfThings.<locals>.check) rj r| r r� �requireTransportSecurityr� r� r4 rB r� r� r ) rB r� r� r� r4 r� rJ rb r� r. rB r1 �testAPileOfThings� s zTLSTests.testAPileOfThingsc s� � j j�dd� g �� j�t�d�� � j�� fdd���� fdd����j ��� j �� � j � � � � }|�� �fdd�� |S )Nrk rn c r" )Nrn r� r� rL r. r1 r2 � r� z)TLSTests.testLoginLogin.<locals>.<lambda>c r� r- )r� r� r� rL r. r1 r2 � r� c s � � t��d�S r, )r? r� rm �rB �successr. r1 r2 rn )r� rr rq r� r� r r� r� r� rr r� r� r� r rK r. rF r1 �testLoginLogin� s$ ����zTLSTests.testLoginLoginc sj g �� j �t� jj�� � fdd�}� j �|� � j ��j� � �� }|�� �fdd�� t�|� j g�S )z� Begin a C{STARTTLS} sequence and assert that it results in a TLS session. @return: A L{Deferred} that fires when the underlying connection between the client and server has been terminated. c s � � tj�� jj�� d S r- )r/ r � ISSLTransport� providedByr� r� r rL r. r1 � checkSecure r� z6TLSTests.startTLSAndAssertSession.<locals>.checkSecurec s � � ��S r- )r/ rm rF r. r1 r2 r� z3TLSTests.startTLSAndAssertSession.<locals>.<lambda>) r� r� r4 r� �startTLSrr r r r� )rB rK r� r. rF r1 �startTLSAndAssertSession s z!TLSTests.startTLSAndAssertSessionc C s( | � � }| j�| j� | j�| j� |S )z� L{IMAP4Client.startTLS} triggers TLS negotiation and returns a L{Deferred} which fires after the client's transport is using encryption. )rM r� r� r� r� r� )rB � disconnectedr. r. r1 � test_startTLS s zTLSTests.test_startTLSc C sn G dd� dt �}|| j| jd�| _| �� }| j�t| jj�� | j�| j d� | j�| j � | j�| j � |S )z] A server that receives a second C{STARTTLS} sends a C{NO} response. c @ � e Zd Zdd� ZdS )z:TLSTests.test_doubleSTARTTLS.<locals>.DoubleSTARTTLSClientc S s | j st�| �S | �t�d��S )Ns STARTTLS)rA r} rL r� r r rL r. r. r1 rL - s zCTLSTests.test_doubleSTARTTLS.<locals>.DoubleSTARTTLSClient.startTLSN)ri rj rk rL r. r. r. r1 �DoubleSTARTTLSClient, � rQ r� s TLS already negotiated) r} r� r� r� rM r� r4 rL r� r� r� r� )rB rQ rN r. r. r1 �test_doubleSTARTTLS& s ��z TLSTests.test_doubleSTARTTLSc sl t jt jd�� j_tj� fdd��}� j�t |�� � � � }� j�t |�� � j�� j � � j� � j � |S )z� Starting a TLS negotiation with an L{IMAP4Server} that already has C{LOGIN} and C{PLAIN} L{IChallengeResponse} factories uses those factories. )r rg c 3 s> � � j �� V } � �d| � � �d| d � � �d| d � d S )Nr� r rg )r� r� r� r� rL r. r1 �assertLOGINandPLAINN s � zJTLSTests.test_startTLSWithExistingChallengers.<locals>.assertLOGINandPLAIN)r r� r� r� r� r r� r� r� r4 rM r� r� r� )rB rT rN r. rL r1 �$test_startTLSWithExistingChallengersC s �z-TLSTests.test_startTLSWithExistingChallengersc s` dd� � j _� j�� fdd�� � j�� jd� � j�� j� � j�� j� t� � � � � jg�S )z| A client that attempts to log in before issuing the C{STARTTLS} command receives a C{NO} response. c S s t �g df�S )Nz OK Begin TLS negotiation now)r r4 r. r. r. r1 r2 f s �z3TLSTests.test_loginBeforeSTARTTLS.<locals>.<lambda>c r� )Ns wrongs timer� r� rL r. r1 r2 j r� s! LOGIN is disabled before STARTTLS) r� rL r� r� r� r� r� r� r r� r rL r. rL r1 �test_loginBeforeSTARTTLS` s ��z!TLSTests.test_loginBeforeSTARTTLSc s| g � �fdd�}�j �|� �j ��fdd�� �j �� fdd�� �j ��j� �j ��j� � �fdd�}��� �|�S )Nc s d� j _d S r~ )r� � canStartTLSr� rL r. r1 �breakServerTLSz r5 z3TLSTests.testFailedStartTLS.<locals>.breakServerTLSc r� r- )r� rL r� rL r. r1 r2 ~ r� z-TLSTests.testFailedStartTLS.<locals>.<lambda>c s � � | �tj��S r- )rr r� r r� )r� )r� r. r1 r2 � r7 c s �� � � ��� d tj� d S r> )r/ r� r r� r �r� rB r. r1 rb � s z*TLSTests.testFailedStartTLS.<locals>.check)r� r� r� r� r� r )rB rX rb r. rY r1 �testFailedStartTLSw s �zTLSTests.testFailedStartTLS)ri rj rk r� r� r, r+ r rE rH rM rO rS rU rV rZ r. r. r. r1 r; � s ) r; c @ s e Zd ZdZdZdZdd� ZdS )� SlowMailboxr� Nc C s* t �� }| �| j|jd� | j�d � |S )Nr. )r r� � callLater�howSlowr� � fetchDeferred)rB r� r| r� r. r. r1 rO � s zSlowMailbox.fetch)ri rj rk r] r\ r^ rO r. r. r. r1 r[ � s r[ c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd S )� TimeoutTestsc sp t � � d�j_d�j_� j�j_d�_� ��fdd�}�fdd���j�t |��}|� �j � t � |��� g�S )z{ The *client* has a timeout mechanism which will close connections that are inactive for a period. Tr� Nc s& �j �dd�} � �d� | ��� | S )Nrk rn r� )r� r� �advancer� r� �r� rB �timedOutr. r1 r� � s z.TimeoutTests.test_serverTimeout.<locals>.loginc s � � d � | �tj� d S r- )r� r� r � TimeoutErrorr? rL r. r1 rb � r� z1TimeoutTests.test_serverTimeout.<locals>.timedOut)r r� ru r� r� r\ r r� r� r4 r� r� r r� r )rB r� r� r. ra r1 �test_serverTimeout� s z TimeoutTests.test_serverTimeoutc sZ t � � � j�j_�fdd�}� �fdd�}�j�t|��}|�t|�� t�|��� g�S )z4 The server times out a connection. c r� r� r� r. rL r. r1 r� � r. z/TimeoutTests.test_serverTimesOut.<locals>.loginc � � � �jjd � d S �Nr� �r` r� �POSTAUTH_TIMEOUTr. r? r. r1 � expireTime� r� z4TimeoutTests.test_serverTimesOut.<locals>.expireTime) r r\ r� r� r� r4 r r� r )rB r� ri r� r. r? r1 �test_serverTimesOut� s z TimeoutTests.test_serverTimesOutc s� �� tjdt� tj�d� tjjd ���t���� t � � � j �j _ �fdd�}�fdd�}��fdd �}� �fd d �}�fd d �}�j � t|��}|� t|�� |� t|�� |� t|�� |� t|�� t�|��� g�S )z^ The server unsets the selected mailbox when timing out a connection. r^ � mailbox-test� MAILBOX-TESTc r� r� r� r. rL r. r1 r� � r. z7TimeoutTests.test_serverUnselectsMailbox.<locals>.loginc r" �Nrk r# r. rL r. r1 rd � r5 z8TimeoutTests.test_serverUnselectsMailbox.<locals>.selectc s �� � �jj� d S r- )r1 r� r r. �r rB r. r1 � assertSet� ri z;TimeoutTests.test_serverUnselectsMailbox.<locals>.assertSetc re rf rg r. r? r. r1 ri � r� z<TimeoutTests.test_serverUnselectsMailbox.<locals>.expireTimec r% r- )r- r� r r. rL r. r1 � assertUnset� r� z=TimeoutTests.test_serverUnselectsMailbox.<locals>.assertUnset)r� rj r| rW r r/ r- r rJ r r\ r� r� r� r4 r r� r )rB r� rd ro ri rp r� r. �r� r rB r1 �test_serverUnselectsMailbox� s" z(TimeoutTests.test_serverUnselectsMailboxc s� t j�d� t jjd �tt�� t� � � j�j_�fdd�}�fdd�}��fdd�}� �fd d �}��fd d �}�j � t |��}|� t |�� |� t |�� |� t |�� |� t |�� t � |��� g�S ) zi The server closes the selected, closeable mailbox when timing out a connection. rk rl c r� r� r� r. rL r. r1 r� � r. z?TimeoutTests.test_serverTimesOutAndClosesMailbox.<locals>.loginc r" rm r# r. rL r. r1 rd � r5 z@TimeoutTests.test_serverTimesOutAndClosesMailbox.<locals>.selectc � �� � j� d S r- )r- rL r. rn r. r1 �assertMailboxOpen r� zKTimeoutTests.test_serverTimesOutAndClosesMailbox.<locals>.assertMailboxOpenc re rf rg r. r? r. r1 ri r� zDTimeoutTests.test_serverTimesOutAndClosesMailbox.<locals>.expireTimec rs r- )r/ rL r. rn r. r1 �assertMailboxClosed r� zMTimeoutTests.test_serverTimesOutAndClosesMailbox.<locals>.assertMailboxClosed)rj r| r r/ r r r r\ r� r� r� r4 r r� r )rB r� rd rt ri ru r� r. rq r1 �#test_serverTimesOutAndClosesMailbox� s z0TimeoutTests.test_serverTimesOutAndClosesMailboxc s� t � � � jt_t�� t_� j�j_ttj_ tj� d� �j� d� �fdd�}�fdd�}�fdd�}�fd d �}� fd d �}tj� |� �j � t|��}|� t|�� |� t|�� |� t|�� |� �j� |��j� t�|��� g�}|S ) zM The connection timeout does not take effect during fetches. rk r� c r� r� r� r. rL r. r1 r� # r. z7TimeoutTests.test_longFetchDoesntTimeout.<locals>.loginc s � j �d� � j�d�S )Nr� rk )r� � setTimeoutr� rd r. rL r. r1 rd & s z8TimeoutTests.test_longFetchDoesntTimeout.<locals>.selectc r" )Nr� rp r. rL r. r1 rO * r5 z7TimeoutTests.test_longFetchDoesntTimeout.<locals>.fetchc s � � � jjd� d S )Nr� )r� r� r� r. rL r. r1 �stillConnected- ri z@TimeoutTests.test_longFetchDoesntTimeout.<locals>.stillConnectedc s t d�D ]}� �d� qd S )Nr� g �?)rd r` )r� r� r� r. r1 � cbAdvance0 s �z;TimeoutTests.test_longFetchDoesntTimeout.<locals>.cbAdvance)r r\ r[ r r� r^ r� rj r| r^ r rw r� r� r4 r� r� r� r� r )rB r� rd rO rx ry r� r� r. r? r1 �test_longFetchDoesntTimeout s* z(TimeoutTests.test_longFetchDoesntTimeoutc s� t � }t� }| j|_|j| j_| j�|� g �| jj� � �fdd�| j_|�dg| jjd gd � | � ��� |�d| jjd g� | � �� dS )z{ The *server* has a timeout mechanism which will close connections that are inactive for a period. c s �� d �� | �fd S r, )rr )�reason��connLost�lostr. r1 r2 N s ��z<TimeoutTests.test_idleClientDoesDisconnect.<locals>.<lambda>g g @r� g @N) r r( r� r� r\ r� r� �pump�timeOutr- r/ )rB r� r� r. r| r1 � test_idleClientDoesDisconnect? s z*TimeoutTests.test_idleClientDoesDisconnectN) ri rj rk rd rj rr rv rz r� r. r. r. r1 r_ � s '& )r_ c @ rP )�DisconnectionTestsc C sB t �� }t� }|�|� | �|�dd�tj�}|�t�d�� |S )Nrk z example.com�Connection closed) r r~ r( r� rB r� r r� r� )rB r� �tr� r. r. r1 �"testClientDisconnectFailsDeferreds] s �z5DisconnectionTests.testClientDisconnectFailsDeferredsN)ri rj rk r� r. r. r. r1 r� \ rR r� c @ r )�SynchronousMailboxzb Trivial, in-memory mailbox implementation which can produce a message synchronously. c C s || _ d S r- r� )rB r� r. r. r1 rp n rq zSynchronousMailbox.__init__c c s0 � |rJ d��|D ] }|| j |d fV q d S )NzCannot handle uid requests.r� r� )rB rP r| r� r. r. r1 rO q s � �zSynchronousMailbox.fetchN)ri rj rk r rp rO r. r. r. r1 r� h s r� c @ s| e Zd ZdZei g dddd�ei g dddd�ei g dddd�gZdd� Zd d � Zd d � fd d�Zdd� Z dd� Z dd� Z dS )�PipeliningTestszM Tests for various aspects of the IMAP4 server's pipelining support. r� r� Nr� � 2c C sV g | _ t� | _t�d d | j�| _| j�| j� t| j �}d| j_ || j_ | j� � d S r ) � iteratorsr' r� r ro �iterateInReactorr� r� r� r� r� r r� )rB r� r. r. r1 r� � s zPipeliningTests.setUpc C s t �� }| j�||f� |S )z� A fake L{imap4.iterateInReactor} that records the iterators it receives. @param iterator: An iterator. @return: A L{Deferred} associated with this iterator. )r r� r� rr )rB �iteratorr� r. r. r1 r� � s z PipeliningTests.iterateInReactorc C r( rK r. r. r. r. r1 r2 � r� zPipeliningTests.<lambda>c C sn | j r1|� r3| j d d D ]}| jjr | jj�� | jjsq | j �d�d �d� | j r5|� sdS dS dS dS )a� Advance pending iterators enqueued with L{iterateInReactor} in a round-robin fashion, resuming the transport's producer until it has completed. This ensures bodies are flushed. @param asLongAs: (optional) An optional predicate function. Flushing iterators continues as long as there are iterators and this returns L{True}. r r� N)r� r� �producerrt r� r� )rB �asLongAs�er. r. r1 � flushPending� s �� �z PipeliningTests.flushPendingc C r� r- r� rL r. r. r1 r� � r� zPipeliningTests.tearDownc C s� | j �d� | �� | �| j�� d�dtdt| j d � � � � �f �dtdt| j d � � � � �f �d td t| j d � � � � �f �g�� d S ) z� Test that pipelined FETCH commands which can be responded to synchronously are responded to correctly. s9 01 FETCH 1 BODY[] 02 FETCH 2 BODY[] 03 FETCH 3 BODY[] r� � * 1 FETCH (BODY[] ) �"01 OK FETCH completed {5} %sr � * 2 FETCH (BODY[] ) z"02 OK FETCH completed {5} %sr� s * 3 FETCH (BODY[] ) z"03 OK FETCH completed {5} %sr� N) r� r� r� r? r� r� r� r& r% r� r rP rL r. r. r1 �test_synchronousFetch� s8 ����������z%PipeliningTests.test_synchronousFetchc C s� | j �d� t�ttg d���}| j|d� | �| j� � d� dt dt | j d �� �� �f �g�� | j�� | j jdd � | �| j� � � | �� | �| j� � d� d d t d t | j d �� �� �f �g�� dS )z� When a server status change occurs during an ongoing FETCH command, the server status is buffered until the FETCH completes. s 01 FETCH 1,2 BODY[] )TTF)r� r� r� z {5} %sr T)r� r� s * [READ-WRITE] r� r� N)r� r� � functools�partial�nextrg r� r? r� r� r� r& r% r� r rP r� r� r- )rB �twicer. r. r1 �test_bufferedServerStatus� s@ ����� �����z)PipeliningTests.test_bufferedServerStatus) ri rj rk r r� r� r� r� r� r� r� r� r. r. r. r1 r� w s � #r� c @ r )�IMAP4ServerFetchTestszV This test case is for the FETCH tests that require a C{StringTransport}. c C s, t � | _t�� | _d| j_| j�| j� d S r )r' r� r ro r� r� r� rL r. r. r1 r� s zIMAP4ServerFetchTests.setUpc C sL | j �� | j�d� d}| �| j �� |� | j �� | j�t�d�� dS )a If by any chance, extra bytes got appended at the end of a valid FETCH arguments, the client should get a BAD - arguments invalid response. See U{RFC 3501<http://tools.ietf.org/html/rfc3501#section-6.4.5>}, section 6.4.5, s 0001 FETCH 1 FULLL s+ 0001 BAD Illegal syntax: Invalid Argument r� N) r� r� r� r� r? r� r� r r� )rB r? r. r. r1 �"test_fetchWithPartialValidArgument s z8IMAP4ServerFetchTests.test_fetchWithPartialValidArgumentN)ri rj rk r r� r� r. r. r. r1 r� s r� c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �LiteralTestsMixinz� Shared tests for literal classes. @ivar literalFactory: A callable that returns instances of the literal under test. c C s t �� | _dS )z Shared setup. N)r r� r rL r. r. r1 r� 5 s zLiteralTestsMixin.setUpc C s0 | � d| j�}| �d|�d�� | �| j� dS )ze The literal returns L{None} when given less data than the literal requires. r Ns incomplete)�literalFactoryr r1 rT �assertNoResult)rB �literalr. r. r1 �test_partialWrite; s z#LiteralTestsMixin.test_partialWritec C sF d}| � t|�| j�}|�|�}| �|t� | �|� | �| j� dS )zz The literal returns an empty L{bytes} instance when given exactly the data the literal requires. � completeN)r� r� r rT r� rH r- r� �rB �datar� �leftoverr. r. r1 �test_exactWriteD s z!LiteralTestsMixin.test_exactWritec C s0 d}| � td�| j�}|�|�}| �|d� dS )zt The literal returns any left over L{bytes} when given more data than the literal requires. s completeleftoverr� � leftoverN)r� r� r rT r? r� r. r. r1 �test_overlongWriteQ s z$LiteralTestsMixin.test_overlongWritec C s, | � d| j�}d}|�|�}| �||� dS )zo The literal returns an empty L{bytes} instance when given an empty L{bytes} instance. r r� N)r� r rT r? )rB r� r� r� r. r. r1 �test_emptyLiteral] s z#LiteralTestsMixin.test_emptyLiteralN) ri rj rk r r� r� r� r� r� r. r. r. r1 r� - s r� c @ s e Zd ZdZejZdd� ZdS )�LiteralStringTestsz+ Tests for L{self.literalFactory}. c C s\ d}d}t �t|�| j�}t|�D ]}|�|� q|�d� | �| j�}| �|||f� dS )z� Calling L{imap4.LiteralString.callback} with a line fires the instance's L{Deferred} with a 2-L{tuple} whose first element is the collected data and whose second is the provided line. � datar N) r � LiteralStringr� r r$ rT r� rQ r? )rB r� �extrar� r� r/ r. r. r1 � test_callbackq s z LiteralStringTests.test_callbackN)ri rj rk r r r� r� r� r. r. r. r1 r� j s r� c @ s& e Zd ZdZejZdd� Zdd� ZdS )�LiteralFileTestsz) Tests for L{imap4.LiteralFile}. c C st d}d}t �t|�| j�}t|�D ]}|�|� q|�d� | �| j�}| �t|�d� |\}}| �|� � d� dS )z� Calling L{imap4.LiteralFile.callback} with a line fires the instance's L{Deferred} with a 2-L{tuple} whose first element is the file and whose second is the provided line. r� r r� N) r � LiteralFiler� r r$ rT r� rQ r? rP �rB r� r� r� r� r/ �dataFiler. r. r1 r� � s z LiteralFileTests.test_callbackc C s� d}d}| � tjdd� t�t|�| j�}t|�D ]}|�|� q|�d� | �| j�}| � t|�d� |\}}| � |� � d� dS )a= A L{imap4.LiteralFile} whose size exceeds the maximum in-memory size spools its content to disk, and invoking its L{callback} with a line fires the instance's L{Deferred} with a 2-L{tuple} whose first element is the spooled file and whose second is the provided line. r� r �_memoryFileLimitr� r� N) r� r r� r� r r$ rT r� rQ r? rP r� r. r. r1 �test_callbackSpooledToDisk� s z+LiteralFileTests.test_callbackSpooledToDiskN) ri rj rk r r r� r� r� r� r. r. r. r1 r� � s r� c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�WriteBufferTestsz) Tests for L{imap4.WriteBuffer}. c C s t � | _d S r- )r' r� rL r. r. r1 r� � r5 zWriteBufferTests.setUpc C s4 t �| j�}d|j }|�|� | �| j�� � dS )zd L{imap4.WriteBuffer} buffers writes that are smaller than its buffer size. � xN)r � WriteBufferr� � bufferSizerT r- r� �rB �bufr� r. r. r1 r� � s z"WriteBufferTests.test_partialWritec C s: t �| j�}d|jd }|�|� | �| j�� |� dS )z� L{imap4.WriteBuffer} writes data without buffering it when the size of the data exceeds the size of its buffer. r� r� N)r r� r� r� rT r? r� r� r. r. r1 r� � s z#WriteBufferTests.test_overlongWritec C sX t �| j�}d|j }d}|�|� | �| j�� � |�|� | �| j�� || � dS )zp L{imap4.WriteBuffer} buffers writes until its buffer's size exceeds its maximum value. r� � yN)r r� r� r� rT r- r� r? )rB r� � firstData� secondDatar. r. r1 �test_writesImplyFlush� s z&WriteBufferTests.test_writesImplyFlushc C sN t �| j�}d|j }|�|� | �| j�� � |�� | �| j�� |� dS )z{ L{imap4.WriteBuffer.flush} flushes the buffer even when its size is smaller than the buffer size. r� N) r r� r� r� rT r- r� �flushr? r� r. r. r1 �test_explicitFlush� s z#WriteBufferTests.test_explicitFlushc C s( t �| j�}|�� | �| j�� � dS )z_ L{imap4.WriteBuffer.flush} has no effect if when the buffer is empty. N)r r� r� r� r- r� )rB r� r. r. r1 � test_explicitFlushEmptyBuffer� s z.WriteBufferTests.test_explicitFlushEmptyBufferN) ri rj rk r r� r� r� r� r� r� r. r. r. r1 r� � s r� )�r r� rN r� r� r� r� � collectionsr �ior � itertoolsr �typingr r r r �unittestr �zope.interfacer �zope.interface.verifyr r �twisted.cred.checkersr �twisted.cred.credentialsr r r �twisted.cred.errorr �twisted.cred.portalr r �twisted.internetr r r r �twisted.internet.taskr � twisted.mailr �twisted.mail.imap4r �twisted.mail.interfacesr r r �twisted.protocolsr �twisted.pythonr! r" r# �twisted.python.compatr$ r% r& �twisted.test.proto_helpersr' r( �twisted.trial.unittestr) r* �twisted.test.ssl_helpersr+ r, � ImportErrorr4 r6 rm ry r� r � IMailboxInfo�IMailbox�ICloseableMailboxr rW � MemoryAccountWithoutNamespacesr\ rc rg ro rj r~ r} r� r� r� rB rp rj rt r� r� r� r r rE rH rj rl rm rw r� r� r� r� r� �IMessage� FancyStrMixinr� r r rf r� �ISearchableMailboxr r# � IMessageFiler% �IMessageCopierr' r) � IReactorSSLr; r[ r_ r� r� r� r� r� r� r� r� r. r. r. r1 �<module> s �e h M : S 2 ) ' ( .2gO I.2 ! /N'B f S 7 Q M C =8PK Mb�ZS2yh� � 1 mail/test/__pycache__/test_bounce.cpython-310.pycnu �[��� o �b� � @ sN d dl Zd dlZd dlmZmZ d dlmZ d dlm Z G dd� de j �Z dS )� N)�BytesIO�StringIO)�bounce)�unittestc @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � BounceTestsz# Bounce message generation c C s� t �td�dd�\}}}| �|d� | �|d� tj�� }|�t|�d���}| �|d d� | �|d d � | �|d d � d S ) zN L{twisted.mail.bounce.generateBounce} can accept L{unicode}. zRFrom: Moshe Zadka <moshez@example.com> To: nonexistent@example.org Subject: test �moshez@example.com�nonexistent@example.org� � moshez@example.com�utf-8�To�From�postmaster@example.org�subject�)Returned Mail: see transcript for detailsN) r �generateBouncer � assertEqual�email�parser�Parser�parse�decode��self� fromAddress�to�s� emailParser�mess� r �?/usr/lib/python3/dist-packages/twisted/mail/test/test_bounce.py�test_bounceMessageUnicode � � � z%BounceTests.test_bounceMessageUnicodec C s� t �td�dd�\}}}| �|d� | �|d� tj�� }|�t|� d���}| �|d d� | �|d d � | �|d d � d S ) zL L{twisted.mail.bounce.generateBounce} can accept L{bytes}. �R From: Moshe Zadka <moshez@example.com> To: nonexistent@example.org Subject: test r � nonexistent@example.orgr r r r r r r r N) r r r r r r r r r r r r r r �test_bounceMessageBytes) r" z#BounceTests.test_bounceMessageBytesc C s� t �td�ddd�\}}}| �|d� | �|d� tj�� }|�t|� d���}| �|d d� | �|d d � | �|d d � | � |� � � |� � }| �|d � � d� dS )z\ Pass a custom transcript message to L{twisted.mail.bounce.generateBounce}. r# r r$ zCustom transcriptr r r r r r r r r zCustom transcript N) r r r r r r r r r r � assertTrue� is_multipart� get_payload)r r r r r r �partsr r r �"test_bounceMessageCustomTranscriptA s$ � � z.BounceTests.test_bounceMessageCustomTranscriptc C s� t �||| �dd�\}}}tj�� }|�t|�d���}| �|d d� | �|d d� | �|d d� | � |� � � |� � } | d � � } t |t �rP|�d�}| �| d � � d |� d S ) zU Pass a really big message to L{twisted.mail.bounce.generateBounce}. r r r r r r r r � r � N)r r r r r r r r r r& r' r( � isinstance�bytes) r �header�message�ioTyper r r r r r) � innerMessager r r �_bounceBigMessage] s � z BounceTests._bounceBigMessagec C s2 d}| � |dd t� | � |�d�dd t� dS )zj L{twisted.mail.bounce.generateBounce} with big L{unicode} and L{bytes} messages. r# s Test test i' r z More test N)r3 r r r )r r/ r r r �test_bounceBigMessagep s z!BounceTests.test_bounceBigMessageN) �__name__� __module__� __qualname__�__doc__r! r% r* r3 r4 r r r r r s r ) � email.messager � email.parser�ior r � twisted.mailr � twisted.trialr �TestCaser r r r r �<module> s PK Mb�Z\�kK�� �� mail/test/test_pop3.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.mail.pop3} module. """ import base64 import hmac import itertools from collections import OrderedDict from hashlib import md5 from io import BytesIO from zope.interface import implementer import twisted.cred.checkers import twisted.cred.credentials import twisted.cred.portal import twisted.internet.protocol import twisted.mail.pop3 import twisted.mail.protocols from twisted import cred, internet, mail from twisted.internet import defer from twisted.mail import pop3 from twisted.protocols import loopback from twisted.python import failure from twisted.test.proto_helpers import LineSendingProtocol from twisted.trial import unittest, util class UtilityTests(unittest.TestCase): """ Test the various helper functions and classes used by the POP3 server protocol implementation. """ def test_LineBuffering(self): """ Test creating a LineBuffer and feeding it some lines. The lines should build up in its internal buffer for a while and then get spat out to the writer. """ output = [] input = iter(itertools.cycle(["012", "345", "6", "7", "8", "9"])) c = pop3._IteratorBuffer(output.extend, input, 6) i = iter(c) self.assertEqual(output, []) # Nothing is buffer next(i) self.assertEqual(output, []) # '012' is buffered next(i) self.assertEqual(output, []) # '012345' is buffered next(i) self.assertEqual(output, ["012", "345", "6"]) # Nothing is buffered for n in range(5): next(i) self.assertEqual(output, ["012", "345", "6", "7", "8", "9", "012", "345"]) def test_FinishLineBuffering(self): """ Test that a LineBuffer flushes everything when its iterator is exhausted, and itself raises StopIteration. """ output = [] input = iter(["a", "b", "c"]) c = pop3._IteratorBuffer(output.extend, input, 5) for i in c: pass self.assertEqual(output, ["a", "b", "c"]) def test_SuccessResponseFormatter(self): """ Test that the thing that spits out POP3 'success responses' works right. """ self.assertEqual(pop3.successResponse(b"Great."), b"+OK Great.\r\n") def test_StatLineFormatter(self): """ Test that the function which formats stat lines does so appropriately. """ statLine = list(pop3.formatStatResponse([]))[-1] self.assertEqual(statLine, b"+OK 0 0\r\n") statLine = list(pop3.formatStatResponse([10, 31, 0, 10101]))[-1] self.assertEqual(statLine, b"+OK 4 10142\r\n") def test_ListLineFormatter(self): """ Test that the function which formats the lines in response to a LIST command does so appropriately. """ listLines = list(pop3.formatListResponse([])) self.assertEqual(listLines, [b"+OK 0\r\n", b".\r\n"]) listLines = list(pop3.formatListResponse([1, 2, 3, 100])) self.assertEqual( listLines, [b"+OK 4\r\n", b"1 1\r\n", b"2 2\r\n", b"3 3\r\n", b"4 100\r\n", b".\r\n"], ) def test_UIDListLineFormatter(self): """ Test that the function which formats lines in response to a UIDL command does so appropriately. """ uids = ["abc", "def", "ghi"] listLines = list(pop3.formatUIDListResponse([], uids.__getitem__)) self.assertEqual(listLines, [b"+OK \r\n", b".\r\n"]) listLines = list(pop3.formatUIDListResponse([123, 431, 591], uids.__getitem__)) self.assertEqual( listLines, [b"+OK \r\n", b"1 abc\r\n", b"2 def\r\n", b"3 ghi\r\n", b".\r\n"] ) listLines = list(pop3.formatUIDListResponse([0, None, 591], uids.__getitem__)) self.assertEqual(listLines, [b"+OK \r\n", b"1 abc\r\n", b"3 ghi\r\n", b".\r\n"]) class MyVirtualPOP3(mail.protocols.VirtualPOP3): """ A virtual-domain-supporting POP3 server. """ magic = b"<moshez>" def authenticateUserAPOP(self, user, digest): """ Authenticate against a user against a virtual domain. @param user: The username. @param digest: The digested password. @return: A three-tuple like the one returned by L{IRealm.requestAvatar}. The mailbox will be for the user given by C{user}. """ user, domain = self.lookupDomain(user) return self.service.domains[b"baz.com"].authenticateUserAPOP( user, digest, self.magic, domain ) class DummyDomain: """ A virtual domain for a POP3 server. """ def __init__(self): self.users = {} def addUser(self, name): """ Create a mailbox for a new user. @param name: The username. """ self.users[name] = [] def addMessage(self, name, message): """ Add a message to the mailbox of the named user. @param name: The username. @param message: The contents of the message. """ self.users[name].append(message) def authenticateUserAPOP(self, name, digest, magic, domain): """ Succeed with a L{ListMailbox}. @param name: The name of the user authenticating. @param digest: ignored @param magic: ignored @param domain: ignored @return: A three-tuple like the one returned by L{IRealm.requestAvatar}. The mailbox will be for the user given by C{name}. """ return pop3.IMailbox, ListMailbox(self.users[name]), lambda: None class ListMailbox: """ A simple in-memory list implementation of L{IMailbox}. """ def __init__(self, list): """ @param list: The messages. """ self.list = list def listMessages(self, i=None): """ Get some message information. @param i: See L{pop3.IMailbox.listMessages}. @return: See L{pop3.IMailbox.listMessages}. """ if i is None: return [len(l) for l in self.list] return len(self.list[i]) def getMessage(self, i): """ Get the message content. @param i: See L{pop3.IMailbox.getMessage}. @return: See L{pop3.IMailbox.getMessage}. """ return BytesIO(self.list[i]) def getUidl(self, i): """ Construct a UID by using the given index value. @param i: See L{pop3.IMailbox.getUidl}. @return: See L{pop3.IMailbox.getUidl}. """ return i def deleteMessage(self, i): """ Wipe the message at the given index. @param i: See L{pop3.IMailbox.deleteMessage}. """ self.list[i] = b"" def sync(self): """ No-op. @see: L{pop3.IMailbox.sync} """ class MyPOP3Downloader(pop3.POP3Client): """ A POP3 client which downloads all messages from the server. """ def handle_WELCOME(self, line): """ Authenticate. @param line: The welcome response. """ pop3.POP3Client.handle_WELCOME(self, line) self.apop(b"hello@baz.com", b"world") def handle_APOP(self, line): """ Require an I{OK} response to I{APOP}. @param line: The I{APOP} response. """ parts = line.split() code = parts[0] if code != b"+OK": raise AssertionError(f"code is: {code} , parts is: {parts} ") self.lines = [] self.retr(1) def handle_RETR_continue(self, line): """ Record one line of message information. @param line: A I{RETR} response line. """ self.lines.append(line) def handle_RETR_end(self): """ Record the received message information. """ self.message = b"\n".join(self.lines) + b"\n" self.quit() def handle_QUIT(self, line): """ Require an I{OK} response to I{QUIT}. @param line: The I{QUIT} response. """ if line[:3] != b"+OK": raise AssertionError(b"code is " + line) class POP3Tests(unittest.TestCase): """ Tests for L{pop3.POP3}. """ message = b"""\ Subject: urgent Someone set up us the bomb! """ expectedOutput = b"""\ +OK <moshez>\015 +OK Authentication succeeded\015 +OK \015 1 0\015 .\015 +OK %d\015 Subject: urgent\015 \015 Someone set up us the bomb!\015 .\015 +OK \015 """ % ( len(message), ) def setUp(self): """ Set up a POP3 server with virtual domain support. """ self.factory = internet.protocol.Factory() self.factory.domains = {} self.factory.domains[b"baz.com"] = DummyDomain() self.factory.domains[b"baz.com"].addUser(b"hello") self.factory.domains[b"baz.com"].addMessage(b"hello", self.message) def test_messages(self): """ Messages can be downloaded over a loopback TCP connection. """ client = LineSendingProtocol( [ b"APOP hello@baz.com world", b"UIDL", b"RETR 1", b"QUIT", ] ) server = MyVirtualPOP3() server.service = self.factory def check(ignored): output = b"\r\n".join(client.response) + b"\r\n" self.assertEqual(output, self.expectedOutput) return loopback.loopbackTCP(server, client).addCallback(check) def test_loopback(self): """ Messages can be downloaded over a loopback connection. """ protocol = MyVirtualPOP3() protocol.service = self.factory clientProtocol = MyPOP3Downloader() def check(ignored): self.assertEqual(clientProtocol.message, self.message) protocol.connectionLost( failure.Failure(Exception("Test harness disconnect")) ) d = loopback.loopbackAsync(protocol, clientProtocol) return d.addCallback(check) test_loopback.suppress = [ # type: ignore[attr-defined] util.suppress(message="twisted.mail.pop3.POP3Client is deprecated") ] def test_incorrectDomain(self): """ Look up a user in a domain which this server does not support. """ factory = internet.protocol.Factory() factory.domains = {} factory.domains[b"twistedmatrix.com"] = DummyDomain() server = MyVirtualPOP3() server.service = factory exc = self.assertRaises( pop3.POP3Error, server.authenticateUserAPOP, b"nobody@baz.com", b"password" ) self.assertEqual(exc.args[0], "no such domain baz.com") class DummyPOP3(pop3.POP3): """ A simple POP3 server with a hard-coded mailbox for any user. """ magic = b"<moshez>" def authenticateUserAPOP(self, user, password): """ Succeed with a L{DummyMailbox}. @param user: ignored @param password: ignored @return: A three-tuple like the one returned by L{IRealm.requestAvatar}. """ return pop3.IMailbox, DummyMailbox(ValueError), lambda: None class DummyPOP3Auth(DummyPOP3): """ Class to test successful authentication in twisted.mail.pop3.POP3. """ def __init__(self, user, password): self.portal = cred.portal.Portal(TestRealm()) ch = cred.checkers.InMemoryUsernamePasswordDatabaseDontUse() ch.addUser(user, password) self.portal.registerChecker(ch) class DummyMailbox(pop3.Mailbox): """ An in-memory L{pop3.IMailbox} implementation. @ivar messages: A sequence of L{bytes} defining the messages in this mailbox. @ivar exceptionType: The type of exception to raise when an out-of-bounds index is addressed. """ messages = [b"From: moshe\nTo: moshe\n\nHow are you, friend?\n"] def __init__(self, exceptionType): self.messages = DummyMailbox.messages[:] self.exceptionType = exceptionType def listMessages(self, i=None): """ Get some message information. @param i: See L{pop3.IMailbox.listMessages}. @return: See L{pop3.IMailbox.listMessages}. """ if i is None: return [len(m) for m in self.messages] if i >= len(self.messages): raise self.exceptionType() return len(self.messages[i]) def getMessage(self, i): """ Get the message content. @param i: See L{pop3.IMailbox.getMessage}. @return: See L{pop3.IMailbox.getMessage}. """ return BytesIO(self.messages[i]) def getUidl(self, i): """ Construct a UID which is simply the string representation of the given index. @param i: See L{pop3.IMailbox.getUidl}. @return: See L{pop3.IMailbox.getUidl}. """ if i >= len(self.messages): raise self.exceptionType() return b"%d" % (i,) def deleteMessage(self, i): """ Wipe the message at the given index. @param i: See L{pop3.IMailbox.deleteMessage}. """ self.messages[i] = b"" class AnotherPOP3Tests(unittest.TestCase): """ Additional L{pop3.POP3} tests. """ def runTest(self, lines, expectedOutput, protocolInstance=None): """ Assert that when C{lines} are delivered to L{pop3.POP3} it responds with C{expectedOutput}. @param lines: A sequence of L{bytes} representing lines to deliver to the server. @param expectedOutput: A sequence of L{bytes} representing the expected response from the server. @param protocolInstance: Instance of L{twisted.mail.pop3.POP3} or L{None}. If L{None}, a new DummyPOP3 will be used. @return: A L{Deferred} that fires when the lines have been delivered and the output checked. """ dummy = protocolInstance if protocolInstance else DummyPOP3() client = LineSendingProtocol(lines) d = loopback.loopbackAsync(dummy, client) return d.addCallback(self._cbRunTest, client, dummy, expectedOutput) def _cbRunTest(self, ignored, client, dummy, expectedOutput): self.assertEqual(b"\r\n".join(expectedOutput), b"\r\n".join(client.response)) dummy.connectionLost(failure.Failure(Exception("Test harness disconnect"))) return ignored def test_buffer(self): """ Test a lot of different POP3 commands in an extremely pipelined scenario. This test may cover legitimate behavior, but the intent and granularity are not very good. It would likely be an improvement to split it into a number of smaller, more focused tests. """ return self.runTest( [ b"APOP moshez dummy", b"LIST", b"UIDL", b"RETR 1", b"RETR 2", b"DELE 1", b"RETR 1", b"QUIT", ], [ b"+OK <moshez>", b"+OK Authentication succeeded", b"+OK 1", b"1 44", b".", b"+OK ", b"1 0", b".", b"+OK 44", b"From: moshe", b"To: moshe", b"", b"How are you, friend?", b".", b"-ERR Bad message number argument", b"+OK ", b"-ERR message deleted", b"+OK ", ], ) def test_noop(self): """ Test the no-op command. """ return self.runTest( [b"APOP spiv dummy", b"NOOP", b"QUIT"], [b"+OK <moshez>", b"+OK Authentication succeeded", b"+OK ", b"+OK "], ) def test_badUTF8CharactersInCommand(self): """ Sending a command with invalid UTF-8 characters will raise a L{pop3.POP3Error}. """ error = b"not authenticated yet: cannot do \x81PASS" d = self.runTest( [b"\x81PASS", b"QUIT"], [ b"+OK <moshez>", b"-ERR bad protocol or server: POP3Error: " + error, b"+OK ", ], ) errors = self.flushLoggedErrors(pop3.POP3Error) self.assertEqual(len(errors), 1) return d def test_authListing(self): """ L{pop3.POP3} responds to an I{AUTH} command with a list of supported authentication types based on its factory's C{challengers}. """ p = DummyPOP3() p.factory = internet.protocol.Factory() p.factory.challengers = {b"Auth1": None, b"secondAuth": None, b"authLast": None} client = LineSendingProtocol( [ b"AUTH", b"QUIT", ] ) d = loopback.loopbackAsync(p, client) return d.addCallback(self._cbTestAuthListing, client) def _cbTestAuthListing(self, ignored, client): self.assertTrue(client.response[1].startswith(b"+OK")) self.assertEqual( sorted(client.response[2:5]), [b"AUTH1", b"AUTHLAST", b"SECONDAUTH"] ) self.assertEqual(client.response[5], b".") def run_PASS( self, real_user, real_password, tried_user=None, tried_password=None, after_auth_input=[], after_auth_output=[], ): """ Test a login with PASS. If L{real_user} matches L{tried_user} and L{real_password} matches L{tried_password}, a successful login will be expected. Otherwise an unsuccessful login will be expected. @type real_user: L{bytes} @param real_user: The user to test. @type real_password: L{bytes} @param real_password: The password of the test user. @type tried_user: L{bytes} or L{None} @param tried_user: The user to call USER with. If None, real_user will be used. @type tried_password: L{bytes} or L{None} @param tried_password: The password to call PASS with. If None, real_password will be used. @type after_auth_input: L{list} of l{bytes} @param after_auth_input: Extra protocol input after authentication. @type after_auth_output: L{list} of l{bytes} @param after_auth_output: Extra protocol output after authentication. """ if not tried_user: tried_user = real_user if not tried_password: tried_password = real_password response = [ b"+OK <moshez>", b"+OK USER accepted, send PASS", b"-ERR Authentication failed", ] if real_user == tried_user and real_password == tried_password: response = [ b"+OK <moshez>", b"+OK USER accepted, send PASS", b"+OK Authentication succeeded", ] fullInput = [ b" ".join([b"USER", tried_user]), b" ".join([b"PASS", tried_password]), ] fullInput += after_auth_input + [b"QUIT"] response += after_auth_output + [b"+OK "] return self.runTest( fullInput, response, protocolInstance=DummyPOP3Auth(real_user, real_password), ) def run_PASS_before_USER(self, password): """ Test protocol violation produced by calling PASS before USER. @type password: L{bytes} @param password: A password to test. """ return self.runTest( [b" ".join([b"PASS", password]), b"QUIT"], [b"+OK <moshez>", b"-ERR USER required before PASS", b"+OK "], ) def test_illegal_PASS_before_USER(self): """ Test PASS before USER with a wrong password. """ return self.run_PASS_before_USER(b"fooz") def test_empty_PASS_before_USER(self): """ Test PASS before USER with an empty password. """ return self.run_PASS_before_USER(b"") def test_one_space_PASS_before_USER(self): """ Test PASS before USER with an password that is a space. """ return self.run_PASS_before_USER(b" ") def test_space_PASS_before_USER(self): """ Test PASS before USER with a password containing a space. """ return self.run_PASS_before_USER(b"fooz barz") def test_multiple_spaces_PASS_before_USER(self): """ Test PASS before USER with a password containing multiple spaces. """ return self.run_PASS_before_USER(b"fooz barz asdf") def test_other_whitespace_PASS_before_USER(self): """ Test PASS before USER with a password containing tabs and spaces. """ return self.run_PASS_before_USER(b"fooz barz\tcrazy@! \t ") def test_good_PASS(self): """ Test PASS with a good password. """ return self.run_PASS(b"testuser", b"fooz") def test_space_PASS(self): """ Test PASS with a password containing a space. """ return self.run_PASS(b"testuser", b"fooz barz") def test_multiple_spaces_PASS(self): """ Test PASS with a password containing a space. """ return self.run_PASS(b"testuser", b"fooz barz asdf") def test_other_whitespace_PASS(self): """ Test PASS with a password containing tabs and spaces. """ return self.run_PASS(b"testuser", b"fooz barz\tcrazy@! \t ") def test_pass_wrong_user(self): """ Test PASS with a wrong user. """ return self.run_PASS(b"testuser", b"fooz", tried_user=b"wronguser") def test_wrong_PASS(self): """ Test PASS with a wrong password. """ return self.run_PASS(b"testuser", b"fooz", tried_password=b"barz") def test_wrong_space_PASS(self): """ Test PASS with a password containing a space. """ return self.run_PASS(b"testuser", b"fooz barz", tried_password=b"foozbarz ") def test_wrong_multiple_spaces_PASS(self): """ Test PASS with a password containing a space. """ return self.run_PASS( b"testuser", b"fooz barz asdf", tried_password=b"foozbarz " ) def test_wrong_other_whitespace_PASS(self): """ Test PASS with a password containing tabs and spaces. """ return self.run_PASS(b"testuser", b"fooz barz\tcrazy@! \t ") def test_wrong_command(self): """ After logging in, test a dummy command that is not defined. """ extra_input = [b"DUMMY COMMAND"] extra_output = [ b" ".join( [ b"-ERR bad protocol or server: POP3Error:", b"Unknown protocol command: DUMMY", ] ) ] return self.run_PASS( b"testuser", b"testpassword", after_auth_input=extra_input, after_auth_output=extra_output, ).addCallback(self.flushLoggedErrors, pop3.POP3Error) @implementer(pop3.IServerFactory) class TestServerFactory: """ A L{pop3.IServerFactory} implementation, for use by the test suite, with some behavior controlled by the values of (settable) public attributes and other behavior based on values hard-coded both here and in some test methods. """ def cap_IMPLEMENTATION(self): """ Return the hard-coded value. @return: L{pop3.IServerFactory} """ return "Test Implementation String" def cap_EXPIRE(self): """ Return the hard-coded value. @return: L{pop3.IServerFactory} """ return 60 challengers = OrderedDict([(b"SCHEME_1", None), (b"SCHEME_2", None)]) def cap_LOGIN_DELAY(self): """ Return the hard-coded value. @return: L{pop3.IServerFactory} """ return 120 pue = True def perUserExpiration(self): """ Return the hard-coded value. @return: L{pop3.IServerFactory} """ return self.pue puld = True def perUserLoginDelay(self): """ Return the hard-coded value. @return: L{pop3.IServerFactory} """ return self.puld class TestMailbox: """ An incomplete L{IMailbox} implementation with certain per-user values hard-coded and known by tests in this module. This is useful for testing the server's per-user capability implementation. """ loginDelay = 100 messageExpiration = 25 def contained(testcase, s, *caps): """ Assert that the given capability is included in all of the capability sets. @param testcase: A L{unittest.TestCase} to use to make assertions. @param s: The capability for which to check. @type s: L{bytes} @param caps: The capability sets in which to check. @type caps: L{tuple} of iterable """ for c in caps: testcase.assertIn(s, c) class CapabilityTests(unittest.TestCase): """ Tests for L{pop3.POP3}'s per-user capability handling. """ def setUp(self): """ Create a POP3 server with some capabilities. """ s = BytesIO() p = pop3.POP3() p.factory = TestServerFactory() p.transport = internet.protocol.FileWrapper(s) p.connectionMade() p.do_CAPA() self.caps = p.listCapabilities() self.pcaps = s.getvalue().splitlines() s = BytesIO() p.mbox = TestMailbox() p.transport = internet.protocol.FileWrapper(s) p.do_CAPA() self.lpcaps = s.getvalue().splitlines() p.connectionLost(failure.Failure(Exception("Test harness disconnect"))) def test_UIDL(self): """ The server can advertise the I{UIDL} capability. """ contained(self, b"UIDL", self.caps, self.pcaps, self.lpcaps) def test_TOP(self): """ The server can advertise the I{TOP} capability. """ contained(self, b"TOP", self.caps, self.pcaps, self.lpcaps) def test_USER(self): """ The server can advertise the I{USER} capability. """ contained(self, b"USER", self.caps, self.pcaps, self.lpcaps) def test_EXPIRE(self): """ The server can advertise its per-user expiration as well as a global expiration. """ contained(self, b"EXPIRE 60 USER", self.caps, self.pcaps) contained(self, b"EXPIRE 25", self.lpcaps) def test_IMPLEMENTATION(self): """ The server can advertise its implementation string. """ contained( self, b"IMPLEMENTATION Test Implementation String", self.caps, self.pcaps, self.lpcaps, ) def test_SASL(self): """ The server can advertise the SASL schemes it supports. """ contained(self, b"SASL SCHEME_1 SCHEME_2", self.caps, self.pcaps, self.lpcaps) def test_LOGIN_DELAY(self): """ The can advertise a per-user login delay as well as a global login delay. """ contained(self, b"LOGIN-DELAY 120 USER", self.caps, self.pcaps) self.assertIn(b"LOGIN-DELAY 100", self.lpcaps) class GlobalCapabilitiesTests(unittest.TestCase): """ Tests for L{pop3.POP3}'s global capability handling. """ def setUp(self): """ Create a POP3 server with some capabilities. """ s = BytesIO() p = pop3.POP3() p.factory = TestServerFactory() p.factory.pue = p.factory.puld = False p.transport = internet.protocol.FileWrapper(s) p.connectionMade() p.do_CAPA() self.caps = p.listCapabilities() self.pcaps = s.getvalue().splitlines() s = BytesIO() p.mbox = TestMailbox() p.transport = internet.protocol.FileWrapper(s) p.do_CAPA() self.lpcaps = s.getvalue().splitlines() p.connectionLost(failure.Failure(Exception("Test harness disconnect"))) def test_EXPIRE(self): """ I{EXPIRE} is in the server's advertised capabilities. """ contained(self, b"EXPIRE 60", self.caps, self.pcaps, self.lpcaps) def test_LOGIN_DELAY(self): """ I{LOGIN-DELAY} is in the server's advertised capabilities. """ contained(self, b"LOGIN-DELAY 120", self.caps, self.pcaps, self.lpcaps) class TestRealm: """ An L{IRealm} which knows about a single test account's mailbox. """ def requestAvatar(self, avatarId, mind, *interfaces): """ Retrieve a mailbox for I{testuser} or fail. @param avatarId: See L{IRealm.requestAvatar}. @param mind: See L{IRealm.requestAvatar}. @param interfaces: See L{IRealm.requestAvatar}. @raises: L{AssertionError} when requesting an C{avatarId} other than I{testuser}. """ if avatarId == b"testuser": return pop3.IMailbox, DummyMailbox(ValueError), lambda: None assert False class SASLTests(unittest.TestCase): """ Tests for L{pop3.POP3}'s SASL implementation. """ def test_ValidLogin(self): """ A CRAM-MD5-based SASL login attempt succeeds if it uses a username and a hashed password known to the server's credentials checker. """ p = pop3.POP3() p.factory = TestServerFactory() p.factory.challengers = {b"CRAM-MD5": cred.credentials.CramMD5Credentials} p.portal = cred.portal.Portal(TestRealm()) ch = cred.checkers.InMemoryUsernamePasswordDatabaseDontUse() ch.addUser(b"testuser", b"testpassword") p.portal.registerChecker(ch) s = BytesIO() p.transport = internet.protocol.FileWrapper(s) p.connectionMade() p.lineReceived(b"CAPA") self.assertTrue(s.getvalue().find(b"SASL CRAM-MD5") >= 0) p.lineReceived(b"AUTH CRAM-MD5") chal = s.getvalue().splitlines()[-1][2:] chal = base64.b64decode(chal) response = ( hmac.HMAC(b"testpassword", chal, digestmod=md5).hexdigest().encode("ascii") ) p.lineReceived(base64.b64encode(b"testuser " + response)) self.assertTrue(p.mbox) self.assertTrue(s.getvalue().splitlines()[-1].find(b"+OK") >= 0) p.connectionLost(failure.Failure(Exception("Test harness disconnect"))) class CommandMixin: """ Tests for all the commands a POP3 server is allowed to receive. """ extraMessage = b"""\ From: guy To: fellow More message text for you. """ def setUp(self): """ Make a POP3 server protocol instance hooked up to a simple mailbox and a transport that buffers output to a BytesIO. """ p = pop3.POP3() p.mbox = self.mailboxType(self.exceptionType) p.schedule = list self.pop3Server = p s = BytesIO() p.transport = internet.protocol.FileWrapper(s) p.connectionMade() s.seek(0) s.truncate(0) self.pop3Transport = s def tearDown(self): """ Disconnect the server protocol so it can clean up anything it might need to clean up. """ self.pop3Server.connectionLost( failure.Failure(Exception("Test harness disconnect")) ) def _flush(self): """ Do some of the things that the reactor would take care of, if the reactor were actually running. """ # Oh man FileWrapper is pooh. self.pop3Server.transport._checkProducer() def test_LIST(self): """ Test the two forms of list: with a message index number, which should return a short-form response, and without a message index number, which should return a long-form response, one line per message. """ p = self.pop3Server s = self.pop3Transport p.lineReceived(b"LIST 1") self._flush() self.assertEqual(s.getvalue(), b"+OK 1 44\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"LIST") self._flush() self.assertEqual(s.getvalue(), b"+OK 1\r\n1 44\r\n.\r\n") def test_LISTWithBadArgument(self): """ Test that non-integers and out-of-bound integers produce appropriate error responses. """ p = self.pop3Server s = self.pop3Transport p.lineReceived(b"LIST a") self.assertEqual(s.getvalue(), b"-ERR Invalid message-number: a\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"LIST 0") self.assertEqual(s.getvalue(), b"-ERR Invalid message-number: 0\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"LIST 2") self.assertEqual(s.getvalue(), b"-ERR Invalid message-number: 2\r\n") s.seek(0) s.truncate(0) def test_UIDL(self): """ Test the two forms of the UIDL command. These are just like the two forms of the LIST command. """ p = self.pop3Server s = self.pop3Transport p.lineReceived(b"UIDL 1") self.assertEqual(s.getvalue(), b"+OK 0\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"UIDL") self._flush() self.assertEqual(s.getvalue(), b"+OK \r\n1 0\r\n.\r\n") def test_UIDLWithBadArgument(self): """ Test that UIDL with a non-integer or an out-of-bounds integer produces the appropriate error response. """ p = self.pop3Server s = self.pop3Transport p.lineReceived(b"UIDL a") self.assertEqual(s.getvalue(), b"-ERR Bad message number argument\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"UIDL 0") self.assertEqual(s.getvalue(), b"-ERR Bad message number argument\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"UIDL 2") self.assertEqual(s.getvalue(), b"-ERR Bad message number argument\r\n") s.seek(0) s.truncate(0) def test_STAT(self): """ Test the single form of the STAT command, which returns a short-form response of the number of messages in the mailbox and their total size. """ p = self.pop3Server s = self.pop3Transport p.lineReceived(b"STAT") self._flush() self.assertEqual(s.getvalue(), b"+OK 1 44\r\n") def test_RETR(self): """ Test downloading a message. """ p = self.pop3Server s = self.pop3Transport p.lineReceived(b"RETR 1") self._flush() self.assertEqual( s.getvalue(), b"+OK 44\r\n" b"From: moshe\r\n" b"To: moshe\r\n" b"\r\n" b"How are you, friend?\r\n" b".\r\n", ) s.seek(0) s.truncate(0) def test_RETRWithBadArgument(self): """ Test that trying to download a message with a bad argument, either not an integer or an out-of-bounds integer, fails with the appropriate error response. """ p = self.pop3Server s = self.pop3Transport p.lineReceived(b"RETR a") self.assertEqual(s.getvalue(), b"-ERR Bad message number argument\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"RETR 0") self.assertEqual(s.getvalue(), b"-ERR Bad message number argument\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"RETR 2") self.assertEqual(s.getvalue(), b"-ERR Bad message number argument\r\n") s.seek(0) s.truncate(0) def test_TOP(self): """ Test downloading the headers and part of the body of a message. """ p = self.pop3Server s = self.pop3Transport p.mbox.messages.append(self.extraMessage) p.lineReceived(b"TOP 1 0") self._flush() self.assertEqual( s.getvalue(), b"+OK Top of message follows\r\n" b"From: moshe\r\n" b"To: moshe\r\n" b"\r\n" b".\r\n", ) def test_TOPWithBadArgument(self): """ Test that trying to download a message with a bad argument, either a message number which isn't an integer or is an out-of-bounds integer or a number of lines which isn't an integer or is a negative integer, fails with the appropriate error response. """ p = self.pop3Server s = self.pop3Transport p.mbox.messages.append(self.extraMessage) p.lineReceived(b"TOP 1 a") self.assertEqual(s.getvalue(), b"-ERR Bad line count argument\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"TOP 1 -1") self.assertEqual(s.getvalue(), b"-ERR Bad line count argument\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"TOP a 1") self.assertEqual(s.getvalue(), b"-ERR Bad message number argument\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"TOP 0 1") self.assertEqual(s.getvalue(), b"-ERR Bad message number argument\r\n") s.seek(0) s.truncate(0) p.lineReceived(b"TOP 3 1") self.assertEqual(s.getvalue(), b"-ERR Bad message number argument\r\n") s.seek(0) s.truncate(0) def test_LAST(self): """ Test the exceedingly pointless LAST command, which tells you the highest message index which you have already downloaded. """ p = self.pop3Server s = self.pop3Transport p.mbox.messages.append(self.extraMessage) p.lineReceived(b"LAST") self.assertEqual(s.getvalue(), b"+OK 0\r\n") s.seek(0) s.truncate(0) def test_RetrieveUpdatesHighest(self): """ Test that issuing a RETR command updates the LAST response. """ p = self.pop3Server s = self.pop3Transport p.mbox.messages.append(self.extraMessage) p.lineReceived(b"RETR 2") self._flush() s.seek(0) s.truncate(0) p.lineReceived(b"LAST") self.assertEqual(s.getvalue(), b"+OK 2\r\n") s.seek(0) s.truncate(0) def test_TopUpdatesHighest(self): """ Test that issuing a TOP command updates the LAST response. """ p = self.pop3Server s = self.pop3Transport p.mbox.messages.append(self.extraMessage) p.lineReceived(b"TOP 2 10") self._flush() s.seek(0) s.truncate(0) p.lineReceived(b"LAST") self.assertEqual(s.getvalue(), b"+OK 2\r\n") def test_HighestOnlyProgresses(self): """ Test that downloading a message with a smaller index than the current LAST response doesn't change the LAST response. """ p = self.pop3Server s = self.pop3Transport p.mbox.messages.append(self.extraMessage) p.lineReceived(b"RETR 2") self._flush() p.lineReceived(b"TOP 1 10") self._flush() s.seek(0) s.truncate(0) p.lineReceived(b"LAST") self.assertEqual(s.getvalue(), b"+OK 2\r\n") def test_ResetClearsHighest(self): """ Test that issuing RSET changes the LAST response to 0. """ p = self.pop3Server s = self.pop3Transport p.mbox.messages.append(self.extraMessage) p.lineReceived(b"RETR 2") self._flush() p.lineReceived(b"RSET") s.seek(0) s.truncate(0) p.lineReceived(b"LAST") self.assertEqual(s.getvalue(), b"+OK 0\r\n") _listMessageDeprecation = ( "twisted.mail.pop3.IMailbox.listMessages may not " "raise IndexError for out-of-bounds message numbers: " "raise ValueError instead." ) _listMessageSuppression = util.suppress( message=_listMessageDeprecation, category=PendingDeprecationWarning ) _getUidlDeprecation = ( "twisted.mail.pop3.IMailbox.getUidl may not " "raise IndexError for out-of-bounds message numbers: " "raise ValueError instead." ) _getUidlSuppression = util.suppress( message=_getUidlDeprecation, category=PendingDeprecationWarning ) class IndexErrorCommandTests(CommandMixin, unittest.TestCase): """ Run all of the command tests against a mailbox which raises IndexError when an out of bounds request is made. This behavior will be deprecated shortly and then removed. """ exceptionType = IndexError mailboxType = DummyMailbox def test_LISTWithBadArgument(self): """ An attempt to get metadata about a message with a bad argument fails with an I{ERR} response even if the mailbox implementation raises L{IndexError}. """ return CommandMixin.test_LISTWithBadArgument(self) test_LISTWithBadArgument.suppress = [_listMessageSuppression] # type: ignore[attr-defined] def test_UIDLWithBadArgument(self): """ An attempt to look up the UID of a message with a bad argument fails with an I{ERR} response even if the mailbox implementation raises L{IndexError}. """ return CommandMixin.test_UIDLWithBadArgument(self) test_UIDLWithBadArgument.suppress = [_getUidlSuppression] # type: ignore[attr-defined] def test_TOPWithBadArgument(self): """ An attempt to download some of a message with a bad argument fails with an I{ERR} response even if the mailbox implementation raises L{IndexError}. """ return CommandMixin.test_TOPWithBadArgument(self) test_TOPWithBadArgument.suppress = [_listMessageSuppression] # type: ignore[attr-defined] def test_RETRWithBadArgument(self): """ An attempt to download a message with a bad argument fails with an I{ERR} response even if the mailbox implementation raises L{IndexError}. """ return CommandMixin.test_RETRWithBadArgument(self) test_RETRWithBadArgument.suppress = [_listMessageSuppression] # type: ignore[attr-defined] class ValueErrorCommandTests(CommandMixin, unittest.TestCase): """ Run all of the command tests against a mailbox which raises ValueError when an out of bounds request is made. This is the correct behavior and after support for mailboxes which raise IndexError is removed, this will become just C{CommandTestCase}. """ exceptionType = ValueError mailboxType = DummyMailbox class SyncDeferredMailbox(DummyMailbox): """ Mailbox which has a listMessages implementation which returns a Deferred which has already fired. """ def listMessages(self, n=None): """ Synchronously list messages. @type n: L{int} or L{None} @param n: The 0-based index of the message. @return: A L{Deferred} which already has a message list result. """ return defer.succeed(DummyMailbox.listMessages(self, n)) class IndexErrorSyncDeferredCommandTests(IndexErrorCommandTests): """ Run all of the L{IndexErrorCommandTests} tests with a synchronous-Deferred returning IMailbox implementation. """ mailboxType = SyncDeferredMailbox class ValueErrorSyncDeferredCommandTests(ValueErrorCommandTests): """ Run all of the L{ValueErrorCommandTests} tests with a synchronous-Deferred returning IMailbox implementation. """ mailboxType = SyncDeferredMailbox class AsyncDeferredMailbox(DummyMailbox): """ Mailbox which has a listMessages implementation which returns a Deferred which has not yet fired. """ def __init__(self, *a, **kw): self.waiting = [] DummyMailbox.__init__(self, *a, **kw) def listMessages(self, n=None): """ Record a new unfired L{Deferred} in C{self.waiting} and return it. @type n: L{int} or L{None} @param n: The 0-based index of the message. @return: The L{Deferred} """ d = defer.Deferred() # See AsyncDeferredMailbox._flush self.waiting.append((d, DummyMailbox.listMessages(self, n))) return d class IndexErrorAsyncDeferredCommandTests(IndexErrorCommandTests): """ Run all of the L{IndexErrorCommandTests} tests with an asynchronous-Deferred returning IMailbox implementation. """ mailboxType = AsyncDeferredMailbox def _flush(self): """ Fire whatever Deferreds we've built up in our mailbox. """ while self.pop3Server.mbox.waiting: d, a = self.pop3Server.mbox.waiting.pop() d.callback(a) IndexErrorCommandTests._flush(self) class ValueErrorAsyncDeferredCommandTests(ValueErrorCommandTests): """ Run all of the L{IndexErrorCommandTests} tests with an asynchronous-Deferred returning IMailbox implementation. """ mailboxType = AsyncDeferredMailbox def _flush(self): """ Fire whatever Deferreds we've built up in our mailbox. """ while self.pop3Server.mbox.waiting: d, a = self.pop3Server.mbox.waiting.pop() d.callback(a) ValueErrorCommandTests._flush(self) class POP3MiscTests(unittest.TestCase): """ Miscellaneous tests more to do with module/package structure than anything to do with the Post Office Protocol. """ def test_all(self): """ This test checks that all names listed in twisted.mail.pop3.__all__ are actually present in the module. """ mod = twisted.mail.pop3 for attr in mod.__all__: self.assertTrue(hasattr(mod, attr)) class POP3ClientDeprecationTests(unittest.TestCase): """ Tests for the now deprecated L{twisted.mail.pop3client} module. """ def test_deprecation(self): """ A deprecation warning is emitted when directly importing the now deprected pop3client module. This test might fail is some other code has already imported it. No code should use the deprected module. """ from twisted.mail import pop3client warningsShown = self.flushWarnings(offendingFunctions=[self.test_deprecation]) self.assertEqual(warningsShown[0]["category"], DeprecationWarning) self.assertEqual( warningsShown[0]["message"], "twisted.mail.pop3client was deprecated in Twisted 21.2.0. " "Use twisted.mail.pop3 instead.", ) self.assertEqual(len(warningsShown), 1) pop3client # Fake usage to please pyflakes. PK Mb�Z���:TU TU mail/test/test_pop3client.pynu �[��� # -*- test-case-name: twisted.mail.test.test_pop3client -*- # Copyright (c) 2001-2004 Divmod Inc. # See LICENSE for details. import inspect import sys from typing import List from unittest import skipIf from zope.interface import directlyProvides import twisted.mail._pop3client from twisted.internet import defer, error, interfaces, protocol, reactor from twisted.mail.pop3 import ( AdvancedPOP3Client as POP3Client, InsecureAuthenticationDisallowed, ServerErrorResponse, ) from twisted.mail.test import pop3testserver from twisted.protocols import basic, loopback from twisted.python import log from twisted.test.proto_helpers import StringTransport from twisted.trial.unittest import TestCase try: from twisted.test.ssl_helpers import ClientTLSContext, ServerTLSContext except ImportError: ClientTLSContext = None # type: ignore[assignment,misc] ServerTLSContext = None # type: ignore[assignment,misc] class StringTransportWithConnectionLosing(StringTransport): def loseConnection(self): self.protocol.connectionLost(error.ConnectionDone()) capCache = { b"TOP": None, b"LOGIN-DELAY": b"180", b"UIDL": None, b"STLS": None, b"USER": None, b"SASL": b"LOGIN", } def setUp(greet=True): p = POP3Client() # Skip the CAPA login will issue if it doesn't already have a # capability cache p._capCache = capCache t = StringTransportWithConnectionLosing() t.protocol = p p.makeConnection(t) if greet: p.dataReceived(b"+OK Hello!\r\n") return p, t def strip(f): return lambda result, f=f: f() class POP3ClientLoginTests(TestCase): def testNegativeGreeting(self): p, t = setUp(greet=False) p.allowInsecureLogin = True d = p.login(b"username", b"password") p.dataReceived(b"-ERR Offline for maintenance\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"Offline for maintenance") ) def testOkUser(self): p, t = setUp() d = p.user(b"username") self.assertEqual(t.value(), b"USER username\r\n") p.dataReceived(b"+OK send password\r\n") return d.addCallback(self.assertEqual, b"send password") def testBadUser(self): p, t = setUp() d = p.user(b"username") self.assertEqual(t.value(), b"USER username\r\n") p.dataReceived(b"-ERR account suspended\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"account suspended") ) def testOkPass(self): p, t = setUp() d = p.password(b"password") self.assertEqual(t.value(), b"PASS password\r\n") p.dataReceived(b"+OK you're in!\r\n") return d.addCallback(self.assertEqual, b"you're in!") def testBadPass(self): p, t = setUp() d = p.password(b"password") self.assertEqual(t.value(), b"PASS password\r\n") p.dataReceived(b"-ERR go away\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"go away") ) def testOkLogin(self): p, t = setUp() p.allowInsecureLogin = True d = p.login(b"username", b"password") self.assertEqual(t.value(), b"USER username\r\n") p.dataReceived(b"+OK go ahead\r\n") self.assertEqual(t.value(), b"USER username\r\nPASS password\r\n") p.dataReceived(b"+OK password accepted\r\n") return d.addCallback(self.assertEqual, b"password accepted") def testBadPasswordLogin(self): p, t = setUp() p.allowInsecureLogin = True d = p.login(b"username", b"password") self.assertEqual(t.value(), b"USER username\r\n") p.dataReceived(b"+OK waiting on you\r\n") self.assertEqual(t.value(), b"USER username\r\nPASS password\r\n") p.dataReceived(b"-ERR bogus login\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"bogus login") ) def testBadUsernameLogin(self): p, t = setUp() p.allowInsecureLogin = True d = p.login(b"username", b"password") self.assertEqual(t.value(), b"USER username\r\n") p.dataReceived(b"-ERR bogus login\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"bogus login") ) def testServerGreeting(self): p, t = setUp(greet=False) p.dataReceived(b"+OK lalala this has no challenge\r\n") self.assertEqual(p.serverChallenge, None) def testServerGreetingWithChallenge(self): p, t = setUp(greet=False) p.dataReceived(b"+OK <here is the challenge>\r\n") self.assertEqual(p.serverChallenge, b"<here is the challenge>") def testAPOP(self): p, t = setUp(greet=False) p.dataReceived(b"+OK <challenge string goes here>\r\n") d = p.login(b"username", b"password") self.assertEqual( t.value(), b"APOP username f34f1e464d0d7927607753129cabe39a\r\n" ) p.dataReceived(b"+OK Welcome!\r\n") return d.addCallback(self.assertEqual, b"Welcome!") def testInsecureLoginRaisesException(self): p, t = setUp(greet=False) p.dataReceived(b"+OK Howdy\r\n") d = p.login(b"username", b"password") self.assertFalse(t.value()) return self.assertFailure(d, InsecureAuthenticationDisallowed) def testSSLTransportConsideredSecure(self): """ If a server doesn't offer APOP but the transport is secured using SSL or TLS, a plaintext login should be allowed, not rejected with an InsecureAuthenticationDisallowed exception. """ p, t = setUp(greet=False) directlyProvides(t, interfaces.ISSLTransport) p.dataReceived(b"+OK Howdy\r\n") d = p.login(b"username", b"password") self.assertEqual(t.value(), b"USER username\r\n") t.clear() p.dataReceived(b"+OK\r\n") self.assertEqual(t.value(), b"PASS password\r\n") p.dataReceived(b"+OK\r\n") return d class ListConsumer: def __init__(self): self.data = {} def consume(self, result): (item, value) = result self.data.setdefault(item, []).append(value) class MessageConsumer: def __init__(self): self.data = [] def consume(self, line): self.data.append(line) class POP3ClientListTests(TestCase): def testListSize(self): p, t = setUp() d = p.listSize() self.assertEqual(t.value(), b"LIST\r\n") p.dataReceived(b"+OK Here it comes\r\n") p.dataReceived(b"1 3\r\n2 2\r\n3 1\r\n.\r\n") return d.addCallback(self.assertEqual, [3, 2, 1]) def testListSizeWithConsumer(self): p, t = setUp() c = ListConsumer() f = c.consume d = p.listSize(f) self.assertEqual(t.value(), b"LIST\r\n") p.dataReceived(b"+OK Here it comes\r\n") p.dataReceived(b"1 3\r\n2 2\r\n3 1\r\n") self.assertEqual(c.data, {0: [3], 1: [2], 2: [1]}) p.dataReceived(b"5 3\r\n6 2\r\n7 1\r\n") self.assertEqual(c.data, {0: [3], 1: [2], 2: [1], 4: [3], 5: [2], 6: [1]}) p.dataReceived(b".\r\n") return d.addCallback(self.assertIdentical, f) def testFailedListSize(self): p, t = setUp() d = p.listSize() self.assertEqual(t.value(), b"LIST\r\n") p.dataReceived(b"-ERR Fatal doom server exploded\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"Fatal doom server exploded") ) def testListUID(self): p, t = setUp() d = p.listUID() self.assertEqual(t.value(), b"UIDL\r\n") p.dataReceived(b"+OK Here it comes\r\n") p.dataReceived(b"1 abc\r\n2 def\r\n3 ghi\r\n.\r\n") return d.addCallback(self.assertEqual, [b"abc", b"def", b"ghi"]) def testListUIDWithConsumer(self): p, t = setUp() c = ListConsumer() f = c.consume d = p.listUID(f) self.assertEqual(t.value(), b"UIDL\r\n") p.dataReceived(b"+OK Here it comes\r\n") p.dataReceived(b"1 xyz\r\n2 abc\r\n5 mno\r\n") self.assertEqual(c.data, {0: [b"xyz"], 1: [b"abc"], 4: [b"mno"]}) p.dataReceived(b".\r\n") return d.addCallback(self.assertIdentical, f) def testFailedListUID(self): p, t = setUp() d = p.listUID() self.assertEqual(t.value(), b"UIDL\r\n") p.dataReceived(b"-ERR Fatal doom server exploded\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"Fatal doom server exploded") ) class POP3ClientMessageTests(TestCase): def testRetrieve(self): p, t = setUp() d = p.retrieve(7) self.assertEqual(t.value(), b"RETR 8\r\n") p.dataReceived(b"+OK Message incoming\r\n") p.dataReceived(b"La la la here is message text\r\n") p.dataReceived(b"..Further message text tra la la\r\n") p.dataReceived(b".\r\n") return d.addCallback( self.assertEqual, [b"La la la here is message text", b".Further message text tra la la"], ) def testRetrieveWithConsumer(self): p, t = setUp() c = MessageConsumer() f = c.consume d = p.retrieve(7, f) self.assertEqual(t.value(), b"RETR 8\r\n") p.dataReceived(b"+OK Message incoming\r\n") p.dataReceived(b"La la la here is message text\r\n") p.dataReceived(b"..Further message text\r\n.\r\n") return d.addCallback(self._cbTestRetrieveWithConsumer, f, c) def _cbTestRetrieveWithConsumer(self, result, f, c): self.assertIdentical(result, f) self.assertEqual( c.data, [b"La la la here is message text", b".Further message text"] ) def testPartialRetrieve(self): p, t = setUp() d = p.retrieve(7, lines=2) self.assertEqual(t.value(), b"TOP 8 2\r\n") p.dataReceived(b"+OK 2 lines on the way\r\n") p.dataReceived(b"Line the first! Woop\r\n") p.dataReceived(b"Line the last! Bye\r\n") p.dataReceived(b".\r\n") return d.addCallback( self.assertEqual, [b"Line the first! Woop", b"Line the last! Bye"] ) def testPartialRetrieveWithConsumer(self): p, t = setUp() c = MessageConsumer() f = c.consume d = p.retrieve(7, f, lines=2) self.assertEqual(t.value(), b"TOP 8 2\r\n") p.dataReceived(b"+OK 2 lines on the way\r\n") p.dataReceived(b"Line the first! Woop\r\n") p.dataReceived(b"Line the last! Bye\r\n") p.dataReceived(b".\r\n") return d.addCallback(self._cbTestPartialRetrieveWithConsumer, f, c) def _cbTestPartialRetrieveWithConsumer(self, result, f, c): self.assertIdentical(result, f) self.assertEqual(c.data, [b"Line the first! Woop", b"Line the last! Bye"]) def testFailedRetrieve(self): p, t = setUp() d = p.retrieve(0) self.assertEqual(t.value(), b"RETR 1\r\n") p.dataReceived(b"-ERR Fatal doom server exploded\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"Fatal doom server exploded") ) def test_concurrentRetrieves(self): """ Issue three retrieve calls immediately without waiting for any to succeed and make sure they all do succeed eventually. """ p, t = setUp() messages = [ p.retrieve(i).addCallback( self.assertEqual, [b"First line of %d." % (i + 1,), b"Second line of %d." % (i + 1,)], ) for i in range(3) ] for i in range(1, 4): self.assertEqual(t.value(), b"RETR %d\r\n" % (i,)) t.clear() p.dataReceived(b"+OK 2 lines on the way\r\n") p.dataReceived(b"First line of %d.\r\n" % (i,)) p.dataReceived(b"Second line of %d.\r\n" % (i,)) self.assertEqual(t.value(), b"") p.dataReceived(b".\r\n") return defer.DeferredList(messages, fireOnOneErrback=True) class POP3ClientMiscTests(TestCase): def testCapability(self): p, t = setUp() d = p.capabilities(useCache=0) self.assertEqual(t.value(), b"CAPA\r\n") p.dataReceived(b"+OK Capabilities on the way\r\n") p.dataReceived(b"X\r\nY\r\nZ\r\nA 1 2 3\r\nB 1 2\r\nC 1\r\n.\r\n") return d.addCallback( self.assertEqual, { b"X": None, b"Y": None, b"Z": None, b"A": [b"1", b"2", b"3"], b"B": [b"1", b"2"], b"C": [b"1"], }, ) def testCapabilityError(self): p, t = setUp() d = p.capabilities(useCache=0) self.assertEqual(t.value(), b"CAPA\r\n") p.dataReceived(b"-ERR This server is lame!\r\n") return d.addCallback(self.assertEqual, {}) def testStat(self): p, t = setUp() d = p.stat() self.assertEqual(t.value(), b"STAT\r\n") p.dataReceived(b"+OK 1 1212\r\n") return d.addCallback(self.assertEqual, (1, 1212)) def testStatError(self): p, t = setUp() d = p.stat() self.assertEqual(t.value(), b"STAT\r\n") p.dataReceived(b"-ERR This server is lame!\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"This server is lame!") ) def testNoop(self): p, t = setUp() d = p.noop() self.assertEqual(t.value(), b"NOOP\r\n") p.dataReceived(b"+OK No-op to you too!\r\n") return d.addCallback(self.assertEqual, b"No-op to you too!") def testNoopError(self): p, t = setUp() d = p.noop() self.assertEqual(t.value(), b"NOOP\r\n") p.dataReceived(b"-ERR This server is lame!\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"This server is lame!") ) def testRset(self): p, t = setUp() d = p.reset() self.assertEqual(t.value(), b"RSET\r\n") p.dataReceived(b"+OK Reset state\r\n") return d.addCallback(self.assertEqual, b"Reset state") def testRsetError(self): p, t = setUp() d = p.reset() self.assertEqual(t.value(), b"RSET\r\n") p.dataReceived(b"-ERR This server is lame!\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"This server is lame!") ) def testDelete(self): p, t = setUp() d = p.delete(3) self.assertEqual(t.value(), b"DELE 4\r\n") p.dataReceived(b"+OK Hasta la vista\r\n") return d.addCallback(self.assertEqual, b"Hasta la vista") def testDeleteError(self): p, t = setUp() d = p.delete(3) self.assertEqual(t.value(), b"DELE 4\r\n") p.dataReceived(b"-ERR Winner is not you.\r\n") return self.assertFailure(d, ServerErrorResponse).addCallback( lambda exc: self.assertEqual(exc.args[0], b"Winner is not you.") ) class SimpleClient(POP3Client): def __init__(self, deferred, contextFactory=None): self.deferred = deferred self.allowInsecureLogin = True def serverGreeting(self, challenge): self.deferred.callback(None) class POP3HelperMixin: serverCTX = None clientCTX = None def setUp(self): d = defer.Deferred() self.server = pop3testserver.POP3TestServer(contextFactory=self.serverCTX) self.client = SimpleClient(d, contextFactory=self.clientCTX) self.client.timeout = 30 self.connected = d def tearDown(self): del self.server del self.client del self.connected def _cbStopClient(self, ignore): self.client.transport.loseConnection() def _ebGeneral(self, failure): self.client.transport.loseConnection() self.server.transport.loseConnection() return failure def loopback(self): return loopback.loopbackTCP(self.server, self.client, noisy=False) class TLSServerFactory(protocol.ServerFactory): class protocol(basic.LineReceiver): context = None output: List[bytes] = [] def connectionMade(self): self.factory.input = [] self.output = self.output[:] for line in self.output.pop(0): self.sendLine(line) def lineReceived(self, line): self.factory.input.append(line) [self.sendLine(l) for l in self.output.pop(0)] if line == b"STLS": self.transport.startTLS(self.context) @skipIf(not ClientTLSContext, "OpenSSL not present") @skipIf(not interfaces.IReactorSSL(reactor, None), "OpenSSL not present") class POP3TLSTests(TestCase): """ Tests for POP3Client's support for TLS connections. """ def test_startTLS(self): """ POP3Client.startTLS starts a TLS session over its existing TCP connection. """ sf = TLSServerFactory() sf.protocol.output = [ [b"+OK"], # Server greeting [b"+OK", b"STLS", b"."], # CAPA response [b"+OK"], # STLS response [b"+OK", b"."], # Second CAPA response [b"+OK"], # QUIT response ] sf.protocol.context = ServerTLSContext() port = reactor.listenTCP(0, sf, interface="127.0.0.1") self.addCleanup(port.stopListening) H = port.getHost().host P = port.getHost().port connLostDeferred = defer.Deferred() cp = SimpleClient(defer.Deferred(), ClientTLSContext()) def connectionLost(reason): SimpleClient.connectionLost(cp, reason) connLostDeferred.callback(None) cp.connectionLost = connectionLost cf = protocol.ClientFactory() cf.protocol = lambda: cp conn = reactor.connectTCP(H, P, cf) def cbConnected(ignored): log.msg("Connected to server; starting TLS") return cp.startTLS() def cbStartedTLS(ignored): log.msg("Started TLS; disconnecting") return cp.quit() def cbDisconnected(ign): log.msg("Disconnected; asserting correct input received") self.assertEqual(sf.input, [b"CAPA", b"STLS", b"CAPA", b"QUIT"]) def cleanup(result): log.msg( "Asserted correct input; disconnecting " "client and shutting down server" ) conn.disconnect() return connLostDeferred cp.deferred.addCallback(cbConnected) cp.deferred.addCallback(cbStartedTLS) cp.deferred.addCallback(cbDisconnected) cp.deferred.addBoth(cleanup) return cp.deferred class POP3TimeoutTests(POP3HelperMixin, TestCase): def testTimeout(self): def login(): d = self.client.login("test", "twisted") d.addCallback(loggedIn) d.addErrback(timedOut) return d def loggedIn(result): self.fail("Successfully logged in!? Impossible!") def timedOut(failure): failure.trap(error.TimeoutError) self._cbStopClient(None) def quit(): return self.client.quit() self.client.timeout = 0.01 # Tell the server to not return a response to client. This # will trigger a timeout. pop3testserver.TIMEOUT_RESPONSE = True methods = [login, quit] map(self.connected.addCallback, map(strip, methods)) self.connected.addCallback(self._cbStopClient) self.connected.addErrback(self._ebGeneral) return self.loopback() class POP3ClientModuleStructureTests(TestCase): """ Miscellaneous tests more to do with module/package structure than anything to do with the POP3 client. """ def test_all(self): """ twisted.mail._pop3client.__all__ should be empty because all classes should be imported through twisted.mail.pop3. """ self.assertEqual(twisted.mail._pop3client.__all__, []) def test_import(self): """ Every public class in twisted.mail._pop3client should be available as a member of twisted.mail.pop3 with the exception of twisted.mail._pop3client.POP3Client which should be available as twisted.mail.pop3.AdvancedClient. """ publicClasses = [ c[0] for c in inspect.getmembers( sys.modules["twisted.mail._pop3client"], inspect.isclass ) if not c[0][0] == "_" ] for pc in publicClasses: if sys.version_info < (3, 7) and pc == "List": # typing.List shows up in publicClasses on # Python < 3.7, so skip it. continue if not pc == "POP3Client": self.assertTrue( hasattr(twisted.mail.pop3, pc), f"{pc} not in {twisted.mail.pop3}", ) else: self.assertTrue(hasattr(twisted.mail.pop3, "AdvancedPOP3Client")) PK Mb�Z�vuG� � mail/test/test_bounce.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import email.message import email.parser from io import BytesIO, StringIO from twisted.mail import bounce from twisted.trial import unittest class BounceTests(unittest.TestCase): """ Bounce message generation """ def test_bounceMessageUnicode(self): """ L{twisted.mail.bounce.generateBounce} can accept L{unicode}. """ fromAddress, to, s = bounce.generateBounce( StringIO( """\ From: Moshe Zadka <moshez@example.com> To: nonexistent@example.org Subject: test """ ), "moshez@example.com", "nonexistent@example.org", ) self.assertEqual(fromAddress, b"") self.assertEqual(to, b"moshez@example.com") emailParser = email.parser.Parser() mess = emailParser.parse(StringIO(s.decode("utf-8"))) self.assertEqual(mess["To"], "moshez@example.com") self.assertEqual(mess["From"], "postmaster@example.org") self.assertEqual(mess["subject"], "Returned Mail: see transcript for details") def test_bounceMessageBytes(self): """ L{twisted.mail.bounce.generateBounce} can accept L{bytes}. """ fromAddress, to, s = bounce.generateBounce( BytesIO( b"""\ From: Moshe Zadka <moshez@example.com> To: nonexistent@example.org Subject: test """ ), b"moshez@example.com", b"nonexistent@example.org", ) self.assertEqual(fromAddress, b"") self.assertEqual(to, b"moshez@example.com") emailParser = email.parser.Parser() mess = emailParser.parse(StringIO(s.decode("utf-8"))) self.assertEqual(mess["To"], "moshez@example.com") self.assertEqual(mess["From"], "postmaster@example.org") self.assertEqual(mess["subject"], "Returned Mail: see transcript for details") def test_bounceMessageCustomTranscript(self): """ Pass a custom transcript message to L{twisted.mail.bounce.generateBounce}. """ fromAddress, to, s = bounce.generateBounce( BytesIO( b"""\ From: Moshe Zadka <moshez@example.com> To: nonexistent@example.org Subject: test """ ), b"moshez@example.com", b"nonexistent@example.org", "Custom transcript", ) self.assertEqual(fromAddress, b"") self.assertEqual(to, b"moshez@example.com") emailParser = email.parser.Parser() mess = emailParser.parse(StringIO(s.decode("utf-8"))) self.assertEqual(mess["To"], "moshez@example.com") self.assertEqual(mess["From"], "postmaster@example.org") self.assertEqual(mess["subject"], "Returned Mail: see transcript for details") self.assertTrue(mess.is_multipart()) parts = mess.get_payload() self.assertEqual(parts[0].get_payload(), "Custom transcript\n") def _bounceBigMessage(self, header, message, ioType): """ Pass a really big message to L{twisted.mail.bounce.generateBounce}. """ fromAddress, to, s = bounce.generateBounce( ioType(header + message), "moshez@example.com", "nonexistent@example.org" ) emailParser = email.parser.Parser() mess = emailParser.parse(StringIO(s.decode("utf-8"))) self.assertEqual(mess["To"], "moshez@example.com") self.assertEqual(mess["From"], "postmaster@example.org") self.assertEqual(mess["subject"], "Returned Mail: see transcript for details") self.assertTrue(mess.is_multipart()) parts = mess.get_payload() innerMessage = parts[1].get_payload() if isinstance(message, bytes): message = message.decode("utf-8") self.assertEqual(innerMessage[0].get_payload() + "\n", message) def test_bounceBigMessage(self): """ L{twisted.mail.bounce.generateBounce} with big L{unicode} and L{bytes} messages. """ header = b"""\ From: Moshe Zadka <moshez@example.com> To: nonexistent@example.org Subject: test """ self._bounceBigMessage(header, b"Test test\n" * 10000, BytesIO) self._bounceBigMessage(header.decode("utf-8"), "More test\n" * 10000, StringIO) PK Mb�ZTLP:� � mail/test/rfc822.messagenu �[��� Return-Path: <twisted-commits-admin@twistedmatrix.com> Delivered-To: exarkun@meson.dyndns.org Received: from localhost [127.0.0.1] by localhost with POP3 (fetchmail-6.2.1) for exarkun@localhost (single-drop); Thu, 20 Mar 2003 14:50:20 -0500 (EST) Received: from pyramid.twistedmatrix.com (adsl-64-123-27-105.dsl.austtx.swbell.net [64.123.27.105]) by intarweb.us (Postfix) with ESMTP id 4A4A513EA4 for <exarkun@meson.dyndns.org>; Thu, 20 Mar 2003 14:49:27 -0500 (EST) Received: from localhost ([127.0.0.1] helo=pyramid.twistedmatrix.com) by pyramid.twistedmatrix.com with esmtp (Exim 3.35 #1 (Debian)) id 18w648-0007Vl-00; Thu, 20 Mar 2003 13:51:04 -0600 Received: from acapnotic by pyramid.twistedmatrix.com with local (Exim 3.35 #1 (Debian)) id 18w63j-0007VK-00 for <twisted-commits@twistedmatrix.com>; Thu, 20 Mar 2003 13:50:39 -0600 To: twisted-commits@twistedmatrix.com From: etrepum CVS <etrepum@twistedmatrix.com> Reply-To: twisted-python@twistedmatrix.com X-Mailer: CVSToys Message-Id: <E18w63j-0007VK-00@pyramid.twistedmatrix.com> Subject: [Twisted-commits] rebuild now works on python versions from 2.2.0 and up. Sender: twisted-commits-admin@twistedmatrix.com Errors-To: twisted-commits-admin@twistedmatrix.com X-BeenThere: twisted-commits@twistedmatrix.com X-Mailman-Version: 2.0.11 Precedence: bulk List-Help: <mailto:twisted-commits-request@twistedmatrix.com?subject=help> List-Post: <mailto:twisted-commits@twistedmatrix.com> List-Subscribe: <http://twistedmatrix.com/cgi-bin/mailman/listinfo/twisted-commits>, <mailto:twisted-commits-request@twistedmatrix.com?subject=subscribe> List-Id: <twisted-commits.twistedmatrix.com> List-Unsubscribe: <http://twistedmatrix.com/cgi-bin/mailman/listinfo/twisted-commits>, <mailto:twisted-commits-request@twistedmatrix.com?subject=unsubscribe> List-Archive: <http://twistedmatrix.com/pipermail/twisted-commits/> Date: Thu, 20 Mar 2003 13:50:39 -0600 Modified files: Twisted/twisted/python/rebuild.py 1.19 1.20 Log message: rebuild now works on python versions from 2.2.0 and up. ViewCVS links: http://twistedmatrix.com/users/jh.twistd/viewcvs/cgi/viewcvs.cgi/twisted/python/rebuild.py.diff?r1=text&tr1=1.19&r2=text&tr2=1.20&cvsroot=Twisted Index: Twisted/twisted/python/rebuild.py diff -u Twisted/twisted/python/rebuild.py:1.19 Twisted/twisted/python/rebuild.py:1.20 --- Twisted/twisted/python/rebuild.py:1.19 Fri Jan 17 13:50:49 2003 +++ Twisted/twisted/python/rebuild.py Thu Mar 20 11:50:08 2003 @@ -206,15 +206,27 @@ clazz.__dict__.clear() clazz.__getattr__ = __getattr__ clazz.__module__ = module.__name__ + if newclasses: + import gc + if (2, 2, 0) <= sys.version_info[:3] < (2, 2, 2): + hasBrokenRebuild = 1 + gc_objects = gc.get_objects() + else: + hasBrokenRebuild = 0 for nclass in newclasses: ga = getattr(module, nclass.__name__) if ga is nclass: log.msg("WARNING: new-class %s not replaced by reload!" % reflect.qual(nclass)) else: - import gc - for r in gc.get_referrers(nclass): - if isinstance(r, nclass): + if hasBrokenRebuild: + for r in gc_objects: + if not getattr(r, '__class__', None) is nclass: + continue r.__class__ = ga + else: + for r in gc.get_referrers(nclass): + if getattr(r, '__class__', None) is nclass: + r.__class__ = ga if doLog: log.msg('') log.msg(' (fixing %s): ' % str(module.__name__)) _______________________________________________ Twisted-commits mailing list Twisted-commits@twistedmatrix.com http://twistedmatrix.com/cgi-bin/mailman/listinfo/twisted-commits PK Mb�Z��� mail/test/test_options.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.mail.tap}. """ from twisted.internet import defer, endpoints from twisted.mail import protocols from twisted.mail.tap import Options, makeService from twisted.python.usage import UsageError from twisted.trial.unittest import TestCase class OptionsTests(TestCase): """ Tests for the command line option parser used for I{twistd mail}. """ def setUp(self): self.aliasFilename = self.mktemp() with open(self.aliasFilename, "w") as aliasFile: aliasFile.write("someuser:\tdifferentuser\n") def testAliasesWithoutDomain(self): """ Test that adding an aliases(5) file before adding a domain raises a UsageError. """ self.assertRaises( UsageError, Options().parseOptions, ["--aliases", self.aliasFilename] ) def testAliases(self): """ Test that adding an aliases(5) file to an IAliasableDomain at least doesn't raise an unhandled exception. """ Options().parseOptions( [ "--maildirdbmdomain", "example.com=example.com", "--aliases", self.aliasFilename, ] ) def _endpointTest(self, service): """ Use L{Options} to parse a single service configuration parameter and verify that an endpoint of the correct type is added to the list for that service. """ options = Options() options.parseOptions(["--" + service, "tcp:1234"]) self.assertEqual(len(options[service]), 1) self.assertIsInstance(options[service][0], endpoints.TCP4ServerEndpoint) def test_endpointSMTP(self): """ When I{--smtp} is given a TCP endpoint description as an argument, a TCPServerEndpoint is added to the list of SMTP endpoints. """ self._endpointTest("smtp") def test_endpointPOP3(self): """ When I{--pop3} is given a TCP endpoint description as an argument, a TCPServerEndpoint is added to the list of POP3 endpoints. """ self._endpointTest("pop3") def test_protoDefaults(self): """ POP3 and SMTP each listen on a TCP4ServerEndpoint by default. """ options = Options() options.parseOptions([]) self.assertEqual(len(options["pop3"]), 1) self.assertIsInstance(options["pop3"][0], endpoints.TCP4ServerEndpoint) self.assertEqual(len(options["smtp"]), 1) self.assertIsInstance(options["smtp"][0], endpoints.TCP4ServerEndpoint) def test_protoDisable(self): """ The I{--no-pop3} and I{--no-smtp} options disable POP3 and SMTP respectively. """ options = Options() options.parseOptions(["--no-pop3"]) self.assertEqual(options._getEndpoints(None, "pop3"), []) self.assertNotEqual(options._getEndpoints(None, "smtp"), []) options = Options() options.parseOptions(["--no-smtp"]) self.assertNotEqual(options._getEndpoints(None, "pop3"), []) self.assertEqual(options._getEndpoints(None, "smtp"), []) def test_allProtosDisabledError(self): """ If all protocols are disabled, L{UsageError} is raised. """ options = Options() self.assertRaises( UsageError, options.parseOptions, (["--no-pop3", "--no-smtp"]) ) def test_esmtpWithoutHostname(self): """ If I{--esmtp} is given without I{--hostname}, L{Options.parseOptions} raises L{UsageError}. """ options = Options() exc = self.assertRaises(UsageError, options.parseOptions, ["--esmtp"]) self.assertEqual("--esmtp requires --hostname", str(exc)) def test_auth(self): """ Tests that the --auth option registers a checker. """ options = Options() options.parseOptions(["--auth", "memory:admin:admin:bob:password"]) self.assertEqual(len(options["credCheckers"]), 1) checker = options["credCheckers"][0] interfaces = checker.credentialInterfaces registered_checkers = options.service.smtpPortal.checkers for iface in interfaces: self.assertEqual(checker, registered_checkers[iface]) class SpyEndpoint: """ SpyEndpoint remembers what factory it is told to listen with. """ listeningWith = None def listen(self, factory): self.listeningWith = factory return defer.succeed(None) class MakeServiceTests(TestCase): """ Tests for L{twisted.mail.tap.makeService} """ def _endpointServerTest(self, key, factoryClass): """ Configure a service with two endpoints for the protocol associated with C{key} and verify that when the service is started a factory of type C{factoryClass} is used to listen on each of them. """ cleartext = SpyEndpoint() secure = SpyEndpoint() config = Options() config[key] = [cleartext, secure] service = makeService(config) service.privilegedStartService() service.startService() self.addCleanup(service.stopService) self.assertIsInstance(cleartext.listeningWith, factoryClass) self.assertIsInstance(secure.listeningWith, factoryClass) def test_pop3(self): """ If one or more endpoints is included in the configuration passed to L{makeService} for the C{"pop3"} key, a service for starting a POP3 server is constructed for each of them and attached to the returned service. """ self._endpointServerTest("pop3", protocols.POP3Factory) def test_smtp(self): """ If one or more endpoints is included in the configuration passed to L{makeService} for the C{"smtp"} key, a service for starting an SMTP server is constructed for each of them and attached to the returned service. """ self._endpointServerTest("smtp", protocols.SMTPFactory) PK Mb�Z �ȓ \ \ mail/test/test_mail.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for large portions of L{twisted.mail}. """ import email.message import email.parser import errno import io import os import pickle import shutil import signal import sys import tempfile import textwrap import time from hashlib import md5 from unittest import skipIf from zope.interface import Interface, implementer from zope.interface.verify import verifyClass import twisted.cred.checkers import twisted.cred.credentials import twisted.cred.portal import twisted.mail.alias import twisted.mail.mail import twisted.mail.maildir import twisted.mail.protocols import twisted.mail.relay import twisted.mail.relaymanager from twisted import cred, mail from twisted.internet import address, defer, interfaces, protocol, reactor, task from twisted.internet.defer import Deferred from twisted.internet.error import ( CannotListenError, DNSLookupError, ProcessDone, ProcessTerminated, ) from twisted.mail import pop3, smtp from twisted.mail.relaymanager import _AttemptManager from twisted.names import dns from twisted.names.dns import Record_CNAME, Record_MX, RRHeader from twisted.names.error import DNSNameError from twisted.python import failure, log from twisted.python.filepath import FilePath from twisted.python.runtime import platformType from twisted.test.proto_helpers import ( LineSendingProtocol, MemoryReactorClock, StringTransport, ) from twisted.trial.unittest import TestCase @skipIf(platformType != "posix", "twisted.mail only works on posix") class DomainWithDefaultsTests(TestCase): @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testMethods(self): d = {x: x + 10 for x in range(10)} d = mail.mail.DomainWithDefaultDict(d, "Default") self.assertEqual(len(d), 10) self.assertEqual(list(iter(d)), list(range(10))) self.assertEqual(list(d.iterkeys()), list(iter(d))) items = list(d.iteritems()) items.sort() self.assertEqual(items, [(x, x + 10) for x in range(10)]) values = list(d.itervalues()) values.sort() self.assertEqual(values, list(range(10, 20))) items = d.items() items.sort() self.assertEqual(items, [(x, x + 10) for x in range(10)]) values = d.values() values.sort() self.assertEqual(values, list(range(10, 20))) for x in range(10): self.assertEqual(d[x], x + 10) self.assertEqual(d.get(x), x + 10) self.assertTrue(x in d) del d[2], d[4], d[6] self.assertEqual(len(d), 7) self.assertEqual(d[2], "Default") self.assertEqual(d[4], "Default") self.assertEqual(d[6], "Default") d.update({"a": None, "b": (), "c": "*"}) self.assertEqual(len(d), 10) self.assertEqual(d["a"], None) self.assertEqual(d["b"], ()) self.assertEqual(d["c"], "*") d.clear() self.assertEqual(len(d), 0) self.assertEqual(d.setdefault("key", "value"), "value") self.assertEqual(d["key"], "value") self.assertEqual(d.popitem(), ("key", "value")) self.assertEqual(len(d), 0) dcopy = d.copy() self.assertEqual(d.domains, dcopy.domains) self.assertEqual(d.default, dcopy.default) def _stringificationTest(self, stringifier): """ Assert that the class name of a L{mail.mail.DomainWithDefaultDict} instance and the string-formatted underlying domain dictionary both appear in the string produced by the given string-returning function. @type stringifier: one-argument callable @param stringifier: either C{str} or C{repr}, to be used to get a string to make assertions against. """ domain = mail.mail.DomainWithDefaultDict({}, "Default") self.assertIn(domain.__class__.__name__, stringifier(domain)) domain["key"] = "value" self.assertIn(str({"key": "value"}), stringifier(domain)) def test_str(self): """ L{DomainWithDefaultDict.__str__} should return a string including the class name and the domain mapping held by the instance. """ self._stringificationTest(str) def test_repr(self): """ L{DomainWithDefaultDict.__repr__} should return a string including the class name and the domain mapping held by the instance. """ self._stringificationTest(repr) def test_has_keyDeprecation(self): """ has_key is now deprecated. """ sut = mail.mail.DomainWithDefaultDict({}, "Default") sut.has_key("anything") message = ( "twisted.mail.mail.DomainWithDefaultDict.has_key was deprecated " "in Twisted 16.3.0. Use the `in` keyword instead." ) warnings = self.flushWarnings([self.test_has_keyDeprecation]) self.assertEqual(1, len(warnings)) self.assertEqual(DeprecationWarning, warnings[0]["category"]) self.assertEqual(message, warnings[0]["message"]) @skipIf(platformType != "posix", "twisted.mail only works on posix") class BounceTests(TestCase): def setUp(self): self.domain = mail.mail.BounceDomain() def testExists(self): self.assertRaises(smtp.AddressError, self.domain.exists, "any user") def testRelay(self): self.assertEqual(self.domain.willRelay("random q emailer", "protocol"), False) def testAddUser(self): self.domain.addUser("bob", "password") self.assertRaises(smtp.SMTPBadRcpt, self.domain.exists, "bob") @skipIf(platformType != "posix", "twisted.mail only works on posix") class BounceWithSMTPServerTests(TestCase): """ Tests for L{twisted.mail.mail.BounceDomain} with L{twisted.mail.smtp.SMTPServer}. """ def test_rejected(self): """ Incoming emails to a SMTP server with L{twisted.mail.mail.BounceDomain} are rejected. """ service = mail.mail.MailService() domain = mail.mail.BounceDomain() service.addDomain(b"foo.com", domain) factory = mail.protocols.SMTPFactory(service) protocol = factory.buildProtocol(None) deliverer = mail.protocols.SMTPDomainDelivery(service, None, None) protocol.delivery = deliverer transport = StringTransport() protocol.makeConnection(transport) protocol.lineReceived(b"HELO baz.net") protocol.lineReceived(b"MAIL FROM:<a@baz.net>") protocol.lineReceived(b"RCPT TO:<any@foo.com>") protocol.lineReceived(b"QUIT") self.assertTrue(transport.disconnecting) protocol.connectionLost(None) self.assertEqual( transport.value().strip().split(b"\r\n")[-2], b"550 Cannot receive for specified address", ) @skipIf(platformType != "posix", "twisted.mail only works on posix") class FileMessageTests(TestCase): def setUp(self): self.name = "fileMessage.testFile" self.final = "final.fileMessage.testFile" self.f = open(self.name, "w") self.fp = mail.mail.FileMessage(self.f, self.name, self.final) def tearDown(self): try: self.f.close() except BaseException: pass try: os.remove(self.name) except BaseException: pass try: os.remove(self.final) except BaseException: pass def testFinalName(self): return self.fp.eomReceived().addCallback(self._cbFinalName) def _cbFinalName(self, result): self.assertEqual(result, self.final) self.assertTrue(self.f.closed) self.assertFalse(os.path.exists(self.name)) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testContents(self): contents = "first line\nsecond line\nthird line\n" for line in contents.splitlines(): self.fp.lineReceived(line) self.fp.eomReceived() with open(self.final) as f: self.assertEqual(f.read(), contents) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testInterrupted(self): contents = "first line\nsecond line\n" for line in contents.splitlines(): self.fp.lineReceived(line) self.fp.connectionLost() self.assertFalse(os.path.exists(self.name)) self.assertFalse(os.path.exists(self.final)) @skipIf(platformType != "posix", "twisted.mail only works on posix") class MailServiceTests(TestCase): def setUp(self): self.service = mail.mail.MailService() def testFactories(self): f = self.service.getPOP3Factory() self.assertTrue(isinstance(f, protocol.ServerFactory)) self.assertTrue(f.buildProtocol(("127.0.0.1", 12345)), pop3.POP3) f = self.service.getSMTPFactory() self.assertTrue(isinstance(f, protocol.ServerFactory)) self.assertTrue(f.buildProtocol(("127.0.0.1", 12345)), smtp.SMTP) f = self.service.getESMTPFactory() self.assertTrue(isinstance(f, protocol.ServerFactory)) self.assertTrue(f.buildProtocol(("127.0.0.1", 12345)), smtp.ESMTP) def testPortals(self): o1 = object() o2 = object() self.service.portals["domain"] = o1 self.service.portals[""] = o2 self.assertTrue(self.service.lookupPortal("domain") is o1) self.assertTrue(self.service.defaultPortal() is o2) @skipIf(platformType != "posix", "twisted.mail only works on posix") class StringListMailboxTests(TestCase): """ Tests for L{StringListMailbox}, an in-memory only implementation of L{pop3.IMailbox}. """ def test_listOneMessage(self): """ L{StringListMailbox.listMessages} returns the length of the message at the offset into the mailbox passed to it. """ mailbox = mail.maildir.StringListMailbox(["abc", "ab", "a"]) self.assertEqual(mailbox.listMessages(0), 3) self.assertEqual(mailbox.listMessages(1), 2) self.assertEqual(mailbox.listMessages(2), 1) def test_listAllMessages(self): """ L{StringListMailbox.listMessages} returns a list of the lengths of all messages if not passed an index. """ mailbox = mail.maildir.StringListMailbox(["a", "abc", "ab"]) self.assertEqual(mailbox.listMessages(), [1, 3, 2]) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_getMessage(self): """ L{StringListMailbox.getMessage} returns a file-like object from which the contents of the message at the given offset into the mailbox can be read. """ mailbox = mail.maildir.StringListMailbox(["foo", "real contents"]) self.assertEqual(mailbox.getMessage(1).read(), "real contents") @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_getUidl(self): """ L{StringListMailbox.getUidl} returns a unique identifier for the message at the given offset into the mailbox. """ mailbox = mail.maildir.StringListMailbox(["foo", "bar"]) self.assertNotEqual(mailbox.getUidl(0), mailbox.getUidl(1)) def test_deleteMessage(self): """ L{StringListMailbox.deleteMessage} marks a message for deletion causing further requests for its length to return 0. """ mailbox = mail.maildir.StringListMailbox(["foo"]) mailbox.deleteMessage(0) self.assertEqual(mailbox.listMessages(0), 0) self.assertEqual(mailbox.listMessages(), [0]) def test_undeleteMessages(self): """ L{StringListMailbox.undeleteMessages} causes any messages marked for deletion to be returned to their original state. """ mailbox = mail.maildir.StringListMailbox(["foo"]) mailbox.deleteMessage(0) mailbox.undeleteMessages() self.assertEqual(mailbox.listMessages(0), 3) self.assertEqual(mailbox.listMessages(), [3]) def test_sync(self): """ L{StringListMailbox.sync} causes any messages as marked for deletion to be permanently deleted. """ mailbox = mail.maildir.StringListMailbox(["foo"]) mailbox.deleteMessage(0) mailbox.sync() mailbox.undeleteMessages() self.assertEqual(mailbox.listMessages(0), 0) self.assertEqual(mailbox.listMessages(), [0]) @skipIf(platformType != "posix", "twisted.mail only works on posix") class FailingMaildirMailboxAppendMessageTask( mail.maildir._MaildirMailboxAppendMessageTask ): _openstate = True _writestate = True _renamestate = True def osopen(self, fn, attr, mode): if self._openstate: return os.open(fn, attr, mode) else: raise OSError(errno.EPERM, "Faked Permission Problem") def oswrite(self, fh, data): if self._writestate: return os.write(fh, data) else: raise OSError(errno.ENOSPC, "Faked Space problem") def osrename(self, oldname, newname): if self._renamestate: return os.rename(oldname, newname) else: raise OSError(errno.EPERM, "Faked Permission Problem") class _AppendTestMixin: """ Mixin for L{MaildirMailbox.appendMessage} test cases which defines a helper for serially appending multiple messages to a mailbox. """ def _appendMessages(self, mbox, messages): """ Deliver the given messages one at a time. Delivery is serialized to guarantee a predictable order in the mailbox (overlapped message deliver makes no guarantees about which message which appear first). """ results = [] def append(): for m in messages: d = mbox.appendMessage(m) d.addCallback(results.append) yield d d = task.cooperate(append()).whenDone() d.addCallback(lambda ignored: results) return d @skipIf(platformType != "posix", "twisted.mail only works on posix") class MaildirAppendStringTests(TestCase, _AppendTestMixin): """ Tests for L{MaildirMailbox.appendMessage} when invoked with a C{str}. """ def setUp(self): self.d = self.mktemp() mail.maildir.initializeMaildir(self.d) def _append(self, ignored, mbox): d = mbox.appendMessage("TEST") return self.assertFailure(d, Exception) def _setState(self, ignored, mbox, rename=None, write=None, open=None): """ Change the behavior of future C{rename}, C{write}, or C{open} calls made by the mailbox C{mbox}. @param rename: If not L{None}, a new value for the C{_renamestate} attribute of the mailbox's append factory. The original value will be restored at the end of the test. @param write: Like C{rename}, but for the C{_writestate} attribute. @param open: Like C{rename}, but for the C{_openstate} attribute. """ if rename is not None: self.addCleanup( setattr, mbox.AppendFactory, "_renamestate", mbox.AppendFactory._renamestate, ) mbox.AppendFactory._renamestate = rename if write is not None: self.addCleanup( setattr, mbox.AppendFactory, "_writestate", mbox.AppendFactory._writestate, ) mbox.AppendFactory._writestate = write if open is not None: self.addCleanup( setattr, mbox.AppendFactory, "_openstate", mbox.AppendFactory._openstate ) mbox.AppendFactory._openstate = open @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_append(self): """ L{MaildirMailbox.appendMessage} returns a L{Deferred} which fires when the message has been added to the end of the mailbox. """ mbox = mail.maildir.MaildirMailbox(self.d) mbox.AppendFactory = FailingMaildirMailboxAppendMessageTask d = self._appendMessages(mbox, ["X" * i for i in range(1, 11)]) d.addCallback(self.assertEqual, [None] * 10) d.addCallback(self._cbTestAppend, mbox) return d def _cbTestAppend(self, ignored, mbox): """ Check that the mailbox has the expected number (ten) of messages in it, and that each has the expected contents, and that they are in the same order as that in which they were appended. """ self.assertEqual(len(mbox.listMessages()), 10) self.assertEqual( [len(mbox.getMessage(i).read()) for i in range(10)], list(range(1, 11)) ) # test in the right order: last to first error location. self._setState(None, mbox, rename=False) d = self._append(None, mbox) d.addCallback(self._setState, mbox, rename=True, write=False) d.addCallback(self._append, mbox) d.addCallback(self._setState, mbox, write=True, open=False) d.addCallback(self._append, mbox) d.addCallback(self._setState, mbox, open=True) return d @skipIf(platformType != "posix", "twisted.mail only works on posix") class MaildirAppendFileTests(TestCase, _AppendTestMixin): """ Tests for L{MaildirMailbox.appendMessage} when invoked with a C{str}. """ def setUp(self): self.d = self.mktemp() mail.maildir.initializeMaildir(self.d) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_append(self): """ L{MaildirMailbox.appendMessage} returns a L{Deferred} which fires when the message has been added to the end of the mailbox. """ mbox = mail.maildir.MaildirMailbox(self.d) messages = [] for i in range(1, 11): temp = tempfile.TemporaryFile() temp.write("X" * i) temp.seek(0, 0) messages.append(temp) self.addCleanup(temp.close) d = self._appendMessages(mbox, messages) d.addCallback(self._cbTestAppend, mbox) return d def _cbTestAppend(self, result, mbox): """ Check that the mailbox has the expected number (ten) of messages in it, and that each has the expected contents, and that they are in the same order as that in which they were appended. """ self.assertEqual(len(mbox.listMessages()), 10) self.assertEqual( [len(mbox.getMessage(i).read()) for i in range(10)], list(range(1, 11)) ) @skipIf(platformType != "posix", "twisted.mail only works on posix") class MaildirTests(TestCase): def setUp(self): self.d = self.mktemp() mail.maildir.initializeMaildir(self.d) def tearDown(self): shutil.rmtree(self.d) def testInitializer(self): d = self.d trash = os.path.join(d, ".Trash") self.assertTrue(os.path.exists(d) and os.path.isdir(d)) self.assertTrue(os.path.exists(os.path.join(d, "new"))) self.assertTrue(os.path.exists(os.path.join(d, "cur"))) self.assertTrue(os.path.exists(os.path.join(d, "tmp"))) self.assertTrue(os.path.isdir(os.path.join(d, "new"))) self.assertTrue(os.path.isdir(os.path.join(d, "cur"))) self.assertTrue(os.path.isdir(os.path.join(d, "tmp"))) self.assertTrue(os.path.exists(os.path.join(trash, "new"))) self.assertTrue(os.path.exists(os.path.join(trash, "cur"))) self.assertTrue(os.path.exists(os.path.join(trash, "tmp"))) self.assertTrue(os.path.isdir(os.path.join(trash, "new"))) self.assertTrue(os.path.isdir(os.path.join(trash, "cur"))) self.assertTrue(os.path.isdir(os.path.join(trash, "tmp"))) def test_nameGenerator(self): """ Each call to L{_MaildirNameGenerator.generate} returns a unique string suitable for use as the basename of a new message file. The names are ordered such that those generated earlier sort less than those generated later. """ clock = task.Clock() clock.advance(0.05) generator = mail.maildir._MaildirNameGenerator(clock) firstName = generator.generate() clock.advance(0.05) secondName = generator.generate() self.assertTrue(firstName < secondName) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_mailbox(self): """ Exercise the methods of L{IMailbox} as implemented by L{MaildirMailbox}. """ j = os.path.join n = mail.maildir._generateMaildirName msgs = [j(b, n()) for b in ("cur", "new") for x in range(5)] # Toss a few files into the mailbox i = 1 for f in msgs: with open(j(self.d, f), "w") as fObj: fObj.write("x" * i) i = i + 1 mb = mail.maildir.MaildirMailbox(self.d) self.assertEqual(mb.listMessages(), list(range(1, 11))) self.assertEqual(mb.listMessages(1), 2) self.assertEqual(mb.listMessages(5), 6) self.assertEqual(mb.getMessage(6).read(), "x" * 7) self.assertEqual(mb.getMessage(1).read(), "x" * 2) d = {} for i in range(10): u = mb.getUidl(i) self.assertFalse(u in d) d[u] = None p, f = os.path.split(msgs[5]) mb.deleteMessage(5) self.assertEqual(mb.listMessages(5), 0) self.assertTrue(os.path.exists(j(self.d, ".Trash", "cur", f))) self.assertFalse(os.path.exists(j(self.d, msgs[5]))) mb.undeleteMessages() self.assertEqual(mb.listMessages(5), 6) self.assertFalse(os.path.exists(j(self.d, ".Trash", "cur", f))) self.assertTrue(os.path.exists(j(self.d, msgs[5]))) @skipIf(platformType != "posix", "twisted.mail only works on posix") class AbstractMaildirDomainTests(TestCase): """ Tests for L{twisted.mail.maildir.AbstractMaildirDomain}. """ def test_interface(self): """ L{maildir.AbstractMaildirDomain} implements L{mail.IAliasableDomain}. """ verifyClass(mail.mail.IAliasableDomain, mail.maildir.AbstractMaildirDomain) @skipIf(platformType != "posix", "twisted.mail only works on posix") class MaildirDirdbmDomainTests(TestCase): """ Tests for L{MaildirDirdbmDomain}. """ def setUp(self): """ Create a temporary L{MaildirDirdbmDomain} and parent L{MailService} before running each test. """ self.P = self.mktemp() self.S = mail.mail.MailService() self.D = mail.maildir.MaildirDirdbmDomain(self.S, self.P) def tearDown(self): """ Remove the temporary C{maildir} directory when the test has finished. """ shutil.rmtree(self.P) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_addUser(self): """ L{MaildirDirdbmDomain.addUser} accepts a user and password argument. It stores those in a C{dbm} dictionary attribute and creates a directory for each user. """ toAdd = (("user1", "pwd1"), ("user2", "pwd2"), ("user3", "pwd3")) for (u, p) in toAdd: self.D.addUser(u, p) for (u, p) in toAdd: self.assertTrue(u in self.D.dbm) self.assertEqual(self.D.dbm[u], p) self.assertTrue(os.path.exists(os.path.join(self.P, u))) def test_credentials(self): """ L{MaildirDirdbmDomain.getCredentialsCheckers} initializes and returns one L{ICredentialsChecker} checker by default. """ creds = self.D.getCredentialsCheckers() self.assertEqual(len(creds), 1) self.assertTrue(cred.checkers.ICredentialsChecker.providedBy(creds[0])) self.assertTrue( cred.credentials.IUsernamePassword in creds[0].credentialInterfaces ) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_requestAvatar(self): """ L{MaildirDirdbmDomain.requestAvatar} raises L{NotImplementedError} unless it is supplied with an L{pop3.IMailbox} interface. When called with an L{pop3.IMailbox}, it returns a 3-tuple containing L{pop3.IMailbox}, an implementation of that interface and a NOOP callable. """ class ISomething(Interface): pass self.D.addUser("user", "password") self.assertRaises( NotImplementedError, self.D.requestAvatar, "user", None, ISomething ) t = self.D.requestAvatar("user", None, pop3.IMailbox) self.assertEqual(len(t), 3) self.assertTrue(t[0] is pop3.IMailbox) self.assertTrue(pop3.IMailbox.providedBy(t[1])) t[2]() @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_requestAvatarId(self): """ L{DirdbmDatabase.requestAvatarId} raises L{UnauthorizedLogin} if supplied with invalid user credentials. When called with valid credentials, L{requestAvatarId} returns the username associated with the supplied credentials. """ self.D.addUser("user", "password") database = self.D.getCredentialsCheckers()[0] creds = cred.credentials.UsernamePassword("user", "wrong password") self.assertRaises(cred.error.UnauthorizedLogin, database.requestAvatarId, creds) creds = cred.credentials.UsernamePassword("user", "password") self.assertEqual(database.requestAvatarId(creds), "user") @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_userDirectory(self): """ L{MaildirDirdbmDomain.userDirectory} is supplied with a user name and returns the path to that user's maildir subdirectory. Calling L{MaildirDirdbmDomain.userDirectory} with a non-existent user returns the 'postmaster' directory if there is a postmaster or returns L{None} if there is no postmaster. """ self.D.addUser("user", "password") self.assertEqual( self.D.userDirectory("user"), os.path.join(self.D.root, "user") ) self.D.postmaster = False self.assertIdentical(self.D.userDirectory("nouser"), None) self.D.postmaster = True self.assertEqual( self.D.userDirectory("nouser"), os.path.join(self.D.root, "postmaster") ) @implementer(mail.mail.IAliasableDomain) class StubAliasableDomain: """ Minimal testable implementation of IAliasableDomain. """ def exists(self, user, memo=None): """ No test coverage for invocations of this method on domain objects, so we just won't implement it. """ raise NotImplementedError() def addUser(self, user, password): """ No test coverage for invocations of this method on domain objects, so we just won't implement it. """ raise NotImplementedError() def getCredentialsCheckers(self): """ This needs to succeed in order for other tests to complete successfully, but we don't actually assert anything about its behavior. Return an empty list. Sometime later we should return something else and assert that a portal got set up properly. """ return [] def setAliasGroup(self, aliases): """ Just record the value so the test can check it later. """ self.aliasGroup = aliases @skipIf(platformType != "posix", "twisted.mail only works on posix") class ServiceDomainTests(TestCase): def setUp(self): self.S = mail.mail.MailService() self.D = mail.protocols.DomainDeliveryBase(self.S, None) self.D.service = self.S self.D.protocolName = "TEST" self.D.host = "hostname" self.tmpdir = self.mktemp() domain = mail.maildir.MaildirDirdbmDomain(self.S, self.tmpdir) domain.addUser(b"user", b"password") self.S.addDomain("test.domain", domain) def tearDown(self): shutil.rmtree(self.tmpdir) def testAddAliasableDomain(self): """ Test that adding an IAliasableDomain to a mail service properly sets up alias group references and such. """ aliases = object() domain = StubAliasableDomain() self.S.aliases = aliases self.S.addDomain("example.com", domain) self.assertIdentical(domain.aliasGroup, aliases) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testReceivedHeader(self): hdr = self.D.receivedHeader( ("remotehost", "123.232.101.234"), smtp.Address("<someguy@someplace>"), ["user@host.name"], ) fp = io.BytesIO(hdr) emailParser = email.parser.Parser() m = emailParser.parse(fp) self.assertEqual(len(m.items()), 1) self.assertIn("Received", m) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testValidateTo(self): user = smtp.User("user@test.domain", "helo", None, "wherever@whatever") return defer.maybeDeferred(self.D.validateTo, user).addCallback( self._cbValidateTo ) def _cbValidateTo(self, result): self.assertTrue(callable(result)) def testValidateToBadUsername(self): user = smtp.User("resu@test.domain", "helo", None, "wherever@whatever") return self.assertFailure( defer.maybeDeferred(self.D.validateTo, user), smtp.SMTPBadRcpt ) def testValidateToBadDomain(self): user = smtp.User("user@domain.test", "helo", None, "wherever@whatever") return self.assertFailure( defer.maybeDeferred(self.D.validateTo, user), smtp.SMTPBadRcpt ) def testValidateFrom(self): helo = ("hostname", "127.0.0.1") origin = smtp.Address("<user@hostname>") self.assertTrue(self.D.validateFrom(helo, origin) is origin) helo = ("hostname", "1.2.3.4") origin = smtp.Address("<user@hostname>") self.assertTrue(self.D.validateFrom(helo, origin) is origin) helo = ("hostname", "1.2.3.4") origin = smtp.Address("<>") self.assertTrue(self.D.validateFrom(helo, origin) is origin) self.assertRaises(smtp.SMTPBadSender, self.D.validateFrom, None, origin) @skipIf(platformType != "posix", "twisted.mail only works on posix") class VirtualPOP3Tests(TestCase): def setUp(self): self.tmpdir = self.mktemp() self.S = mail.mail.MailService() self.D = mail.maildir.MaildirDirdbmDomain(self.S, self.tmpdir) self.D.addUser(b"user", b"password") self.S.addDomain("test.domain", self.D) portal = cred.portal.Portal(self.D) map(portal.registerChecker, self.D.getCredentialsCheckers()) self.S.portals[""] = self.S.portals["test.domain"] = portal self.P = mail.protocols.VirtualPOP3() self.P.service = self.S self.P.magic = "<unit test magic>" def tearDown(self): shutil.rmtree(self.tmpdir) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testAuthenticateAPOP(self): resp = md5(self.P.magic + "password").hexdigest() return self.P.authenticateUserAPOP("user", resp).addCallback( self._cbAuthenticateAPOP ) def _cbAuthenticateAPOP(self, result): self.assertEqual(len(result), 3) self.assertEqual(result[0], pop3.IMailbox) self.assertTrue(pop3.IMailbox.providedBy(result[1])) result[2]() @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testAuthenticateIncorrectUserAPOP(self): resp = md5(self.P.magic + "password").hexdigest() return self.assertFailure( self.P.authenticateUserAPOP("resu", resp), cred.error.UnauthorizedLogin ) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testAuthenticateIncorrectResponseAPOP(self): resp = md5("wrong digest").hexdigest() return self.assertFailure( self.P.authenticateUserAPOP("user", resp), cred.error.UnauthorizedLogin ) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testAuthenticatePASS(self): return self.P.authenticateUserPASS("user", "password").addCallback( self._cbAuthenticatePASS ) def _cbAuthenticatePASS(self, result): self.assertEqual(len(result), 3) self.assertEqual(result[0], pop3.IMailbox) self.assertTrue(pop3.IMailbox.providedBy(result[1])) result[2]() @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testAuthenticateBadUserPASS(self): return self.assertFailure( self.P.authenticateUserPASS("resu", "password"), cred.error.UnauthorizedLogin, ) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testAuthenticateBadPasswordPASS(self): return self.assertFailure( self.P.authenticateUserPASS("user", "wrong password"), cred.error.UnauthorizedLogin, ) class empty(smtp.User): def __init__(self): pass @skipIf(platformType != "posix", "twisted.mail only works on posix") class RelayTests(TestCase): @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testExists(self): service = mail.mail.MailService() domain = mail.relay.DomainQueuer(service) doRelay = [ address.UNIXAddress("/var/run/mail-relay"), address.IPv4Address("TCP", "127.0.0.1", 12345), ] dontRelay = [ address.IPv4Address("TCP", "192.168.2.1", 62), address.IPv4Address("TCP", "1.2.3.4", 1943), ] for peer in doRelay: user = empty() user.orig = "user@host" user.dest = "tsoh@resu" user.protocol = empty() user.protocol.transport = empty() user.protocol.transport.getPeer = lambda: peer self.assertTrue(callable(domain.exists(user))) for peer in dontRelay: user = empty() user.orig = "some@place" user.protocol = empty() user.protocol.transport = empty() user.protocol.transport.getPeer = lambda: peer user.dest = "who@cares" self.assertRaises(smtp.SMTPBadRcpt, domain.exists, user) @skipIf(platformType != "posix", "twisted.mail only works on posix") class RelayerTests(TestCase): def setUp(self): self.tmpdir = self.mktemp() os.mkdir(self.tmpdir) self.messageFiles = [] for i in range(10): name = os.path.join(self.tmpdir, "body-%d" % (i,)) with open(name + "-H", "wb") as f: pickle.dump(["from-%d" % (i,), "to-%d" % (i,)], f) f = open(name + "-D", "w") f.write(name) f.seek(0, 0) self.messageFiles.append(name) self.R = mail.relay.RelayerMixin() self.R.loadMessages(self.messageFiles) def tearDown(self): shutil.rmtree(self.tmpdir) def testMailFrom(self): for i in range(10): self.assertEqual(self.R.getMailFrom(), "from-%d" % (i,)) self.R.sentMail(250, None, None, None, None) self.assertEqual(self.R.getMailFrom(), None) def testMailTo(self): for i in range(10): self.assertEqual(self.R.getMailTo(), ["to-%d" % (i,)]) self.R.sentMail(250, None, None, None, None) self.assertEqual(self.R.getMailTo(), None) def testMailData(self): for i in range(10): name = os.path.join(self.tmpdir, "body-%d" % (i,)) self.assertEqual(self.R.getMailData().read(), name) self.R.sentMail(250, None, None, None, None) self.assertEqual(self.R.getMailData(), None) class Manager: def __init__(self): self.success = [] self.failure = [] self.done = [] def notifySuccess(self, factory, message): self.success.append((factory, message)) def notifyFailure(self, factory, message): self.failure.append((factory, message)) def notifyDone(self, factory): self.done.append(factory) @skipIf(platformType != "posix", "twisted.mail only works on posix") class ManagedRelayerTests(TestCase): def setUp(self): self.manager = Manager() self.messages = list(range(0, 20, 2)) self.factory = object() self.relay = mail.relaymanager.ManagedRelayerMixin(self.manager) self.relay.messages = self.messages[:] self.relay.names = self.messages[:] self.relay.factory = self.factory def testSuccessfulSentMail(self): for i in self.messages: self.relay.sentMail(250, None, None, None, None) self.assertEqual( self.manager.success, [(self.factory, m) for m in self.messages] ) def testFailedSentMail(self): for i in self.messages: self.relay.sentMail(550, None, None, None, None) self.assertEqual( self.manager.failure, [(self.factory, m) for m in self.messages] ) def testConnectionLost(self): self.relay.connectionLost(failure.Failure(Exception())) self.assertEqual(self.manager.done, [self.factory]) @skipIf(platformType != "posix", "twisted.mail only works on posix") class DirectoryQueueTests(TestCase): def setUp(self): # This is almost a test case itself. self.tmpdir = self.mktemp() os.mkdir(self.tmpdir) self.queue = mail.relaymanager.Queue(self.tmpdir) self.queue.noisy = False for m in range(25): hdrF, msgF = self.queue.createNewMessage() with hdrF: pickle.dump(["header", m], hdrF) msgF.lineReceived(b"body: %d" % (m,)) msgF.eomReceived() self.queue.readDirectory() def tearDown(self): shutil.rmtree(self.tmpdir) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testWaiting(self): self.assertTrue(self.queue.hasWaiting()) self.assertEqual(len(self.queue.getWaiting()), 25) waiting = self.queue.getWaiting() self.queue.setRelaying(waiting[0]) self.assertEqual(len(self.queue.getWaiting()), 24) self.queue.setWaiting(waiting[0]) self.assertEqual(len(self.queue.getWaiting()), 25) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testRelaying(self): for m in self.queue.getWaiting(): self.queue.setRelaying(m) self.assertEqual( len(self.queue.getRelayed()), 25 - len(self.queue.getWaiting()) ) self.assertFalse(self.queue.hasWaiting()) relayed = self.queue.getRelayed() self.queue.setWaiting(relayed[0]) self.assertEqual(len(self.queue.getWaiting()), 1) self.assertEqual(len(self.queue.getRelayed()), 24) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testDone(self): msg = self.queue.getWaiting()[0] self.queue.setRelaying(msg) self.queue.done(msg) self.assertEqual(len(self.queue.getWaiting()), 24) self.assertEqual(len(self.queue.getRelayed()), 0) self.assertFalse(msg in self.queue.getWaiting()) self.assertFalse(msg in self.queue.getRelayed()) def testEnvelope(self): envelopes = [] for msg in self.queue.getWaiting(): envelopes.append(self.queue.getEnvelope(msg)) envelopes.sort() for i in range(25): self.assertEqual(envelopes.pop(0), ["header", i]) from twisted.names import client, common, server class TestAuthority(common.ResolverBase): def __init__(self): common.ResolverBase.__init__(self) self.addresses = {} def _lookup(self, name, cls, type, timeout=None): if name in self.addresses and type == dns.MX: results = [] for a in self.addresses[name]: hdr = dns.RRHeader(name, dns.MX, dns.IN, 60, dns.Record_MX(0, a)) results.append(hdr) return defer.succeed((results, [], [])) return defer.fail(failure.Failure(dns.DomainError(name))) def setUpDNS(self): self.auth = TestAuthority() factory = server.DNSServerFactory([self.auth]) protocol = dns.DNSDatagramProtocol(factory) while 1: self.port = reactor.listenTCP(0, factory, interface="127.0.0.1") portNumber = self.port.getHost().port try: self.udpPort = reactor.listenUDP( portNumber, protocol, interface="127.0.0.1" ) except CannotListenError: self.port.stopListening() else: break self.resolver = client.Resolver(servers=[("127.0.0.1", portNumber)]) def tearDownDNS(self): dl = [] dl.append(defer.maybeDeferred(self.port.stopListening)) dl.append(defer.maybeDeferred(self.udpPort.stopListening)) try: self.resolver._parseCall.cancel() except BaseException: pass return defer.DeferredList(dl) @skipIf(platformType != "posix", "twisted.mail only works on posix") class MXTests(TestCase): """ Tests for L{mail.relaymanager.MXCalculator}. """ def setUp(self): setUpDNS(self) self.clock = task.Clock() self.mx = mail.relaymanager.MXCalculator(self.resolver, self.clock) def tearDown(self): return tearDownDNS(self) def test_defaultClock(self): """ L{MXCalculator}'s default clock is C{twisted.internet.reactor}. """ self.assertIdentical( mail.relaymanager.MXCalculator(self.resolver).clock, reactor ) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testSimpleSuccess(self): self.auth.addresses["test.domain"] = ["the.email.test.domain"] return self.mx.getMX("test.domain").addCallback(self._cbSimpleSuccess) def _cbSimpleSuccess(self, mx): self.assertEqual(mx.preference, 0) self.assertEqual(str(mx.name), "the.email.test.domain") def testSimpleFailure(self): self.mx.fallbackToDomain = False return self.assertFailure(self.mx.getMX("test.domain"), IOError) def testSimpleFailureWithFallback(self): return self.assertFailure(self.mx.getMX("test.domain"), DNSLookupError) def _exchangeTest(self, domain, records, correctMailExchange): """ Issue an MX request for the given domain and arrange for it to be responded to with the given records. Verify that the resulting mail exchange is the indicated host. @type domain: C{str} @type records: C{list} of L{RRHeader} @type correctMailExchange: C{str} @rtype: L{Deferred} """ class DummyResolver: def lookupMailExchange(self, name): if name == domain: return defer.succeed((records, [], [])) return defer.fail(DNSNameError(domain)) self.mx.resolver = DummyResolver() d = self.mx.getMX(domain) def gotMailExchange(record): self.assertEqual(str(record.name), correctMailExchange) d.addCallback(gotMailExchange) return d def test_mailExchangePreference(self): """ The MX record with the lowest preference is returned by L{MXCalculator.getMX}. """ domain = "example.com" good = "good.example.com" bad = "bad.example.com" records = [ RRHeader(name=domain, type=Record_MX.TYPE, payload=Record_MX(1, bad)), RRHeader(name=domain, type=Record_MX.TYPE, payload=Record_MX(0, good)), RRHeader(name=domain, type=Record_MX.TYPE, payload=Record_MX(2, bad)), ] return self._exchangeTest(domain, records, good) def test_badExchangeExcluded(self): """ L{MXCalculator.getMX} returns the MX record with the lowest preference which is not also marked as bad. """ domain = "example.com" good = "good.example.com" bad = "bad.example.com" records = [ RRHeader(name=domain, type=Record_MX.TYPE, payload=Record_MX(0, bad)), RRHeader(name=domain, type=Record_MX.TYPE, payload=Record_MX(1, good)), ] self.mx.markBad(bad) return self._exchangeTest(domain, records, good) def test_fallbackForAllBadExchanges(self): """ L{MXCalculator.getMX} returns the MX record with the lowest preference if all the MX records in the response have been marked bad. """ domain = "example.com" bad = "bad.example.com" worse = "worse.example.com" records = [ RRHeader(name=domain, type=Record_MX.TYPE, payload=Record_MX(0, bad)), RRHeader(name=domain, type=Record_MX.TYPE, payload=Record_MX(1, worse)), ] self.mx.markBad(bad) self.mx.markBad(worse) return self._exchangeTest(domain, records, bad) def test_badExchangeExpires(self): """ L{MXCalculator.getMX} returns the MX record with the lowest preference if it was last marked bad longer than L{MXCalculator.timeOutBadMX} seconds ago. """ domain = "example.com" good = "good.example.com" previouslyBad = "bad.example.com" records = [ RRHeader( name=domain, type=Record_MX.TYPE, payload=Record_MX(0, previouslyBad) ), RRHeader(name=domain, type=Record_MX.TYPE, payload=Record_MX(1, good)), ] self.mx.markBad(previouslyBad) self.clock.advance(self.mx.timeOutBadMX) return self._exchangeTest(domain, records, previouslyBad) def test_goodExchangeUsed(self): """ L{MXCalculator.getMX} returns the MX record with the lowest preference if it was marked good after it was marked bad. """ domain = "example.com" good = "good.example.com" previouslyBad = "bad.example.com" records = [ RRHeader( name=domain, type=Record_MX.TYPE, payload=Record_MX(0, previouslyBad) ), RRHeader(name=domain, type=Record_MX.TYPE, payload=Record_MX(1, good)), ] self.mx.markBad(previouslyBad) self.mx.markGood(previouslyBad) self.clock.advance(self.mx.timeOutBadMX) return self._exchangeTest(domain, records, previouslyBad) def test_successWithoutResults(self): """ If an MX lookup succeeds but the result set is empty, L{MXCalculator.getMX} should try to look up an I{A} record for the requested name and call back its returned Deferred with that address. """ ip = "1.2.3.4" domain = "example.org" class DummyResolver: """ Fake resolver which will respond to an MX lookup with an empty result set. @ivar mx: A dictionary mapping hostnames to three-tuples of results to be returned from I{MX} lookups. @ivar a: A dictionary mapping hostnames to addresses to be returned from I{A} lookups. """ mx = {domain: ([], [], [])} a = {domain: ip} def lookupMailExchange(self, domain): return defer.succeed(self.mx[domain]) def getHostByName(self, domain): return defer.succeed(self.a[domain]) self.mx.resolver = DummyResolver() d = self.mx.getMX(domain) d.addCallback(self.assertEqual, Record_MX(name=ip)) return d def test_failureWithSuccessfulFallback(self): """ Test that if the MX record lookup fails, fallback is enabled, and an A record is available for the name, then the Deferred returned by L{MXCalculator.getMX} ultimately fires with a Record_MX instance which gives the address in the A record for the name. """ class DummyResolver: """ Fake resolver which will fail an MX lookup but then succeed a getHostByName call. """ def lookupMailExchange(self, domain): return defer.fail(DNSNameError()) def getHostByName(self, domain): return defer.succeed("1.2.3.4") self.mx.resolver = DummyResolver() d = self.mx.getMX("domain") d.addCallback(self.assertEqual, Record_MX(name="1.2.3.4")) return d def test_cnameWithoutGlueRecords(self): """ If an MX lookup returns a single CNAME record as a result, MXCalculator will perform an MX lookup for the canonical name indicated and return the MX record which results. """ alias = "alias.example.com" canonical = "canonical.example.com" exchange = "mail.example.com" class DummyResolver: """ Fake resolver which will return a CNAME for an MX lookup of a name which is an alias and an MX for an MX lookup of the canonical name. """ def lookupMailExchange(self, domain): if domain == alias: return defer.succeed( ( [ RRHeader( name=domain, type=Record_CNAME.TYPE, payload=Record_CNAME(canonical), ) ], [], [], ) ) elif domain == canonical: return defer.succeed( ( [ RRHeader( name=domain, type=Record_MX.TYPE, payload=Record_MX(0, exchange), ) ], [], [], ) ) else: return defer.fail(DNSNameError(domain)) self.mx.resolver = DummyResolver() d = self.mx.getMX(alias) d.addCallback(self.assertEqual, Record_MX(name=exchange)) return d def test_cnameChain(self): """ If L{MXCalculator.getMX} encounters a CNAME chain which is longer than the length specified, the returned L{Deferred} should errback with L{CanonicalNameChainTooLong}. """ class DummyResolver: """ Fake resolver which generates a CNAME chain of infinite length in response to MX lookups. """ chainCounter = 0 def lookupMailExchange(self, domain): self.chainCounter += 1 name = "x-%d.example.com" % (self.chainCounter,) return defer.succeed( ( [ RRHeader( name=domain, type=Record_CNAME.TYPE, payload=Record_CNAME(name), ) ], [], [], ) ) cnameLimit = 3 self.mx.resolver = DummyResolver() d = self.mx.getMX("mail.example.com", cnameLimit) self.assertFailure(d, twisted.mail.relaymanager.CanonicalNameChainTooLong) def cbChainTooLong(error): self.assertEqual( error.args[0], Record_CNAME("x-%d.example.com" % (cnameLimit + 1,)) ) self.assertEqual(self.mx.resolver.chainCounter, cnameLimit + 1) d.addCallback(cbChainTooLong) return d def test_cnameWithGlueRecords(self): """ If an MX lookup returns a CNAME and the MX record for the CNAME, the L{Deferred} returned by L{MXCalculator.getMX} should be called back with the name from the MX record without further lookups being attempted. """ lookedUp = [] alias = "alias.example.com" canonical = "canonical.example.com" exchange = "mail.example.com" class DummyResolver: def lookupMailExchange(self, domain): if domain != alias or lookedUp: # Don't give back any results for anything except the alias # or on any request after the first. return ([], [], []) return defer.succeed( ( [ RRHeader( name=alias, type=Record_CNAME.TYPE, payload=Record_CNAME(canonical), ), RRHeader( name=canonical, type=Record_MX.TYPE, payload=Record_MX(name=exchange), ), ], [], [], ) ) self.mx.resolver = DummyResolver() d = self.mx.getMX(alias) d.addCallback(self.assertEqual, Record_MX(name=exchange)) return d def test_cnameLoopWithGlueRecords(self): """ If an MX lookup returns two CNAME records which point to each other, the loop should be detected and the L{Deferred} returned by L{MXCalculator.getMX} should be errbacked with L{CanonicalNameLoop}. """ firstAlias = "cname1.example.com" secondAlias = "cname2.example.com" class DummyResolver: def lookupMailExchange(self, domain): return defer.succeed( ( [ RRHeader( name=firstAlias, type=Record_CNAME.TYPE, payload=Record_CNAME(secondAlias), ), RRHeader( name=secondAlias, type=Record_CNAME.TYPE, payload=Record_CNAME(firstAlias), ), ], [], [], ) ) self.mx.resolver = DummyResolver() d = self.mx.getMX(firstAlias) self.assertFailure(d, twisted.mail.relaymanager.CanonicalNameLoop) return d @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testManyRecords(self): self.auth.addresses["test.domain"] = [ "mx1.test.domain", "mx2.test.domain", "mx3.test.domain", ] return self.mx.getMX("test.domain").addCallback( self._cbManyRecordsSuccessfulLookup ) def _cbManyRecordsSuccessfulLookup(self, mx): self.assertTrue(str(mx.name).split(".", 1)[0] in ("mx1", "mx2", "mx3")) self.mx.markBad(str(mx.name)) return self.mx.getMX("test.domain").addCallback( self._cbManyRecordsDifferentResult, mx ) def _cbManyRecordsDifferentResult(self, nextMX, mx): self.assertNotEqual(str(mx.name), str(nextMX.name)) self.mx.markBad(str(nextMX.name)) return self.mx.getMX("test.domain").addCallback( self._cbManyRecordsLastResult, mx, nextMX ) def _cbManyRecordsLastResult(self, lastMX, mx, nextMX): self.assertNotEqual(str(mx.name), str(lastMX.name)) self.assertNotEqual(str(nextMX.name), str(lastMX.name)) self.mx.markBad(str(lastMX.name)) self.mx.markGood(str(nextMX.name)) return self.mx.getMX("test.domain").addCallback( self._cbManyRecordsRepeatSpecificResult, nextMX ) def _cbManyRecordsRepeatSpecificResult(self, againMX, nextMX): self.assertEqual(str(againMX.name), str(nextMX.name)) @skipIf(platformType != "posix", "twisted.mail only works on posix") class LiveFireExerciseTests(TestCase): if interfaces.IReactorUDP(reactor, None) is None: skip = "UDP support is required to determining MX records" def setUp(self): setUpDNS(self) self.tmpdirs = [ "domainDir", "insertionDomain", "insertionQueue", "destinationDomain", "destinationQueue", ] def tearDown(self): for d in self.tmpdirs: if os.path.exists(d): shutil.rmtree(d) return tearDownDNS(self) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testLocalDelivery(self): service = mail.mail.MailService() service.smtpPortal.registerChecker(cred.checkers.AllowAnonymousAccess()) domain = mail.maildir.MaildirDirdbmDomain(service, "domainDir") domain.addUser("user", "password") service.addDomain("test.domain", domain) service.portals[""] = service.portals["test.domain"] map(service.portals[""].registerChecker, domain.getCredentialsCheckers()) service.setQueue(mail.relay.DomainQueuer(service)) f = service.getSMTPFactory() self.smtpServer = reactor.listenTCP(0, f, interface="127.0.0.1") client = LineSendingProtocol( [ "HELO meson", "MAIL FROM: <user@hostname>", "RCPT TO: <user@test.domain>", "DATA", "This is the message", ".", "QUIT", ] ) done = Deferred() f = protocol.ClientFactory() f.protocol = lambda: client f.clientConnectionLost = lambda *args: done.callback(None) reactor.connectTCP("127.0.0.1", self.smtpServer.getHost().port, f) def finished(ign): mbox = domain.requestAvatar("user", None, pop3.IMailbox)[1] msg = mbox.getMessage(0).read() self.assertNotEqual(msg.find("This is the message"), -1) return self.smtpServer.stopListening() done.addCallback(finished) return done @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testRelayDelivery(self): # Here is the service we will connect to and send mail from insServ = mail.mail.MailService() insServ.smtpPortal.registerChecker(cred.checkers.AllowAnonymousAccess()) domain = mail.maildir.MaildirDirdbmDomain(insServ, "insertionDomain") insServ.addDomain("insertion.domain", domain) os.mkdir("insertionQueue") insServ.setQueue(mail.relaymanager.Queue("insertionQueue")) insServ.domains.setDefaultDomain(mail.relay.DomainQueuer(insServ)) manager = mail.relaymanager.SmartHostSMTPRelayingManager(insServ.queue) manager.fArgs += ("test.identity.hostname",) helper = mail.relaymanager.RelayStateHelper(manager, 1) # Yoink! Now the internet obeys OUR every whim! manager.mxcalc = mail.relaymanager.MXCalculator(self.resolver) # And this is our whim. self.auth.addresses["destination.domain"] = ["127.0.0.1"] f = insServ.getSMTPFactory() self.insServer = reactor.listenTCP(0, f, interface="127.0.0.1") # Here is the service the previous one will connect to for final # delivery destServ = mail.mail.MailService() destServ.smtpPortal.registerChecker(cred.checkers.AllowAnonymousAccess()) domain = mail.maildir.MaildirDirdbmDomain(destServ, "destinationDomain") domain.addUser("user", "password") destServ.addDomain("destination.domain", domain) os.mkdir("destinationQueue") destServ.setQueue(mail.relaymanager.Queue("destinationQueue")) helper = mail.relaymanager.RelayStateHelper(manager, 1) helper.startService() f = destServ.getSMTPFactory() self.destServer = reactor.listenTCP(0, f, interface="127.0.0.1") # Update the port number the *first* relay will connect to, because we can't use # port 25 manager.PORT = self.destServer.getHost().port client = LineSendingProtocol( [ "HELO meson", "MAIL FROM: <user@wherever>", "RCPT TO: <user@destination.domain>", "DATA", "This is the message", ".", "QUIT", ] ) done = Deferred() f = protocol.ClientFactory() f.protocol = lambda: client f.clientConnectionLost = lambda *args: done.callback(None) reactor.connectTCP("127.0.0.1", self.insServer.getHost().port, f) def finished(ign): # First part of the delivery is done. Poke the queue manually now # so we don't have to wait for the queue to be flushed. delivery = manager.checkState() def delivered(ign): mbox = domain.requestAvatar("user", None, pop3.IMailbox)[1] msg = mbox.getMessage(0).read() self.assertNotEqual(msg.find("This is the message"), -1) self.insServer.stopListening() self.destServer.stopListening() helper.stopService() delivery.addCallback(delivered) return delivery done.addCallback(finished) return done class LineBufferMessage: def __init__(self): self.lines = [] self.eom = False self.lost = False def lineReceived(self, line): self.lines.append(line) def eomReceived(self): self.eom = True return defer.succeed("<Whatever>") def connectionLost(self): self.lost = True @skipIf(platformType != "posix", "twisted.mail only works on posix") class AliasTests(TestCase): lines = ["First line", "Next line", "", "After a blank line", "Last line"] def testHandle(self): result = {} lines = [ "user: another@host\n", "nextuser: |/bin/program\n", "user: me@again\n", "moreusers: :/etc/include/filename\n", "multiuser: first@host, second@host,last@anotherhost", ] for l in lines: mail.alias.handle(result, l, "TestCase", None) self.assertEqual(result["user"], ["another@host", "me@again"]) self.assertEqual(result["nextuser"], ["|/bin/program"]) self.assertEqual(result["moreusers"], [":/etc/include/filename"]) self.assertEqual( result["multiuser"], ["first@host", "second@host", "last@anotherhost"] ) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testFileLoader(self): domains = {"": object()} result = mail.alias.loadAliasFile( domains, fp=io.BytesIO( textwrap.dedent( """\ # Here's a comment # woop another one testuser: address1,address2, address3, continuation@address, |/bin/process/this usertwo:thisaddress,thataddress, lastaddress lastuser: :/includable, /filename, |/program, address """ ).encode() ), ) self.assertEqual(len(result), 3) group = result["testuser"] s = str(group) for a in ( "address1", "address2", "address3", "continuation@address", "/bin/process/this", ): self.assertNotEqual(s.find(a), -1) self.assertEqual(len(group), 5) group = result["usertwo"] s = str(group) for a in ("thisaddress", "thataddress", "lastaddress"): self.assertNotEqual(s.find(a), -1) self.assertEqual(len(group), 3) group = result["lastuser"] s = str(group) self.assertEqual(s.find("/includable"), -1) for a in ("/filename", "program", "address"): self.assertNotEqual(s.find(a), -1, "%s not found" % a) self.assertEqual(len(group), 3) def testMultiWrapper(self): msgs = LineBufferMessage(), LineBufferMessage(), LineBufferMessage() msg = mail.alias.MultiWrapper(msgs) for L in self.lines: msg.lineReceived(L) return msg.eomReceived().addCallback(self._cbMultiWrapper, msgs) def _cbMultiWrapper(self, ignored, msgs): for m in msgs: self.assertTrue(m.eom) self.assertFalse(m.lost) self.assertEqual(self.lines, m.lines) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def testFileAlias(self): tmpfile = self.mktemp() a = mail.alias.FileAlias(tmpfile, None, None) m = a.createMessageReceiver() for l in self.lines: m.lineReceived(l) return m.eomReceived().addCallback(self._cbTestFileAlias, tmpfile) def _cbTestFileAlias(self, ignored, tmpfile): with open(tmpfile) as f: lines = f.readlines() self.assertEqual([L[:-1] for L in lines], self.lines) class DummyDomain: """ Test domain for L{AddressAliasTests}. """ def __init__(self, address): self.address = address def exists(self, user, memo=None): """ @returns: When a C{memo} is passed in this will raise a L{smtp.SMTPBadRcpt} exception, otherwise a boolean indicating if the C{user} and string version of L{self.address} are equal or not. @rtype: C{bool} """ if memo: raise mail.smtp.SMTPBadRcpt("ham") return lambda: user == str(self.address) @skipIf(platformType != "posix", "twisted.mail only works on posix") class AddressAliasTests(TestCase): """ Tests for L{twisted.mail.alias.AddressAlias}. """ def setUp(self): """ Setup an L{AddressAlias}. """ self.address = mail.smtp.Address("foo@bar") domains = {self.address.domain: DummyDomain(self.address)} self.alias = mail.alias.AddressAlias(self.address, domains, self.address) def test_createMessageReceiver(self): """ L{createMessageReceiever} calls C{exists()} on the domain object which key matches the C{alias} passed to L{AddressAlias}. """ self.assertTrue(self.alias.createMessageReceiver()) def test_str(self): """ The string presentation of L{AddressAlias} includes the alias. """ self.assertEqual(str(self.alias), "<Address foo@bar>") def test_resolve(self): """ L{resolve} will look for additional aliases when an C{aliasmap} dictionary is passed, and returns L{None} if none were found. """ self.assertEqual(self.alias.resolve({self.address: "bar"}), None) def test_resolveWithoutAliasmap(self): """ L{resolve} returns L{None} when the alias could not be found in the C{aliasmap} and no L{mail.smtp.User} with this alias exists either. """ self.assertEqual(self.alias.resolve({}), None) class DummyProcess: __slots__ = ["onEnd"] class MockProcessAlias(mail.alias.ProcessAlias): """ An alias processor that doesn't actually launch processes. """ def spawnProcess(self, proto, program, path): """ Don't spawn a process. """ class MockAliasGroup(mail.alias.AliasGroup): """ An alias group using C{MockProcessAlias}. """ processAliasFactory = MockProcessAlias class StubProcess: """ Fake implementation of L{IProcessTransport}. @ivar signals: A list of all the signals which have been sent to this fake process. """ def __init__(self): self.signals = [] def loseConnection(self): """ No-op implementation of disconnection. """ def signalProcess(self, signal): """ Record a signal sent to this process for later inspection. """ self.signals.append(signal) @skipIf(platformType != "posix", "twisted.mail only works on posix") class ProcessAliasTests(TestCase): """ Tests for alias resolution. """ if interfaces.IReactorProcess(reactor, None) is None: skip = "IReactorProcess not supported" lines = ["First line", "Next line", "", "After a blank line", "Last line"] def exitStatus(self, code): """ Construct a status from the given exit code. @type code: L{int} between 0 and 255 inclusive. @param code: The exit status which the code will represent. @rtype: L{int} @return: A status integer for the given exit code. """ # /* Macros for constructing status values. */ # #define __W_EXITCODE(ret, sig) ((ret) << 8 | (sig)) status = (code << 8) | 0 # Sanity check self.assertTrue(os.WIFEXITED(status)) self.assertEqual(os.WEXITSTATUS(status), code) self.assertFalse(os.WIFSIGNALED(status)) return status def signalStatus(self, signal): """ Construct a status from the given signal. @type signal: L{int} between 0 and 255 inclusive. @param signal: The signal number which the status will represent. @rtype: L{int} @return: A status integer for the given signal. """ # /* If WIFSIGNALED(STATUS), the terminating signal. */ # #define __WTERMSIG(status) ((status) & 0x7f) # /* Nonzero if STATUS indicates termination by a signal. */ # #define __WIFSIGNALED(status) \ # (((signed char) (((status) & 0x7f) + 1) >> 1) > 0) status = signal # Sanity check self.assertTrue(os.WIFSIGNALED(status)) self.assertEqual(os.WTERMSIG(status), signal) self.assertFalse(os.WIFEXITED(status)) return status def setUp(self): """ Replace L{smtp.DNSNAME} with a well-known value. """ self.DNSNAME = smtp.DNSNAME smtp.DNSNAME = "" def tearDown(self): """ Restore the original value of L{smtp.DNSNAME}. """ smtp.DNSNAME = self.DNSNAME @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_processAlias(self): """ Standard call to C{mail.alias.ProcessAlias}: check that the specified script is called, and that the input is correctly transferred to it. """ sh = FilePath(self.mktemp()) sh.setContent( """\ #!/bin/sh rm -f process.alias.out while read i; do echo $i >> process.alias.out done""" ) os.chmod(sh.path, 0o700) a = mail.alias.ProcessAlias(sh.path, None, None) m = a.createMessageReceiver() for l in self.lines: m.lineReceived(l) def _cbProcessAlias(ignored): with open("process.alias.out") as f: lines = f.readlines() self.assertEqual([L[:-1] for L in lines], self.lines) return m.eomReceived().addCallback(_cbProcessAlias) def test_processAliasTimeout(self): """ If the alias child process does not exit within a particular period of time, the L{Deferred} returned by L{MessageWrapper.eomReceived} should fail with L{ProcessAliasTimeout} and send the I{KILL} signal to the child process.. """ reactor = task.Clock() transport = StubProcess() proto = mail.alias.ProcessAliasProtocol() proto.makeConnection(transport) receiver = mail.alias.MessageWrapper(proto, None, reactor) d = receiver.eomReceived() reactor.advance(receiver.completionTimeout) def timedOut(ignored): self.assertEqual(transport.signals, ["KILL"]) # Now that it has been killed, disconnect the protocol associated # with it. proto.processEnded(ProcessTerminated(self.signalStatus(signal.SIGKILL))) self.assertFailure(d, mail.alias.ProcessAliasTimeout) d.addCallback(timedOut) return d def test_earlyProcessTermination(self): """ If the process associated with an L{mail.alias.MessageWrapper} exits before I{eomReceived} is called, the L{Deferred} returned by I{eomReceived} should fail. """ transport = StubProcess() protocol = mail.alias.ProcessAliasProtocol() protocol.makeConnection(transport) receiver = mail.alias.MessageWrapper(protocol, None, None) protocol.processEnded(failure.Failure(ProcessDone(0))) return self.assertFailure(receiver.eomReceived(), ProcessDone) def _terminationTest(self, status): """ Verify that if the process associated with an L{mail.alias.MessageWrapper} exits with the given status, the L{Deferred} returned by I{eomReceived} fails with L{ProcessTerminated}. """ transport = StubProcess() protocol = mail.alias.ProcessAliasProtocol() protocol.makeConnection(transport) receiver = mail.alias.MessageWrapper(protocol, None, None) protocol.processEnded(failure.Failure(ProcessTerminated(status))) return self.assertFailure(receiver.eomReceived(), ProcessTerminated) def test_errorProcessTermination(self): """ If the process associated with an L{mail.alias.MessageWrapper} exits with a non-zero exit code, the L{Deferred} returned by I{eomReceived} should fail. """ return self._terminationTest(self.exitStatus(1)) def test_signalProcessTermination(self): """ If the process associated with an L{mail.alias.MessageWrapper} exits because it received a signal, the L{Deferred} returned by I{eomReceived} should fail. """ return self._terminationTest(self.signalStatus(signal.SIGHUP)) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_aliasResolution(self): """ Check that the C{resolve} method of alias processors produce the correct set of objects: - direct alias with L{mail.alias.AddressAlias} if a simple input is passed - aliases in a file with L{mail.alias.FileWrapper} if an input in the format '/file' is given - aliases resulting of a process call wrapped by L{mail.alias.MessageWrapper} if the format is '|process' """ aliases = {} domain = {"": TestDomain(aliases, ["user1", "user2", "user3"])} A1 = MockAliasGroup(["user1", "|echo", "/file"], domain, "alias1") A2 = MockAliasGroup(["user2", "user3"], domain, "alias2") A3 = mail.alias.AddressAlias("alias1", domain, "alias3") aliases.update( { "alias1": A1, "alias2": A2, "alias3": A3, } ) res1 = A1.resolve(aliases) r1 = map(str, res1.objs) r1.sort() expected = map( str, [ mail.alias.AddressAlias("user1", None, None), mail.alias.MessageWrapper(DummyProcess(), "echo"), mail.alias.FileWrapper("/file"), ], ) expected.sort() self.assertEqual(r1, expected) res2 = A2.resolve(aliases) r2 = map(str, res2.objs) r2.sort() expected = map( str, [ mail.alias.AddressAlias("user2", None, None), mail.alias.AddressAlias("user3", None, None), ], ) expected.sort() self.assertEqual(r2, expected) res3 = A3.resolve(aliases) r3 = map(str, res3.objs) r3.sort() expected = map( str, [ mail.alias.AddressAlias("user1", None, None), mail.alias.MessageWrapper(DummyProcess(), "echo"), mail.alias.FileWrapper("/file"), ], ) expected.sort() self.assertEqual(r3, expected) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_cyclicAlias(self): """ Check that a cycle in alias resolution is correctly handled. """ aliases = {} domain = {"": TestDomain(aliases, [])} A1 = mail.alias.AddressAlias("alias2", domain, "alias1") A2 = mail.alias.AddressAlias("alias3", domain, "alias2") A3 = mail.alias.AddressAlias("alias1", domain, "alias3") aliases.update({"alias1": A1, "alias2": A2, "alias3": A3}) self.assertEqual(aliases["alias1"].resolve(aliases), None) self.assertEqual(aliases["alias2"].resolve(aliases), None) self.assertEqual(aliases["alias3"].resolve(aliases), None) A4 = MockAliasGroup(["|echo", "alias1"], domain, "alias4") aliases["alias4"] = A4 res = A4.resolve(aliases) r = map(str, res.objs) r.sort() expected = map(str, [mail.alias.MessageWrapper(DummyProcess(), "echo")]) expected.sort() self.assertEqual(r, expected) class TestDomain: def __init__(self, aliases, users): self.aliases = aliases self.users = users def exists(self, user, memo=None): user = user.dest.local if user in self.users: return lambda: mail.alias.AddressAlias(user, None, None) try: a = self.aliases[user] except BaseException: raise smtp.SMTPBadRcpt(user) else: aliases = a.resolve(self.aliases, memo) if aliases: return lambda: aliases raise smtp.SMTPBadRcpt(user) class DummyQueue: """ A fake relay queue to use for testing. This queue doesn't keep track of which messages are waiting to be relayed or are in the process of being relayed. @ivar directory: See L{__init__}. """ def __init__(self, directory): """ @type directory: L{bytes} @param directory: The pathname of the directory holding messages in the queue. """ self.directory = directory def done(self, message): """ Remove a message from the queue. @type message: L{bytes} @param message: The base filename of a message. """ message = os.path.basename(message) os.remove(self.getPath(message) + "-D") os.remove(self.getPath(message) + "-H") def getEnvelopeFile(self, message): """ Get the envelope file for a message in the queue. @type message: L{bytes} @param message: The base filename of a message. @rtype: L{file} @return: The envelope file for the message. """ return open(os.path.join(self.directory, message + "-H"), "rb") def getPath(self, message): """ Return the full base pathname of a message in the queue. @type message: L{bytes} @param message: The base filename of a message. @rtype: L{bytes} @return: The full base pathname of the message. """ return os.path.join(self.directory, message) def createNewMessage(self): """ Create a new message in the queue. @rtype: 2-L{tuple} of (E{1}) L{file}, (E{2}) L{FileMessage} @return: The envelope file and a message receiver for a new message in the queue. """ fname = f"{time.time()}_{id(self)}" headerFile = open(os.path.join(self.directory, fname + "-H"), "wb") tempFilename = os.path.join(self.directory, fname + "-C") finalFilename = os.path.join(self.directory, fname + "-D") messageFile = open(tempFilename, "wb") return headerFile, mail.mail.FileMessage( messageFile, tempFilename, finalFilename ) def setWaiting(self, message): """ Ignore the request to mark a message as waiting to be relayed. @type message: L{bytes} @param message: The base filename of a message. """ pass class DummySmartHostSMTPRelayingManager: """ A fake smart host to use for testing. @type managed: L{dict} of L{bytes} -> L{list} of L{list} of L{bytes} @ivar managed: A mapping of a string identifying a managed relayer to filenames of messages the managed relayer is responsible for. @ivar queue: See L{__init__}. """ def __init__(self, queue): """ Initialize the minimum necessary members of a smart host. @type queue: L{DummyQueue} @param queue: A queue that can be used for testing purposes. """ self.managed = {} self.queue = queue @skipIf(platformType != "posix", "twisted.mail only works on posix") class _AttemptManagerTests(TestCase): """ Test the behavior of L{_AttemptManager}. @type tmpdir: L{bytes} @ivar tmpdir: The path to a temporary directory holding the message files. @type reactor: L{MemoryReactorClock} @ivar reactor: The reactor used for test purposes. @type eventLog: L{None} or L{dict} of L{bytes} -> L{object} @ivar eventLog: Information about the last informational log message generated or none if no log message has been generated. @type noisyAttemptMgr: L{_AttemptManager} @ivar noisyAttemptMgr: An attempt manager which generates informational log messages. @type quietAttemptMgr: L{_AttemptManager} @ivar quietAttemptMgr: An attempt manager which does not generate informational log messages. @type noisyMessage: L{bytes} @ivar noisyMessage: The full base pathname of the message to be used with the noisy attempt manager. @type quietMessage: L{bytes} @ivar quietMessage: The full base pathname of the message to be used with the quiet. """ def setUp(self): """ Set up a temporary directory for the queue, attempt managers with the noisy flag on and off, message files for use with each attempt manager, and a reactor. Also, register to be notified when log messages are generated. """ self.tmpdir = self.mktemp() os.mkdir(self.tmpdir) self.reactor = MemoryReactorClock() self.eventLog = None log.addObserver(self._logObserver) self.noisyAttemptMgr = _AttemptManager( DummySmartHostSMTPRelayingManager(DummyQueue(self.tmpdir)), True, self.reactor, ) self.quietAttemptMgr = _AttemptManager( DummySmartHostSMTPRelayingManager(DummyQueue(self.tmpdir)), False, self.reactor, ) noisyBaseName = "noisyMessage" quietBaseName = "quietMessage" self.noisyMessage = os.path.join(self.tmpdir, noisyBaseName) self.quietMessage = os.path.join(self.tmpdir, quietBaseName) open(self.noisyMessage + "-D", "w").close() open(self.quietMessage + "-D", "w").close() self.noisyAttemptMgr.manager.managed["noisyRelayer"] = [noisyBaseName] self.quietAttemptMgr.manager.managed["quietRelayer"] = [quietBaseName] with open(self.noisyMessage + "-H", "wb") as envelope: pickle.dump(["from-noisy@domain", "to-noisy@domain"], envelope) with open(self.quietMessage + "-H", "wb") as envelope: pickle.dump(["from-quiet@domain", "to-quiet@domain"], envelope) def tearDown(self): """ Unregister for log events and remove the temporary directory. """ log.removeObserver(self._logObserver) shutil.rmtree(self.tmpdir) def _logObserver(self, eventDict): """ A log observer. @type eventDict: L{dict} of L{bytes} -> L{object} @param eventDict: Information about the last informational log message generated. """ self.eventLog = eventDict def test_initNoisyDefault(self): """ When an attempt manager is created without the noisy parameter, the noisy instance variable should default to true. """ am = _AttemptManager(DummySmartHostSMTPRelayingManager(DummyQueue(self.tmpdir))) self.assertTrue(am.noisy) def test_initNoisy(self): """ When an attempt manager is created with the noisy parameter set to true, the noisy instance variable should be set to true. """ self.assertTrue(self.noisyAttemptMgr.noisy) def test_initQuiet(self): """ When an attempt manager is created with the noisy parameter set to false, the noisy instance variable should be set to false. """ self.assertFalse(self.quietAttemptMgr.noisy) def test_initReactorDefault(self): """ When an attempt manager is created without the reactor parameter, the reactor instance variable should default to the global reactor. """ am = _AttemptManager(DummySmartHostSMTPRelayingManager(DummyQueue(self.tmpdir))) self.assertEqual(am.reactor, reactor) def test_initReactor(self): """ When an attempt manager is created with a reactor provided, the reactor instance variable should default to that reactor. """ self.assertEqual(self.noisyAttemptMgr.reactor, self.reactor) def test_notifySuccessNoisy(self): """ For an attempt manager with the noisy flag set, notifySuccess should result in a log message. """ self.noisyAttemptMgr.notifySuccess("noisyRelayer", self.noisyMessage) self.assertTrue(self.eventLog) def test_notifySuccessQuiet(self): """ For an attempt manager with the noisy flag not set, notifySuccess should result in no log message. """ self.quietAttemptMgr.notifySuccess("quietRelayer", self.quietMessage) self.assertFalse(self.eventLog) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_notifyFailureNoisy(self): """ For an attempt manager with the noisy flag set, notifyFailure should result in a log message. """ self.noisyAttemptMgr.notifyFailure("noisyRelayer", self.noisyMessage) self.assertTrue(self.eventLog) @skipIf(sys.version_info >= (3,), "not ported to Python 3") def test_notifyFailureQuiet(self): """ For an attempt manager with the noisy flag not set, notifyFailure should result in no log message. """ self.quietAttemptMgr.notifyFailure("quietRelayer", self.quietMessage) self.assertFalse(self.eventLog) def test_notifyDoneNoisy(self): """ For an attempt manager with the noisy flag set, notifyDone should result in a log message. """ self.noisyAttemptMgr.notifyDone("noisyRelayer") self.assertTrue(self.eventLog) def test_notifyDoneQuiet(self): """ For an attempt manager with the noisy flag not set, notifyDone should result in no log message. """ self.quietAttemptMgr.notifyDone("quietRelayer") self.assertFalse(self.eventLog) def test_notifyNoConnectionNoisy(self): """ For an attempt manager with the noisy flag set, notifyNoConnection should result in a log message. """ self.noisyAttemptMgr.notifyNoConnection("noisyRelayer") self.assertTrue(self.eventLog) self.reactor.advance(60) def test_notifyNoConnectionQuiet(self): """ For an attempt manager with the noisy flag not set, notifyNoConnection should result in no log message. """ self.quietAttemptMgr.notifyNoConnection("quietRelayer") self.assertFalse(self.eventLog) self.reactor.advance(60) PK Mb�Z?���k2 k2 mail/test/test_mailmail.pynu �[��� # -*- test-case-name: twisted.mail.test.test_mailmail -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.mail.scripts.mailmail}, the implementation of the command line program I{mailmail}. """ import os import sys from io import StringIO from unittest import skipIf from twisted.copyright import version from twisted.internet.defer import Deferred from twisted.mail import smtp from twisted.mail.scripts import mailmail from twisted.mail.scripts.mailmail import parseOptions from twisted.python.failure import Failure from twisted.python.runtime import platformType from twisted.test.proto_helpers import MemoryReactor from twisted.trial.unittest import TestCase class OptionsTests(TestCase): """ Tests for L{parseOptions} which parses command line arguments and reads message text from stdin to produce an L{Options} instance which can be used to send a message. """ memoryReactor = MemoryReactor() def setUp(self): """ Override some things in mailmail, so that we capture C{stdout}, and do not call L{reactor.stop}. """ self.out = StringIO() # Override the mailmail logger, so we capture stderr output from twisted.logger import Logger, textFileLogObserver logObserver = textFileLogObserver(self.out) self.patch(mailmail, "_log", Logger(observer=logObserver)) self.host = None self.options = None self.ident = None # Override mailmail.sendmail, so we don't call reactor.stop() def sendmail(host, options, ident): self.host = host self.options = options self.ident = ident return smtp.sendmail( host, options.sender, options.to, options.body, reactor=self.memoryReactor, ) self.patch(mailmail, "sendmail", sendmail) def test_unspecifiedRecipients(self): """ If no recipients are given in the argument list and there is no recipient header in the message text, L{parseOptions} raises L{SystemExit} with a string describing the problem. """ self.patch(sys, "stdin", StringIO("Subject: foo\n" "\n" "Hello, goodbye.\n")) exc = self.assertRaises(SystemExit, parseOptions, []) self.assertEqual(exc.args, ("No recipients specified.",)) def test_listQueueInformation(self): """ The I{-bp} option for listing queue information is unsupported and if it is passed to L{parseOptions}, L{SystemExit} is raised. """ exc = self.assertRaises(SystemExit, parseOptions, ["-bp"]) self.assertEqual(exc.args, ("Unsupported option.",)) def test_stdioTransport(self): """ The I{-bs} option for using stdin and stdout as the SMTP transport is unsupported and if it is passed to L{parseOptions}, L{SystemExit} is raised. """ exc = self.assertRaises(SystemExit, parseOptions, ["-bs"]) self.assertEqual(exc.args, ("Unsupported option.",)) def test_ignoreFullStop(self): """ The I{-i} and I{-oi} options for ignoring C{"."} by itself on a line are unsupported and if either is passed to L{parseOptions}, L{SystemExit} is raised. """ exc = self.assertRaises(SystemExit, parseOptions, ["-i"]) self.assertEqual(exc.args, ("Unsupported option.",)) exc = self.assertRaises(SystemExit, parseOptions, ["-oi"]) self.assertEqual(exc.args, ("Unsupported option.",)) def test_copyAliasedSender(self): """ The I{-om} option for copying the sender if they appear in an alias expansion is unsupported and if it is passed to L{parseOptions}, L{SystemExit} is raised. """ exc = self.assertRaises(SystemExit, parseOptions, ["-om"]) self.assertEqual(exc.args, ("Unsupported option.",)) def test_version(self): """ The I{--version} option displays the version and raises L{SystemExit} with L{None} as the exit code. """ out = StringIO() self.patch(sys, "stdout", out) systemExitCode = self.assertRaises(SystemExit, parseOptions, "--version") # SystemExit.code is None on success self.assertEqual(systemExitCode.code, None) data = out.getvalue() self.assertEqual(data, f"mailmail version: {version}\n") def test_backgroundDelivery(self): """ The I{-odb} flag specifies background delivery. """ stdin = StringIO("\n") self.patch(sys, "stdin", stdin) o = parseOptions("-odb") self.assertTrue(o.background) def test_foregroundDelivery(self): """ The I{-odf} flags specifies foreground delivery. """ stdin = StringIO("\n") self.patch(sys, "stdin", stdin) o = parseOptions("-odf") self.assertFalse(o.background) def test_recipientsFromHeaders(self): """ The I{-t} flags specifies that recipients should be obtained from headers. """ stdin = StringIO( "To: Curly <invaliduser2@example.com>\n" "Cc: Larry <invaliduser1@example.com>\n" "Bcc: Moe <invaliduser3@example.com>\n" "\n" "Oh, a wise guy?\n" ) self.patch(sys, "stdin", stdin) o = parseOptions("-t") self.assertEqual(len(o.to), 3) def test_setFrom(self): """ When a message has no I{From:} header, a I{From:} value can be specified with the I{-F} flag. """ stdin = StringIO("To: invaliduser2@example.com\n" "Subject: A wise guy?\n\n") self.patch(sys, "stdin", stdin) o = parseOptions(["-F", "Larry <invaliduser1@example.com>", "-t"]) self.assertEqual(o.sender, "Larry <invaliduser1@example.com>") def test_overrideFromFlagByFromHeader(self): """ The I{-F} flag specifies the From: value. However, I{-F} flag is overriden by the value of From: in the e-mail header. """ stdin = StringIO( "To: Curly <invaliduser4@example.com>\n" "From: Shemp <invaliduser4@example.com>\n" ) self.patch(sys, "stdin", stdin) o = parseOptions(["-F", "Groucho <invaliduser5@example.com>", "-t"]) self.assertEqual(o.sender, "invaliduser4@example.com") @skipIf( platformType == "win32", "mailmail.run() does not work on win32 due to lack of support for" " getuid()", ) def test_runErrorsToStderr(self): """ Call L{mailmail.run}, and specify I{-oep} to print errors to stderr. The sender, to, and printErrors options should be set and there should be no failure. """ argv = ("test_mailmail.py", "invaliduser2@example.com", "-oep") stdin = StringIO("\n") self.patch(sys, "argv", argv) self.patch(sys, "stdin", stdin) mailmail.run() self.assertEqual(self.options.sender, mailmail.getlogin()) self.assertEqual(self.options.to, ["invaliduser2@example.com"]) # We should have printErrors set because we specified "-oep" self.assertTrue(self.options.printErrors) # We should not have any failures. self.assertIsNone(mailmail.failed) @skipIf( platformType == "win32", "mailmail.run() does not work on win32 due to lack of support for" " getuid()", ) def test_readInvalidConfig(self): """ Error messages for illegal UID value, illegal GID value, and illegal identity entry will be sent to stderr. """ stdin = StringIO("\n") self.patch(sys, "stdin", stdin) filename = self.mktemp() myUid = os.getuid() myGid = os.getgid() with open(filename, "w") as f: # Create a config file with some invalid values f.write( "[useraccess]\n" "allow=invaliduser2,invaliduser1\n" "deny=invaliduser3,invaliduser4,{}\n" "order=allow,deny\n" "[groupaccess]\n" "allow=invalidgid1,invalidgid2\n" "deny=invalidgid1,invalidgid2,{}\n" "order=deny,allow\n" "[identity]\n" "localhost=funny\n" "[addresses]\n" "smarthost=localhost\n" "default_domain=example.com\n".format(myUid, myGid) ) # The mailmail script looks in # the twisted.mail.scripts.GLOBAL_CFG variable # and then the twisted.mail.scripts.LOCAL_CFG # variable for the path to it's config file. # # Override twisted.mail.scripts.LOCAL_CFG with the file we just # created. self.patch(mailmail, "LOCAL_CFG", filename) argv = ("test_mailmail.py", "invaliduser2@example.com", "-oep") self.patch(sys, "argv", argv) mailmail.run() self.assertRegex( self.out.getvalue(), "Illegal UID in \\[useraccess\\] section: " "invaliduser1", ) self.assertRegex( self.out.getvalue(), "Illegal GID in \\[groupaccess\\] section: " "invalidgid1", ) self.assertRegex( self.out.getvalue(), "Illegal entry in \\[identity\\] section: funny" ) def getConfigFromFile(self, config): """ Read a mailmail configuration file. The mailmail script checks the twisted.mail.scripts.mailmail.GLOBAL_CFG variable and then the twisted.mail.scripts.mailmail.LOCAL_CFG variable for the path to its config file. @param config: path to config file @type config: L{str} @return: A parsed config. @rtype: L{twisted.mail.scripts.mailmail.Configuration} """ from twisted.mail.scripts.mailmail import loadConfig filename = self.mktemp() with open(filename, "w") as f: f.write(config) return loadConfig(filename) def test_loadConfig(self): """ L{twisted.mail.scripts.mailmail.loadConfig} parses the config file for mailmail. """ config = self.getConfigFromFile( """ [addresses] smarthost=localhost""" ) self.assertEqual(config.smarthost, "localhost") config = self.getConfigFromFile( """ [addresses] default_domain=example.com""" ) self.assertEqual(config.domain, "example.com") config = self.getConfigFromFile( """ [addresses] smarthost=localhost default_domain=example.com""" ) self.assertEqual(config.smarthost, "localhost") self.assertEqual(config.domain, "example.com") config = self.getConfigFromFile( """ [identity] host1=invalid host2=username:password""" ) self.assertNotIn("host1", config.identities) self.assertEqual(config.identities["host2"], ["username", "password"]) config = self.getConfigFromFile( """ [useraccess] allow=invalid1,35 order=allow""" ) self.assertEqual(config.allowUIDs, [35]) config = self.getConfigFromFile( """ [useraccess] deny=35,36 order=deny""" ) self.assertEqual(config.denyUIDs, [35, 36]) config = self.getConfigFromFile( """ [useraccess] allow=35,36 deny=37,38 order=deny""" ) self.assertEqual(config.allowUIDs, [35, 36]) self.assertEqual(config.denyUIDs, [37, 38]) config = self.getConfigFromFile( """ [groupaccess] allow=gid1,41 order=allow""" ) self.assertEqual(config.allowGIDs, [41]) config = self.getConfigFromFile( """ [groupaccess] deny=41 order=deny""" ) self.assertEqual(config.denyGIDs, [41]) config = self.getConfigFromFile( """ [groupaccess] allow=41,42 deny=43,44 order=allow,deny""" ) self.assertEqual(config.allowGIDs, [41, 42]) self.assertEqual(config.denyGIDs, [43, 44]) def test_senderror(self): """ L{twisted.mail.scripts.mailmail.senderror} sends mail back to the sender if an error occurs while sending mail to the recipient. """ def sendmail(host, sender, recipient, body): self.assertRegex(sender, "postmaster@") self.assertEqual(recipient, ["testsender"]) self.assertRegex(body.getvalue(), "ValueError") return Deferred() self.patch(smtp, "sendmail", sendmail) opts = mailmail.Options() opts.sender = "testsender" fail = Failure(ValueError()) mailmail.senderror(fail, opts) PK Mb�Z��0�# # mail/test/pop3testserver.pynu ȯ�� #! /usr/bin/python3 # -*- test-case-name: twisted.mail.test.test_pop3client -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import sys from twisted.internet import reactor from twisted.internet.protocol import Factory from twisted.protocols import basic USER = "test" PASS = "twisted" PORT = 1100 SSL_SUPPORT = True UIDL_SUPPORT = True INVALID_SERVER_RESPONSE = False INVALID_CAPABILITY_RESPONSE = False INVALID_LOGIN_RESPONSE = False DENY_CONNECTION = False DROP_CONNECTION = False BAD_TLS_RESPONSE = False TIMEOUT_RESPONSE = False TIMEOUT_DEFERRED = False SLOW_GREETING = False """Commands""" CONNECTION_MADE = b"+OK POP3 localhost v2003.83 server ready" CAPABILITIES = [b"TOP", b"LOGIN-DELAY 180", b"USER", b"SASL LOGIN"] CAPABILITIES_SSL = b"STLS" CAPABILITIES_UIDL = b"UIDL" INVALID_RESPONSE = b"-ERR Unknown request" VALID_RESPONSE = b"+OK Command Completed" AUTH_DECLINED = b"-ERR LOGIN failed" AUTH_ACCEPTED = b"+OK Mailbox open, 0 messages" TLS_ERROR = b"-ERR server side error start TLS handshake" LOGOUT_COMPLETE = b"+OK quit completed" NOT_LOGGED_IN = b"-ERR Unknown AUHORIZATION state command" STAT = b"+OK 0 0" UIDL = b"+OK Unique-ID listing follows\r\n." LIST = b"+OK Mailbox scan listing follows\r\n." CAP_START = b"+OK Capability list follows:" class POP3TestServer(basic.LineReceiver): def __init__(self, contextFactory=None): self.loggedIn = False self.caps = None self.tmpUser = None self.ctx = contextFactory def sendSTATResp(self, req): self.sendLine(STAT) def sendUIDLResp(self, req): self.sendLine(UIDL) def sendLISTResp(self, req): self.sendLine(LIST) def sendCapabilities(self): if self.caps is None: self.caps = [CAP_START] if UIDL_SUPPORT: self.caps.append(CAPABILITIES_UIDL) if SSL_SUPPORT: self.caps.append(CAPABILITIES_SSL) for cap in CAPABILITIES: self.caps.append(cap) resp = b"\r\n".join(self.caps) resp += b"\r\n." self.sendLine(resp) def connectionMade(self): if DENY_CONNECTION: self.disconnect() return if SLOW_GREETING: reactor.callLater(20, self.sendGreeting) else: self.sendGreeting() def sendGreeting(self): self.sendLine(CONNECTION_MADE) def lineReceived(self, line): """Error Conditions""" uline = line.upper() find = lambda s: uline.find(s) != -1 if TIMEOUT_RESPONSE: # Do not respond to clients request return if DROP_CONNECTION: self.disconnect() return elif find(b"CAPA"): if INVALID_CAPABILITY_RESPONSE: self.sendLine(INVALID_RESPONSE) else: self.sendCapabilities() elif find(b"STLS") and SSL_SUPPORT: self.startTLS() elif find(b"USER"): if INVALID_LOGIN_RESPONSE: self.sendLine(INVALID_RESPONSE) return resp = None try: self.tmpUser = line.split(" ")[1] resp = VALID_RESPONSE except BaseException: resp = AUTH_DECLINED self.sendLine(resp) elif find(b"PASS"): resp = None try: pwd = line.split(" ")[1] if self.tmpUser is None or pwd is None: resp = AUTH_DECLINED elif self.tmpUser == USER and pwd == PASS: resp = AUTH_ACCEPTED self.loggedIn = True else: resp = AUTH_DECLINED except BaseException: resp = AUTH_DECLINED self.sendLine(resp) elif find(b"QUIT"): self.loggedIn = False self.sendLine(LOGOUT_COMPLETE) self.disconnect() elif INVALID_SERVER_RESPONSE: self.sendLine(INVALID_RESPONSE) elif not self.loggedIn: self.sendLine(NOT_LOGGED_IN) elif find(b"NOOP"): self.sendLine(VALID_RESPONSE) elif find(b"STAT"): if TIMEOUT_DEFERRED: return self.sendLine(STAT) elif find(b"LIST"): if TIMEOUT_DEFERRED: return self.sendLine(LIST) elif find(b"UIDL"): if TIMEOUT_DEFERRED: return elif not UIDL_SUPPORT: self.sendLine(INVALID_RESPONSE) return self.sendLine(UIDL) def startTLS(self): if self.ctx is None: self.getContext() if SSL_SUPPORT and self.ctx is not None: self.sendLine(b"+OK Begin TLS negotiation now") self.transport.startTLS(self.ctx) else: self.sendLine(b"-ERR TLS not available") def disconnect(self): self.transport.loseConnection() def getContext(self): try: from twisted.internet import ssl except ImportError: self.ctx = None else: self.ctx = ssl.ClientContextFactory() self.ctx.method = ssl.SSL.TLSv1_METHOD usage = """popServer.py [arg] (default is Standard POP Server with no messages) no_ssl - Start with no SSL support no_uidl - Start with no UIDL support bad_resp - Send a non-RFC compliant response to the Client bad_cap_resp - send a non-RFC compliant response when the Client sends a 'CAPABILITY' request bad_login_resp - send a non-RFC compliant response when the Client sends a 'LOGIN' request deny - Deny the connection drop - Drop the connection after sending the greeting bad_tls - Send a bad response to a STARTTLS timeout - Do not return a response to a Client request to_deferred - Do not return a response on a 'Select' request. This will test Deferred callback handling slow - Wait 20 seconds after the connection is made to return a Server Greeting """ def printMessage(msg): print("Server Starting in %s mode" % msg) def processArg(arg): if arg.lower() == "no_ssl": global SSL_SUPPORT SSL_SUPPORT = False printMessage("NON-SSL") elif arg.lower() == "no_uidl": global UIDL_SUPPORT UIDL_SUPPORT = False printMessage("NON-UIDL") elif arg.lower() == "bad_resp": global INVALID_SERVER_RESPONSE INVALID_SERVER_RESPONSE = True printMessage("Invalid Server Response") elif arg.lower() == "bad_cap_resp": global INVALID_CAPABILITY_RESPONSE INVALID_CAPABILITY_RESPONSE = True printMessage("Invalid Capability Response") elif arg.lower() == "bad_login_resp": global INVALID_LOGIN_RESPONSE INVALID_LOGIN_RESPONSE = True printMessage("Invalid Capability Response") elif arg.lower() == "deny": global DENY_CONNECTION DENY_CONNECTION = True printMessage("Deny Connection") elif arg.lower() == "drop": global DROP_CONNECTION DROP_CONNECTION = True printMessage("Drop Connection") elif arg.lower() == "bad_tls": global BAD_TLS_RESPONSE BAD_TLS_RESPONSE = True printMessage("Bad TLS Response") elif arg.lower() == "timeout": global TIMEOUT_RESPONSE TIMEOUT_RESPONSE = True printMessage("Timeout Response") elif arg.lower() == "to_deferred": global TIMEOUT_DEFERRED TIMEOUT_DEFERRED = True printMessage("Timeout Deferred Response") elif arg.lower() == "slow": global SLOW_GREETING SLOW_GREETING = True printMessage("Slow Greeting") elif arg.lower() == "--help": print(usage) sys.exit() else: print(usage) sys.exit() def main(): if len(sys.argv) < 2: printMessage("POP3 with no messages") else: args = sys.argv[1:] for arg in args: processArg(arg) f = Factory() f.protocol = POP3TestServer reactor.listenTCP(PORT, f) reactor.run() if __name__ == "__main__": main() PK Mb�ZT�� mail/test/__init__.pynu �[��� "Tests for twistd.mail" PK Mb�Z ��aP aP mail/mail.pynu �[��� # -*- test-case-name: twisted.mail.test.test_mail -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Mail service support. """ # System imports import os import warnings from zope.interface import implementer from twisted.application import internet, service from twisted.cred.portal import Portal # Twisted imports from twisted.internet import defer # Sibling imports from twisted.mail import protocols, smtp from twisted.mail.interfaces import IAliasableDomain, IDomain from twisted.python import log, util class DomainWithDefaultDict: """ A simulated dictionary for mapping domain names to domain objects with a default value for non-existing keys. @ivar domains: See L{__init__} @ivar default: See L{__init__} """ def __init__(self, domains, default): """ @type domains: L{dict} of L{bytes} -> L{IDomain} provider @param domains: A mapping of domain name to domain object. @type default: L{IDomain} provider @param default: The default domain. """ self.domains = domains self.default = default def setDefaultDomain(self, domain): """ Set the default domain. @type domain: L{IDomain} provider @param domain: The default domain. """ self.default = domain def has_key(self, name): """ Test for the presence of a domain name in this dictionary. This always returns C{True} because a default value will be returned if the name doesn't exist in this dictionary. @type name: L{bytes} @param name: A domain name. @rtype: L{bool} @return: C{True} to indicate that the domain name is in this dictionary. """ warnings.warn( "twisted.mail.mail.DomainWithDefaultDict.has_key was deprecated " "in Twisted 16.3.0. " "Use the `in` keyword instead.", category=DeprecationWarning, stacklevel=2, ) return 1 @classmethod def fromkeys(klass, keys, value=None): """ Create a new L{DomainWithDefaultDict} with the specified keys. @type keys: iterable of L{bytes} @param keys: Domain names to serve as keys in the new dictionary. @type value: L{None} or L{IDomain} provider @param value: A domain object to serve as the value for all new keys in the dictionary. @rtype: L{DomainWithDefaultDict} @return: A new dictionary. """ d = klass() for k in keys: d[k] = value return d def __contains__(self, name): """ Test for the presence of a domain name in this dictionary. This always returns C{True} because a default value will be returned if the name doesn't exist in this dictionary. @type name: L{bytes} @param name: A domain name. @rtype: L{bool} @return: C{True} to indicate that the domain name is in this dictionary. """ return 1 def __getitem__(self, name): """ Look up a domain name and, if it is present, return the domain object associated with it. Otherwise return the default domain. @type name: L{bytes} @param name: A domain name. @rtype: L{IDomain} provider or L{None} @return: A domain object. """ return self.domains.get(name, self.default) def __setitem__(self, name, value): """ Associate a domain object with a domain name in this dictionary. @type name: L{bytes} @param name: A domain name. @type value: L{IDomain} provider @param value: A domain object. """ self.domains[name] = value def __delitem__(self, name): """ Delete the entry for a domain name in this dictionary. @type name: L{bytes} @param name: A domain name. """ del self.domains[name] def __iter__(self): """ Return an iterator over the domain names in this dictionary. @rtype: iterator over L{bytes} @return: An iterator over the domain names. """ return iter(self.domains) def __len__(self): """ Return the number of domains in this dictionary. @rtype: L{int} @return: The number of domains in this dictionary. """ return len(self.domains) def __str__(self) -> str: """ Build an informal string representation of this dictionary. @rtype: L{bytes} @return: A string containing the mapping of domain names to domain objects. """ return f"<DomainWithDefaultDict {self.domains}>" def __repr__(self) -> str: """ Build an "official" string representation of this dictionary. @rtype: L{bytes} @return: A pseudo-executable string describing the underlying domain mapping of this object. """ return f"DomainWithDefaultDict({self.domains})" def get(self, key, default=None): """ Look up a domain name in this dictionary. @type key: L{bytes} @param key: A domain name. @type default: L{IDomain} provider or L{None} @param default: A domain object to be returned if the domain name is not in this dictionary. @rtype: L{IDomain} provider or L{None} @return: The domain object associated with the domain name if it is in this dictionary. Otherwise, the default value. """ return self.domains.get(key, default) def copy(self): """ Make a copy of this dictionary. @rtype: L{DomainWithDefaultDict} @return: A copy of this dictionary. """ return DomainWithDefaultDict(self.domains.copy(), self.default) def iteritems(self): """ Return an iterator over the domain name/domain object pairs in the dictionary. Using the returned iterator while adding or deleting entries from the dictionary may result in a L{RuntimeError} or failing to iterate over all the domain name/domain object pairs. @rtype: iterator over 2-L{tuple} of (E{1}) L{bytes}, (E{2}) L{IDomain} provider or L{None} @return: An iterator over the domain name/domain object pairs. """ return self.domains.iteritems() def iterkeys(self): """ Return an iterator over the domain names in this dictionary. Using the returned iterator while adding or deleting entries from the dictionary may result in a L{RuntimeError} or failing to iterate over all the domain names. @rtype: iterator over L{bytes} @return: An iterator over the domain names. """ return self.domains.iterkeys() def itervalues(self): """ Return an iterator over the domain objects in this dictionary. Using the returned iterator while adding or deleting entries from the dictionary may result in a L{RuntimeError} or failing to iterate over all the domain objects. @rtype: iterator over L{IDomain} provider or L{None} @return: An iterator over the domain objects. """ return self.domains.itervalues() def keys(self): """ Return a list of all domain names in this dictionary. @rtype: L{list} of L{bytes} @return: The domain names in this dictionary. """ return self.domains.keys() def values(self): """ Return a list of all domain objects in this dictionary. @rtype: L{list} of L{IDomain} provider or L{None} @return: The domain objects in this dictionary. """ return self.domains.values() def items(self): """ Return a list of all domain name/domain object pairs in this dictionary. @rtype: L{list} of 2-L{tuple} of (E{1}) L{bytes}, (E{2}) L{IDomain} provider or L{None} @return: Domain name/domain object pairs in this dictionary. """ return self.domains.items() def popitem(self): """ Remove a random domain name/domain object pair from this dictionary and return it as a tuple. @rtype: 2-L{tuple} of (E{1}) L{bytes}, (E{2}) L{IDomain} provider or L{None} @return: A domain name/domain object pair. @raise KeyError: When this dictionary is empty. """ return self.domains.popitem() def update(self, other): """ Update this dictionary with domain name/domain object pairs from another dictionary. When this dictionary contains a domain name which is in the other dictionary, its value will be overwritten. @type other: L{dict} of L{bytes} -> L{IDomain} provider and/or L{bytes} -> L{None} @param other: Another dictionary of domain name/domain object pairs. @rtype: L{None} @return: None. """ return self.domains.update(other) def clear(self): """ Remove all items from this dictionary. @rtype: L{None} @return: None. """ return self.domains.clear() def setdefault(self, key, default): """ Return the domain object associated with the domain name if it is present in this dictionary. Otherwise, set the value for the domain name to the default and return that value. @type key: L{bytes} @param key: A domain name. @type default: L{IDomain} provider @param default: A domain object. @rtype: L{IDomain} provider or L{None} @return: The domain object associated with the domain name. """ return self.domains.setdefault(key, default) @implementer(IDomain) class BounceDomain: """ A domain with no users. This can be used to block off a domain. """ def exists(self, user): """ Raise an exception to indicate that the user does not exist in this domain. @type user: L{User} @param user: A user. @raise SMTPBadRcpt: When the given user does not exist in this domain. """ raise smtp.SMTPBadRcpt(user) def willRelay(self, user, protocol): """ Indicate that this domain will not relay. @type user: L{Address} @param user: The destination address. @type protocol: L{Protocol <twisted.internet.protocol.Protocol>} @param protocol: The protocol over which the message to be relayed is being received. @rtype: L{bool} @return: C{False}. """ return False def addUser(self, user, password): """ Ignore attempts to add a user to this domain. @type user: L{bytes} @param user: A username. @type password: L{bytes} @param password: A password. """ pass def getCredentialsCheckers(self): """ Return no credentials checkers for this domain. @rtype: L{list} @return: The empty list. """ return [] @implementer(smtp.IMessage) class FileMessage: """ A message receiver which delivers a message to a file. @ivar fp: See L{__init__}. @ivar name: See L{__init__}. @ivar finalName: See L{__init__}. """ def __init__(self, fp, name, finalName): """ @type fp: file-like object @param fp: The file in which to store the message while it is being received. @type name: L{bytes} @param name: The full path name of the temporary file. @type finalName: L{bytes} @param finalName: The full path name that should be given to the file holding the message after it has been fully received. """ self.fp = fp self.name = name self.finalName = finalName def lineReceived(self, line): """ Write a received line to the file. @type line: L{bytes} @param line: A received line. """ self.fp.write(line + b"\n") def eomReceived(self): """ At the end of message, rename the file holding the message to its final name. @rtype: L{Deferred} which successfully results in L{bytes} @return: A deferred which returns the final name of the file. """ self.fp.close() os.rename(self.name, self.finalName) return defer.succeed(self.finalName) def connectionLost(self): """ Delete the file holding the partially received message. """ self.fp.close() os.remove(self.name) class MailService(service.MultiService): """ An email service. @type queue: L{Queue} or L{None} @ivar queue: A queue for outgoing messages. @type domains: L{dict} of L{bytes} -> L{IDomain} provider @ivar domains: A mapping of supported domain name to domain object. @type portals: L{dict} of L{bytes} -> L{Portal} @ivar portals: A mapping of domain name to authentication portal. @type aliases: L{None} or L{dict} of L{bytes} -> L{IAlias} provider @ivar aliases: A mapping of domain name to alias. @type smtpPortal: L{Portal} @ivar smtpPortal: A portal for authentication for the SMTP server. @type monitor: L{FileMonitoringService} @ivar monitor: A service to monitor changes to files. """ queue = None domains = None portals = None aliases = None smtpPortal = None def __init__(self): """ Initialize the mail service. """ service.MultiService.__init__(self) # Domains and portals for "client" protocols - POP3, IMAP4, etc self.domains = DomainWithDefaultDict({}, BounceDomain()) self.portals = {} self.monitor = FileMonitoringService() self.monitor.setServiceParent(self) self.smtpPortal = Portal(self) def getPOP3Factory(self): """ Create a POP3 protocol factory. @rtype: L{POP3Factory} @return: A POP3 protocol factory. """ return protocols.POP3Factory(self) def getSMTPFactory(self): """ Create an SMTP protocol factory. @rtype: L{SMTPFactory <protocols.SMTPFactory>} @return: An SMTP protocol factory. """ return protocols.SMTPFactory(self, self.smtpPortal) def getESMTPFactory(self): """ Create an ESMTP protocol factory. @rtype: L{ESMTPFactory <protocols.ESMTPFactory>} @return: An ESMTP protocol factory. """ return protocols.ESMTPFactory(self, self.smtpPortal) def addDomain(self, name, domain): """ Add a domain for which the service will accept email. @type name: L{bytes} @param name: A domain name. @type domain: L{IDomain} provider @param domain: A domain object. """ portal = Portal(domain) map(portal.registerChecker, domain.getCredentialsCheckers()) self.domains[name] = domain self.portals[name] = portal if self.aliases and IAliasableDomain.providedBy(domain): domain.setAliasGroup(self.aliases) def setQueue(self, queue): """ Set the queue for outgoing emails. @type queue: L{Queue} @param queue: A queue for outgoing messages. """ self.queue = queue def requestAvatar(self, avatarId, mind, *interfaces): """ Return a message delivery for an authenticated SMTP user. @type avatarId: L{bytes} @param avatarId: A string which identifies an authenticated user. @type mind: L{None} @param mind: Unused. @type interfaces: n-L{tuple} of C{zope.interface.Interface} @param interfaces: A group of interfaces one of which the avatar must support. @rtype: 3-L{tuple} of (E{1}) L{IMessageDelivery}, (E{2}) L{ESMTPDomainDelivery}, (E{3}) no-argument callable @return: A tuple of the supported interface, a message delivery, and a logout function. @raise NotImplementedError: When the given interfaces do not include L{IMessageDelivery}. """ if smtp.IMessageDelivery in interfaces: a = protocols.ESMTPDomainDelivery(self, avatarId) return smtp.IMessageDelivery, a, lambda: None raise NotImplementedError() def lookupPortal(self, name): """ Find the portal for a domain. @type name: L{bytes} @param name: A domain name. @rtype: L{Portal} @return: A portal. """ return self.portals[name] def defaultPortal(self): """ Return the portal for the default domain. The default domain is named ''. @rtype: L{Portal} @return: The portal for the default domain. """ return self.portals[""] class FileMonitoringService(internet.TimerService): """ A service for monitoring changes to files. @type files: L{list} of L{list} of (E{1}) L{float}, (E{2}) L{bytes}, (E{3}) callable which takes a L{bytes} argument, (E{4}) L{float} @ivar files: Information about files to be monitored. Each list entry provides the following information for a file: interval in seconds between checks, filename, callback function, time of last modification to the file. @type intervals: L{_IntervalDifferentialIterator <twisted.python.util._IntervalDifferentialIterator>} @ivar intervals: Intervals between successive file checks. @type _call: L{IDelayedCall <twisted.internet.interfaces.IDelayedCall>} provider @ivar _call: The next scheduled call to check a file. @type index: L{int} @ivar index: The index of the next file to be checked. """ def __init__(self): """ Initialize the file monitoring service. """ self.files = [] self.intervals = iter(util.IntervalDifferential([], 60)) def startService(self): """ Start the file monitoring service. """ service.Service.startService(self) self._setupMonitor() def _setupMonitor(self): """ Schedule the next monitoring call. """ from twisted.internet import reactor t, self.index = self.intervals.next() self._call = reactor.callLater(t, self._monitor) def stopService(self): """ Stop the file monitoring service. """ service.Service.stopService(self) if self._call: self._call.cancel() self._call = None def monitorFile(self, name, callback, interval=10): """ Start monitoring a file for changes. @type name: L{bytes} @param name: The name of a file to monitor. @type callback: callable which takes a L{bytes} argument @param callback: The function to call when the file has changed. @type interval: L{float} @param interval: The interval in seconds between checks. """ try: mtime = os.path.getmtime(name) except BaseException: mtime = 0 self.files.append([interval, name, callback, mtime]) self.intervals.addInterval(interval) def unmonitorFile(self, name): """ Stop monitoring a file. @type name: L{bytes} @param name: A file name. """ for i in range(len(self.files)): if name == self.files[i][1]: self.intervals.removeInterval(self.files[i][0]) del self.files[i] break def _monitor(self): """ Monitor a file and make a callback if it has changed. """ self._call = None if self.index is not None: name, callback, mtime = self.files[self.index][1:] try: now = os.path.getmtime(name) except BaseException: now = 0 if now > mtime: log.msg(f"{name} changed, notifying listener") self.files[self.index][3] = now callback(name) self._setupMonitor() PK Mb�ZB���� � mail/pop3client.pynu �[��� """ Deprecated POP3 client protocol implementation. Don't use this module directly. Use twisted.mail.pop3 instead. """ import warnings from typing import List from twisted.mail._pop3client import ERR, OK, POP3Client warnings.warn( "twisted.mail.pop3client was deprecated in Twisted 21.2.0. Use twisted.mail.pop3 instead.", DeprecationWarning, stacklevel=2, ) # Fake usage to please pyflakes as we don't to add them to __all__. OK ERR POP3Client __all__: List[str] = [] PK Mb�Zߓ��I} I} mail/interfaces.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Interfaces for L{twisted.mail}. @since: 16.5 """ from zope.interface import Interface class IChallengeResponse(Interface): """ An C{IMAPrev4} authorization challenge mechanism. """ def getChallenge(): """ Return a client challenge. @return: A challenge. @rtype: L{bytes} """ def setResponse(response): """ Extract a username and possibly a password from a response and assign them to C{username} and C{password} instance variables. @param response: A decoded response. @type response: L{bytes} @see: L{credentials.IUsernamePassword} or L{credentials.IUsernameHashedPassword} """ def moreChallenges(): """ Are there more challenges than just the first? If so, callers should challenge clients with the result of L{getChallenge}, and check their response with L{setResponse} in a loop until this returns L{False} @return: Are there more challenges? @rtype: L{bool} """ class IClientAuthentication(Interface): def getName(): """ Return an identifier associated with this authentication scheme. @rtype: L{bytes} """ def challengeResponse(secret, challenge): """ Generate a challenge response string. """ class IServerFactoryPOP3(Interface): """ An interface for querying capabilities of a POP3 server. Any cap_* method may raise L{NotImplementedError} if the particular capability is not supported. If L{cap_EXPIRE()} does not raise L{NotImplementedError}, L{perUserExpiration()} must be implemented, otherwise they are optional. If L{cap_LOGIN_DELAY()} is implemented, L{perUserLoginDelay()} must be implemented, otherwise they are optional. @type challengers: L{dict} of L{bytes} -> L{IUsernameHashedPassword <cred.credentials.IUsernameHashedPassword>} @ivar challengers: A mapping of challenger names to L{IUsernameHashedPassword <cred.credentials.IUsernameHashedPassword>} provider. """ def cap_IMPLEMENTATION(): """ Return a string describing the POP3 server implementation. @rtype: L{bytes} @return: Server implementation information. """ def cap_EXPIRE(): """ Return the minimum number of days messages are retained. @rtype: L{int} or L{None} @return: The minimum number of days messages are retained or none, if the server never deletes messages. """ def perUserExpiration(): """ Indicate whether the message expiration policy differs per user. @rtype: L{bool} @return: C{True} when the message expiration policy differs per user, C{False} otherwise. """ def cap_LOGIN_DELAY(): """ Return the minimum number of seconds between client logins. @rtype: L{int} @return: The minimum number of seconds between client logins. """ def perUserLoginDelay(): """ Indicate whether the login delay period differs per user. @rtype: L{bool} @return: C{True} when the login delay differs per user, C{False} otherwise. """ class IMailboxPOP3(Interface): """ An interface for mailbox access. Message indices are 0-based. @type loginDelay: L{int} @ivar loginDelay: The number of seconds between allowed logins for the user associated with this mailbox. @type messageExpiration: L{int} @ivar messageExpiration: The number of days messages in this mailbox will remain on the server before being deleted. """ def listMessages(index=None): """ Retrieve the size of a message, or, if none is specified, the size of each message in the mailbox. @type index: L{int} or L{None} @param index: The 0-based index of the message. @rtype: L{int}, sequence of L{int}, or L{Deferred <defer.Deferred>} @return: The number of octets in the specified message, or, if an index is not specified, a sequence of the number of octets for all messages in the mailbox or a deferred which fires with one of those. Any value which corresponds to a deleted message is set to 0. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. """ def getMessage(index): """ Retrieve a file containing the contents of a message. @type index: L{int} @param index: The 0-based index of a message. @rtype: file-like object @return: A file containing the message. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. """ def getUidl(index): """ Get a unique identifier for a message. @type index: L{int} @param index: The 0-based index of a message. @rtype: L{bytes} @return: A string of printable characters uniquely identifying the message for all time. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. """ def deleteMessage(index): """ Mark a message for deletion. This must not change the number of messages in this mailbox. Further requests for the size of the deleted message should return 0. Further requests for the message itself may raise an exception. @type index: L{int} @param index: The 0-based index of a message. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. """ def undeleteMessages(): """ Undelete all messages marked for deletion. Any message which can be undeleted should be returned to its original position in the message sequence and retain its original UID. """ def sync(): """ Discard the contents of any message marked for deletion. """ class IDomain(Interface): """ An interface for email domains. """ def exists(user): """ Check whether a user exists in this domain. @type user: L{User} @param user: A user. @rtype: no-argument callable which returns L{IMessageSMTP} provider @return: A function which takes no arguments and returns a message receiver for the user. @raise SMTPBadRcpt: When the given user does not exist in this domain. """ def addUser(user, password): """ Add a user to this domain. @type user: L{bytes} @param user: A username. @type password: L{bytes} @param password: A password. """ def getCredentialsCheckers(): """ Return credentials checkers for this domain. @rtype: L{list} of L{ICredentialsChecker <twisted.cred.checkers.ICredentialsChecker>} provider @return: Credentials checkers for this domain. """ class IAlias(Interface): """ An interface for aliases. """ def createMessageReceiver(): """ Create a message receiver. @rtype: L{IMessageSMTP} provider @return: A message receiver. """ class IAliasableDomain(IDomain): """ An interface for email domains which can be aliased to other domains. """ def setAliasGroup(aliases): """ Set the group of defined aliases for this domain. @type aliases: L{dict} of L{bytes} -> L{IAlias} provider @param aliases: A mapping of domain name to alias. """ def exists(user, memo=None): """ Check whether a user exists in this domain or an alias of it. @type user: L{User} @param user: A user. @type memo: L{None} or L{dict} of L{AliasBase <twisted.mail.alias.AliasBase>} @param memo: A record of the addresses already considered while resolving aliases. The default value should be used by all external code. @rtype: no-argument callable which returns L{IMessageSMTP} provider @return: A function which takes no arguments and returns a message receiver for the user. @raise SMTPBadRcpt: When the given user does not exist in this domain or an alias of it. """ class IMessageDelivery(Interface): def receivedHeader(helo, origin, recipients): """ Generate the Received header for a message. @type helo: 2-L{tuple} of L{bytes} and L{bytes}. @param helo: The argument to the HELO command and the client's IP address. @type origin: L{Address} @param origin: The address the message is from @type recipients: L{list} of L{User} @param recipients: A list of the addresses for which this message is bound. @rtype: L{bytes} @return: The full C{"Received"} header string. """ def validateTo(user): """ Validate the address for which the message is destined. @type user: L{User} @param user: The address to validate. @rtype: no-argument callable @return: A L{Deferred} which becomes, or a callable which takes no arguments and returns an object implementing L{IMessageSMTP}. This will be called and the returned object used to deliver the message when it arrives. @raise SMTPBadRcpt: Raised if messages to the address are not to be accepted. """ def validateFrom(helo, origin): """ Validate the address from which the message originates. @type helo: 2-L{tuple} of L{bytes} and L{bytes}. @param helo: The argument to the HELO command and the client's IP address. @type origin: L{Address} @param origin: The address the message is from @rtype: L{Deferred} or L{Address} @return: C{origin} or a L{Deferred} whose callback will be passed C{origin}. @raise SMTPBadSender: Raised of messages from this address are not to be accepted. """ class IMessageDeliveryFactory(Interface): """ An alternate interface to implement for handling message delivery. It is useful to implement this interface instead of L{IMessageDelivery} directly because it allows the implementor to distinguish between different messages delivery over the same connection. This can be used to optimize delivery of a single message to multiple recipients, something which cannot be done by L{IMessageDelivery} implementors due to their lack of information. """ def getMessageDelivery(): """ Return an L{IMessageDelivery} object. This will be called once per message. """ class IMessageSMTP(Interface): """ Interface definition for messages that can be sent via SMTP. """ def lineReceived(line): """ Handle another line. """ def eomReceived(): """ Handle end of message. return a deferred. The deferred should be called with either: callback(string) or errback(error) @rtype: L{Deferred} """ def connectionLost(): """ Handle message truncated. semantics should be to discard the message """ class IMessageIMAPPart(Interface): def getHeaders(negate, *names): """ Retrieve a group of message headers. @type names: L{tuple} of L{str} @param names: The names of the headers to retrieve or omit. @type negate: L{bool} @param negate: If True, indicates that the headers listed in C{names} should be omitted from the return value, rather than included. @rtype: L{dict} @return: A mapping of header field names to header field values """ def getBodyFile(): """ Retrieve a file object containing only the body of this message. """ def getSize(): """ Retrieve the total size, in octets, of this message. @rtype: L{int} """ def isMultipart(): """ Indicate whether this message has subparts. @rtype: L{bool} """ def getSubPart(part): """ Retrieve a MIME sub-message @type part: L{int} @param part: The number of the part to retrieve, indexed from 0. @raise IndexError: Raised if the specified part does not exist. @raise TypeError: Raised if this message is not multipart. @rtype: Any object implementing L{IMessageIMAPPart}. @return: The specified sub-part. """ class IMessageIMAP(IMessageIMAPPart): def getUID(): """ Retrieve the unique identifier associated with this message. """ def getFlags(): """ Retrieve the flags associated with this message. @rtype: C{iterable} @return: The flags, represented as strings. """ def getInternalDate(): """ Retrieve the date internally associated with this message. @rtype: L{bytes} @return: An RFC822-formatted date string. """ class IMessageIMAPFile(Interface): """ Optional message interface for representing messages as files. If provided by message objects, this interface will be used instead the more complex MIME-based interface. """ def open(): """ Return a file-like object opened for reading. Reading from the returned file will return all the bytes of which this message consists. """ class ISearchableIMAPMailbox(Interface): def search(query, uid): """ Search for messages that meet the given query criteria. If this interface is not implemented by the mailbox, L{IMailboxIMAP.fetch} and various methods of L{IMessageIMAP} will be used instead. Implementations which wish to offer better performance than the default implementation should implement this interface. @type query: L{list} @param query: The search criteria @type uid: L{bool} @param uid: If true, the IDs specified in the query are UIDs; otherwise they are message sequence IDs. @rtype: L{list} or L{Deferred} @return: A list of message sequence numbers or message UIDs which match the search criteria or a L{Deferred} whose callback will be invoked with such a list. @raise IllegalQueryError: Raised when query is not valid. """ class IMailboxIMAPListener(Interface): """ Interface for objects interested in mailbox events """ def modeChanged(writeable): """ Indicates that the write status of a mailbox has changed. @type writeable: L{bool} @param writeable: A true value if write is now allowed, false otherwise. """ def flagsChanged(newFlags): """ Indicates that the flags of one or more messages have changed. @type newFlags: L{dict} @param newFlags: A mapping of message identifiers to tuples of flags now set on that message. """ def newMessages(exists, recent): """ Indicates that the number of messages in a mailbox has changed. @type exists: L{int} or L{None} @param exists: The total number of messages now in this mailbox. If the total number of messages has not changed, this should be L{None}. @type recent: L{int} @param recent: The number of messages now flagged C{\\Recent}. If the number of recent messages has not changed, this should be L{None}. """ class IMessageIMAPCopier(Interface): def copy(messageObject): """ Copy the given message object into this mailbox. The message object will be one which was previously returned by L{IMailboxIMAP.fetch}. Implementations which wish to offer better performance than the default implementation should implement this interface. If this interface is not implemented by the mailbox, L{IMailboxIMAP.addMessage} will be used instead. @rtype: L{Deferred} or L{int} @return: Either the UID of the message or a Deferred which fires with the UID when the copy finishes. """ class IMailboxIMAPInfo(Interface): """ Interface specifying only the methods required for C{listMailboxes}. Implementations can return objects implementing only these methods for return to C{listMailboxes} if it can allow them to operate more efficiently. """ def getFlags(): """ Return the flags defined in this mailbox Flags with the \\ prefix are reserved for use as system flags. @rtype: L{list} of L{str} @return: A list of the flags that can be set on messages in this mailbox. """ def getHierarchicalDelimiter(): """ Get the character which delimits namespaces for in this mailbox. @rtype: L{bytes} """ class IMailboxIMAP(IMailboxIMAPInfo): def getUIDValidity(): """ Return the unique validity identifier for this mailbox. @rtype: L{int} """ def getUIDNext(): """ Return the likely UID for the next message added to this mailbox. @rtype: L{int} """ def getUID(message): """ Return the UID of a message in the mailbox @type message: L{int} @param message: The message sequence number @rtype: L{int} @return: The UID of the message. """ def getMessageCount(): """ Return the number of messages in this mailbox. @rtype: L{int} """ def getRecentCount(): """ Return the number of messages with the 'Recent' flag. @rtype: L{int} """ def getUnseenCount(): """ Return the number of messages with the 'Unseen' flag. @rtype: L{int} """ def isWriteable(): """ Get the read/write status of the mailbox. @rtype: L{int} @return: A true value if write permission is allowed, a false value otherwise. """ def destroy(): """ Called before this mailbox is deleted, permanently. If necessary, all resources held by this mailbox should be cleaned up here. This function _must_ set the \\Noselect flag on this mailbox. """ def requestStatus(names): """ Return status information about this mailbox. Mailboxes which do not intend to do any special processing to generate the return value, C{statusRequestHelper} can be used to build the dictionary by calling the other interface methods which return the data for each name. @type names: Any iterable @param names: The status names to return information regarding. The possible values for each name are: MESSAGES, RECENT, UIDNEXT, UIDVALIDITY, UNSEEN. @rtype: L{dict} or L{Deferred} @return: A dictionary containing status information about the requested names is returned. If the process of looking this information up would be costly, a deferred whose callback will eventually be passed this dictionary is returned instead. """ def addListener(listener): """ Add a mailbox change listener @type listener: Any object which implements C{IMailboxIMAPListener} @param listener: An object to add to the set of those which will be notified when the contents of this mailbox change. """ def removeListener(listener): """ Remove a mailbox change listener @type listener: Any object previously added to and not removed from this mailbox as a listener. @param listener: The object to remove from the set of listeners. @raise ValueError: Raised when the given object is not a listener for this mailbox. """ def addMessage(message, flags, date): """ Add the given message to this mailbox. @type message: A file-like object @param message: The RFC822 formatted message @type flags: Any iterable of L{bytes} @param flags: The flags to associate with this message @type date: L{bytes} @param date: If specified, the date to associate with this message. @rtype: L{Deferred} @return: A deferred whose callback is invoked with the message id if the message is added successfully and whose errback is invoked otherwise. @raise ReadOnlyMailbox: Raised if this Mailbox is not open for read-write. """ def expunge(): """ Remove all messages flagged \\Deleted. @rtype: L{list} or L{Deferred} @return: The list of message sequence numbers which were deleted, or a L{Deferred} whose callback will be invoked with such a list. @raise ReadOnlyMailbox: Raised if this Mailbox is not open for read-write. """ def fetch(messages, uid): """ Retrieve one or more messages. @type messages: C{MessageSet} @param messages: The identifiers of messages to retrieve information about @type uid: L{bool} @param uid: If true, the IDs specified in the query are UIDs; otherwise they are message sequence IDs. @rtype: Any iterable of two-tuples of message sequence numbers and implementors of C{IMessageIMAP}. """ def store(messages, flags, mode, uid): """ Set the flags of one or more messages. @type messages: A MessageSet object with the list of messages requested @param messages: The identifiers of the messages to set the flags of. @type flags: sequence of L{str} @param flags: The flags to set, unset, or add. @type mode: -1, 0, or 1 @param mode: If mode is -1, these flags should be removed from the specified messages. If mode is 1, these flags should be added to the specified messages. If mode is 0, all existing flags should be cleared and these flags should be added. @type uid: L{bool} @param uid: If true, the IDs specified in the query are UIDs; otherwise they are message sequence IDs. @rtype: L{dict} or L{Deferred} @return: A L{dict} mapping message sequence numbers to sequences of L{str} representing the flags set on the message after this operation has been performed, or a L{Deferred} whose callback will be invoked with such a L{dict}. @raise ReadOnlyMailbox: Raised if this mailbox is not open for read-write. """ class ICloseableMailboxIMAP(Interface): """ A supplementary interface for mailboxes which require cleanup on close. Implementing this interface is optional. If it is implemented, the protocol code will call the close method defined whenever a mailbox is closed. """ def close(): """ Close this mailbox. @return: A L{Deferred} which fires when this mailbox has been closed, or None if the mailbox can be closed immediately. """ class IAccountIMAP(Interface): """ Interface for Account classes Implementors of this interface should consider implementing C{INamespacePresenter}. """ def addMailbox(name, mbox=None): """ Add a new mailbox to this account @type name: L{bytes} @param name: The name associated with this mailbox. It may not contain multiple hierarchical parts. @type mbox: An object implementing C{IMailboxIMAP} @param mbox: The mailbox to associate with this name. If L{None}, a suitable default is created and used. @rtype: L{Deferred} or L{bool} @return: A true value if the creation succeeds, or a deferred whose callback will be invoked when the creation succeeds. @raise MailboxException: Raised if this mailbox cannot be added for some reason. This may also be raised asynchronously, if a L{Deferred} is returned. """ def create(pathspec): """ Create a new mailbox from the given hierarchical name. @type pathspec: L{bytes} @param pathspec: The full hierarchical name of a new mailbox to create. If any of the inferior hierarchical names to this one do not exist, they are created as well. @rtype: L{Deferred} or L{bool} @return: A true value if the creation succeeds, or a deferred whose callback will be invoked when the creation succeeds. @raise MailboxException: Raised if this mailbox cannot be added. This may also be raised asynchronously, if a L{Deferred} is returned. """ def select(name, rw=True): """ Acquire a mailbox, given its name. @type name: L{bytes} @param name: The mailbox to acquire @type rw: L{bool} @param rw: If a true value, request a read-write version of this mailbox. If a false value, request a read-only version. @rtype: Any object implementing C{IMailboxIMAP} or L{Deferred} @return: The mailbox object, or a L{Deferred} whose callback will be invoked with the mailbox object. None may be returned if the specified mailbox may not be selected for any reason. """ def delete(name): """ Delete the mailbox with the specified name. @type name: L{bytes} @param name: The mailbox to delete. @rtype: L{Deferred} or L{bool} @return: A true value if the mailbox is successfully deleted, or a L{Deferred} whose callback will be invoked when the deletion completes. @raise MailboxException: Raised if this mailbox cannot be deleted. This may also be raised asynchronously, if a L{Deferred} is returned. """ def rename(oldname, newname): """ Rename a mailbox @type oldname: L{bytes} @param oldname: The current name of the mailbox to rename. @type newname: L{bytes} @param newname: The new name to associate with the mailbox. @rtype: L{Deferred} or L{bool} @return: A true value if the mailbox is successfully renamed, or a L{Deferred} whose callback will be invoked when the rename operation is completed. @raise MailboxException: Raised if this mailbox cannot be renamed. This may also be raised asynchronously, if a L{Deferred} is returned. """ def isSubscribed(name): """ Check the subscription status of a mailbox @type name: L{bytes} @param name: The name of the mailbox to check @rtype: L{Deferred} or L{bool} @return: A true value if the given mailbox is currently subscribed to, a false value otherwise. A L{Deferred} may also be returned whose callback will be invoked with one of these values. """ def subscribe(name): """ Subscribe to a mailbox @type name: L{bytes} @param name: The name of the mailbox to subscribe to @rtype: L{Deferred} or L{bool} @return: A true value if the mailbox is subscribed to successfully, or a Deferred whose callback will be invoked with this value when the subscription is successful. @raise MailboxException: Raised if this mailbox cannot be subscribed to. This may also be raised asynchronously, if a L{Deferred} is returned. """ def unsubscribe(name): """ Unsubscribe from a mailbox @type name: L{bytes} @param name: The name of the mailbox to unsubscribe from @rtype: L{Deferred} or L{bool} @return: A true value if the mailbox is unsubscribed from successfully, or a Deferred whose callback will be invoked with this value when the unsubscription is successful. @raise MailboxException: Raised if this mailbox cannot be unsubscribed from. This may also be raised asynchronously, if a L{Deferred} is returned. """ def listMailboxes(ref, wildcard): """ List all the mailboxes that meet a certain criteria @type ref: L{bytes} @param ref: The context in which to apply the wildcard @type wildcard: L{bytes} @param wildcard: An expression against which to match mailbox names. '*' matches any number of characters in a mailbox name, and '%' matches similarly, but will not match across hierarchical boundaries. @rtype: L{list} of L{tuple} @return: A list of C{(mailboxName, mailboxObject)} which meet the given criteria. C{mailboxObject} should implement either C{IMailboxIMAPInfo} or C{IMailboxIMAP}. A Deferred may also be returned. """ class INamespacePresenter(Interface): def getPersonalNamespaces(): """ Report the available personal namespaces. Typically there should be only one personal namespace. A common name for it is C{\"\"}, and its hierarchical delimiter is usually C{\"/\"}. @rtype: iterable of two-tuples of strings @return: The personal namespaces and their hierarchical delimiters. If no namespaces of this type exist, None should be returned. """ def getSharedNamespaces(): """ Report the available shared namespaces. Shared namespaces do not belong to any individual user but are usually to one or more of them. Examples of shared namespaces might be C{\"#news\"} for a usenet gateway. @rtype: iterable of two-tuples of strings @return: The shared namespaces and their hierarchical delimiters. If no namespaces of this type exist, None should be returned. """ def getUserNamespaces(): """ Report the available user namespaces. These are namespaces that contain folders belonging to other users access to which this account has been granted. @rtype: iterable of two-tuples of strings @return: The user namespaces and their hierarchical delimiters. If no namespaces of this type exist, None should be returned. """ __all__ = [ # IMAP "IAccountIMAP", "ICloseableMailboxIMAP", "IMailboxIMAP", "IMailboxIMAPInfo", "IMailboxIMAPListener", "IMessageIMAP", "IMessageIMAPCopier", "IMessageIMAPFile", "IMessageIMAPPart", "ISearchableIMAPMailbox", "INamespacePresenter", # SMTP "IMessageDelivery", "IMessageDeliveryFactory", "IMessageSMTP", # Domains and aliases "IDomain", "IAlias", "IAliasableDomain", # POP3 "IMailboxPOP3", "IServerFactoryPOP3", # Authentication "IClientAuthentication", ] PK Mb�Zhݓ�Ml Ml mail/maildir.pynu �[��� # -*- test-case-name: twisted.mail.test.test_mail -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Maildir-style mailbox support. """ import io import os import socket import stat from hashlib import md5 from typing import IO from zope.interface import implementer from twisted.cred import checkers, credentials, portal from twisted.cred.error import UnauthorizedLogin from twisted.internet import defer, interfaces, reactor from twisted.mail import mail, pop3, smtp from twisted.persisted import dirdbm from twisted.protocols import basic from twisted.python import failure, log INTERNAL_ERROR = """\ From: Twisted.mail Internals Subject: An Error Occurred An internal server error has occurred. Please contact the server administrator. """ class _MaildirNameGenerator: """ A utility class to generate a unique maildir name. @type n: L{int} @ivar n: A counter used to generate unique integers. @type p: L{int} @ivar p: The ID of the current process. @type s: L{bytes} @ivar s: A representation of the hostname. @ivar _clock: See C{clock} parameter of L{__init__}. """ n = 0 p = os.getpid() s = socket.gethostname().replace("/", r"\057").replace(":", r"\072") def __init__(self, clock): """ @type clock: L{IReactorTime <interfaces.IReactorTime>} provider @param clock: A reactor which will be used to learn the current time. """ self._clock = clock def generate(self): """ Generate a string which is intended to be unique across all calls to this function (across all processes, reboots, etc). Strings returned by earlier calls to this method will compare less than strings returned by later calls as long as the clock provided doesn't go backwards. @rtype: L{bytes} @return: A unique string. """ self.n = self.n + 1 t = self._clock.seconds() seconds = str(int(t)) microseconds = "%07d" % (int((t - int(t)) * 10e6),) return f"{seconds}.M{microseconds}P{self.p}Q{self.n}.{self.s}" _generateMaildirName = _MaildirNameGenerator(reactor).generate def initializeMaildir(dir): """ Create a maildir user directory if it doesn't already exist. @type dir: L{bytes} @param dir: The path name for a user directory. """ dir = os.fsdecode(dir) if not os.path.isdir(dir): os.mkdir(dir, 0o700) for subdir in ["new", "cur", "tmp", ".Trash"]: os.mkdir(os.path.join(dir, subdir), 0o700) for subdir in ["new", "cur", "tmp"]: os.mkdir(os.path.join(dir, ".Trash", subdir), 0o700) # touch open(os.path.join(dir, ".Trash", "maildirfolder"), "w").close() class MaildirMessage(mail.FileMessage): """ A message receiver which adds a header and delivers a message to a file whose name includes the size of the message. @type size: L{int} @ivar size: The number of octets in the message. """ size = None def __init__(self, address, fp, *a, **kw): """ @type address: L{bytes} @param address: The address of the message recipient. @type fp: file-like object @param fp: The file in which to store the message while it is being received. @type a: 2-L{tuple} of (0) L{bytes}, (1) L{bytes} @param a: Positional arguments for L{FileMessage.__init__}. @type kw: L{dict} @param kw: Keyword arguments for L{FileMessage.__init__}. """ header = "Delivered-To: %s\n" % address fp.write(header) self.size = len(header) mail.FileMessage.__init__(self, fp, *a, **kw) def lineReceived(self, line): """ Write a line to the file. @type line: L{bytes} @param line: A received line. """ mail.FileMessage.lineReceived(self, line) self.size += len(line) + 1 def eomReceived(self): """ At the end of message, rename the file holding the message to its final name concatenated with the size of the file. @rtype: L{Deferred <defer.Deferred>} which successfully results in L{bytes} @return: A deferred which returns the name of the file holding the message. """ self.finalName = self.finalName + ",S=%d" % self.size return mail.FileMessage.eomReceived(self) @implementer(mail.IAliasableDomain) class AbstractMaildirDomain: """ An abstract maildir-backed domain. @type alias: L{None} or L{dict} mapping L{bytes} to L{AliasBase} @ivar alias: A mapping of username to alias. @ivar root: See L{__init__}. """ alias = None root = None def __init__(self, service, root): """ @type service: L{MailService} @param service: An email service. @type root: L{bytes} @param root: The maildir root directory. """ self.root = root def userDirectory(self, user): """ Return the maildir directory for a user. @type user: L{bytes} @param user: A username. @rtype: L{bytes} or L{None} @return: The user's mail directory for a valid user. Otherwise, L{None}. """ return None def setAliasGroup(self, alias): """ Set the group of defined aliases for this domain. @type alias: L{dict} mapping L{bytes} to L{IAlias} provider. @param alias: A mapping of domain name to alias. """ self.alias = alias def exists(self, user, memo=None): """ Check whether a user exists in this domain or an alias of it. @type user: L{User} @param user: A user. @type memo: L{None} or L{dict} of L{AliasBase} @param memo: A record of the addresses already considered while resolving aliases. The default value should be used by all external code. @rtype: no-argument callable which returns L{IMessage <smtp.IMessage>} provider. @return: A function which takes no arguments and returns a message receiver for the user. @raises SMTPBadRcpt: When the given user does not exist in this domain or an alias of it. """ if self.userDirectory(user.dest.local) is not None: return lambda: self.startMessage(user) try: a = self.alias[user.dest.local] except BaseException: raise smtp.SMTPBadRcpt(user) else: aliases = a.resolve(self.alias, memo) if aliases: return lambda: aliases log.err("Bad alias configuration: " + str(user)) raise smtp.SMTPBadRcpt(user) def startMessage(self, user): """ Create a maildir message for a user. @type user: L{bytes} @param user: A username. @rtype: L{MaildirMessage} @return: A message receiver for this user. """ if isinstance(user, str): name, domain = user.split("@", 1) else: name, domain = user.dest.local, user.dest.domain dir = self.userDirectory(name) fname = _generateMaildirName() filename = os.path.join(dir, "tmp", fname) fp = open(filename, "w") return MaildirMessage( f"{name}@{domain}", fp, filename, os.path.join(dir, "new", fname) ) def willRelay(self, user, protocol): """ Check whether this domain will relay. @type user: L{Address} @param user: The destination address. @type protocol: L{SMTP} @param protocol: The protocol over which the message to be relayed is being received. @rtype: L{bool} @return: An indication of whether this domain will relay the message to the destination. """ return False def addUser(self, user, password): """ Add a user to this domain. Subclasses should override this method. @type user: L{bytes} @param user: A username. @type password: L{bytes} @param password: A password. """ raise NotImplementedError def getCredentialsCheckers(self): """ Return credentials checkers for this domain. Subclasses should override this method. @rtype: L{list} of L{ICredentialsChecker <checkers.ICredentialsChecker>} provider @return: Credentials checkers for this domain. """ raise NotImplementedError @implementer(interfaces.IConsumer) class _MaildirMailboxAppendMessageTask: """ A task which adds a message to a maildir mailbox. @ivar mbox: See L{__init__}. @type defer: L{Deferred <defer.Deferred>} which successfully returns L{None} @ivar defer: A deferred which fires when the task has completed. @type opencall: L{IDelayedCall <interfaces.IDelayedCall>} provider or L{None} @ivar opencall: A scheduled call to L{prodProducer}. @type msg: file-like object @ivar msg: The message to add. @type tmpname: L{bytes} @ivar tmpname: The pathname of the temporary file holding the message while it is being transferred. @type fh: file @ivar fh: The new maildir file. @type filesender: L{FileSender <basic.FileSender>} @ivar filesender: A file sender which sends the message. @type myproducer: L{IProducer <interfaces.IProducer>} @ivar myproducer: The registered producer. @type streaming: L{bool} @ivar streaming: Indicates whether the registered producer provides a streaming interface. """ osopen = staticmethod(os.open) oswrite = staticmethod(os.write) osclose = staticmethod(os.close) osrename = staticmethod(os.rename) def __init__(self, mbox, msg): """ @type mbox: L{MaildirMailbox} @param mbox: A maildir mailbox. @type msg: L{bytes} or file-like object @param msg: The message to add. """ self.mbox = mbox self.defer = defer.Deferred() self.openCall = None if not hasattr(msg, "read"): msg = io.BytesIO(msg) self.msg = msg def startUp(self): """ Start transferring the message to the mailbox. """ self.createTempFile() if self.fh != -1: self.filesender = basic.FileSender() self.filesender.beginFileTransfer(self.msg, self) def registerProducer(self, producer, streaming): """ Register a producer and start asking it for data if it is non-streaming. @type producer: L{IProducer <interfaces.IProducer>} @param producer: A producer. @type streaming: L{bool} @param streaming: A flag indicating whether the producer provides a streaming interface. """ self.myproducer = producer self.streaming = streaming if not streaming: self.prodProducer() def prodProducer(self): """ Repeatedly prod a non-streaming producer to produce data. """ self.openCall = None if self.myproducer is not None: self.openCall = reactor.callLater(0, self.prodProducer) self.myproducer.resumeProducing() def unregisterProducer(self): """ Finish transferring the message to the mailbox. """ self.myproducer = None self.streaming = None self.osclose(self.fh) self.moveFileToNew() def write(self, data): """ Write data to the maildir file. @type data: L{bytes} @param data: Data to be written to the file. """ try: self.oswrite(self.fh, data) except BaseException: self.fail() def fail(self, err=None): """ Fire the deferred to indicate the task completed with a failure. @type err: L{Failure <failure.Failure>} @param err: The error that occurred. """ if err is None: err = failure.Failure() if self.openCall is not None: self.openCall.cancel() self.defer.errback(err) self.defer = None def moveFileToNew(self): """ Place the message in the I{new/} directory, add it to the mailbox and fire the deferred to indicate that the task has completed successfully. """ while True: newname = os.path.join(self.mbox.path, "new", _generateMaildirName()) try: self.osrename(self.tmpname, newname) break except OSError as e: (err, estr) = e.args import errno # if the newname exists, retry with a new newname. if err != errno.EEXIST: self.fail() newname = None break if newname is not None: self.mbox.list.append(newname) self.defer.callback(None) self.defer = None def createTempFile(self): """ Create a temporary file to hold the message as it is being transferred. """ attr = ( os.O_RDWR | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOINHERIT", 0) | getattr(os, "O_NOFOLLOW", 0) ) tries = 0 self.fh = -1 while True: self.tmpname = os.path.join(self.mbox.path, "tmp", _generateMaildirName()) try: self.fh = self.osopen(self.tmpname, attr, 0o600) return None except OSError: tries += 1 if tries > 500: self.defer.errback( RuntimeError( "Could not create tmp file for %s" % self.mbox.path ) ) self.defer = None return None class MaildirMailbox(pop3.Mailbox): """ A maildir-backed mailbox. @ivar path: See L{__init__}. @type list: L{list} of L{int} or 2-L{tuple} of (0) file-like object, (1) L{bytes} @ivar list: Information about the messages in the mailbox. For undeleted messages, the file containing the message and the full path name of the file are stored. Deleted messages are indicated by 0. @type deleted: L{dict} mapping 2-L{tuple} of (0) file-like object, (1) L{bytes} to L{bytes} @type deleted: A mapping of the information about a file before it was deleted to the full path name of the deleted file in the I{.Trash/} subfolder. """ AppendFactory = _MaildirMailboxAppendMessageTask def __init__(self, path): """ @type path: L{bytes} @param path: The directory name for a maildir mailbox. """ self.path = path self.list = [] self.deleted = {} initializeMaildir(path) for name in ("cur", "new"): for file in os.listdir(os.path.join(path, name)): self.list.append((file, os.path.join(path, name, file))) self.list.sort() self.list = [e[1] for e in self.list] def listMessages(self, i=None): """ Retrieve the size of a message, or, if none is specified, the size of each message in the mailbox. @type i: L{int} or L{None} @param i: The 0-based index of a message. @rtype: L{int} or L{list} of L{int} @return: The number of octets in the specified message, or, if an index is not specified, a list of the number of octets for all messages in the mailbox. Any value which corresponds to a deleted message is set to 0. @raise IndexError: When the index does not correspond to a message in the mailbox. """ if i is None: ret = [] for mess in self.list: if mess: ret.append(os.stat(mess)[stat.ST_SIZE]) else: ret.append(0) return ret return self.list[i] and os.stat(self.list[i])[stat.ST_SIZE] or 0 def getMessage(self, i): """ Retrieve a file-like object with the contents of a message. @type i: L{int} @param i: The 0-based index of a message. @rtype: file-like object @return: A file containing the message. @raise IndexError: When the index does not correspond to a message in the mailbox. """ return open(self.list[i]) def getUidl(self, i): """ Get a unique identifier for a message. @type i: L{int} @param i: The 0-based index of a message. @rtype: L{bytes} @return: A string of printable characters uniquely identifying the message for all time. @raise IndexError: When the index does not correspond to a message in the mailbox. """ # Returning the actual filename is a mistake. Hash it. base = os.path.basename(self.list[i]) return md5(base).hexdigest() def deleteMessage(self, i): """ Mark a message for deletion. Move the message to the I{.Trash/} subfolder so it can be undeleted by an administrator. @type i: L{int} @param i: The 0-based index of a message. @raise IndexError: When the index does not correspond to a message in the mailbox. """ trashFile = os.path.join( self.path, ".Trash", "cur", os.path.basename(self.list[i]) ) os.rename(self.list[i], trashFile) self.deleted[self.list[i]] = trashFile self.list[i] = 0 def undeleteMessages(self): """ Undelete all messages marked for deletion. Move each message marked for deletion from the I{.Trash/} subfolder back to its original position. """ for (real, trash) in self.deleted.items(): try: os.rename(trash, real) except OSError as e: (err, estr) = e.args import errno # If the file has been deleted from disk, oh well! if err != errno.ENOENT: raise # This is a pass else: try: self.list[self.list.index(0)] = real except ValueError: self.list.append(real) self.deleted.clear() def appendMessage(self, txt): """ Add a message to the mailbox. @type txt: L{bytes} or file-like object @param txt: A message to add. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which fires when the message has been added to the mailbox. """ task = self.AppendFactory(self, txt) result = task.defer task.startUp() return result @implementer(pop3.IMailbox) class StringListMailbox: """ An in-memory mailbox. @ivar msgs: See L{__init__}. @type _delete: L{set} of L{int} @ivar _delete: The indices of messages which have been marked for deletion. """ def __init__(self, msgs): """ @type msgs: L{list} of L{bytes} @param msgs: The contents of each message in the mailbox. """ self.msgs = msgs self._delete = set() def listMessages(self, i=None): """ Retrieve the size of a message, or, if none is specified, the size of each message in the mailbox. @type i: L{int} or L{None} @param i: The 0-based index of a message. @rtype: L{int} or L{list} of L{int} @return: The number of octets in the specified message, or, if an index is not specified, a list of the number of octets in each message in the mailbox. Any value which corresponds to a deleted message is set to 0. @raise IndexError: When the index does not correspond to a message in the mailbox. """ if i is None: return [self.listMessages(msg) for msg in range(len(self.msgs))] if i in self._delete: return 0 return len(self.msgs[i]) def getMessage(self, i: int) -> IO[bytes]: """ Return an in-memory file-like object with the contents of a message. @param i: The 0-based index of a message. @return: An in-memory file-like object containing the message. @raise IndexError: When the index does not correspond to a message in the mailbox. """ return io.BytesIO(self.msgs[i]) def getUidl(self, i): """ Get a unique identifier for a message. @type i: L{int} @param i: The 0-based index of a message. @rtype: L{bytes} @return: A hash of the contents of the message at the given index. @raise IndexError: When the index does not correspond to a message in the mailbox. """ return md5(self.msgs[i]).hexdigest() def deleteMessage(self, i): """ Mark a message for deletion. @type i: L{int} @param i: The 0-based index of a message to delete. @raise IndexError: When the index does not correspond to a message in the mailbox. """ self._delete.add(i) def undeleteMessages(self): """ Undelete any messages which have been marked for deletion. """ self._delete = set() def sync(self): """ Discard the contents of any messages marked for deletion. """ for index in self._delete: self.msgs[index] = "" self._delete = set() @implementer(portal.IRealm) class MaildirDirdbmDomain(AbstractMaildirDomain): """ A maildir-backed domain where membership is checked with a L{DirDBM <dirdbm.DirDBM>} database. The directory structure of a MaildirDirdbmDomain is: /passwd <-- a DirDBM directory /USER/{cur, new, del} <-- each user has these three directories @ivar postmaster: See L{__init__}. @type dbm: L{DirDBM <dirdbm.DirDBM>} @ivar dbm: The authentication database for the domain. """ portal = None _credcheckers = None def __init__(self, service, root, postmaster=0): """ @type service: L{MailService} @param service: An email service. @type root: L{bytes} @param root: The maildir root directory. @type postmaster: L{bool} @param postmaster: A flag indicating whether non-existent addresses should be forwarded to the postmaster (C{True}) or bounced (C{False}). """ root = os.fsencode(root) AbstractMaildirDomain.__init__(self, service, root) dbm = os.path.join(root, b"passwd") if not os.path.exists(dbm): os.makedirs(dbm) self.dbm = dirdbm.open(dbm) self.postmaster = postmaster def userDirectory(self, name): """ Return the path to a user's mail directory. @type name: L{bytes} @param name: A username. @rtype: L{bytes} or L{None} @return: The path to the user's mail directory for a valid user. For an invalid user, the path to the postmaster's mailbox if bounces are redirected there. Otherwise, L{None}. """ if name not in self.dbm: if not self.postmaster: return None name = "postmaster" dir = os.path.join(self.root, name) if not os.path.exists(dir): initializeMaildir(dir) return dir def addUser(self, user, password): """ Add a user to this domain by adding an entry in the authentication database and initializing the user's mail directory. @type user: L{bytes} @param user: A username. @type password: L{bytes} @param password: A password. """ self.dbm[user] = password # Ensure it is initialized self.userDirectory(user) def getCredentialsCheckers(self): """ Return credentials checkers for this domain. @rtype: L{list} of L{ICredentialsChecker <checkers.ICredentialsChecker>} provider @return: Credentials checkers for this domain. """ if self._credcheckers is None: self._credcheckers = [DirdbmDatabase(self.dbm)] return self._credcheckers def requestAvatar(self, avatarId, mind, *interfaces): """ Get the mailbox for an authenticated user. The mailbox for the authenticated user will be returned only if the given interfaces include L{IMailbox <pop3.IMailbox>}. Requests for anonymous access will be met with a mailbox containing a message indicating that an internal error has occurred. @type avatarId: L{bytes} or C{twisted.cred.checkers.ANONYMOUS} @param avatarId: A string which identifies a user or an object which signals a request for anonymous access. @type mind: L{None} @param mind: Unused. @type interfaces: n-L{tuple} of C{zope.interface.Interface} @param interfaces: A group of interfaces, one of which the avatar must support. @rtype: 3-L{tuple} of (0) L{IMailbox <pop3.IMailbox>}, (1) L{IMailbox <pop3.IMailbox>} provider, (2) no-argument callable @return: A tuple of the supported interface, a mailbox, and a logout function. @raise NotImplementedError: When the given interfaces do not include L{IMailbox <pop3.IMailbox>}. """ if pop3.IMailbox not in interfaces: raise NotImplementedError("No interface") if avatarId == checkers.ANONYMOUS: mbox = StringListMailbox([INTERNAL_ERROR]) else: mbox = MaildirMailbox(os.path.join(self.root, avatarId)) return (pop3.IMailbox, mbox, lambda: None) @implementer(checkers.ICredentialsChecker) class DirdbmDatabase: """ A credentials checker which authenticates users out of a L{DirDBM <dirdbm.DirDBM>} database. @type dirdbm: L{DirDBM <dirdbm.DirDBM>} @ivar dirdbm: An authentication database. """ # credentialInterfaces is not used by the class credentialInterfaces = ( credentials.IUsernamePassword, credentials.IUsernameHashedPassword, ) def __init__(self, dbm): """ @type dbm: L{DirDBM <dirdbm.DirDBM>} @param dbm: An authentication database. """ self.dirdbm = dbm def requestAvatarId(self, c): """ Authenticate a user and, if successful, return their username. @type c: L{IUsernamePassword <credentials.IUsernamePassword>} or L{IUsernameHashedPassword <credentials.IUsernameHashedPassword>} provider. @param c: Credentials. @rtype: L{bytes} @return: A string which identifies an user. @raise UnauthorizedLogin: When the credentials check fails. """ if c.username in self.dirdbm: if c.checkPassword(self.dirdbm[c.username]): return c.username raise UnauthorizedLogin() PK Mb�Z�;�og� g� mail/pop3.pynu �[��� # -*- test-case-name: twisted.mail.test.test_pop3 -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Post-office Protocol version 3. @author: Glyph Lefkowitz @author: Jp Calderone """ import base64 import binascii import warnings from hashlib import md5 from typing import Optional from zope.interface import implementer from twisted import cred from twisted.internet import defer, interfaces, task from twisted.mail import smtp from twisted.mail._except import POP3ClientError, POP3Error, _POP3MessageDeleted from twisted.mail.interfaces import ( IMailboxPOP3 as IMailbox, IServerFactoryPOP3 as IServerFactory, ) from twisted.protocols import basic, policies from twisted.python import log # Authentication @implementer(cred.credentials.IUsernamePassword) class APOPCredentials: """ Credentials for use in APOP authentication. @ivar magic: See L{__init__} @ivar username: See L{__init__} @ivar digest: See L{__init__} """ def __init__(self, magic, username, digest): """ @type magic: L{bytes} @param magic: The challenge string used to encrypt the password. @type username: L{bytes} @param username: The username associated with these credentials. @type digest: L{bytes} @param digest: An encrypted version of the user's password. Should be generated as an MD5 hash of the challenge string concatenated with the plaintext password. """ self.magic = magic self.username = username self.digest = digest def checkPassword(self, password): """ Validate a plaintext password against the credentials. @type password: L{bytes} @param password: A plaintext password. @rtype: L{bool} @return: C{True} if the credentials represented by this object match the given password, C{False} if they do not. """ seed = self.magic + password myDigest = md5(seed).hexdigest() return myDigest == self.digest class _HeadersPlusNLines: """ A utility class to retrieve the header and some lines of the body of a mail message. @ivar _file: See L{__init__} @ivar _extraLines: See L{__init__} @type linecount: L{int} @ivar linecount: The number of full lines of the message body scanned. @type headers: L{bool} @ivar headers: An indication of which part of the message is being scanned. C{True} for the header and C{False} for the body. @type done: L{bool} @ivar done: A flag indicating when the desired part of the message has been scanned. @type buf: L{bytes} @ivar buf: The portion of the message body that has been scanned, up to C{n} lines. """ def __init__(self, file, extraLines): """ @type file: file-like object @param file: A file containing a mail message. @type extraLines: L{int} @param extraLines: The number of lines of the message body to retrieve. """ self._file = file self._extraLines = extraLines self.linecount = 0 self.headers = 1 self.done = 0 self.buf = b"" def read(self, bytes): """ Scan bytes from the file. @type bytes: L{int} @param bytes: The number of bytes to read from the file. @rtype: L{bytes} @return: Each portion of the header as it is scanned. Then, full lines of the message body as they are scanned. When more than one line of the header and/or body has been scanned, the result is the concatenation of the lines. When the scan results in no full lines, the empty string is returned. """ if self.done: return b"" data = self._file.read(bytes) if not data: return data if self.headers: df, sz = data.find(b"\r\n\r\n"), 4 if df == -1: df, sz = data.find(b"\n\n"), 2 if df != -1: df += sz val = data[:df] data = data[df:] self.linecount = 1 self.headers = 0 else: val = b"" if self.linecount > 0: dsplit = (self.buf + data).split(b"\n") self.buf = dsplit[-1] for ln in dsplit[:-1]: if self.linecount > self._extraLines: self.done = 1 return val val += ln + b"\n" self.linecount += 1 return val else: return data class _IteratorBuffer: """ An iterator which buffers the elements of a container and periodically passes them as input to a writer. @ivar write: See L{__init__}. @ivar memoryBufferSize: See L{__init__}. @type bufSize: L{int} @ivar bufSize: The number of bytes currently in the buffer. @type lines: L{list} of L{bytes} @ivar lines: The buffer, which is a list of strings. @type iterator: iterator which yields L{bytes} @ivar iterator: An iterator over a container of strings. """ bufSize = 0 def __init__(self, write, iterable, memoryBufferSize=None): """ @type write: callable that takes L{list} of L{bytes} @param write: A writer which is a callable that takes a list of strings. @type iterable: iterable which yields L{bytes} @param iterable: An iterable container of strings. @type memoryBufferSize: L{int} or L{None} @param memoryBufferSize: The number of bytes to buffer before flushing the buffer to the writer. """ self.lines = [] self.write = write self.iterator = iter(iterable) if memoryBufferSize is None: memoryBufferSize = 2 ** 16 self.memoryBufferSize = memoryBufferSize def __iter__(self): """ Return an iterator. @rtype: iterator which yields L{bytes} @return: An iterator over strings. """ return self def __next__(self): """ Get the next string from the container, buffer it, and possibly send the buffer to the writer. The contents of the buffer are written when it is full or when no further values are available from the container. @raise StopIteration: When no further values are available from the container. """ try: v = next(self.iterator) except StopIteration: if self.lines: self.write(self.lines) # Drop some references, in case they're edges in a cycle. del self.iterator, self.lines, self.write raise else: if v is not None: self.lines.append(v) self.bufSize += len(v) if self.bufSize > self.memoryBufferSize: self.write(self.lines) self.lines = [] self.bufSize = 0 next = __next__ def iterateLineGenerator(proto, gen): """ Direct the output of an iterator to the transport of a protocol and arrange for iteration to take place. @type proto: L{POP3} @param proto: A POP3 server protocol. @type gen: iterator which yields L{bytes} @param gen: An iterator over strings. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which fires when the iterator finishes. """ coll = _IteratorBuffer(proto.transport.writeSequence, gen) return proto.schedule(coll) def successResponse(response): """ Format an object as a positive response. @type response: stringifyable L{object} @param response: An object with a string representation. @rtype: L{bytes} @return: A positive POP3 response string. """ if not isinstance(response, bytes): response = str(response).encode("utf-8") return b"+OK " + response + b"\r\n" def formatStatResponse(msgs): """ Format a list of message sizes into a STAT response. This generator function is intended to be used with L{Cooperator <twisted.internet.task.Cooperator>}. @type msgs: L{list} of L{int} @param msgs: A list of message sizes. @rtype: L{None} or L{bytes} @return: Yields none until a result is available, then a string that is suitable for use in a STAT response. The string consists of the number of messages and the total size of the messages in octets. """ i = 0 bytes = 0 for size in msgs: i += 1 bytes += size yield None yield successResponse(b"%d %d" % (i, bytes)) def formatListLines(msgs): """ Format a list of message sizes for use in a LIST response. @type msgs: L{list} of L{int} @param msgs: A list of message sizes. @rtype: L{bytes} @return: Yields a series of strings that are suitable for use as scan listings in a LIST response. Each string consists of a message number and its size in octets. """ i = 0 for size in msgs: i += 1 yield b"%d %d\r\n" % (i, size) def formatListResponse(msgs): """ Format a list of message sizes into a complete LIST response. This generator function is intended to be used with L{Cooperator <twisted.internet.task.Cooperator>}. @type msgs: L{list} of L{int} @param msgs: A list of message sizes. @rtype: L{bytes} @return: Yields a series of strings which make up a complete LIST response. """ yield successResponse(b"%d" % (len(msgs),)) yield from formatListLines(msgs) yield b".\r\n" def formatUIDListLines(msgs, getUidl): """ Format a list of message sizes for use in a UIDL response. @param msgs: See L{formatUIDListResponse} @param getUidl: See L{formatUIDListResponse} @rtype: L{bytes} @return: Yields a series of strings that are suitable for use as unique-id listings in a UIDL response. Each string consists of a message number and its unique id. """ for i, m in enumerate(msgs): if m is not None: uid = getUidl(i) if not isinstance(uid, bytes): uid = str(uid).encode("utf-8") yield b"%d %b\r\n" % (i + 1, uid) def formatUIDListResponse(msgs, getUidl): """ Format a list of message sizes into a complete UIDL response. This generator function is intended to be used with L{Cooperator <twisted.internet.task.Cooperator>}. @type msgs: L{list} of L{int} @param msgs: A list of message sizes. @type getUidl: one-argument callable returning bytes @param getUidl: A callable which takes a message index number and returns the UID of the corresponding message in the mailbox. @rtype: L{bytes} @return: Yields a series of strings which make up a complete UIDL response. """ yield successResponse("") yield from formatUIDListLines(msgs, getUidl) yield b".\r\n" @implementer(interfaces.IProducer) class POP3(basic.LineOnlyReceiver, policies.TimeoutMixin): """ A POP3 server protocol. @type portal: L{Portal} @ivar portal: A portal for authentication. @type factory: L{IServerFactory} provider @ivar factory: A server factory which provides an interface for querying capabilities of the server. @type timeOut: L{int} @ivar timeOut: The number of seconds to wait for a command from the client before disconnecting. @type schedule: callable that takes interator and returns L{Deferred <defer.Deferred>} @ivar schedule: A callable that arranges for an iterator to be cooperatively iterated over along with all other iterators which have been passed to it such that runtime is divided between all of them. It returns a deferred which fires when the iterator finishes. @type magic: L{bytes} or L{None} @ivar magic: An APOP challenge. If not set, an APOP challenge string will be generated when a connection is made. @type _userIs: L{bytes} or L{None} @ivar _userIs: The username sent with the USER command. @type _onLogout: no-argument callable or L{None} @ivar _onLogout: The function to be executed when the connection is lost. @type mbox: L{IMailbox} provider @ivar mbox: The mailbox for the authenticated user. @type state: L{bytes} @ivar state: The state which indicates what type of messages are expected from the client. Valid states are 'COMMAND' and 'AUTH' @type blocked: L{None} or L{list} of 2-L{tuple} of (E{1}) L{bytes} (E{2}) L{tuple} of L{bytes} @ivar blocked: A list of blocked commands. While a response to a command is being generated by the server, other commands are blocked. When no command is outstanding, C{blocked} is set to none. Otherwise, it contains a list of information about blocked commands. Each list entry consists of the command and the arguments to the command. @type _highest: L{int} @ivar _highest: The 1-based index of the highest message retrieved. @type _auth: L{IUsernameHashedPassword <cred.credentials.IUsernameHashedPassword>} provider @ivar _auth: Authorization credentials. """ magic: Optional[bytes] = None _userIs = None _onLogout = None AUTH_CMDS = [b"CAPA", b"USER", b"PASS", b"APOP", b"AUTH", b"RPOP", b"QUIT"] portal = None factory = None # The mailbox we're serving mbox = None # Set this pretty low -- POP3 clients are expected to log in, download # everything, and log out. timeOut = 300 state = "COMMAND" # PIPELINE blocked = None # Cooperate and suchlike. schedule = staticmethod(task.coiterate) _highest = 0 def connectionMade(self): """ Send a greeting to the client after the connection has been made. """ if self.magic is None: self.magic = self.generateMagic() self.successResponse(self.magic) self.setTimeout(self.timeOut) if getattr(self.factory, "noisy", True): log.msg("New connection from " + str(self.transport.getPeer())) def connectionLost(self, reason): """ Clean up when the connection has been lost. @type reason: L{Failure} @param reason: The reason the connection was terminated. """ if self._onLogout is not None: self._onLogout() self._onLogout = None self.setTimeout(None) def generateMagic(self): """ Generate an APOP challenge. @rtype: L{bytes} @return: An RFC 822 message id format string. """ return smtp.messageid() def successResponse(self, message=""): """ Send a response indicating success. @type message: stringifyable L{object} @param message: An object whose string representation should be included in the response. """ self.transport.write(successResponse(message)) def failResponse(self, message=b""): """ Send a response indicating failure. @type message: stringifyable L{object} @param message: An object whose string representation should be included in the response. """ if not isinstance(message, bytes): message = str(message).encode("utf-8") self.sendLine(b"-ERR " + message) def lineReceived(self, line): """ Pass a received line to a state machine function. @type line: L{bytes} @param line: A received line. """ self.resetTimeout() getattr(self, "state_" + self.state)(line) def _unblock(self, _): """ Process as many blocked commands as possible. If there are no more blocked commands, set up for the next command to be sent immediately. @type _: L{object} @param _: Ignored. """ commands = self.blocked self.blocked = None while commands and self.blocked is None: cmd, args = commands.pop(0) self.processCommand(cmd, *args) if self.blocked is not None: self.blocked.extend(commands) def state_COMMAND(self, line): """ Handle received lines for the COMMAND state in which commands from the client are expected. @type line: L{bytes} @param line: A received command. """ try: return self.processCommand(*line.split(b" ")) except (ValueError, AttributeError, POP3Error, TypeError) as e: log.err() self.failResponse( b": ".join( [ b"bad protocol or server", e.__class__.__name__.encode("utf-8"), b"".join(e.args), ] ) ) def processCommand(self, command, *args): """ Dispatch a command from the client for handling. @type command: L{bytes} @param command: A POP3 command. @type args: L{tuple} of L{bytes} @param args: Arguments to the command. @raise POP3Error: When the command is invalid or the command requires prior authentication which hasn't been performed. """ if self.blocked is not None: self.blocked.append((command, args)) return command = command.upper() authCmd = command in self.AUTH_CMDS if not self.mbox and not authCmd: raise POP3Error(b"not authenticated yet: cannot do " + command) f = getattr(self, "do_" + command.decode("utf-8"), None) if f: return f(*args) raise POP3Error(b"Unknown protocol command: " + command) def listCapabilities(self): """ Return a list of server capabilities suitable for use in a CAPA response. @rtype: L{list} of L{bytes} @return: A list of server capabilities. """ baseCaps = [ b"TOP", b"USER", b"UIDL", b"PIPELINE", b"CELERITY", b"AUSPEX", b"POTENCE", ] if IServerFactory.providedBy(self.factory): # Oh my god. We can't just loop over a list of these because # each has spectacularly different return value semantics! try: v = self.factory.cap_IMPLEMENTATION() if v and not isinstance(v, bytes): v = str(v).encode("utf-8") except NotImplementedError: pass except BaseException: log.err() else: baseCaps.append(b"IMPLEMENTATION " + v) try: v = self.factory.cap_EXPIRE() if v and not isinstance(v, bytes): v = str(v).encode("utf-8") except NotImplementedError: pass except BaseException: log.err() else: if v is None: v = b"NEVER" if self.factory.perUserExpiration(): if self.mbox: v = str(self.mbox.messageExpiration).encode("utf-8") else: v = v + b" USER" baseCaps.append(b"EXPIRE " + v) try: v = self.factory.cap_LOGIN_DELAY() if v and not isinstance(v, bytes): v = str(v).encode("utf-8") except NotImplementedError: pass except BaseException: log.err() else: if self.factory.perUserLoginDelay(): if self.mbox: v = str(self.mbox.loginDelay).encode("utf-8") else: v = v + b" USER" baseCaps.append(b"LOGIN-DELAY " + v) try: v = self.factory.challengers except AttributeError: pass except BaseException: log.err() else: baseCaps.append(b"SASL " + b" ".join(v.keys())) return baseCaps def do_CAPA(self): """ Handle a CAPA command. Respond with the server capabilities. """ self.successResponse(b"I can do the following:") for cap in self.listCapabilities(): self.sendLine(cap) self.sendLine(b".") def do_AUTH(self, args=None): """ Handle an AUTH command. If the AUTH extension is not supported, send an error response. If an authentication mechanism was not specified in the command, send a list of all supported authentication methods. Otherwise, send an authentication challenge to the client and transition to the AUTH state. @type args: L{bytes} or L{None} @param args: The name of an authentication mechanism. """ if not getattr(self.factory, "challengers", None): self.failResponse(b"AUTH extension unsupported") return if args is None: self.successResponse("Supported authentication methods:") for a in self.factory.challengers: self.sendLine(a.upper()) self.sendLine(b".") return auth = self.factory.challengers.get(args.strip().upper()) if not self.portal or not auth: self.failResponse(b"Unsupported SASL selected") return self._auth = auth() chal = self._auth.getChallenge() self.sendLine(b"+ " + base64.b64encode(chal)) self.state = "AUTH" def state_AUTH(self, line): """ Handle received lines for the AUTH state in which an authentication challenge response from the client is expected. Transition back to the COMMAND state. Check the credentials and complete the authorization process with the L{_cbMailbox} callback function on success or the L{_ebMailbox} and L{_ebUnexpected} errback functions on failure. @type line: L{bytes} @param line: The challenge response. """ self.state = "COMMAND" try: parts = base64.b64decode(line).split(None, 1) except binascii.Error: self.failResponse(b"Invalid BASE64 encoding") else: if len(parts) != 2: self.failResponse(b"Invalid AUTH response") return self._auth.username = parts[0] self._auth.response = parts[1] d = self.portal.login(self._auth, None, IMailbox) d.addCallback(self._cbMailbox, parts[0]) d.addErrback(self._ebMailbox) d.addErrback(self._ebUnexpected) def do_APOP(self, user, digest): """ Handle an APOP command. Perform APOP authentication and complete the authorization process with the L{_cbMailbox} callback function on success or the L{_ebMailbox} and L{_ebUnexpected} errback functions on failure. @type user: L{bytes} @param user: A username. @type digest: L{bytes} @param digest: An MD5 digest string. """ d = defer.maybeDeferred(self.authenticateUserAPOP, user, digest) d.addCallbacks( self._cbMailbox, self._ebMailbox, callbackArgs=(user,) ).addErrback(self._ebUnexpected) def _cbMailbox(self, result, user): """ Complete successful authentication. Save the mailbox and logout function for the authenticated user and send a successful response to the client. @type result: C{tuple} @param result: The first item of the tuple is a C{zope.interface.Interface} which is the interface supported by the avatar. The second item of the tuple is a L{IMailbox} provider which is the mailbox for the authenticated user. The third item of the tuple is a no-argument callable which is a function to be invoked when the session is terminated. @type user: L{bytes} @param user: The user being authenticated. """ (interface, avatar, logout) = result if interface is not IMailbox: self.failResponse(b"Authentication failed") log.err("_cbMailbox() called with an interface other than IMailbox") return self.mbox = avatar self._onLogout = logout self.successResponse("Authentication succeeded") if getattr(self.factory, "noisy", True): log.msg(b"Authenticated login for " + user) def _ebMailbox(self, failure): """ Handle an expected authentication failure. Send an appropriate error response for a L{LoginDenied} or L{LoginFailed} authentication failure. @type failure: L{Failure} @param failure: The authentication error. """ failure = failure.trap(cred.error.LoginDenied, cred.error.LoginFailed) if issubclass(failure, cred.error.LoginDenied): self.failResponse("Access denied: " + str(failure)) elif issubclass(failure, cred.error.LoginFailed): self.failResponse(b"Authentication failed") if getattr(self.factory, "noisy", True): log.msg("Denied login attempt from " + str(self.transport.getPeer())) def _ebUnexpected(self, failure): """ Handle an unexpected authentication failure. Send an error response for an unexpected authentication failure. @type failure: L{Failure} @param failure: The authentication error. """ self.failResponse("Server error: " + failure.getErrorMessage()) log.err(failure) def do_USER(self, user): """ Handle a USER command. Save the username and send a successful response prompting the client for the password. @type user: L{bytes} @param user: A username. """ self._userIs = user self.successResponse(b"USER accepted, send PASS") def do_PASS(self, password, *words): """ Handle a PASS command. If a USER command was previously received, authenticate the user and complete the authorization process with the L{_cbMailbox} callback function on success or the L{_ebMailbox} and L{_ebUnexpected} errback functions on failure. If a USER command was not previously received, send an error response. @type password: L{bytes} @param password: A password. @type words: L{tuple} of L{bytes} @param words: Other parts of the password split by spaces. """ if self._userIs is None: self.failResponse(b"USER required before PASS") return user = self._userIs self._userIs = None password = b" ".join((password,) + words) d = defer.maybeDeferred(self.authenticateUserPASS, user, password) d.addCallbacks( self._cbMailbox, self._ebMailbox, callbackArgs=(user,) ).addErrback(self._ebUnexpected) def _longOperation(self, d): """ Stop timeouts and block further command processing while a long operation completes. @type d: L{Deferred <defer.Deferred>} @param d: A deferred which triggers at the completion of a long operation. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which triggers after command processing resumes and timeouts restart after the completion of a long operation. """ timeOut = self.timeOut self.setTimeout(None) self.blocked = [] d.addCallback(self._unblock) d.addCallback(lambda ign: self.setTimeout(timeOut)) return d def _coiterate(self, gen): """ Direct the output of an iterator to the transport and arrange for iteration to take place. @type gen: iterable which yields L{bytes} @param gen: An iterator over strings. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which fires when the iterator finishes. """ return self.schedule(_IteratorBuffer(self.transport.writeSequence, gen)) def do_STAT(self): """ Handle a STAT command. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which triggers after the response to the STAT command has been issued. """ d = defer.maybeDeferred(self.mbox.listMessages) def cbMessages(msgs): return self._coiterate(formatStatResponse(msgs)) def ebMessages(err): self.failResponse(err.getErrorMessage()) log.msg("Unexpected do_STAT failure:") log.err(err) return self._longOperation(d.addCallbacks(cbMessages, ebMessages)) def do_LIST(self, i=None): """ Handle a LIST command. @type i: L{bytes} or L{None} @param i: A 1-based message index. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which triggers after the response to the LIST command has been issued. """ if i is None: d = defer.maybeDeferred(self.mbox.listMessages) def cbMessages(msgs): return self._coiterate(formatListResponse(msgs)) def ebMessages(err): self.failResponse(err.getErrorMessage()) log.msg("Unexpected do_LIST failure:") log.err(err) return self._longOperation(d.addCallbacks(cbMessages, ebMessages)) else: try: i = int(i) if i < 1: raise ValueError() except ValueError: if not isinstance(i, bytes): i = str(i).encode("utf-8") self.failResponse(b"Invalid message-number: " + i) else: d = defer.maybeDeferred(self.mbox.listMessages, i - 1) def cbMessage(msg): self.successResponse(b"%d %d" % (i, msg)) def ebMessage(err): errcls = err.check(ValueError, IndexError) if errcls is not None: if errcls is IndexError: # IndexError was supported for a while, but really # shouldn't be. One error condition, one exception # type. See ticket #6669. warnings.warn( "twisted.mail.pop3.IMailbox.listMessages may " "not raise IndexError for out-of-bounds " "message numbers: raise ValueError instead.", PendingDeprecationWarning, ) invalidNum = i if invalidNum and not isinstance(invalidNum, bytes): invalidNum = str(invalidNum).encode("utf-8") self.failResponse(b"Invalid message-number: " + invalidNum) else: self.failResponse(err.getErrorMessage()) log.msg("Unexpected do_LIST failure:") log.err(err) d.addCallbacks(cbMessage, ebMessage) return self._longOperation(d) def do_UIDL(self, i=None): """ Handle a UIDL command. @type i: L{bytes} or L{None} @param i: A 1-based message index. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which triggers after the response to the UIDL command has been issued. """ if i is None: d = defer.maybeDeferred(self.mbox.listMessages) def cbMessages(msgs): return self._coiterate( formatUIDListResponse(msgs, self.mbox.getUidl), ) def ebMessages(err): self.failResponse(err.getErrorMessage()) log.msg("Unexpected do_UIDL failure:") log.err(err) return self._longOperation(d.addCallbacks(cbMessages, ebMessages)) else: try: i = int(i) if i < 1: raise ValueError() except ValueError: self.failResponse("Bad message number argument") else: try: msg = self.mbox.getUidl(i - 1) except IndexError: # XXX TODO See above comment regarding IndexError. warnings.warn( "twisted.mail.pop3.IMailbox.getUidl may not " "raise IndexError for out-of-bounds message numbers: " "raise ValueError instead.", PendingDeprecationWarning, ) self.failResponse("Bad message number argument") except ValueError: self.failResponse("Bad message number argument") else: if not isinstance(msg, bytes): msg = str(msg).encode("utf-8") self.successResponse(msg) def _getMessageFile(self, i): """ Retrieve the size and contents of a message. @type i: L{bytes} @param i: A 1-based message index. @rtype: L{Deferred <defer.Deferred>} which successfully fires with 2-L{tuple} of (E{1}) L{int}, (E{2}) file-like object @return: A deferred which successfully fires with the size of the message and a file containing the contents of the message. """ try: msg = int(i) - 1 if msg < 0: raise ValueError() except ValueError: self.failResponse("Bad message number argument") return defer.succeed(None) sizeDeferred = defer.maybeDeferred(self.mbox.listMessages, msg) def cbMessageSize(size): if not size: return defer.fail(_POP3MessageDeleted()) fileDeferred = defer.maybeDeferred(self.mbox.getMessage, msg) fileDeferred.addCallback(lambda fObj: (size, fObj)) return fileDeferred def ebMessageSomething(err): errcls = err.check(_POP3MessageDeleted, ValueError, IndexError) if errcls is _POP3MessageDeleted: self.failResponse("message deleted") elif errcls in (ValueError, IndexError): if errcls is IndexError: # XXX TODO See above comment regarding IndexError. warnings.warn( "twisted.mail.pop3.IMailbox.listMessages may not " "raise IndexError for out-of-bounds message numbers: " "raise ValueError instead.", PendingDeprecationWarning, ) self.failResponse("Bad message number argument") else: log.msg("Unexpected _getMessageFile failure:") log.err(err) return None sizeDeferred.addCallback(cbMessageSize) sizeDeferred.addErrback(ebMessageSomething) return sizeDeferred def _sendMessageContent(self, i, fpWrapper, successResponse): """ Send the contents of a message. @type i: L{bytes} @param i: A 1-based message index. @type fpWrapper: callable that takes a file-like object and returns a file-like object @param fpWrapper: @type successResponse: callable that takes L{int} and returns L{bytes} @param successResponse: @rtype: L{Deferred} @return: A deferred which triggers after the message has been sent. """ d = self._getMessageFile(i) def cbMessageFile(info): if info is None: # Some error occurred - a failure response has been sent # already, just give up. return self._highest = max(self._highest, int(i)) resp, fp = info fp = fpWrapper(fp) self.successResponse(successResponse(resp)) s = basic.FileSender() d = s.beginFileTransfer(fp, self.transport, self.transformChunk) def cbFileTransfer(lastsent): if lastsent != b"\n": line = b"\r\n." else: line = b"." self.sendLine(line) def ebFileTransfer(err): self.transport.loseConnection() log.msg("Unexpected error in _sendMessageContent:") log.err(err) d.addCallback(cbFileTransfer) d.addErrback(ebFileTransfer) return d return self._longOperation(d.addCallback(cbMessageFile)) def do_TOP(self, i, size): """ Handle a TOP command. @type i: L{bytes} @param i: A 1-based message index. @type size: L{bytes} @param size: The number of lines of the message to retrieve. @rtype: L{Deferred} @return: A deferred which triggers after the response to the TOP command has been issued. """ try: size = int(size) if size < 0: raise ValueError except ValueError: self.failResponse("Bad line count argument") else: return self._sendMessageContent( i, lambda fp: _HeadersPlusNLines(fp, size), lambda size: "Top of message follows", ) def do_RETR(self, i): """ Handle a RETR command. @type i: L{bytes} @param i: A 1-based message index. @rtype: L{Deferred} @return: A deferred which triggers after the response to the RETR command has been issued. """ return self._sendMessageContent(i, lambda fp: fp, lambda size: "%d" % (size,)) def transformChunk(self, chunk): """ Transform a chunk of a message to POP3 message format. Make sure each line ends with C{'\\r\\n'} and byte-stuff the termination character (C{'.'}) by adding an extra one when one appears at the beginning of a line. @type chunk: L{bytes} @param chunk: A string to transform. @rtype: L{bytes} @return: The transformed string. """ return chunk.replace(b"\n", b"\r\n").replace(b"\r\n.", b"\r\n..") def finishedFileTransfer(self, lastsent): """ Send the termination sequence. @type lastsent: L{bytes} @param lastsent: The last character of the file. """ if lastsent != b"\n": line = b"\r\n." else: line = b"." self.sendLine(line) def do_DELE(self, i): """ Handle a DELE command. Mark a message for deletion and issue a successful response. @type i: L{int} @param i: A 1-based message index. """ i = int(i) - 1 self.mbox.deleteMessage(i) self.successResponse() def do_NOOP(self): """ Handle a NOOP command. Do nothing but issue a successful response. """ self.successResponse() def do_RSET(self): """ Handle a RSET command. Unmark any messages that have been flagged for deletion. """ try: self.mbox.undeleteMessages() except BaseException: log.err() self.failResponse() else: self._highest = 0 self.successResponse() def do_LAST(self): """ Handle a LAST command. Respond with the 1-based index of the highest retrieved message. """ self.successResponse(self._highest) def do_RPOP(self, user): """ Handle an RPOP command. RPOP is not supported. Send an error response. @type user: L{bytes} @param user: A username. """ self.failResponse("permission denied, sucker") def do_QUIT(self): """ Handle a QUIT command. Remove any messages marked for deletion, issue a successful response, and drop the connection. """ if self.mbox: self.mbox.sync() self.successResponse() self.transport.loseConnection() def authenticateUserAPOP(self, user, digest): """ Perform APOP authentication. @type user: L{bytes} @param user: The name of the user attempting to log in. @type digest: L{bytes} @param digest: The challenge response. @rtype: L{Deferred <defer.Deferred>} which successfully results in 3-L{tuple} of (E{1}) L{IMailbox <pop3.IMailbox>}, (E{2}) L{IMailbox <pop3.IMailbox>} provider, (E{3}) no-argument callable @return: A deferred which fires when authentication is complete. If successful, it returns an L{IMailbox <pop3.IMailbox>} interface, a mailbox, and a function to be invoked with the session is terminated. If authentication fails, the deferred fails with an L{UnathorizedLogin <cred.error.UnauthorizedLogin>} error. @raise cred.error.UnauthorizedLogin: When authentication fails. """ if self.portal is not None: return self.portal.login( APOPCredentials(self.magic, user, digest), None, IMailbox ) raise cred.error.UnauthorizedLogin() def authenticateUserPASS(self, user, password): """ Perform authentication for a username/password login. @type user: L{bytes} @param user: The name of the user attempting to log in. @type password: L{bytes} @param password: The password to authenticate with. @rtype: L{Deferred <defer.Deferred>} which successfully results in 3-L{tuple} of (E{1}) L{IMailbox <pop3.IMailbox>}, (E{2}) L{IMailbox <pop3.IMailbox>} provider, (E{3}) no-argument callable @return: A deferred which fires when authentication is complete. If successful, it returns a L{pop3.IMailbox} interface, a mailbox, and a function to be invoked with the session is terminated. If authentication fails, the deferred fails with an L{UnathorizedLogin <cred.error.UnauthorizedLogin>} error. @raise cred.error.UnauthorizedLogin: When authentication fails. """ if self.portal is not None: return self.portal.login( cred.credentials.UsernamePassword(user, password), None, IMailbox ) raise cred.error.UnauthorizedLogin() def stopProducing(self): # IProducer.stopProducing raise NotImplementedError() @implementer(IMailbox) class Mailbox: """ A base class for mailboxes. """ def listMessages(self, i=None): """ Retrieve the size of a message, or, if none is specified, the size of each message in the mailbox. @type i: L{int} or L{None} @param i: The 0-based index of the message. @rtype: L{int}, sequence of L{int}, or L{Deferred <defer.Deferred>} @return: The number of octets in the specified message, or, if an index is not specified, a sequence of the number of octets for all messages in the mailbox or a deferred which fires with one of those. Any value which corresponds to a deleted message is set to 0. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. """ return [] def getMessage(self, i): """ Retrieve a file containing the contents of a message. @type i: L{int} @param i: The 0-based index of a message. @rtype: file-like object @return: A file containing the message. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. """ raise ValueError def getUidl(self, i): """ Get a unique identifier for a message. @type i: L{int} @param i: The 0-based index of a message. @rtype: L{bytes} @return: A string of printable characters uniquely identifying the message for all time. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. """ raise ValueError def deleteMessage(self, i): """ Mark a message for deletion. This must not change the number of messages in this mailbox. Further requests for the size of the deleted message should return 0. Further requests for the message itself may raise an exception. @type i: L{int} @param i: The 0-based index of a message. @raise ValueError or IndexError: When the index does not correspond to a message in the mailbox. The use of ValueError is preferred. """ raise ValueError def undeleteMessages(self): """ Undelete all messages marked for deletion. Any message which can be undeleted should be returned to its original position in the message sequence and retain its original UID. """ pass def sync(self): """ Discard the contents of any message marked for deletion. """ pass NONE, SHORT, FIRST_LONG, LONG = range(4) NEXT = {} NEXT[NONE] = NONE NEXT[SHORT] = NONE NEXT[FIRST_LONG] = LONG NEXT[LONG] = NONE class POP3Client(basic.LineOnlyReceiver): """ A POP3 client protocol. @type mode: L{int} @ivar mode: The type of response expected from the server. Choices include none (0), a one line response (1), the first line of a multi-line response (2), and subsequent lines of a multi-line response (3). @type command: L{bytes} @ivar command: The command most recently sent to the server. @type welcomeRe: L{Pattern <re.Pattern.search>} @ivar welcomeRe: A regular expression which matches the APOP challenge in the server greeting. @type welcomeCode: L{bytes} @ivar welcomeCode: The APOP challenge passed in the server greeting. """ mode = SHORT command = b"WELCOME" import re welcomeRe = re.compile(b"<(.*)>") def __init__(self): """ Issue deprecation warning. """ import warnings warnings.warn( "twisted.mail.pop3.POP3Client is deprecated, " "please use twisted.mail.pop3.AdvancedPOP3Client " "instead.", DeprecationWarning, stacklevel=3, ) def sendShort(self, command, params=None): """ Send a POP3 command to which a short response is expected. @type command: L{bytes} @param command: A POP3 command. @type params: stringifyable L{object} or L{None} @param params: Command arguments. """ if params is not None: if not isinstance(params, bytes): params = str(params).encode("utf-8") self.sendLine(command + b" " + params) else: self.sendLine(command) self.command = command self.mode = SHORT def sendLong(self, command, params): """ Send a POP3 command to which a long response is expected. @type command: L{bytes} @param command: A POP3 command. @type params: stringifyable L{object} @param params: Command arguments. """ if params: if not isinstance(params, bytes): params = str(params).encode("utf-8") self.sendLine(command + b" " + params) else: self.sendLine(command) self.command = command self.mode = FIRST_LONG def handle_default(self, line): """ Handle responses from the server for which no other handler exists. @type line: L{bytes} @param line: A received line. """ if line[:-4] == b"-ERR": self.mode = NONE def handle_WELCOME(self, line): """ Handle a server response which is expected to be a server greeting. @type line: L{bytes} @param line: A received line. """ code, data = line.split(b" ", 1) if code != b"+OK": self.transport.loseConnection() else: m = self.welcomeRe.match(line) if m: self.welcomeCode = m.group(1) def _dispatch(self, command, default, *args): """ Dispatch a response from the server for handling. Command X is dispatched to handle_X() if it exists. If not, it is dispatched to the default handler. @type command: L{bytes} @param command: The command. @type default: callable that takes L{bytes} or L{None} @param default: The default handler. @type args: L{tuple} or L{None} @param args: Arguments to the handler function. """ try: method = getattr(self, "handle_" + command.decode("utf-8"), default) if method is not None: method(*args) except BaseException: log.err() def lineReceived(self, line): """ Dispatch a received line for processing. The choice of function to handle the received line is based on the type of response expected to the command sent to the server and how much of that response has been received. An expected one line response to command X is handled by handle_X(). The first line of a multi-line response to command X is also handled by handle_X(). Subsequent lines of the multi-line response are handled by handle_X_continue() except for the last line which is handled by handle_X_end(). @type line: L{bytes} @param line: A received line. """ if self.mode == SHORT or self.mode == FIRST_LONG: self.mode = NEXT[self.mode] self._dispatch(self.command, self.handle_default, line) elif self.mode == LONG: if line == b".": self.mode = NEXT[self.mode] self._dispatch(self.command + b"_end", None) return if line[:1] == b".": line = line[1:] self._dispatch(self.command + b"_continue", None, line) def apopAuthenticate(self, user, password, magic): """ Perform an authenticated login. @type user: L{bytes} @param user: The username with which to log in. @type password: L{bytes} @param password: The password with which to log in. @type magic: L{bytes} @param magic: The challenge provided by the server. """ digest = md5(magic + password).hexdigest().encode("ascii") self.apop(user, digest) def apop(self, user, digest): """ Send an APOP command to perform authenticated login. @type user: L{bytes} @param user: The username with which to log in. @type digest: L{bytes} @param digest: The challenge response with which to authenticate. """ self.sendLong(b"APOP", b" ".join((user, digest))) def retr(self, i): """ Send a RETR command to retrieve a message from the server. @type i: L{int} or L{bytes} @param i: A 0-based message index. """ self.sendLong(b"RETR", i) def dele(self, i): """ Send a DELE command to delete a message from the server. @type i: L{int} or L{bytes} @param i: A 0-based message index. """ self.sendShort(b"DELE", i) def list(self, i=""): """ Send a LIST command to retrieve the size of a message or, if no message is specified, the sizes of all messages. @type i: L{int} or L{bytes} @param i: A 0-based message index or the empty string to specify all messages. """ self.sendLong(b"LIST", i) def uidl(self, i=""): """ Send a UIDL command to retrieve the unique identifier of a message or, if no message is specified, the unique identifiers of all messages. @type i: L{int} or L{bytes} @param i: A 0-based message index or the empty string to specify all messages. """ self.sendLong(b"UIDL", i) def user(self, name): """ Send a USER command to perform the first half of a plaintext login. @type name: L{bytes} @param name: The username with which to log in. """ self.sendShort(b"USER", name) def password(self, password): """ Perform the second half of a plaintext login. @type password: L{bytes} @param password: The plaintext password with which to authenticate. """ self.sendShort(b"PASS", password) pass_ = password def quit(self): """ Send a QUIT command to disconnect from the server. """ self.sendShort(b"QUIT") from twisted.mail._except import ( InsecureAuthenticationDisallowed, LineTooLong, ServerErrorResponse, TLSError, TLSNotSupportedError, ) from twisted.mail._pop3client import POP3Client as AdvancedPOP3Client __all__ = [ # Interfaces "IMailbox", "IServerFactory", # Exceptions "POP3Error", "POP3ClientError", "InsecureAuthenticationDisallowed", "ServerErrorResponse", "LineTooLong", "TLSError", "TLSNotSupportedError", # Protocol classes "POP3", "POP3Client", "AdvancedPOP3Client", # Misc "APOPCredentials", "Mailbox", ] PK Mb�Z� j d� d� mail/relaymanager.pynu �[��� # -*- test-case-name: twisted.mail.test.test_mail -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Infrastructure for relaying mail through a smart host. Traditional peer-to-peer email has been increasingly replaced by smart host configurations. Instead of sending mail directly to the recipient, a sender sends mail to a smart host. The smart host finds the mail exchange server for the recipient and sends on the message. """ import email.utils import os import pickle import time from typing import Type from twisted.application import internet from twisted.internet import protocol from twisted.internet.defer import Deferred, DeferredList from twisted.internet.error import DNSLookupError from twisted.internet.protocol import connectionDone from twisted.mail import bounce, relay, smtp from twisted.python import log from twisted.python.failure import Failure class ManagedRelayerMixin: """ SMTP Relayer which notifies a manager Notify the manager about successful mail, failed mail and broken connections """ def __init__(self, manager): self.manager = manager @property def factory(self): return self._factory @factory.setter def factory(self, value): self._factory = value def sentMail(self, code, resp, numOk, addresses, log): """ called when e-mail has been sent we will always get 0 or 1 addresses. """ message = self.names[0] if code in smtp.SUCCESS: self.manager.notifySuccess(self.factory, message) else: self.manager.notifyFailure(self.factory, message) del self.messages[0] del self.names[0] def connectionLost(self, reason: Failure = connectionDone): """ called when connection is broken notify manager we will try to send no more e-mail """ self.manager.notifyDone(self.factory) class SMTPManagedRelayer(ManagedRelayerMixin, relay.SMTPRelayer): # type: ignore[misc] """ An SMTP managed relayer. This managed relayer is an SMTP client which is responsible for sending a set of messages and keeping an attempt manager informed about its progress. @type factory: L{SMTPManagedRelayerFactory} @ivar factory: The factory that created this relayer. This must be set by the factory. """ def __init__(self, messages, manager, *args, **kw): """ @type messages: L{list} of L{bytes} @param messages: The base filenames of messages to be relayed. @type manager: L{_AttemptManager} @param manager: An attempt manager. @type args: 1-L{tuple} of (0) L{bytes} or 2-L{tuple} of (0) L{bytes}, (1) L{int} @param args: Positional arguments for L{SMTPClient.__init__} @type kw: L{dict} @param kw: Keyword arguments for L{SMTPClient.__init__} """ ManagedRelayerMixin.__init__(self, manager) relay.SMTPRelayer.__init__(self, messages, *args, **kw) class ESMTPManagedRelayer(ManagedRelayerMixin, relay.ESMTPRelayer): # type: ignore[misc] """ An ESMTP managed relayer. This managed relayer is an ESMTP client which is responsible for sending a set of messages and keeping an attempt manager informed about its progress. """ def __init__(self, messages, manager, *args, **kw): """ @type messages: L{list} of L{bytes} @param messages: The base filenames of messages to be relayed. @type manager: L{_AttemptManager} @param manager: An attempt manager. @type args: 3-L{tuple} of (0) L{bytes}, (1) L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>}, (2) L{bytes} or 4-L{tuple} of (0) L{bytes}, (1) L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>}, (2) L{bytes}, (3) L{int} @param args: Positional arguments for L{ESMTPClient.__init__} @type kw: L{dict} @param kw: Keyword arguments for L{ESMTPClient.__init__} """ ManagedRelayerMixin.__init__(self, manager) relay.ESMTPRelayer.__init__(self, messages, *args, **kw) class SMTPManagedRelayerFactory(protocol.ClientFactory): """ A factory to create an L{SMTPManagedRelayer}. This factory creates a managed relayer which relays a set of messages over SMTP and informs an attempt manager of its progress. @ivar messages: See L{__init__} @ivar manager: See L{__init__} @type protocol: callable which returns L{SMTPManagedRelayer} @ivar protocol: A callable which returns a managed relayer for SMTP. See L{SMTPManagedRelayer.__init__} for parameters to the callable. @type pArgs: 1-L{tuple} of (0) L{bytes} or 2-L{tuple} of (0) L{bytes}, (1), L{int} @ivar pArgs: Positional arguments for L{SMTPClient.__init__} @type pKwArgs: L{dict} @ivar pKwArgs: Keyword arguments for L{SMTPClient.__init__} """ protocol: "Type[protocol.Protocol]" = SMTPManagedRelayer def __init__(self, messages, manager, *args, **kw): """ @type messages: L{list} of L{bytes} @param messages: The base filenames of messages to be relayed. @type manager: L{_AttemptManager} @param manager: An attempt manager. @type args: 1-L{tuple} of (0) L{bytes} or 2-L{tuple} of (0) L{bytes}, (1), L{int} @param args: Positional arguments for L{SMTPClient.__init__} @type kw: L{dict} @param kw: Keyword arguments for L{SMTPClient.__init__} """ self.messages = messages self.manager = manager self.pArgs = args self.pKwArgs = kw def buildProtocol(self, addr): """ Create an L{SMTPManagedRelayer}. @type addr: L{IAddress <twisted.internet.interfaces.IAddress>} provider @param addr: The address of the SMTP server. @rtype: L{SMTPManagedRelayer} @return: A managed relayer for SMTP. """ protocol = self.protocol( self.messages, self.manager, *self.pArgs, **self.pKwArgs ) protocol.factory = self return protocol def clientConnectionFailed(self, connector, reason): """ Notify the attempt manager that a connection could not be established. @type connector: L{IConnector <twisted.internet.interfaces.IConnector>} provider @param connector: A connector. @type reason: L{Failure} @param reason: The reason the connection attempt failed. """ self.manager.notifyNoConnection(self) self.manager.notifyDone(self) class ESMTPManagedRelayerFactory(SMTPManagedRelayerFactory): """ A factory to create an L{ESMTPManagedRelayer}. This factory creates a managed relayer which relays a set of messages over ESMTP and informs an attempt manager of its progress. @type protocol: callable which returns L{ESMTPManagedRelayer} @ivar protocol: A callable which returns a managed relayer for ESMTP. See L{ESMTPManagedRelayer.__init__} for parameters to the callable. @ivar secret: See L{__init__} @ivar contextFactory: See L{__init__} """ protocol = ESMTPManagedRelayer def __init__(self, messages, manager, secret, contextFactory, *args, **kw): """ @type messages: L{list} of L{bytes} @param messages: The base filenames of messages to be relayed. @type manager: L{_AttemptManager} @param manager: An attempt manager. @type secret: L{bytes} @param secret: A string for the authentication challenge response. @type contextFactory: L{None} or L{ClientContextFactory <twisted.internet.ssl.ClientContextFactory>} @param contextFactory: An SSL context factory. @type args: 1-L{tuple} of (0) L{bytes} or 2-L{tuple} of (0) L{bytes}, (1), L{int} @param args: Positional arguments for L{SMTPClient.__init__} @param kw: Keyword arguments for L{SMTPClient.__init__} """ self.secret = secret self.contextFactory = contextFactory SMTPManagedRelayerFactory.__init__(self, messages, manager, *args, **kw) def buildProtocol(self, addr): """ Create an L{ESMTPManagedRelayer}. @type addr: L{IAddress <twisted.internet.interfaces.IAddress>} provider @param addr: The address of the ESMTP server. @rtype: L{ESMTPManagedRelayer} @return: A managed relayer for ESMTP. """ s = self.secret and self.secret(addr) protocol = self.protocol( self.messages, self.manager, s, self.contextFactory, *self.pArgs, **self.pKwArgs, ) protocol.factory = self return protocol class Queue: """ A queue for messages to be relayed. @ivar directory: See L{__init__} @type n: L{int} @ivar n: A number used to form unique filenames. @type waiting: L{dict} of L{bytes} @ivar waiting: The base filenames of messages waiting to be relayed. @type relayed: L{dict} of L{bytes} @ivar relayed: The base filenames of messages in the process of being relayed. @type noisy: L{bool} @ivar noisy: A flag which determines whether informational log messages will be generated (C{True}) or not (C{False}). """ noisy = True def __init__(self, directory): """ Initialize non-volatile state. @type directory: L{bytes} @param directory: The pathname of the directory holding messages in the queue. """ self.directory = directory self._init() def _init(self): """ Initialize volatile state. """ self.n = 0 self.waiting = {} self.relayed = {} self.readDirectory() def __getstate__(self): """ Create a representation of the non-volatile state of the queue. @rtype: L{dict} mapping L{bytes} to L{object} @return: The non-volatile state of the queue. """ return {"directory": self.directory} def __setstate__(self, state): """ Restore the non-volatile state of the queue and recreate the volatile state. @type state: L{dict} mapping L{bytes} to L{object} @param state: The non-volatile state of the queue. """ self.__dict__.update(state) self._init() def readDirectory(self): """ Scan the message directory for new messages. """ for message in os.listdir(self.directory): # Skip non data files if message[-2:] != "-D": continue self.addMessage(message[:-2]) def getWaiting(self): """ Return the base filenames of messages waiting to be relayed. @rtype: L{list} of L{bytes} @return: The base filenames of messages waiting to be relayed. """ return self.waiting.keys() def hasWaiting(self): """ Return an indication of whether the queue has messages waiting to be relayed. @rtype: L{bool} @return: C{True} if messages are waiting to be relayed. C{False} otherwise. """ return len(self.waiting) > 0 def getRelayed(self): """ Return the base filenames of messages in the process of being relayed. @rtype: L{list} of L{bytes} @return: The base filenames of messages in the process of being relayed. """ return self.relayed.keys() def setRelaying(self, message): """ Mark a message as being relayed. @type message: L{bytes} @param message: The base filename of a message. """ del self.waiting[message] self.relayed[message] = 1 def setWaiting(self, message): """ Mark a message as waiting to be relayed. @type message: L{bytes} @param message: The base filename of a message. """ del self.relayed[message] self.waiting[message] = 1 def addMessage(self, message): """ Mark a message as waiting to be relayed unless it is in the process of being relayed. @type message: L{bytes} @param message: The base filename of a message. """ if message not in self.relayed: self.waiting[message] = 1 if self.noisy: log.msg("Set " + message + " waiting") def done(self, message): """ Remove a message from the queue. @type message: L{bytes} @param message: The base filename of a message. """ message = os.path.basename(message) os.remove(self.getPath(message) + "-D") os.remove(self.getPath(message) + "-H") del self.relayed[message] def getPath(self, message): """ Return the full base pathname of a message in the queue. @type message: L{bytes} @param message: The base filename of a message. @rtype: L{bytes} @return: The full base pathname of the message. """ return os.path.join(self.directory, message) def getEnvelope(self, message): """ Get the envelope for a message. @type message: L{bytes} @param message: The base filename of a message. @rtype: L{list} of two L{bytes} @return: A list containing the origination and destination addresses for the message. """ with self.getEnvelopeFile(message) as f: return pickle.load(f) def getEnvelopeFile(self, message): """ Return the envelope file for a message in the queue. @type message: L{bytes} @param message: The base filename of a message. @rtype: file @return: The envelope file for the message. """ return open(os.path.join(self.directory, message + "-H"), "rb") def createNewMessage(self): """ Create a new message in the queue. @rtype: 2-L{tuple} of (0) file, (1) L{FileMessage} @return: The envelope file and a message receiver for a new message in the queue. """ fname = f"{os.getpid()}_{time.time()}_{self.n}_{id(self)}" self.n = self.n + 1 headerFile = open(os.path.join(self.directory, fname + "-H"), "wb") tempFilename = os.path.join(self.directory, fname + "-C") finalFilename = os.path.join(self.directory, fname + "-D") messageFile = open(tempFilename, "wb") from twisted.mail.mail import FileMessage return headerFile, FileMessage(messageFile, tempFilename, finalFilename) class _AttemptManager: """ A manager for an attempt to relay a set of messages to a mail exchange server. @ivar manager: See L{__init__} @type _completionDeferreds: L{list} of L{Deferred} @ivar _completionDeferreds: Deferreds which are to be notified when the attempt to relay is finished. """ def __init__(self, manager, noisy=True, reactor=None): """ @type manager: L{SmartHostSMTPRelayingManager} @param manager: A smart host. @type noisy: L{bool} @param noisy: A flag which determines whether informational log messages will be generated (L{True}) or not (L{False}). @type reactor: L{IReactorTime <twisted.internet.interfaces.IReactorTime>} provider @param reactor: A reactor which will be used to schedule delayed calls. """ self.manager = manager self._completionDeferreds = [] self.noisy = noisy if not reactor: from twisted.internet import reactor self.reactor = reactor def getCompletionDeferred(self): """ Return a deferred which will fire when the attempt to relay is finished. @rtype: L{Deferred} @return: A deferred which will fire when the attempt to relay is finished. """ self._completionDeferreds.append(Deferred()) return self._completionDeferreds[-1] def _finish(self, relay, message): """ Remove a message from the relay queue and from the smart host's list of messages being relayed. @type relay: L{SMTPManagedRelayerFactory} @param relay: The factory for the relayer which sent the message. @type message: L{bytes} @param message: The path of the file holding the message. """ self.manager.managed[relay].remove(os.path.basename(message)) self.manager.queue.done(message) def notifySuccess(self, relay, message): """ Remove a message from the relay queue after it has been successfully sent. @type relay: L{SMTPManagedRelayerFactory} @param relay: The factory for the relayer which sent the message. @type message: L{bytes} @param message: The path of the file holding the message. """ if self.noisy: log.msg("success sending %s, removing from queue" % message) self._finish(relay, message) def notifyFailure(self, relay, message): """ Generate a bounce message for a message which cannot be relayed. @type relay: L{SMTPManagedRelayerFactory} @param relay: The factory for the relayer responsible for the message. @type message: L{bytes} @param message: The path of the file holding the message. """ if self.noisy: log.msg("could not relay " + message) # Moshe - Bounce E-mail here # Be careful: if it's a bounced bounce, silently # discard it message = os.path.basename(message) with self.manager.queue.getEnvelopeFile(message) as fp: from_, to = pickle.load(fp) from_, to, bounceMessage = bounce.generateBounce( open(self.manager.queue.getPath(message) + "-D"), from_, to ) fp, outgoingMessage = self.manager.queue.createNewMessage() with fp: pickle.dump([from_, to], fp) for line in bounceMessage.splitlines(): outgoingMessage.lineReceived(line) outgoingMessage.eomReceived() self._finish(relay, self.manager.queue.getPath(message)) def notifyDone(self, relay): """ When the connection is lost or cannot be established, prepare to resend unsent messages and fire all deferred which are waiting for the completion of the attempt to relay. @type relay: L{SMTPManagedRelayerFactory} @param relay: The factory for the relayer for the connection. """ for message in self.manager.managed.get(relay, ()): if self.noisy: log.msg("Setting " + message + " waiting") self.manager.queue.setWaiting(message) try: del self.manager.managed[relay] except KeyError: pass notifications = self._completionDeferreds self._completionDeferreds = None for d in notifications: d.callback(None) def notifyNoConnection(self, relay): """ When a connection to the mail exchange server cannot be established, prepare to resend messages later. @type relay: L{SMTPManagedRelayerFactory} @param relay: The factory for the relayer meant to use the connection. """ # Back off a bit try: msgs = self.manager.managed[relay] except KeyError: log.msg("notifyNoConnection passed unknown relay!") return if self.noisy: log.msg("Backing off on delivery of " + str(msgs)) def setWaiting(queue, messages): map(queue.setWaiting, messages) self.reactor.callLater(30, setWaiting, self.manager.queue, msgs) del self.manager.managed[relay] class SmartHostSMTPRelayingManager: """ A smart host which uses SMTP managed relayers to send messages from the relay queue. L{checkState} must be called periodically at which time the state of the relay queue is checked and new relayers are created as needed. In order to relay a set of messages to a mail exchange server, a smart host creates an attempt manager and a managed relayer factory for that set of messages. When a connection is made with the mail exchange server, the managed relayer factory creates a managed relayer to send the messages. The managed relayer reports on its progress to the attempt manager which, in turn, updates the smart host's relay queue and information about its managed relayers. @ivar queue: See L{__init__}. @ivar maxConnections: See L{__init__}. @ivar maxMessagesPerConnection: See L{__init__}. @type fArgs: 3-L{tuple} of (0) L{list} of L{bytes}, (1) L{_AttemptManager}, (2) L{bytes} or 4-L{tuple} of (0) L{list} of L{bytes}, (1) L{_AttemptManager}, (2) L{bytes}, (3) L{int} @ivar fArgs: Positional arguments for L{SMTPManagedRelayerFactory.__init__}. @type fKwArgs: L{dict} @ivar fKwArgs: Keyword arguments for L{SMTPManagedRelayerFactory.__init__}. @type factory: callable which returns L{SMTPManagedRelayerFactory} @ivar factory: A callable which creates a factory for creating a managed relayer. See L{SMTPManagedRelayerFactory.__init__} for parameters to the callable. @type PORT: L{int} @ivar PORT: The port over which to connect to the SMTP server. @type mxcalc: L{None} or L{MXCalculator} @ivar mxcalc: A resource for mail exchange host lookups. @type managed: L{dict} mapping L{SMTPManagedRelayerFactory} to L{list} of L{bytes} @ivar managed: A mapping of factory for a managed relayer to filenames of messages the managed relayer is responsible for. """ factory: Type[protocol.ClientFactory] = SMTPManagedRelayerFactory PORT = 25 mxcalc = None def __init__(self, queue, maxConnections=2, maxMessagesPerConnection=10): """ Initialize a smart host. The default values specify connection limits appropriate for a low-volume smart host. @type queue: L{Queue} @param queue: A relay queue. @type maxConnections: L{int} @param maxConnections: The maximum number of concurrent connections to SMTP servers. @type maxMessagesPerConnection: L{int} @param maxMessagesPerConnection: The maximum number of messages for which a relayer will be given responsibility. """ self.maxConnections = maxConnections self.maxMessagesPerConnection = maxMessagesPerConnection self.managed = {} # SMTP clients we're managing self.queue = queue self.fArgs = () self.fKwArgs = {} def __getstate__(self): """ Create a representation of the non-volatile state of this object. @rtype: L{dict} mapping L{bytes} to L{object} @return: The non-volatile state of the queue. """ dct = self.__dict__.copy() del dct["managed"] return dct def __setstate__(self, state): """ Restore the non-volatile state of this object and recreate the volatile state. @type state: L{dict} mapping L{bytes} to L{object} @param state: The non-volatile state of the queue. """ self.__dict__.update(state) self.managed = {} def checkState(self): """ Check the state of the relay queue and, if possible, launch relayers to handle waiting messages. @rtype: L{None} or L{Deferred} @return: No return value if no further messages can be relayed or a deferred which fires when all of the SMTP connections initiated by this call have disconnected. """ self.queue.readDirectory() if len(self.managed) >= self.maxConnections: return if not self.queue.hasWaiting(): return return self._checkStateMX() def _checkStateMX(self): nextMessages = self.queue.getWaiting() nextMessages.reverse() exchanges = {} for msg in nextMessages: from_, to = self.queue.getEnvelope(msg) name, addr = email.utils.parseaddr(to) parts = addr.split("@", 1) if len(parts) != 2: log.err("Illegal message destination: " + to) continue domain = parts[1] self.queue.setRelaying(msg) exchanges.setdefault(domain, []).append(self.queue.getPath(msg)) if len(exchanges) >= (self.maxConnections - len(self.managed)): break if self.mxcalc is None: self.mxcalc = MXCalculator() relays = [] for (domain, msgs) in exchanges.iteritems(): manager = _AttemptManager(self, self.queue.noisy) factory = self.factory(msgs, manager, *self.fArgs, **self.fKwArgs) self.managed[factory] = map(os.path.basename, msgs) relayAttemptDeferred = manager.getCompletionDeferred() connectSetupDeferred = self.mxcalc.getMX(domain) connectSetupDeferred.addCallback(lambda mx: str(mx.name)) connectSetupDeferred.addCallback(self._cbExchange, self.PORT, factory) connectSetupDeferred.addErrback( lambda err: (relayAttemptDeferred.errback(err), err)[1] ) connectSetupDeferred.addErrback(self._ebExchange, factory, domain) relays.append(relayAttemptDeferred) return DeferredList(relays) def _cbExchange(self, address, port, factory): """ Initiate a connection with a mail exchange server. This callback function runs after mail exchange server for the domain has been looked up. @type address: L{bytes} @param address: The hostname of a mail exchange server. @type port: L{int} @param port: A port number. @type factory: L{SMTPManagedRelayerFactory} @param factory: A factory which can create a relayer for the mail exchange server. """ from twisted.internet import reactor reactor.connectTCP(address, port, factory) def _ebExchange(self, failure, factory, domain): """ Prepare to resend messages later. This errback function runs when no mail exchange server for the domain can be found. @type failure: L{Failure} @param failure: The reason the mail exchange lookup failed. @type factory: L{SMTPManagedRelayerFactory} @param factory: A factory which can create a relayer for the mail exchange server. @type domain: L{bytes} @param domain: A domain. """ log.err("Error setting up managed relay factory for " + domain) log.err(failure) def setWaiting(queue, messages): map(queue.setWaiting, messages) from twisted.internet import reactor reactor.callLater(30, setWaiting, self.queue, self.managed[factory]) del self.managed[factory] class SmartHostESMTPRelayingManager(SmartHostSMTPRelayingManager): """ A smart host which uses ESMTP managed relayers to send messages from the relay queue. @type factory: callable which returns L{ESMTPManagedRelayerFactory} @ivar factory: A callable which creates a factory for creating a managed relayer. See L{ESMTPManagedRelayerFactory.__init__} for parameters to the callable. """ factory = ESMTPManagedRelayerFactory def _checkState(manager): """ Prompt a relaying manager to check state. @type manager: L{SmartHostSMTPRelayingManager} @param manager: A relaying manager. """ manager.checkState() def RelayStateHelper(manager, delay): """ Set up a periodic call to prompt a relaying manager to check state. @type manager: L{SmartHostSMTPRelayingManager} @param manager: A relaying manager. @type delay: L{float} @param delay: The number of seconds between calls. @rtype: L{TimerService <internet.TimerService>} @return: A service which periodically reminds a relaying manager to check state. """ return internet.TimerService(delay, _checkState, manager) class CanonicalNameLoop(Exception): """ An error indicating that when trying to look up a mail exchange host, a set of canonical name records was found which form a cycle and resolution was abandoned. """ class CanonicalNameChainTooLong(Exception): """ An error indicating that when trying to look up a mail exchange host, too many canonical name records which point to other canonical name records were encountered and resolution was abandoned. """ class MXCalculator: """ A utility for looking up mail exchange hosts and tracking whether they are working or not. @type clock: L{IReactorTime <twisted.internet.interfaces.IReactorTime>} provider @ivar clock: A reactor which will be used to schedule timeouts. @type resolver: L{IResolver <twisted.internet.interfaces.IResolver>} @ivar resolver: A resolver. @type badMXs: L{dict} mapping L{bytes} to L{float} @ivar badMXs: A mapping of non-functioning mail exchange hostname to time at which another attempt at contacting it may be made. @type timeOutBadMX: L{int} @ivar timeOutBadMX: Period in seconds between attempts to contact a non-functioning mail exchange host. @type fallbackToDomain: L{bool} @ivar fallbackToDomain: A flag indicating whether to attempt to use the hostname directly when no mail exchange can be found (C{True}) or not (C{False}). """ timeOutBadMX = 60 * 60 # One hour fallbackToDomain = True def __init__(self, resolver=None, clock=None): """ @type resolver: L{IResolver <twisted.internet.interfaces.IResolver>} provider or L{None} @param resolver: A resolver. @type clock: L{IReactorTime <twisted.internet.interfaces.IReactorTime>} provider or L{None} @param clock: A reactor which will be used to schedule timeouts. """ self.badMXs = {} if resolver is None: from twisted.names.client import createResolver resolver = createResolver() self.resolver = resolver if clock is None: from twisted.internet import reactor as clock self.clock = clock def markBad(self, mx): """ Record that a mail exchange host is not currently functioning. @type mx: L{bytes} @param mx: The hostname of a mail exchange host. """ self.badMXs[str(mx)] = self.clock.seconds() + self.timeOutBadMX def markGood(self, mx): """ Record that a mail exchange host is functioning. @type mx: L{bytes} @param mx: The hostname of a mail exchange host. """ try: del self.badMXs[mx] except KeyError: pass def getMX(self, domain, maximumCanonicalChainLength=3): """ Find the name of a host that acts as a mail exchange server for a domain. @type domain: L{bytes} @param domain: A domain name. @type maximumCanonicalChainLength: L{int} @param maximumCanonicalChainLength: The maximum number of unique canonical name records to follow while looking up the mail exchange host. @rtype: L{Deferred} which successfully fires with L{Record_MX} @return: A deferred which succeeds with the MX record for the mail exchange server for the domain or fails if none can be found. """ mailExchangeDeferred = self.resolver.lookupMailExchange(domain) mailExchangeDeferred.addCallback(self._filterRecords) mailExchangeDeferred.addCallback( self._cbMX, domain, maximumCanonicalChainLength ) mailExchangeDeferred.addErrback(self._ebMX, domain) return mailExchangeDeferred def _filterRecords(self, records): """ Organize the records of a DNS response by record name. @type records: 3-L{tuple} of (0) L{list} of L{RRHeader <twisted.names.dns.RRHeader>}, (1) L{list} of L{RRHeader <twisted.names.dns.RRHeader>}, (2) L{list} of L{RRHeader <twisted.names.dns.RRHeader>} @param records: Answer resource records, authority resource records and additional resource records. @rtype: L{dict} mapping L{bytes} to L{list} of L{IRecord <twisted.names.dns.IRecord>} provider @return: A mapping of record name to record payload. """ recordBag = {} for answer in records[0]: recordBag.setdefault(str(answer.name), []).append(answer.payload) return recordBag def _cbMX(self, answers, domain, cnamesLeft): """ Try to find the mail exchange host for a domain from the given DNS records. This will attempt to resolve canonical name record results. It can recognize loops and will give up on non-cyclic chains after a specified number of lookups. @type answers: L{dict} mapping L{bytes} to L{list} of L{IRecord <twisted.names.dns.IRecord>} provider @param answers: A mapping of record name to record payload. @type domain: L{bytes} @param domain: A domain name. @type cnamesLeft: L{int} @param cnamesLeft: The number of unique canonical name records left to follow while looking up the mail exchange host. @rtype: L{Record_MX <twisted.names.dns.Record_MX>} or L{Failure} @return: An MX record for the mail exchange host or a failure if one cannot be found. """ # Do this import here so that relaymanager.py doesn't depend on # twisted.names, only MXCalculator will. from twisted.names import dns, error seenAliases = set() exchanges = [] # Examine the answers for the domain we asked about pertinentRecords = answers.get(domain, []) while pertinentRecords: record = pertinentRecords.pop() # If it's a CNAME, we'll need to do some more processing if record.TYPE == dns.CNAME: # Remember that this name was an alias. seenAliases.add(domain) canonicalName = str(record.name) # See if we have some local records which might be relevant. if canonicalName in answers: # Make sure it isn't a loop contained entirely within the # results we have here. if canonicalName in seenAliases: return Failure(CanonicalNameLoop(record)) pertinentRecords = answers[canonicalName] exchanges = [] else: if cnamesLeft: # Request more information from the server. return self.getMX(canonicalName, cnamesLeft - 1) else: # Give up. return Failure(CanonicalNameChainTooLong(record)) # If it's an MX, collect it. if record.TYPE == dns.MX: exchanges.append((record.preference, record)) if exchanges: exchanges.sort() for (preference, record) in exchanges: host = str(record.name) if host not in self.badMXs: return record t = self.clock.seconds() - self.badMXs[host] if t >= 0: del self.badMXs[host] return record return exchanges[0][1] else: # Treat no answers the same as an error - jump to the errback to # try to look up an A record. This provides behavior described as # a special case in RFC 974 in the section headed I{Interpreting # the List of MX RRs}. return Failure(error.DNSNameError(f"No MX records for {domain!r}")) def _ebMX(self, failure, domain): """ Attempt to use the name of the domain directly when mail exchange lookup fails. @type failure: L{Failure} @param failure: The reason for the lookup failure. @type domain: L{bytes} @param domain: The domain name. @rtype: L{Record_MX <twisted.names.dns.Record_MX>} or L{Failure} @return: An MX record for the domain or a failure if the fallback to domain option is not in effect and an error, other than not finding an MX record, occurred during lookup. @raise IOError: When no MX record could be found and the fallback to domain option is not in effect. @raise DNSLookupError: When no MX record could be found and the fallback to domain option is in effect but no address for the domain could be found. """ from twisted.names import dns, error if self.fallbackToDomain: failure.trap(error.DNSNameError) log.msg( "MX lookup failed; attempting to use hostname ({}) directly".format( domain ) ) # Alright, I admit, this is a bit icky. d = self.resolver.getHostByName(domain) def cbResolved(addr): return dns.Record_MX(name=addr) def ebResolved(err): err.trap(error.DNSNameError) raise DNSLookupError() d.addCallbacks(cbResolved, ebResolved) return d elif failure.check(error.DNSNameError): raise OSError(f"No MX found for {domain!r}") return failure PK Mb�Z8)#��] �] mail/alias.pynu �[��� # -*- test-case-name: twisted.mail.test.test_mail -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Support for aliases(5) configuration files. @author: Jp Calderone """ import os import tempfile from zope.interface import implementer from twisted.internet import defer, protocol, reactor from twisted.mail import smtp from twisted.mail.interfaces import IAlias from twisted.python import failure, log def handle(result, line, filename, lineNo): """ Parse a line from an aliases file. @type result: L{dict} mapping L{bytes} to L{list} of L{bytes} @param result: A dictionary mapping username to aliases to which the results of parsing the line are added. @type line: L{bytes} @param line: A line from an aliases file. @type filename: L{bytes} @param filename: The full or relative path to the aliases file. @type lineNo: L{int} @param lineNo: The position of the line within the aliases file. """ parts = [p.strip() for p in line.split(":", 1)] if len(parts) != 2: fmt = "Invalid format on line %d of alias file %s." arg = (lineNo, filename) log.err(fmt % arg) else: user, alias = parts result.setdefault(user.strip(), []).extend(map(str.strip, alias.split(","))) def loadAliasFile(domains, filename=None, fp=None): """ Load a file containing email aliases. Lines in the file should be formatted like so:: username: alias1, alias2, ..., aliasN Aliases beginning with a C{|} will be treated as programs, will be run, and the message will be written to their stdin. Aliases beginning with a C{:} will be treated as a file containing additional aliases for the username. Aliases beginning with a C{/} will be treated as the full pathname to a file to which the message will be appended. Aliases without a host part will be assumed to be addresses on localhost. If a username is specified multiple times, the aliases for each are joined together as if they had all been on one line. Lines beginning with a space or a tab are continuations of the previous line. Lines beginning with a C{#} are comments. @type domains: L{dict} mapping L{bytes} to L{IDomain} provider @param domains: A mapping of domain name to domain object. @type filename: L{bytes} or L{None} @param filename: The full or relative path to a file from which to load aliases. If omitted, the C{fp} parameter must be specified. @type fp: file-like object or L{None} @param fp: The file from which to load aliases. If specified, the C{filename} parameter is ignored. @rtype: L{dict} mapping L{bytes} to L{AliasGroup} @return: A mapping from username to group of aliases. """ result = {} close = False if fp is None: fp = open(filename) close = True else: filename = getattr(fp, "name", "<unknown>") i = 0 prev = "" try: for line in fp: i += 1 line = line.rstrip() if line.lstrip().startswith("#"): continue elif line.startswith(" ") or line.startswith("\t"): prev = prev + line else: if prev: handle(result, prev, filename, i) prev = line finally: if close: fp.close() if prev: handle(result, prev, filename, i) for (u, a) in result.items(): result[u] = AliasGroup(a, domains, u) return result class AliasBase: """ The default base class for aliases. @ivar domains: See L{__init__}. @type original: L{Address} @ivar original: The original address being aliased. """ def __init__(self, domains, original): """ @type domains: L{dict} mapping L{bytes} to L{IDomain} provider @param domains: A mapping of domain name to domain object. @type original: L{bytes} @param original: The original address being aliased. """ self.domains = domains self.original = smtp.Address(original) def domain(self): """ Return the domain associated with original address. @rtype: L{IDomain} provider @return: The domain for the original address. """ return self.domains[self.original.domain] def resolve(self, aliasmap, memo=None): """ Map this alias to its ultimate destination. @type aliasmap: L{dict} mapping L{bytes} to L{AliasBase} @param aliasmap: A mapping of username to alias or group of aliases. @type memo: L{None} or L{dict} of L{AliasBase} @param memo: A record of the aliases already considered in the resolution process. If provided, C{memo} is modified to include this alias. @rtype: L{IMessage <smtp.IMessage>} or L{None} @return: A message receiver for the ultimate destination or None for an invalid destination. """ if memo is None: memo = {} if str(self) in memo: return None memo[str(self)] = None return self.createMessageReceiver() @implementer(IAlias) class AddressAlias(AliasBase): """ An alias which translates one email address into another. @type alias : L{Address} @ivar alias: The destination address. """ def __init__(self, alias, *args): """ @type alias: L{Address}, L{User}, L{bytes} or object which can be converted into L{bytes} @param alias: The destination address. @type args: 2-L{tuple} of (0) L{dict} mapping L{bytes} to L{IDomain} provider, (1) L{bytes} @param args: Arguments for L{AliasBase.__init__}. """ AliasBase.__init__(self, *args) self.alias = smtp.Address(alias) def __str__(self) -> str: """ Build a string representation of this L{AddressAlias} instance. @rtype: L{bytes} @return: A string containing the destination address. """ return f"<Address {self.alias}>" def createMessageReceiver(self): """ Create a message receiver which delivers a message to the destination address. @rtype: L{IMessage <smtp.IMessage>} provider @return: A message receiver. """ return self.domain().exists(str(self.alias)) def resolve(self, aliasmap, memo=None): """ Map this alias to its ultimate destination. @type aliasmap: L{dict} mapping L{bytes} to L{AliasBase} @param aliasmap: A mapping of username to alias or group of aliases. @type memo: L{None} or L{dict} of L{AliasBase} @param memo: A record of the aliases already considered in the resolution process. If provided, C{memo} is modified to include this alias. @rtype: L{IMessage <smtp.IMessage>} or L{None} @return: A message receiver for the ultimate destination or None for an invalid destination. """ if memo is None: memo = {} if str(self) in memo: return None memo[str(self)] = None try: return self.domain().exists(smtp.User(self.alias, None, None, None), memo)() except smtp.SMTPBadRcpt: pass if self.alias.local in aliasmap: return aliasmap[self.alias.local].resolve(aliasmap, memo) return None @implementer(smtp.IMessage) class FileWrapper: """ A message receiver which delivers a message to a file. @type fp: file-like object @ivar fp: A file used for temporary storage of the message. @type finalname: L{bytes} @ivar finalname: The name of the file in which the message should be stored. """ def __init__(self, filename): """ @type filename: L{bytes} @param filename: The name of the file in which the message should be stored. """ self.fp = tempfile.TemporaryFile() self.finalname = filename def lineReceived(self, line): """ Write a received line to the temporary file. @type line: L{bytes} @param line: A received line of the message. """ self.fp.write(line + "\n") def eomReceived(self): """ Handle end of message by writing the message to the file. @rtype: L{Deferred <defer.Deferred>} which successfully results in L{bytes} @return: A deferred which succeeds with the name of the file to which the message has been stored or fails if the message cannot be saved to the file. """ self.fp.seek(0, 0) try: f = open(self.finalname, "a") except BaseException: return defer.fail(failure.Failure()) with f: f.write(self.fp.read()) self.fp.close() return defer.succeed(self.finalname) def connectionLost(self): """ Close the temporary file when the connection is lost. """ self.fp.close() self.fp = None def __str__(self) -> str: """ Build a string representation of this L{FileWrapper} instance. @rtype: L{bytes} @return: A string containing the file name of the message. """ return f"<FileWrapper {self.finalname}>" @implementer(IAlias) class FileAlias(AliasBase): """ An alias which translates an address to a file. @ivar filename: See L{__init__}. """ def __init__(self, filename, *args): """ @type filename: L{bytes} @param filename: The name of the file in which to store the message. @type args: 2-L{tuple} of (0) L{dict} mapping L{bytes} to L{IDomain} provider, (1) L{bytes} @param args: Arguments for L{AliasBase.__init__}. """ AliasBase.__init__(self, *args) self.filename = filename def __str__(self) -> str: """ Build a string representation of this L{FileAlias} instance. @rtype: L{bytes} @return: A string containing the name of the file. """ return f"<File {self.filename}>" def createMessageReceiver(self): """ Create a message receiver which delivers a message to the file. @rtype: L{FileWrapper} @return: A message receiver which writes a message to the file. """ return FileWrapper(self.filename) class ProcessAliasTimeout(Exception): """ An error indicating that a timeout occurred while waiting for a process to complete. """ @implementer(smtp.IMessage) class MessageWrapper: """ A message receiver which delivers a message to a child process. @type completionTimeout: L{int} or L{float} @ivar completionTimeout: The number of seconds to wait for the child process to exit before reporting the delivery as a failure. @type _timeoutCallID: L{None} or L{IDelayedCall <twisted.internet.interfaces.IDelayedCall>} provider @ivar _timeoutCallID: The call used to time out delivery, started when the connection to the child process is closed. @type done: L{bool} @ivar done: A flag indicating whether the child process has exited (C{True}) or not (C{False}). @type reactor: L{IReactorTime <twisted.internet.interfaces.IReactorTime>} provider @ivar reactor: A reactor which will be used to schedule timeouts. @ivar protocol: See L{__init__}. @type processName: L{bytes} or L{None} @ivar processName: The process name. @type completion: L{Deferred <defer.Deferred>} @ivar completion: The deferred which will be triggered by the protocol when the child process exits. """ done = False completionTimeout = 60 _timeoutCallID = None reactor = reactor def __init__(self, protocol, process=None, reactor=None): """ @type protocol: L{ProcessAliasProtocol} @param protocol: The protocol associated with the child process. @type process: L{bytes} or L{None} @param process: The process name. @type reactor: L{None} or L{IReactorTime <twisted.internet.interfaces.IReactorTime>} provider @param reactor: A reactor which will be used to schedule timeouts. """ self.processName = process self.protocol = protocol self.completion = defer.Deferred() self.protocol.onEnd = self.completion self.completion.addBoth(self._processEnded) if reactor is not None: self.reactor = reactor def _processEnded(self, result): """ Record process termination and cancel the timeout call if it is active. @type result: L{Failure <failure.Failure>} @param result: The reason the child process terminated. @rtype: L{None} or L{Failure <failure.Failure>} @return: None, if the process end is expected, or the reason the child process terminated, if the process end is unexpected. """ self.done = True if self._timeoutCallID is not None: # eomReceived was called, we're actually waiting for the process to # exit. self._timeoutCallID.cancel() self._timeoutCallID = None else: # eomReceived was not called, this is unexpected, propagate the # error. return result def lineReceived(self, line): """ Write a received line to the child process. @type line: L{bytes} @param line: A received line of the message. """ if self.done: return self.protocol.transport.write(line + "\n") def eomReceived(self): """ Disconnect from the child process and set up a timeout to wait for it to exit. @rtype: L{Deferred <defer.Deferred>} @return: A deferred which will be called back when the child process exits. """ if not self.done: self.protocol.transport.loseConnection() self._timeoutCallID = self.reactor.callLater( self.completionTimeout, self._completionCancel ) return self.completion def _completionCancel(self): """ Handle the expiration of the timeout for the child process to exit by terminating the child process forcefully and issuing a failure to the L{completion} deferred. """ self._timeoutCallID = None self.protocol.transport.signalProcess("KILL") exc = ProcessAliasTimeout(f"No answer after {self.completionTimeout} seconds") self.protocol.onEnd = None self.completion.errback(failure.Failure(exc)) def connectionLost(self): """ Ignore notification of lost connection. """ def __str__(self) -> str: """ Build a string representation of this L{MessageWrapper} instance. @rtype: L{bytes} @return: A string containing the name of the process. """ return f"<ProcessWrapper {self.processName}>" class ProcessAliasProtocol(protocol.ProcessProtocol): """ A process protocol which errbacks a deferred when the associated process ends. @type onEnd: L{None} or L{Deferred <defer.Deferred>} @ivar onEnd: If set, a deferred on which to errback when the process ends. """ onEnd = None def processEnded(self, reason): """ Call an errback. @type reason: L{Failure <failure.Failure>} @param reason: The reason the child process terminated. """ if self.onEnd is not None: self.onEnd.errback(reason) @implementer(IAlias) class ProcessAlias(AliasBase): """ An alias which is handled by the execution of a program. @type path: L{list} of L{bytes} @ivar path: The arguments to pass to the process. The first string is the executable's name. @type program: L{bytes} @ivar program: The path of the program to be executed. @type reactor: L{IReactorTime <twisted.internet.interfaces.IReactorTime>} and L{IReactorProcess <twisted.internet.interfaces.IReactorProcess>} provider @ivar reactor: A reactor which will be used to create and timeout the child process. """ reactor = reactor def __init__(self, path, *args): """ @type path: L{bytes} @param path: The command to invoke the program consisting of the path to the executable followed by any arguments. @type args: 2-L{tuple} of (0) L{dict} mapping L{bytes} to L{IDomain} provider, (1) L{bytes} @param args: Arguments for L{AliasBase.__init__}. """ AliasBase.__init__(self, *args) self.path = path.split() self.program = self.path[0] def __str__(self) -> str: """ Build a string representation of this L{ProcessAlias} instance. @rtype: L{bytes} @return: A string containing the command used to invoke the process. """ return f"<Process {self.path}>" def spawnProcess(self, proto, program, path): """ Spawn a process. This wraps the L{spawnProcess <twisted.internet.interfaces.IReactorProcess.spawnProcess>} method on L{reactor} so that it can be customized for test purposes. @type proto: L{IProcessProtocol <twisted.internet.interfaces.IProcessProtocol>} provider @param proto: An object which will be notified of all events related to the created process. @type program: L{bytes} @param program: The full path name of the file to execute. @type path: L{list} of L{bytes} @param path: The arguments to pass to the process. The first string should be the executable's name. @rtype: L{IProcessTransport <twisted.internet.interfaces.IProcessTransport>} provider @return: A process transport. """ return self.reactor.spawnProcess(proto, program, path) def createMessageReceiver(self): """ Launch a process and create a message receiver to pass a message to the process. @rtype: L{MessageWrapper} @return: A message receiver which delivers a message to the process. """ p = ProcessAliasProtocol() m = MessageWrapper(p, self.program, self.reactor) self.spawnProcess(p, self.program, self.path) return m @implementer(smtp.IMessage) class MultiWrapper: """ A message receiver which delivers a single message to multiple other message receivers. @ivar objs: See L{__init__}. """ def __init__(self, objs): """ @type objs: L{list} of L{IMessage <smtp.IMessage>} provider @param objs: Message receivers to which the incoming message should be directed. """ self.objs = objs def lineReceived(self, line): """ Pass a received line to the message receivers. @type line: L{bytes} @param line: A line of the message. """ for o in self.objs: o.lineReceived(line) def eomReceived(self): """ Pass the end of message along to the message receivers. @rtype: L{DeferredList <defer.DeferredList>} whose successful results are L{bytes} or L{None} @return: A deferred list which triggers when all of the message receivers have finished handling their end of message. """ return defer.DeferredList([o.eomReceived() for o in self.objs]) def connectionLost(self): """ Inform the message receivers that the connection has been lost. """ for o in self.objs: o.connectionLost() def __str__(self) -> str: """ Build a string representation of this L{MultiWrapper} instance. @rtype: L{bytes} @return: A string containing a list of the message receivers. """ return f"<GroupWrapper {map(str, self.objs)!r}>" @implementer(IAlias) class AliasGroup(AliasBase): """ An alias which points to multiple destination aliases. @type processAliasFactory: no-argument callable which returns L{ProcessAlias} @ivar processAliasFactory: A factory for process aliases. @type aliases: L{list} of L{AliasBase} which implements L{IAlias} @ivar aliases: The destination aliases. """ processAliasFactory = ProcessAlias def __init__(self, items, *args): """ Create a group of aliases. Parse a list of alias strings and, for each, create an appropriate alias object. @type items: L{list} of L{bytes} @param items: Aliases. @type args: n-L{tuple} of (0) L{dict} mapping L{bytes} to L{IDomain} provider, (1) L{bytes} @param args: Arguments for L{AliasBase.__init__}. """ AliasBase.__init__(self, *args) self.aliases = [] while items: addr = items.pop().strip() if addr.startswith(":"): try: f = open(addr[1:]) except BaseException: log.err(f"Invalid filename in alias file {addr[1:]!r}") else: with f: addr = " ".join([l.strip() for l in f]) items.extend(addr.split(",")) elif addr.startswith("|"): self.aliases.append(self.processAliasFactory(addr[1:], *args)) elif addr.startswith("/"): if os.path.isdir(addr): log.err("Directory delivery not supported") else: self.aliases.append(FileAlias(addr, *args)) else: self.aliases.append(AddressAlias(addr, *args)) def __len__(self): """ Return the number of aliases in the group. @rtype: L{int} @return: The number of aliases in the group. """ return len(self.aliases) def __str__(self) -> str: """ Build a string representation of this L{AliasGroup} instance. @rtype: L{bytes} @return: A string containing the aliases in the group. """ return "<AliasGroup [%s]>" % (", ".join(map(str, self.aliases))) def createMessageReceiver(self): """ Create a message receiver for each alias and return a message receiver which will pass on a message to each of those. @rtype: L{MultiWrapper} @return: A message receiver which passes a message on to message receivers for each alias in the group. """ return MultiWrapper([a.createMessageReceiver() for a in self.aliases]) def resolve(self, aliasmap, memo=None): """ Map each of the aliases in the group to its ultimate destination. @type aliasmap: L{dict} mapping L{bytes} to L{AliasBase} @param aliasmap: A mapping of username to alias or group of aliases. @type memo: L{None} or L{dict} of L{AliasBase} @param memo: A record of the aliases already considered in the resolution process. If provided, C{memo} is modified to include this alias. @rtype: L{MultiWrapper} @return: A message receiver which passes the message on to message receivers for the ultimate destination of each alias in the group. """ if memo is None: memo = {} r = [] for a in self.aliases: r.append(a.resolve(aliasmap, memo)) return MultiWrapper(filter(None, r)) PK Mb�Zly]8W: W: mail/imap4.pynu �[��� # -*- test-case-name: twisted.mail.test.test_imap.IMAP4HelperTests -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ An IMAP4 protocol implementation @author: Jp Calderone To do:: Suspend idle timeout while server is processing Use an async message parser instead of buffering in memory Figure out a way to not queue multi-message client requests (Flow? A simple callback?) Clarify some API docs (Query, etc) Make APPEND recognize (again) non-existent mailboxes before accepting the literal """ import binascii import codecs import copy import email.utils import functools import re import string import tempfile import time import uuid from base64 import decodebytes, encodebytes from io import BytesIO from itertools import chain from typing import Any, List, cast from zope.interface import implementer from twisted.cred import credentials from twisted.cred.error import UnauthorizedLogin, UnhandledCredentials from twisted.internet import defer, error, interfaces from twisted.internet.defer import maybeDeferred from twisted.mail._cred import ( CramMD5ClientAuthenticator, LOGINAuthenticator, LOGINCredentials, PLAINAuthenticator, PLAINCredentials, ) from twisted.mail._except import ( IllegalClientResponse, IllegalIdentifierError, IllegalMailboxEncoding, IllegalOperation, IllegalQueryError, IllegalServerResponse, IMAP4Exception, MailboxCollision, MailboxException, MismatchedNesting, MismatchedQuoting, NegativeResponse, NoSuchMailbox, NoSupportedAuthentication, ReadOnlyMailbox, UnhandledResponse, ) # Re-exported for compatibility reasons from twisted.mail.interfaces import ( IAccountIMAP as IAccount, IClientAuthentication, ICloseableMailboxIMAP as ICloseableMailbox, IMailboxIMAP as IMailbox, IMailboxIMAPInfo as IMailboxInfo, IMailboxIMAPListener as IMailboxListener, IMessageIMAP as IMessage, IMessageIMAPCopier as IMessageCopier, IMessageIMAPFile as IMessageFile, IMessageIMAPPart as IMessagePart, INamespacePresenter, ISearchableIMAPMailbox as ISearchableMailbox, ) from twisted.protocols import basic, policies from twisted.python import log, text from twisted.python.compat import ( _get_async_param, _matchingString, iterbytes, nativeString, networkString, ) # locale-independent month names to use instead of strftime's _MONTH_NAMES = dict( zip(range(1, 13), "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split()) ) def _swap(this, that, ifIs): """ Swap C{this} with C{that} if C{this} is C{ifIs}. @param this: The object that may be replaced. @param that: The object that may replace C{this}. @param ifIs: An object whose identity will be compared to C{this}. """ return that if this is ifIs else this def _swapAllPairs(of, that, ifIs): """ Swap each element in each pair in C{of} with C{that} it is C{ifIs}. @param of: A list of 2-L{tuple}s, whose members may be the object C{that} @type of: L{list} of 2-L{tuple}s @param ifIs: An object whose identity will be compared to members of each pair in C{of} @return: A L{list} of 2-L{tuple}s with all occurences of C{ifIs} replaced with C{that} """ return [ (_swap(first, that, ifIs), _swap(second, that, ifIs)) for first, second in of ] class MessageSet: """ A set of message identifiers usable by both L{IMAP4Client} and L{IMAP4Server} via L{IMailboxIMAP.store} and L{IMailboxIMAP.fetch}. These identifiers can be either message sequence numbers or unique identifiers. See Section 2.3.1, "Message Numbers", RFC 3501. This represents the C{sequence-set} described in Section 9, "Formal Syntax" of RFC 3501: - A L{MessageSet} can describe a single identifier, e.g. C{MessageSet(1)} - A L{MessageSet} can describe C{*} via L{None}, e.g. C{MessageSet(None)} - A L{MessageSet} can describe a range of identifiers, e.g. C{MessageSet(1, 2)}. The range is inclusive and unordered (see C{seq-range} in RFC 3501, Section 9), so that C{Message(2, 1)} is equivalent to C{MessageSet(1, 2)}, and both describe messages 1 and 2. Ranges can include C{*} by specifying L{None}, e.g. C{MessageSet(None, 1)}. In all cases ranges are normalized so that the smallest identifier comes first, and L{None} always comes last; C{Message(2, 1)} becomes C{MessageSet(1, 2)} and C{MessageSet(None, 1)} becomes C{MessageSet(1, None)} - A L{MessageSet} can describe a sequence of single identifiers and ranges, constructed by addition. C{MessageSet(1) + MessageSet(5, 10)} refers the message identified by C{1} and the messages identified by C{5} through C{10}. B{NB: The meaning of * varies, but it always represents the largest number in use}. B{For servers}: Your L{IMailboxIMAP} provider must set L{MessageSet.last} to the highest-valued identifier (unique or message sequence) before iterating over it. B{For clients}: C{*} consumes ranges smaller than it, e.g. C{MessageSet(1, 100) + MessageSet(50, None)} is equivalent to C{1:*}. @type getnext: Function taking L{int} returning L{int} @ivar getnext: A function that returns the next message number, used when iterating through the L{MessageSet}. By default, a function returning the next integer is supplied, but as this can be rather inefficient for sparse UID iterations, it is recommended to supply one when messages are requested by UID. The argument is provided as a hint to the implementation and may be ignored if it makes sense to do so (eg, if an iterator is being used that maintains its own state, it is guaranteed that it will not be called out-of-order). """ _empty: List[Any] = [] _infinity = float("inf") def __init__(self, start=_empty, end=_empty): """ Create a new MessageSet() @type start: Optional L{int} @param start: Start of range, or only message number @type end: Optional L{int} @param end: End of range. """ self._last = self._empty # Last message/UID in use self.ranges = [] # List of ranges included self.getnext = lambda x: x + 1 # A function which will return the next # message id. Handy for UID requests. if start is self._empty: return if isinstance(start, list): self.ranges = start[:] self.clean() else: self.add(start, end) @property def last(self): """ The largest number in use. This is undefined until it has been set by assigning to this property. """ return self._last @last.setter def last(self, value): """ Replaces all occurrences of "*". This should be the largest number in use. Must be set before attempting to use the MessageSet as a container. @raises ValueError: if a largest value has already been set. """ if self._last is not self._empty: raise ValueError("last already set") self._last = value for i, (low, high) in enumerate(self.ranges): if low is None: low = value if high is None: high = value if low > high: low, high = high, low self.ranges[i] = (low, high) self.clean() def add(self, start, end=_empty): """ Add another range @type start: L{int} @param start: Start of range, or only message number @type end: Optional L{int} @param end: End of range. """ if end is self._empty: end = start if self._last is not self._empty: if start is None: start = self.last if end is None: end = self.last start, end = sorted( [start, end], key=functools.partial(_swap, that=self._infinity, ifIs=None) ) self.ranges.append((start, end)) self.clean() def __add__(self, other): if isinstance(other, MessageSet): ranges = self.ranges + other.ranges return MessageSet(ranges) else: res = MessageSet(self.ranges) if self.last is not self._empty: res.last = self.last try: res.add(*other) except TypeError: res.add(other) return res def extend(self, other): """ Extend our messages with another message or set of messages. @param other: The messages to include. @type other: L{MessageSet}, L{tuple} of two L{int}s, or a single L{int} """ if isinstance(other, MessageSet): self.ranges.extend(other.ranges) self.clean() else: try: self.add(*other) except TypeError: self.add(other) return self def clean(self): """ Clean ranges list, combining adjacent ranges """ ranges = sorted(_swapAllPairs(self.ranges, that=self._infinity, ifIs=None)) mergedRanges = [(float("-inf"), float("-inf"))] for low, high in ranges: previousLow, previousHigh = mergedRanges[-1] if previousHigh < low - 1: mergedRanges.append((low, high)) continue mergedRanges[-1] = (min(previousLow, low), max(previousHigh, high)) self.ranges = _swapAllPairs(mergedRanges[1:], that=None, ifIs=self._infinity) def _noneInRanges(self): """ Is there a L{None} in our ranges? L{MessageSet.clean} merges overlapping or consecutive ranges. None is represents a value larger than any number. There are thus two cases: 1. C{(x, *) + (y, z)} such that C{x} is smaller than C{y} 2. C{(z, *) + (x, y)} such that C{z} is larger than C{y} (Other cases, such as C{y < x < z}, can be split into these two cases; for example C{(y - 1, y)} + C{(x, x) + (z, z + 1)}) In case 1, C{* > y} and C{* > z}, so C{(x, *) + (y, z) = (x, *)} In case 2, C{z > x and z > y}, so the intervals do not merge, and the ranges are sorted as C{[(x, y), (z, *)]}. C{*} is represented as C{(*, *)}, so this is the same as 2. but with a C{z} that is greater than everything. The result is that there is a maximum of two L{None}s, and one of them has to be the high element in the last tuple in C{self.ranges}. That means checking if C{self.ranges[-1][-1]} is L{None} suffices to check if I{any} element is L{None}. @return: L{True} if L{None} is in some range in ranges and L{False} if otherwise. """ return self.ranges[-1][-1] is None def __contains__(self, value): """ May raise TypeError if we encounter an open-ended range @param value: Is this in our ranges? @type value: L{int} """ if self._noneInRanges(): raise TypeError("Can't determine membership; last value not set") for low, high in self.ranges: if low <= value <= high: return True return False def _iterator(self): for l, h in self.ranges: l = self.getnext(l - 1) while l <= h: yield l l = self.getnext(l) def __iter__(self): if self._noneInRanges(): raise TypeError("Can't iterate; last value not set") return self._iterator() def __len__(self): res = 0 for l, h in self.ranges: if l is None: res += 1 elif h is None: raise TypeError("Can't size object; last value not set") else: res += (h - l) + 1 return res def __str__(self) -> str: p = [] for low, high in self.ranges: if low == high: if low is None: p.append("*") else: p.append(str(low)) elif high is None: p.append("%d:*" % (low,)) else: p.append("%d:%d" % (low, high)) return ",".join(p) def __repr__(self) -> str: return f"<MessageSet {str(self)}>" def __eq__(self, other: object) -> bool: if isinstance(other, MessageSet): return cast(bool, self.ranges == other.ranges) return NotImplemented class LiteralString: def __init__(self, size, defered): self.size = size self.data = [] self.defer = defered def write(self, data): self.size -= len(data) passon = None if self.size > 0: self.data.append(data) else: if self.size: data, passon = data[: self.size], data[self.size :] else: passon = b"" if data: self.data.append(data) return passon def callback(self, line): """ Call deferred with data and rest of line """ self.defer.callback((b"".join(self.data), line)) class LiteralFile: _memoryFileLimit = 1024 * 1024 * 10 def __init__(self, size, defered): self.size = size self.defer = defered if size > self._memoryFileLimit: self.data = tempfile.TemporaryFile() else: self.data = BytesIO() def write(self, data): self.size -= len(data) passon = None if self.size > 0: self.data.write(data) else: if self.size: data, passon = data[: self.size], data[self.size :] else: passon = b"" if data: self.data.write(data) return passon def callback(self, line): """ Call deferred with data and rest of line """ self.data.seek(0, 0) self.defer.callback((self.data, line)) class WriteBuffer: """ Buffer up a bunch of writes before sending them all to a transport at once. """ def __init__(self, transport, size=8192): self.bufferSize = size self.transport = transport self._length = 0 self._writes = [] def write(self, s): self._length += len(s) self._writes.append(s) if self._length > self.bufferSize: self.flush() def flush(self): if self._writes: self.transport.writeSequence(self._writes) self._writes = [] self._length = 0 class Command: _1_RESPONSES = ( b"CAPABILITY", b"FLAGS", b"LIST", b"LSUB", b"STATUS", b"SEARCH", b"NAMESPACE", ) _2_RESPONSES = (b"EXISTS", b"EXPUNGE", b"FETCH", b"RECENT") _OK_RESPONSES = ( b"UIDVALIDITY", b"UNSEEN", b"READ-WRITE", b"READ-ONLY", b"UIDNEXT", b"PERMANENTFLAGS", ) defer = None def __init__( self, command, args=None, wantResponse=(), continuation=None, *contArgs, **contKw, ): self.command = command self.args = args self.wantResponse = wantResponse self.continuation = lambda x: continuation(x, *contArgs, **contKw) self.lines = [] def __repr__(self) -> str: return "<imap4.Command {!r} {!r} {!r} {!r} {!r}>".format( self.command, self.args, self.wantResponse, self.continuation, self.lines ) def format(self, tag): if self.args is None: return b" ".join((tag, self.command)) return b" ".join((tag, self.command, self.args)) def finish(self, lastLine, unusedCallback): send = [] unuse = [] for L in self.lines: names = parseNestedParens(L) N = len(names) if ( N >= 1 and names[0] in self._1_RESPONSES or N >= 2 and names[1] in self._2_RESPONSES or N >= 2 and names[0] == b"OK" and isinstance(names[1], list) and names[1][0] in self._OK_RESPONSES ): send.append(names) else: unuse.append(names) d, self.defer = self.defer, None d.callback((send, lastLine)) if unuse: unusedCallback(unuse) # Some constants to help define what an atom is and is not - see the grammar # section of the IMAP4 RFC - <https://tools.ietf.org/html/rfc3501#section-9>. # Some definitions (SP, CTL, DQUOTE) are also from the ABNF RFC - # <https://tools.ietf.org/html/rfc2234>. _SP = b" " _CTL = bytes(chain(range(0x21), range(0x80, 0x100))) # It is easier to define ATOM-CHAR in terms of what it does not match than in # terms of what it does match. _nonAtomChars = b']\\\\(){%*"' + _SP + _CTL # _nonAtomRE is only used in Query, so it uses native strings. _nativeNonAtomChars = _nonAtomChars.decode("charmap") _nonAtomRE = re.compile("[" + _nativeNonAtomChars + "]") # This is all the bytes that match the ATOM-CHAR from the grammar in the RFC. _atomChars = bytes(ch for ch in range(0x100) if ch not in _nonAtomChars) @implementer(IMailboxListener) class IMAP4Server(basic.LineReceiver, policies.TimeoutMixin): """ Protocol implementation for an IMAP4rev1 server. The server can be in any of four states: - Non-authenticated - Authenticated - Selected - Logout """ # Identifier for this server software IDENT = b"Twisted IMAP4rev1 Ready" # Number of seconds before idle timeout # Initially 1 minute. Raised to 30 minutes after login. timeOut = 60 POSTAUTH_TIMEOUT = 60 * 30 # Whether STARTTLS has been issued successfully yet or not. startedTLS = False # Whether our transport supports TLS canStartTLS = False # Mapping of tags to commands we have received tags = None # The object which will handle logins for us portal = None # The account object for this connection account = None # Logout callback _onLogout = None # The currently selected mailbox mbox = None # Command data to be processed when literal data is received _pendingLiteral = None # Maximum length to accept for a "short" string literal _literalStringLimit = 4096 # IChallengeResponse factories for AUTHENTICATE command challengers = None # Search terms the implementation of which needs to be passed both the last # message identifier (UID) and the last sequence id. _requiresLastMessageInfo = {b"OR", b"NOT", b"UID"} state = "unauth" parseState = "command" def __init__(self, chal=None, contextFactory=None, scheduler=None): if chal is None: chal = {} self.challengers = chal self.ctx = contextFactory if scheduler is None: scheduler = iterateInReactor self._scheduler = scheduler self._queuedAsync = [] def capabilities(self): cap = {b"AUTH": list(self.challengers.keys())} if self.ctx and self.canStartTLS: if ( not self.startedTLS and interfaces.ISSLTransport(self.transport, None) is None ): cap[b"LOGINDISABLED"] = None cap[b"STARTTLS"] = None cap[b"NAMESPACE"] = None cap[b"IDLE"] = None return cap def connectionMade(self): self.tags = {} self.canStartTLS = interfaces.ITLSTransport(self.transport, None) is not None self.setTimeout(self.timeOut) self.sendServerGreeting() def connectionLost(self, reason): self.setTimeout(None) if self._onLogout: self._onLogout() self._onLogout = None def timeoutConnection(self): self.sendLine(b"* BYE Autologout; connection idle too long") self.transport.loseConnection() if self.mbox: self.mbox.removeListener(self) cmbx = ICloseableMailbox(self.mbox, None) if cmbx is not None: maybeDeferred(cmbx.close).addErrback(log.err) self.mbox = None self.state = "timeout" def rawDataReceived(self, data): self.resetTimeout() passon = self._pendingLiteral.write(data) if passon is not None: self.setLineMode(passon) # Avoid processing commands while buffers are being dumped to # our transport blocked = None def _unblock(self): commands = self.blocked self.blocked = None while commands and self.blocked is None: self.lineReceived(commands.pop(0)) if self.blocked is not None: self.blocked.extend(commands) def lineReceived(self, line): if self.blocked is not None: self.blocked.append(line) return self.resetTimeout() f = getattr(self, "parse_" + self.parseState) try: f(line) except Exception as e: self.sendUntaggedResponse(b"BAD Server error: " + networkString(str(e))) log.err() def parse_command(self, line): args = line.split(None, 2) rest = None if len(args) == 3: tag, cmd, rest = args elif len(args) == 2: tag, cmd = args elif len(args) == 1: tag = args[0] self.sendBadResponse(tag, b"Missing command") return None else: self.sendBadResponse(None, b"Null command") return None cmd = cmd.upper() try: return self.dispatchCommand(tag, cmd, rest) except IllegalClientResponse as e: self.sendBadResponse(tag, b"Illegal syntax: " + networkString(str(e))) except IllegalOperation as e: self.sendNegativeResponse( tag, b"Illegal operation: " + networkString(str(e)) ) except IllegalMailboxEncoding as e: self.sendNegativeResponse( tag, b"Illegal mailbox name: " + networkString(str(e)) ) def parse_pending(self, line): d = self._pendingLiteral self._pendingLiteral = None self.parseState = "command" d.callback(line) def dispatchCommand(self, tag, cmd, rest, uid=None): f = self.lookupCommand(cmd) if f: fn = f[0] parseargs = f[1:] self.__doCommand(tag, fn, [self, tag], parseargs, rest, uid) else: self.sendBadResponse(tag, b"Unsupported command") def lookupCommand(self, cmd): return getattr(self, "_".join((self.state, nativeString(cmd.upper()))), None) def __doCommand(self, tag, handler, args, parseargs, line, uid): for (i, arg) in enumerate(parseargs): if callable(arg): parseargs = parseargs[i + 1 :] maybeDeferred(arg, self, line).addCallback( self.__cbDispatch, tag, handler, args, parseargs, uid ).addErrback(self.__ebDispatch, tag) return else: args.append(arg) if line: # Too many arguments raise IllegalClientResponse("Too many arguments for command: " + repr(line)) if uid is not None: handler(uid=uid, *args) else: handler(*args) def __cbDispatch(self, result, tag, fn, args, parseargs, uid): (arg, rest) = result args.append(arg) self.__doCommand(tag, fn, args, parseargs, rest, uid) def __ebDispatch(self, failure, tag): if failure.check(IllegalClientResponse): self.sendBadResponse( tag, b"Illegal syntax: " + networkString(str(failure.value)) ) elif failure.check(IllegalOperation): self.sendNegativeResponse( tag, b"Illegal operation: " + networkString(str(failure.value)) ) elif failure.check(IllegalMailboxEncoding): self.sendNegativeResponse( tag, b"Illegal mailbox name: " + networkString(str(failure.value)) ) else: self.sendBadResponse( tag, b"Server error: " + networkString(str(failure.value)) ) log.err(failure) def _stringLiteral(self, size): if size > self._literalStringLimit: raise IllegalClientResponse( "Literal too long! I accept at most %d octets" % (self._literalStringLimit,) ) d = defer.Deferred() self.parseState = "pending" self._pendingLiteral = LiteralString(size, d) self.sendContinuationRequest( networkString("Ready for %d octets of text" % size) ) self.setRawMode() return d def _fileLiteral(self, size): d = defer.Deferred() self.parseState = "pending" self._pendingLiteral = LiteralFile(size, d) self.sendContinuationRequest( networkString("Ready for %d octets of data" % size) ) self.setRawMode() return d def arg_finalastring(self, line): """ Parse an astring from line that represents a command's final argument. This special case exists to enable parsing empty string literals. @param line: A line that contains a string literal. @type line: L{bytes} @return: A 2-tuple containing the parsed argument and any trailing data, or a L{Deferred} that fires with that 2-tuple @rtype: L{tuple} of (L{bytes}, L{bytes}) or a L{Deferred} @see: https://twistedmatrix.com/trac/ticket/9207 """ return self.arg_astring(line, final=True) def arg_astring(self, line, final=False): """ Parse an astring from the line, return (arg, rest), possibly via a deferred (to handle literals) @param line: A line that contains a string literal. @type line: L{bytes} @param final: Is this the final argument? @type final L{bool} @return: A 2-tuple containing the parsed argument and any trailing data, or a L{Deferred} that fires with that 2-tuple @rtype: L{tuple} of (L{bytes}, L{bytes}) or a L{Deferred} """ line = line.strip() if not line: raise IllegalClientResponse("Missing argument") d = None arg, rest = None, None if line[0:1] == b'"': try: spam, arg, rest = line.split(b'"', 2) rest = rest[1:] # Strip space except ValueError: raise IllegalClientResponse("Unmatched quotes") elif line[0:1] == b"{": # literal if line[-1:] != b"}": raise IllegalClientResponse("Malformed literal") try: size = int(line[1:-1]) except ValueError: raise IllegalClientResponse("Bad literal size: " + repr(line[1:-1])) if final and not size: return (b"", b"") d = self._stringLiteral(size) else: arg = line.split(b" ", 1) if len(arg) == 1: arg.append(b"") arg, rest = arg return d or (arg, rest) # ATOM: Any CHAR except ( ) { % * " \ ] CTL SP (CHAR is 7bit) atomre = re.compile( b"(?P<atom>[" + re.escape(_atomChars) + b"]+)( (?P<rest>.*$)|$)" ) def arg_atom(self, line): """ Parse an atom from the line """ if not line: raise IllegalClientResponse("Missing argument") m = self.atomre.match(line) if m: return m.group("atom"), m.group("rest") else: raise IllegalClientResponse("Malformed ATOM") def arg_plist(self, line): """ Parse a (non-nested) parenthesised list from the line """ if not line: raise IllegalClientResponse("Missing argument") if line[:1] != b"(": raise IllegalClientResponse("Missing parenthesis") i = line.find(b")") if i == -1: raise IllegalClientResponse("Mismatched parenthesis") return (parseNestedParens(line[1:i], 0), line[i + 2 :]) def arg_literal(self, line): """ Parse a literal from the line """ if not line: raise IllegalClientResponse("Missing argument") if line[:1] != b"{": raise IllegalClientResponse("Missing literal") if line[-1:] != b"}": raise IllegalClientResponse("Malformed literal") try: size = int(line[1:-1]) except ValueError: raise IllegalClientResponse(f"Bad literal size: {line[1:-1]!r}") return self._fileLiteral(size) def arg_searchkeys(self, line): """ searchkeys """ query = parseNestedParens(line) # XXX Should really use list of search terms and parse into # a proper tree return (query, b"") def arg_seqset(self, line): """ sequence-set """ rest = b"" arg = line.split(b" ", 1) if len(arg) == 2: rest = arg[1] arg = arg[0] try: return (parseIdList(arg), rest) except IllegalIdentifierError as e: raise IllegalClientResponse("Bad message number " + str(e)) def arg_fetchatt(self, line): """ fetch-att """ p = _FetchParser() p.parseString(line) return (p.result, b"") def arg_flaglist(self, line): """ Flag part of store-att-flag """ flags = [] if line[0:1] == b"(": if line[-1:] != b")": raise IllegalClientResponse("Mismatched parenthesis") line = line[1:-1] while line: m = self.atomre.search(line) if not m: raise IllegalClientResponse("Malformed flag") if line[0:1] == b"\\" and m.start() == 1: flags.append(b"\\" + m.group("atom")) elif m.start() == 0: flags.append(m.group("atom")) else: raise IllegalClientResponse("Malformed flag") line = m.group("rest") return (flags, b"") def arg_line(self, line): """ Command line of UID command """ return (line, b"") def opt_plist(self, line): """ Optional parenthesised list """ if line.startswith(b"("): return self.arg_plist(line) else: return (None, line) def opt_datetime(self, line): """ Optional date-time string """ if line.startswith(b'"'): try: spam, date, rest = line.split(b'"', 2) except ValueError: raise IllegalClientResponse("Malformed date-time") return (date, rest[1:]) else: return (None, line) def opt_charset(self, line): """ Optional charset of SEARCH command """ if line[:7].upper() == b"CHARSET": arg = line.split(b" ", 2) if len(arg) == 1: raise IllegalClientResponse("Missing charset identifier") if len(arg) == 2: arg.append(b"") spam, arg, rest = arg return (arg, rest) else: return (None, line) def sendServerGreeting(self): msg = b"[CAPABILITY " + b" ".join(self.listCapabilities()) + b"] " + self.IDENT self.sendPositiveResponse(message=msg) def sendBadResponse(self, tag=None, message=b""): self._respond(b"BAD", tag, message) def sendPositiveResponse(self, tag=None, message=b""): self._respond(b"OK", tag, message) def sendNegativeResponse(self, tag=None, message=b""): self._respond(b"NO", tag, message) def sendUntaggedResponse(self, message, isAsync=None, **kwargs): isAsync = _get_async_param(isAsync, **kwargs) if not isAsync or (self.blocked is None): self._respond(message, None, None) else: self._queuedAsync.append(message) def sendContinuationRequest(self, msg=b"Ready for additional command text"): if msg: self.sendLine(b"+ " + msg) else: self.sendLine(b"+") def _respond(self, state, tag, message): if state in (b"OK", b"NO", b"BAD") and self._queuedAsync: lines = self._queuedAsync self._queuedAsync = [] for msg in lines: self._respond(msg, None, None) if not tag: tag = b"*" if message: self.sendLine(b" ".join((tag, state, message))) else: self.sendLine(b" ".join((tag, state))) def listCapabilities(self): caps = [b"IMAP4rev1"] for c, v in self.capabilities().items(): if v is None: caps.append(c) elif len(v): caps.extend([(c + b"=" + cap) for cap in v]) return caps def do_CAPABILITY(self, tag): self.sendUntaggedResponse(b"CAPABILITY " + b" ".join(self.listCapabilities())) self.sendPositiveResponse(tag, b"CAPABILITY completed") unauth_CAPABILITY = (do_CAPABILITY,) auth_CAPABILITY = unauth_CAPABILITY select_CAPABILITY = unauth_CAPABILITY logout_CAPABILITY = unauth_CAPABILITY def do_LOGOUT(self, tag): self.sendUntaggedResponse(b"BYE Nice talking to you") self.sendPositiveResponse(tag, b"LOGOUT successful") self.transport.loseConnection() unauth_LOGOUT = (do_LOGOUT,) auth_LOGOUT = unauth_LOGOUT select_LOGOUT = unauth_LOGOUT logout_LOGOUT = unauth_LOGOUT def do_NOOP(self, tag): self.sendPositiveResponse(tag, b"NOOP No operation performed") unauth_NOOP = (do_NOOP,) auth_NOOP = unauth_NOOP select_NOOP = unauth_NOOP logout_NOOP = unauth_NOOP def do_AUTHENTICATE(self, tag, args): args = args.upper().strip() if args not in self.challengers: self.sendNegativeResponse(tag, b"AUTHENTICATE method unsupported") else: self.authenticate(self.challengers[args](), tag) unauth_AUTHENTICATE = (do_AUTHENTICATE, arg_atom) def authenticate(self, chal, tag): if self.portal is None: self.sendNegativeResponse(tag, b"Temporary authentication failure") return self._setupChallenge(chal, tag) def _setupChallenge(self, chal, tag): try: challenge = chal.getChallenge() except Exception as e: self.sendBadResponse(tag, b"Server error: " + networkString(str(e))) else: coded = encodebytes(challenge)[:-1] self.parseState = "pending" self._pendingLiteral = defer.Deferred() self.sendContinuationRequest(coded) self._pendingLiteral.addCallback(self.__cbAuthChunk, chal, tag) self._pendingLiteral.addErrback(self.__ebAuthChunk, tag) def __cbAuthChunk(self, result, chal, tag): try: uncoded = decodebytes(result) except binascii.Error: raise IllegalClientResponse("Malformed Response - not base64") chal.setResponse(uncoded) if chal.moreChallenges(): self._setupChallenge(chal, tag) else: self.portal.login(chal, None, IAccount).addCallbacks( self.__cbAuthResp, self.__ebAuthResp, (tag,), None, (tag,), None ) def __cbAuthResp(self, result, tag): (iface, avatar, logout) = result assert iface is IAccount, "IAccount is the only supported interface" self.account = avatar self.state = "auth" self._onLogout = logout self.sendPositiveResponse(tag, b"Authentication successful") self.setTimeout(self.POSTAUTH_TIMEOUT) def __ebAuthResp(self, failure, tag): if failure.check(UnauthorizedLogin): self.sendNegativeResponse(tag, b"Authentication failed: unauthorized") elif failure.check(UnhandledCredentials): self.sendNegativeResponse( tag, b"Authentication failed: server misconfigured" ) else: self.sendBadResponse(tag, b"Server error: login failed unexpectedly") log.err(failure) def __ebAuthChunk(self, failure, tag): self.sendNegativeResponse( tag, b"Authentication failed: " + networkString(str(failure.value)) ) def do_STARTTLS(self, tag): if self.startedTLS: self.sendNegativeResponse(tag, b"TLS already negotiated") elif self.ctx and self.canStartTLS: self.sendPositiveResponse(tag, b"Begin TLS negotiation now") self.transport.startTLS(self.ctx) self.startedTLS = True self.challengers = self.challengers.copy() if b"LOGIN" not in self.challengers: self.challengers[b"LOGIN"] = LOGINCredentials if b"PLAIN" not in self.challengers: self.challengers[b"PLAIN"] = PLAINCredentials else: self.sendNegativeResponse(tag, b"TLS not available") unauth_STARTTLS = (do_STARTTLS,) def do_LOGIN(self, tag, user, passwd): if b"LOGINDISABLED" in self.capabilities(): self.sendBadResponse(tag, b"LOGIN is disabled before STARTTLS") return maybeDeferred(self.authenticateLogin, user, passwd).addCallback( self.__cbLogin, tag ).addErrback(self.__ebLogin, tag) unauth_LOGIN = (do_LOGIN, arg_astring, arg_finalastring) def authenticateLogin(self, user, passwd): """ Lookup the account associated with the given parameters Override this method to define the desired authentication behavior. The default behavior is to defer authentication to C{self.portal} if it is not None, or to deny the login otherwise. @type user: L{str} @param user: The username to lookup @type passwd: L{str} @param passwd: The password to login with """ if self.portal: return self.portal.login( credentials.UsernamePassword(user, passwd), None, IAccount ) raise UnauthorizedLogin() def __cbLogin(self, result, tag): (iface, avatar, logout) = result if iface is not IAccount: self.sendBadResponse(tag, b"Server error: login returned unexpected value") log.err(f"__cbLogin called with {iface!r}, IAccount expected") else: self.account = avatar self._onLogout = logout self.sendPositiveResponse(tag, b"LOGIN succeeded") self.state = "auth" self.setTimeout(self.POSTAUTH_TIMEOUT) def __ebLogin(self, failure, tag): if failure.check(UnauthorizedLogin): self.sendNegativeResponse(tag, b"LOGIN failed") else: self.sendBadResponse( tag, b"Server error: " + networkString(str(failure.value)) ) log.err(failure) def do_NAMESPACE(self, tag): personal = public = shared = None np = INamespacePresenter(self.account, None) if np is not None: personal = np.getPersonalNamespaces() public = np.getSharedNamespaces() shared = np.getSharedNamespaces() self.sendUntaggedResponse( b"NAMESPACE " + collapseNestedLists([personal, public, shared]) ) self.sendPositiveResponse(tag, b"NAMESPACE command completed") auth_NAMESPACE = (do_NAMESPACE,) select_NAMESPACE = auth_NAMESPACE def _selectWork(self, tag, name, rw, cmdName): if self.mbox: self.mbox.removeListener(self) cmbx = ICloseableMailbox(self.mbox, None) if cmbx is not None: maybeDeferred(cmbx.close).addErrback(log.err) self.mbox = None self.state = "auth" name = _parseMbox(name) maybeDeferred(self.account.select, _parseMbox(name), rw).addCallback( self._cbSelectWork, cmdName, tag ).addErrback(self._ebSelectWork, cmdName, tag) def _ebSelectWork(self, failure, cmdName, tag): self.sendBadResponse(tag, cmdName + b" failed: Server error") log.err(failure) def _cbSelectWork(self, mbox, cmdName, tag): if mbox is None: self.sendNegativeResponse(tag, b"No such mailbox") return if "\\noselect" in [s.lower() for s in mbox.getFlags()]: self.sendNegativeResponse(tag, "Mailbox cannot be selected") return flags = [networkString(flag) for flag in mbox.getFlags()] self.sendUntaggedResponse(b"%d EXISTS" % (mbox.getMessageCount(),)) self.sendUntaggedResponse(b"%d RECENT" % (mbox.getRecentCount(),)) self.sendUntaggedResponse(b"FLAGS (" + b" ".join(flags) + b")") self.sendPositiveResponse(None, b"[UIDVALIDITY %d]" % (mbox.getUIDValidity(),)) s = mbox.isWriteable() and b"READ-WRITE" or b"READ-ONLY" mbox.addListener(self) self.sendPositiveResponse(tag, b"[" + s + b"] " + cmdName + b" successful") self.state = "select" self.mbox = mbox auth_SELECT = (_selectWork, arg_astring, 1, b"SELECT") select_SELECT = auth_SELECT auth_EXAMINE = (_selectWork, arg_astring, 0, b"EXAMINE") select_EXAMINE = auth_EXAMINE def do_IDLE(self, tag): self.sendContinuationRequest(None) self.parseTag = tag self.lastState = self.parseState self.parseState = "idle" def parse_idle(self, *args): self.parseState = self.lastState del self.lastState self.sendPositiveResponse(self.parseTag, b"IDLE terminated") del self.parseTag select_IDLE = (do_IDLE,) auth_IDLE = select_IDLE def do_CREATE(self, tag, name): name = _parseMbox(name) try: result = self.account.create(name) except MailboxException as c: self.sendNegativeResponse(tag, networkString(str(c))) except BaseException: self.sendBadResponse( tag, b"Server error encountered while creating mailbox" ) log.err() else: if result: self.sendPositiveResponse(tag, b"Mailbox created") else: self.sendNegativeResponse(tag, b"Mailbox not created") auth_CREATE = (do_CREATE, arg_finalastring) select_CREATE = auth_CREATE def do_DELETE(self, tag, name): name = _parseMbox(name) if name.lower() == "inbox": self.sendNegativeResponse(tag, b"You cannot delete the inbox") return try: self.account.delete(name) except MailboxException as m: self.sendNegativeResponse(tag, str(m).encode("imap4-utf-7")) except BaseException: self.sendBadResponse( tag, b"Server error encountered while deleting mailbox" ) log.err() else: self.sendPositiveResponse(tag, b"Mailbox deleted") auth_DELETE = (do_DELETE, arg_finalastring) select_DELETE = auth_DELETE def do_RENAME(self, tag, oldname, newname): oldname, newname = (_parseMbox(n) for n in (oldname, newname)) if oldname.lower() == "inbox" or newname.lower() == "inbox": self.sendNegativeResponse( tag, b"You cannot rename the inbox, or rename another mailbox to inbox." ) return try: self.account.rename(oldname, newname) except TypeError: self.sendBadResponse(tag, b"Invalid command syntax") except MailboxException as m: self.sendNegativeResponse(tag, networkString(str(m))) except BaseException: self.sendBadResponse( tag, b"Server error encountered while renaming mailbox" ) log.err() else: self.sendPositiveResponse(tag, b"Mailbox renamed") auth_RENAME = (do_RENAME, arg_astring, arg_finalastring) select_RENAME = auth_RENAME def do_SUBSCRIBE(self, tag, name): name = _parseMbox(name) try: self.account.subscribe(name) except MailboxException as m: self.sendNegativeResponse(tag, networkString(str(m))) except BaseException: self.sendBadResponse( tag, b"Server error encountered while subscribing to mailbox" ) log.err() else: self.sendPositiveResponse(tag, b"Subscribed") auth_SUBSCRIBE = (do_SUBSCRIBE, arg_finalastring) select_SUBSCRIBE = auth_SUBSCRIBE def do_UNSUBSCRIBE(self, tag, name): name = _parseMbox(name) try: self.account.unsubscribe(name) except MailboxException as m: self.sendNegativeResponse(tag, networkString(str(m))) except BaseException: self.sendBadResponse( tag, b"Server error encountered while unsubscribing from mailbox" ) log.err() else: self.sendPositiveResponse(tag, b"Unsubscribed") auth_UNSUBSCRIBE = (do_UNSUBSCRIBE, arg_finalastring) select_UNSUBSCRIBE = auth_UNSUBSCRIBE def _listWork(self, tag, ref, mbox, sub, cmdName): mbox = _parseMbox(mbox) ref = _parseMbox(ref) maybeDeferred(self.account.listMailboxes, ref, mbox).addCallback( self._cbListWork, tag, sub, cmdName ).addErrback(self._ebListWork, tag) def _cbListWork(self, mailboxes, tag, sub, cmdName): for (name, box) in mailboxes: if not sub or self.account.isSubscribed(name): flags = [networkString(flag) for flag in box.getFlags()] delim = box.getHierarchicalDelimiter().encode("imap4-utf-7") resp = ( DontQuoteMe(cmdName), map(DontQuoteMe, flags), delim, name.encode("imap4-utf-7"), ) self.sendUntaggedResponse(collapseNestedLists(resp)) self.sendPositiveResponse(tag, cmdName + b" completed") def _ebListWork(self, failure, tag): self.sendBadResponse(tag, b"Server error encountered while listing mailboxes.") log.err(failure) auth_LIST = (_listWork, arg_astring, arg_astring, 0, b"LIST") select_LIST = auth_LIST auth_LSUB = (_listWork, arg_astring, arg_astring, 1, b"LSUB") select_LSUB = auth_LSUB def do_STATUS(self, tag, mailbox, names): nativeNames = [] for name in names: nativeNames.append(nativeString(name)) mailbox = _parseMbox(mailbox) maybeDeferred(self.account.select, mailbox, 0).addCallback( self._cbStatusGotMailbox, tag, mailbox, nativeNames ).addErrback(self._ebStatusGotMailbox, tag) def _cbStatusGotMailbox(self, mbox, tag, mailbox, names): if mbox: maybeDeferred(mbox.requestStatus, names).addCallbacks( self.__cbStatus, self.__ebStatus, (tag, mailbox), None, (tag, mailbox), None, ) else: self.sendNegativeResponse(tag, b"Could not open mailbox") def _ebStatusGotMailbox(self, failure, tag): self.sendBadResponse(tag, b"Server error encountered while opening mailbox.") log.err(failure) auth_STATUS = (do_STATUS, arg_astring, arg_plist) select_STATUS = auth_STATUS def __cbStatus(self, status, tag, box): # STATUS names should only be ASCII line = networkString(" ".join(["%s %s" % x for x in status.items()])) self.sendUntaggedResponse( b"STATUS " + box.encode("imap4-utf-7") + b" (" + line + b")" ) self.sendPositiveResponse(tag, b"STATUS complete") def __ebStatus(self, failure, tag, box): self.sendBadResponse( tag, b"STATUS " + box + b" failed: " + networkString(str(failure.value)) ) def do_APPEND(self, tag, mailbox, flags, date, message): mailbox = _parseMbox(mailbox) maybeDeferred(self.account.select, mailbox).addCallback( self._cbAppendGotMailbox, tag, flags, date, message ).addErrback(self._ebAppendGotMailbox, tag) def _cbAppendGotMailbox(self, mbox, tag, flags, date, message): if not mbox: self.sendNegativeResponse(tag, "[TRYCREATE] No such mailbox") return decodedFlags = [nativeString(flag) for flag in flags] d = mbox.addMessage(message, decodedFlags, date) d.addCallback(self.__cbAppend, tag, mbox) d.addErrback(self.__ebAppend, tag) def _ebAppendGotMailbox(self, failure, tag): self.sendBadResponse(tag, b"Server error encountered while opening mailbox.") log.err(failure) auth_APPEND = (do_APPEND, arg_astring, opt_plist, opt_datetime, arg_literal) select_APPEND = auth_APPEND def __cbAppend(self, result, tag, mbox): self.sendUntaggedResponse(b"%d EXISTS" % (mbox.getMessageCount(),)) self.sendPositiveResponse(tag, b"APPEND complete") def __ebAppend(self, failure, tag): self.sendBadResponse( tag, b"APPEND failed: " + networkString(str(failure.value)) ) def do_CHECK(self, tag): d = self.checkpoint() if d is None: self.__cbCheck(None, tag) else: d.addCallbacks( self.__cbCheck, self.__ebCheck, callbackArgs=(tag,), errbackArgs=(tag,) ) select_CHECK = (do_CHECK,) def __cbCheck(self, result, tag): self.sendPositiveResponse(tag, b"CHECK completed") def __ebCheck(self, failure, tag): self.sendBadResponse(tag, b"CHECK failed: " + networkString(str(failure.value))) def checkpoint(self): """ Called when the client issues a CHECK command. This should perform any checkpoint operations required by the server. It may be a long running operation, but may not block. If it returns a deferred, the client will only be informed of success (or failure) when the deferred's callback (or errback) is invoked. """ return None def do_CLOSE(self, tag): d = None if self.mbox.isWriteable(): d = maybeDeferred(self.mbox.expunge) cmbx = ICloseableMailbox(self.mbox, None) if cmbx is not None: if d is not None: d.addCallback(lambda result: cmbx.close()) else: d = maybeDeferred(cmbx.close) if d is not None: d.addCallbacks(self.__cbClose, self.__ebClose, (tag,), None, (tag,), None) else: self.__cbClose(None, tag) select_CLOSE = (do_CLOSE,) def __cbClose(self, result, tag): self.sendPositiveResponse(tag, b"CLOSE completed") self.mbox.removeListener(self) self.mbox = None self.state = "auth" def __ebClose(self, failure, tag): self.sendBadResponse(tag, b"CLOSE failed: " + networkString(str(failure.value))) def do_EXPUNGE(self, tag): if self.mbox.isWriteable(): maybeDeferred(self.mbox.expunge).addCallbacks( self.__cbExpunge, self.__ebExpunge, (tag,), None, (tag,), None ) else: self.sendNegativeResponse(tag, b"EXPUNGE ignored on read-only mailbox") select_EXPUNGE = (do_EXPUNGE,) def __cbExpunge(self, result, tag): for e in result: self.sendUntaggedResponse(b"%d EXPUNGE" % (e,)) self.sendPositiveResponse(tag, b"EXPUNGE completed") def __ebExpunge(self, failure, tag): self.sendBadResponse( tag, b"EXPUNGE failed: " + networkString(str(failure.value)) ) log.err(failure) def do_SEARCH(self, tag, charset, query, uid=0): sm = ISearchableMailbox(self.mbox, None) if sm is not None: maybeDeferred(sm.search, query, uid=uid).addCallback( self.__cbSearch, tag, self.mbox, uid ).addErrback(self.__ebSearch, tag) else: # that's not the ideal way to get all messages, there should be a # method on mailboxes that gives you all of them s = parseIdList(b"1:*") maybeDeferred(self.mbox.fetch, s, uid=uid).addCallback( self.__cbManualSearch, tag, self.mbox, query, uid ).addErrback(self.__ebSearch, tag) select_SEARCH = (do_SEARCH, opt_charset, arg_searchkeys) def __cbSearch(self, result, tag, mbox, uid): if uid: result = map(mbox.getUID, result) ids = networkString(" ".join([str(i) for i in result])) self.sendUntaggedResponse(b"SEARCH " + ids) self.sendPositiveResponse(tag, b"SEARCH completed") def __cbManualSearch(self, result, tag, mbox, query, uid, searchResults=None): """ Apply the search filter to a set of messages. Send the response to the client. @type result: L{list} of L{tuple} of (L{int}, provider of L{imap4.IMessage}) @param result: A list two tuples of messages with their sequence ids, sorted by the ids in descending order. @type tag: L{str} @param tag: A command tag. @type mbox: Provider of L{imap4.IMailbox} @param mbox: The searched mailbox. @type query: L{list} @param query: A list representing the parsed form of the search query. @param uid: A flag indicating whether the search is over message sequence numbers or UIDs. @type searchResults: L{list} @param searchResults: The search results so far or L{None} if no results yet. """ if searchResults is None: searchResults = [] i = 0 # result is a list of tuples (sequenceId, Message) lastSequenceId = result and result[-1][0] lastMessageId = result and result[-1][1].getUID() for (i, (msgId, msg)) in list(zip(range(5), result)): # searchFilter and singleSearchStep will mutate the query. Dang. # Copy it here or else things will go poorly for subsequent # messages. if self._searchFilter( copy.deepcopy(query), msgId, msg, lastSequenceId, lastMessageId ): searchResults.append(b"%d" % (msg.getUID() if uid else msgId,)) if i == 4: from twisted.internet import reactor reactor.callLater( 0, self.__cbManualSearch, list(result[5:]), tag, mbox, query, uid, searchResults, ) else: if searchResults: self.sendUntaggedResponse(b"SEARCH " + b" ".join(searchResults)) self.sendPositiveResponse(tag, b"SEARCH completed") def _searchFilter(self, query, id, msg, lastSequenceId, lastMessageId): """ Pop search terms from the beginning of C{query} until there are none left and apply them to the given message. @param query: A list representing the parsed form of the search query. @param id: The sequence number of the message being checked. @param msg: The message being checked. @type lastSequenceId: L{int} @param lastSequenceId: The highest sequence number of any message in the mailbox being searched. @type lastMessageId: L{int} @param lastMessageId: The highest UID of any message in the mailbox being searched. @return: Boolean indicating whether all of the query terms match the message. """ while query: if not self._singleSearchStep( query, id, msg, lastSequenceId, lastMessageId ): return False return True def _singleSearchStep(self, query, msgId, msg, lastSequenceId, lastMessageId): """ Pop one search term from the beginning of C{query} (possibly more than one element) and return whether it matches the given message. @param query: A list representing the parsed form of the search query. @param msgId: The sequence number of the message being checked. @param msg: The message being checked. @param lastSequenceId: The highest sequence number of any message in the mailbox being searched. @param lastMessageId: The highest UID of any message in the mailbox being searched. @return: Boolean indicating whether the query term matched the message. """ q = query.pop(0) if isinstance(q, list): if not self._searchFilter(q, msgId, msg, lastSequenceId, lastMessageId): return False else: c = q.upper() if not c[:1].isalpha(): # A search term may be a word like ALL, ANSWERED, BCC, etc (see # below) or it may be a message sequence set. Here we # recognize a message sequence set "N:M". messageSet = parseIdList(c, lastSequenceId) return msgId in messageSet else: f = getattr(self, "search_" + nativeString(c), None) if f is None: raise IllegalQueryError( "Invalid search command %s" % nativeString(c) ) if c in self._requiresLastMessageInfo: result = f(query, msgId, msg, (lastSequenceId, lastMessageId)) else: result = f(query, msgId, msg) if not result: return False return True def search_ALL(self, query, id, msg): """ Returns C{True} if the message matches the ALL search key (always). @type query: A L{list} of L{str} @param query: A list representing the parsed query string. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} """ return True def search_ANSWERED(self, query, id, msg): """ Returns C{True} if the message has been answered. @type query: A L{list} of L{str} @param query: A list representing the parsed query string. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} """ return "\\Answered" in msg.getFlags() def search_BCC(self, query, id, msg): """ Returns C{True} if the message has a BCC address matching the query. @type query: A L{list} of L{str} @param query: A list whose first element is a BCC L{str} @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} """ bcc = msg.getHeaders(False, "bcc").get("bcc", "") return bcc.lower().find(query.pop(0).lower()) != -1 def search_BEFORE(self, query, id, msg): date = parseTime(query.pop(0)) return email.utils.parsedate(nativeString(msg.getInternalDate())) < date def search_BODY(self, query, id, msg): body = query.pop(0).lower() return text.strFile(body, msg.getBodyFile(), False) def search_CC(self, query, id, msg): cc = msg.getHeaders(False, "cc").get("cc", "") return cc.lower().find(query.pop(0).lower()) != -1 def search_DELETED(self, query, id, msg): return "\\Deleted" in msg.getFlags() def search_DRAFT(self, query, id, msg): return "\\Draft" in msg.getFlags() def search_FLAGGED(self, query, id, msg): return "\\Flagged" in msg.getFlags() def search_FROM(self, query, id, msg): fm = msg.getHeaders(False, "from").get("from", "") return fm.lower().find(query.pop(0).lower()) != -1 def search_HEADER(self, query, id, msg): hdr = query.pop(0).lower() hdr = msg.getHeaders(False, hdr).get(hdr, "") return hdr.lower().find(query.pop(0).lower()) != -1 def search_KEYWORD(self, query, id, msg): query.pop(0) return False def search_LARGER(self, query, id, msg): return int(query.pop(0)) < msg.getSize() def search_NEW(self, query, id, msg): return "\\Recent" in msg.getFlags() and "\\Seen" not in msg.getFlags() def search_NOT(self, query, id, msg, lastIDs): """ Returns C{True} if the message does not match the query. @type query: A L{list} of L{str} @param query: A list representing the parsed form of the search query. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} @param msg: The message being checked. @type lastIDs: L{tuple} @param lastIDs: A tuple of (last sequence id, last message id). The I{last sequence id} is an L{int} containing the highest sequence number of a message in the mailbox. The I{last message id} is an L{int} containing the highest UID of a message in the mailbox. """ (lastSequenceId, lastMessageId) = lastIDs return not self._singleSearchStep(query, id, msg, lastSequenceId, lastMessageId) def search_OLD(self, query, id, msg): return "\\Recent" not in msg.getFlags() def search_ON(self, query, id, msg): date = parseTime(query.pop(0)) return email.utils.parsedate(msg.getInternalDate()) == date def search_OR(self, query, id, msg, lastIDs): """ Returns C{True} if the message matches any of the first two query items. @type query: A L{list} of L{str} @param query: A list representing the parsed form of the search query. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} @param msg: The message being checked. @type lastIDs: L{tuple} @param lastIDs: A tuple of (last sequence id, last message id). The I{last sequence id} is an L{int} containing the highest sequence number of a message in the mailbox. The I{last message id} is an L{int} containing the highest UID of a message in the mailbox. """ (lastSequenceId, lastMessageId) = lastIDs a = self._singleSearchStep(query, id, msg, lastSequenceId, lastMessageId) b = self._singleSearchStep(query, id, msg, lastSequenceId, lastMessageId) return a or b def search_RECENT(self, query, id, msg): return "\\Recent" in msg.getFlags() def search_SEEN(self, query, id, msg): return "\\Seen" in msg.getFlags() def search_SENTBEFORE(self, query, id, msg): """ Returns C{True} if the message date is earlier than the query date. @type query: A L{list} of L{str} @param query: A list whose first element starts with a stringified date that is a fragment of an L{imap4.Query()}. The date must be in the format 'DD-Mon-YYYY', for example '03-March-2003' or '03-Mar-2003'. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} """ date = msg.getHeaders(False, "date").get("date", "") date = email.utils.parsedate(date) return date < parseTime(query.pop(0)) def search_SENTON(self, query, id, msg): """ Returns C{True} if the message date is the same as the query date. @type query: A L{list} of L{str} @param query: A list whose first element starts with a stringified date that is a fragment of an L{imap4.Query()}. The date must be in the format 'DD-Mon-YYYY', for example '03-March-2003' or '03-Mar-2003'. @type msg: Provider of L{imap4.IMessage} """ date = msg.getHeaders(False, "date").get("date", "") date = email.utils.parsedate(date) return date[:3] == parseTime(query.pop(0))[:3] def search_SENTSINCE(self, query, id, msg): """ Returns C{True} if the message date is later than the query date. @type query: A L{list} of L{str} @param query: A list whose first element starts with a stringified date that is a fragment of an L{imap4.Query()}. The date must be in the format 'DD-Mon-YYYY', for example '03-March-2003' or '03-Mar-2003'. @type msg: Provider of L{imap4.IMessage} """ date = msg.getHeaders(False, "date").get("date", "") date = email.utils.parsedate(date) return date > parseTime(query.pop(0)) def search_SINCE(self, query, id, msg): date = parseTime(query.pop(0)) return email.utils.parsedate(msg.getInternalDate()) > date def search_SMALLER(self, query, id, msg): return int(query.pop(0)) > msg.getSize() def search_SUBJECT(self, query, id, msg): subj = msg.getHeaders(False, "subject").get("subject", "") return subj.lower().find(query.pop(0).lower()) != -1 def search_TEXT(self, query, id, msg): # XXX - This must search headers too body = query.pop(0).lower() return text.strFile(body, msg.getBodyFile(), False) def search_TO(self, query, id, msg): to = msg.getHeaders(False, "to").get("to", "") return to.lower().find(query.pop(0).lower()) != -1 def search_UID(self, query, id, msg, lastIDs): """ Returns C{True} if the message UID is in the range defined by the search query. @type query: A L{list} of L{bytes} @param query: A list representing the parsed form of the search query. Its first element should be a L{str} that can be interpreted as a sequence range, for example '2:4,5:*'. @type id: L{int} @param id: The sequence number of the message being checked. @type msg: Provider of L{imap4.IMessage} @param msg: The message being checked. @type lastIDs: L{tuple} @param lastIDs: A tuple of (last sequence id, last message id). The I{last sequence id} is an L{int} containing the highest sequence number of a message in the mailbox. The I{last message id} is an L{int} containing the highest UID of a message in the mailbox. """ (lastSequenceId, lastMessageId) = lastIDs c = query.pop(0) m = parseIdList(c, lastMessageId) return msg.getUID() in m def search_UNANSWERED(self, query, id, msg): return "\\Answered" not in msg.getFlags() def search_UNDELETED(self, query, id, msg): return "\\Deleted" not in msg.getFlags() def search_UNDRAFT(self, query, id, msg): return "\\Draft" not in msg.getFlags() def search_UNFLAGGED(self, query, id, msg): return "\\Flagged" not in msg.getFlags() def search_UNKEYWORD(self, query, id, msg): query.pop(0) return False def search_UNSEEN(self, query, id, msg): return "\\Seen" not in msg.getFlags() def __ebSearch(self, failure, tag): self.sendBadResponse( tag, b"SEARCH failed: " + networkString(str(failure.value)) ) log.err(failure) def do_FETCH(self, tag, messages, query, uid=0): if query: self._oldTimeout = self.setTimeout(None) maybeDeferred(self.mbox.fetch, messages, uid=uid).addCallback( iter ).addCallback(self.__cbFetch, tag, query, uid).addErrback( self.__ebFetch, tag ) else: self.sendPositiveResponse(tag, b"FETCH complete") select_FETCH = (do_FETCH, arg_seqset, arg_fetchatt) def __cbFetch(self, results, tag, query, uid): if self.blocked is None: self.blocked = [] try: id, msg = next(results) except StopIteration: # The idle timeout was suspended while we delivered results, # restore it now. self.setTimeout(self._oldTimeout) del self._oldTimeout # All results have been processed, deliver completion notification. # It's important to run this *after* resetting the timeout to "rig # a race" in some test code. writing to the transport will # synchronously call test code, which synchronously loses the # connection, calling our connectionLost method, which cancels the # timeout. We want to make sure that timeout is cancelled *after* # we reset it above, so that the final state is no timed # calls. This avoids reactor uncleanliness errors in the test # suite. # XXX: Perhaps loopback should be fixed to not call the user code # synchronously in transport.write? self.sendPositiveResponse(tag, b"FETCH completed") # Instance state is now consistent again (ie, it is as though # the fetch command never ran), so allow any pending blocked # commands to execute. self._unblock() else: self.spewMessage(id, msg, query, uid).addCallback( lambda _: self.__cbFetch(results, tag, query, uid) ).addErrback(self.__ebSpewMessage) def __ebSpewMessage(self, failure): # This indicates a programming error. # There's no reliable way to indicate anything to the client, since we # may have already written an arbitrary amount of data in response to # the command. log.err(failure) self.transport.loseConnection() def spew_envelope(self, id, msg, _w=None, _f=None): if _w is None: _w = self.transport.write _w(b"ENVELOPE " + collapseNestedLists([getEnvelope(msg)])) def spew_flags(self, id, msg, _w=None, _f=None): if _w is None: _w = self.transport.writen encodedFlags = [networkString(flag) for flag in msg.getFlags()] _w(b"FLAGS " + b"(" + b" ".join(encodedFlags) + b")") def spew_internaldate(self, id, msg, _w=None, _f=None): if _w is None: _w = self.transport.write idate = msg.getInternalDate() ttup = email.utils.parsedate_tz(nativeString(idate)) if ttup is None: log.msg("%d:%r: unpareseable internaldate: %r" % (id, msg, idate)) raise IMAP4Exception("Internal failure generating INTERNALDATE") # need to specify the month manually, as strftime depends on locale strdate = time.strftime("%d-%%s-%Y %H:%M:%S ", ttup[:9]) odate = networkString(strdate % (_MONTH_NAMES[ttup[1]],)) if ttup[9] is None: odate = odate + b"+0000" else: if ttup[9] >= 0: sign = b"+" else: sign = b"-" odate = ( odate + sign + b"%04d" % ((abs(ttup[9]) // 3600) * 100 + (abs(ttup[9]) % 3600) // 60,) ) _w(b"INTERNALDATE " + _quote(odate)) def spew_rfc822header(self, id, msg, _w=None, _f=None): if _w is None: _w = self.transport.write hdrs = _formatHeaders(msg.getHeaders(True)) _w(b"RFC822.HEADER " + _literal(hdrs)) def spew_rfc822text(self, id, msg, _w=None, _f=None): if _w is None: _w = self.transport.write _w(b"RFC822.TEXT ") _f() return FileProducer(msg.getBodyFile()).beginProducing(self.transport) def spew_rfc822size(self, id, msg, _w=None, _f=None): if _w is None: _w = self.transport.write _w(b"RFC822.SIZE %d" % (msg.getSize(),)) def spew_rfc822(self, id, msg, _w=None, _f=None): if _w is None: _w = self.transport.write _w(b"RFC822 ") _f() mf = IMessageFile(msg, None) if mf is not None: return FileProducer(mf.open()).beginProducing(self.transport) return MessageProducer(msg, None, self._scheduler).beginProducing( self.transport ) def spew_uid(self, id, msg, _w=None, _f=None): if _w is None: _w = self.transport.write _w(b"UID %d" % (msg.getUID(),)) def spew_bodystructure(self, id, msg, _w=None, _f=None): _w(b"BODYSTRUCTURE " + collapseNestedLists([getBodyStructure(msg, True)])) def spew_body(self, part, id, msg, _w=None, _f=None): if _w is None: _w = self.transport.write for p in part.part: if msg.isMultipart(): msg = msg.getSubPart(p) elif p > 0: # Non-multipart messages have an implicit first part but no # other parts - reject any request for any other part. raise TypeError("Requested subpart of non-multipart message") if part.header: hdrs = msg.getHeaders(part.header.negate, *part.header.fields) hdrs = _formatHeaders(hdrs) _w(part.__bytes__() + b" " + _literal(hdrs)) elif part.text: _w(part.__bytes__() + b" ") _f() return FileProducer(msg.getBodyFile()).beginProducing(self.transport) elif part.mime: hdrs = _formatHeaders(msg.getHeaders(True)) _w(part.__bytes__() + b" " + _literal(hdrs)) elif part.empty: _w(part.__bytes__() + b" ") _f() if part.part: return FileProducer(msg.getBodyFile()).beginProducing(self.transport) else: mf = IMessageFile(msg, None) if mf is not None: return FileProducer(mf.open()).beginProducing(self.transport) return MessageProducer(msg, None, self._scheduler).beginProducing( self.transport ) else: _w(b"BODY " + collapseNestedLists([getBodyStructure(msg)])) def spewMessage(self, id, msg, query, uid): wbuf = WriteBuffer(self.transport) write = wbuf.write flush = wbuf.flush def start(): write(b"* %d FETCH (" % (id,)) def finish(): write(b")\r\n") def space(): write(b" ") def spew(): seenUID = False start() for part in query: if part.type == "uid": seenUID = True if part.type == "body": yield self.spew_body(part, id, msg, write, flush) else: f = getattr(self, "spew_" + part.type) yield f(id, msg, write, flush) if part is not query[-1]: space() if uid and not seenUID: space() yield self.spew_uid(id, msg, write, flush) finish() flush() return self._scheduler(spew()) def __ebFetch(self, failure, tag): self.setTimeout(self._oldTimeout) del self._oldTimeout log.err(failure) self.sendBadResponse(tag, b"FETCH failed: " + networkString(str(failure.value))) def do_STORE(self, tag, messages, mode, flags, uid=0): mode = mode.upper() silent = mode.endswith(b"SILENT") if mode.startswith(b"+"): mode = 1 elif mode.startswith(b"-"): mode = -1 else: mode = 0 flags = [nativeString(flag) for flag in flags] maybeDeferred(self.mbox.store, messages, flags, mode, uid=uid).addCallbacks( self.__cbStore, self.__ebStore, (tag, self.mbox, uid, silent), None, (tag,), None, ) select_STORE = (do_STORE, arg_seqset, arg_atom, arg_flaglist) def __cbStore(self, result, tag, mbox, uid, silent): if result and not silent: for (k, v) in result.items(): if uid: uidstr = b" UID %d" % (mbox.getUID(k),) else: uidstr = b"" flags = [networkString(flag) for flag in v] self.sendUntaggedResponse( b"%d FETCH (FLAGS (%b)%b)" % (k, b" ".join(flags), uidstr) ) self.sendPositiveResponse(tag, b"STORE completed") def __ebStore(self, failure, tag): self.sendBadResponse(tag, b"Server error: " + networkString(str(failure.value))) def do_COPY(self, tag, messages, mailbox, uid=0): mailbox = _parseMbox(mailbox) maybeDeferred(self.account.select, mailbox).addCallback( self._cbCopySelectedMailbox, tag, messages, mailbox, uid ).addErrback(self._ebCopySelectedMailbox, tag) select_COPY = (do_COPY, arg_seqset, arg_finalastring) def _cbCopySelectedMailbox(self, mbox, tag, messages, mailbox, uid): if not mbox: self.sendNegativeResponse(tag, "No such mailbox: " + mailbox) else: maybeDeferred(self.mbox.fetch, messages, uid).addCallback( self.__cbCopy, tag, mbox ).addCallback(self.__cbCopied, tag, mbox).addErrback(self.__ebCopy, tag) def _ebCopySelectedMailbox(self, failure, tag): self.sendBadResponse(tag, b"Server error: " + networkString(str(failure.value))) def __cbCopy(self, messages, tag, mbox): # XXX - This should handle failures with a rollback or something addedDeferreds = [] fastCopyMbox = IMessageCopier(mbox, None) for (id, msg) in messages: if fastCopyMbox is not None: d = maybeDeferred(fastCopyMbox.copy, msg) addedDeferreds.append(d) continue # XXX - The following should be an implementation of IMessageCopier.copy # on an IMailbox->IMessageCopier adapter. flags = msg.getFlags() date = msg.getInternalDate() body = IMessageFile(msg, None) if body is not None: bodyFile = body.open() d = maybeDeferred(mbox.addMessage, bodyFile, flags, date) else: def rewind(f): f.seek(0) return f buffer = tempfile.TemporaryFile() d = ( MessageProducer(msg, buffer, self._scheduler) .beginProducing(None) .addCallback( lambda _, b=buffer, f=flags, d=date: mbox.addMessage( rewind(b), f, d ) ) ) addedDeferreds.append(d) return defer.DeferredList(addedDeferreds) def __cbCopied(self, deferredIds, tag, mbox): ids = [] failures = [] for (status, result) in deferredIds: if status: ids.append(result) else: failures.append(result.value) if failures: self.sendNegativeResponse(tag, "[ALERT] Some messages were not copied") else: self.sendPositiveResponse(tag, b"COPY completed") def __ebCopy(self, failure, tag): self.sendBadResponse(tag, b"COPY failed:" + networkString(str(failure.value))) log.err(failure) def do_UID(self, tag, command, line): command = command.upper() if command not in (b"COPY", b"FETCH", b"STORE", b"SEARCH"): raise IllegalClientResponse(command) self.dispatchCommand(tag, command, line, uid=1) select_UID = (do_UID, arg_atom, arg_line) # # IMailboxListener implementation # def modeChanged(self, writeable): if writeable: self.sendUntaggedResponse(message=b"[READ-WRITE]", isAsync=True) else: self.sendUntaggedResponse(message=b"[READ-ONLY]", isAsync=True) def flagsChanged(self, newFlags): for (mId, flags) in newFlags.items(): encodedFlags = [networkString(flag) for flag in flags] msg = b"%d FETCH (FLAGS (%b))" % (mId, b" ".join(encodedFlags)) self.sendUntaggedResponse(msg, isAsync=True) def newMessages(self, exists, recent): if exists is not None: self.sendUntaggedResponse(b"%d EXISTS" % (exists,), isAsync=True) if recent is not None: self.sendUntaggedResponse(b"%d RECENT" % (recent,), isAsync=True) TIMEOUT_ERROR = error.TimeoutError() @implementer(IMailboxListener) class IMAP4Client(basic.LineReceiver, policies.TimeoutMixin): """IMAP4 client protocol implementation @ivar state: A string representing the state the connection is currently in. """ tags = None waiting = None queued = None tagID = 1 state = None startedTLS = False # Number of seconds to wait before timing out a connection. # If the number is <= 0 no timeout checking will be performed. timeout = 0 # Capabilities are not allowed to change during the session # So cache the first response and use that for all later # lookups _capCache = None _memoryFileLimit = 1024 * 1024 * 10 # Authentication is pluggable. This maps names to IClientAuthentication # objects. authenticators = None STATUS_CODES = ("OK", "NO", "BAD", "PREAUTH", "BYE") STATUS_TRANSFORMATIONS = {"MESSAGES": int, "RECENT": int, "UNSEEN": int} context = None def __init__(self, contextFactory=None): self.tags = {} self.queued = [] self.authenticators = {} self.context = contextFactory self._tag = None self._parts = None self._lastCmd = None def registerAuthenticator(self, auth): """ Register a new form of authentication When invoking the authenticate() method of IMAP4Client, the first matching authentication scheme found will be used. The ordering is that in which the server lists support authentication schemes. @type auth: Implementor of C{IClientAuthentication} @param auth: The object to use to perform the client side of this authentication scheme. """ self.authenticators[auth.getName().upper()] = auth def rawDataReceived(self, data): if self.timeout > 0: self.resetTimeout() self._pendingSize -= len(data) if self._pendingSize > 0: self._pendingBuffer.write(data) else: passon = b"" if self._pendingSize < 0: data, passon = data[: self._pendingSize], data[self._pendingSize :] self._pendingBuffer.write(data) rest = self._pendingBuffer self._pendingBuffer = None self._pendingSize = None rest.seek(0, 0) self._parts.append(rest.read()) self.setLineMode(passon.lstrip(b"\r\n")) # def sendLine(self, line): # print 'S:', repr(line) # return basic.LineReceiver.sendLine(self, line) def _setupForLiteral(self, rest, octets): self._pendingBuffer = self.messageFile(octets) self._pendingSize = octets if self._parts is None: self._parts = [rest, b"\r\n"] else: self._parts.extend([rest, b"\r\n"]) self.setRawMode() def connectionMade(self): if self.timeout > 0: self.setTimeout(self.timeout) def connectionLost(self, reason): """ We are no longer connected """ if self.timeout > 0: self.setTimeout(None) if self.queued is not None: queued = self.queued self.queued = None for cmd in queued: cmd.defer.errback(reason) if self.tags is not None: tags = self.tags self.tags = None for cmd in tags.values(): if cmd is not None and cmd.defer is not None: cmd.defer.errback(reason) def lineReceived(self, line): """ Attempt to parse a single line from the server. @type line: L{bytes} @param line: The line from the server, without the line delimiter. @raise IllegalServerResponse: If the line or some part of the line does not represent an allowed message from the server at this time. """ # print('C: ' + repr(line)) if self.timeout > 0: self.resetTimeout() lastPart = line.rfind(b"{") if lastPart != -1: lastPart = line[lastPart + 1 :] if lastPart.endswith(b"}"): # It's a literal a-comin' in try: octets = int(lastPart[:-1]) except ValueError: raise IllegalServerResponse(line) if self._parts is None: self._tag, parts = line.split(None, 1) else: parts = line self._setupForLiteral(parts, octets) return if self._parts is None: # It isn't a literal at all self._regularDispatch(line) else: # If an expression is in progress, no tag is required here # Since we didn't find a literal indicator, this expression # is done. self._parts.append(line) tag, rest = self._tag, b"".join(self._parts) self._tag = self._parts = None self.dispatchCommand(tag, rest) def timeoutConnection(self): if self._lastCmd and self._lastCmd.defer is not None: d, self._lastCmd.defer = self._lastCmd.defer, None d.errback(TIMEOUT_ERROR) if self.queued: for cmd in self.queued: if cmd.defer is not None: d, cmd.defer = cmd.defer, d d.errback(TIMEOUT_ERROR) self.transport.loseConnection() def _regularDispatch(self, line): parts = line.split(None, 1) if len(parts) != 2: parts.append(b"") tag, rest = parts self.dispatchCommand(tag, rest) def messageFile(self, octets): """ Create a file to which an incoming message may be written. @type octets: L{int} @param octets: The number of octets which will be written to the file @rtype: Any object which implements C{write(string)} and C{seek(int, int)} @return: A file-like object """ if octets > self._memoryFileLimit: return tempfile.TemporaryFile() else: return BytesIO() def makeTag(self): tag = ("%0.4X" % self.tagID).encode("ascii") self.tagID += 1 return tag def dispatchCommand(self, tag, rest): if self.state is None: f = self.response_UNAUTH else: f = getattr(self, "response_" + self.state.upper(), None) if f: try: f(tag, rest) except BaseException: log.err() self.transport.loseConnection() else: log.err(f"Cannot dispatch: {self.state}, {tag!r}, {rest!r}") self.transport.loseConnection() def response_UNAUTH(self, tag, rest): if self.state is None: # Server greeting, this is status, rest = rest.split(None, 1) if status.upper() == b"OK": self.state = "unauth" elif status.upper() == b"PREAUTH": self.state = "auth" else: # XXX - This is rude. self.transport.loseConnection() raise IllegalServerResponse(tag + b" " + rest) b, e = rest.find(b"["), rest.find(b"]") if b != -1 and e != -1: self.serverGreeting( self.__cbCapabilities(([parseNestedParens(rest[b + 1 : e])], None)) ) else: self.serverGreeting(None) else: self._defaultHandler(tag, rest) def response_AUTH(self, tag, rest): self._defaultHandler(tag, rest) def _defaultHandler(self, tag, rest): if tag == b"*" or tag == b"+": if not self.waiting: self._extraInfo([parseNestedParens(rest)]) else: cmd = self.tags[self.waiting] if tag == b"+": cmd.continuation(rest) else: cmd.lines.append(rest) else: try: cmd = self.tags[tag] except KeyError: # XXX - This is rude. self.transport.loseConnection() raise IllegalServerResponse(tag + b" " + rest) else: status, line = rest.split(None, 1) if status == b"OK": # Give them this last line, too cmd.finish(rest, self._extraInfo) else: cmd.defer.errback(IMAP4Exception(line)) del self.tags[tag] self.waiting = None self._flushQueue() def _flushQueue(self): if self.queued: cmd = self.queued.pop(0) t = self.makeTag() self.tags[t] = cmd self.sendLine(cmd.format(t)) self.waiting = t def _extraInfo(self, lines): # XXX - This is terrible. # XXX - Also, this should collapse temporally proximate calls into single # invocations of IMailboxListener methods, where possible. flags = {} recent = exists = None for response in lines: elements = len(response) if elements == 1 and response[0] == [b"READ-ONLY"]: self.modeChanged(False) elif elements == 1 and response[0] == [b"READ-WRITE"]: self.modeChanged(True) elif elements == 2 and response[1] == b"EXISTS": exists = int(response[0]) elif elements == 2 and response[1] == b"RECENT": recent = int(response[0]) elif elements == 3 and response[1] == b"FETCH": mId = int(response[0]) values, _ = self._parseFetchPairs(response[2]) flags.setdefault(mId, []).extend(values.get("FLAGS", ())) else: log.msg(f"Unhandled unsolicited response: {response}") if flags: self.flagsChanged(flags) if recent is not None or exists is not None: self.newMessages(exists, recent) def sendCommand(self, cmd): cmd.defer = defer.Deferred() if self.waiting: self.queued.append(cmd) return cmd.defer t = self.makeTag() self.tags[t] = cmd self.sendLine(cmd.format(t)) self.waiting = t self._lastCmd = cmd return cmd.defer def getCapabilities(self, useCache=1): """ Request the capabilities available on this server. This command is allowed in any state of connection. @type useCache: C{bool} @param useCache: Specify whether to use the capability-cache or to re-retrieve the capabilities from the server. Server capabilities should never change, so for normal use, this flag should never be false. @rtype: L{Deferred} @return: A deferred whose callback will be invoked with a dictionary mapping capability types to lists of supported mechanisms, or to None if a support list is not applicable. """ if useCache and self._capCache is not None: return defer.succeed(self._capCache) cmd = b"CAPABILITY" resp = (b"CAPABILITY",) d = self.sendCommand(Command(cmd, wantResponse=resp)) d.addCallback(self.__cbCapabilities) return d def __cbCapabilities(self, result): (lines, tagline) = result caps = {} for rest in lines: for cap in rest[1:]: parts = cap.split(b"=", 1) if len(parts) == 1: category, value = parts[0], None else: category, value = parts caps.setdefault(category, []).append(value) # Preserve a non-ideal API for backwards compatibility. It would # probably be entirely sensible to have an object with a wider API than # dict here so this could be presented less insanely. for category in caps: if caps[category] == [None]: caps[category] = None self._capCache = caps return caps def logout(self): """ Inform the server that we are done with the connection. This command is allowed in any state of connection. @rtype: L{Deferred} @return: A deferred whose callback will be invoked with None when the proper server acknowledgement has been received. """ d = self.sendCommand(Command(b"LOGOUT", wantResponse=(b"BYE",))) d.addCallback(self.__cbLogout) return d def __cbLogout(self, result): (lines, tagline) = result self.transport.loseConnection() # We don't particularly care what the server said return None def noop(self): """ Perform no operation. This command is allowed in any state of connection. @rtype: L{Deferred} @return: A deferred whose callback will be invoked with a list of untagged status updates the server responds with. """ d = self.sendCommand(Command(b"NOOP")) d.addCallback(self.__cbNoop) return d def __cbNoop(self, result): # Conceivable, this is elidable. # It is, afterall, a no-op. (lines, tagline) = result return lines def startTLS(self, contextFactory=None): """ Initiates a 'STARTTLS' request and negotiates the TLS / SSL Handshake. @param contextFactory: The TLS / SSL Context Factory to leverage. If the contextFactory is None the IMAP4Client will either use the current TLS / SSL Context Factory or attempt to create a new one. @type contextFactory: C{ssl.ClientContextFactory} @return: A Deferred which fires when the transport has been secured according to the given contextFactory, or which fails if the transport cannot be secured. """ assert ( not self.startedTLS ), "Client and Server are currently communicating via TLS" if contextFactory is None: contextFactory = self._getContextFactory() if contextFactory is None: return defer.fail( IMAP4Exception( "IMAP4Client requires a TLS context to " "initiate the STARTTLS handshake" ) ) if b"STARTTLS" not in self._capCache: return defer.fail( IMAP4Exception( "Server does not support secure communication " "via TLS / SSL" ) ) tls = interfaces.ITLSTransport(self.transport, None) if tls is None: return defer.fail( IMAP4Exception( "IMAP4Client transport does not implement " "interfaces.ITLSTransport" ) ) d = self.sendCommand(Command(b"STARTTLS")) d.addCallback(self._startedTLS, contextFactory) d.addCallback(lambda _: self.getCapabilities()) return d def authenticate(self, secret): """ Attempt to enter the authenticated state with the server This command is allowed in the Non-Authenticated state. @rtype: L{Deferred} @return: A deferred whose callback is invoked if the authentication succeeds and whose errback will be invoked otherwise. """ if self._capCache is None: d = self.getCapabilities() else: d = defer.succeed(self._capCache) d.addCallback(self.__cbAuthenticate, secret) return d def __cbAuthenticate(self, caps, secret): auths = caps.get(b"AUTH", ()) for scheme in auths: if scheme.upper() in self.authenticators: cmd = Command( b"AUTHENTICATE", scheme, (), self.__cbContinueAuth, scheme, secret ) return self.sendCommand(cmd) if self.startedTLS: return defer.fail( NoSupportedAuthentication(auths, self.authenticators.keys()) ) else: def ebStartTLS(err): err.trap(IMAP4Exception) # We couldn't negotiate TLS for some reason return defer.fail( NoSupportedAuthentication(auths, self.authenticators.keys()) ) d = self.startTLS() d.addErrback(ebStartTLS) d.addCallback(lambda _: self.getCapabilities()) d.addCallback(self.__cbAuthTLS, secret) return d def __cbContinueAuth(self, rest, scheme, secret): try: chal = decodebytes(rest + b"\n") except binascii.Error: self.sendLine(b"*") raise IllegalServerResponse(rest) else: auth = self.authenticators[scheme] chal = auth.challengeResponse(secret, chal) self.sendLine(encodebytes(chal).strip()) def __cbAuthTLS(self, caps, secret): auths = caps.get(b"AUTH", ()) for scheme in auths: if scheme.upper() in self.authenticators: cmd = Command( b"AUTHENTICATE", scheme, (), self.__cbContinueAuth, scheme, secret ) return self.sendCommand(cmd) raise NoSupportedAuthentication(auths, self.authenticators.keys()) def login(self, username, password): """ Authenticate with the server using a username and password This command is allowed in the Non-Authenticated state. If the server supports the STARTTLS capability and our transport supports TLS, TLS is negotiated before the login command is issued. A more secure way to log in is to use C{startTLS} or C{authenticate} or both. @type username: L{str} @param username: The username to log in with @type password: L{str} @param password: The password to log in with @rtype: L{Deferred} @return: A deferred whose callback is invoked if login is successful and whose errback is invoked otherwise. """ d = maybeDeferred(self.getCapabilities) d.addCallback(self.__cbLoginCaps, username, password) return d def serverGreeting(self, caps): """ Called when the server has sent us a greeting. @type caps: C{dict} @param caps: Capabilities the server advertised in its greeting. """ def _getContextFactory(self): if self.context is not None: return self.context try: from twisted.internet import ssl except ImportError: return None else: context = ssl.ClientContextFactory() context.method = ssl.SSL.TLSv1_METHOD return context def __cbLoginCaps(self, capabilities, username, password): # If the server advertises STARTTLS, we might want to try to switch to TLS tryTLS = b"STARTTLS" in capabilities # If our transport supports switching to TLS, we might want to try to switch to TLS. tlsableTransport = interfaces.ITLSTransport(self.transport, None) is not None # If our transport is not already using TLS, we might want to try to switch to TLS. nontlsTransport = interfaces.ISSLTransport(self.transport, None) is None if not self.startedTLS and tryTLS and tlsableTransport and nontlsTransport: d = self.startTLS() d.addCallbacks( self.__cbLoginTLS, self.__ebLoginTLS, callbackArgs=(username, password), ) return d else: if nontlsTransport: log.msg("Server has no TLS support. logging in over cleartext!") args = b" ".join((_quote(username), _quote(password))) return self.sendCommand(Command(b"LOGIN", args)) def _startedTLS(self, result, context): self.transport.startTLS(context) self._capCache = None self.startedTLS = True return result def __cbLoginTLS(self, result, username, password): args = b" ".join((_quote(username), _quote(password))) return self.sendCommand(Command(b"LOGIN", args)) def __ebLoginTLS(self, failure): log.err(failure) return failure def namespace(self): """ Retrieve information about the namespaces available to this account This command is allowed in the Authenticated and Selected states. @rtype: L{Deferred} @return: A deferred whose callback is invoked with namespace information. An example of this information is:: [[['', '/']], [], []] which indicates a single personal namespace called '' with '/' as its hierarchical delimiter, and no shared or user namespaces. """ cmd = b"NAMESPACE" resp = (b"NAMESPACE",) d = self.sendCommand(Command(cmd, wantResponse=resp)) d.addCallback(self.__cbNamespace) return d def __cbNamespace(self, result): (lines, last) = result # Namespaces and their delimiters qualify and delimit # mailboxes, so they should be native strings # # On Python 2, no decoding is necessary to maintain # the API contract. # # On Python 3, users specify mailboxes with native strings, so # they should receive namespaces and delimiters as native # strings. Both cases are possible because of the imap4-utf-7 # encoding. def _prepareNamespaceOrDelimiter(namespaceList): return [element.decode("imap4-utf-7") for element in namespaceList] for parts in lines: if len(parts) == 4 and parts[0] == b"NAMESPACE": return [ [] if pairOrNone is None else [_prepareNamespaceOrDelimiter(value) for value in pairOrNone] for pairOrNone in parts[1:] ] log.err("No NAMESPACE response to NAMESPACE command") return [[], [], []] def select(self, mailbox): """ Select a mailbox This command is allowed in the Authenticated and Selected states. @type mailbox: L{str} @param mailbox: The name of the mailbox to select @rtype: L{Deferred} @return: A deferred whose callback is invoked with mailbox information if the select is successful and whose errback is invoked otherwise. Mailbox information consists of a dictionary with the following L{str} keys and values:: FLAGS: A list of strings containing the flags settable on messages in this mailbox. EXISTS: An integer indicating the number of messages in this mailbox. RECENT: An integer indicating the number of "recent" messages in this mailbox. UNSEEN: The message sequence number (an integer) of the first unseen message in the mailbox. PERMANENTFLAGS: A list of strings containing the flags that can be permanently set on messages in this mailbox. UIDVALIDITY: An integer uniquely identifying this mailbox. """ cmd = b"SELECT" args = _prepareMailboxName(mailbox) # This appears not to be used, so we can use native strings to # indicate that the return type is native strings. resp = ("FLAGS", "EXISTS", "RECENT", "UNSEEN", "PERMANENTFLAGS", "UIDVALIDITY") d = self.sendCommand(Command(cmd, args, wantResponse=resp)) d.addCallback(self.__cbSelect, 1) return d def examine(self, mailbox): """ Select a mailbox in read-only mode This command is allowed in the Authenticated and Selected states. @type mailbox: L{str} @param mailbox: The name of the mailbox to examine @rtype: L{Deferred} @return: A deferred whose callback is invoked with mailbox information if the examine is successful and whose errback is invoked otherwise. Mailbox information consists of a dictionary with the following keys and values:: 'FLAGS': A list of strings containing the flags settable on messages in this mailbox. 'EXISTS': An integer indicating the number of messages in this mailbox. 'RECENT': An integer indicating the number of \"recent\" messages in this mailbox. 'UNSEEN': An integer indicating the number of messages not flagged \\Seen in this mailbox. 'PERMANENTFLAGS': A list of strings containing the flags that can be permanently set on messages in this mailbox. 'UIDVALIDITY': An integer uniquely identifying this mailbox. """ cmd = b"EXAMINE" args = _prepareMailboxName(mailbox) resp = ( b"FLAGS", b"EXISTS", b"RECENT", b"UNSEEN", b"PERMANENTFLAGS", b"UIDVALIDITY", ) d = self.sendCommand(Command(cmd, args, wantResponse=resp)) d.addCallback(self.__cbSelect, 0) return d def _intOrRaise(self, value, phrase): """ Parse C{value} as an integer and return the result or raise L{IllegalServerResponse} with C{phrase} as an argument if C{value} cannot be parsed as an integer. """ try: return int(value) except ValueError: raise IllegalServerResponse(phrase) def __cbSelect(self, result, rw): """ Handle lines received in response to a SELECT or EXAMINE command. See RFC 3501, section 6.3.1. """ (lines, tagline) = result # In the absence of specification, we are free to assume: # READ-WRITE access datum = {"READ-WRITE": rw} lines.append(parseNestedParens(tagline)) for split in lines: if len(split) > 0 and split[0].upper() == b"OK": # Handle all the kinds of OK response. content = split[1] if isinstance(content, list): key = content[0] else: # not multi-valued, like OK LOGIN key = content key = key.upper() if key == b"READ-ONLY": datum["READ-WRITE"] = False elif key == b"READ-WRITE": datum["READ-WRITE"] = True elif key == b"UIDVALIDITY": datum["UIDVALIDITY"] = self._intOrRaise(content[1], split) elif key == b"UNSEEN": datum["UNSEEN"] = self._intOrRaise(content[1], split) elif key == b"UIDNEXT": datum["UIDNEXT"] = self._intOrRaise(content[1], split) elif key == b"PERMANENTFLAGS": datum["PERMANENTFLAGS"] = tuple( nativeString(flag) for flag in content[1] ) else: log.err(f"Unhandled SELECT response (2): {split}") elif len(split) == 2: # Handle FLAGS, EXISTS, and RECENT if split[0].upper() == b"FLAGS": datum["FLAGS"] = tuple(nativeString(flag) for flag in split[1]) elif isinstance(split[1], bytes): # Must make sure things are strings before treating them as # strings since some other forms of response have nesting in # places which results in lists instead. if split[1].upper() == b"EXISTS": datum["EXISTS"] = self._intOrRaise(split[0], split) elif split[1].upper() == b"RECENT": datum["RECENT"] = self._intOrRaise(split[0], split) else: log.err(f"Unhandled SELECT response (0): {split}") else: log.err(f"Unhandled SELECT response (1): {split}") else: log.err(f"Unhandled SELECT response (4): {split}") return datum def create(self, name): """ Create a new mailbox on the server This command is allowed in the Authenticated and Selected states. @type name: L{str} @param name: The name of the mailbox to create. @rtype: L{Deferred} @return: A deferred whose callback is invoked if the mailbox creation is successful and whose errback is invoked otherwise. """ return self.sendCommand(Command(b"CREATE", _prepareMailboxName(name))) def delete(self, name): """ Delete a mailbox This command is allowed in the Authenticated and Selected states. @type name: L{str} @param name: The name of the mailbox to delete. @rtype: L{Deferred} @return: A deferred whose calblack is invoked if the mailbox is deleted successfully and whose errback is invoked otherwise. """ return self.sendCommand(Command(b"DELETE", _prepareMailboxName(name))) def rename(self, oldname, newname): """ Rename a mailbox This command is allowed in the Authenticated and Selected states. @type oldname: L{str} @param oldname: The current name of the mailbox to rename. @type newname: L{str} @param newname: The new name to give the mailbox. @rtype: L{Deferred} @return: A deferred whose callback is invoked if the rename is successful and whose errback is invoked otherwise. """ oldname = _prepareMailboxName(oldname) newname = _prepareMailboxName(newname) return self.sendCommand(Command(b"RENAME", b" ".join((oldname, newname)))) def subscribe(self, name): """ Add a mailbox to the subscription list This command is allowed in the Authenticated and Selected states. @type name: L{str} @param name: The mailbox to mark as 'active' or 'subscribed' @rtype: L{Deferred} @return: A deferred whose callback is invoked if the subscription is successful and whose errback is invoked otherwise. """ return self.sendCommand(Command(b"SUBSCRIBE", _prepareMailboxName(name))) def unsubscribe(self, name): """ Remove a mailbox from the subscription list This command is allowed in the Authenticated and Selected states. @type name: L{str} @param name: The mailbox to unsubscribe @rtype: L{Deferred} @return: A deferred whose callback is invoked if the unsubscription is successful and whose errback is invoked otherwise. """ return self.sendCommand(Command(b"UNSUBSCRIBE", _prepareMailboxName(name))) def list(self, reference, wildcard): """ List a subset of the available mailboxes This command is allowed in the Authenticated and Selected states. @type reference: L{str} @param reference: The context in which to interpret C{wildcard} @type wildcard: L{str} @param wildcard: The pattern of mailbox names to match, optionally including either or both of the '*' and '%' wildcards. '*' will match zero or more characters and cross hierarchical boundaries. '%' will also match zero or more characters, but is limited to a single hierarchical level. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a list of L{tuple}s, the first element of which is a L{tuple} of mailbox flags, the second element of which is the hierarchy delimiter for this mailbox, and the third of which is the mailbox name; if the command is unsuccessful, the deferred's errback is invoked instead. B{NB}: the delimiter and the mailbox name are L{str}s. """ cmd = b"LIST" args = (f'"{reference}" "{wildcard}"').encode("imap4-utf-7") resp = (b"LIST",) d = self.sendCommand(Command(cmd, args, wantResponse=resp)) d.addCallback(self.__cbList, b"LIST") return d def lsub(self, reference, wildcard): """ List a subset of the subscribed available mailboxes This command is allowed in the Authenticated and Selected states. The parameters and returned object are the same as for the L{list} method, with one slight difference: Only mailboxes which have been subscribed can be included in the resulting list. """ cmd = b"LSUB" encodedReference = reference.encode("ascii") encodedWildcard = wildcard.encode("imap4-utf-7") args = b"".join( [ b'"', encodedReference, b'"' b' "', encodedWildcard, b'"', ] ) resp = (b"LSUB",) d = self.sendCommand(Command(cmd, args, wantResponse=resp)) d.addCallback(self.__cbList, b"LSUB") return d def __cbList(self, result, command): (lines, last) = result results = [] for parts in lines: if len(parts) == 4 and parts[0] == command: # flags parts[1] = tuple(nativeString(flag) for flag in parts[1]) # The mailbox should be a native string. # On Python 2, this maintains the API's contract. # # On Python 3, users specify mailboxes with native # strings, so they should receive mailboxes as native # strings. Both cases are possible because of the # imap4-utf-7 encoding. # # Mailbox names contain the hierarchical delimiter, so # it too should be a native string. # delimiter parts[2] = parts[2].decode("imap4-utf-7") # mailbox parts[3] = parts[3].decode("imap4-utf-7") results.append(tuple(parts[1:])) return results _statusNames = { name: name.encode("ascii") for name in ( "MESSAGES", "RECENT", "UIDNEXT", "UIDVALIDITY", "UNSEEN", ) } def status(self, mailbox, *names): """ Retrieve the status of the given mailbox This command is allowed in the Authenticated and Selected states. @type mailbox: L{str} @param mailbox: The name of the mailbox to query @type names: L{bytes} @param names: The status names to query. These may be any number of: C{'MESSAGES'}, C{'RECENT'}, C{'UIDNEXT'}, C{'UIDVALIDITY'}, and C{'UNSEEN'}. @rtype: L{Deferred} @return: A deferred which fires with the status information if the command is successful and whose errback is invoked otherwise. The status information is in the form of a C{dict}. Each element of C{names} is a key in the dictionary. The value for each key is the corresponding response from the server. """ cmd = b"STATUS" preparedMailbox = _prepareMailboxName(mailbox) try: names = b" ".join(self._statusNames[name] for name in names) except KeyError: raise ValueError(f"Unknown names: {set(names) - set(self._statusNames)!r}") args = b"".join([preparedMailbox, b" (", names, b")"]) resp = (b"STATUS",) d = self.sendCommand(Command(cmd, args, wantResponse=resp)) d.addCallback(self.__cbStatus) return d def __cbStatus(self, result): (lines, last) = result status = {} for parts in lines: if parts[0] == b"STATUS": items = parts[2] items = [items[i : i + 2] for i in range(0, len(items), 2)] for k, v in items: try: status[nativeString(k)] = v except UnicodeDecodeError: raise IllegalServerResponse(repr(items)) for k in status.keys(): t = self.STATUS_TRANSFORMATIONS.get(k) if t: try: status[k] = t(status[k]) except Exception as e: raise IllegalServerResponse( "(" + k + " " + status[k] + "): " + str(e) ) return status def append(self, mailbox, message, flags=(), date=None): """ Add the given message to the given mailbox. This command is allowed in the Authenticated and Selected states. @type mailbox: L{str} @param mailbox: The mailbox to which to add this message. @type message: Any file-like object opened in B{binary mode}. @param message: The message to add, in RFC822 format. Newlines in this file should be \\r\\n-style. @type flags: Any iterable of L{str} @param flags: The flags to associated with this message. @type date: L{str} @param date: The date to associate with this message. This should be of the format DD-MM-YYYY HH:MM:SS +/-HHMM. For example, in Eastern Standard Time, on July 1st 2004 at half past 1 PM, \"01-07-2004 13:30:00 -0500\". @rtype: L{Deferred} @return: A deferred whose callback is invoked when this command succeeds or whose errback is invoked if it fails. """ message.seek(0, 2) L = message.tell() message.seek(0, 0) if date: date = networkString(' "%s"' % nativeString(date)) else: date = b"" encodedFlags = [networkString(flag) for flag in flags] cmd = b"%b (%b)%b {%d}" % ( _prepareMailboxName(mailbox), b" ".join(encodedFlags), date, L, ) d = self.sendCommand( Command(b"APPEND", cmd, (), self.__cbContinueAppend, message) ) return d def __cbContinueAppend(self, lines, message): s = basic.FileSender() return s.beginFileTransfer(message, self.transport, None).addCallback( self.__cbFinishAppend ) def __cbFinishAppend(self, foo): self.sendLine(b"") def check(self): """ Tell the server to perform a checkpoint This command is allowed in the Selected state. @rtype: L{Deferred} @return: A deferred whose callback is invoked when this command succeeds or whose errback is invoked if it fails. """ return self.sendCommand(Command(b"CHECK")) def close(self): """ Return the connection to the Authenticated state. This command is allowed in the Selected state. Issuing this command will also remove all messages flagged \\Deleted from the selected mailbox if it is opened in read-write mode, otherwise it indicates success by no messages are removed. @rtype: L{Deferred} @return: A deferred whose callback is invoked when the command completes successfully or whose errback is invoked if it fails. """ return self.sendCommand(Command(b"CLOSE")) def expunge(self): """ Return the connection to the Authenticate state. This command is allowed in the Selected state. Issuing this command will perform the same actions as issuing the close command, but will also generate an 'expunge' response for every message deleted. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a list of the 'expunge' responses when this command is successful or whose errback is invoked otherwise. """ cmd = b"EXPUNGE" resp = (b"EXPUNGE",) d = self.sendCommand(Command(cmd, wantResponse=resp)) d.addCallback(self.__cbExpunge) return d def __cbExpunge(self, result): (lines, last) = result ids = [] for parts in lines: if len(parts) == 2 and parts[1] == b"EXPUNGE": ids.append(self._intOrRaise(parts[0], parts)) return ids def search(self, *queries, uid=False): """ Search messages in the currently selected mailbox This command is allowed in the Selected state. Any non-zero number of queries are accepted by this method, as returned by the C{Query}, C{Or}, and C{Not} functions. @param uid: if true, the server is asked to return message UIDs instead of message sequence numbers. @type uid: L{bool} @rtype: L{Deferred} @return: A deferred whose callback will be invoked with a list of all the message sequence numbers return by the search, or whose errback will be invoked if there is an error. """ # Queries should be encoded as ASCII unless a charset # identifier is provided. See #9201. queries = [query.encode("charmap") for query in queries] cmd = b"UID SEARCH" if uid else b"SEARCH" args = b" ".join(queries) d = self.sendCommand(Command(cmd, args, wantResponse=(cmd,))) d.addCallback(self.__cbSearch) return d def __cbSearch(self, result): (lines, end) = result ids = [] for parts in lines: if len(parts) > 0 and parts[0] == b"SEARCH": ids.extend([self._intOrRaise(p, parts) for p in parts[1:]]) return ids def fetchUID(self, messages, uid=0): """ Retrieve the unique identifier for one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message sequence numbers to unique message identifiers, or whose errback is invoked if there is an error. """ return self._fetch(messages, useUID=uid, uid=1) def fetchFlags(self, messages, uid=0): """ Retrieve the flags for one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: The messages for which to retrieve flags. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to lists of flags, or whose errback is invoked if there is an error. """ return self._fetch(messages, useUID=uid, flags=1) def fetchInternalDate(self, messages, uid=0): """ Retrieve the internal date associated with one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: The messages for which to retrieve the internal date. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to date strings, or whose errback is invoked if there is an error. Date strings take the format of \"day-month-year time timezone\". """ return self._fetch(messages, useUID=uid, internaldate=1) def fetchEnvelope(self, messages, uid=0): """ Retrieve the envelope data for one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: The messages for which to retrieve envelope data. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to envelope data, or whose errback is invoked if there is an error. Envelope data consists of a sequence of the date, subject, from, sender, reply-to, to, cc, bcc, in-reply-to, and message-id header fields. The date, subject, in-reply-to, and message-id fields are L{str}, while the from, sender, reply-to, to, cc, and bcc fields contain address data as L{str}s. Address data consists of a sequence of name, source route, mailbox name, and hostname. Fields which are not present for a particular address may be L{None}. """ return self._fetch(messages, useUID=uid, envelope=1) def fetchBodyStructure(self, messages, uid=0): """ Retrieve the structure of the body of one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: The messages for which to retrieve body structure data. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to body structure data, or whose errback is invoked if there is an error. Body structure data describes the MIME-IMB format of a message and consists of a sequence of mime type, mime subtype, parameters, content id, description, encoding, and size. The fields following the size field are variable: if the mime type/subtype is message/rfc822, the contained message's envelope information, body structure data, and number of lines of text; if the mime type is text, the number of lines of text. Extension fields may also be included; if present, they are: the MD5 hash of the body, body disposition, body language. """ return self._fetch(messages, useUID=uid, bodystructure=1) def fetchSimplifiedBody(self, messages, uid=0): """ Retrieve the simplified body structure of one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: C{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to body data, or whose errback is invoked if there is an error. The simplified body structure is the same as the body structure, except that extension fields will never be present. """ return self._fetch(messages, useUID=uid, body=1) def fetchMessage(self, messages, uid=0): """ Retrieve one or more entire messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: C{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A L{Deferred} which will fire with a C{dict} mapping message sequence numbers to C{dict}s giving message data for the corresponding message. If C{uid} is true, the inner dictionaries have a C{'UID'} key mapped to a L{str} giving the UID for the message. The text of the message is a L{str} associated with the C{'RFC822'} key in each dictionary. """ return self._fetch(messages, useUID=uid, rfc822=1) def fetchHeaders(self, messages, uid=0): """ Retrieve headers of one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to dicts of message headers, or whose errback is invoked if there is an error. """ return self._fetch(messages, useUID=uid, rfc822header=1) def fetchBody(self, messages, uid=0): """ Retrieve body text of one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to file-like objects containing body text, or whose errback is invoked if there is an error. """ return self._fetch(messages, useUID=uid, rfc822text=1) def fetchSize(self, messages, uid=0): """ Retrieve the size, in octets, of one or more messages This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to sizes, or whose errback is invoked if there is an error. """ return self._fetch(messages, useUID=uid, rfc822size=1) def fetchFull(self, messages, uid=0): """ Retrieve several different fields of one or more messages This command is allowed in the Selected state. This is equivalent to issuing all of the C{fetchFlags}, C{fetchInternalDate}, C{fetchSize}, C{fetchEnvelope}, and C{fetchSimplifiedBody} functions. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to dict of the retrieved data values, or whose errback is invoked if there is an error. They dictionary keys are "flags", "date", "size", "envelope", and "body". """ return self._fetch( messages, useUID=uid, flags=1, internaldate=1, rfc822size=1, envelope=1, body=1, ) def fetchAll(self, messages, uid=0): """ Retrieve several different fields of one or more messages This command is allowed in the Selected state. This is equivalent to issuing all of the C{fetchFlags}, C{fetchInternalDate}, C{fetchSize}, and C{fetchEnvelope} functions. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to dict of the retrieved data values, or whose errback is invoked if there is an error. They dictionary keys are "flags", "date", "size", and "envelope". """ return self._fetch( messages, useUID=uid, flags=1, internaldate=1, rfc822size=1, envelope=1 ) def fetchFast(self, messages, uid=0): """ Retrieve several different fields of one or more messages This command is allowed in the Selected state. This is equivalent to issuing all of the C{fetchFlags}, C{fetchInternalDate}, and C{fetchSize} functions. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a dict mapping message numbers to dict of the retrieved data values, or whose errback is invoked if there is an error. They dictionary keys are "flags", "date", and "size". """ return self._fetch(messages, useUID=uid, flags=1, internaldate=1, rfc822size=1) def _parseFetchPairs(self, fetchResponseList): """ Given the result of parsing a single I{FETCH} response, construct a L{dict} mapping response keys to response values. @param fetchResponseList: The result of parsing a I{FETCH} response with L{parseNestedParens} and extracting just the response data (that is, just the part that comes after C{"FETCH"}). The form of this input (and therefore the output of this method) is very disagreeable. A valuable improvement would be to enumerate the possible keys (representing them as structured objects of some sort) rather than using strings and tuples of tuples of strings and so forth. This would allow the keys to be documented more easily and would allow for a much simpler application-facing API (one not based on looking up somewhat hard to predict keys in a dict). Since C{fetchResponseList} notionally represents a flattened sequence of pairs (identifying keys followed by their associated values), collapsing such complex elements of this list as C{["BODY", ["HEADER.FIELDS", ["SUBJECT"]]]} into a single object would also greatly simplify the implementation of this method. @return: A C{dict} of the response data represented by C{pairs}. Keys in this dictionary are things like C{"RFC822.TEXT"}, C{"FLAGS"}, or C{("BODY", ("HEADER.FIELDS", ("SUBJECT",)))}. Values are entirely dependent on the key with which they are associated, but retain the same structured as produced by L{parseNestedParens}. """ # TODO: RFC 3501 Section 7.4.2, "FETCH Response", says for # BODY responses that "8-bit textual data is permitted if a # charset identifier is part of the body parameter # parenthesized list". Every other component is 7-bit. This # should parse out the charset identifier and use it to decode # 8-bit bodies. Until then, on Python 2 it should continue to # return native (byte) strings, while on Python 3 it should # decode bytes to native strings via charmap, ensuring data # fidelity at the cost of mojibake. def nativeStringResponse(thing): if isinstance(thing, bytes): return thing.decode("charmap") elif isinstance(thing, list): return [nativeStringResponse(subthing) for subthing in thing] values = {} unstructured = [] responseParts = iter(fetchResponseList) while True: try: key = next(responseParts) except StopIteration: break try: value = next(responseParts) except StopIteration: raise IllegalServerResponse(b"Not enough arguments", fetchResponseList) # The parsed forms of responses like: # # BODY[] VALUE # BODY[TEXT] VALUE # BODY[HEADER.FIELDS (SUBJECT)] VALUE # BODY[HEADER.FIELDS (SUBJECT)]<N.M> VALUE # # are: # # ["BODY", [], VALUE] # ["BODY", ["TEXT"], VALUE] # ["BODY", ["HEADER.FIELDS", ["SUBJECT"]], VALUE] # ["BODY", ["HEADER.FIELDS", ["SUBJECT"]], "<N.M>", VALUE] # # Additionally, BODY responses for multipart messages are # represented as: # # ["BODY", VALUE] # # with list as the type of VALUE and the type of VALUE[0]. # # See #6281 for ideas on how this might be improved. if key not in (b"BODY", b"BODY.PEEK"): # Only BODY (and by extension, BODY.PEEK) responses can have # body sections. hasSection = False elif not isinstance(value, list): # A BODY section is always represented as a list. Any non-list # is not a BODY section. hasSection = False elif len(value) > 2: # The list representing a BODY section has at most two elements. hasSection = False elif value and isinstance(value[0], list): # A list containing a list represents the body structure of a # multipart message, instead. hasSection = False else: # Otherwise it must have a BODY section to examine. hasSection = True # If it has a BODY section, grab some extra elements and shuffle # around the shape of the key a little bit. key = nativeString(key) unstructured.append(key) if hasSection: if len(value) < 2: value = [nativeString(v) for v in value] unstructured.append(value) key = (key, tuple(value)) else: valueHead = nativeString(value[0]) valueTail = [nativeString(v) for v in value[1]] unstructured.append([valueHead, valueTail]) key = (key, (valueHead, tuple(valueTail))) try: value = next(responseParts) except StopIteration: raise IllegalServerResponse( b"Not enough arguments", fetchResponseList ) # Handle partial ranges if value.startswith(b"<") and value.endswith(b">"): try: int(value[1:-1]) except ValueError: # This isn't really a range, it's some content. pass else: value = nativeString(value) unstructured.append(value) key = key + (value,) try: value = next(responseParts) except StopIteration: raise IllegalServerResponse( b"Not enough arguments", fetchResponseList ) value = nativeStringResponse(value) unstructured.append(value) values[key] = value return values, unstructured def _cbFetch(self, result, requestedParts, structured): (lines, last) = result info = {} for parts in lines: if len(parts) == 3 and parts[1] == b"FETCH": id = self._intOrRaise(parts[0], parts) if id not in info: info[id] = [parts[2]] else: info[id][0].extend(parts[2]) results = {} decodedInfo = {} for (messageId, values) in info.items(): structuredMap, unstructuredList = self._parseFetchPairs(values[0]) decodedInfo.setdefault(messageId, [[]])[0].extend(unstructuredList) results.setdefault(messageId, {}).update(structuredMap) info = decodedInfo flagChanges = {} for messageId in list(results.keys()): values = results[messageId] for part in list(values.keys()): if part not in requestedParts and part == "FLAGS": flagChanges[messageId] = values["FLAGS"] # Find flags in the result and get rid of them. for i in range(len(info[messageId][0])): if info[messageId][0][i] == "FLAGS": del info[messageId][0][i : i + 2] break del values["FLAGS"] if not values: del results[messageId] if flagChanges: self.flagsChanged(flagChanges) if structured: return results else: return info def fetchSpecific( self, messages, uid=0, headerType=None, headerNumber=None, headerArgs=None, peek=None, offset=None, length=None, ): """ Retrieve a specific section of one or more messages @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @type headerType: L{str} @param headerType: If specified, must be one of HEADER, HEADER.FIELDS, HEADER.FIELDS.NOT, MIME, or TEXT, and will determine which part of the message is retrieved. For HEADER.FIELDS and HEADER.FIELDS.NOT, C{headerArgs} must be a sequence of header names. For MIME, C{headerNumber} must be specified. @type headerNumber: L{int} or L{int} sequence @param headerNumber: The nested rfc822 index specifying the entity to retrieve. For example, C{1} retrieves the first entity of the message, and C{(2, 1, 3}) retrieves the 3rd entity inside the first entity inside the second entity of the message. @type headerArgs: A sequence of L{str} @param headerArgs: If C{headerType} is HEADER.FIELDS, these are the headers to retrieve. If it is HEADER.FIELDS.NOT, these are the headers to exclude from retrieval. @type peek: C{bool} @param peek: If true, cause the server to not set the \\Seen flag on this message as a result of this command. @type offset: L{int} @param offset: The number of octets at the beginning of the result to skip. @type length: L{int} @param length: The number of octets to retrieve. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a mapping of message numbers to retrieved data, or whose errback is invoked if there is an error. """ fmt = "%s BODY%s[%s%s%s]%s" if headerNumber is None: number = "" elif isinstance(headerNumber, int): number = str(headerNumber) else: number = ".".join(map(str, headerNumber)) if headerType is None: header = "" elif number: header = "." + headerType else: header = headerType if header and headerType in ("HEADER.FIELDS", "HEADER.FIELDS.NOT"): if headerArgs is not None: payload = " (%s)" % " ".join(headerArgs) else: payload = " ()" else: payload = "" if offset is None: extra = "" else: extra = "<%d.%d>" % (offset, length) fetch = uid and b"UID FETCH" or b"FETCH" cmd = fmt % (messages, peek and ".PEEK" or "", number, header, payload, extra) # APPEND components should be encoded as ASCII unless a # charset identifier is provided. See #9201. cmd = cmd.encode("charmap") d = self.sendCommand(Command(fetch, cmd, wantResponse=(b"FETCH",))) d.addCallback(self._cbFetch, (), False) return d def _fetch(self, messages, useUID=0, **terms): messages = str(messages).encode("ascii") fetch = useUID and b"UID FETCH" or b"FETCH" if "rfc822text" in terms: del terms["rfc822text"] terms["rfc822.text"] = True if "rfc822size" in terms: del terms["rfc822size"] terms["rfc822.size"] = True if "rfc822header" in terms: del terms["rfc822header"] terms["rfc822.header"] = True # The terms in 6.4.5 are all ASCII congruent, so wing it. # Note that this isn't a public API, so terms in responses # should not be decoded to native strings. encodedTerms = [networkString(s) for s in terms] cmd = messages + b" (" + b" ".join([s.upper() for s in encodedTerms]) + b")" d = self.sendCommand(Command(fetch, cmd, wantResponse=(b"FETCH",))) d.addCallback(self._cbFetch, [t.upper() for t in terms.keys()], True) return d def setFlags(self, messages, flags, silent=1, uid=0): """ Set the flags for one or more messages. This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type flags: Any iterable of L{str} @param flags: The flags to set @type silent: L{bool} @param silent: If true, cause the server to suppress its verbose response. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a list of the server's responses (C{[]} if C{silent} is true) or whose errback is invoked if there is an error. """ return self._store(messages, b"FLAGS", silent, flags, uid) def addFlags(self, messages, flags, silent=1, uid=0): """ Add to the set flags for one or more messages. This command is allowed in the Selected state. @type messages: C{MessageSet} or L{str} @param messages: A message sequence set @type flags: Any iterable of L{str} @param flags: The flags to set @type silent: C{bool} @param silent: If true, cause the server to suppress its verbose response. @type uid: C{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a list of the server's responses (C{[]} if C{silent} is true) or whose errback is invoked if there is an error. """ return self._store(messages, b"+FLAGS", silent, flags, uid) def removeFlags(self, messages, flags, silent=1, uid=0): """ Remove from the set flags for one or more messages. This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type flags: Any iterable of L{str} @param flags: The flags to set @type silent: L{bool} @param silent: If true, cause the server to suppress its verbose response. @type uid: L{bool} @param uid: Indicates whether the message sequence set is of message numbers or of unique message IDs. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a list of the server's responses (C{[]} if C{silent} is true) or whose errback is invoked if there is an error. """ return self._store(messages, b"-FLAGS", silent, flags, uid) def _store(self, messages, cmd, silent, flags, uid): messages = str(messages).encode("ascii") encodedFlags = [networkString(flag) for flag in flags] if silent: cmd = cmd + b".SILENT" store = uid and b"UID STORE" or b"STORE" args = b" ".join((messages, cmd, b"(" + b" ".join(encodedFlags) + b")")) d = self.sendCommand(Command(store, args, wantResponse=(b"FETCH",))) expected = () if not silent: expected = ("FLAGS",) d.addCallback(self._cbFetch, expected, True) return d def copy(self, messages, mailbox, uid): """ Copy the specified messages to the specified mailbox. This command is allowed in the Selected state. @type messages: L{MessageSet} or L{str} @param messages: A message sequence set @type mailbox: L{str} @param mailbox: The mailbox to which to copy the messages @type uid: C{bool} @param uid: If true, the C{messages} refers to message UIDs, rather than message sequence numbers. @rtype: L{Deferred} @return: A deferred whose callback is invoked with a true value when the copy is successful, or whose errback is invoked if there is an error. """ messages = str(messages).encode("ascii") if uid: cmd = b"UID COPY" else: cmd = b"COPY" args = b" ".join([messages, _prepareMailboxName(mailbox)]) return self.sendCommand(Command(cmd, args)) # # IMailboxListener methods # def modeChanged(self, writeable): """Override me""" def flagsChanged(self, newFlags): """Override me""" def newMessages(self, exists, recent): """Override me""" def parseIdList(s, lastMessageId=None): """ Parse a message set search key into a C{MessageSet}. @type s: L{bytes} @param s: A string description of an id list, for example "1:3, 4:*" @type lastMessageId: L{int} @param lastMessageId: The last message sequence id or UID, depending on whether we are parsing the list in UID or sequence id context. The caller should pass in the correct value. @rtype: C{MessageSet} @return: A C{MessageSet} that contains the ids defined in the list """ res = MessageSet() parts = s.split(b",") for p in parts: if b":" in p: low, high = p.split(b":", 1) try: if low == b"*": low = None else: low = int(low) if high == b"*": high = None else: high = int(high) if low is high is None: # *:* does not make sense raise IllegalIdentifierError(p) # non-positive values are illegal according to RFC 3501 if (low is not None and low <= 0) or (high is not None and high <= 0): raise IllegalIdentifierError(p) # star means "highest value of an id in the mailbox" high = high or lastMessageId low = low or lastMessageId res.add(low, high) except ValueError: raise IllegalIdentifierError(p) else: try: if p == b"*": p = None else: p = int(p) if p is not None and p <= 0: raise IllegalIdentifierError(p) except ValueError: raise IllegalIdentifierError(p) else: res.extend(p or lastMessageId) return res _SIMPLE_BOOL = ( "ALL", "ANSWERED", "DELETED", "DRAFT", "FLAGGED", "NEW", "OLD", "RECENT", "SEEN", "UNANSWERED", "UNDELETED", "UNDRAFT", "UNFLAGGED", "UNSEEN", ) _NO_QUOTES = ("LARGER", "SMALLER", "UID") _sorted = sorted def Query(sorted=0, **kwarg): """ Create a query string Among the accepted keywords are:: all : If set to a true value, search all messages in the current mailbox answered : If set to a true value, search messages flagged with \\Answered bcc : A substring to search the BCC header field for before : Search messages with an internal date before this value. The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. body : A substring to search the body of the messages for cc : A substring to search the CC header field for deleted : If set to a true value, search messages flagged with \\Deleted draft : If set to a true value, search messages flagged with \\Draft flagged : If set to a true value, search messages flagged with \\Flagged from : A substring to search the From header field for header : A two-tuple of a header name and substring to search for in that header keyword : Search for messages with the given keyword set larger : Search for messages larger than this number of octets messages : Search only the given message sequence set. new : If set to a true value, search messages flagged with \\Recent but not \\Seen old : If set to a true value, search messages not flagged with \\Recent on : Search messages with an internal date which is on this date. The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. recent : If set to a true value, search for messages flagged with \\Recent seen : If set to a true value, search for messages flagged with \\Seen sentbefore : Search for messages with an RFC822 'Date' header before this date. The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. senton : Search for messages with an RFC822 'Date' header which is on this date The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. sentsince : Search for messages with an RFC822 'Date' header which is after this date. The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. since : Search for messages with an internal date that is after this date.. The given date should be a string in the format of 'DD-Mon-YYYY'. For example, '03-Mar-2003'. smaller : Search for messages smaller than this number of octets subject : A substring to search the 'subject' header for text : A substring to search the entire message for to : A substring to search the 'to' header for uid : Search only the messages in the given message set unanswered : If set to a true value, search for messages not flagged with \\Answered undeleted : If set to a true value, search for messages not flagged with \\Deleted undraft : If set to a true value, search for messages not flagged with \\Draft unflagged : If set to a true value, search for messages not flagged with \\Flagged unkeyword : Search for messages without the given keyword set unseen : If set to a true value, search for messages not flagged with \\Seen @type sorted: C{bool} @param sorted: If true, the output will be sorted, alphabetically. The standard does not require it, but it makes testing this function easier. The default is zero, and this should be acceptable for any application. @rtype: L{str} @return: The formatted query string """ cmd = [] keys = kwarg.keys() if sorted: keys = _sorted(keys) for k in keys: v = kwarg[k] k = k.upper() if k in _SIMPLE_BOOL and v: cmd.append(k) elif k == "HEADER": cmd.extend([k, str(v[0]), str(v[1])]) elif k == "KEYWORD" or k == "UNKEYWORD": # Discard anything that does not fit into an "atom". Perhaps turn # the case where this actually removes bytes from the value into a # warning and then an error, eventually. See #6277. v = _nonAtomRE.sub("", v) cmd.extend([k, v]) elif k not in _NO_QUOTES: if isinstance(v, MessageSet): fmt = '"%s"' elif isinstance(v, str): fmt = '"%s"' else: fmt = '"%d"' cmd.extend([k, fmt % (v,)]) elif isinstance(v, int): cmd.extend([k, "%d" % (v,)]) else: cmd.extend([k, f"{v}"]) if len(cmd) > 1: return "(" + " ".join(cmd) + ")" else: return " ".join(cmd) def Or(*args): """ The disjunction of two or more queries """ if len(args) < 2: raise IllegalQueryError(args) elif len(args) == 2: return "(OR %s %s)" % args else: return f"(OR {args[0]} {Or(*args[1:])})" def Not(query): """The negation of a query""" return f"(NOT {query})" def wildcardToRegexp(wildcard, delim=None): wildcard = wildcard.replace("*", "(?:.*?)") if delim is None: wildcard = wildcard.replace("%", "(?:.*?)") else: wildcard = wildcard.replace("%", "(?:(?:[^%s])*?)" % re.escape(delim)) return re.compile(wildcard, re.I) def splitQuoted(s): """ Split a string into whitespace delimited tokens Tokens that would otherwise be separated but are surrounded by \" remain as a single token. Any token that is not quoted and is equal to \"NIL\" is tokenized as L{None}. @type s: L{bytes} @param s: The string to be split @rtype: L{list} of L{bytes} @return: A list of the resulting tokens @raise MismatchedQuoting: Raised if an odd number of quotes are present """ s = s.strip() result = [] word = [] inQuote = inWord = False qu = _matchingString('"', s) esc = _matchingString("\x5c", s) empty = _matchingString("", s) nil = _matchingString("NIL", s) for i, c in enumerate(iterbytes(s)): if c == qu: if i and s[i - 1 : i] == esc: word.pop() word.append(qu) elif not inQuote: inQuote = True else: inQuote = False result.append(empty.join(word)) word = [] elif ( not inWord and not inQuote and c not in (qu + (string.whitespace.encode("ascii"))) ): inWord = True word.append(c) elif inWord and not inQuote and c in string.whitespace.encode("ascii"): w = empty.join(word) if w == nil: result.append(None) else: result.append(w) word = [] inWord = False elif inWord or inQuote: word.append(c) if inQuote: raise MismatchedQuoting(s) if inWord: w = empty.join(word) if w == nil: result.append(None) else: result.append(w) return result def splitOn(sequence, predicate, transformers): result = [] mode = predicate(sequence[0]) tmp = [sequence[0]] for e in sequence[1:]: p = predicate(e) if p != mode: result.extend(transformers[mode](tmp)) tmp = [e] mode = p else: tmp.append(e) result.extend(transformers[mode](tmp)) return result def collapseStrings(results): """ Turns a list of length-one strings and lists into a list of longer strings and lists. For example, ['a', 'b', ['c', 'd']] is returned as ['ab', ['cd']] @type results: L{list} of L{bytes} and L{list} @param results: The list to be collapsed @rtype: L{list} of L{bytes} and L{list} @return: A new list which is the collapsed form of C{results} """ copy = [] begun = None pred = lambda e: isinstance(e, tuple) tran = { 0: lambda e: splitQuoted(b"".join(e)), 1: lambda e: [b"".join([i[0] for i in e])], } for i, c in enumerate(results): if isinstance(c, list): if begun is not None: copy.extend(splitOn(results[begun:i], pred, tran)) begun = None copy.append(collapseStrings(c)) elif begun is None: begun = i if begun is not None: copy.extend(splitOn(results[begun:], pred, tran)) return copy def parseNestedParens(s, handleLiteral=1): """ Parse an s-exp-like string into a more useful data structure. @type s: L{bytes} @param s: The s-exp-like string to parse @rtype: L{list} of L{bytes} and L{list} @return: A list containing the tokens present in the input. @raise MismatchedNesting: Raised if the number or placement of opening or closing parenthesis is invalid. """ s = s.strip() inQuote = 0 contentStack = [[]] try: i = 0 L = len(s) while i < L: c = s[i : i + 1] if inQuote: if c == b"\\": contentStack[-1].append(s[i : i + 2]) i += 2 continue elif c == b'"': inQuote = not inQuote contentStack[-1].append(c) i += 1 else: if c == b'"': contentStack[-1].append(c) inQuote = not inQuote i += 1 elif handleLiteral and c == b"{": end = s.find(b"}", i) if end == -1: raise ValueError("Malformed literal") literalSize = int(s[i + 1 : end]) contentStack[-1].append((s[end + 3 : end + 3 + literalSize],)) i = end + 3 + literalSize elif c == b"(" or c == b"[": contentStack.append([]) i += 1 elif c == b")" or c == b"]": contentStack[-2].append(contentStack.pop()) i += 1 else: contentStack[-1].append(c) i += 1 except IndexError: raise MismatchedNesting(s) if len(contentStack) != 1: raise MismatchedNesting(s) return collapseStrings(contentStack[0]) def _quote(s): qu = _matchingString('"', s) esc = _matchingString("\x5c", s) return qu + s.replace(esc, esc + esc).replace(qu, esc + qu) + qu def _literal(s: bytes) -> bytes: return b"{%d}\r\n%b" % (len(s), s) class DontQuoteMe: def __init__(self, value): self.value = value def __str__(self) -> str: return str(self.value) _ATOM_SPECIALS = b'(){ %*"' def _needsQuote(s): if s == b"": return 1 for c in iterbytes(s): if c < b"\x20" or c > b"\x7f": return 1 if c in _ATOM_SPECIALS: return 1 return 0 def _parseMbox(name): if isinstance(name, str): return name try: return name.decode("imap4-utf-7") except BaseException: log.err() raise IllegalMailboxEncoding(name) def _prepareMailboxName(name): if not isinstance(name, str): name = name.decode("charmap") name = name.encode("imap4-utf-7") if _needsQuote(name): return _quote(name) return name def _needsLiteral(s): # change this to "return 1" to wig out stupid clients cr = _matchingString("\n", s) lf = _matchingString("\r", s) return cr in s or lf in s or len(s) > 1000 def collapseNestedLists(items): """ Turn a nested list structure into an s-exp-like string. Strings in C{items} will be sent as literals if they contain CR or LF, otherwise they will be quoted. References to None in C{items} will be translated to the atom NIL. Objects with a 'read' attribute will have it called on them with no arguments and the returned string will be inserted into the output as a literal. Integers will be converted to strings and inserted into the output unquoted. Instances of C{DontQuoteMe} will be converted to strings and inserted into the output unquoted. This function used to be much nicer, and only quote things that really needed to be quoted (and C{DontQuoteMe} did not exist), however, many broken IMAP4 clients were unable to deal with this level of sophistication, forcing the current behavior to be adopted for practical reasons. @type items: Any iterable @rtype: L{str} """ pieces = [] for i in items: if isinstance(i, str): # anything besides ASCII will have to wait for an RFC 5738 # implementation. See # https://twistedmatrix.com/trac/ticket/9258 i = i.encode("ascii") if i is None: pieces.extend([b" ", b"NIL"]) elif isinstance(i, int): pieces.extend([b" ", networkString(str(i))]) elif isinstance(i, DontQuoteMe): pieces.extend([b" ", i.value]) elif isinstance(i, bytes): # XXX warning if _needsLiteral(i): pieces.extend([b" ", b"{%d}" % (len(i),), IMAP4Server.delimiter, i]) else: pieces.extend([b" ", _quote(i)]) elif hasattr(i, "read"): d = i.read() pieces.extend([b" ", b"{%d}" % (len(d),), IMAP4Server.delimiter, d]) else: pieces.extend([b" ", b"(" + collapseNestedLists(i) + b")"]) return b"".join(pieces[1:]) @implementer(IAccount) class MemoryAccountWithoutNamespaces: mailboxes = None subscriptions = None top_id = 0 def __init__(self, name): self.name = name self.mailboxes = {} self.subscriptions = [] def allocateID(self): id = self.top_id self.top_id += 1 return id ## ## IAccount ## def addMailbox(self, name, mbox=None): name = _parseMbox(name.upper()) if name in self.mailboxes: raise MailboxCollision(name) if mbox is None: mbox = self._emptyMailbox(name, self.allocateID()) self.mailboxes[name] = mbox return 1 def create(self, pathspec): paths = [path for path in pathspec.split("/") if path] for accum in range(1, len(paths)): try: self.addMailbox("/".join(paths[:accum])) except MailboxCollision: pass try: self.addMailbox("/".join(paths)) except MailboxCollision: if not pathspec.endswith("/"): return False return True def _emptyMailbox(self, name, id): raise NotImplementedError def select(self, name, readwrite=1): return self.mailboxes.get(_parseMbox(name.upper())) def delete(self, name): name = _parseMbox(name.upper()) # See if this mailbox exists at all mbox = self.mailboxes.get(name) if not mbox: raise MailboxException("No such mailbox") # See if this box is flagged \Noselect if r"\Noselect" in mbox.getFlags(): # Check for hierarchically inferior mailboxes with this one # as part of their root. for others in self.mailboxes.keys(): if others != name and others.startswith(name): raise MailboxException( "Hierarchically inferior mailboxes exist and \\Noselect is set" ) mbox.destroy() # iff there are no hierarchically inferior names, we will # delete it from our ken. if len(self._inferiorNames(name)) > 1: raise MailboxException(f'Name "{name}" has inferior hierarchical names') del self.mailboxes[name] def rename(self, oldname, newname): oldname = _parseMbox(oldname.upper()) newname = _parseMbox(newname.upper()) if oldname not in self.mailboxes: raise NoSuchMailbox(oldname) inferiors = self._inferiorNames(oldname) inferiors = [(o, o.replace(oldname, newname, 1)) for o in inferiors] for (old, new) in inferiors: if new in self.mailboxes: raise MailboxCollision(new) for (old, new) in inferiors: self.mailboxes[new] = self.mailboxes[old] del self.mailboxes[old] def _inferiorNames(self, name): inferiors = [] for infname in self.mailboxes.keys(): if infname.startswith(name): inferiors.append(infname) return inferiors def isSubscribed(self, name): return _parseMbox(name.upper()) in self.subscriptions def subscribe(self, name): name = _parseMbox(name.upper()) if name not in self.subscriptions: self.subscriptions.append(name) def unsubscribe(self, name): name = _parseMbox(name.upper()) if name not in self.subscriptions: raise MailboxException(f"Not currently subscribed to {name}") self.subscriptions.remove(name) def listMailboxes(self, ref, wildcard): ref = self._inferiorNames(_parseMbox(ref.upper())) wildcard = wildcardToRegexp(wildcard, "/") return [(i, self.mailboxes[i]) for i in ref if wildcard.match(i)] @implementer(INamespacePresenter) class MemoryAccount(MemoryAccountWithoutNamespaces): ## ## INamespacePresenter ## def getPersonalNamespaces(self): return [[b"", b"/"]] def getSharedNamespaces(self): return None def getOtherNamespaces(self): return None def getUserNamespaces(self): # INamespacePresenter.getUserNamespaces return None _statusRequestDict = { "MESSAGES": "getMessageCount", "RECENT": "getRecentCount", "UIDNEXT": "getUIDNext", "UIDVALIDITY": "getUIDValidity", "UNSEEN": "getUnseenCount", } def statusRequestHelper(mbox, names): r = {} for n in names: r[n] = getattr(mbox, _statusRequestDict[n.upper()])() return r def parseAddr(addr): if addr is None: return [ (None, None, None), ] addr = email.utils.getaddresses([addr]) return [[fn or None, None] + address.split("@") for fn, address in addr] def getEnvelope(msg): headers = msg.getHeaders(True) date = headers.get("date") subject = headers.get("subject") from_ = headers.get("from") sender = headers.get("sender", from_) reply_to = headers.get("reply-to", from_) to = headers.get("to") cc = headers.get("cc") bcc = headers.get("bcc") in_reply_to = headers.get("in-reply-to") mid = headers.get("message-id") return ( date, subject, parseAddr(from_), parseAddr(sender), reply_to and parseAddr(reply_to), to and parseAddr(to), cc and parseAddr(cc), bcc and parseAddr(bcc), in_reply_to, mid, ) def getLineCount(msg): # XXX - Super expensive, CACHE THIS VALUE FOR LATER RE-USE # XXX - This must be the number of lines in the ENCODED version lines = 0 for _ in msg.getBodyFile(): lines += 1 return lines def unquote(s): if s[0] == s[-1] == '"': return s[1:-1] return s def _getContentType(msg): """ Return a two-tuple of the main and subtype of the given message. """ attrs = None mm = msg.getHeaders(False, "content-type").get("content-type", "") mm = "".join(mm.splitlines()) if mm: mimetype = mm.split(";") type = mimetype[0].split("/", 1) if len(type) == 1: major = type[0] minor = None else: # length must be 2, because of split('/', 1) major, minor = type attrs = dict(x.strip().lower().split("=", 1) for x in mimetype[1:]) else: major = minor = None return major, minor, attrs def _getMessageStructure(message): """ Construct an appropriate type of message structure object for the given message object. @param message: A L{IMessagePart} provider @return: A L{_MessageStructure} instance of the most specific type available for the given message, determined by inspecting the MIME type of the message. """ main, subtype, attrs = _getContentType(message) if main is not None: main = main.lower() if subtype is not None: subtype = subtype.lower() if main == "multipart": return _MultipartMessageStructure(message, subtype, attrs) elif (main, subtype) == ("message", "rfc822"): return _RFC822MessageStructure(message, main, subtype, attrs) elif main == "text": return _TextMessageStructure(message, main, subtype, attrs) else: return _SinglepartMessageStructure(message, main, subtype, attrs) class _MessageStructure: """ L{_MessageStructure} is a helper base class for message structure classes representing the structure of particular kinds of messages, as defined by their MIME type. """ def __init__(self, message, attrs): """ @param message: An L{IMessagePart} provider which this structure object reports on. @param attrs: A C{dict} giving the parameters of the I{Content-Type} header of the message. """ self.message = message self.attrs = attrs def _disposition(self, disp): """ Parse a I{Content-Disposition} header into a two-sequence of the disposition and a flattened list of its parameters. @return: L{None} if there is no disposition header value, a L{list} with two elements otherwise. """ if disp: disp = disp.split("; ") if len(disp) == 1: disp = (disp[0].lower(), None) elif len(disp) > 1: # XXX Poorly tested parser params = [x for param in disp[1:] for x in param.split("=", 1)] disp = [disp[0].lower(), params] return disp else: return None def _unquotedAttrs(self): """ @return: The I{Content-Type} parameters, unquoted, as a flat list with each Nth element giving a parameter name and N+1th element giving the corresponding parameter value. """ if self.attrs: unquoted = [(k, unquote(v)) for (k, v) in self.attrs.items()] return [y for x in sorted(unquoted) for y in x] return None class _SinglepartMessageStructure(_MessageStructure): """ L{_SinglepartMessageStructure} represents the message structure of a non-I{multipart/*} message. """ _HEADERS = ["content-id", "content-description", "content-transfer-encoding"] def __init__(self, message, main, subtype, attrs): """ @param message: An L{IMessagePart} provider which this structure object reports on. @param main: A L{str} giving the main MIME type of the message (for example, C{"text"}). @param subtype: A L{str} giving the MIME subtype of the message (for example, C{"plain"}). @param attrs: A C{dict} giving the parameters of the I{Content-Type} header of the message. """ _MessageStructure.__init__(self, message, attrs) self.main = main self.subtype = subtype self.attrs = attrs def _basicFields(self): """ Return a list of the basic fields for a single-part message. """ headers = self.message.getHeaders(False, *self._HEADERS) # Number of octets total size = self.message.getSize() major, minor = self.main, self.subtype # content-type parameter list unquotedAttrs = self._unquotedAttrs() return [ major, minor, unquotedAttrs, headers.get("content-id"), headers.get("content-description"), headers.get("content-transfer-encoding"), size, ] def encode(self, extended): """ Construct and return a list of the basic and extended fields for a single-part message. The list suitable to be encoded into a BODY or BODYSTRUCTURE response. """ result = self._basicFields() if extended: result.extend(self._extended()) return result def _extended(self): """ The extension data of a non-multipart body part are in the following order: 1. body MD5 A string giving the body MD5 value as defined in [MD5]. 2. body disposition A parenthesized list with the same content and function as the body disposition for a multipart body part. 3. body language A string or parenthesized list giving the body language value as defined in [LANGUAGE-TAGS]. 4. body location A string list giving the body content URI as defined in [LOCATION]. """ result = [] headers = self.message.getHeaders( False, "content-md5", "content-disposition", "content-language", "content-language", ) result.append(headers.get("content-md5")) result.append(self._disposition(headers.get("content-disposition"))) result.append(headers.get("content-language")) result.append(headers.get("content-location")) return result class _TextMessageStructure(_SinglepartMessageStructure): """ L{_TextMessageStructure} represents the message structure of a I{text/*} message. """ def encode(self, extended): """ A body type of type TEXT contains, immediately after the basic fields, the size of the body in text lines. Note that this size is the size in its content transfer encoding and not the resulting size after any decoding. """ result = _SinglepartMessageStructure._basicFields(self) result.append(getLineCount(self.message)) if extended: result.extend(self._extended()) return result class _RFC822MessageStructure(_SinglepartMessageStructure): """ L{_RFC822MessageStructure} represents the message structure of a I{message/rfc822} message. """ def encode(self, extended): """ A body type of type MESSAGE and subtype RFC822 contains, immediately after the basic fields, the envelope structure, body structure, and size in text lines of the encapsulated message. """ result = _SinglepartMessageStructure.encode(self, extended) contained = self.message.getSubPart(0) result.append(getEnvelope(contained)) result.append(getBodyStructure(contained, False)) result.append(getLineCount(contained)) return result class _MultipartMessageStructure(_MessageStructure): """ L{_MultipartMessageStructure} represents the message structure of a I{multipart/*} message. """ def __init__(self, message, subtype, attrs): """ @param message: An L{IMessagePart} provider which this structure object reports on. @param subtype: A L{str} giving the MIME subtype of the message (for example, C{"plain"}). @param attrs: A C{dict} giving the parameters of the I{Content-Type} header of the message. """ _MessageStructure.__init__(self, message, attrs) self.subtype = subtype def _getParts(self): """ Return an iterator over all of the sub-messages of this message. """ i = 0 while True: try: part = self.message.getSubPart(i) except IndexError: break else: yield part i += 1 def encode(self, extended): """ Encode each sub-message and added the additional I{multipart} fields. """ result = [_getMessageStructure(p).encode(extended) for p in self._getParts()] result.append(self.subtype) if extended: result.extend(self._extended()) return result def _extended(self): """ The extension data of a multipart body part are in the following order: 1. body parameter parenthesized list A parenthesized list of attribute/value pairs [e.g., ("foo" "bar" "baz" "rag") where "bar" is the value of "foo", and "rag" is the value of "baz"] as defined in [MIME-IMB]. 2. body disposition A parenthesized list, consisting of a disposition type string, followed by a parenthesized list of disposition attribute/value pairs as defined in [DISPOSITION]. 3. body language A string or parenthesized list giving the body language value as defined in [LANGUAGE-TAGS]. 4. body location A string list giving the body content URI as defined in [LOCATION]. """ result = [] headers = self.message.getHeaders( False, "content-language", "content-location", "content-disposition" ) result.append(self._unquotedAttrs()) result.append(self._disposition(headers.get("content-disposition"))) result.append(headers.get("content-language", None)) result.append(headers.get("content-location", None)) return result def getBodyStructure(msg, extended=False): """ RFC 3501, 7.4.2, BODYSTRUCTURE:: A parenthesized list that describes the [MIME-IMB] body structure of a message. This is computed by the server by parsing the [MIME-IMB] header fields, defaulting various fields as necessary. For example, a simple text message of 48 lines and 2279 octets can have a body structure of: ("TEXT" "PLAIN" ("CHARSET" "US-ASCII") NIL NIL "7BIT" 2279 48) This is represented as:: ["TEXT", "PLAIN", ["CHARSET", "US-ASCII"], None, None, "7BIT", 2279, 48] These basic fields are documented in the RFC as: 1. body type A string giving the content media type name as defined in [MIME-IMB]. 2. body subtype A string giving the content subtype name as defined in [MIME-IMB]. 3. body parameter parenthesized list A parenthesized list of attribute/value pairs [e.g., ("foo" "bar" "baz" "rag") where "bar" is the value of "foo" and "rag" is the value of "baz"] as defined in [MIME-IMB]. 4. body id A string giving the content id as defined in [MIME-IMB]. 5. body description A string giving the content description as defined in [MIME-IMB]. 6. body encoding A string giving the content transfer encoding as defined in [MIME-IMB]. 7. body size A number giving the size of the body in octets. Note that this size is the size in its transfer encoding and not the resulting size after any decoding. Put another way, the body structure is a list of seven elements. The semantics of the elements of this list are: 1. Byte string giving the major MIME type 2. Byte string giving the minor MIME type 3. A list giving the Content-Type parameters of the message 4. A byte string giving the content identifier for the message part, or None if it has no content identifier. 5. A byte string giving the content description for the message part, or None if it has no content description. 6. A byte string giving the Content-Encoding of the message body 7. An integer giving the number of octets in the message body The RFC goes on:: Multiple parts are indicated by parenthesis nesting. Instead of a body type as the first element of the parenthesized list, there is a sequence of one or more nested body structures. The second element of the parenthesized list is the multipart subtype (mixed, digest, parallel, alternative, etc.). For example, a two part message consisting of a text and a BASE64-encoded text attachment can have a body structure of: (("TEXT" "PLAIN" ("CHARSET" "US-ASCII") NIL NIL "7BIT" 1152 23)("TEXT" "PLAIN" ("CHARSET" "US-ASCII" "NAME" "cc.diff") "<960723163407.20117h@cac.washington.edu>" "Compiler diff" "BASE64" 4554 73) "MIXED") This is represented as:: [["TEXT", "PLAIN", ["CHARSET", "US-ASCII"], None, None, "7BIT", 1152, 23], ["TEXT", "PLAIN", ["CHARSET", "US-ASCII", "NAME", "cc.diff"], "<960723163407.20117h@cac.washington.edu>", "Compiler diff", "BASE64", 4554, 73], "MIXED"] In other words, a list of N + 1 elements, where N is the number of parts in the message. The first N elements are structures as defined by the previous section. The last element is the minor MIME subtype of the multipart message. Additionally, the RFC describes extension data:: Extension data follows the multipart subtype. Extension data is never returned with the BODY fetch, but can be returned with a BODYSTRUCTURE fetch. Extension data, if present, MUST be in the defined order. The C{extended} flag controls whether extension data might be returned with the normal data. """ return _getMessageStructure(msg).encode(extended) def _formatHeaders(headers): # TODO: This should use email.header.Header, which handles encoding hdrs = [ ": ".join((k.title(), "\r\n".join(v.splitlines()))) for (k, v) in headers.items() ] hdrs = "\r\n".join(hdrs) + "\r\n" return networkString(hdrs) def subparts(m): i = 0 try: while True: yield m.getSubPart(i) i += 1 except IndexError: pass def iterateInReactor(i): """ Consume an interator at most a single iteration per reactor iteration. If the iterator produces a Deferred, the next iteration will not occur until the Deferred fires, otherwise the next iteration will be taken in the next reactor iteration. @rtype: C{Deferred} @return: A deferred which fires (with None) when the iterator is exhausted or whose errback is called if there is an exception. """ from twisted.internet import reactor d = defer.Deferred() def go(last): try: r = next(i) except StopIteration: d.callback(last) except BaseException: d.errback() else: if isinstance(r, defer.Deferred): r.addCallback(go) else: reactor.callLater(0, go, r) go(None) return d class MessageProducer: CHUNK_SIZE = 2 ** 2 ** 2 ** 2 _uuid4 = staticmethod(uuid.uuid4) def __init__(self, msg, buffer=None, scheduler=None): """ Produce this message. @param msg: The message I am to produce. @type msg: L{IMessage} @param buffer: A buffer to hold the message in. If None, I will use a L{tempfile.TemporaryFile}. @type buffer: file-like """ self.msg = msg if buffer is None: buffer = tempfile.TemporaryFile() self.buffer = buffer if scheduler is None: scheduler = iterateInReactor self.scheduler = scheduler self.write = self.buffer.write def beginProducing(self, consumer): self.consumer = consumer return self.scheduler(self._produce()) def _produce(self): headers = self.msg.getHeaders(True) boundary = None if self.msg.isMultipart(): content = headers.get("content-type") parts = [x.split("=", 1) for x in content.split(";")[1:]] parts = {k.lower().strip(): v for (k, v) in parts} boundary = parts.get("boundary") if boundary is None: # Bastards boundary = f"----={self._uuid4().hex}" headers["content-type"] += f'; boundary="{boundary}"' else: if boundary.startswith('"') and boundary.endswith('"'): boundary = boundary[1:-1] boundary = networkString(boundary) self.write(_formatHeaders(headers)) self.write(b"\r\n") if self.msg.isMultipart(): for p in subparts(self.msg): self.write(b"\r\n--" + boundary + b"\r\n") yield MessageProducer(p, self.buffer, self.scheduler).beginProducing( None ) self.write(b"\r\n--" + boundary + b"--\r\n") else: f = self.msg.getBodyFile() while True: b = f.read(self.CHUNK_SIZE) if b: self.buffer.write(b) yield None else: break if self.consumer: self.buffer.seek(0, 0) yield FileProducer(self.buffer).beginProducing(self.consumer).addCallback( lambda _: self ) class _FetchParser: class Envelope: # Response should be a list of fields from the message: # date, subject, from, sender, reply-to, to, cc, bcc, in-reply-to, # and message-id. # # from, sender, reply-to, to, cc, and bcc are themselves lists of # address information: # personal name, source route, mailbox name, host name # # reply-to and sender must not be None. If not present in a message # they should be defaulted to the value of the from field. type = "envelope" __str__ = lambda self: "envelope" class Flags: type = "flags" __str__ = lambda self: "flags" class InternalDate: type = "internaldate" __str__ = lambda self: "internaldate" class RFC822Header: type = "rfc822header" __str__ = lambda self: "rfc822.header" class RFC822Text: type = "rfc822text" __str__ = lambda self: "rfc822.text" class RFC822Size: type = "rfc822size" __str__ = lambda self: "rfc822.size" class RFC822: type = "rfc822" __str__ = lambda self: "rfc822" class UID: type = "uid" __str__ = lambda self: "uid" class Body: type = "body" peek = False header = None mime = None text = None part = () empty = False partialBegin = None partialLength = None def __str__(self) -> str: return self.__bytes__().decode("ascii") def __bytes__(self) -> bytes: base = b"BODY" part = b"" separator = b"" if self.part: part = b".".join([str(x + 1).encode("ascii") for x in self.part]) # type: ignore[unreachable] separator = b"." # if self.peek: # base += '.PEEK' if self.header: base += ( # type: ignore[unreachable] b"[" + part + separator + str(self.header).encode("ascii") + b"]" ) elif self.text: base += b"[" + part + separator + b"TEXT]" # type: ignore[unreachable] elif self.mime: base += b"[" + part + separator + b"MIME]" # type: ignore[unreachable] elif self.empty: base += b"[" + part + b"]" if self.partialBegin is not None: base += b"<%d.%d>" % (self.partialBegin, self.partialLength) # type: ignore[unreachable] return base class BodyStructure: type = "bodystructure" __str__ = lambda self: "bodystructure" # These three aren't top-level, they don't need type indicators class Header: negate = False fields = None part = None def __str__(self) -> str: return self.__bytes__().decode("ascii") def __bytes__(self) -> bytes: base = b"HEADER" if self.fields: base += b".FIELDS" # type: ignore[unreachable] if self.negate: base += b".NOT" fields = [] for f in self.fields: f = f.title() if _needsQuote(f): f = _quote(f) fields.append(f) base += b" (" + b" ".join(fields) + b")" if self.part: # TODO: _FetchParser never assigns Header.part - dead # code? base = b".".join([(x + 1).__bytes__() for x in self.part]) + b"." + base # type: ignore[unreachable] return base class Text: pass class MIME: pass parts = None _simple_fetch_att = [ (b"envelope", Envelope), (b"flags", Flags), (b"internaldate", InternalDate), (b"rfc822.header", RFC822Header), (b"rfc822.text", RFC822Text), (b"rfc822.size", RFC822Size), (b"rfc822", RFC822), (b"uid", UID), (b"bodystructure", BodyStructure), ] def __init__(self): self.state = ["initial"] self.result = [] self.remaining = b"" def parseString(self, s): s = self.remaining + s try: while s or self.state: if not self.state: raise IllegalClientResponse("Invalid Argument") # print 'Entering state_' + self.state[-1] + ' with', repr(s) state = self.state.pop() try: used = getattr(self, "state_" + state)(s) except BaseException: self.state.append(state) raise else: # print state, 'consumed', repr(s[:used]) s = s[used:] finally: self.remaining = s def state_initial(self, s): # In the initial state, the literals "ALL", "FULL", and "FAST" # are accepted, as is a ( indicating the beginning of a fetch_att # token, as is the beginning of a fetch_att token. if s == b"": return 0 l = s.lower() if l.startswith(b"all"): self.result.extend( (self.Flags(), self.InternalDate(), self.RFC822Size(), self.Envelope()) ) return 3 if l.startswith(b"full"): self.result.extend( ( self.Flags(), self.InternalDate(), self.RFC822Size(), self.Envelope(), self.Body(), ) ) return 4 if l.startswith(b"fast"): self.result.extend( ( self.Flags(), self.InternalDate(), self.RFC822Size(), ) ) return 4 if l.startswith(b"("): self.state.extend(("close_paren", "maybe_fetch_att", "fetch_att")) return 1 self.state.append("fetch_att") return 0 def state_close_paren(self, s): if s.startswith(b")"): return 1 # TODO: does maybe_fetch_att's startswith(b')') make this dead # code? raise Exception("Missing )") def state_whitespace(self, s): # Eat up all the leading whitespace if not s or not s[0:1].isspace(): raise Exception("Whitespace expected, none found") i = 0 for i in range(len(s)): if not s[i : i + 1].isspace(): break return i def state_maybe_fetch_att(self, s): if not s.startswith(b")"): self.state.extend(("maybe_fetch_att", "fetch_att", "whitespace")) return 0 def state_fetch_att(self, s): # Allowed fetch_att tokens are "ENVELOPE", "FLAGS", "INTERNALDATE", # "RFC822", "RFC822.HEADER", "RFC822.SIZE", "RFC822.TEXT", "BODY", # "BODYSTRUCTURE", "UID", # "BODY [".PEEK"] [<section>] ["<" <number> "." <nz_number> ">"] l = s.lower() for (name, cls) in self._simple_fetch_att: if l.startswith(name): self.result.append(cls()) return len(name) b = self.Body() if l.startswith(b"body.peek"): b.peek = True used = 9 elif l.startswith(b"body"): used = 4 else: raise Exception(f"Nothing recognized in fetch_att: {l}") self.pending_body = b self.state.extend(("got_body", "maybe_partial", "maybe_section")) return used def state_got_body(self, s): self.result.append(self.pending_body) del self.pending_body return 0 def state_maybe_section(self, s): if not s.startswith(b"["): return 0 self.state.extend(("section", "part_number")) return 1 _partExpr = re.compile(br"(\d+(?:\.\d+)*)\.?") def state_part_number(self, s): m = self._partExpr.match(s) if m is not None: self.parts = [int(p) - 1 for p in m.groups()[0].split(b".")] return m.end() else: self.parts = [] return 0 def state_section(self, s): # Grab "HEADER]" or "HEADER.FIELDS (Header list)]" or # "HEADER.FIELDS.NOT (Header list)]" or "TEXT]" or "MIME]" or # just "]". l = s.lower() used = 0 if l.startswith(b"]"): self.pending_body.empty = True used += 1 elif l.startswith(b"header]"): h = self.pending_body.header = self.Header() h.negate = True h.fields = () used += 7 elif l.startswith(b"text]"): self.pending_body.text = self.Text() used += 5 elif l.startswith(b"mime]"): self.pending_body.mime = self.MIME() used += 5 else: h = self.Header() if l.startswith(b"header.fields.not"): h.negate = True used += 17 elif l.startswith(b"header.fields"): used += 13 else: raise Exception(f"Unhandled section contents: {l!r}") self.pending_body.header = h self.state.extend(("finish_section", "header_list", "whitespace")) self.pending_body.part = tuple(self.parts) self.parts = None return used def state_finish_section(self, s): if not s.startswith(b"]"): raise Exception("section must end with ]") return 1 def state_header_list(self, s): if not s.startswith(b"("): raise Exception("Header list must begin with (") end = s.find(b")") if end == -1: raise Exception("Header list must end with )") headers = s[1:end].split() self.pending_body.header.fields = [h.upper() for h in headers] return end + 1 def state_maybe_partial(self, s): # Grab <number.number> or nothing at all if not s.startswith(b"<"): return 0 end = s.find(b">") if end == -1: raise Exception("Found < but not >") partial = s[1:end] parts = partial.split(b".", 1) if len(parts) != 2: raise Exception( "Partial specification did not include two .-delimited integers" ) begin, length = map(int, parts) self.pending_body.partialBegin = begin self.pending_body.partialLength = length return end + 1 class FileProducer: CHUNK_SIZE = 2 ** 2 ** 2 ** 2 firstWrite = True def __init__(self, f): self.f = f def beginProducing(self, consumer): self.consumer = consumer self.produce = consumer.write d = self._onDone = defer.Deferred() self.consumer.registerProducer(self, False) return d def resumeProducing(self): b = b"" if self.firstWrite: b = b"{%d}\r\n" % (self._size(),) self.firstWrite = False if not self.f: return b = b + self.f.read(self.CHUNK_SIZE) if not b: self.consumer.unregisterProducer() self._onDone.callback(self) self._onDone = self.f = self.consumer = None else: self.produce(b) def pauseProducing(self): """ Pause the producer. This does nothing. """ def stopProducing(self): """ Stop the producer. This does nothing. """ def _size(self): b = self.f.tell() self.f.seek(0, 2) e = self.f.tell() self.f.seek(b, 0) return e - b def parseTime(s): # XXX - This may require localization :( months = [ "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec", "january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december", ] expr = { "day": r"(?P<day>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])", "mon": r"(?P<mon>\w+)", "year": r"(?P<year>\d\d\d\d)", } m = re.match("%(day)s-%(mon)s-%(year)s" % expr, s) if not m: raise ValueError(f"Cannot parse time string {s!r}") d = m.groupdict() try: d["mon"] = 1 + (months.index(d["mon"].lower()) % 12) d["year"] = int(d["year"]) d["day"] = int(d["day"]) except ValueError: raise ValueError(f"Cannot parse time string {s!r}") else: return time.struct_time((d["year"], d["mon"], d["day"], 0, 0, 0, -1, -1, -1)) # we need to cast Python >=3.3 memoryview to chars (from unsigned bytes), but # cast is absent in previous versions: thus, the lambda returns the # memoryview instance while ignoring the format memory_cast = getattr(memoryview, "cast", lambda *x: x[0]) def modified_base64(s): s_utf7 = s.encode("utf-7") return s_utf7[1:-1].replace(b"/", b",") def modified_unbase64(s): s_utf7 = b"+" + s.replace(b",", b"/") + b"-" return s_utf7.decode("utf-7") def encoder(s, errors=None): """ Encode the given C{unicode} string using the IMAP4 specific variation of UTF-7. @type s: C{unicode} @param s: The text to encode. @param errors: Policy for handling encoding errors. Currently ignored. @return: L{tuple} of a L{str} giving the encoded bytes and an L{int} giving the number of code units consumed from the input. """ r = bytearray() _in = [] valid_chars = set(map(chr, range(0x20, 0x7F))) - {"&"} for c in s: if c in valid_chars: if _in: r += b"&" + modified_base64("".join(_in)) + b"-" del _in[:] r.append(ord(c)) elif c == "&": if _in: r += b"&" + modified_base64("".join(_in)) + b"-" del _in[:] r += b"&-" else: _in.append(c) if _in: r.extend(b"&" + modified_base64("".join(_in)) + b"-") return (bytes(r), len(s)) def decoder(s, errors=None): """ Decode the given L{str} using the IMAP4 specific variation of UTF-7. @type s: L{str} @param s: The bytes to decode. @param errors: Policy for handling decoding errors. Currently ignored. @return: a L{tuple} of a C{unicode} string giving the text which was decoded and an L{int} giving the number of bytes consumed from the input. """ r = [] decode = [] s = memory_cast(memoryview(s), "c") for c in s: if c == b"&" and not decode: decode.append(b"&") elif c == b"-" and decode: if len(decode) == 1: r.append("&") else: r.append(modified_unbase64(b"".join(decode[1:]))) decode = [] elif decode: decode.append(c) else: r.append(c.decode()) if decode: r.append(modified_unbase64(b"".join(decode[1:]))) return ("".join(r), len(s)) class StreamReader(codecs.StreamReader): def decode(self, s, errors="strict"): return decoder(s) class StreamWriter(codecs.StreamWriter): def encode(self, s, errors="strict"): return encoder(s) _codecInfo = codecs.CodecInfo(encoder, decoder, StreamReader, StreamWriter) def imap4_utf_7(name): # In Python 3.9, codecs.lookup() was changed to normalize the codec name # in the same way as encodings.normalize_encoding(). The docstring # for encodings.normalize_encoding() describes how the codec name is # normalized. We need to replace '-' with '_' to be compatible with # older Python versions. # See: https://bugs.python.org/issue37751 # https://github.com/python/cpython/pull/17997 if name.replace("-", "_") == "imap4_utf_7": return _codecInfo codecs.register(imap4_utf_7) __all__ = [ # Protocol classes "IMAP4Server", "IMAP4Client", # Interfaces "IMailboxListener", "IClientAuthentication", "IAccount", "IMailbox", "INamespacePresenter", "ICloseableMailbox", "IMailboxInfo", "IMessage", "IMessageCopier", "IMessageFile", "ISearchableMailbox", "IMessagePart", # Exceptions "IMAP4Exception", "IllegalClientResponse", "IllegalOperation", "IllegalMailboxEncoding", "UnhandledResponse", "NegativeResponse", "NoSupportedAuthentication", "IllegalServerResponse", "IllegalIdentifierError", "IllegalQueryError", "MismatchedNesting", "MismatchedQuoting", "MailboxException", "MailboxCollision", "NoSuchMailbox", "ReadOnlyMailbox", # Auth objects "CramMD5ClientAuthenticator", "PLAINAuthenticator", "LOGINAuthenticator", "PLAINCredentials", "LOGINCredentials", # Simple query interface "Query", "Not", "Or", # Miscellaneous "MemoryAccount", "statusRequestHelper", ] PK Mb�Z��ew w mail/pb.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import os from twisted.spread import pb class Maildir(pb.Referenceable): def __init__(self, directory, rootDirectory): self.virtualDirectory = directory self.rootDirectory = rootDirectory self.directory = os.path.join(rootDirectory, directory) def getFolderMessage(self, folder, name): if "/" in name: raise OSError("can only open files in '%s' directory'" % folder) with open(os.path.join(self.directory, "new", name)) as fp: return fp.read() def deleteFolderMessage(self, folder, name): if "/" in name: raise OSError("can only delete files in '%s' directory'" % folder) os.rename( os.path.join(self.directory, folder, name), os.path.join(self.rootDirectory, ".Trash", folder, name), ) def deleteNewMessage(self, name): return self.deleteFolderMessage("new", name) remote_deleteNewMessage = deleteNewMessage def deleteCurMessage(self, name): return self.deleteFolderMessage("cur", name) remote_deleteCurMessage = deleteCurMessage def getNewMessages(self): return os.listdir(os.path.join(self.directory, "new")) remote_getNewMessages = getNewMessages def getCurMessages(self): return os.listdir(os.path.join(self.directory, "cur")) remote_getCurMessages = getCurMessages def getNewMessage(self, name): return self.getFolderMessage("new", name) remote_getNewMessage = getNewMessage def getCurMessage(self, name): return self.getFolderMessage("cur", name) remote_getCurMessage = getCurMessage def getSubFolder(self, name): if name[0] == ".": raise OSError("subfolder name cannot begin with a '.'") name = name.replace("/", ":") if self.virtualDirectoy == ".": name = "." + name else: name = self.virtualDirectory + ":" + name if not self._isSubFolder(name): raise OSError("not a subfolder") return Maildir(name, self.rootDirectory) remote_getSubFolder = getSubFolder def _isSubFolder(self, name): return not os.path.isdir( os.path.join(self.rootDirectory, name) ) or not os.path.isfile(os.path.join(self.rootDirectory, name, "maildirfolder")) class MaildirCollection(pb.Referenceable): def __init__(self, root): self.root = root def getSubFolders(self): return os.listdir(self.getRoot()) remote_getSubFolders = getSubFolders def getSubFolder(self, name): if "/" in name or name[0] == ".": raise OSError("invalid name") return Maildir(".", os.path.join(self.getRoot(), name)) remote_getSubFolder = getSubFolder class MaildirBroker(pb.Broker): def proto_getCollection(self, requestID, name, domain, password): collection = self._getCollection() if collection is None: self.sendError(requestID, "permission denied") else: self.sendAnswer(requestID, collection) def getCollection(self, name, domain, password): if domain not in self.domains: return domain = self.domains[domain] if name in domain.dbm and domain.dbm[name] == password: return MaildirCollection(domain.userDirectory(name)) class MaildirClient(pb.Broker): def getCollection(self, name, domain, password, callback, errback): requestID = self.newRequestID() self.waitingForAnswers[requestID] = callback, errback self.sendCall("getCollection", requestID, name, domain, password) PK Mb�Z���� � mail/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted Mail: Servers and clients for POP3, ESMTP, and IMAP. """ PK Mb�Z ��t t mail/smtp.pynu �[��� # -*- test-case-name: twisted.mail.test.test_smtp -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # pylint: disable=I0011,C0103,C9302 """ Simple Mail Transfer Protocol implementation. """ import base64 import binascii import os import random import re import socket import time import warnings from email.utils import parseaddr from io import BytesIO from typing import Type from zope.interface import implementer from twisted import cred from twisted.copyright import longversion from twisted.internet import defer, error, protocol, reactor from twisted.internet._idna import _idnaText from twisted.internet.interfaces import ISSLTransport, ITLSTransport from twisted.mail._cred import ( CramMD5ClientAuthenticator, LOGINAuthenticator, LOGINCredentials as _lcredentials, ) from twisted.mail._except import ( AddressError, AUTHDeclinedError, AuthenticationError, AUTHRequiredError, EHLORequiredError, ESMTPClientError, SMTPAddressError, SMTPBadRcpt, SMTPBadSender, SMTPClientError, SMTPConnectError, SMTPDeliveryError, SMTPError, SMTPProtocolError, SMTPServerError, SMTPTimeoutError, SMTPTLSError as TLSError, TLSRequiredError, ) from twisted.mail.interfaces import ( IClientAuthentication, IMessageDelivery, IMessageDeliveryFactory, IMessageSMTP as IMessage, ) from twisted.protocols import basic, policies from twisted.python import log, util from twisted.python.compat import iterbytes, nativeString, networkString from twisted.python.runtime import platform __all__ = [ "AUTHDeclinedError", "AUTHRequiredError", "AddressError", "AuthenticationError", "EHLORequiredError", "ESMTPClientError", "SMTPAddressError", "SMTPBadRcpt", "SMTPBadSender", "SMTPClientError", "SMTPConnectError", "SMTPDeliveryError", "SMTPError", "SMTPServerError", "SMTPTimeoutError", "TLSError", "TLSRequiredError", "SMTPProtocolError", "IClientAuthentication", "IMessage", "IMessageDelivery", "IMessageDeliveryFactory", "CramMD5ClientAuthenticator", "LOGINAuthenticator", "LOGINCredentials", "PLAINAuthenticator", "Address", "User", "sendmail", "SenderMixin", "ESMTP", "ESMTPClient", "ESMTPSender", "ESMTPSenderFactory", "SMTP", "SMTPClient", "SMTPFactory", "SMTPSender", "SMTPSenderFactory", "idGenerator", "messageid", "quoteaddr", "rfc822date", "xtextStreamReader", "xtextStreamWriter", "xtext_codec", "xtext_decode", "xtext_encode", ] # Cache the hostname (XXX Yes - this is broken) # Encode the DNS name into something we can send over the wire if platform.isMacOSX(): # On macOS, getfqdn() is ridiculously slow - use the # probably-identical-but-sometimes-not gethostname() there. DNSNAME = socket.gethostname().encode("ascii") else: DNSNAME = socket.getfqdn().encode("ascii") # Used for fast success code lookup SUCCESS = dict.fromkeys(range(200, 300)) def rfc822date(timeinfo=None, local=1): """ Format an RFC-2822 compliant date string. @param timeinfo: (optional) A sequence as returned by C{time.localtime()} or C{time.gmtime()}. Default is now. @param local: (optional) Indicates if the supplied time is local or universal time, or if no time is given, whether now should be local or universal time. Default is local, as suggested (SHOULD) by rfc-2822. @returns: A L{bytes} representing the time and date in RFC-2822 format. """ if not timeinfo: if local: timeinfo = time.localtime() else: timeinfo = time.gmtime() if local: if timeinfo[8]: # DST tz = -time.altzone else: tz = -time.timezone (tzhr, tzmin) = divmod(abs(tz), 3600) if tz: tzhr *= int(abs(tz) // tz) (tzmin, tzsec) = divmod(tzmin, 60) else: (tzhr, tzmin) = (0, 0) return networkString( "%s, %02d %s %04d %02d:%02d:%02d %+03d%02d" % ( ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"][timeinfo[6]], timeinfo[2], [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", ][timeinfo[1] - 1], timeinfo[0], timeinfo[3], timeinfo[4], timeinfo[5], tzhr, tzmin, ) ) def idGenerator(): i = 0 while True: yield i i += 1 _gen = idGenerator() def messageid(uniq=None, N=lambda: next(_gen)): """ Return a globally unique random string in RFC 2822 Message-ID format <datetime.pid.random@host.dom.ain> Optional uniq string will be added to strengthen uniqueness if given. """ datetime = time.strftime("%Y%m%d%H%M%S", time.gmtime()) pid = os.getpid() rand = random.randrange(2 ** 31 - 1) if uniq is None: uniq = "" else: uniq = "." + uniq return "<{}.{}.{}{}.{}@{}>".format( datetime, pid, rand, uniq, N(), DNSNAME.decode() ).encode() def quoteaddr(addr): """ Turn an email address, possibly with realname part etc, into a form suitable for and SMTP envelope. """ if isinstance(addr, Address): return b"<" + bytes(addr) + b">" if isinstance(addr, bytes): addr = addr.decode("ascii") res = parseaddr(addr) if res == (None, None): # It didn't parse, use it as-is return b"<" + bytes(addr) + b">" else: return b"<" + res[1].encode("ascii") + b">" COMMAND, DATA, AUTH = "COMMAND", "DATA", "AUTH" # Character classes for parsing addresses atom = br"[-A-Za-z0-9!\#$%&'*+/=?^_`{|}~]" class Address: """Parse and hold an RFC 2821 address. Source routes are stipped and ignored, UUCP-style bang-paths and %-style routing are not parsed. @type domain: C{bytes} @ivar domain: The domain within which this address resides. @type local: C{bytes} @ivar local: The local (\"user\") portion of this address. """ tstring = re.compile( br"""( # A string of (?:"[^"]*" # quoted string |\\. # backslash-escaped characted |""" + atom + br""" # atom character )+|.) # or any single character""", re.X, ) atomre = re.compile(atom) # match any one atom character def __init__(self, addr, defaultDomain=None): if isinstance(addr, User): addr = addr.dest if isinstance(addr, Address): self.__dict__ = addr.__dict__.copy() return elif not isinstance(addr, bytes): addr = str(addr).encode("ascii") self.addrstr = addr # Tokenize atl = list(filter(None, self.tstring.split(addr))) local = [] domain = [] while atl: if atl[0] == b"<": if atl[-1] != b">": raise AddressError("Unbalanced <>") atl = atl[1:-1] elif atl[0] == b"@": atl = atl[1:] if not local: # Source route while atl and atl[0] != b":": # remove it atl = atl[1:] if not atl: raise AddressError("Malformed source route") atl = atl[1:] # remove : elif domain: raise AddressError("Too many @") else: # Now in domain domain = [b""] elif len(atl[0]) == 1 and not self.atomre.match(atl[0]) and atl[0] != b".": raise AddressError(f"Parse error at {atl[0]!r} of {(addr, atl)!r}") else: if not domain: local.append(atl[0]) else: domain.append(atl[0]) atl = atl[1:] self.local = b"".join(local) self.domain = b"".join(domain) if self.local != b"" and self.domain == b"": if defaultDomain is None: defaultDomain = DNSNAME self.domain = defaultDomain dequotebs = re.compile(br"\\(.)") def dequote(self, addr): """ Remove RFC-2821 quotes from address. """ res = [] if not isinstance(addr, bytes): addr = str(addr).encode("ascii") atl = filter(None, self.tstring.split(addr)) for t in atl: if t[0] == b'"' and t[-1] == b'"': res.append(t[1:-1]) elif "\\" in t: res.append(self.dequotebs.sub(br"\1", t)) else: res.append(t) return b"".join(res) def __str__(self) -> str: return self.__bytes__().decode("ascii") def __bytes__(self) -> bytes: if self.local or self.domain: return b"@".join((self.local, self.domain)) else: return b"" def __repr__(self) -> str: return "{}.{}({})".format( self.__module__, self.__class__.__name__, repr(str(self)) ) class User: """ Hold information about and SMTP message recipient, including information on where the message came from """ def __init__(self, destination, helo, protocol, orig): try: host = protocol.host except AttributeError: host = None self.dest = Address(destination, host) self.helo = helo self.protocol = protocol if isinstance(orig, Address): self.orig = orig else: self.orig = Address(orig, host) def __getstate__(self): """ Helper for pickle. protocol isn't picklabe, but we want User to be, so skip it in the pickle. """ return { "dest": self.dest, "helo": self.helo, "protocol": None, "orig": self.orig, } def __str__(self) -> str: return self.__bytes__().decode("ascii") def __bytes__(self) -> bytes: return bytes(self.dest) class SMTP(basic.LineOnlyReceiver, policies.TimeoutMixin): """ SMTP server-side protocol. @ivar host: The hostname of this mail server. @type host: L{bytes} """ timeout = 600 portal = None # Control whether we log SMTP events noisy = True # A factory for IMessageDelivery objects. If an # avatar implementing IMessageDeliveryFactory can # be acquired from the portal, it will be used to # create a new IMessageDelivery object for each # message which is received. deliveryFactory = None # An IMessageDelivery object. A new instance is # used for each message received if we can get an # IMessageDeliveryFactory from the portal. Otherwise, # a single instance is used throughout the lifetime # of the connection. delivery = None # Cred cleanup function. _onLogout = None def __init__(self, delivery=None, deliveryFactory=None): self.mode = COMMAND self._from = None self._helo = None self._to = [] self.delivery = delivery self.deliveryFactory = deliveryFactory self.host = DNSNAME @property def host(self): return self._host @host.setter def host(self, toSet): if not isinstance(toSet, bytes): toSet = str(toSet).encode("ascii") self._host = toSet def timeoutConnection(self): msg = self.host + b" Timeout. Try talking faster next time!" self.sendCode(421, msg) self.transport.loseConnection() def greeting(self): return self.host + b" NO UCE NO UBE NO RELAY PROBES" def connectionMade(self): # Ensure user-code always gets something sane for _helo peer = self.transport.getPeer() try: host = peer.host except AttributeError: # not an IPv4Address host = str(peer) self._helo = (None, host) self.sendCode(220, self.greeting()) self.setTimeout(self.timeout) def sendCode(self, code, message=b""): """ Send an SMTP code with a message. """ lines = message.splitlines() lastline = lines[-1:] for line in lines[:-1]: self.sendLine(networkString("%3.3d-" % (code,)) + line) self.sendLine( networkString("%3.3d " % (code,)) + (lastline and lastline[0] or b"") ) def lineReceived(self, line): self.resetTimeout() return getattr(self, "state_" + self.mode)(line) def state_COMMAND(self, line): # Ignore leading and trailing whitespace, as well as an arbitrary # amount of whitespace between the command and its argument, though # it is not required by the protocol, for it is a nice thing to do. line = line.strip() parts = line.split(None, 1) if parts: method = self.lookupMethod(parts[0]) or self.do_UNKNOWN if len(parts) == 2: method(parts[1]) else: method(b"") else: self.sendSyntaxError() def sendSyntaxError(self): self.sendCode(500, b"Error: bad syntax") def lookupMethod(self, command): """ @param command: The command to get from this class. @type command: L{str} @return: The function which executes this command. """ if not isinstance(command, str): command = nativeString(command) return getattr(self, "do_" + command.upper(), None) def lineLengthExceeded(self, line): if self.mode is DATA: for message in self.__messages: message.connectionLost() self.mode = COMMAND del self.__messages self.sendCode(500, b"Line too long") def do_UNKNOWN(self, rest): self.sendCode(500, b"Command not implemented") def do_HELO(self, rest): peer = self.transport.getPeer() try: host = peer.host except AttributeError: host = str(peer) if not isinstance(host, bytes): host = host.encode("idna") self._helo = (rest, host) self._from = None self._to = [] self.sendCode(250, self.host + b" Hello " + host + b", nice to meet you") def do_QUIT(self, rest): self.sendCode(221, b"See you later") self.transport.loseConnection() # A string of quoted strings, backslash-escaped character or # atom characters + '@.,:' qstring = br'("[^"]*"|\\.|' + atom + br"|[@.,:])+" mail_re = re.compile( br"""\s*FROM:\s*(?P<path><> # Empty <> |<""" + qstring + br"""> # <addr> |""" + qstring + br""" # addr )\s*(\s(?P<opts>.*))? # Optional WS + ESMTP options $""", re.I | re.X, ) rcpt_re = re.compile( br"\s*TO:\s*(?P<path><" + qstring + br"""> # <addr> |""" + qstring + br""" # addr )\s*(\s(?P<opts>.*))? # Optional WS + ESMTP options $""", re.I | re.X, ) def do_MAIL(self, rest): if self._from: self.sendCode(503, b"Only one sender per message, please") return # Clear old recipient list self._to = [] m = self.mail_re.match(rest) if not m: self.sendCode(501, b"Syntax error") return try: addr = Address(m.group("path"), self.host) except AddressError as e: self.sendCode(553, networkString(str(e))) return validated = defer.maybeDeferred(self.validateFrom, self._helo, addr) validated.addCallbacks(self._cbFromValidate, self._ebFromValidate) def _cbFromValidate(self, fromEmail, code=250, msg=b"Sender address accepted"): self._from = fromEmail self.sendCode(code, msg) def _ebFromValidate(self, failure): if failure.check(SMTPBadSender): self.sendCode( failure.value.code, ( b"Cannot receive from specified address " + quoteaddr(failure.value.addr) + b": " + networkString(failure.value.resp) ), ) elif failure.check(SMTPServerError): self.sendCode(failure.value.code, networkString(failure.value.resp)) else: log.err(failure, "SMTP sender validation failure") self.sendCode(451, b"Requested action aborted: local error in processing") def do_RCPT(self, rest): if not self._from: self.sendCode(503, b"Must have sender before recipient") return m = self.rcpt_re.match(rest) if not m: self.sendCode(501, b"Syntax error") return try: user = User(m.group("path"), self._helo, self, self._from) except AddressError as e: self.sendCode(553, networkString(str(e))) return d = defer.maybeDeferred(self.validateTo, user) d.addCallbacks(self._cbToValidate, self._ebToValidate, callbackArgs=(user,)) def _cbToValidate(self, to, user=None, code=250, msg=b"Recipient address accepted"): if user is None: user = to self._to.append((user, to)) self.sendCode(code, msg) def _ebToValidate(self, failure): if failure.check(SMTPBadRcpt, SMTPServerError): self.sendCode(failure.value.code, networkString(failure.value.resp)) else: log.err(failure) self.sendCode(451, b"Requested action aborted: local error in processing") def _disconnect(self, msgs): for msg in msgs: try: msg.connectionLost() except BaseException: log.msg("msg raised exception from connectionLost") log.err() def do_DATA(self, rest): if self._from is None or (not self._to): self.sendCode(503, b"Must have valid receiver and originator") return self.mode = DATA helo, origin = self._helo, self._from recipients = self._to self._from = None self._to = [] self.datafailed = None msgs = [] for (user, msgFunc) in recipients: try: msg = msgFunc() rcvdhdr = self.receivedHeader(helo, origin, [user]) if rcvdhdr: msg.lineReceived(rcvdhdr) msgs.append(msg) except SMTPServerError as e: self.sendCode(e.code, e.resp) self.mode = COMMAND self._disconnect(msgs) return except BaseException: log.err() self.sendCode(550, b"Internal server error") self.mode = COMMAND self._disconnect(msgs) return self.__messages = msgs self.__inheader = self.__inbody = 0 self.sendCode(354, b"Continue") if self.noisy: fmt = "Receiving message for delivery: from=%s to=%s" log.msg(fmt % (origin, [str(u) for (u, f) in recipients])) def connectionLost(self, reason): # self.sendCode(421, 'Dropping connection.') # This does nothing... # Ideally, if we (rather than the other side) lose the connection, # we should be able to tell the other side that we are going away. # RFC-2821 requires that we try. if self.mode is DATA: try: for message in self.__messages: try: message.connectionLost() except BaseException: log.err() del self.__messages except AttributeError: pass if self._onLogout: self._onLogout() self._onLogout = None self.setTimeout(None) def do_RSET(self, rest): self._from = None self._to = [] self.sendCode(250, b"I remember nothing.") def dataLineReceived(self, line): if line[:1] == b".": if line == b".": self.mode = COMMAND if self.datafailed: self.sendCode(self.datafailed.code, self.datafailed.resp) return if not self.__messages: self._messageHandled("thrown away") return defer.DeferredList( [m.eomReceived() for m in self.__messages], consumeErrors=True ).addCallback(self._messageHandled) del self.__messages return line = line[1:] if self.datafailed: return try: # Add a blank line between the generated Received:-header # and the message body if the message comes in without any # headers if not self.__inheader and not self.__inbody: if b":" in line: self.__inheader = 1 elif line: for message in self.__messages: message.lineReceived(b"") self.__inbody = 1 if not line: self.__inbody = 1 for message in self.__messages: message.lineReceived(line) except SMTPServerError as e: self.datafailed = e for message in self.__messages: message.connectionLost() state_DATA = dataLineReceived def _messageHandled(self, resultList): failures = 0 for (success, result) in resultList: if not success: failures += 1 log.err(result) if failures: msg = "Could not send e-mail" resultLen = len(resultList) if resultLen > 1: msg += f" ({failures} failures out of {resultLen} recipients)" self.sendCode(550, networkString(msg)) else: self.sendCode(250, b"Delivery in progress") def _cbAnonymousAuthentication(self, result): """ Save the state resulting from a successful anonymous cred login. """ (iface, avatar, logout) = result if issubclass(iface, IMessageDeliveryFactory): self.deliveryFactory = avatar self.delivery = None elif issubclass(iface, IMessageDelivery): self.deliveryFactory = None self.delivery = avatar else: raise RuntimeError(f"{iface.__name__} is not a supported interface") self._onLogout = logout self.challenger = None # overridable methods: def validateFrom(self, helo, origin): """ Validate the address from which the message originates. @type helo: C{(bytes, bytes)} @param helo: The argument to the HELO command and the client's IP address. @type origin: C{Address} @param origin: The address the message is from @rtype: C{Deferred} or C{Address} @return: C{origin} or a C{Deferred} whose callback will be passed C{origin}. @raise SMTPBadSender: Raised of messages from this address are not to be accepted. """ if self.deliveryFactory is not None: self.delivery = self.deliveryFactory.getMessageDelivery() if self.delivery is not None: return defer.maybeDeferred(self.delivery.validateFrom, helo, origin) # No login has been performed, no default delivery object has been # provided: try to perform an anonymous login and then invoke this # method again. if self.portal: result = self.portal.login( cred.credentials.Anonymous(), None, IMessageDeliveryFactory, IMessageDelivery, ) def ebAuthentication(err): """ Translate cred exceptions into SMTP exceptions so that the protocol code which invokes C{validateFrom} can properly report the failure. """ if err.check(cred.error.UnauthorizedLogin): exc = SMTPBadSender(origin) elif err.check(cred.error.UnhandledCredentials): exc = SMTPBadSender( origin, resp="Unauthenticated senders not allowed" ) else: return err return defer.fail(exc) result.addCallbacks(self._cbAnonymousAuthentication, ebAuthentication) def continueValidation(ignored): """ Re-attempt from address validation. """ return self.validateFrom(helo, origin) result.addCallback(continueValidation) return result raise SMTPBadSender(origin) def validateTo(self, user): """ Validate the address for which the message is destined. @type user: L{User} @param user: The address to validate. @rtype: no-argument callable @return: A C{Deferred} which becomes, or a callable which takes no arguments and returns an object implementing C{IMessage}. This will be called and the returned object used to deliver the message when it arrives. @raise SMTPBadRcpt: Raised if messages to the address are not to be accepted. """ if self.delivery is not None: return self.delivery.validateTo(user) raise SMTPBadRcpt(user) def receivedHeader(self, helo, origin, recipients): if self.delivery is not None: return self.delivery.receivedHeader(helo, origin, recipients) heloStr = b"" if helo[0]: heloStr = b" helo=" + helo[0] domain = networkString(self.transport.getHost().host) from_ = b"from " + helo[0] + b" ([" + helo[1] + b"]" + heloStr + b")" by = b"by %s with %s (%s)" % (domain, self.__class__.__name__, longversion) for_ = b"for %s; %s" % (" ".join(map(str, recipients)), rfc822date()) return b"Received: " + from_ + b"\n\t" + by + b"\n\t" + for_ class SMTPFactory(protocol.ServerFactory): """ Factory for SMTP. """ # override in instances or subclasses domain = DNSNAME timeout = 600 protocol = SMTP portal = None def __init__(self, portal=None): self.portal = portal def buildProtocol(self, addr): p = protocol.ServerFactory.buildProtocol(self, addr) p.portal = self.portal p.host = self.domain return p class SMTPClient(basic.LineReceiver, policies.TimeoutMixin): """ SMTP client for sending emails. After the client has connected to the SMTP server, it repeatedly calls L{SMTPClient.getMailFrom}, L{SMTPClient.getMailTo} and L{SMTPClient.getMailData} and uses this information to send an email. It then calls L{SMTPClient.getMailFrom} again; if it returns L{None}, the client will disconnect, otherwise it will continue as normal i.e. call L{SMTPClient.getMailTo} and L{SMTPClient.getMailData} and send a new email. """ # If enabled then log SMTP client server communication debug = True # Number of seconds to wait before timing out a connection. If # None, perform no timeout checking. timeout = None def __init__(self, identity, logsize=10): if isinstance(identity, str): identity = identity.encode("ascii") self.identity = identity or b"" self.toAddressesResult = [] self.successAddresses = [] self._from = None self.resp = [] self.code = -1 self.log = util.LineLog(logsize) def sendLine(self, line): # Log sendLine only if you are in debug mode for performance if self.debug: self.log.append(b">>> " + line) basic.LineReceiver.sendLine(self, line) def connectionMade(self): self.setTimeout(self.timeout) self._expected = [220] self._okresponse = self.smtpState_helo self._failresponse = self.smtpConnectionFailed def connectionLost(self, reason=protocol.connectionDone): """ We are no longer connected """ self.setTimeout(None) self.mailFile = None def timeoutConnection(self): self.sendError( SMTPTimeoutError( -1, b"Timeout waiting for SMTP server response", self.log.str() ) ) def lineReceived(self, line): self.resetTimeout() # Log lineReceived only if you are in debug mode for performance if self.debug: self.log.append(b"<<< " + line) why = None try: self.code = int(line[:3]) except ValueError: # This is a fatal error and will disconnect the transport # lineReceived will not be called again. self.sendError( SMTPProtocolError( -1, f"Invalid response from SMTP server: {line}", self.log.str(), ) ) return if line[0:1] == b"0": # Verbose informational message, ignore it return self.resp.append(line[4:]) if line[3:4] == b"-": # Continuation return if self.code in self._expected: why = self._okresponse(self.code, b"\n".join(self.resp)) else: why = self._failresponse(self.code, b"\n".join(self.resp)) self.code = -1 self.resp = [] return why def smtpConnectionFailed(self, code, resp): self.sendError(SMTPConnectError(code, resp, self.log.str())) def smtpTransferFailed(self, code, resp): if code < 0: self.sendError(SMTPProtocolError(code, resp, self.log.str())) else: self.smtpState_msgSent(code, resp) def smtpState_helo(self, code, resp): self.sendLine(b"HELO " + self.identity) self._expected = SUCCESS self._okresponse = self.smtpState_from def smtpState_from(self, code, resp): self._from = self.getMailFrom() self._failresponse = self.smtpTransferFailed if self._from is not None: self.sendLine(b"MAIL FROM:" + quoteaddr(self._from)) self._expected = [250] self._okresponse = self.smtpState_to else: # All messages have been sent, disconnect self._disconnectFromServer() def smtpState_disconnect(self, code, resp): self.transport.loseConnection() def smtpState_to(self, code, resp): self.toAddresses = iter(self.getMailTo()) self.toAddressesResult = [] self.successAddresses = [] self._okresponse = self.smtpState_toOrData self._expected = range(0, 1000) self.lastAddress = None return self.smtpState_toOrData(0, b"") def smtpState_toOrData(self, code, resp): if self.lastAddress is not None: self.toAddressesResult.append((self.lastAddress, code, resp)) if code in SUCCESS: self.successAddresses.append(self.lastAddress) try: self.lastAddress = next(self.toAddresses) except StopIteration: if self.successAddresses: self.sendLine(b"DATA") self._expected = [354] self._okresponse = self.smtpState_data else: return self.smtpState_msgSent(code, "No recipients accepted") else: self.sendLine(b"RCPT TO:" + quoteaddr(self.lastAddress)) def smtpState_data(self, code, resp): s = basic.FileSender() d = s.beginFileTransfer(self.getMailData(), self.transport, self.transformChunk) def ebTransfer(err): self.sendError(err.value) d.addCallbacks(self.finishedFileTransfer, ebTransfer) self._expected = SUCCESS self._okresponse = self.smtpState_msgSent def smtpState_msgSent(self, code, resp): if self._from is not None: self.sentMail( code, resp, len(self.successAddresses), self.toAddressesResult, self.log ) self.toAddressesResult = [] self._from = None self.sendLine(b"RSET") self._expected = SUCCESS self._okresponse = self.smtpState_from ## ## Helpers for FileSender ## def transformChunk(self, chunk): """ Perform the necessary local to network newline conversion and escape leading periods. This method also resets the idle timeout so that as long as process is being made sending the message body, the client will not time out. """ self.resetTimeout() return chunk.replace(b"\n", b"\r\n").replace(b"\r\n.", b"\r\n..") def finishedFileTransfer(self, lastsent): if lastsent != b"\n": line = b"\r\n." else: line = b"." self.sendLine(line) ## # these methods should be overridden in subclasses def getMailFrom(self): """ Return the email address the mail is from. """ raise NotImplementedError def getMailTo(self): """ Return a list of emails to send to. """ raise NotImplementedError def getMailData(self): """ Return file-like object containing data of message to be sent. Lines in the file should be delimited by '\\n'. """ raise NotImplementedError def sendError(self, exc): """ If an error occurs before a mail message is sent sendError will be called. This base class method sends a QUIT if the error is non-fatal and disconnects the connection. @param exc: The SMTPClientError (or child class) raised @type exc: C{SMTPClientError} """ if isinstance(exc, SMTPClientError) and not exc.isFatal: self._disconnectFromServer() else: # If the error was fatal then the communication channel with the # SMTP Server is broken so just close the transport connection self.smtpState_disconnect(-1, None) def sentMail(self, code, resp, numOk, addresses, log): """ Called when an attempt to send an email is completed. If some addresses were accepted, code and resp are the response to the DATA command. If no addresses were accepted, code is -1 and resp is an informative message. @param code: the code returned by the SMTP Server @param resp: The string response returned from the SMTP Server @param numOk: the number of addresses accepted by the remote host. @param addresses: is a list of tuples (address, code, resp) listing the response to each RCPT command. @param log: is the SMTP session log """ raise NotImplementedError def _disconnectFromServer(self): self._expected = range(0, 1000) self._okresponse = self.smtpState_disconnect self.sendLine(b"QUIT") class ESMTPClient(SMTPClient): """ A client for sending emails over ESMTP. @ivar heloFallback: Whether or not to fall back to plain SMTP if the C{EHLO} command is not recognised by the server. If L{requireAuthentication} is C{True}, or L{requireTransportSecurity} is C{True} and the connection is not over TLS, this fallback flag will not be honored. @type heloFallback: L{bool} @ivar requireAuthentication: If C{True}, refuse to proceed if authentication cannot be performed. Overrides L{heloFallback}. @type requireAuthentication: L{bool} @ivar requireTransportSecurity: If C{True}, refuse to proceed if the transport cannot be secured. If the transport layer is not already secured via TLS, this will override L{heloFallback}. @type requireAuthentication: L{bool} @ivar context: The context factory to use for STARTTLS, if desired. @type context: L{IOpenSSLClientConnectionCreator} @ivar _tlsMode: Whether or not the connection is over TLS. @type _tlsMode: L{bool} """ heloFallback = True requireAuthentication = False requireTransportSecurity = False context = None _tlsMode = False def __init__(self, secret, contextFactory=None, *args, **kw): SMTPClient.__init__(self, *args, **kw) self.authenticators = [] self.secret = secret self.context = contextFactory def __getattr__(self, name): if name == "tlsMode": warnings.warn( "tlsMode attribute of twisted.mail.smtp.ESMTPClient " "is deprecated since Twisted 13.0", category=DeprecationWarning, stacklevel=2, ) return self._tlsMode else: raise AttributeError( "%s instance has no attribute %r" % ( self.__class__.__name__, name, ) ) def __setattr__(self, name, value): if name == "tlsMode": warnings.warn( "tlsMode attribute of twisted.mail.smtp.ESMTPClient " "is deprecated since Twisted 13.0", category=DeprecationWarning, stacklevel=2, ) self._tlsMode = value else: self.__dict__[name] = value def esmtpEHLORequired(self, code=-1, resp=None): """ Fail because authentication is required, but the server does not support ESMTP, which is required for authentication. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} """ self.sendError( EHLORequiredError( 502, b"Server does not support ESMTP " b"Authentication", self.log.str() ) ) def esmtpAUTHRequired(self, code=-1, resp=None): """ Fail because authentication is required, but the server does not support any schemes we support. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} """ tmp = [] for a in self.authenticators: tmp.append(a.getName().upper()) auth = b"[%s]" % b", ".join(tmp) self.sendError( AUTHRequiredError( 502, b"Server does not support Client " b"Authentication schemes %s" % auth, self.log.str(), ) ) def esmtpTLSRequired(self, code=-1, resp=None): """ Fail because TLS is required and the server does not support it. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} """ self.sendError( TLSRequiredError( 502, b"Server does not support secure " b"communication via TLS / SSL", self.log.str(), ) ) def esmtpTLSFailed(self, code=-1, resp=None): """ Fail because the TLS handshake wasn't able to be completed. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} """ self.sendError( TLSError( code, b"Could not complete the SSL/TLS " b"handshake", self.log.str() ) ) def esmtpAUTHDeclined(self, code=-1, resp=None): """ Fail because the authentication was rejected. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} """ self.sendError(AUTHDeclinedError(code, resp, self.log.str())) def esmtpAUTHMalformedChallenge(self, code=-1, resp=None): """ Fail because the server sent a malformed authentication challenge. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} """ self.sendError( AuthenticationError( 501, b"Login failed because the " b"SMTP Server returned a malformed Authentication Challenge", self.log.str(), ) ) def esmtpAUTHServerError(self, code=-1, resp=None): """ Fail because of some other authentication error. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} """ self.sendError(AuthenticationError(code, resp, self.log.str())) def registerAuthenticator(self, auth): """ Registers an Authenticator with the ESMTPClient. The ESMTPClient will attempt to login to the SMTP Server in the order the Authenticators are registered. The most secure Authentication mechanism should be registered first. @param auth: The Authentication mechanism to register @type auth: L{IClientAuthentication} implementor @return: L{None} """ self.authenticators.append(auth) def connectionMade(self): """ Called when a connection has been made, and triggers sending an C{EHLO} to the server. """ self._tlsMode = ISSLTransport.providedBy(self.transport) SMTPClient.connectionMade(self) self._okresponse = self.esmtpState_ehlo def esmtpState_ehlo(self, code, resp): """ Send an C{EHLO} to the server. If L{heloFallback} is C{True}, and there is no requirement for TLS or authentication, the client will fall back to basic SMTP. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} @return: L{None} """ self._expected = SUCCESS self._okresponse = self.esmtpState_serverConfig self._failresponse = self.esmtpEHLORequired if self._tlsMode: needTLS = False else: needTLS = self.requireTransportSecurity if self.heloFallback and not self.requireAuthentication and not needTLS: self._failresponse = self.smtpState_helo self.sendLine(b"EHLO " + self.identity) def esmtpState_serverConfig(self, code, resp): """ Handle a positive response to the I{EHLO} command by parsing the capabilities in the server's response and then taking the most appropriate next step towards entering a mail transaction. """ items = {} for line in resp.splitlines(): e = line.split(None, 1) if len(e) > 1: items[e[0]] = e[1] else: items[e[0]] = None self.tryTLS(code, resp, items) def tryTLS(self, code, resp, items): """ Take a necessary step towards being able to begin a mail transaction. The step may be to ask the server to being a TLS session. If TLS is already in use or not necessary and not available then the step may be to authenticate with the server. If TLS is necessary and not available, fail the mail transmission attempt. This is an internal helper method. @param code: The server status code from the most recently received server message. @type code: L{int} @param resp: The server status response from the most recently received server message. @type resp: L{bytes} @param items: A mapping of ESMTP extensions offered by the server. Keys are extension identifiers and values are the associated values. @type items: L{dict} mapping L{bytes} to L{bytes} @return: L{None} """ # has tls can tls must tls result # t t t authenticate # t t f authenticate # t f t authenticate # t f f authenticate # f t t STARTTLS # f t f STARTTLS # f f t esmtpTLSRequired # f f f authenticate hasTLS = self._tlsMode canTLS = self.context and b"STARTTLS" in items mustTLS = self.requireTransportSecurity if hasTLS or not (canTLS or mustTLS): self.authenticate(code, resp, items) elif canTLS: self._expected = [220] self._okresponse = self.esmtpState_starttls self._failresponse = self.esmtpTLSFailed self.sendLine(b"STARTTLS") else: self.esmtpTLSRequired() def esmtpState_starttls(self, code, resp): """ Handle a positive response to the I{STARTTLS} command by starting a new TLS session on C{self.transport}. Upon success, re-handshake with the server to discover what capabilities it has when TLS is in use. """ try: self.transport.startTLS(self.context) self._tlsMode = True except BaseException: log.err() self.esmtpTLSFailed(451) # Send another EHLO once TLS has been started to # get the TLS / AUTH schemes. Some servers only allow AUTH in TLS mode. self.esmtpState_ehlo(code, resp) def authenticate(self, code, resp, items): if self.secret and items.get(b"AUTH"): schemes = items[b"AUTH"].split() tmpSchemes = {} # XXX: May want to come up with a more efficient way to do this for s in schemes: tmpSchemes[s.upper()] = 1 for a in self.authenticators: auth = a.getName().upper() if auth in tmpSchemes: self._authinfo = a # Special condition handled if auth == b"PLAIN": self._okresponse = self.smtpState_from self._failresponse = self._esmtpState_plainAuth self._expected = [235] challenge = base64.b64encode( self._authinfo.challengeResponse(self.secret, 1) ) self.sendLine(b"AUTH %s %s" % (auth, challenge)) else: self._expected = [334] self._okresponse = self.esmtpState_challenge # If some error occurs here, the server declined the # AUTH before the user / password phase. This would be # a very rare case self._failresponse = self.esmtpAUTHServerError self.sendLine(b"AUTH " + auth) return if self.requireAuthentication: self.esmtpAUTHRequired() else: self.smtpState_from(code, resp) def _esmtpState_plainAuth(self, code, resp): self._okresponse = self.smtpState_from self._failresponse = self.esmtpAUTHDeclined self._expected = [235] challenge = base64.b64encode(self._authinfo.challengeResponse(self.secret, 2)) self.sendLine(b"AUTH PLAIN " + challenge) def esmtpState_challenge(self, code, resp): self._authResponse(self._authinfo, resp) def _authResponse(self, auth, challenge): self._failresponse = self.esmtpAUTHDeclined try: challenge = base64.b64decode(challenge) except binascii.Error: # Illegal challenge, give up, then quit self.sendLine(b"*") self._okresponse = self.esmtpAUTHMalformedChallenge self._failresponse = self.esmtpAUTHMalformedChallenge else: resp = auth.challengeResponse(self.secret, challenge) self._expected = [235, 334] self._okresponse = self.smtpState_maybeAuthenticated self.sendLine(base64.b64encode(resp)) def smtpState_maybeAuthenticated(self, code, resp): """ Called to handle the next message from the server after sending a response to a SASL challenge. The server response might be another challenge or it might indicate authentication has succeeded. """ if code == 235: # Yes, authenticated! del self._authinfo self.smtpState_from(code, resp) else: # No, not authenticated yet. Keep trying. self._authResponse(self._authinfo, resp) class ESMTP(SMTP): ctx = None canStartTLS = False startedTLS = False authenticated = False def __init__(self, chal=None, contextFactory=None): SMTP.__init__(self) if chal is None: chal = {} self.challengers = chal self.authenticated = False self.ctx = contextFactory def connectionMade(self): SMTP.connectionMade(self) self.canStartTLS = ITLSTransport.providedBy(self.transport) self.canStartTLS = self.canStartTLS and (self.ctx is not None) def greeting(self): return SMTP.greeting(self) + b" ESMTP" def extensions(self): """ SMTP service extensions @return: the SMTP service extensions that are supported. @rtype: L{dict} with L{bytes} keys and a value of either L{None} or a L{list} of L{bytes}. """ ext = {b"AUTH": list(self.challengers.keys())} if self.canStartTLS and not self.startedTLS: ext[b"STARTTLS"] = None return ext def lookupMethod(self, command): command = nativeString(command) m = SMTP.lookupMethod(self, command) if m is None: m = getattr(self, "ext_" + command.upper(), None) return m def listExtensions(self): r = [] for c, v in self.extensions().items(): if v is not None: if v: # Intentionally omit extensions with empty argument lists r.append(c + b" " + b" ".join(v)) else: r.append(c) return b"\n".join(r) def do_EHLO(self, rest): peer = self.transport.getPeer().host if not isinstance(peer, bytes): peer = peer.encode("idna") self._helo = (rest, peer) self._from = None self._to = [] self.sendCode( 250, ( self.host + b" Hello " + peer + b", nice to meet you\n" + self.listExtensions() ), ) def ext_STARTTLS(self, rest): if self.startedTLS: self.sendCode(503, b"TLS already negotiated") elif self.ctx and self.canStartTLS: self.sendCode(220, b"Begin TLS negotiation now") self.transport.startTLS(self.ctx) self.startedTLS = True else: self.sendCode(454, b"TLS not available") def ext_AUTH(self, rest): if self.authenticated: self.sendCode(503, b"Already authenticated") return parts = rest.split(None, 1) chal = self.challengers.get(parts[0].upper(), lambda: None)() if not chal: self.sendCode(504, b"Unrecognized authentication type") return self.mode = AUTH self.challenger = chal if len(parts) > 1: chal.getChallenge() # Discard it, apparently the client does not # care about it. rest = parts[1] else: rest = None self.state_AUTH(rest) def _cbAuthenticated(self, loginInfo): """ Save the state resulting from a successful cred login and mark this connection as authenticated. """ result = SMTP._cbAnonymousAuthentication(self, loginInfo) self.authenticated = True return result def _ebAuthenticated(self, reason): """ Handle cred login errors by translating them to the SMTP authenticate failed. Translate all other errors into a generic SMTP error code and log the failure for inspection. Stop all errors from propagating. @param reason: Reason for failure. """ self.challenge = None if reason.check(cred.error.UnauthorizedLogin): self.sendCode(535, b"Authentication failed") else: log.err(reason, "SMTP authentication failure") self.sendCode(451, b"Requested action aborted: local error in processing") def state_AUTH(self, response): """ Handle one step of challenge/response authentication. @param response: The text of a response. If None, this function has been called as a result of an AUTH command with no initial response. A response of '*' aborts authentication, as per RFC 2554. """ if self.portal is None: self.sendCode(454, b"Temporary authentication failure") self.mode = COMMAND return if response is None: challenge = self.challenger.getChallenge() encoded = base64.b64encode(challenge) self.sendCode(334, encoded) return if response == b"*": self.sendCode(501, b"Authentication aborted") self.challenger = None self.mode = COMMAND return try: uncoded = base64.b64decode(response) except (TypeError, binascii.Error): self.sendCode(501, b"Syntax error in parameters or arguments") self.challenger = None self.mode = COMMAND return self.challenger.setResponse(uncoded) if self.challenger.moreChallenges(): challenge = self.challenger.getChallenge() coded = base64.b64encode(challenge) self.sendCode(334, coded) return self.mode = COMMAND result = self.portal.login( self.challenger, None, IMessageDeliveryFactory, IMessageDelivery ) result.addCallback(self._cbAuthenticated) result.addCallback( lambda ign: self.sendCode(235, b"Authentication successful.") ) result.addErrback(self._ebAuthenticated) class SenderMixin: """ Utility class for sending emails easily. Use with SMTPSenderFactory or ESMTPSenderFactory. """ done = 0 def getMailFrom(self): if not self.done: self.done = 1 return str(self.factory.fromEmail) else: return None def getMailTo(self): return self.factory.toEmail def getMailData(self): return self.factory.file def sendError(self, exc): # Call the base class to close the connection with the SMTP server SMTPClient.sendError(self, exc) # Do not retry to connect to SMTP Server if: # 1. No more retries left (This allows the correct error to be returned to the errorback) # 2. retry is false # 3. The error code is not in the 4xx range (Communication Errors) if self.factory.retries >= 0 or ( not exc.retry and not (exc.code >= 400 and exc.code < 500) ): self.factory.sendFinished = True self.factory.result.errback(exc) def sentMail(self, code, resp, numOk, addresses, log): # Do not retry, the SMTP server acknowledged the request self.factory.sendFinished = True if code not in SUCCESS: errlog = [] for addr, acode, aresp in addresses: if acode not in SUCCESS: errlog.append( addr + b": " + networkString("%03d" % (acode,)) + b" " + aresp ) errlog.append(log.str()) exc = SMTPDeliveryError(code, resp, b"\n".join(errlog), addresses) self.factory.result.errback(exc) else: self.factory.result.callback((numOk, addresses)) class SMTPSender(SenderMixin, SMTPClient): """ SMTP protocol that sends a single email based on information it gets from its factory, a L{SMTPSenderFactory}. """ class SMTPSenderFactory(protocol.ClientFactory): """ Utility factory for sending emails easily. @type currentProtocol: L{SMTPSender} @ivar currentProtocol: The current running protocol returned by L{buildProtocol}. @type sendFinished: C{bool} @ivar sendFinished: When the value is set to True, it means the message has been sent or there has been an unrecoverable error or the sending has been cancelled. The default value is False. """ domain = DNSNAME protocol: Type[SMTPClient] = SMTPSender def __init__(self, fromEmail, toEmail, file, deferred, retries=5, timeout=None): """ @param fromEmail: The RFC 2821 address from which to send this message. @param toEmail: A sequence of RFC 2821 addresses to which to send this message. @param file: A file-like object containing the message to send. @param deferred: A Deferred to callback or errback when sending of this message completes. @type deferred: L{defer.Deferred} @param retries: The number of times to retry delivery of this message. @param timeout: Period, in seconds, for which to wait for server responses, or None to wait forever. """ assert isinstance(retries, int) if isinstance(toEmail, str): toEmail = [toEmail.encode("ascii")] elif isinstance(toEmail, bytes): toEmail = [toEmail] else: toEmailFinal = [] for _email in toEmail: if not isinstance(_email, bytes): _email = _email.encode("ascii") toEmailFinal.append(_email) toEmail = toEmailFinal self.fromEmail = Address(fromEmail) self.nEmails = len(toEmail) self.toEmail = toEmail self.file = file self.result = deferred self.result.addBoth(self._removeDeferred) self.sendFinished = False self.currentProtocol = None self.retries = -retries self.timeout = timeout def _removeDeferred(self, result): del self.result return result def clientConnectionFailed(self, connector, err): self._processConnectionError(connector, err) def clientConnectionLost(self, connector, err): self._processConnectionError(connector, err) def _processConnectionError(self, connector, err): self.currentProtocol = None if (self.retries < 0) and (not self.sendFinished): log.msg("SMTP Client retrying server. Retry: %s" % -self.retries) # Rewind the file in case part of it was read while attempting to # send the message. self.file.seek(0, 0) connector.connect() self.retries += 1 elif not self.sendFinished: # If we were unable to communicate with the SMTP server a ConnectionDone will be # returned. We want a more clear error message for debugging if err.check(error.ConnectionDone): err.value = SMTPConnectError(-1, "Unable to connect to server.") self.result.errback(err.value) def buildProtocol(self, addr): p = self.protocol(self.domain, self.nEmails * 2 + 2) p.factory = self p.timeout = self.timeout self.currentProtocol = p self.result.addBoth(self._removeProtocol) return p def _removeProtocol(self, result): """ Remove the protocol created in C{buildProtocol}. @param result: The result/error passed to the callback/errback of L{defer.Deferred}. @return: The C{result} untouched. """ if self.currentProtocol: self.currentProtocol = None return result class LOGINCredentials(_lcredentials): """ L{LOGINCredentials} generates challenges for I{LOGIN} authentication. For interoperability with Outlook, the challenge generated does not exactly match the one defined in the U{draft specification<http://sepp.oetiker.ch/sasl-2.1.19-ds/draft-murchison-sasl-login-00.txt>}. """ def __init__(self): _lcredentials.__init__(self) self.challenges = [b"Password:", b"Username:"] @implementer(IClientAuthentication) class PLAINAuthenticator: def __init__(self, user): self.user = user def getName(self): return b"PLAIN" def challengeResponse(self, secret, chal=1): if chal == 1: return self.user + b"\0" + self.user + b"\0" + secret else: return b"\0" + self.user + b"\0" + secret class ESMTPSender(SenderMixin, ESMTPClient): requireAuthentication = True requireTransportSecurity = True def __init__(self, username, secret, contextFactory=None, *args, **kw): self.heloFallback = 0 self.username = username self._hostname = kw.pop("hostname", None) if contextFactory is None: contextFactory = self._getContextFactory() ESMTPClient.__init__(self, secret, contextFactory, *args, **kw) self._registerAuthenticators() def _registerAuthenticators(self): # Register Authenticator in order from most secure to least secure self.registerAuthenticator(CramMD5ClientAuthenticator(self.username)) self.registerAuthenticator(LOGINAuthenticator(self.username)) self.registerAuthenticator(PLAINAuthenticator(self.username)) def _getContextFactory(self): if self.context is not None: return self.context if self._hostname is None: return None try: from twisted.internet.ssl import optionsForClientTLS except ImportError: return None else: context = optionsForClientTLS(self._hostname) return context class ESMTPSenderFactory(SMTPSenderFactory): """ Utility factory for sending emails easily. @type currentProtocol: L{ESMTPSender} @ivar currentProtocol: The current running protocol as made by L{buildProtocol}. """ protocol = ESMTPSender def __init__( self, username, password, fromEmail, toEmail, file, deferred, retries=5, timeout=None, contextFactory=None, heloFallback=False, requireAuthentication=True, requireTransportSecurity=True, hostname=None, ): SMTPSenderFactory.__init__( self, fromEmail, toEmail, file, deferred, retries, timeout ) self.username = username self.password = password self._contextFactory = contextFactory self._heloFallback = heloFallback self._requireAuthentication = requireAuthentication self._requireTransportSecurity = requireTransportSecurity self._hostname = hostname def buildProtocol(self, addr): """ Build an L{ESMTPSender} protocol configured with C{heloFallback}, C{requireAuthentication}, and C{requireTransportSecurity} as specified in L{__init__}. This sets L{currentProtocol} on the factory, as well as returning it. @rtype: L{ESMTPSender} """ p = self.protocol( self.username, self.password, self._contextFactory, self.domain, self.nEmails * 2 + 2, hostname=self._hostname, ) p.heloFallback = self._heloFallback p.requireAuthentication = self._requireAuthentication p.requireTransportSecurity = self._requireTransportSecurity p.factory = self p.timeout = self.timeout self.currentProtocol = p self.result.addBoth(self._removeProtocol) return p def sendmail( smtphost, from_addr, to_addrs, msg, senderDomainName=None, port=25, reactor=reactor, username=None, password=None, requireAuthentication=False, requireTransportSecurity=False, ): """ Send an email. This interface is intended to be a replacement for L{smtplib.SMTP.sendmail} and related methods. To maintain backwards compatibility, it will fall back to plain SMTP, if ESMTP support is not available. If ESMTP support is available, it will attempt to provide encryption via STARTTLS and authentication if a secret is provided. @param smtphost: The host the message should be sent to. @type smtphost: L{bytes} @param from_addr: The (envelope) address sending this mail. @type from_addr: L{bytes} @param to_addrs: A list of addresses to send this mail to. A string will be treated as a list of one address. @type to_addrs: L{list} of L{bytes} or L{bytes} @param msg: The message, including headers, either as a file or a string. File-like objects need to support read() and close(). Lines must be delimited by '\\n'. If you pass something that doesn't look like a file, we try to convert it to a string (so you should be able to pass an L{email.message} directly, but doing the conversion with L{email.generator} manually will give you more control over the process). @param senderDomainName: Name by which to identify. If None, try to pick something sane (but this depends on external configuration and may not succeed). @type senderDomainName: L{bytes} @param port: Remote port to which to connect. @type port: L{int} @param username: The username to use, if wanting to authenticate. @type username: L{bytes} or L{unicode} @param password: The secret to use, if wanting to authenticate. If you do not specify this, SMTP authentication will not occur. @type password: L{bytes} or L{unicode} @param requireTransportSecurity: Whether or not STARTTLS is required. @type requireTransportSecurity: L{bool} @param requireAuthentication: Whether or not authentication is required. @type requireAuthentication: L{bool} @param reactor: The L{reactor} used to make the TCP connection. @rtype: L{Deferred} @returns: A cancellable L{Deferred}, its callback will be called if a message is sent to ANY address, the errback if no message is sent. When the C{cancel} method is called, it will stop retrying and disconnect the connection immediately. The callback will be called with a tuple (numOk, addresses) where numOk is the number of successful recipient addresses and addresses is a list of tuples (address, code, resp) giving the response to the RCPT command for each address. """ if not hasattr(msg, "read"): # It's not a file msg = BytesIO(bytes(msg)) def cancel(d): """ Cancel the L{twisted.mail.smtp.sendmail} call, tell the factory not to retry and disconnect the connection. @param d: The L{defer.Deferred} to be cancelled. """ factory.sendFinished = True if factory.currentProtocol: factory.currentProtocol.transport.abortConnection() else: # Connection hasn't been made yet connector.disconnect() d = defer.Deferred(cancel) if isinstance(username, str): username = username.encode("utf-8") if isinstance(password, str): password = password.encode("utf-8") tlsHostname = smtphost if not isinstance(tlsHostname, str): tlsHostname = _idnaText(tlsHostname) factory = ESMTPSenderFactory( username, password, from_addr, to_addrs, msg, d, heloFallback=True, requireAuthentication=requireAuthentication, requireTransportSecurity=requireTransportSecurity, hostname=tlsHostname, ) if senderDomainName is not None: factory.domain = networkString(senderDomainName) connector = reactor.connectTCP(smtphost, port, factory) return d import codecs def xtext_encode(s, errors=None): r = [] for ch in iterbytes(s): o = ord(ch) if ch == "+" or ch == "=" or o < 33 or o > 126: r.append(networkString(f"+{o:02X}")) else: r.append(bytes((o,))) return (b"".join(r), len(s)) def xtext_decode(s, errors=None): """ Decode the xtext-encoded string C{s}. @param s: String to decode. @param errors: codec error handling scheme. @return: The decoded string. """ r = [] i = 0 while i < len(s): if s[i : i + 1] == b"+": try: r.append(chr(int(bytes(s[i + 1 : i + 3]), 16))) except ValueError: r.append(ord(s[i : i + 3])) i += 3 else: r.append(bytes(s[i : i + 1]).decode("ascii")) i += 1 return ("".join(r), len(s)) class xtextStreamReader(codecs.StreamReader): def decode(self, s, errors="strict"): return xtext_decode(s) class xtextStreamWriter(codecs.StreamWriter): def decode(self, s, errors="strict"): return xtext_encode(s) def xtext_codec(name): if name == "xtext": return (xtext_encode, xtext_decode, xtextStreamReader, xtextStreamWriter) codecs.register(xtext_codec) PK Mb�Z9��)o )o positioning/base.pynu �[��� # -*- test-case-name: twisted.positioning.test.test_base,twisted.positioning.test.test_sentence -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Generic positioning base classes. @since: 14.0 """ from functools import partial from operator import attrgetter from typing import ClassVar, Sequence from zope.interface import implementer from constantly import NamedConstant, Names # type: ignore[import] from twisted.positioning import ipositioning from twisted.python.util import FancyEqMixin MPS_PER_KNOT = 0.5144444444444444 MPS_PER_KPH = 0.27777777777777777 METERS_PER_FOOT = 0.3048 class Angles(Names): """ The types of angles. @cvar LATITUDE: Angle representing a latitude of an object. @type LATITUDE: L{NamedConstant} @cvar LONGITUDE: Angle representing the longitude of an object. @type LONGITUDE: L{NamedConstant} @cvar HEADING: Angle representing the heading of an object. @type HEADING: L{NamedConstant} @cvar VARIATION: Angle representing a magnetic variation. @type VARIATION: L{NamedConstant} """ LATITUDE = NamedConstant() LONGITUDE = NamedConstant() HEADING = NamedConstant() VARIATION = NamedConstant() class Directions(Names): """ The four cardinal directions (north, east, south, west). """ NORTH = NamedConstant() EAST = NamedConstant() SOUTH = NamedConstant() WEST = NamedConstant() @implementer(ipositioning.IPositioningReceiver) class BasePositioningReceiver: """ A base positioning receiver. This class would be a good base class for building positioning receivers. It implements the interface (so you don't have to) with stub methods. People who want to implement positioning receivers should subclass this class and override the specific callbacks they want to handle. """ def timeReceived(self, time): """ Implements L{IPositioningReceiver.timeReceived} stub. """ def headingReceived(self, heading): """ Implements L{IPositioningReceiver.headingReceived} stub. """ def speedReceived(self, speed): """ Implements L{IPositioningReceiver.speedReceived} stub. """ def climbReceived(self, climb): """ Implements L{IPositioningReceiver.climbReceived} stub. """ def positionReceived(self, latitude, longitude): """ Implements L{IPositioningReceiver.positionReceived} stub. """ def positionErrorReceived(self, positionError): """ Implements L{IPositioningReceiver.positionErrorReceived} stub. """ def altitudeReceived(self, altitude): """ Implements L{IPositioningReceiver.altitudeReceived} stub. """ def beaconInformationReceived(self, beaconInformation): """ Implements L{IPositioningReceiver.beaconInformationReceived} stub. """ class InvalidSentence(Exception): """ An exception raised when a sentence is invalid. """ class InvalidChecksum(Exception): """ An exception raised when the checksum of a sentence is invalid. """ class Angle(FancyEqMixin): """ An object representing an angle. @cvar _RANGE_EXPRESSIONS: A collection of expressions for the allowable range for the angular value of a particular coordinate value. @type _RANGE_EXPRESSIONS: C{dict} of L{Angles} constants to callables @cvar _ANGLE_TYPE_NAMES: English names for angle types. @type _ANGLE_TYPE_NAMES: C{dict} of L{Angles} constants to C{str} """ _RANGE_EXPRESSIONS = { Angles.LATITUDE: lambda latitude: -90.0 < latitude < 90.0, Angles.LONGITUDE: lambda longitude: -180.0 < longitude < 180.0, Angles.HEADING: lambda heading: 0 <= heading < 360, Angles.VARIATION: lambda variation: -180 < variation <= 180, } _ANGLE_TYPE_NAMES = { Angles.LATITUDE: "Latitude", Angles.LONGITUDE: "Longitude", Angles.VARIATION: "Variation", Angles.HEADING: "Heading", } compareAttributes: ClassVar[Sequence[str]] = ( "angleType", "inDecimalDegrees", ) def __init__(self, angle=None, angleType=None): """ Initializes an angle. @param angle: The value of the angle in decimal degrees. (L{None} if unknown). @type angle: C{float} or L{None} @param angleType: A symbolic constant describing the angle type. Should be one of L{Angles} or {None} if unknown. @raises ValueError: If the angle type is not the default argument, but it is an unknown type (not in C{Angle._RANGE_EXPRESSIONS}), or it is a known type but the supplied value was out of the allowable range for said type. """ if angleType is not None and angleType not in self._RANGE_EXPRESSIONS: raise ValueError("Unknown angle type") if angle is not None and angleType is not None: rangeExpression = self._RANGE_EXPRESSIONS[angleType] if not rangeExpression(angle): template = "Angle {0} not in allowed range for type {1}" raise ValueError(template.format(angle, angleType)) self.angleType = angleType self._angle = angle @property def inDecimalDegrees(self): """ The value of this angle in decimal degrees. This value is immutable. @return: This angle expressed in decimal degrees, or L{None} if the angle is unknown. @rtype: C{float} (or L{None}) """ return self._angle @property def inDegreesMinutesSeconds(self): """ The value of this angle as a degrees, minutes, seconds tuple. This value is immutable. @return: This angle expressed in degrees, minutes, seconds. L{None} if the angle is unknown. @rtype: 3-C{tuple} of C{int} (or L{None}) """ if self._angle is None: return None degrees = abs(int(self._angle)) fractionalDegrees = abs(self._angle - int(self._angle)) decimalMinutes = 60 * fractionalDegrees minutes = int(decimalMinutes) fractionalMinutes = decimalMinutes - int(decimalMinutes) decimalSeconds = 60 * fractionalMinutes return degrees, minutes, int(decimalSeconds) def setSign(self, sign): """ Sets the sign of this angle. @param sign: The new sign. C{1} for positive and C{-1} for negative signs, respectively. @type sign: C{int} @raise ValueError: If the C{sign} parameter is not C{-1} or C{1}. """ if sign not in (-1, 1): raise ValueError("bad sign (got %s, expected -1 or 1)" % sign) self._angle = sign * abs(self._angle) def __float__(self): """ Returns this angle as a float. @return: The float value of this angle, expressed in degrees. @rtype: C{float} """ return self._angle def __repr__(self) -> str: """ Returns a string representation of this angle. @return: The string representation. @rtype: C{str} """ return "<{s._angleTypeNameRepr} ({s._angleValueRepr})>".format(s=self) @property def _angleValueRepr(self): """ Returns a string representation of the angular value of this angle. This is a helper function for the actual C{__repr__}. @return: The string representation. @rtype: C{str} """ if self.inDecimalDegrees is not None: return "%s degrees" % round(self.inDecimalDegrees, 2) else: return "unknown value" @property def _angleTypeNameRepr(self): """ Returns a string representation of the type of this angle. This is a helper function for the actual C{__repr__}. @return: The string representation. @rtype: C{str} """ try: return self._ANGLE_TYPE_NAMES[self.angleType] except KeyError: return "Angle of unknown type" class Heading(Angle): """ The heading of a mobile object. @ivar variation: The (optional) magnetic variation. The sign of the variation is positive for variations towards the east (clockwise from north), and negative for variations towards the west (counterclockwise from north). If the variation is unknown or not applicable, this is L{None}. @type variation: C{Angle} or L{None}. @ivar correctedHeading: The heading, corrected for variation. If the variation is unknown (L{None}), is None. This attribute is read-only (its value is determined by the angle and variation attributes). The value is coerced to being between 0 (inclusive) and 360 (exclusive). """ def __init__(self, angle=None, variation=None): """ Initializes an angle with an optional variation. """ Angle.__init__(self, angle, Angles.HEADING) self.variation = variation @classmethod def fromFloats(cls, angleValue=None, variationValue=None): """ Constructs a Heading from the float values of the angle and variation. @param angleValue: The angle value of this heading. @type angleValue: C{float} @param variationValue: The value of the variation of this heading. @type variationValue: C{float} @return: A L{Heading} with the given values. """ variation = Angle(variationValue, Angles.VARIATION) return cls(angleValue, variation) @property def correctedHeading(self): """ Corrects the heading by the given variation. This is sometimes known as the true heading. @return: The heading, corrected by the variation. If the variation or the angle are unknown, returns L{None}. @rtype: C{float} or L{None} """ if self._angle is None or self.variation is None: return None angle = (self.inDecimalDegrees - self.variation.inDecimalDegrees) % 360 return Angle(angle, Angles.HEADING) def setSign(self, sign): """ Sets the sign of the variation of this heading. @param sign: The new sign. C{1} for positive and C{-1} for negative signs, respectively. @type sign: C{int} @raise ValueError: If the C{sign} parameter is not C{-1} or C{1}. """ if self.variation.inDecimalDegrees is None: raise ValueError("can't set the sign of an unknown variation") self.variation.setSign(sign) compareAttributes = list(Angle.compareAttributes) + ["variation"] def __repr__(self) -> str: """ Returns a string representation of this angle. @return: The string representation. @rtype: C{str} """ if self.variation is None: variationRepr = "unknown variation" else: variationRepr = repr(self.variation) return "<{} ({}, {})>".format( self._angleTypeNameRepr, self._angleValueRepr, variationRepr, ) class Coordinate(Angle): """ A coordinate. @ivar angle: The value of the coordinate in decimal degrees, with the usual rules for sign (northern and eastern hemispheres are positive, southern and western hemispheres are negative). @type angle: C{float} """ def __init__(self, angle, coordinateType=None): """ Initializes a coordinate. @param angle: The angle of this coordinate in decimal degrees. The hemisphere is determined by the sign (north and east are positive). If this coordinate describes a latitude, this value must be within -90.0 and +90.0 (exclusive). If this value describes a longitude, this value must be within -180.0 and +180.0 (exclusive). @type angle: C{float} @param coordinateType: The coordinate type. One of L{Angles.LATITUDE}, L{Angles.LONGITUDE} or L{None} if unknown. """ if coordinateType not in [Angles.LATITUDE, Angles.LONGITUDE, None]: raise ValueError( "coordinateType must be one of Angles.LATITUDE, " "Angles.LONGITUDE or None, was {!r}".format(coordinateType) ) Angle.__init__(self, angle, coordinateType) @property def hemisphere(self): """ Gets the hemisphere of this coordinate. @return: A symbolic constant representing a hemisphere (one of L{Angles}) """ if self.angleType is Angles.LATITUDE: if self.inDecimalDegrees < 0: return Directions.SOUTH else: return Directions.NORTH elif self.angleType is Angles.LONGITUDE: if self.inDecimalDegrees < 0: return Directions.WEST else: return Directions.EAST else: raise ValueError("unknown coordinate type (cant find hemisphere)") class Altitude(FancyEqMixin): """ An altitude. @ivar inMeters: The altitude represented by this object, in meters. This attribute is read-only. @type inMeters: C{float} @ivar inFeet: As above, but expressed in feet. @type inFeet: C{float} """ compareAttributes = ("inMeters",) def __init__(self, altitude): """ Initializes an altitude. @param altitude: The altitude in meters. @type altitude: C{float} """ self._altitude = altitude @property def inFeet(self): """ Gets the altitude this object represents, in feet. @return: The altitude, expressed in feet. @rtype: C{float} """ return self._altitude / METERS_PER_FOOT @property def inMeters(self): """ Returns the altitude this object represents, in meters. @return: The altitude, expressed in feet. @rtype: C{float} """ return self._altitude def __float__(self): """ Returns the altitude represented by this object expressed in meters. @return: The altitude represented by this object, expressed in meters. @rtype: C{float} """ return self._altitude def __repr__(self) -> str: """ Returns a string representation of this altitude. @return: The string representation. @rtype: C{str} """ return f"<Altitude ({self._altitude} m)>" class _BaseSpeed(FancyEqMixin): """ An object representing the abstract concept of the speed (rate of movement) of a mobile object. This primarily has behavior for converting between units and comparison. """ compareAttributes = ("inMetersPerSecond",) def __init__(self, speed): """ Initializes a speed. @param speed: The speed that this object represents, expressed in meters per second. @type speed: C{float} @raises ValueError: Raised if value was invalid for this particular kind of speed. Only happens in subclasses. """ self._speed = speed @property def inMetersPerSecond(self): """ The speed that this object represents, expressed in meters per second. This attribute is immutable. @return: The speed this object represents, in meters per second. @rtype: C{float} """ return self._speed @property def inKnots(self): """ Returns the speed represented by this object, expressed in knots. This attribute is immutable. @return: The speed this object represents, in knots. @rtype: C{float} """ return self._speed / MPS_PER_KNOT def __float__(self): """ Returns the speed represented by this object expressed in meters per second. @return: The speed represented by this object, expressed in meters per second. @rtype: C{float} """ return self._speed def __repr__(self) -> str: """ Returns a string representation of this speed object. @return: The string representation. @rtype: C{str} """ speedValue = round(self.inMetersPerSecond, 2) return f"<{self.__class__.__name__} ({speedValue} m/s)>" class Speed(_BaseSpeed): """ The speed (rate of movement) of a mobile object. """ def __init__(self, speed): """ Initializes a L{Speed} object. @param speed: The speed that this object represents, expressed in meters per second. @type speed: C{float} @raises ValueError: Raised if C{speed} is negative. """ if speed < 0: raise ValueError(f"negative speed: {speed!r}") _BaseSpeed.__init__(self, speed) class Climb(_BaseSpeed): """ The climb ("vertical speed") of an object. """ def __init__(self, climb): """ Initializes a L{Climb} object. @param climb: The climb that this object represents, expressed in meters per second. @type climb: C{float} """ _BaseSpeed.__init__(self, climb) class PositionError(FancyEqMixin): """ Position error information. @cvar _ALLOWABLE_THRESHOLD: The maximum allowable difference between PDOP and the geometric mean of VDOP and HDOP. That difference is supposed to be zero, but can be non-zero because of rounding error and limited reporting precision. You should never have to change this value. @type _ALLOWABLE_THRESHOLD: C{float} @cvar _DOP_EXPRESSIONS: A mapping of DOP types (C[hvp]dop) to a list of callables that take self and return that DOP type, or raise C{TypeError}. This allows a DOP value to either be returned directly if it's know, or computed from other DOP types if it isn't. @type _DOP_EXPRESSIONS: C{dict} of C{str} to callables @ivar pdop: The position dilution of precision. L{None} if unknown. @type pdop: C{float} or L{None} @ivar hdop: The horizontal dilution of precision. L{None} if unknown. @type hdop: C{float} or L{None} @ivar vdop: The vertical dilution of precision. L{None} if unknown. @type vdop: C{float} or L{None} """ compareAttributes = "pdop", "hdop", "vdop" def __init__(self, pdop=None, hdop=None, vdop=None, testInvariant=False): """ Initializes a positioning error object. @param pdop: The position dilution of precision. L{None} if unknown. @type pdop: C{float} or L{None} @param hdop: The horizontal dilution of precision. L{None} if unknown. @type hdop: C{float} or L{None} @param vdop: The vertical dilution of precision. L{None} if unknown. @type vdop: C{float} or L{None} @param testInvariant: Flag to test if the DOP invariant is valid or not. If C{True}, the invariant (PDOP = (HDOP**2 + VDOP**2)*.5) is checked at every mutation. By default, this is false, because the vast majority of DOP-providing devices ignore this invariant. @type testInvariant: c{bool} """ self._pdop = pdop self._hdop = hdop self._vdop = vdop self._testInvariant = testInvariant self._testDilutionOfPositionInvariant() _ALLOWABLE_TRESHOLD = 0.01 def _testDilutionOfPositionInvariant(self): """ Tests if this positioning error object satisfies the dilution of position invariant (PDOP = (HDOP**2 + VDOP**2)*.5), unless the C{self._testInvariant} instance variable is C{False}. @return: L{None} if the invariant was not satisfied or not tested. @raises ValueError: Raised if the invariant was tested but not satisfied. """ if not self._testInvariant: return for x in (self.pdop, self.hdop, self.vdop): if x is None: return delta = abs(self.pdop - (self.hdop ** 2 + self.vdop ** 2) ** 0.5) if delta > self._ALLOWABLE_TRESHOLD: raise ValueError( "invalid combination of dilutions of precision: " "position: %s, horizontal: %s, vertical: %s" % (self.pdop, self.hdop, self.vdop) ) _DOP_EXPRESSIONS = { "pdop": [ lambda self: float(self._pdop), lambda self: (self._hdop ** 2 + self._vdop ** 2) ** 0.5, ], "hdop": [ lambda self: float(self._hdop), lambda self: (self._pdop ** 2 - self._vdop ** 2) ** 0.5, ], "vdop": [ lambda self: float(self._vdop), lambda self: (self._pdop ** 2 - self._hdop ** 2) ** 0.5, ], } def _getDOP(self, dopType): """ Gets a particular dilution of position value. @param dopType: The type of dilution of position to get. One of ('pdop', 'hdop', 'vdop'). @type dopType: C{str} @return: The DOP if it is known, L{None} otherwise. @rtype: C{float} or L{None} """ for dopExpression in self._DOP_EXPRESSIONS[dopType]: try: return dopExpression(self) except TypeError: continue def _setDOP(self, dopType, value): """ Sets a particular dilution of position value. @param dopType: The type of dilution of position to set. One of ('pdop', 'hdop', 'vdop'). @type dopType: C{str} @param value: The value to set the dilution of position type to. @type value: C{float} If this position error tests dilution of precision invariants, it will be checked. If the invariant is not satisfied, the assignment will be undone and C{ValueError} is raised. """ attributeName = "_" + dopType oldValue = getattr(self, attributeName) setattr(self, attributeName, float(value)) try: self._testDilutionOfPositionInvariant() except ValueError: setattr(self, attributeName, oldValue) raise @property def pdop(self): return self._getDOP("pdop") @pdop.setter def pdop(self, value): return self._setDOP("pdop", value) @property def hdop(self): return self._getDOP("hdop") @hdop.setter def hdop(self, value): return self._setDOP("hdop", value) @property def vdop(self): return self._getDOP("vdop") @vdop.setter def vdop(self, value): return self._setDOP("vdop", value) _REPR_TEMPLATE = "<PositionError (pdop: %s, hdop: %s, vdop: %s)>" def __repr__(self) -> str: """ Returns a string representation of positioning information object. @return: The string representation. @rtype: C{str} """ return self._REPR_TEMPLATE % (self.pdop, self.hdop, self.vdop) class BeaconInformation: """ Information about positioning beacons (a generalized term for the reference objects that help you determine your position, such as satellites or cell towers). @ivar seenBeacons: A set of visible beacons. Note that visible beacons are not necessarily used in acquiring a positioning fix. @type seenBeacons: C{set} of L{IPositioningBeacon} @ivar usedBeacons: A set of the beacons that were used in obtaining a positioning fix. This only contains beacons that are actually used, not beacons for which it is unknown if they are used or not. @type usedBeacons: C{set} of L{IPositioningBeacon} """ def __init__(self, seenBeacons=()): """ Initializes a beacon information object. @param seenBeacons: A collection of beacons that are currently seen. @type seenBeacons: iterable of L{IPositioningBeacon}s """ self.seenBeacons = set(seenBeacons) self.usedBeacons = set() def __repr__(self) -> str: """ Returns a string representation of this beacon information object. The beacons are sorted by their identifier. @return: The string representation. @rtype: C{str} """ sortedBeacons = partial(sorted, key=attrgetter("identifier")) usedBeacons = sortedBeacons(self.usedBeacons) unusedBeacons = sortedBeacons(self.seenBeacons - self.usedBeacons) template = ( "<BeaconInformation (" "used beacons ({numUsed}): {usedBeacons}, " "unused beacons: {unusedBeacons})>" ) formatted = template.format( numUsed=len(self.usedBeacons), usedBeacons=usedBeacons, unusedBeacons=unusedBeacons, ) return formatted @implementer(ipositioning.IPositioningBeacon) class PositioningBeacon: """ A positioning beacon. @ivar identifier: The unique identifier for this beacon. This is usually an integer. For GPS, this is also known as the PRN. @type identifier: Pretty much anything that can be used as a unique identifier. Depends on the implementation. """ def __init__(self, identifier): """ Initializes a positioning beacon. @param identifier: The identifier for this beacon. @type identifier: Can be pretty much anything (see ivar documentation). """ self.identifier = identifier def __hash__(self): """ Returns the hash of the identifier for this beacon. @return: The hash of the identifier. (C{hash(self.identifier)}) @rtype: C{int} """ return hash(self.identifier) def __repr__(self) -> str: """ Returns a string representation of this beacon. @return: The string representation. @rtype: C{str} """ return f"<Beacon ({self.identifier})>" class Satellite(PositioningBeacon): """ A satellite. @ivar azimuth: The azimuth of the satellite. This is the heading (positive angle relative to true north) where the satellite appears to be to the device. @ivar elevation: The (positive) angle above the horizon where this satellite appears to be to the device. @ivar signalToNoiseRatio: The signal to noise ratio of the signal coming from this satellite. """ def __init__( self, identifier, azimuth=None, elevation=None, signalToNoiseRatio=None ): """ Initializes a satellite object. @param identifier: The PRN (unique identifier) of this satellite. @type identifier: C{int} @param azimuth: The azimuth of the satellite (see instance variable documentation). @type azimuth: C{float} @param elevation: The elevation of the satellite (see instance variable documentation). @type elevation: C{float} @param signalToNoiseRatio: The signal to noise ratio of the connection to this satellite (see instance variable documentation). @type signalToNoiseRatio: C{float} """ PositioningBeacon.__init__(self, int(identifier)) self.azimuth = azimuth self.elevation = elevation self.signalToNoiseRatio = signalToNoiseRatio def __repr__(self) -> str: """ Returns a string representation of this Satellite. @return: The string representation. @rtype: C{str} """ template = ( "<Satellite ({s.identifier}), " "azimuth: {s.azimuth}, " "elevation: {s.elevation}, " "snr: {s.signalToNoiseRatio}>" ) return template.format(s=self) __all__ = [ "Altitude", "Angle", "Angles", "BasePositioningReceiver", "BeaconInformation", "Climb", "Coordinate", "Directions", "Heading", "InvalidChecksum", "InvalidSentence", "METERS_PER_FOOT", "MPS_PER_KNOT", "MPS_PER_KPH", "PositionError", "PositioningBeacon", "Satellite", "Speed", ] PK Mb�Z6�_�� � positioning/ipositioning.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Positioning interfaces. @since: 14.0 """ from zope.interface import Attribute, Interface class IPositioningReceiver(Interface): """ An interface for positioning providers. """ def positionReceived(latitude, longitude): """ Method called when a position is received. @param latitude: The latitude of the received position. @type latitude: L{twisted.positioning.base.Coordinate} @param longitude: The longitude of the received position. @type longitude: L{twisted.positioning.base.Coordinate} """ def positionErrorReceived(positionError): """ Method called when position error is received. @param positionError: The position error. @type positionError: L{twisted.positioning.base.PositionError} """ def timeReceived(time): """ Method called when time and date information arrives. @param time: The date and time (expressed in UTC unless otherwise specified). @type time: L{datetime.datetime} """ def headingReceived(heading): """ Method called when a true heading is received. @param heading: The heading. @type heading: L{twisted.positioning.base.Heading} """ def altitudeReceived(altitude): """ Method called when an altitude is received. @param altitude: The altitude. @type altitude: L{twisted.positioning.base.Altitude} """ def speedReceived(speed): """ Method called when the speed is received. @param speed: The speed of a mobile object. @type speed: L{twisted.positioning.base.Speed} """ def climbReceived(climb): """ Method called when the climb is received. @param climb: The climb of the mobile object. @type climb: L{twisted.positioning.base.Climb} """ def beaconInformationReceived(beaconInformation): """ Method called when positioning beacon information is received. @param beaconInformation: The beacon information. @type beaconInformation: L{twisted.positioning.base.BeaconInformation} """ class IPositioningBeacon(Interface): """ A positioning beacon. """ identifier = Attribute( """ A unique identifier for this beacon. The type is dependent on the implementation, but must be immutable. """ ) class INMEAReceiver(Interface): """ An object that can receive NMEA data. """ def sentenceReceived(sentence): """ Method called when a sentence is received. @param sentence: The received NMEA sentence. @type L{twisted.positioning.nmea.NMEASentence} """ __all__ = ["IPositioningReceiver", "IPositioningBeacon", "INMEAReceiver"] PK Mb�ZC�!�� � 1 positioning/__pycache__/_sentence.cpython-310.pycnu �[��� o �bp � @ s0 d Z ddlmZ G dd� d�ZG dd� d�ZdS )z6 Generic sentence handling tools: hopefully reusable. � )�Setc @ sN e Zd ZU dZe� Zee ed< dd� Z e dd� �Z dd� Z d efd d �Z d S ) � _BaseSentencea- A base sentence class for a particular protocol. Using this base class, specific sentence classes can almost automatically be created for a particular protocol. To do this, fill the ALLOWED_ATTRIBUTES class attribute using the C{getSentenceAttributes} class method of the producer:: class FooSentence(BaseSentence): """ A sentence for integalactic transmodulator sentences. @ivar transmogrificationConstant: The value used in the transmogrifier while producing this sentence, corrected for gravitational fields. @type transmogrificationConstant: C{Tummy} """ ALLOWED_ATTRIBUTES = FooProtocol.getSentenceAttributes() @ivar presentAttributes: An iterable containing the names of the attributes that are present in this sentence. @type presentAttributes: iterable of C{str} @cvar ALLOWED_ATTRIBUTES: A set of attributes that are allowed in this sentence. @type ALLOWED_ATTRIBUTES: C{set} of C{str} �ALLOWED_ATTRIBUTESc C s || _ dS )z� Initializes a sentence with parsed sentence data. @param sentenceData: The parsed sentence data. @type sentenceData: C{dict} (C{str} -> C{str} or L{None}) N)� _sentenceData)�self� sentenceData� r �?/usr/lib/python3/dist-packages/twisted/positioning/_sentence.py�__init__( s z_BaseSentence.__init__c C s t | j�S )z� An iterable containing the names of the attributes that are present in this sentence. @return: The iterable of names of present attributes. @rtype: iterable of C{str} )�iterr )r r r r �presentAttributes1 s z _BaseSentence.presentAttributesc C s8 || j v r | j�|d�S | jj}|� d|� d�}t|��)z5 Gets an attribute of this sentence. Nz sentences have no z attributes)r r �get� __class__�__name__�AttributeError)r �name� className�msgr r r � __getattr__< s z_BaseSentence.__getattr__�returnc C sV | j �� }dd� t|�D �}d�|�}| j �d�pd}| jj}d|� d|� d|� d �S ) z� Returns a textual representation of this sentence. @return: A textual representation of this sentence. @rtype: C{str} c S s& g | ]\}}|d kr|� d|� ��qS )�typez: r )�.0�k�vr r r � <listcomp>O s & z*_BaseSentence.__repr__.<locals>.<listcomp>z, r z unknown type�<z (z) {z}>)r �items�sorted�joinr r r )r r �data�dataRepr�typeReprr r r r �__repr__G s z_BaseSentence.__repr__N)r � __module__� __qualname__�__doc__�setr r �str�__annotations__r �propertyr r r" r r r r r s r c @ s e Zd ZdZedd� �ZdS )�!_PositioningSentenceProducerMixina� A mixin for certain protocols that produce positioning sentences. This mixin helps protocols that store the layout of sentences that they consume in a C{_SENTENCE_CONTENTS} class variable provide all sentence attributes that can ever occur. It does this by providing a class method, C{getSentenceAttributes}, which iterates over all sentence types and collects the possible sentence attributes. c C s8 dh}| j �� D ]}|D ] }|du rq |�|� q q|S )aR Returns a set of all attributes that might be found in the sentences produced by this protocol. This is basically a set of all the attributes of all the sentences that this protocol can produce. @return: The set of all possible sentence attribute names. @rtype: C{set} of C{str} r N)�_SENTENCE_CONTENTS�values�add)�cls� attributes� attributeList� attributer r r �getSentenceAttributesc s �z7_PositioningSentenceProducerMixin.getSentenceAttributesN)r r# r$ r% � classmethodr2 r r r r r* X s r* N)r% �typingr r r* r r r r �<module> s OPK Mb�Z�4j} 0 positioning/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z] Twisted Positioning: Framework for applications that make use of positioning. @since: 14.0 N)�__doc__� r r �>/usr/lib/python3/dist-packages/twisted/positioning/__init__.py�<module> s PK Mb�Z"N�q � � , positioning/__pycache__/nmea.cpython-310.pycnu �[��� o �bn� � @ s d Z ddlZddlZddlmZ ddlmZ ddlmZm Z ddl m Z m Z m Z ddlmZ ddlmZ dd lmZmZ G d d � d e �ZG d d � d e �ZG dd� de �Zdd� Zdd� ZG dd� dee j�ZG dd� de j �Z ee j �G dd� d��Z g d�Z dS )a� Classes for working with NMEA 0183 sentence producing devices. This standard is generally just called "NMEA", which is actually the name of the body that produces the standard, not the standard itself.. For more information, read the blog post on NMEA by ESR (the gpsd maintainer) at U{http://esr.ibiblio.org/?p=801}. Unfortunately, official specifications on NMEA 0183 are only available at a cost. More information can be found on the Wikipedia page: U{https://en.wikipedia.org/wiki/NMEA_0183}. The official standard may be obtained through the NMEA's website: U{http://www.nmea.org/content/nmea_standards/nmea_0183_v_410.asp}. @since: 14.0 � N)�reduce)� implementer)� ValueConstant�Values)� _sentence�base� ipositioning)�Angles)� LineReceiver)� iterbytes� nativeStringc @ s4 e Zd ZdZdZdZdZdZdZdZ dZ d Z d Z d S ) �GPGGAFixQualitiesav The possible fix quality indications for GPGGA sentences. @cvar INVALID_FIX: The fix is invalid. @cvar GPS_FIX: There is a fix, acquired using GPS. @cvar DGPS_FIX: There is a fix, acquired using differential GPS (DGPS). @cvar PPS_FIX: There is a fix, acquired using the precise positioning service (PPS). @cvar RTK_FIX: There is a fix, acquired using fixed real-time kinematics. This means that there was a sufficient number of shared satellites with the base station, usually yielding a resolution in the centimeter range. This was added in NMEA 0183 version 3.0. This is also called Carrier-Phase Enhancement or CPGPS, particularly when used in combination with GPS. @cvar FLOAT_RTK_FIX: There is a fix, acquired using floating real-time kinematics. The same comments apply as for a fixed real-time kinematics fix, except that there were insufficient shared satellites to acquire it, so instead you got a slightly less good floating fix. Typical resolution in the decimeter range. @cvar DEAD_RECKONING: There is currently no more fix, but this data was computed using a previous fix and some information about motion (either from that fix or from other sources) using simple dead reckoning. Not particularly reliable, but better-than-nonsense data. @cvar MANUAL: There is no real fix from this device, but the location has been manually entered, presumably with data obtained from some other positioning method. @cvar SIMULATED: There is no real fix, but instead it is being simulated. �0�1�2�3�4�5�6�7�8N) �__name__� __module__� __qualname__�__doc__� INVALID_FIX�GPS_FIX�DGPS_FIX�PPS_FIX�RTK_FIX� FLOAT_RTK_FIX�DEAD_RECKONING�MANUAL� SIMULATED� r$ r$ �:/usr/lib/python3/dist-packages/twisted/positioning/nmea.pyr % s r c @ s e Zd ZdZed�Zed�ZdS )�GPGLLGPRMCFixQualitiesa� The possible fix quality indications in GPGLL and GPRMC sentences. Unfortunately, these sentences only indicate whether data is good or void. They provide no other information, such as what went wrong if the data is void, or how good the data is if the data is not void. @cvar ACTIVE: The data is okay. @cvar VOID: The data is void, and should not be used. �A�VN)r r r r r �ACTIVE�VOIDr$ r$ r$ r% r& N s r& c @ s( e Zd ZdZed�Zed�Zed�ZdS )� GPGSAFixTypesa The possible fix types of a GPGSA sentence. @cvar GSA_NO_FIX: The sentence reports no fix at all. @cvar GSA_2D_FIX: The sentence reports a 2D fix: position but no altitude. @cvar GSA_3D_FIX: The sentence reports a 3D fix: position with altitude. r r r N)r r r r r � GSA_NO_FIX� GSA_2D_FIX� GSA_3D_FIXr$ r$ r$ r% r+ ^ s r+ c C sT | dd� dkr| dd� � d�S | dd� dkr"| dd� � d�S t�d| � ���) z� Returns the split version of an NMEA sentence, minus header and checksum. >>> _split(b"$GPGGA,spam,eggs*00") [b'GPGGA', b'spam', b'eggs'] @param sentence: The NMEA sentence to split. @type sentence: C{bytes} ������� *� � ,���Nzmalformed sentence )�splitr �InvalidSentence)�sentencer$ r$ r% �_splitl s r8 c C sr | dd� dkr5t | dd� d�| dd� }}ttjdd� t|�D ��}||kr7t�|d �d |d ����dS dS ) a7 Validates the checksum of an NMEA sentence. @param sentence: The NMEA sentence to check the checksum of. @type sentence: C{bytes} @raise ValueError: If the sentence has an invalid checksum. Simply returns on sentences that either don't have a checksum, or have a valid checksum. r/ r0 r1 N� r2 c S � g | ]}t |��qS r$ )�ord��.0�xr$ r$ r% � <listcomp>� � z%_validateChecksum.<locals>.<listcomp>�02xz != )�intr �operator�xorr r �InvalidChecksum)r7 � reference�source�computedr$ r$ r% �_validateChecksum s �rI c @ sP e Zd ZdZddd�Zdd� Zg d�g d�g d �g d �d gg d �g d �d�ZdS )� NMEAProtocola� A protocol that parses and verifies the checksum of an NMEA sentence (in string form, not L{NMEASentence}), and delegates to a receiver. It receives lines and verifies these lines are NMEA sentences. If they are, verifies their checksum and unpacks them into their components. It then wraps them in L{NMEASentence} objects and calls the appropriate receiver method with them. @cvar _SENTENCE_CONTENTS: Has the field names in an NMEA sentence for each sentence type (in order, obviously). @type _SENTENCE_CONTENTS: C{dict} of bytestrings to C{list}s of C{str} @param receiver: A receiver for NMEAProtocol sentence objects. @type receiver: L{INMEAReceiver} @param sentenceCallback: A function that will be called with a new L{NMEASentence} when it is created. Useful for massaging data from particularly misbehaving NMEA receivers. @type sentenceCallback: unary callable Nc C s || _ || _dS )a� Initializes an NMEAProtocol. @param receiver: A receiver for NMEAProtocol sentence objects. @type receiver: L{INMEAReceiver} @param sentenceCallback: A function that will be called with a new L{NMEASentence} when it is created. Useful for massaging data from particularly misbehaving NMEA receivers. @type sentenceCallback: unary callable N)� _receiver�_sentenceCallback)�self�receiver�sentenceCallbackr$ r$ r% �__init__� s zNMEAProtocol.__init__c C s� |� � }t|� t|�}t|d �}dd� |dd� D �}z| j| }W n ty1 td| ��w d|i}t||�D ]\}} |durK| dkrK| ||< q;t|�}| j durZ| � |� | j � |� dS ) z� Parses the data from the sentence and validates the checksum. @param rawSentence: The NMEA positioning sentence. @type rawSentence: C{bytes} r c S r: r$ )r r< r$ r$ r% r? � r@ z-NMEAProtocol.lineReceived.<locals>.<listcomp>r2 Nzunknown sentence type %s�type� ) �striprI r8 r �_SENTENCE_CONTENTS�KeyError� ValueError�zip� NMEASentencerL rK �sentenceReceived) rM � rawSentencer7 � splitSentence� sentenceType�contents�keys� sentenceData�key�valuer$ r$ r% � lineReceived� s& �� zNMEAProtocol.lineReceived)� timestamp� latitudeFloat�latitudeHemisphere�longitudeFloat�longitudeHemisphere� fixQuality�numberOfSatellitesSeen� horizontalDilutionOfPrecision�altitude� altitudeUnits�heightOfGeoidAboveWGS84� heightOfGeoidAboveWGS84UnitsNN) rc �dataModerd re rf rg � speedInKnots� trueHeading� datestamp�magneticVariation�magneticVariationDirection)�numberOfGSVSentences�GSVSentenceIndexri �satellitePRN_0� elevation_0� azimuth_0�signalToNoiseRatio_0�satellitePRN_1� elevation_1� azimuth_1�signalToNoiseRatio_1�satellitePRN_2� elevation_2� azimuth_2�signalToNoiseRatio_2�satellitePRN_3� elevation_3� azimuth_3�signalToNoiseRatio_3)rd re rf rg rc ro rq ) rr rc rd re rf rg � elevation�numberOfIterations�numberOfDopplerIntervals� updateDistanceInNauticalMiles� satellitePRN)ro �fixType�usedSatellitePRN_0�usedSatellitePRN_1�usedSatellitePRN_2�usedSatellitePRN_3�usedSatellitePRN_4�usedSatellitePRN_5�usedSatellitePRN_6�usedSatellitePRN_7�usedSatellitePRN_8�usedSatellitePRN_9�usedSatellitePRN_10�usedSatellitePRN_11�positionDilutionOfPrecisionrj �verticalDilutionOfPrecision)�GPGGA�GPRMC�GPGSV�GPGLL�GPHDT�GPTRF�GPGSA�N)r r r r rP rb rT r$ r$ r$ r% rJ � s ! � �rJ c @ s( e Zd ZdZe�� Zdd� Zdd� ZdS )rX a� An object representing an NMEA sentence. The attributes of this objects are raw NMEA protocol data, which are all ASCII bytestrings. This object contains all the raw NMEA protocol data in a single sentence. Not all of these necessarily have to be present in the sentence. Missing attributes are L{None} when accessed. @ivar type: The sentence type (C{"GPGGA"}, C{"GPGSV"}...). @ivar numberOfGSVSentences: The total number of GSV sentences in a sequence. @ivar GSVSentenceIndex: The index of this GSV sentence in the GSV sequence. @ivar timestamp: A timestamp. (C{"123456"} -> 12:34:56Z) @ivar datestamp: A datestamp. (C{"230394"} -> 23 Mar 1994) @ivar latitudeFloat: Latitude value. (for example: C{"1234.567"} -> 12 degrees, 34.567 minutes). @ivar latitudeHemisphere: Latitudinal hemisphere (C{"N"} or C{"S"}). @ivar longitudeFloat: Longitude value. See C{latitudeFloat} for an example. @ivar longitudeHemisphere: Longitudinal hemisphere (C{"E"} or C{"W"}). @ivar altitude: The altitude above mean sea level. @ivar altitudeUnits: Units in which altitude is expressed. (Always C{"M"} for meters.) @ivar heightOfGeoidAboveWGS84: The local height of the geoid above the WGS84 ellipsoid model. @ivar heightOfGeoidAboveWGS84Units: The units in which the height above the geoid is expressed. (Always C{"M"} for meters.) @ivar trueHeading: The true heading. @ivar magneticVariation: The magnetic variation. @ivar magneticVariationDirection: The direction of the magnetic variation. One of C{"E"} or C{"W"}. @ivar speedInKnots: The ground speed, expressed in knots. @ivar fixQuality: The quality of the fix. @type fixQuality: One of L{GPGGAFixQualities}. @ivar dataMode: Signals if the data is usable or not. @type dataMode: One of L{GPGLLGPRMCFixQualities}. @ivar numberOfSatellitesSeen: The number of satellites seen by the receiver. @ivar numberOfSatellitesUsed: The number of satellites used in computing the fix. @ivar horizontalDilutionOfPrecision: The dilution of the precision of the position on a plane tangential to the geoid. (HDOP) @ivar verticalDilutionOfPrecision: As C{horizontalDilutionOfPrecision}, but for a position on a plane perpendicular to the geoid. (VDOP) @ivar positionDilutionOfPrecision: Euclidean norm of HDOP and VDOP. @ivar satellitePRN: The unique identifcation number of a particular satellite. Optionally suffixed with C{_N} if multiple satellites are referenced in a sentence, where C{N in range(4)}. @ivar elevation: The elevation of a satellite in decimal degrees. Optionally suffixed with C{_N}, as with C{satellitePRN}. @ivar azimuth: The azimuth of a satellite in decimal degrees. Optionally suffixed with C{_N}, as with C{satellitePRN}. @ivar signalToNoiseRatio: The SNR of a satellite signal, in decibels. Optionally suffixed with C{_N}, as with C{satellitePRN}. @ivar usedSatellitePRN_N: Where C{int(N) in range(12)}. The PRN of a satellite used in computing the fix. c C s | j dkS )z� Tests if this current GSV sentence is the first one in a sequence. @return: C{True} if this is the first GSV sentence. @rtype: C{bool} r )rv �rM r$ r$ r% �_isFirstGSVSentencew s z NMEASentence._isFirstGSVSentencec C s | j | jkS )z� Tests if this current GSV sentence is the final one in a sequence. @return: C{True} if this is the last GSV sentence. @rtype: C{bool} )rv ru r� r$ r$ r% �_isLastGSVSentence� s z NMEASentence._isLastGSVSentenceN) r r r r rJ �getSentenceAttributes�ALLOWED_ATTRIBUTESr� r� r$ r$ r$ r% rX 7 s = rX c @ s� e Zd ZdZdd� Zdd� ZdZdd� Zd d � Zdcd d �Z dd� Z dd� Z de j defde j ddd� fde jdefde jdefde jdefd�Zd d � Zed g�Zd d� d d� d!�Zddd"d#�Zd$d%� Zd&d'� Zeed(�Zd)d*� Zi d+d,d� �d-d.d� �d/d0d� �d1d2d� �d3d4d� �d5d6d� �d7d8d� �d9d:d� �d;d<d� �d=d>d� �d?d@d� �dAdBd� �dCdDd� �dEdFd� �dGdHd� �dIdJd� �dKdLd� �dMdNd� i�ZdOdP� ZdQdR� Z dSdT� Z dUdV� Z dWdX� Z dYdZ� Z d[d\� Z!d]d^� Z"d_d`� Z#dadb� Z$d S )e� NMEAAdaptera An adapter from NMEAProtocol receivers to positioning receivers. @cvar _STATEFUL_UPDATE: Information on how to update partial information in the sentence data or internal adapter state. For more information, see C{_statefulUpdate}'s docstring. @type _STATEFUL_UPDATE: See C{_statefulUpdate}'s docstring @cvar _ACCEPTABLE_UNITS: A set of NMEA notations of units that are already acceptable (metric), and therefore don't need to be converted. @type _ACCEPTABLE_UNITS: C{frozenset} of bytestrings @cvar _UNIT_CONVERTERS: Mapping of NMEA notations of units that are not acceptable (not metric) to converters that take a quantity in that unit and produce a metric quantity. @type _UNIT_CONVERTERS: C{dict} of bytestrings to unary callables @cvar _SPECIFIC_SENTENCE_FIXES: A mapping of sentece types to specific fixes that are required to extract useful information from data from those sentences. @type _SPECIFIC_SENTENCE_FIXES: C{dict} of sentence types to callables that take self and modify it in-place @cvar _FIXERS: Set of unary callables that take an NMEAAdapter instance and extract useful data from the sentence data, usually modifying the adapter's sentence data in-place. @type _FIXERS: C{dict} of native strings to unary callables @ivar yearThreshold: The earliest possible year that data will be interpreted as. For example, if this value is C{1990}, an NMEA 0183 two-digit year of "96" will be interpreted as 1996, and a two-digit year of "13" will be interpreted as 2013. @type yearThreshold: L{int} @ivar _state: The current internal state of the receiver. @type _state: C{dict} @ivar _sentenceData: The data present in the sentence currently being processed. Starts empty, is filled as the sentence is parsed. @type _sentenceData: C{dict} @ivar _receiver: The positioning receiver that will receive parsed data. @type _receiver: L{ipositioning.IPositioningReceiver} c C s i | _ i | _|| _dS )z� Initializes a new NMEA adapter. @param receiver: The receiver for positioning sentences. @type receiver: L{ipositioning.IPositioningReceiver} N)�_state� _sentenceDatarK )rM rN r$ r$ r% rP � s zNMEAAdapter.__init__c C s2 | j j�d�d }tj�|d��� }|| jd< dS )z� Turns the NMEAProtocol timestamp notation into a datetime.time object. The time in this object is expressed as Zulu time. �.r z%H%M%S�_timeN)�currentSentencerc r5 �datetime�strptime�timer� )rM rc � timeObjectr$ r$ r% � _fixTimestamp� s zNMEAAdapter._fixTimestampi� c C st | j j}tt|dd� |dd� |dd� g�\}}}|| j| jd 7 }|| jk r.|d7 }t�|||�| jd< dS )z� Turns an NMEA datestamp format into a C{datetime.date} object. @raise ValueError: When the day or month value was invalid, e.g. 32nd day, or 13th month, or 0th day or month. r � � � �d �_dateN)r� rr �maprB � yearThresholdr� �dater� )rM r� �day�month�yearr$ r$ r% � _fixDatestamp� s . zNMEAAdapter._fixDatestampc C s� |t ju rd}nd}t| j|d �}|�d�\}}t|dd� �t|dd� � d|� ��}}||d }t�||�} | | j |< dS )z� Turns the NMEAProtocol coordinate format into Python float. @param coordinateType: The coordinate type. @type coordinateType: One of L{Angles.LATITUDE} or L{Angles.LONGITUDE}. �latitude� longitude�Floatr� Nr0 �< ) r �LATITUDE�getattrr� r5 rB �floatr � Coordinater� ) rM �coordinateType�coordinateName�nmeaCoordinate�left�right�degrees�minutes�angle� coordinater$ r$ r% �_fixCoordinateFloat� s , z NMEAAdapter._fixCoordinateFloatNc C s& |p|}| � |�}| j| �|� dS )a� Fixes the sign for a hemisphere. This method must be called after the magnitude for the thing it determines the sign of has been set. This is done by the following functions: - C{self.FIXERS['magneticVariation']} - C{self.FIXERS['latitudeFloat']} - C{self.FIXERS['longitudeFloat']} @param coordinateType: Coordinate type. One of L{Angles.LATITUDE}, L{Angles.LONGITUDE} or L{Angles.VARIATION}. @param sentenceDataKey: The key name of the hemisphere sign being fixed in the sentence data. If unspecified, C{coordinateType} is used. @type sentenceDataKey: C{str} (unless L{None}) N)�_getHemisphereSignr� �setSign)rM r� �sentenceDataKey�signr$ r$ r% �_fixHemisphereSign� s z NMEAAdapter._fixHemisphereSignc C st |t ju rd}n|t ju rd}n|t ju rd}ntd|� ���t| j|��� }|dv r-dS |dv r3dS td |� ���) aS Returns the hemisphere sign for a given coordinate type. @param coordinateType: The coordinate type to find the hemisphere for. @type coordinateType: L{Angles.LATITUDE}, L{Angles.LONGITUDE} or L{Angles.VARIATION}. @return: The sign of that hemisphere (-1 or 1). @rtype: C{int} re rg rt zunknown coordinate type �NEr2 �SWr4 zbad hemisphere/direction: )r r� � LONGITUDE� VARIATIONrV r� r� �upper)rM r� � hemisphereKey� hemispherer$ r$ r% r� s z NMEAAdapter._getHemisphereSignc C s t | j|�}||�| j|< dS )a A simple conversion fix. @param key: The attribute name of the value to fix. @type key: native string (Python identifier) @param converter: The function that converts the value. @type converter: unary callable N)r� r� r� )rM r` � converter� currentValuer$ r$ r% �_convert s zNMEAAdapter._convert�heading�_angle� variationc C s t �t| �tj�S r� )r �Angler� r r� )r� r$ r$ r% �<lambda>2 s zNMEAAdapter.<lambda>� positionError�hdop�vdop�pdop)rq rs rj r� r� c C sv | j | \}}}}|| jvr(z | j| | j|< W n ty' |� | j|< Y nw |t| j|��}t| j| ||� dS )a� Does a stateful update of a particular positioning attribute. Specifically, this will mutate an object in the current sentence data. Using the C{sentenceKey}, this will get a tuple containing, in order, the key name in the current state and sentence data, a factory for new values, the attribute to update, and a converter from sentence data (in NMEA notation) to something useful. If the sentence data doesn't have this data yet, it is grabbed from the state. If that doesn't have anything useful yet either, the factory is called to produce a new, empty object. Either way, the object ends up in the sentence data. @param sentenceKey: The name of the key in the sentence attributes, C{NMEAAdapter._STATEFUL_UPDATE} dictionary and the adapter state. @type sentenceKey: C{str} N)�_STATEFUL_UPDATEr� r� rU r� r� �setattr)rM � sentenceKeyr` �factory�attrr� �newValuer$ r$ r% �_statefulUpdateH s �zNMEAAdapter._statefulUpdate�Mc C � t �t| �t j �S r� )r �Speedr� � MPS_PER_KNOT)�inKnotsr$ r$ r% r� h r@ c C r� r� )r r� r� � MPS_PER_KPH)�inKPHr$ r$ r% r� i r@ )�N�Kc C s� |du r t | j|�}|du r"|dur |�d�r |dd� }ntd��|du r(|}|| jvrA| j| }t | j|�}||�| j|< dS dS )a� Fixes the units of a certain value. If the units are already acceptable (metric), does nothing. None of the keys are allowed to be the empty string. @param unit: The unit that is being converted I{from}. If unspecified or L{None}, asks the current sentence for the C{unitKey}. If that also fails, raises C{AttributeError}. @type unit: C{str} @param unitKey: The name of the key/attribute under which the unit can be found in the current sentence. If the C{unit} parameter is set, this parameter is not used. @type unitKey: C{str} @param sourceKey: The name of the key/attribute that contains the current value to be converted (expressed in units as defined according to the C{unit} parameter). If unset, will use the same key as the value key. @type sourceKey: C{str} @param valueKey: The key name in which the data will be stored in the C{_sentenceData} instance attribute. If unset, attempts to remove "Units" from the end of the C{unitKey} parameter. If that fails, raises C{ValueError}. @type valueKey: C{str} N�Units���z,valueKey unspecified and couldn't be guessed)r� r� �endswithrV �_ACCEPTABLE_UNITS�_UNIT_CONVERTERSr� )rM �unitKey�valueKey� sourceKey�unitr� r� r$ r$ r% � _fixUnitsl s �zNMEAAdapter._fixUnitsc s~ t �� }|�jd< d}td�D ]-� �fdd�� fdd�|D �D �\}}}}|du s-|du r.qt �||||�}|j�|� qdS )zS Parses partial visible satellite information from a GSV sentence. �_partialBeaconInformation)r� �azimuthr� �signalToNoiseRatior� c 3 s � | ] }t � j|�V qd S r� )r� r� )r= r� r� r$ r% � <genexpr>� s � � �z&NMEAAdapter._fixGSV.<locals>.<genexpr>c 3 s � | ] }d |� f V qdS )z%s_%iNr$ �r= r` )�indexr$ r% r � s � N)r �BeaconInformationr� �range� Satellite� seenBeacons�add)rM �beaconInformationr^ �prnr r� �snr� satelliter$ )r rM r% �_fixGSV� s ��zNMEAAdapter._fixGSVc C sR t � | jd< dd� td�D �D ]}t| j|d�}|dur&| jd �t|�� qdS )aQ Extracts the information regarding which satellites were used in obtaining the GPS fix from a GSA sentence. Precondition: A GSA sentence was fired. Postcondition: The current sentence data (C{self._sentenceData} will contain a set of the currently used PRNs (under the key C{_usedPRNs}. � _usedPRNsc s s � | ]}d |f V qdS )zusedSatellitePRN_%dNr$ r< r$ r$ r% r � � � z&NMEAAdapter._fixGSA.<locals>.<genexpr>� N)�setr� r r� r� r rB )rM r` r r$ r$ r% �_fixGSA� s ��zNMEAAdapter._fixGSA)r� r� c C s( | j �| jj�}|dur|| � dS dS )zA Executes a fix for a specific type of sentence. N)�_SPECIFIC_SENTENCE_FIXES�getr� rQ )rM �fixerr$ r$ r% �_sentenceSpecificFix� s �z NMEAAdapter._sentenceSpecificFixrQ c C � | � � S r� )r r� r$ r$ r% r� � � rc c C r r� )r� r� r$ r$ r% r� � r rr c C r r� )r� r� r$ r$ r% r� � r rd c C � | � tj�S r� )r� r r� r� r$ r$ r% r� � � re c C � | � tjd�S )Nr� )r� r r� r� r$ r$ r% r� � � �rf c C r r� )r� r r� r� r$ r$ r% r� � r rg c C r )Nr� )r� r r� r� r$ r$ r% r� � r! rk c C � | j ddd� d�S )Nrk c S � t �t| ��S r� �r �Altituder� ��strReprr$ r$ r% r� � � �&NMEAAdapter.<lambda>.<locals>.<lambda>�r� �r� r� r$ r$ r% r� � s �rl c C � | j dd�S )Nrl �r� �r r� r$ r$ r% r� � r rm c C r" )Nrm c S r# r� r$ r& r$ r$ r% r� � r( r) r* r+ r� r$ r$ r% r� � s �rn c C r, )Nrn r- r. r� r$ r$ r% r� � s �rq c C � | � d�S )Nrq �r� r� r$ r$ r% r� � � rs c C r/ )Nrs r0 r� r$ r$ r% r� � r1 rt c C r )Nr� )r� r r� r� r$ r$ r% r� � r! rp c C s | j dddd�S )N�speedrp r� )r� r r r. r� r$ r$ r% r� � s �r� c C r/ )Nr� r0 r� r$ r$ r% r� � � �rj c C r/ )Nrj r0 r� r$ r$ r% r� � r3 r� c C r/ )Nr� r0 r� r$ r$ r% r� � r3 c C s i | _ i | _dS )zp Resets this adapter. This will empty the adapter state and the current sentence data. N)r� r� r� r$ r$ r% �clear� s zNMEAAdapter.clearc C sR || _ i | _z | �� | �� W n tjy | �� Y nw | �� | �� dS )aj Called when a sentence is received. Will clean the received NMEAProtocol sentence up, and then update the adapter's state, followed by firing the callbacks. If the received sentence was invalid, the state will be cleared. @param sentence: The sentence that is received. @type sentence: L{NMEASentence} N) r� r� �_validateCurrentSentence�_cleanCurrentSentencer r6 r4 � _updateState�_fireSentenceCallbacks)rM r7 r$ r$ r% rY � s � z NMEAAdapter.sentenceReceivedc C s8 | j jtju s| j jtju s| j jtj u rt � d��dS )z; Tests if a sentence contains a valid fix. z bad sentenceN) r� rh r r ro r& r* r� r+ r, r r6 r� r$ r$ r% r5 s �z$NMEAAdapter._validateCurrentSentencec C s4 t | jj�D ]}| j�|d�}|dur|| � qdS )z. Cleans the current sentence. N)�sortedr� �presentAttributes�_FIXERSr )rM r` r r$ r$ r% r6 " s ��z!NMEAAdapter._cleanCurrentSentencec C s" | � � | �� | j�| j� dS )zW Updates the current state with the new information from the sentence. N)�_updateBeaconInformation�_combineDateAndTimer� �updater� r� r$ r$ r% r7 , s zNMEAAdapter._updateStatec C sf | j �d�}|du r dS | �|� | �|� | j�� r1| j�� s$| jd= | j �d�}|| j d< dS dS )zJ Updates existing beacon information state with new data. r Nr ) r� r �_updateUsedBeacons�_mergeBeaconInformationr� r� r� r� �pop)rM �new�bir$ r$ r% r< 4 s �z$NMEAAdapter._updateBeaconInformationc C sR | j | jfD ] }|�d�}|dur nqdS |jD ] }|j|v r&|j�|� qdS )a� Searches the adapter state and sentence data for information about which beacons where used, then adds it to the provided beacon information object. If no new beacon usage information is available, does nothing. @param beaconInformation: The beacon information object that beacon usage information will be added to (if necessary). @type beaconInformation: L{twisted.positioning.base.BeaconInformation} r N)r� r� r r � identifier� usedBeaconsr )rM r rG �usedPRNs�beaconr$ r$ r% r? F s � ��z NMEAAdapter._updateUsedBeaconsc C s< | j �d�}|du r dS dD ] }t||��t||�� qdS )a� Merges beacon information in the adapter state (if it exists) into the provided beacon information. Specifically, this merges used and seen beacons. If the adapter state has no beacon information, does nothing. @param newBeaconInformation: The beacon information object that beacon information will be merged into (if necessary). @type newBeaconInformation: L{twisted.positioning.base.BeaconInformation} r N)r rE )r� r r� r> )rM �newBeaconInformation�oldr� r$ r$ r% r@ ] s �z#NMEAAdapter._mergeBeaconInformationc s` t � fdd�dD ��s dS � fdd�dD �\}}|du s |du r"dS tj�||�}|� jd< dS )z� Combines a C{datetime.date} object and a C{datetime.time} object, collected from one or more NMEA sentences, into a single C{datetime.datetime} object suitable for sending to the L{IPositioningReceiver}. c 3 s � | ]}|� j v V qd S r� )r� )r= �kr� r$ r% r w r z2NMEAAdapter._combineDateAndTime.<locals>.<genexpr>)r� r� Nc 3 s( � | ]}� j �|�p� j�|�V qd S r� )r� r r� r r� r$ r% r | s � � �r� )�anyr� �combiner� )rM r� r� �dtr$ r� r% r= p s �z NMEAAdapter._combineDateAndTimec C s� t j}|�� D ]7\}}t| j|�}i }d}z|jD ]}|| jv r"d}| j| ||< qW n ty4 Y qw |r>|di |�� qdS )a< Fires sentence callbacks for the current sentence. A callback will only fire if all of the keys it requires are present in the current state and at least one such field was altered in the current sentence. The callbacks will only be fired with data from L{_state}. FTNr$ ) r �IPositioningReceiver�namesAndDescriptionsr� rK � positionalr� r� rU )rM �iface�name�method�callback�kwargs�atLeastOnePresentInSentence�fieldr$ r$ r% r8 � s$ � ���z"NMEAAdapter._fireSentenceCallbacksr� )NNNN)%r r r r rP r� r� r� r� r� r� r� r �Headingr� � PositionErrorr� r� � frozensetr� r� r r r r r r; r4 rY r5 r6 r7 r< r? r@ r= r8 r$ r$ r$ r% r� � s� % ����� � )������� � ������� � �"�%�* r� )rJ rX r� )!r r� rC � functoolsr �zope.interfacer � constantlyr r �twisted.positioningr r r �twisted.positioning.baser �twisted.protocols.basicr �twisted.python.compatr r r r& r+ r8 rI �!_PositioningSentenceProducerMixinrJ � _BaseSentencerX � INMEAReceiverr� �__all__r$ r$ r$ r% �<module> s2 ) &S PK Mb�Z��6�{ { 4 positioning/__pycache__/ipositioning.cpython-310.pycnu �[��� o �b� � @ sP d Z ddlmZmZ G dd� de�ZG dd� de�ZG dd� de�Zg d �Zd S ) z' Positioning interfaces. @since: 14.0 � )� Attribute� Interfacec @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )�IPositioningReceiverz1 An interface for positioning providers. c C � dS )a> Method called when a position is received. @param latitude: The latitude of the received position. @type latitude: L{twisted.positioning.base.Coordinate} @param longitude: The longitude of the received position. @type longitude: L{twisted.positioning.base.Coordinate} N� )�latitude� longituder r �B/usr/lib/python3/dist-packages/twisted/positioning/ipositioning.py�positionReceived � z%IPositioningReceiver.positionReceivedc C r )z� Method called when position error is received. @param positionError: The position error. @type positionError: L{twisted.positioning.base.PositionError} Nr )� positionErrorr r r �positionErrorReceived r z*IPositioningReceiver.positionErrorReceivedc C r )z� Method called when time and date information arrives. @param time: The date and time (expressed in UTC unless otherwise specified). @type time: L{datetime.datetime} Nr )�timer r r � timeReceived$ r z!IPositioningReceiver.timeReceivedc C r )z� Method called when a true heading is received. @param heading: The heading. @type heading: L{twisted.positioning.base.Heading} Nr )�headingr r r �headingReceived- r z$IPositioningReceiver.headingReceivedc C r )z� Method called when an altitude is received. @param altitude: The altitude. @type altitude: L{twisted.positioning.base.Altitude} Nr )�altituder r r �altitudeReceived5 r z%IPositioningReceiver.altitudeReceivedc C r )z� Method called when the speed is received. @param speed: The speed of a mobile object. @type speed: L{twisted.positioning.base.Speed} Nr )�speedr r r � speedReceived= r z"IPositioningReceiver.speedReceivedc C r )z� Method called when the climb is received. @param climb: The climb of the mobile object. @type climb: L{twisted.positioning.base.Climb} Nr )�climbr r r � climbReceivedE r z"IPositioningReceiver.climbReceivedc C r )z� Method called when positioning beacon information is received. @param beaconInformation: The beacon information. @type beaconInformation: L{twisted.positioning.base.BeaconInformation} Nr )�beaconInformationr r r �beaconInformationReceivedM r z.IPositioningReceiver.beaconInformationReceivedN) �__name__� __module__� __qualname__�__doc__r r r r r r r r r r r r r s r c @ s e Zd ZdZed�ZdS )�IPositioningBeaconz A positioning beacon. z� A unique identifier for this beacon. The type is dependent on the implementation, but must be immutable. N)r r r r r � identifierr r r r r V s �r c @ s e Zd ZdZdd� ZdS )� INMEAReceiverz/ An object that can receive NMEA data. c C r )z� Method called when a sentence is received. @param sentence: The received NMEA sentence. @type L{twisted.positioning.nmea.NMEASentence} Nr )�sentencer r r �sentenceReceivedh r z INMEAReceiver.sentenceReceivedN)r r r r r" r r r r r c s r )r r r N)r �zope.interfacer r r r r �__all__r r r r �<module> s I PK Mb�Z� ��x x , positioning/__pycache__/base.cpython-310.pycnu �[��� o �b)o � @ s� d Z ddlmZ ddlmZ ddlmZmZ ddlm Z ddl m Z m Z ddl mZ ddlmZ d Zd Zd ZG d d � d e �ZG dd� de �Ze ej�G dd� d��ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Z G dd� de�Z G d d � d e�Z G d d � d e�Z G d d!� d!e �Z G d"d#� d#e �Z!G d$d%� d%e�Z"G d&d'� d'�Z#e ej$�G d(d)� d)��Z%G d*d+� d+e%�Z&g d,�Z'd-S ).z1 Generic positioning base classes. @since: 14.0 � )�partial)� attrgetter)�ClassVar�Sequence)� implementer)� NamedConstant�Names)� ipositioning)� FancyEqMixing��2Tv�?gr �q ��?g����ׁ�?c @ �( e Zd ZdZe� Ze� Ze� Ze� ZdS )�Anglesa� The types of angles. @cvar LATITUDE: Angle representing a latitude of an object. @type LATITUDE: L{NamedConstant} @cvar LONGITUDE: Angle representing the longitude of an object. @type LONGITUDE: L{NamedConstant} @cvar HEADING: Angle representing the heading of an object. @type HEADING: L{NamedConstant} @cvar VARIATION: Angle representing a magnetic variation. @type VARIATION: L{NamedConstant} N) �__name__� __module__� __qualname__�__doc__r �LATITUDE� LONGITUDE�HEADING� VARIATION� r r �:/usr/lib/python3/dist-packages/twisted/positioning/base.pyr s r c @ r )� DirectionszB The four cardinal directions (north, east, south, west). N) r r r r r �NORTH�EAST�SOUTH�WESTr r r r r 3 s r c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )�BasePositioningReceiveraS A base positioning receiver. This class would be a good base class for building positioning receivers. It implements the interface (so you don't have to) with stub methods. People who want to implement positioning receivers should subclass this class and override the specific callbacks they want to handle. c C � dS )zG Implements L{IPositioningReceiver.timeReceived} stub. Nr )�self�timer r r � timeReceivedK � z$BasePositioningReceiver.timeReceivedc C r )zJ Implements L{IPositioningReceiver.headingReceived} stub. Nr )r �headingr r r �headingReceivedP r! z'BasePositioningReceiver.headingReceivedc C r )zH Implements L{IPositioningReceiver.speedReceived} stub. Nr �r �speedr r r � speedReceivedU r! z%BasePositioningReceiver.speedReceivedc C r )zH Implements L{IPositioningReceiver.climbReceived} stub. Nr �r �climbr r r � climbReceivedZ r! z%BasePositioningReceiver.climbReceivedc C r )zK Implements L{IPositioningReceiver.positionReceived} stub. Nr )r �latitude� longituder r r �positionReceived_ r! z(BasePositioningReceiver.positionReceivedc C r )zP Implements L{IPositioningReceiver.positionErrorReceived} stub. Nr )r � positionErrorr r r �positionErrorReceivedd r! z-BasePositioningReceiver.positionErrorReceivedc C r )zK Implements L{IPositioningReceiver.altitudeReceived} stub. Nr �r �altituder r r �altitudeReceivedi r! z(BasePositioningReceiver.altitudeReceivedc C r )zT Implements L{IPositioningReceiver.beaconInformationReceived} stub. Nr )r �beaconInformationr r r �beaconInformationReceivedn r! z1BasePositioningReceiver.beaconInformationReceivedN) r r r r r r# r& r) r, r. r1 r3 r r r r r > s r c @ � e Zd ZdZdS )�InvalidSentencez9 An exception raised when a sentence is invalid. N�r r r r r r r r r5 t � r5 c @ r4 )�InvalidChecksumzI An exception raised when the checksum of a sentence is invalid. Nr6 r r r r r8 z r7 r8 c @ s� e Zd ZU dZejdd� ejdd� ejdd� ejdd� iZ ejdejdejd ejd iZ d Z e e e ed < d dd�Zedd� �Zedd� �Zdd� Zdd� Zdefdd�Zedd � �Zed d � �Zd S ) �Anglea� An object representing an angle. @cvar _RANGE_EXPRESSIONS: A collection of expressions for the allowable range for the angular value of a particular coordinate value. @type _RANGE_EXPRESSIONS: C{dict} of L{Angles} constants to callables @cvar _ANGLE_TYPE_NAMES: English names for angle types. @type _ANGLE_TYPE_NAMES: C{dict} of L{Angles} constants to C{str} c C � d| k o dk S S )Ng �V�g �V@r )r* r r r �<lambda>� � zAngle.<lambda>c C r: )Ng �f�g �f@r )r+ r r r r; � r< c C s d| ko dk S S )Nr �h r )r" r r r r; � r< c C s d| k o dkS S )NiL���� r )� variationr r r r; � r< �Latitude� Longitude� Variation�Heading)� angleType�inDecimalDegrees�compareAttributesNc C s` |dur || j vr td��|dur(|dur(| j | }||�s(d}t|�||���|| _|| _dS )aG Initializes an angle. @param angle: The value of the angle in decimal degrees. (L{None} if unknown). @type angle: C{float} or L{None} @param angleType: A symbolic constant describing the angle type. Should be one of L{Angles} or {None} if unknown. @raises ValueError: If the angle type is not the default argument, but it is an unknown type (not in C{Angle._RANGE_EXPRESSIONS}), or it is a known type but the supplied value was out of the allowable range for said type. NzUnknown angle typez+Angle {0} not in allowed range for type {1})�_RANGE_EXPRESSIONS� ValueError�formatrD �_angle)r �anglerD �rangeExpression�templater r r �__init__� s zAngle.__init__c C � | j S )z� The value of this angle in decimal degrees. This value is immutable. @return: This angle expressed in decimal degrees, or L{None} if the angle is unknown. @rtype: C{float} (or L{None}) �rJ �r r r r rE � � zAngle.inDecimalDegreesc C sb | j du rdS tt| j ��}t| j t| j � �}d| }t|�}|t|� }d| }||t|�fS )a The value of this angle as a degrees, minutes, seconds tuple. This value is immutable. @return: This angle expressed in degrees, minutes, seconds. L{None} if the angle is unknown. @rtype: 3-C{tuple} of C{int} (or L{None}) N�< )rJ �abs�int)r �degrees�fractionalDegrees�decimalMinutes�minutes�fractionalMinutes�decimalSecondsr r r �inDegreesMinutesSeconds� s z Angle.inDegreesMinutesSecondsc C s( |dvr t d| ��|t| j� | _dS )a Sets the sign of this angle. @param sign: The new sign. C{1} for positive and C{-1} for negative signs, respectively. @type sign: C{int} @raise ValueError: If the C{sign} parameter is not C{-1} or C{1}. )���� z#bad sign (got %s, expected -1 or 1)N)rH rT rJ �r �signr r r �setSign� s z Angle.setSignc C rO )z� Returns this angle as a float. @return: The float value of this angle, expressed in degrees. @rtype: C{float} rP rQ r r r � __float__� � zAngle.__float__�returnc C s dj | d�S )�� Returns a string representation of this angle. @return: The string representation. @rtype: C{str} z.<{s._angleTypeNameRepr} ({s._angleValueRepr})>��s�rI rQ r r r �__repr__� s zAngle.__repr__c C s | j dur dt| j d� S dS )z� Returns a string representation of the angular value of this angle. This is a helper function for the actual C{__repr__}. @return: The string representation. @rtype: C{str} Nz %s degrees� z unknown value)rE �roundrQ r r r �_angleValueRepr� s zAngle._angleValueReprc C s$ z| j | j W S ty Y dS w )z� Returns a string representation of the type of this angle. This is a helper function for the actual C{__repr__}. @return: The string representation. @rtype: C{str} zAngle of unknown type)�_ANGLE_TYPE_NAMESrD �KeyErrorrQ r r r �_angleTypeNameRepr s �zAngle._angleTypeNameRepr�NN)r r r r r r r r r rG rm rF r r �str�__annotations__rN �propertyrE r\ ra rb ri rl ro r r r r r9 � s2 �� r9 c @ sZ e Zd ZdZddd�Zeddd��Zedd� �Zd d � Z e e j �d g Z d e fd d�ZdS )rC a� The heading of a mobile object. @ivar variation: The (optional) magnetic variation. The sign of the variation is positive for variations towards the east (clockwise from north), and negative for variations towards the west (counterclockwise from north). If the variation is unknown or not applicable, this is L{None}. @type variation: C{Angle} or L{None}. @ivar correctedHeading: The heading, corrected for variation. If the variation is unknown (L{None}), is None. This attribute is read-only (its value is determined by the angle and variation attributes). The value is coerced to being between 0 (inclusive) and 360 (exclusive). Nc C s t �| |tj� || _dS )zB Initializes an angle with an optional variation. N)r9 rN r r r? )r rK r? r r r rN , s zHeading.__init__c C s t |tj�}| ||�S )a_ Constructs a Heading from the float values of the angle and variation. @param angleValue: The angle value of this heading. @type angleValue: C{float} @param variationValue: The value of the variation of this heading. @type variationValue: C{float} @return: A L{Heading} with the given values. )r9 r r )�cls� angleValue�variationValuer? r r r � fromFloats3 s zHeading.fromFloatsc C s6 | j du s | jdu r dS | j| jj d }t|tj�S )a Corrects the heading by the given variation. This is sometimes known as the true heading. @return: The heading, corrected by the variation. If the variation or the angle are unknown, returns L{None}. @rtype: C{float} or L{None} Nr= )rJ r? rE r9 r r )r rK r r r �correctedHeadingA s zHeading.correctedHeadingc C s$ | j jdu r td��| j �|� dS )a Sets the sign of the variation of this heading. @param sign: The new sign. C{1} for positive and C{-1} for negative signs, respectively. @type sign: C{int} @raise ValueError: If the C{sign} parameter is not C{-1} or C{1}. Nz*can't set the sign of an unknown variation)r? rE rH ra r_ r r r ra Q s zHeading.setSignr? rd c C s, | j du rd}nt| j �}d�| j| j|�S )re Nzunknown variationz <{} ({}, {})>)r? �reprrI ro rl )r � variationReprr r r ri b s �zHeading.__repr__rp )r r r r rN � classmethodrw rs rx ra �listr9 rF rq ri r r r r rC s rC c @ s& e Zd ZdZddd�Zedd� �ZdS )� Coordinatea A coordinate. @ivar angle: The value of the coordinate in decimal degrees, with the usual rules for sign (northern and eastern hemispheres are positive, southern and western hemispheres are negative). @type angle: C{float} Nc C s2 |t jt jdfvrtd�|���t�| ||� dS )aM Initializes a coordinate. @param angle: The angle of this coordinate in decimal degrees. The hemisphere is determined by the sign (north and east are positive). If this coordinate describes a latitude, this value must be within -90.0 and +90.0 (exclusive). If this value describes a longitude, this value must be within -180.0 and +180.0 (exclusive). @type angle: C{float} @param coordinateType: The coordinate type. One of L{Angles.LATITUDE}, L{Angles.LONGITUDE} or L{None} if unknown. NzQcoordinateType must be one of Angles.LATITUDE, Angles.LONGITUDE or None, was {!r})r r r rH rI r9 rN )r rK �coordinateTyper r r rN s �zCoordinate.__init__c C sL | j tju r| jdk rtjS tjS | j tju r"| jdk r tjS tj S t d��)z� Gets the hemisphere of this coordinate. @return: A symbolic constant representing a hemisphere (one of L{Angles}) r z.unknown coordinate type (cant find hemisphere)) rD r r rE r r r r r r rH rQ r r r � hemisphere� s zCoordinate.hemisphere�N)r r r r rN rs r r r r r r} u s r} c @ �J e Zd ZdZdZdd� Zedd� �Zedd� �Zd d � Z d e fd d �Z dS )�Altitudez� An altitude. @ivar inMeters: The altitude represented by this object, in meters. This attribute is read-only. @type inMeters: C{float} @ivar inFeet: As above, but expressed in feet. @type inFeet: C{float} )�inMetersc C � || _ dS )z} Initializes an altitude. @param altitude: The altitude in meters. @type altitude: C{float} N�� _altituder/ r r r rN � � zAltitude.__init__c C � | j t S )z� Gets the altitude this object represents, in feet. @return: The altitude, expressed in feet. @rtype: C{float} )r� �METERS_PER_FOOTrQ r r r �inFeet� s zAltitude.inFeetc C rO )z� Returns the altitude this object represents, in meters. @return: The altitude, expressed in feet. @rtype: C{float} r� rQ r r r r� � s zAltitude.inMetersc C rO )z� Returns the altitude represented by this object expressed in meters. @return: The altitude represented by this object, expressed in meters. @rtype: C{float} r� rQ r r r rb � rc zAltitude.__float__rd c C � d| j � d�S )z� Returns a string representation of this altitude. @return: The string representation. @rtype: C{str} z <Altitude (z m)>r� rQ r r r ri � � zAltitude.__repr__N) r r r r rF rN rs r� r� rb rq ri r r r r r� � s r� c @ r� )� _BaseSpeedz� An object representing the abstract concept of the speed (rate of movement) of a mobile object. This primarily has behavior for converting between units and comparison. )�inMetersPerSecondc C r� )a2 Initializes a speed. @param speed: The speed that this object represents, expressed in meters per second. @type speed: C{float} @raises ValueError: Raised if value was invalid for this particular kind of speed. Only happens in subclasses. N��_speedr$ r r r rN � s z_BaseSpeed.__init__c C rO )z� The speed that this object represents, expressed in meters per second. This attribute is immutable. @return: The speed this object represents, in meters per second. @rtype: C{float} r� rQ r r r r� rR z _BaseSpeed.inMetersPerSecondc C r� )z� Returns the speed represented by this object, expressed in knots. This attribute is immutable. @return: The speed this object represents, in knots. @rtype: C{float} )r� � MPS_PER_KNOTrQ r r r �inKnots s z_BaseSpeed.inKnotsc C rO )z� Returns the speed represented by this object expressed in meters per second. @return: The speed represented by this object, expressed in meters per second. @rtype: C{float} r� rQ r r r rb rR z_BaseSpeed.__float__rd c C s" t | jd�}d| jj� d|� d�S )z� Returns a string representation of this speed object. @return: The string representation. @rtype: C{str} rj �<z (z m/s)>)rk r� � __class__r )r � speedValuer r r ri ! s z_BaseSpeed.__repr__N) r r r r rF rN rs r� r� rb rq ri r r r r r� � s r� c @ � e Zd ZdZdd� ZdS )�Speedz: The speed (rate of movement) of a mobile object. c C s& |dk r t d|����t�| |� dS )z� Initializes a L{Speed} object. @param speed: The speed that this object represents, expressed in meters per second. @type speed: C{float} @raises ValueError: Raised if C{speed} is negative. r znegative speed: N)rH r� rN r$ r r r rN 1 s zSpeed.__init__N�r r r r rN r r r r r� , � r� c @ r� )�Climbz4 The climb ("vertical speed") of an object. c C s t �| |� dS )z� Initializes a L{Climb} object. @param climb: The climb that this object represents, expressed in meters per second. @type climb: C{float} N)r� rN r' r r r rN F s zClimb.__init__Nr� r r r r r� A r� r� c @ s� e Zd ZdZdZd"dd�ZdZdd � Zd d � d d � gd d � dd � gdd � dd � gd�Zdd� Z dd� Z e dd� �Z e j dd� �Z e dd� �Zej dd� �Ze dd � �Zej d d � �Zd Zd efd d!�ZdS )#� PositionErrora# Position error information. @cvar _ALLOWABLE_THRESHOLD: The maximum allowable difference between PDOP and the geometric mean of VDOP and HDOP. That difference is supposed to be zero, but can be non-zero because of rounding error and limited reporting precision. You should never have to change this value. @type _ALLOWABLE_THRESHOLD: C{float} @cvar _DOP_EXPRESSIONS: A mapping of DOP types (C[hvp]dop) to a list of callables that take self and return that DOP type, or raise C{TypeError}. This allows a DOP value to either be returned directly if it's know, or computed from other DOP types if it isn't. @type _DOP_EXPRESSIONS: C{dict} of C{str} to callables @ivar pdop: The position dilution of precision. L{None} if unknown. @type pdop: C{float} or L{None} @ivar hdop: The horizontal dilution of precision. L{None} if unknown. @type hdop: C{float} or L{None} @ivar vdop: The vertical dilution of precision. L{None} if unknown. @type vdop: C{float} or L{None} )�pdop�hdop�vdopNFc C s$ || _ || _|| _|| _| �� dS )a� Initializes a positioning error object. @param pdop: The position dilution of precision. L{None} if unknown. @type pdop: C{float} or L{None} @param hdop: The horizontal dilution of precision. L{None} if unknown. @type hdop: C{float} or L{None} @param vdop: The vertical dilution of precision. L{None} if unknown. @type vdop: C{float} or L{None} @param testInvariant: Flag to test if the DOP invariant is valid or not. If C{True}, the invariant (PDOP = (HDOP**2 + VDOP**2)*.5) is checked at every mutation. By default, this is false, because the vast majority of DOP-providing devices ignore this invariant. @type testInvariant: c{bool} N)�_pdop�_hdop�_vdop�_testInvariant� _testDilutionOfPositionInvariant)r r� r� r� � testInvariantr r r rN i s zPositionError.__init__g{�G�z�?c C sv | j sdS | j| j| jfD ] }|du r dS q t| j| jd | jd d �}|| jkr9td| j| j| jf ��dS )a� Tests if this positioning error object satisfies the dilution of position invariant (PDOP = (HDOP**2 + VDOP**2)*.5), unless the C{self._testInvariant} instance variable is C{False}. @return: L{None} if the invariant was not satisfied or not tested. @raises ValueError: Raised if the invariant was tested but not satisfied. Nrj � �?zYinvalid combination of dilutions of precision: position: %s, horizontal: %s, vertical: %s)r� r� r� r� rT �_ALLOWABLE_TRESHOLDrH )r �x�deltar r r r� � s �" ���z.PositionError._testDilutionOfPositionInvariantc C � t | j�S r� )�floatr� rQ r r r r; � � zPositionError.<lambda>c C s | j d | jd d S �Nrj r� )r� r� rQ r r r r; � r< c C r� r� )r� r� rQ r r r r; � r� c C � | j d | jd d S r� )r� r� rQ r r r r; � r< c C r� r� )r� r� rQ r r r r; � r� c C r� r� )r� r� rQ r r r r; � r< c C s4 | j | D ]}z|| �W S ty Y qw dS )a, Gets a particular dilution of position value. @param dopType: The type of dilution of position to get. One of ('pdop', 'hdop', 'vdop'). @type dopType: C{str} @return: The DOP if it is known, L{None} otherwise. @rtype: C{float} or L{None} N)�_DOP_EXPRESSIONS� TypeError)r �dopType� dopExpressionr r r �_getDOP� s ��zPositionError._getDOPc C sN d| }t | |�}t| |t|�� z| �� W dS ty& t| ||� � w )a� Sets a particular dilution of position value. @param dopType: The type of dilution of position to set. One of ('pdop', 'hdop', 'vdop'). @type dopType: C{str} @param value: The value to set the dilution of position type to. @type value: C{float} If this position error tests dilution of precision invariants, it will be checked. If the invariant is not satisfied, the assignment will be undone and C{ValueError} is raised. �_N)�getattr�setattrr� r� rH )r r� �value� attributeName�oldValuer r r �_setDOP� s �zPositionError._setDOPc C � | � d�S �Nr� �r� rQ r r r r� � � zPositionError.pdopc C � | � d|�S r� �r� �r r� r r r r� � � c C r� �Nr� r� rQ r r r r� � r� zPositionError.hdopc C r� r� r� r� r r r r� � r� c C r� �Nr� r� rQ r r r r� � r� zPositionError.vdopc C r� r� r� r� r r r r� � r� z.<PositionError (pdop: %s, hdop: %s, vdop: %s)>rd c C s | j | j| j| jf S )z� Returns a string representation of positioning information object. @return: The string representation. @rtype: C{str} )�_REPR_TEMPLATEr� r� r� rQ r r r ri � s zPositionError.__repr__)NNNF)r r r r rF rN r� r� r� r� r� rs r� �setterr� r� r� rq ri r r r r r� Q s@ ���� r� c @ s( e Zd ZdZd dd�Zdefdd�ZdS ) �BeaconInformationa� Information about positioning beacons (a generalized term for the reference objects that help you determine your position, such as satellites or cell towers). @ivar seenBeacons: A set of visible beacons. Note that visible beacons are not necessarily used in acquiring a positioning fix. @type seenBeacons: C{set} of L{IPositioningBeacon} @ivar usedBeacons: A set of the beacons that were used in obtaining a positioning fix. This only contains beacons that are actually used, not beacons for which it is unknown if they are used or not. @type usedBeacons: C{set} of L{IPositioningBeacon} r c C s t |�| _t � | _dS )z� Initializes a beacon information object. @param seenBeacons: A collection of beacons that are currently seen. @type seenBeacons: iterable of L{IPositioningBeacon}s N)�set� seenBeacons� usedBeacons)r r� r r r rN s zBeaconInformation.__init__rd c C sH t ttd�d�}|| j�}|| j| j �}d}|jt| j�||d�}|S )z� Returns a string representation of this beacon information object. The beacons are sorted by their identifier. @return: The string representation. @rtype: C{str} � identifier)�keyz^<BeaconInformation (used beacons ({numUsed}): {usedBeacons}, unused beacons: {unusedBeacons})>)�numUsedr� � unusedBeacons)r �sortedr r� r� rI �len)r � sortedBeaconsr� r� rM � formattedr r r ri s ��zBeaconInformation.__repr__N)r �r r r r rN rq ri r r r r r� � s r� c @ s. e Zd ZdZdd� Zdd� Zdefdd�Zd S ) �PositioningBeacona$ A positioning beacon. @ivar identifier: The unique identifier for this beacon. This is usually an integer. For GPS, this is also known as the PRN. @type identifier: Pretty much anything that can be used as a unique identifier. Depends on the implementation. c C r� )z� Initializes a positioning beacon. @param identifier: The identifier for this beacon. @type identifier: Can be pretty much anything (see ivar documentation). N�r� )r r� r r r rN 9 r� zPositioningBeacon.__init__c C r� )z� Returns the hash of the identifier for this beacon. @return: The hash of the identifier. (C{hash(self.identifier)}) @rtype: C{int} )�hashr� rQ r r r �__hash__B r� zPositioningBeacon.__hash__rd c C r� )z� Returns a string representation of this beacon. @return: The string representation. @rtype: C{str} z <Beacon (z)>r� rQ r r r ri K r� zPositioningBeacon.__repr__N)r r r r rN r� rq ri r r r r r� . s r� c @ s* e Zd ZdZ ddd�Zdefdd�ZdS ) � Satellitea� A satellite. @ivar azimuth: The azimuth of the satellite. This is the heading (positive angle relative to true north) where the satellite appears to be to the device. @ivar elevation: The (positive) angle above the horizon where this satellite appears to be to the device. @ivar signalToNoiseRatio: The signal to noise ratio of the signal coming from this satellite. Nc C s& t �| t|�� || _|| _|| _dS )ar Initializes a satellite object. @param identifier: The PRN (unique identifier) of this satellite. @type identifier: C{int} @param azimuth: The azimuth of the satellite (see instance variable documentation). @type azimuth: C{float} @param elevation: The elevation of the satellite (see instance variable documentation). @type elevation: C{float} @param signalToNoiseRatio: The signal to noise ratio of the connection to this satellite (see instance variable documentation). @type signalToNoiseRatio: C{float} N)r� rN rU �azimuth� elevation�signalToNoiseRatio)r r� r� r� r� r r r rN b s zSatellite.__init__rd c C s d}|j | d�S )z� Returns a string representation of this Satellite. @return: The string representation. @rtype: C{str} zi<Satellite ({s.identifier}), azimuth: {s.azimuth}, elevation: {s.elevation}, snr: {s.signalToNoiseRatio}>rf rh )r rM r r r ri z s � zSatellite.__repr__)NNNr� r r r r r� U s �r� )r� r9 r r r� r� r} r rC r8 r5 r� r� � MPS_PER_KPHr� r� r� r� N)(r � functoolsr �operatorr �typingr r �zope.interfacer � constantlyr r �twisted.positioningr �twisted.python.utilr r� r� r� r r �IPositioningReceiverr � Exceptionr5 r8 r9 rC r} r� r� r� r� r� r� �IPositioningBeaconr� r� �__all__r r r r �<module> s@ 5 Y6>C (6& 6PK Mb�Z���^� � : positioning/test/__pycache__/test_sentence.cpython-310.pycnu �[��� o �bZ � @ s� d Z ddlZddlmZ ddlmZ dZdZG dd� d�ZG d d � d ej �Z G d d � d ej �Z G d d� dej �Z G dd� d�ZG dd� dee�ZdS )z" Tests for positioning sentences. � N)� _sentence)�TestCase�someStringValue�someOtherStringValuec @ s e Zd ZdZedd� �ZdS )� DummyProtocolz" A simple, fake protocol. c C s dt tgS )N�type)�sentinelValueOne�sentinelValueTwo� r r �H/usr/lib/python3/dist-packages/twisted/positioning/test/test_sentence.py�getSentenceAttributes s z#DummyProtocol.getSentenceAttributesN)�__name__� __module__� __qualname__�__doc__� staticmethodr r r r r r s r c @ � e Zd ZdZe�� ZdS )� DummySentencez* A sentence for L{DummyProtocol}. N)r r r r r r �ALLOWED_ATTRIBUTESr r r r r � r c @ s e Zd ZdZdeedgiZdS )� MixinProtocolz� A simple, fake protocol that declaratively tells you the sentences it produces using L{base.PositioningSentenceProducerMixin}. N)r r r r r r �_SENTENCE_CONTENTSr r r r r # s ��r c @ r )� MixinSentencez* A sentence for L{MixinProtocol}. N)r r r r r r r r r r r r 2 r r c @ sJ e Zd ZdZdd� Zdd� Zdd� ZdZd Zdd d �Z dd� Z dd� Z dS )�SentenceTestsMixinzI Tests for positioning protocols and their respective sentences. c C s: t � }| �t|i�}| �t|t�|� | �t|t�� dS )z� A sentence attribute gets the correct value, and accessing an unset attribute (which is specified as being a valid sentence attribute) gets L{None}. N)�object� sentenceClassr � assertEqual�getattr� assertIsNoner )�self� thisSentinel�sentencer r r �test_attributeAccess? s z'SentenceTestsMixin.test_attributeAccessc C s | � i �}| �tt|d� dS )zM Accessing a nonexistent attribute raises C{AttributeError}. �BOGUSN�r � assertRaises�AttributeErrorr �r r! r r r �"test_raiseOnMissingAttributeAccessJ s z5SentenceTestsMixin.test_raiseOnMissingAttributeAccessc C s" | � ddi�}| �tt|d� dS )z� Accessing bogus attributes raises C{AttributeError}, *even* when that attribute actually is in the sentence data. r# Nr$ r' r r r � test_raiseOnBadAttributeAccessQ s z1SentenceTestsMixin.test_raiseOnBadAttributeAccess�tummiesz<%s (%s) {%s}>� unknown type� c C s | j j}| j|||f S )aQ Builds the expected repr for a sentence. @param sentenceType: The name of the sentence type (e.g "GPGGA"). @type sentenceType: C{str} @param dataRepr: The repr of the data in the sentence. @type dataRepr: C{str} @return: The expected repr of the sentence. @rtype: C{str} )r r � reprTemplate)r � sentenceType�dataRepr�clsNamer r r � _expectedRepr\ s z SentenceTestsMixin._expectedReprc C s& | � i �}| �� }| �t|�|� dS )zE Test the repr of an empty sentence of unknown type. N)r r1 r �repr�r r! � expectedReprr r r �test_unknownTypeReprj s z'SentenceTestsMixin.test_unknownTypeReprc C s0 | � d| ji�}| �| j�}| �t|�|� dS )zC Test the repr of an empty sentence of known type. r N)r r. r1 r r2 r3 r r r �test_knownTypeReprr s z%SentenceTestsMixin.test_knownTypeReprN)r+ r, ) r r r r r" r( r) r. r- r1 r5 r6 r r r r r : s r c @ s e Zd ZdZdd� Zdd� ZdS )� MixinTestszm Tests for protocols deriving from L{base.PositioningSentenceProducerMixin} and their sentences. c C s t � | _t| _d S )N)r �protocolr r )r r r r �setUp� s zMixinTests.setUpc C s< | j �� }| �d|� | j j}tj|�� � }| �d|� dS )a� L{None} does not appear in the sentence attributes of the protocol, even though it's in the specification. This is because L{None} is a placeholder for parts of the sentence you don't really need or want, but there are some bits later on in the sentence that you do want. The alternative would be to have to specify things like "_UNUSED0", "_UNUSED1"... which would end up cluttering the sentence data and eventually adapter state. N)r8 r � assertNotInr � itertools�chain�values�assertIn)r �sentenceAttributes�sentenceContents�sentenceSpecAttributesr r r � test_noNoneInSentenceAttributes� s z*MixinTests.test_noNoneInSentenceAttributesN)r r r r r9 rB r r r r r7 { s r7 )r r; �twisted.positioningr �twisted.trial.unittestr r r r � _BaseSentencer �!_PositioningSentenceProducerMixinr r r r7 r r r r �<module> s APK Mb�Z�Y$�� � 5 positioning/test/__pycache__/__init__.cpython-310.pycnu �[��� o �b} � @ s d Z dS )z. Tests for the Twisted positioning framework. N)�__doc__� r r �C/usr/lib/python3/dist-packages/twisted/positioning/test/__init__.py�<module> s PK Mb�Z�U5{ 6 positioning/test/__pycache__/test_base.cpython-310.pycnu �[��� o �b�p � @ s� d Z ddlmZ ddlmZ ddlmZmZ ddlm Z ddl m Z G dd� de �Z G d d � d e �Z G d d � d e �Zd d� Zdd� ZG dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG dd � d e �ZG d d � d e �Zd S ) z( Test cases for positioning primitives. � )�verify)�base)�Angles� Directions)�IPositioningBeacon)�TestCasec @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � AngleTestsz@ Tests for the L{twisted.positioning.base.Angle} class. c C s t �� }| �dt|�� dS )zd The repr of an empty angle says that is of unknown type and unknown value. z'<Angle of unknown type (unknown value)>N�r �Angle� assertEqual�repr��self�a� r �D/usr/lib/python3/dist-packages/twisted/positioning/test/test_base.py� test_empty s zAngleTests.test_emptyc C s" t jtjd�}| �dt|�� dS )zf The repr of an empty variation says that it is a variation of unknown value. �� angleTypez<Variation (unknown value)>N)r r r � VARIATIONr r r r r r �test_variation s zAngleTests.test_variationc C s t �d�}| �dt|�� dS )zz The repr of an angle of unknown type but a given value displays that type and value in its repr. � �?z%<Angle of unknown type (1.0 degrees)>Nr r r r r �test_unknownType# s zAngleTests.test_unknownTypec C s | j ttjdd� dS )zS Trying to create an angle with a bogus type raises C{ValueError}. �BOGUSr N)� assertRaises� ValueErrorr r �r r r r �test_bogusType+ � zAngleTests.test_bogusTypeN)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.S )/� HeadingTestszB Tests for the L{twisted.positioning.base.Heading} class. c C sD t �d�}| �|jd� | �t|�d� | �|j� | �|j� dS )z� Tests that a simple heading has a value in decimal degrees, which is also its value when converted to a float. Its variation, and by consequence its corrected heading, is L{None}. r N)r �Headingr �inDecimalDegrees�float� assertIsNone� variation�correctedHeading�r �hr r r � test_simple7 s zHeadingTests.test_simplec C s" t �d�}d}| �t|�|� dS )zt A repr of a heading with no variation reports its value and that the variation is unknown. r z*<Heading (1.0 degrees, unknown variation)>N)r r% r r )r �heading� expectedReprr r r � test_headingWithoutVariationReprC s z-HeadingTests.test_headingWithoutVariationReprc C s8 d\}}t jj||d�}d}| �t|�|�||�� dS )zu A repr of a heading with known variation reports its value and the value of that variation. )r � $���variationValuez2<Heading ({0} degrees, <Variation ({1} degrees)>)>N)r r% � fromFloatsr r �format)r �angler) r. � reprTemplater r r � test_headingWithVariationReprL s z*HeadingTests.test_headingWithVariationReprc C s | � t�d�t�d�� dS )z> Headings with the same values compare equal. r N)r r r% r r r r �test_valueEqualityV � z HeadingTests.test_valueEqualityc C s | � t�d�t�d�� dS )zA Headings with different values compare unequal. r � @N)�assertNotEqualr r% r r r r �test_valueInequality\ r: z!HeadingTests.test_valueInequalityc C s t �d� dS )zR Headings can be instantiated with a value of 0 and no variation. r N�r r% r r r r �test_zeroHeadingEdgeCaseb � z%HeadingTests.test_zeroHeadingEdgeCasec C s t �dd� dS )zh Headings can be instantiated with a value of 0 and a variation of 180 degrees. r � Nr> r r r r �*test_zeroHeading180DegreeVariationEdgeCaseh s z7HeadingTests.test_zeroHeading180DegreeVariationEdgeCasec K s | j ttjjfi |�� dS )z� Helper function for verifying that bad values raise C{ValueError}. @param kw: The keyword arguments passed to L{base.Heading.fromFloats}. N)r r r r% r4 )r �kwr r r � _badValueTesto s zHeadingTests._badValueTestc C � | j dd� dS )zO Headings can not be instantiated with a value of 360 degrees. g �v@�� angleValueN�rD r r r r �test_badAngleValueEdgeCasew � z'HeadingTests.test_badAngleValueEdgeCasec C rE )zT Headings can not be instantiated with a variation of -180 degrees. � �f�r2 NrH r r r r �test_badVariationEdgeCase} rJ z&HeadingTests.test_badVariationEdgeCasec C rE )z> Negative heading values raise C{ValueError}. r1 rF NrH r r r r �test_negativeHeading� rJ z!HeadingTests.test_negativeHeadingc C rE )zK Heading values greater than C{360.0} raise C{ValueError}. g w@rF NrH r r r r �test_headingTooLarge� rJ z!HeadingTests.test_headingTooLargec C rE )zK Variation values less than C{-180.0} raise C{ValueError}. g �g�r2 NrH r r r r �test_variationTooNegative� rJ z&HeadingTests.test_variationTooNegativec C rE )zM Variation values greater than C{180.0} raise C{ValueError}. g �g@r2 NrH r r r r �test_variationTooPositive� rJ z&HeadingTests.test_variationTooPositivec C �, t jjddd�}| �|jt �dtj�� dS )zQ A heading with a value and a variation has a corrected heading. r r1 r2 g &@N�r r% r4 r r* r r �HEADINGr+ r r r �test_correctedHeading� s z"HeadingTests.test_correctedHeadingc C rQ )z� A heading with a value and a variation has the appropriate corrected heading value, even when the variation puts it across the 360 degree boundary. � pv@g �r2 r NrR r+ r r r � test_correctedHeadingOverflow� � z*HeadingTests.test_correctedHeadingOverflowc C rQ )z� A heading with a value and a variation has the appropriate corrected heading value, even when the variation puts it exactly at the 360 degree boundary. rU � �r2 � NrR r+ r r r �%test_correctedHeadingOverflowEdgeCase� rW z2HeadingTests.test_correctedHeadingOverflowEdgeCasec C rQ )z� A heading with a value and a variation has the appropriate corrected heading value, even when the variation puts it under the 0 degree boundary. r r; r2 rU NrR r+ r r r � test_correctedHeadingUnderflow� rW z+HeadingTests.test_correctedHeadingUnderflowc C s, t jjddd�}| �|jt �dtj�� dS )z� A heading with a value and a variation has the appropriate corrected heading value, even when the variation puts it exactly at the 0 degree boundary. r r2 rY NrR r+ r r r �&test_correctedHeadingUnderflowEdgeCase� rW z3HeadingTests.test_correctedHeadingUnderflowEdgeCasec C sH t jjddd�}|�d� | �|jjd� |�d� | �|jjd� dS )zK Setting the sign of a heading changes the variation sign. r r2 � ���rX N)r r% r4 �setSignr r) r& r+ r r r �test_setVariationSign� s z"HeadingTests.test_setVariationSignc C st t jjddd�}| �t|jd� | �|jjd� | �t|jd� | �|jjd� | �t|jd� | �|jjd� dS )z� Setting the sign of a heading to values that aren't C{-1} or C{1} raises C{ValueError} and does not affect the heading. r r2 ����r �2 N) r r% r4 r r r_ r r) r& r+ r r r �test_setBadVariationSign� s z%HeadingTests.test_setBadVariationSignc C s. t j�d�}| �|jj� | �t|jd� dS )zd Setting the sign on a heading with unknown variation raises C{ValueError}. r r] N) r r% r4 r( r) r& r r r_ r+ r r r � test_setUnknownVariationSign� s z)HeadingTests.test_setUnknownVariationSignN)r r! r" r# r- r0 r8 r9 r= r? rB rD rI rL rM rN rO rP rT rV rZ r[ r\ r` rc rd r r r r r$ 2 s0 r$ c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1S )2�CoordinateTestsc C s t �d�}| �t|�d� dS )z9 Coordinates can be converted to floats. � $@N)r � Coordinater r' �r � coordinater r r � test_float� � zCoordinateTests.test_floatc C s* t �d�}dd� d�}| �t|�|� dS )zn Coordinates that aren't explicitly latitudes or longitudes have an appropriate repr. rf z<Angle of unknown type (� degrees)>N)r rg r r �r ri r/ r r r � test_repr� s zCoordinateTests.test_reprc C �. t �dtj�}dd� d�}| �t|�|� dS )zU Positive latitudes have a repr that specifies their type and value. rf � <Latitude (rl N�r rg r �LATITUDEr r rm r r r �test_positiveLatitude� � z%CoordinateTests.test_positiveLatitudec C ro )zU Negative latitudes have a repr that specifies their type and value. � I�rp rl Nrq rm r r r �test_negativeLatitude rt z%CoordinateTests.test_negativeLatitudec C ro )zV Positive longitudes have a repr that specifies their type and value. � I@� <Longitude (rl N�r rg r � LONGITUDEr r �r � longituder/ r r r �test_positiveLongitude rt z&CoordinateTests.test_positiveLongitudec C ro )zV Negative longitudes have a repr that specifies their type and value. ru rx rl Nry r{ r r r �test_negativeLongitude rt z&CoordinateTests.test_negativeLongitudec C s | � ttjdd� dS )zM Creating coordinates with bogus types rasies C{ValueError}. � �b@r N)r r r rg r r r r �test_bogusCoordinateType r z(CoordinateTests.test_bogusCoordinateTypec C s | � ttjdtj� dS )zm Creating coordinates with angle types that aren't coordinates raises C{ValueError}. r N)r r r rg r rS r r r r �test_angleTypeNotCoordinate s z+CoordinateTests.test_angleTypeNotCoordinatec C s dd� }| � |� |� � dS )zE Coordinates with the same value and type are equal. c S s t �dtj�S )Nr �r rg r rz r r r r �makeCoordinate, s z5CoordinateTests.test_equality.<locals>.makeCoordinateN)r )r r� r r r � test_equality' s z CoordinateTests.test_equalityc C �$ t �d�}t �d�}| �||� dS )zA Coordinates with different values aren't equal. r rX N)r rg r< �r �c1�c2r r r � test_differentAnglesInequality1 � z.CoordinateTests.test_differentAnglesInequalityc C s, t �dtj�}t �dtj�}| �||� dS )zT Coordinates with the same values but different types aren't equal. r N)r rg r rr rz r< r� r r r � test_differentTypesInequality9 s z-CoordinateTests.test_differentTypesInequalityc C sB t �dtj�}|�d� | �|jd� |�d� | �|jd� dS )zh Setting the sign on a coordinate sets the sign of the value of the coordinate. rw r] r^ ru N)r rg r rr r_ r r& �r �cr r r � test_signA s zCoordinateTests.test_signc C sp d}t �|tj�}| �t|jd� | �|jd� | �t|jd� | �|jd� | �t|jd� | �|jd� dS )z� Setting a bogus sign value (not -1 or 1) on a coordinate raises C{ValueError} and doesn't affect the coordinate. rw ra r rb N) r rg r rr r r r_ r r& )r �valuer� r r r �test_badVariationSignL s z%CoordinateTests.test_badVariationSignc C �" t �dtj�}| �|jtj� dS )zD Positive latitudes are in the northern hemisphere. r N)r rg r rr r � hemispherer �NORTHrh r r r �test_northernHemisphere] � z'CoordinateTests.test_northernHemispherec C r� )zD Positive longitudes are in the eastern hemisphere. r N)r rg r rz r r� r �EASTrh r r r �test_easternHemisphered r� z&CoordinateTests.test_easternHemispherec C r� )zD Negative latitudes are in the southern hemisphere. rX N)r rg r rr r r� r �SOUTHrh r r r �test_southernHemispherek r� z'CoordinateTests.test_southernHemispherec C r� )zD Negative longitudes are in the western hemisphere. rX N)r rg r rz r r� r �WESTrh r r r �test_westernHemispherer r� z&CoordinateTests.test_westernHemispherec s$ t �dd�� | �t� fdd�� dS )zo Accessing the hemisphere for a coordinate that can't compute it raises C{ValueError}. r Nc s � j S )N)r� r �ri r r �<lambda> s z4CoordinateTests.test_badHemisphere.<locals>.<lambda>)r rg r r r r r� r �test_badHemispherey s z"CoordinateTests.test_badHemispherec C � | � ttd� | � ttd� dS )zt Creating a latitude with a value greater than or equal to 90 degrees raises C{ValueError}. r g �V@N�r r � _makeLatituder r r r �test_latitudeTooLarge� � z%CoordinateTests.test_latitudeTooLargec C r� )zr Creating a latitude with a value less than or equal to -90 degrees raises C{ValueError}. g �b�g �V�Nr� r r r r �test_latitudeTooSmall� r� z%CoordinateTests.test_latitudeTooSmallc C r� )zv Creating a longitude with a value greater than or equal to 180 degrees raises C{ValueError}. g @o@g �f@N�r r �_makeLongituder r r r �test_longitudeTooLarge� r� z&CoordinateTests.test_longitudeTooLargec C r� )zt Creating a longitude with a value less than or equal to -180 degrees raises C{ValueError}. g @o�rK Nr� r r r r �test_longitudeTooSmall� r� z&CoordinateTests.test_longitudeTooSmallc C s< t �dtj�}| �|jd� t �dtj�}| �|jd� dS )zQ Coordinate values can be accessed in degrees, minutes, seconds. g @I@)rb � r g%��CI@)rb � �. N)r rg r rr r �inDegreesMinutesSecondsr� r r r � test_inDegreesMinutesSeconds� s z,CoordinateTests.test_inDegreesMinutesSecondsc C s t �dd�}| �|j� dS )zz If the vaue of a coordinate is L{None}, its values in degrees, minutes, seconds is also L{None}. N)r rg r( r� r� r r r �(test_unknownAngleInDegreesMinutesSeconds� s z8CoordinateTests.test_unknownAngleInDegreesMinutesSecondsN)r r! r" rj rn rs rv r} r~ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r re � s2 re c C � t �| tj�S )z7 Builds and returns a latitude of given value. )r rg r rr �r� r r r r� � r@ r� c C r� )z8 Builds and returns a longitude of given value. r� r� r r r r� � r@ r� c @ r ) � AltitudeTestszC Tests for the L{twisted.positioning.base.Altitude} class. c C s@ t �d�}| �t|�d� | �|jd� | �|jdt j � dS )z� Altitudes can be instantiated and reports the correct value in meters and feet, as well as when converted to float. r N)r �Altituder r' �inMeters�inFeet�METERS_PER_FOOT�r �altituder r r � test_value� s zAltitudeTests.test_valuec C � t �d�}| �t|�d� dS )zF Altitudes report their type and value in their repr. r z<Altitude (1.0 m)>N)r r� r r r� r r r rn � rk zAltitudeTests.test_reprc C s$ t �d�}t �d�}| �||� dS )z< Altitudes with equal values compare equal. r N)r r� r �r � firstAltitude�secondAltituder r r r� � r� zAltitudeTests.test_equalityc C r� )zF Altitudes with different values don't compare equal. r rX N)r r� r< r� r r r �test_inequality� r� z AltitudeTests.test_inequalityN)r r! r" r# r� rn r� r� r r r r r� � s r� c @ �8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � SpeedTestsz@ Tests for the L{twisted.positioning.base.Speed} class. c C �, t �d�}| �|jd� | �t|�d� dS )�� Speeds can be instantiated, and report their value in meters per second, and can be converted to floats. rw N)r �Speedr �inMetersPerSecondr' �r �speedr r r r� � � zSpeedTests.test_valuec C r� )zC Speeds report their type and value in their repr. rw z<Speed (50.0 m/s)>N)r r� r r r� r r r rn � rk zSpeedTests.test_reprc C s | � ttjd� dS )zA Creating a negative speed raises C{ValueError}. rX N)r r r r� r r r r �test_negativeSpeeds� s z SpeedTests.test_negativeSpeedsc C �" t �d�}| �dt j |j� dS )zC A speed can be converted into its value in knots. r r] N)r r� r � MPS_PER_KNOT�inKnotsr� r r r � test_inKnots � zSpeedTests.test_inKnotsc C � | � dtt�d��� dS )z; A speed can be converted into a C{float}. r N)r r' r r� r r r r � test_asFloat � zSpeedTests.test_asFloatN) r r! r" r# r� rn r� r� r� r r r r r� � s r� c @ r� ) � ClimbTestsz6 Tests for L{twisted.positioning.base.Climb}. c C r� )r� � E@N�r �Climbr r� r' �r �climbr r r r- r� zClimbTests.test_simplec C r� )zC Climbs report their type and value in their repr. r� z<Climb (42.0 m/s)>N)r r� r r r� r r r rn rk zClimbTests.test_reprc C r� )z� Climbs can have negative values, and still report that value in meters per second and when converted to floats. g E�Nr� r� r r r �test_negativeClimbs' r� z ClimbTests.test_negativeClimbsc C r� )zC A climb can be converted into its value in knots. r r] N)r r� r r� r� r� r r r �test_speedInKnots0 r� z ClimbTests.test_speedInKnotsc C r� )z; A climb can be converted into a C{float}. r N)r r' r r� r r r r r� 7 r� zClimbTests.test_asFloatN) r r! r" r# r- rn r� r� r� r r r r r� s r� c @ st e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dZ dd� Z dd� Zdd� Zdd� ZdS ) �PositionErrorTestsz> Tests for L{twisted.positioning.base.PositionError}. c C s0 t �� }| �|j� | �|j� | �|j� dS )z~ In an empty L{base.PositionError} with no invariant testing, all dilutions of positions are L{None}. N�r � PositionErrorr( �pdop�hdop�vdop�r � positionErrorr r r � test_allUnsetC s z PositionErrorTests.test_allUnsetc C s4 t jdd�}| �|j� | �|j� | �|j� dS )z{ In an empty L{base.PositionError} with invariant testing, all dilutions of positions are L{None}. T)� testInvariantNr� r� r r r �test_allUnsetWithInvariantM s z-PositionErrorTests.test_allUnsetWithInvariantc C s t jdd�}| �|jd� dS )zN L{base.PositionError}s can be instantiated with just a HDOP. r )r� N�r r� r r� r� r r r �test_withoutInvariantW s z(PositionErrorTests.test_withoutInvariantc C s t jddd�}| �|jd� dS )zv Creating a simple L{base.PositionError} with just a HDOP while checking the invariant works. r T)r� r� Nr� r� r r r �test_withInvariant^ r� z%PositionErrorTests.test_withInvariantc C s> t jdddd�}| �|jd� | �|jd� | �|jd� dS )z� Creating a L{base.PositionError} with values set to an impossible combination works if the invariant is not checked. r )r� r� r� N)r r� r r� r� r� )r �errorr r r � test_invalidWithoutInvariantf s z/PositionErrorTests.test_invalidWithoutInvariantc C s | j ttjddddd� dS )z� Creating a L{base.PositionError} with values set to an impossible combination raises C{ValueError} if the invariant is being tested. r T)r� r� r� r� N)r r r r� r r r r �test_invalidWithInvariantp s �z,PositionErrorTests.test_invalidWithInvariantc C s& t jddd�}d|_| �|jd� dS )z} You can set the PDOP value to value inconsisted with HDOP and VDOP when not checking the invariant. r �r� r� � Y@N)r r� r� r )r �per r r �test_setDOPWithoutInvariant~ s z.PositionErrorTests.test_setDOPWithoutInvariantc C s> t jdddd�}|j}dd� }| �t||� | �|j|� dS )z� Attempting to set the PDOP value to value inconsisted with HDOP and VDOP when checking the invariant raises C{ValueError}. r T)r� r� r� c S s d| _ d S )Nr� )r� )r� r r r �setPDOP� s z<PositionErrorTests.test_setDOPWithInvariant.<locals>.setPDOPN)r r� r� r r r )r r� r� r� r r r �test_setDOPWithInvariant� s z+PositionErrorTests.test_setDOPWithInvariantz.<PositionError (pdop: %s, hdop: %s, vdop: %s)>c C sJ | � |j|� | � |j|� | � |j|� | � t|�| j|||f � dS )a� Tests the DOP values in a position error, and the repr of that position error. @param pe: The position error under test. @type pe: C{PositionError} @param pdop: The expected position dilution of precision. @type pdop: C{float} or L{None} @param hdop: The expected horizontal dilution of precision. @type hdop: C{float} or L{None} @param vdop: The expected vertical dilution of precision. @type vdop: C{float} or L{None} N)r r� r� r� r � REPR_TEMPLATE)r r� r� r� r� r r r �_testDOP� s zPositionErrorTests._testDOPc C s> d\}}|d |d d }t j||d�}| �||||� dS )zF The VDOP is correctly determined from PDOP and HDOP. �r; r � � �?)r� r� N�r r� r� )r r� r� r� r� r r r � test_positionAndHorizontalSet� � z0PositionErrorTests.test_positionAndHorizontalSetc C s> d\}}|d |d d }t j||d�}| �||||� dS )zF The HDOP is correctly determined from PDOP and VDOP. r� r� r� )r� r� Nr� )r r� r� r� r� r r r �test_positionAndVerticalSet� r� z.PositionErrorTests.test_positionAndVerticalSetc C s> d\}}|d |d d }t j||d�}| �||||� dS )zF The PDOP is correctly determined from HDOP and VDOP. )r r r� r� r� Nr� )r r� r� r� r� r r r � test_horizontalAndVerticalSet� r� z0PositionErrorTests.test_horizontalAndVerticalSetN)r r! r" r# r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� > s r� c @ s4 e Zd ZdZdd� Zdddd�Zdd� Zd d � Zd S ) �BeaconInformationTestszB Tests for L{twisted.positioning.base.BeaconInformation}. c C s2 t �� }| �t|j�d� d}| �t|�|� dS )z� For an empty beacon information object, the number of used beacons is zero, the number of seen beacons is zero, and the repr of the object reflects that. r z><BeaconInformation (used beacons (0): [], unused beacons: [])>N)r �BeaconInformationr �len� usedBeaconsr )r �bir/ r r r � test_minimal� s �z#BeaconInformationTests.test_minimalr] r )�azimuth� elevation�signalToNoiseRatioc st � fdd�}t � }tdd�D ] }|�||d�� qt�|�}� �t|j�d� � �t|j�d� � �t |�d� d S ) zw Tests a beacon information with a bunch of satellites, none of which used in computing a fix. c s$ t � j�}|�| � tjdi |��S )Nr )�dict�satelliteKwargs�updater � Satellite)rC �kwargsr r r �_buildSatellite� s z;BeaconInformationTests.test_simple.<locals>._buildSatelliter] � )� identifier� r a <BeaconInformation (used beacons (0): [], unused beacons: [<Satellite (1), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (2), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (3), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (4), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (5), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (6), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (7), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (8), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (9), azimuth: 1, elevation: 1, snr: 1.0>])>N) �set�range�addr r� r r� � seenBeaconsr� r )r r �beacons�prnr� r r r r- � s �z"BeaconInformationTests.test_simplec C s� t �� }tdd�D ] }t jd d|i| j��}|j�|� |d r&|j�|� q | �t |j�d� | �t |j�d� | �t |�d� dS ) zv Tests a beacon information with a bunch of satellites, some of them used in computing a fix. r] r r r� r � a <BeaconInformation (used beacons (5): [<Satellite (1), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (3), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (5), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (7), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (9), azimuth: 1, elevation: 1, snr: 1.0>], unused beacons: [<Satellite (2), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (4), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (6), azimuth: 1, elevation: 1, snr: 1.0>, <Satellite (8), azimuth: 1, elevation: 1, snr: 1.0>])>Nr ) r r� r r r r r r� r r� r )r r� r � satelliter r r �test_someSatellitesUsed� s ��z.BeaconInformationTests.test_someSatellitesUsedN)r r! r" r# r� r r- r r r r r r� � s #r� c @ � e Zd ZdZdd� Zdd� ZdS )�PositioningBeaconTestsz. Tests for L{base.PositioningBeacon}. c C s, t �tj�}| �|� t�t t�d�� dS )zX Tests that L{base.PositioningBeacon} implements L{IPositioningBeacon}. r] N)r � implementedByr �PositioningBeacon� assertTruer � verifyObject)r � implementsr r r �test_interface" s z%PositioningBeaconTests.test_interfacec C s | � tt�d��d� dS )z9 Tests the repr of a positioning beacon. �Az <Beacon (A)>N)r r r r r r r r rn * r� z PositioningBeaconTests.test_reprN)r r! r" r# r rn r r r r r s r c @ r )�SatelliteTestsz: Tests for L{twisted.positioning.base.Satellite}. c C sP t �d�}| �|jd� | �|j� | �|j� | �|j� | �t|�d� dS )z� Tests a minimal satellite that only has a known PRN. Tests that the azimuth, elevation and signal to noise ratios are L{None} and verifies the repr. r] z:<Satellite (1), azimuth: None, elevation: None, snr: None>N) r r r r r( r� r r r �r �sr r r r� 6 s �zSatelliteTests.test_minimalc C s^ t jddddd�}| �|jd� | �|jd� | �|jd� | �|jd� | �t|�d� dS )z� Tests a minimal satellite that only has a known PRN. Tests that the azimuth, elevation and signal to noise ratios are correct and verifies the repr. r] g �p@g >@g 9@)r r� r r z;<Satellite (1), azimuth: 270.0, elevation: 30.0, snr: 25.0>N)r r r r r� r r r r r r r r- F s ��zSatelliteTests.test_simpleN)r r! r" r# r� r- r r r r r 1 s r N)r# �zope.interfacer �twisted.positioningr �twisted.positioning.baser r � twisted.positioning.ipositioningr �twisted.trial.unittestr r r$ re r� r� r� r� r� r� r� r r r r r r �<module> s* $ 8 L'), WPK Mb�Z�"b}� � 5 positioning/test/__pycache__/receiver.cpython-310.pycnu �[��� o �b] � @ s* d Z ddlmZmZ G dd� dej�ZdS )z Receivers for use in tests. � )�base� ipositioningc @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �MockPositioningReceivera A mock positioning receiver. Mocks all the L{IPositioningReceiver} methods with stubs that don't do anything but register that they were called. @ivar called: A mapping of names of callbacks that have been called to C{True}. @type called: C{dict} c C s" | � � tjD ]}| �|� qd S )N)�clearr �IPositioningReceiver� _addCallback)�self� methodName� r �C/usr/lib/python3/dist-packages/twisted/positioning/test/receiver.py�__init__ s �z MockPositioningReceiver.__init__c C s i | _ dS )zt Forget all the methods that have been called on this receiver, by emptying C{self.called}. N��called)r r r r r s z MockPositioningReceiver.clearc s � �fdd�}t �� |� dS )zq Adds a callback of the given name, setting C{self.called[name]} to C{True} when called. c s d�j � < d S )NTr )�a�kw��namer r r �callback* s z6MockPositioningReceiver._addCallback.<locals>.callbackN)�setattr)r r r r r r r $ s z$MockPositioningReceiver._addCallbackN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r N)r �twisted.positioningr r �BasePositioningReceiverr r r r r �<module> s PK Mb�Z��t� � 6 positioning/test/__pycache__/test_nmea.cpython-310.pycnu �[��� o �b`� � @ s( d Z ddlZddlmZ ddlmZ ddlmZmZm Z ddl m Z ddl m Z ddlmZ d Zd Zd Zd Zd ZdZdZdZd�� Z\ZZZ eej �G dd� d��Z G dd� de�Z G dd� de�Z G dd� de�Z!G dd� de�Z"G d d � d �Z#G d d � d e#e�Z$G d d!� d!e#e�Z%G d"d#� d#e#e�Z&G d$d%� d%e#e�Z'G d&d'� d'e�Z(G d(d)� d)�Z)G d*d+� d+e)e�Z*G d,d-� d-e)e�Z+d.d/� Z,d0d1� Z-d2d3� Z.G d4d5� d5e)e�Z/G d6d7� d7e)e�Z0G d8d9� d9e)e�Z1G d:d;� d;e)e�Z2G d<d=� d=e)e�Z3G d>d?� d?e)e�Z4G d@dA� dAe)e�Z5G dBdC� dCe�Z6dS )Dz& Test cases for using NMEA sentences. � N)� attrgetter)� implementer)�base� ipositioning�nmea)�Angles)�MockPositioningReceiver)�TestCasesA $GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47sD $GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6As5 $GPGSA,A,3,19,28,14,18,27,22,31,39,,,,,1.7,1.0,1.3*34s $GPHDT,038.005,T*3Bs' $GPGLL,4916.45,N,12311.12,W,225444,A*31s $GPGLL,3751.65,S,14507.36,E*77s; $GPGSV,1,1,11,03,03,111,00,04,15,270,00,06,01,010,00,,,,*4bs2 $GPGSV,1,1,11,03,03,111,00,,,,,,,,,13,06,292,00*75s� $GPGSV,3,1,11,03,03,111,00,04,15,270,00,06,01,010,00,13,06,292,00*74 $GPGSV,3,2,11,14,25,170,00,16,57,208,39,18,67,296,40,19,40,246,00*74 $GPGSV,3,3,11,22,42,067,42,24,14,311,43,27,05,244,00,,,,*4D c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �NMEATestReceiverzY An NMEA receiver for testing. Remembers the last sentence it has received. c C s | � � d S �N)�clear��self� r �D/usr/lib/python3/dist-packages/twisted/positioning/test/test_nmea.py�__init__/ s zNMEATestReceiver.__init__c C s d| _ dS )zq Forgets the received sentence (if any), by setting C{self.receivedSentence} to L{None}. N��receivedSentencer r r r r 2 s zNMEATestReceiver.clearc C s || _ d S r r �r �sentencer r r �sentenceReceived9 � z!NMEATestReceiver.sentenceReceivedN)�__name__� __module__� __qualname__�__doc__r r r r r r r r ' s r c @ r ) � CallbackTestsaO Tests if the NMEA protocol correctly calls its sentence callback. @ivar protocol: The NMEA protocol under test. @type protocol: L{nmea.NMEAProtocol} @ivar sentenceTypes: The set of sentence types of all sentences the test's sentence callback function has been called with. @type sentenceTypes: C{set} c C s" t � }t�|| j�| _t� | _d S r )r r � NMEAProtocol�_sentenceCallback�protocol�set� sentenceTypes�r �receiverr r r �setUpH s zCallbackTests.setUpc C s | j �|j� dS )zC Remembers that a sentence of this type was fired. N)r" �add�typer r r r r M � z CallbackTests._sentenceCallbackc C sd dgdgdgdgdgdgd�}|� � D ] \}}|D ]}| j�|� | �| j|h� | j�� qqdS ) zI The correct callbacks fire, and that *only* those fire. � $GPGGA*56s $GPGLL*50s $GPGSA*42s $GPGSV*55s $GPHDT*4fs $GPRMC*4b)�GPGGA�GPGLL�GPGSA�GPGSV�GPHDT�GPRMCN)�itemsr � lineReceived� assertEqualr" r )r �sentencesByType� sentenceType� sentencesr r r r �test_callbacksCalledS s � ��z"CallbackTests.test_callbacksCalledN)r r r r r% r r6 r r r r r = s r c @ r ) �BrokenSentenceCallbackTestsz3 Tests for broken NMEA sentence callbacks. c C s t � }t�|| j�| _d S r )r r r r r r# r r r r% l s z!BrokenSentenceCallbackTests.setUpc C s t d��)z+ Raises C{AttributeError}. zERROR!!!)�AttributeErrorr r r r r p s z-BrokenSentenceCallbackTests._sentenceCallbackc C s | j j}| �t|d� dS )zt An C{AttributeError} in the sentence callback of an C{NMEAProtocol} doesn't get swallowed. r) N)r r1 � assertRaisesr8 )r r1 r r r �"test_dontSwallowCallbackExceptionsv � z>BrokenSentenceCallbackTests.test_dontSwallowCallbackExceptionsN)r r r r r% r r: r r r r r7 g s r7 c @ � e Zd ZdZdd� Zdd� ZdS )� SplitTestsz- Checks splitting of NMEA sentences. c C � t �d�}| �|g d�� dS )zH An NMEA sentence with a checksum gets split correctly. s $GPGGA,spam,eggs*00�s GPGGAs spams eggsN�r �_splitr2 �r � splitSentencer r r �test_withChecksum� � z SplitTests.test_withChecksumc C r> )zK An NMEA sentence without a checksum gets split correctly. s $GPGGA,spam,eggs*r? Nr@ rB r r r �test_noCheckum� rE zSplitTests.test_noCheckumN)r r r r rD rF r r r r r= s r= c @ r ) � ChecksumTestsz4 NMEA sentence checksum verification tests. c C s t �t� dS )z? Sentences with valid checksums get validated. N�r �_validateChecksumr* r r r r � test_valid� s zChecksumTests.test_validc C s t �tdd� � dS )zA Sentences with missing checksums get validated. N���rH r r r r � test_missing� � zChecksumTests.test_missingc C sT t j}t�d�\}}dt|d�d f }|d | g}|D ] }| �tj||� q dS )zw Sentences with a bad checksum raise L{base.InvalidChecksum} when attempting to validate them. � *s %d� � N)r rI r* �split�intr9 r �InvalidChecksum)r �validate� bareSentence�checksum� badChecksumr5 �sr r r � test_invalid� s �zChecksumTests.test_invalidN)r r r r rJ rL rY r r r r rG � s rG c @ � e Zd ZdZdd� ZdS )�NMEAReceiverSetupaG A mixin for tests that need an NMEA receiver (and a protocol attached to it). @ivar receiver: An NMEA receiver that remembers the last sentence. @type receiver: L{NMEATestReceiver} @ivar protocol: An NMEA protocol attached to the receiver. @type protocol: L{twisted.positioning.nmea.NMEAProtocol} c C s t � | _t�| j�| _dS )z+ Sets up an NMEA receiver. N)r r$ r r r r r r r r% � � zNMEAReceiverSetup.setUpN)r r r r r% r r r r r[ � s r[ c @ r ) �GSVSequenceTestsz8 Tests for the interpretation of GSV sequences. c C �4 | j �t� | jj}| �|�� � | �|�� � dS )zO The first sentence in a GSV sequence is correctly identified. N) r r1 � GPGSV_FIRSTr$ r � assertTrue�_isFirstGSVSentence� assertFalse�_isLastGSVSentencer r r r �test_firstSentence� � z#GSVSequenceTests.test_firstSentencec C s4 | j �t� | jj}| �|�� � | �|�� � dS )z� A sentence in the middle of a GSV sequence is correctly identified (as being neither the last nor the first). N)r r1 � GPGSV_MIDDLEr$ r rb ra rc r r r r �test_middleSentence� s z$GSVSequenceTests.test_middleSentencec C r^ )zN The last sentence in a GSV sequence is correctly identified. N) r r1 � GPGSV_LASTr$ r rb ra r` rc r r r r �test_lastSentence� re z"GSVSequenceTests.test_lastSentenceN)r r r r rd rg ri r r r r r] � s r] c @ r ) �BogusSentenceTestszK Tests for verifying predictable failure for bogus NMEA sentences. c C s | � || jj|� dS )a= Asserts that the protocol raises C{exceptionClass} when it receives C{sentence}. @param exceptionClass: The exception class expected to be raised. @type exceptionClass: C{Exception} subclass @param sentence: The (bogus) NMEA sentence. @type sentence: C{str} N)r9 r r1 )r �exceptionClassr r r r �assertRaisesOnSentence� s z)BogusSentenceTests.assertRaisesOnSentencec C s | � td� dS )z` Receiving a well-formed sentence of unknown type raises C{ValueError}. s $GPBOGUS*5bN)rl � ValueErrorr r r r � test_raiseOnUnknownSentenceType� � z2BogusSentenceTests.test_raiseOnUnknownSentenceTypec C s | � tjd� dS )zP Receiving a malformed sentence raises L{base.InvalidSentence}. �GPBOGUSN)rl r �InvalidSentencer r r r � test_raiseOnMalformedSentences r( z1BogusSentenceTests.test_raiseOnMalformedSentencesN)r r r r rl rn rr r r r r rj � s rj c @ rZ )�NMEASentenceTestsz1 Tests for L{nmea.NMEASentence} objects. c C s@ t dfg}|D ]\}}| j�|� | jj}| �t|�|� qdS )zI The C{repr} of L{nmea.NMEASentence} objects is correct. aX <NMEASentence (GPGSA) {dataMode: A, fixType: 3, horizontalDilutionOfPrecision: 1.0, positionDilutionOfPrecision: 1.7, usedSatellitePRN_0: 19, usedSatellitePRN_1: 28, usedSatellitePRN_2: 14, usedSatellitePRN_3: 18, usedSatellitePRN_4: 27, usedSatellitePRN_5: 22, usedSatellitePRN_6: 31, usedSatellitePRN_7: 39, verticalDilutionOfPrecision: 1.3}>N)r, r r1 r$ r r2 �repr)r �sentencesWithExpectedReprr � expectedRepr�receivedr r r � test_repr s �� �zNMEASentenceTests.test_reprN)r r r r rx r r r r rs � rs c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )� ParsingTestsz� Tests if raw NMEA sentences get parsed correctly. This doesn't really involve any interpretation, just turning ugly raw NMEA representations into objects that are more pleasant to work with. c C s& | j �|� | jj}| �||j� dS )z� Passes a sentence to the protocol and gets the parsed sentence from the receiver. Then verifies that the parsed sentence contains the expected data. N)r r1 r$ r r2 � _sentenceData)r r �expectedrw r r r � _parserTest7 s zParsingTests._parserTestc C s. ddddddddd d d d d � }| � t|� dS )z: A full RMC sentence is correctly parsed. r/ �4807.038�N� 01131.000�Ez003.1�Wz022.4�123519�230394z084.4�A) r' � latitudeFloat�latitudeHemisphere�longitudeFloat�longitudeHemisphere�magneticVariation�magneticVariationDirection� speedInKnots� timestamp� datestamp� trueHeading�dataModeN)r} r/ �r r| r r r � test_fullRMCA s �zParsingTests.test_fullRMCc C s0 dddddddddd d d d d � }| � t|� dS )z: A full GGA sentence is correctly parsed. r* �545.4�M�46.9z0.9r~ r r� r� �08r� �1) r' �altitude� altitudeUnits�heightOfGeoidAboveWGS84� heightOfGeoidAboveWGS84Units� horizontalDilutionOfPrecisionr� r� r� r� �numberOfSatellitesSeenr� � fixQualityN)r} r* r� r r r � test_fullGGAU s �zParsingTests.test_fullGGAc C s$ dddddddd�}| � t|� d S ) z: A full GLL sentence is correctly parsed. r+ z4916.45r z12311.12r� �225444r� )r' r� r� r� r� r� r� N)r} r+ r� r r r � test_fullGLLj s � zParsingTests.test_fullGLLc C s dddddd�}| � t|� dS )z= A partial GLL sentence is correctly parsed. r+ z3751.65�Sz14507.36r� )r' r� r� r� r� N)r} � GPGLL_PARTIALr� r r r �test_partialGLLy s �z ParsingTests.test_partialGLLc C s� i dd�dd�dd�dd�d d �d d �d d�dd�dd�dd�dd�dd�dd�dd�d d�d d �d d �d d d d!��}| � t|� d"S )#z: A full GSV sentence is correctly parsed. r' r- �GSVSentenceIndexr� �numberOfGSVSentences�3r� �11� azimuth_0�111� azimuth_1�270� azimuth_2�010� azimuth_3�292� elevation_0�03� elevation_1�15� elevation_2�01� elevation_3�06�satellitePRN_0�satellitePRN_1�04�satellitePRN_2�satellitePRN_3�13�signalToNoiseRatio_0�00)�signalToNoiseRatio_1�signalToNoiseRatio_2�signalToNoiseRatio_3N)r} r_ r� r r r � test_fullGSV� sP �������� � � � � ������zParsingTests.test_fullGSVc C st i dd�dd�dd�dd�dd �d d �d d �dd�dd�dd�dd�dd�dd�dd�dd �d d �}| � t|� d S ) z= A partial GSV sentence is correctly parsed. r' r- r� r� r� r� r� r� �067r� �311r� �244r� �42r� �14r� �05r� �22r� �24r� �27r� r� �43r� r� N)r} rh r� r r r �test_partialGSV� sD �������� � � � � ����z ParsingTests.test_partialGSVc C s ddd�}| � t|� dS )z: A full HDT sentence is correctly parsed. r. z038.005)r' r� N)r} r. r� r r r � test_fullHDT� s �zParsingTests.test_fullHDTc C s2 ddddddddd d d d d dd�}| � t|� dS )z= A typical GSA sentence is correctly parsed. r, r� r� �19�28r� �18r� r� �31�39z1.7z1.0z1.3)r' r� �fixType�usedSatellitePRN_0�usedSatellitePRN_1�usedSatellitePRN_2�usedSatellitePRN_3�usedSatellitePRN_4�usedSatellitePRN_5�usedSatellitePRN_6�usedSatellitePRN_7�positionDilutionOfPrecisionr� �verticalDilutionOfPrecisionN)r} r, r� r r r �test_typicalGSA� s �z ParsingTests.test_typicalGSAN) r r r r r} r� r� r� r� r� r� r� r� r r r r rz / s rz c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � FixUnitsTestsz� Tests for the generic unit fixing method, L{nmea.NMEAAdapter._fixUnits}. @ivar adapter: The NMEA adapter. @type adapter: L{nmea.NMEAAdapter} c C � t �t�� �| _d S r �r � NMEAAdapterr �BasePositioningReceiver�adapterr r r r r% � � zFixUnitsTests.setUpc C s@ G dd� d�}|� | j _| j jddd� | �| j jd d� dS ) zv Tests that when no C{valueKey} is provided, C{unitKey} is used, minus C{"Units"} at the end. c @ rZ )z3FixUnitsTests.test_noValueKey.<locals>.FakeSentencezJ A fake sentence that just has a "foo" attribute. c S s d| _ d S )NrP )�foor r r r r � r z<FixUnitsTests.test_noValueKey.<locals>.FakeSentence.__init__N�r r r r r r r r r � FakeSentence� ry r� �fooUnitsr )�unitKey�unitr� rP N�r� �currentSentence� _fixUnits�assertNotEqualr{ �r r� r r r �test_noValueKey� s z FixUnitsTests.test_noValueKeyc C s> G dd� d�}|� | j _| j jdd� | �| j jd d� dS )z� Tests that if a unit key is provided but the unit isn't, the unit is automatically determined from the unit key. c @ rZ )z9FixUnitsTests.test_unitKeyButNoUnit.<locals>.FakeSentencezX A fake sentence that just has "foo" and "fooUnits" attributes. c S s d| _ d| _d S )NrP r )r� r� r r r r r s zBFixUnitsTests.test_unitKeyButNoUnit.<locals>.FakeSentence.__init__Nr� r r r r r� � ry r� r� )r� r� rP Nr� r� r r r �test_unitKeyButNoUnit� s z#FixUnitsTests.test_unitKeyButNoUnitc C s | j t| jjdd� dS )z� Tests that when a unit is specified but neither C{valueKey} nor C{unitKey} is provided, C{ValueError} is raised. �K)r� N)r9 rm r� r� r r r r �test_noValueKeyAndNoUnitKey s z)FixUnitsTests.test_noValueKeyAndNoUnitKeyN)r r r r r% r� r� r� r r r r r� � s r� c @ s" e Zd ZdZdd� Zddd�ZdS )�FixerTestMixinz� Mixin for tests for the fixers on L{nmea.NMEAAdapter} that adapt from NMEA-specific notations to generic Python objects. @ivar adapter: The NMEA adapter. @type adapter: L{nmea.NMEAAdapter} c C r� r r� r r r r r% r� zFixerTestMixin.setUpNc sR t �|��� �fdd�}|du r |� � �� jj|� n� �||� � j�� dS )a� A generic adapter fixer test. Creates a sentence from the C{sentenceData} and sends that to the adapter. If C{exceptionClass} is not passed, this is assumed to work, and C{expected} is compared with the adapter's internal state. Otherwise, passing the sentence to the adapter is checked to raise C{exceptionClass}. @param sentenceData: Raw sentence content. @type sentenceData: C{dict} mapping C{str} to C{str} @param expected: The expected state of the adapter. @type expected: C{dict} or L{None} @param exceptionClass: The exception to be raised by the adapter. @type exceptionClass: subclass of C{Exception} c s � j ��� d S r )r� r r r r r �receiveSentence4 s z2FixerTestMixin._fixerTest.<locals>.receiveSentenceN)r � NMEASentencer2 r� �_stater9 r )r � sentenceDatar| rk r� r r r � _fixerTest s zFixerTestMixin._fixerTest)NN)r r r r r% r� r r r r r� s r� c @ r< )�TimestampFixerTestszL Tests conversion from NMEA timestamps to C{datetime.time} objects. c C s* ddi}dt �ddd�i}| �||� dS )z< A simple timestamp is converted correctly. r� �123456�_time� �" �8 N)�datetime�timer� )r �datar| r r r � test_simpleE s z TimestampFixerTests.test_simplec C s$ d}|D ] }| j d|itd� qdS )z: A broken timestamp raises C{ValueError}. )�993456�129956�123499r� �rk N�r� rm )r � badTimestamps�tr r r � test_brokenM s �z TimestampFixerTests.test_brokenN)r r r r r r r r r r r� @ s r� c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �DatestampFixerTestsc C s | � | jjd� dS )z5 The default year threshold is 1980. i� N)r2 r� � yearThresholdr r r r �test_defaultYearThresholdX s z-DatestampFixerTests.test_defaultYearThresholdc C �, dt �ddd�}}| �d|id|i� dS )z� Dates before the threshold are interpreted as being in the century after the threshold. (Since the threshold is the earliest possible date.) �010115i� rP r� �_dateN�r �dater� �r � datestringr r r r �test_beforeThreshold^ s z(DatestampFixerTests.test_beforeThresholdc C r )zr Dates after the threshold are interpreted as being in the same century as the threshold. �010195i� rP r� r Nr r r r r �test_afterThresholdg s z'DatestampFixerTests.test_afterThresholdc C s | j dditd� dS )zQ A datestring with an invalid month (> 12) raises C{ValueError}. r� �011301r Nr r r r r �test_invalidMontho rM z%DatestampFixerTests.test_invalidMonthc C s( | j dditd� | j dditd� dS )zy A datestring with an invalid day (more days than there are in that month) raises C{ValueError}. r� �320101r �300201Nr r r r r �test_invalidDayu s z#DatestampFixerTests.test_invalidDayN)r r r r r r r r! r r r r r W s r c C s d| |f S )a^ Builds an NMEA float representation for a given angle in degrees and decimal minutes. @param degrees: The integer degrees for this angle. @type degrees: C{int} @param minutes: The decimal minutes value for this angle. @type minutes: C{float} @return: The NMEA float representation for this angle. @rtype: C{str} z%i%0.3fr )�degrees�minutesr r r � _nmeaFloat~ s r$ c C s | dv rdS dS )a8 Return the sign of a coordinate. This is C{1} if the coordinate is in the northern or eastern hemispheres, C{-1} otherwise. @param hemisphere: NMEA shorthand for the hemisphere. One of "NESW". @type hemisphere: C{str} @return: The sign of the coordinate value. @rtype: C{int} �NErP ���r �� hemispherer r r �_coordinateSign� s r) c C s | dv rt jS t jS )ao Return the type of a coordinate. This is L{Angles.LATITUDE} if the coordinate is in the northern or southern hemispheres, L{Angles.LONGITUDE} otherwise. @param hemisphere: NMEA shorthand for the hemisphere. One of "NESW". @type hemisphere: C{str} @return: The type of the coordinate (L{Angles.LATITUDE} or L{Angles.LONGITUDE}) �NS)r �LATITUDE� LONGITUDEr' r r r �_coordinateType� s r- c @ �@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�CoordinateFixerTestszO Tests turning NMEA coordinate notations into something more pleasant. c C �, ddd�}dt �dtj�i}| �||� dS )zg NMEA coordinate representations in the northern hemisphere convert correctly. �1030.000r �r� r� �latitude� %@N�r � Coordinater r+ r� �r r� �stater r r � test_north� � z CoordinateFixerTests.test_northc C r0 )zg NMEA coordinate representations in the southern hemisphere convert correctly. r1 r� r2 r3 � %�Nr5 r7 r r r � test_south� r: z CoordinateFixerTests.test_southc C r0 )zf NMEA coordinate representations in the eastern hemisphere convert correctly. r1 r� �r� r� � longituder4 N�r r6 r r, r� r7 r r r � test_east� r: z CoordinateFixerTests.test_eastc C r0 )zf NMEA coordinate representations in the western hemisphere convert correctly. r1 r� r= r> r; Nr? r7 r r r � test_west� r: z CoordinateFixerTests.test_westc C s ddi}| j |td� dS )z� NMEA coordinate representations for nonexistent hemispheres raise C{ValueError} when you attempt to parse them. r� �Qr Nr �r r� r r r �test_badHemisphere� r; z'CoordinateFixerTests.test_badHemispherec s � fdd�}� � t|� dS )z� NMEA coordinate repesentation parsing fails predictably when you pass nonexistent coordinate types (not latitude or longitude). c s � j �d�S )N� BOGUS_VALUE)r� �_getHemisphereSignr r r r �<lambda>� s z=CoordinateFixerTests.test_badHemisphereSign.<locals>.<lambda>N)r9 rm )r �getSignr r r �test_badHemisphereSign� s z+CoordinateFixerTests.test_badHemisphereSignN) r r r r r9 r< r@ rA rD rI r r r r r/ � s r/ c @ r< )�AltitudeFixerTestszO Tests that NMEA representations of altitudes are correctly converted. c C �. d\}}t �t|��}| �||i||i� dS )zo The NMEA representation of an altitude (above mean sea level) is correctly converted. )r� r� N�r �Altitude�floatr� �r �key�valuer� r r r �test_fixAltitude� � z#AltitudeFixerTests.test_fixAltitudec C rK )z� The NMEA representation of an altitude of the geoid (above the WGS84 reference level) is correctly converted. )r� r� NrL rO r r r � test_heightOfGeoidAboveWGS84� rS z/AltitudeFixerTests.test_heightOfGeoidAboveWGS84N)r r r r rR rT r r r r rJ � s rJ c @ rZ )�SpeedFixerTestszL Tests that NMEA representations of speeds are correctly converted. c C s6 d\}}}t �t|�t j �}| �||i||i� dS )z` Speeds reported in knots correctly get converted to meters per second. )r� �10�speedN)r �SpeedrN � MPS_PER_KNOTr� )r rP rQ � targetKeyrW r r r �test_speedInKnots s z!SpeedFixerTests.test_speedInKnotsN)r r r r r[ r r r r rU ry rU c @ r ) �VariationFixerTestsz� Tests if the absolute values of magnetic variations on the heading and their sign get combined correctly, and if that value gets combined with a heading correctly. c C s< d\}}t jjdt|� d�}||d�}| �|d|i� dS )z? Tests westward (negative) magnetic variation. )�1.34r� r& ��variationValue�r� r� �headingN�r �Heading� fromFloatsrN r� �r � variation� directionra r� r r r rA s �z VariationFixerTests.test_westc C s8 d\}}t jjt|�d�}||d�}| �|d|i� dS )z? Tests eastward (positive) magnetic variation. )r] r� r^ r` ra Nrb re r r r r@ # s �z VariationFixerTests.test_eastc C sB d\}}}|||d�}t jjt|�t|�d�}| �|d|i� dS )zH Variation values get combined with headings correctly. )z123.12r] r� )r� r� r� r^ ra Nrb )r r� rf rg r� ra r r r �test_withHeading0 s � �z$VariationFixerTests.test_withHeadingN)r r r r rA r@ rh r r r r r\ s r\ c @ r< )�PositionErrorFixerTestsa� Position errors in NMEA are passed as dilutions of precision (DOP). This is a measure relative to some specified value of the GPS device as its "reference" precision. Unfortunately, there are very few ways of figuring this out from just the device (sans manual). There are two basic DOP values: vertical and horizontal. HDOP tells you how precise your location is on the face of the earth (pretending it's flat, at least locally). VDOP tells you how precise your altitude is known. PDOP (position DOP) is a dependent value defined as the Euclidean norm of those two, and gives you a more generic "goodness of fix" value. c C s | � ddidtjdd�i� d S )Nr� r� � positionErrorg &@)�hdop)r� r � PositionErrorr r r r r N s �z#PositionErrorFixerTests.test_simplec C sF d\}}}t jt|�t|�t|�d�}|||d�}| �|d|i� d S )N)r� r� r� )�pdoprk �vdop)r� r� r� rj )r rl rN r� )r rm rk rn rj r� r r r � test_mixingT s ��z#PositionErrorFixerTests.test_mixingN)r r r r r ro r r r r ri @ s ri c @ r< )� ValidFixTestsz< Tests that data reported from a valid fix is used. c C �. ddt jjd�}dt�d�i}| �||� dS )z4 GGA data with a valid fix is used. r* r� �r' r� r� r� �33333 �@N)r �GPGGAFixQualities�GPS_FIXr rM r� �r r� � expectedStater r r �test_GGAf � �zValidFixTests.test_GGAc C rq )z: GLL data with a valid data mode is used. r+ r� �r' r� r� r� rs N)r �GPGLLGPRMCFixQualities�ACTIVEr rM r� rv r r r �test_GLLs ry zValidFixTests.test_GLLN)r r r r rx r} r r r r rp a s rp c @ r. )�InvalidFixTestsa: Tests that data being reported from a bad or incomplete fix isn't used. Although the specification dictates that GPSes shouldn't produce NMEA sentences with real-looking values for altitude or position in them unless they have at least some semblance of a GPS fix, this is widely ignored. c C s | � |i � dS )zu Sentences with an invalid fix or data mode result in empty state (ie, the data isn't used). N)r� rC r r r �_invalidFixTest� ro z InvalidFixTests._invalidFixTestc C � ddt jjd�}| �|� dS )zC GGA sentence data is unused when there is no fix. r* r� rr N)r rt � INVALID_FIXr rC r r r rx � � �zInvalidFixTests.test_GGAc C r� )zO GLL sentence data is unused when the data is flagged as void. r+ r� rz N)r r{ �VOIDr rC r r r r} � r� zInvalidFixTests.test_GLLc C �$ ddt jjt jjd�}| �|� dS )z� GSA sentence data is not used when there is no GPS fix, but the data mode claims the data is "active". Some GPSes do this, unfortunately, and that means you shouldn't use the data. r, r� �r' r� r� r� N)r r{ r| � GPGSAFixTypes� GSA_NO_FIXr rC r r r �test_badGSADataMode� � �z#InvalidFixTests.test_badGSADataModec C r� )z� GSA sentence data is not used when the fix claims to be valid (albeit only 2D), but the data mode says the data is void. Some GPSes do this, unfortunately, and that means you shouldn't use the data. r, r� r� N)r r{ r� r� � GSA_2D_FIXr rC r r r �test_badGSAFixType� r� z"InvalidFixTests.test_badGSAFixTypec C r� )zj GSA sentence data is not use when neither the fix nor the data mode is any good. r, r� r� N)r r{ r� r� r� r rC r r r � test_badGSADataModeAndFixType� s �z-InvalidFixTests.test_badGSADataModeAndFixTypeN) r r r r r rx r} r� r� r� r r r r r~ � s r~ c @ s� e Zd ZdZdd� Zdd� Zd$dd �Zd d � Zd d � Zdd� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� ZdS )%�NMEAReceiverTestsz& Tests for the NMEA receiver. c C s( t � | _t�| j�| _t�| j�| _d S r )r r$ r r� r� r r r r r r r% � s zNMEAReceiverTests.setUpc C st | j �t� h d�}| �t| jj�� �|� | j�� | � | j j i � | j �t � dh}| �t| jj�� �|� dS )z� If the current sentence does not contain any new fields for a particular callback, that callback is not called; even if all necessary information is still in the state from one or more previous messages. > �altitudeReceived�positionReceived�positionErrorReceived�headingReceivedN) r r1 r* r2 r! r$ �called�keysr r� r� r� r. )r �gpggaCallbacks�gphdtCallbacksr r r �1test_onlyFireWhenCurrentSentenceHasNewInformation� s zCNMEAReceiverTests.test_onlyFireWhenCurrentSentenceHasNewInformationr Nc C s\ |D ]}| j �|� q| jj�� }| �t|�t|�� |dur"|� | j�� | j�� dS )a� A generic test for NMEA receiver behavior. @param sentences: The sequence of sentences to simulate receiving. @type sentences: iterable of C{str} @param expectedFired: The names of the callbacks expected to fire. @type expectedFired: iterable of C{str} @param extraTest: An optional extra test hook. @type extraTest: nullary callable N) r r1 r$ r� r� r2 r! r r� )r r5 � expectedFired� extraTestr � actuallyFiredr r r � _receiverTest� s z NMEAReceiverTests._receiverTestc s: t gt }ddg}dd� � � �fdd�}��|||� dS )zJ The positioning error is updated across multiple states. r� �beaconInformationReceivedc S s t ttd�| ��S )N� identifier)�sorted�mapr )�beaconsr r r �_getIdentifiers s zONMEAReceiverTests.test_positionErrorUpdateAcrossStates.<locals>._getIdentifiersc sH �j jd } � | j�}g d�}��||� � | j�}��|g d�� d S )N�beaconInformation) � � � � � rO � � � � � )r� r� r� r� r� )r� r� � seenBeaconsr2 � usedBeacons)r� �seenIdentifiersr| �usedIdentifiers�r� r r r �checkBeaconInformation s zVNMEAReceiverTests.test_positionErrorUpdateAcrossStates.<locals>.checkBeaconInformationN)r, � GPGSV_SEQr� �r r5 �callbacksFiredr� r r� r �$test_positionErrorUpdateAcrossStates s z6NMEAReceiverTests.test_positionErrorUpdateAcrossStatesc s* t g}dg}� fdd�}� �|||� dS )z� A GSV sentence with empty entries in any position does not mean that entries in subsequent positions of the same GSV sentence are ignored. r� c s< � j jd } | j}� �t|�d� � �ddd� |D �� d S )Nr� � r� c S s g | ]}|j �qS r )r� )�.0�br r r � <listcomp>7 s zYNMEAReceiverTests.test_emptyMiddleGSV.<locals>.checkBeaconInformation.<locals>.<listcomp>)r� r� r� r2 �len�assertIn)r� r� r r r r� 2 s zENMEAReceiverTests.test_emptyMiddleGSV.<locals>.checkBeaconInformationN��GPGSV_EMPTY_MIDDLEr� r� r r r �test_emptyMiddleGSV* s z%NMEAReceiverTests.test_emptyMiddleGSVc C � t g}g d�}| �||� dS )z� A sequence of GGA sentences fires C{positionReceived}, C{positionErrorReceived} and C{altitudeReceived}. )r� r� r� N)r* r� �r r5 r� r r r �test_GGASentences; s z#NMEAReceiverTests.test_GGASentencesc C s4 t �ddd�| jjd< tg}g d�}| �||� dS )z� When receiving a GPGGA sentence and a date was already in the state, the new time (from the GPGGA sentence) is combined with that date. i� rP r )r� r� r� � timeReceivedN)r r r� r� r* r� r� r r r �test_GGAWithDateInStateI s z)NMEAReceiverTests.test_GGAWithDateInStatec C r� )z� A sequence of RMC sentences fires C{positionReceived}, C{speedReceived}, C{headingReceived} and C{timeReceived}. )r� � speedReceivedr� r� N)r/ r� r� r r r �test_RMCSentences[ s z#NMEAReceiverTests.test_RMCSentencesc s. t ttg}dg}� fdd�}� �|||� dS )zb A complete sequence of GSV sentences fires C{beaconInformationReceived}. r� c s � � d� jj� d S )N�_partialBeaconInformation)� assertNotInr� r� r r r r �checkPartialInformationr r� zDNMEAReceiverTests.test_GSVSentences.<locals>.checkPartialInformationN)r_ rf rh r� )r r5 r� r� r r r �test_GSVSentencesj s z#NMEAReceiverTests.test_GSVSentencesc C � t g}| �|dg� dS )z� A complete sequence of GSV sentences with empty entries in the middle still fires C{beaconInformationReceived}. r� Nr� �r r5 r r r �"test_emptyMiddleEntriesGSVSequencew � z4NMEAReceiverTests.test_emptyMiddleEntriesGSVSequencec C s t g}| �|� dS )zV An incomplete sequence of GSV sentences does not fire any callbacks. N)r_ r� r� r r r �test_incompleteGSVSequence s z,NMEAReceiverTests.test_incompleteGSVSequencec C r� )z� The parser does not fail badly when the sequence consists of only one sentence (but is otherwise complete). r� N)� GPGSV_SINGLEr� r� r r r � test_singleSentenceGSVSequence� r� z0NMEAReceiverTests.test_singleSentenceGSVSequencec C s t tg}| �|dg� dS )z9 GLL sentences fire C{positionReceived}. r� N)r� r+ r� r� r r r �test_GLLSentences� r\ z#NMEAReceiverTests.test_GLLSentencesc C r� )z8 HDT sentences fire C{headingReceived}. r� N)r. r� r� r r r �test_HDTSentences� s z#NMEAReceiverTests.test_HDTSentencesc s. t tg}g d�}� fdd�}� �|||� dS )zA A mix of sentences fires the correct callbacks. )r� r� r� r� r� r� c s, t � dddddd�} � �� jjd | � d S )Ni� r� � r �# r� r )r r2 r� r� )�expectedDateTimer r r � checkTime� s z8NMEAReceiverTests.test_mixedSentences.<locals>.checkTimeN)r/ r* r� )r r5 r� r� r r r �test_mixedSentences� s z%NMEAReceiverTests.test_mixedSentencesc C s, t gt tttg }g d�}| �||� dS )a# Sends an entire gamut of sentences and verifies the appropriate callbacks fire. These are more than you'd expect from your average consumer GPS device. They have most of the important information, including beacon information and visibility. )r� r� r� r� r� r� r� N)r, r� r/ r* r+ r� r� r r r �test_lotsOfMixedSentences� s z+NMEAReceiverTests.test_lotsOfMixedSentences)r N)r r r r r% r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� � s$ r� )7r r �operatorr �zope.interfacer �twisted.positioningr r r �twisted.positioning.baser �!twisted.positioning.test.receiverr �twisted.trial.unittestr r* r/ r, r. r+ r� r� r� rQ r� r_ rf rh � INMEAReceiverr r r7 r= rG r[ r] rj rs rz r� r� r� r r$ r) r- r/ rJ rU r\ ri rp r~ r� r r r r �<module> sb �* % $ -8-';1! TPK Mb�Z��ç�p �p positioning/test/test_base.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for positioning primitives. """ from zope.interface import verify from twisted.positioning import base from twisted.positioning.base import Angles, Directions from twisted.positioning.ipositioning import IPositioningBeacon from twisted.trial.unittest import TestCase class AngleTests(TestCase): """ Tests for the L{twisted.positioning.base.Angle} class. """ def test_empty(self): """ The repr of an empty angle says that is of unknown type and unknown value. """ a = base.Angle() self.assertEqual("<Angle of unknown type (unknown value)>", repr(a)) def test_variation(self): """ The repr of an empty variation says that it is a variation of unknown value. """ a = base.Angle(angleType=Angles.VARIATION) self.assertEqual("<Variation (unknown value)>", repr(a)) def test_unknownType(self): """ The repr of an angle of unknown type but a given value displays that type and value in its repr. """ a = base.Angle(1.0) self.assertEqual("<Angle of unknown type (1.0 degrees)>", repr(a)) def test_bogusType(self): """ Trying to create an angle with a bogus type raises C{ValueError}. """ self.assertRaises(ValueError, base.Angle, angleType="BOGUS") class HeadingTests(TestCase): """ Tests for the L{twisted.positioning.base.Heading} class. """ def test_simple(self): """ Tests that a simple heading has a value in decimal degrees, which is also its value when converted to a float. Its variation, and by consequence its corrected heading, is L{None}. """ h = base.Heading(1.0) self.assertEqual(h.inDecimalDegrees, 1.0) self.assertEqual(float(h), 1.0) self.assertIsNone(h.variation) self.assertIsNone(h.correctedHeading) def test_headingWithoutVariationRepr(self): """ A repr of a heading with no variation reports its value and that the variation is unknown. """ heading = base.Heading(1.0) expectedRepr = "<Heading (1.0 degrees, unknown variation)>" self.assertEqual(repr(heading), expectedRepr) def test_headingWithVariationRepr(self): """ A repr of a heading with known variation reports its value and the value of that variation. """ angle, variation = 1.0, -10.0 heading = base.Heading.fromFloats(angle, variationValue=variation) reprTemplate = "<Heading ({0} degrees, <Variation ({1} degrees)>)>" self.assertEqual(repr(heading), reprTemplate.format(angle, variation)) def test_valueEquality(self): """ Headings with the same values compare equal. """ self.assertEqual(base.Heading(1.0), base.Heading(1.0)) def test_valueInequality(self): """ Headings with different values compare unequal. """ self.assertNotEqual(base.Heading(1.0), base.Heading(2.0)) def test_zeroHeadingEdgeCase(self): """ Headings can be instantiated with a value of 0 and no variation. """ base.Heading(0) def test_zeroHeading180DegreeVariationEdgeCase(self): """ Headings can be instantiated with a value of 0 and a variation of 180 degrees. """ base.Heading(0, 180) def _badValueTest(self, **kw): """ Helper function for verifying that bad values raise C{ValueError}. @param kw: The keyword arguments passed to L{base.Heading.fromFloats}. """ self.assertRaises(ValueError, base.Heading.fromFloats, **kw) def test_badAngleValueEdgeCase(self): """ Headings can not be instantiated with a value of 360 degrees. """ self._badValueTest(angleValue=360.0) def test_badVariationEdgeCase(self): """ Headings can not be instantiated with a variation of -180 degrees. """ self._badValueTest(variationValue=-180.0) def test_negativeHeading(self): """ Negative heading values raise C{ValueError}. """ self._badValueTest(angleValue=-10.0) def test_headingTooLarge(self): """ Heading values greater than C{360.0} raise C{ValueError}. """ self._badValueTest(angleValue=370.0) def test_variationTooNegative(self): """ Variation values less than C{-180.0} raise C{ValueError}. """ self._badValueTest(variationValue=-190.0) def test_variationTooPositive(self): """ Variation values greater than C{180.0} raise C{ValueError}. """ self._badValueTest(variationValue=190.0) def test_correctedHeading(self): """ A heading with a value and a variation has a corrected heading. """ h = base.Heading.fromFloats(1.0, variationValue=-10.0) self.assertEqual(h.correctedHeading, base.Angle(11.0, Angles.HEADING)) def test_correctedHeadingOverflow(self): """ A heading with a value and a variation has the appropriate corrected heading value, even when the variation puts it across the 360 degree boundary. """ h = base.Heading.fromFloats(359.0, variationValue=-2.0) self.assertEqual(h.correctedHeading, base.Angle(1.0, Angles.HEADING)) def test_correctedHeadingOverflowEdgeCase(self): """ A heading with a value and a variation has the appropriate corrected heading value, even when the variation puts it exactly at the 360 degree boundary. """ h = base.Heading.fromFloats(359.0, variationValue=-1.0) self.assertEqual(h.correctedHeading, base.Angle(0.0, Angles.HEADING)) def test_correctedHeadingUnderflow(self): """ A heading with a value and a variation has the appropriate corrected heading value, even when the variation puts it under the 0 degree boundary. """ h = base.Heading.fromFloats(1.0, variationValue=2.0) self.assertEqual(h.correctedHeading, base.Angle(359.0, Angles.HEADING)) def test_correctedHeadingUnderflowEdgeCase(self): """ A heading with a value and a variation has the appropriate corrected heading value, even when the variation puts it exactly at the 0 degree boundary. """ h = base.Heading.fromFloats(1.0, variationValue=1.0) self.assertEqual(h.correctedHeading, base.Angle(0.0, Angles.HEADING)) def test_setVariationSign(self): """ Setting the sign of a heading changes the variation sign. """ h = base.Heading.fromFloats(1.0, variationValue=1.0) h.setSign(1) self.assertEqual(h.variation.inDecimalDegrees, 1.0) h.setSign(-1) self.assertEqual(h.variation.inDecimalDegrees, -1.0) def test_setBadVariationSign(self): """ Setting the sign of a heading to values that aren't C{-1} or C{1} raises C{ValueError} and does not affect the heading. """ h = base.Heading.fromFloats(1.0, variationValue=1.0) self.assertRaises(ValueError, h.setSign, -50) self.assertEqual(h.variation.inDecimalDegrees, 1.0) self.assertRaises(ValueError, h.setSign, 0) self.assertEqual(h.variation.inDecimalDegrees, 1.0) self.assertRaises(ValueError, h.setSign, 50) self.assertEqual(h.variation.inDecimalDegrees, 1.0) def test_setUnknownVariationSign(self): """ Setting the sign on a heading with unknown variation raises C{ValueError}. """ h = base.Heading.fromFloats(1.0) self.assertIsNone(h.variation.inDecimalDegrees) self.assertRaises(ValueError, h.setSign, 1) class CoordinateTests(TestCase): def test_float(self): """ Coordinates can be converted to floats. """ coordinate = base.Coordinate(10.0) self.assertEqual(float(coordinate), 10.0) def test_repr(self): """ Coordinates that aren't explicitly latitudes or longitudes have an appropriate repr. """ coordinate = base.Coordinate(10.0) expectedRepr = f"<Angle of unknown type ({10.0} degrees)>" self.assertEqual(repr(coordinate), expectedRepr) def test_positiveLatitude(self): """ Positive latitudes have a repr that specifies their type and value. """ coordinate = base.Coordinate(10.0, Angles.LATITUDE) expectedRepr = f"<Latitude ({10.0} degrees)>" self.assertEqual(repr(coordinate), expectedRepr) def test_negativeLatitude(self): """ Negative latitudes have a repr that specifies their type and value. """ coordinate = base.Coordinate(-50.0, Angles.LATITUDE) expectedRepr = f"<Latitude ({-50.0} degrees)>" self.assertEqual(repr(coordinate), expectedRepr) def test_positiveLongitude(self): """ Positive longitudes have a repr that specifies their type and value. """ longitude = base.Coordinate(50.0, Angles.LONGITUDE) expectedRepr = f"<Longitude ({50.0} degrees)>" self.assertEqual(repr(longitude), expectedRepr) def test_negativeLongitude(self): """ Negative longitudes have a repr that specifies their type and value. """ longitude = base.Coordinate(-50.0, Angles.LONGITUDE) expectedRepr = f"<Longitude ({-50.0} degrees)>" self.assertEqual(repr(longitude), expectedRepr) def test_bogusCoordinateType(self): """ Creating coordinates with bogus types rasies C{ValueError}. """ self.assertRaises(ValueError, base.Coordinate, 150.0, "BOGUS") def test_angleTypeNotCoordinate(self): """ Creating coordinates with angle types that aren't coordinates raises C{ValueError}. """ self.assertRaises(ValueError, base.Coordinate, 150.0, Angles.HEADING) def test_equality(self): """ Coordinates with the same value and type are equal. """ def makeCoordinate(): return base.Coordinate(1.0, Angles.LONGITUDE) self.assertEqual(makeCoordinate(), makeCoordinate()) def test_differentAnglesInequality(self): """ Coordinates with different values aren't equal. """ c1 = base.Coordinate(1.0) c2 = base.Coordinate(-1.0) self.assertNotEqual(c1, c2) def test_differentTypesInequality(self): """ Coordinates with the same values but different types aren't equal. """ c1 = base.Coordinate(1.0, Angles.LATITUDE) c2 = base.Coordinate(1.0, Angles.LONGITUDE) self.assertNotEqual(c1, c2) def test_sign(self): """ Setting the sign on a coordinate sets the sign of the value of the coordinate. """ c = base.Coordinate(50.0, Angles.LATITUDE) c.setSign(1) self.assertEqual(c.inDecimalDegrees, 50.0) c.setSign(-1) self.assertEqual(c.inDecimalDegrees, -50.0) def test_badVariationSign(self): """ Setting a bogus sign value (not -1 or 1) on a coordinate raises C{ValueError} and doesn't affect the coordinate. """ value = 50.0 c = base.Coordinate(value, Angles.LATITUDE) self.assertRaises(ValueError, c.setSign, -50) self.assertEqual(c.inDecimalDegrees, 50.0) self.assertRaises(ValueError, c.setSign, 0) self.assertEqual(c.inDecimalDegrees, 50.0) self.assertRaises(ValueError, c.setSign, 50) self.assertEqual(c.inDecimalDegrees, 50.0) def test_northernHemisphere(self): """ Positive latitudes are in the northern hemisphere. """ coordinate = base.Coordinate(1.0, Angles.LATITUDE) self.assertEqual(coordinate.hemisphere, Directions.NORTH) def test_easternHemisphere(self): """ Positive longitudes are in the eastern hemisphere. """ coordinate = base.Coordinate(1.0, Angles.LONGITUDE) self.assertEqual(coordinate.hemisphere, Directions.EAST) def test_southernHemisphere(self): """ Negative latitudes are in the southern hemisphere. """ coordinate = base.Coordinate(-1.0, Angles.LATITUDE) self.assertEqual(coordinate.hemisphere, Directions.SOUTH) def test_westernHemisphere(self): """ Negative longitudes are in the western hemisphere. """ coordinate = base.Coordinate(-1.0, Angles.LONGITUDE) self.assertEqual(coordinate.hemisphere, Directions.WEST) def test_badHemisphere(self): """ Accessing the hemisphere for a coordinate that can't compute it raises C{ValueError}. """ coordinate = base.Coordinate(1.0, None) self.assertRaises(ValueError, lambda: coordinate.hemisphere) def test_latitudeTooLarge(self): """ Creating a latitude with a value greater than or equal to 90 degrees raises C{ValueError}. """ self.assertRaises(ValueError, _makeLatitude, 150.0) self.assertRaises(ValueError, _makeLatitude, 90.0) def test_latitudeTooSmall(self): """ Creating a latitude with a value less than or equal to -90 degrees raises C{ValueError}. """ self.assertRaises(ValueError, _makeLatitude, -150.0) self.assertRaises(ValueError, _makeLatitude, -90.0) def test_longitudeTooLarge(self): """ Creating a longitude with a value greater than or equal to 180 degrees raises C{ValueError}. """ self.assertRaises(ValueError, _makeLongitude, 250.0) self.assertRaises(ValueError, _makeLongitude, 180.0) def test_longitudeTooSmall(self): """ Creating a longitude with a value less than or equal to -180 degrees raises C{ValueError}. """ self.assertRaises(ValueError, _makeLongitude, -250.0) self.assertRaises(ValueError, _makeLongitude, -180.0) def test_inDegreesMinutesSeconds(self): """ Coordinate values can be accessed in degrees, minutes, seconds. """ c = base.Coordinate(50.5, Angles.LATITUDE) self.assertEqual(c.inDegreesMinutesSeconds, (50, 30, 0)) c = base.Coordinate(50.213, Angles.LATITUDE) self.assertEqual(c.inDegreesMinutesSeconds, (50, 12, 46)) def test_unknownAngleInDegreesMinutesSeconds(self): """ If the vaue of a coordinate is L{None}, its values in degrees, minutes, seconds is also L{None}. """ c = base.Coordinate(None, None) self.assertIsNone(c.inDegreesMinutesSeconds) def _makeLatitude(value): """ Builds and returns a latitude of given value. """ return base.Coordinate(value, Angles.LATITUDE) def _makeLongitude(value): """ Builds and returns a longitude of given value. """ return base.Coordinate(value, Angles.LONGITUDE) class AltitudeTests(TestCase): """ Tests for the L{twisted.positioning.base.Altitude} class. """ def test_value(self): """ Altitudes can be instantiated and reports the correct value in meters and feet, as well as when converted to float. """ altitude = base.Altitude(1.0) self.assertEqual(float(altitude), 1.0) self.assertEqual(altitude.inMeters, 1.0) self.assertEqual(altitude.inFeet, 1.0 / base.METERS_PER_FOOT) def test_repr(self): """ Altitudes report their type and value in their repr. """ altitude = base.Altitude(1.0) self.assertEqual(repr(altitude), "<Altitude (1.0 m)>") def test_equality(self): """ Altitudes with equal values compare equal. """ firstAltitude = base.Altitude(1.0) secondAltitude = base.Altitude(1.0) self.assertEqual(firstAltitude, secondAltitude) def test_inequality(self): """ Altitudes with different values don't compare equal. """ firstAltitude = base.Altitude(1.0) secondAltitude = base.Altitude(-1.0) self.assertNotEqual(firstAltitude, secondAltitude) class SpeedTests(TestCase): """ Tests for the L{twisted.positioning.base.Speed} class. """ def test_value(self): """ Speeds can be instantiated, and report their value in meters per second, and can be converted to floats. """ speed = base.Speed(50.0) self.assertEqual(speed.inMetersPerSecond, 50.0) self.assertEqual(float(speed), 50.0) def test_repr(self): """ Speeds report their type and value in their repr. """ speed = base.Speed(50.0) self.assertEqual(repr(speed), "<Speed (50.0 m/s)>") def test_negativeSpeeds(self): """ Creating a negative speed raises C{ValueError}. """ self.assertRaises(ValueError, base.Speed, -1.0) def test_inKnots(self): """ A speed can be converted into its value in knots. """ speed = base.Speed(1.0) self.assertEqual(1 / base.MPS_PER_KNOT, speed.inKnots) def test_asFloat(self): """ A speed can be converted into a C{float}. """ self.assertEqual(1.0, float(base.Speed(1.0))) class ClimbTests(TestCase): """ Tests for L{twisted.positioning.base.Climb}. """ def test_simple(self): """ Speeds can be instantiated, and report their value in meters per second, and can be converted to floats. """ climb = base.Climb(42.0) self.assertEqual(climb.inMetersPerSecond, 42.0) self.assertEqual(float(climb), 42.0) def test_repr(self): """ Climbs report their type and value in their repr. """ climb = base.Climb(42.0) self.assertEqual(repr(climb), "<Climb (42.0 m/s)>") def test_negativeClimbs(self): """ Climbs can have negative values, and still report that value in meters per second and when converted to floats. """ climb = base.Climb(-42.0) self.assertEqual(climb.inMetersPerSecond, -42.0) self.assertEqual(float(climb), -42.0) def test_speedInKnots(self): """ A climb can be converted into its value in knots. """ climb = base.Climb(1.0) self.assertEqual(1 / base.MPS_PER_KNOT, climb.inKnots) def test_asFloat(self): """ A climb can be converted into a C{float}. """ self.assertEqual(1.0, float(base.Climb(1.0))) class PositionErrorTests(TestCase): """ Tests for L{twisted.positioning.base.PositionError}. """ def test_allUnset(self): """ In an empty L{base.PositionError} with no invariant testing, all dilutions of positions are L{None}. """ positionError = base.PositionError() self.assertIsNone(positionError.pdop) self.assertIsNone(positionError.hdop) self.assertIsNone(positionError.vdop) def test_allUnsetWithInvariant(self): """ In an empty L{base.PositionError} with invariant testing, all dilutions of positions are L{None}. """ positionError = base.PositionError(testInvariant=True) self.assertIsNone(positionError.pdop) self.assertIsNone(positionError.hdop) self.assertIsNone(positionError.vdop) def test_withoutInvariant(self): """ L{base.PositionError}s can be instantiated with just a HDOP. """ positionError = base.PositionError(hdop=1.0) self.assertEqual(positionError.hdop, 1.0) def test_withInvariant(self): """ Creating a simple L{base.PositionError} with just a HDOP while checking the invariant works. """ positionError = base.PositionError(hdop=1.0, testInvariant=True) self.assertEqual(positionError.hdop, 1.0) def test_invalidWithoutInvariant(self): """ Creating a L{base.PositionError} with values set to an impossible combination works if the invariant is not checked. """ error = base.PositionError(pdop=1.0, vdop=1.0, hdop=1.0) self.assertEqual(error.pdop, 1.0) self.assertEqual(error.hdop, 1.0) self.assertEqual(error.vdop, 1.0) def test_invalidWithInvariant(self): """ Creating a L{base.PositionError} with values set to an impossible combination raises C{ValueError} if the invariant is being tested. """ self.assertRaises( ValueError, base.PositionError, pdop=1.0, vdop=1.0, hdop=1.0, testInvariant=True, ) def test_setDOPWithoutInvariant(self): """ You can set the PDOP value to value inconsisted with HDOP and VDOP when not checking the invariant. """ pe = base.PositionError(hdop=1.0, vdop=1.0) pe.pdop = 100.0 self.assertEqual(pe.pdop, 100.0) def test_setDOPWithInvariant(self): """ Attempting to set the PDOP value to value inconsisted with HDOP and VDOP when checking the invariant raises C{ValueError}. """ pe = base.PositionError(hdop=1.0, vdop=1.0, testInvariant=True) pdop = pe.pdop def setPDOP(pe): pe.pdop = 100.0 self.assertRaises(ValueError, setPDOP, pe) self.assertEqual(pe.pdop, pdop) REPR_TEMPLATE = "<PositionError (pdop: %s, hdop: %s, vdop: %s)>" def _testDOP(self, pe, pdop, hdop, vdop): """ Tests the DOP values in a position error, and the repr of that position error. @param pe: The position error under test. @type pe: C{PositionError} @param pdop: The expected position dilution of precision. @type pdop: C{float} or L{None} @param hdop: The expected horizontal dilution of precision. @type hdop: C{float} or L{None} @param vdop: The expected vertical dilution of precision. @type vdop: C{float} or L{None} """ self.assertEqual(pe.pdop, pdop) self.assertEqual(pe.hdop, hdop) self.assertEqual(pe.vdop, vdop) self.assertEqual(repr(pe), self.REPR_TEMPLATE % (pdop, hdop, vdop)) def test_positionAndHorizontalSet(self): """ The VDOP is correctly determined from PDOP and HDOP. """ pdop, hdop = 2.0, 1.0 vdop = (pdop ** 2 - hdop ** 2) ** 0.5 pe = base.PositionError(pdop=pdop, hdop=hdop) self._testDOP(pe, pdop, hdop, vdop) def test_positionAndVerticalSet(self): """ The HDOP is correctly determined from PDOP and VDOP. """ pdop, vdop = 2.0, 1.0 hdop = (pdop ** 2 - vdop ** 2) ** 0.5 pe = base.PositionError(pdop=pdop, vdop=vdop) self._testDOP(pe, pdop, hdop, vdop) def test_horizontalAndVerticalSet(self): """ The PDOP is correctly determined from HDOP and VDOP. """ hdop, vdop = 1.0, 1.0 pdop = (hdop ** 2 + vdop ** 2) ** 0.5 pe = base.PositionError(hdop=hdop, vdop=vdop) self._testDOP(pe, pdop, hdop, vdop) class BeaconInformationTests(TestCase): """ Tests for L{twisted.positioning.base.BeaconInformation}. """ def test_minimal(self): """ For an empty beacon information object, the number of used beacons is zero, the number of seen beacons is zero, and the repr of the object reflects that. """ bi = base.BeaconInformation() self.assertEqual(len(bi.usedBeacons), 0) expectedRepr = ( "<BeaconInformation (" "used beacons (0): [], " "unused beacons: [])>" ) self.assertEqual(repr(bi), expectedRepr) satelliteKwargs = {"azimuth": 1, "elevation": 1, "signalToNoiseRatio": 1.0} def test_simple(self): """ Tests a beacon information with a bunch of satellites, none of which used in computing a fix. """ def _buildSatellite(**kw): kwargs = dict(self.satelliteKwargs) kwargs.update(kw) return base.Satellite(**kwargs) beacons = set() for prn in range(1, 10): beacons.add(_buildSatellite(identifier=prn)) bi = base.BeaconInformation(beacons) self.assertEqual(len(bi.seenBeacons), 9) self.assertEqual(len(bi.usedBeacons), 0) self.assertEqual( repr(bi), "<BeaconInformation (used beacons (0): [], " "unused beacons: [" "<Satellite (1), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (2), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (3), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (4), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (5), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (6), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (7), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (8), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (9), azimuth: 1, elevation: 1, snr: 1.0>" "])>", ) def test_someSatellitesUsed(self): """ Tests a beacon information with a bunch of satellites, some of them used in computing a fix. """ bi = base.BeaconInformation() for prn in range(1, 10): satellite = base.Satellite(identifier=prn, **self.satelliteKwargs) bi.seenBeacons.add(satellite) if prn % 2: bi.usedBeacons.add(satellite) self.assertEqual(len(bi.seenBeacons), 9) self.assertEqual(len(bi.usedBeacons), 5) self.assertEqual( repr(bi), "<BeaconInformation (used beacons (5): [" "<Satellite (1), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (3), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (5), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (7), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (9), azimuth: 1, elevation: 1, snr: 1.0>], " "unused beacons: [" "<Satellite (2), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (4), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (6), azimuth: 1, elevation: 1, snr: 1.0>, " "<Satellite (8), azimuth: 1, elevation: 1, snr: 1.0>])>", ) class PositioningBeaconTests(TestCase): """ Tests for L{base.PositioningBeacon}. """ def test_interface(self): """ Tests that L{base.PositioningBeacon} implements L{IPositioningBeacon}. """ implements = IPositioningBeacon.implementedBy(base.PositioningBeacon) self.assertTrue(implements) verify.verifyObject(IPositioningBeacon, base.PositioningBeacon(1)) def test_repr(self): """ Tests the repr of a positioning beacon. """ self.assertEqual(repr(base.PositioningBeacon("A")), "<Beacon (A)>") class SatelliteTests(TestCase): """ Tests for L{twisted.positioning.base.Satellite}. """ def test_minimal(self): """ Tests a minimal satellite that only has a known PRN. Tests that the azimuth, elevation and signal to noise ratios are L{None} and verifies the repr. """ s = base.Satellite(1) self.assertEqual(s.identifier, 1) self.assertIsNone(s.azimuth) self.assertIsNone(s.elevation) self.assertIsNone(s.signalToNoiseRatio) self.assertEqual( repr(s), "<Satellite (1), azimuth: None, " "elevation: None, snr: None>" ) def test_simple(self): """ Tests a minimal satellite that only has a known PRN. Tests that the azimuth, elevation and signal to noise ratios are correct and verifies the repr. """ s = base.Satellite( identifier=1, azimuth=270.0, elevation=30.0, signalToNoiseRatio=25.0 ) self.assertEqual(s.identifier, 1) self.assertEqual(s.azimuth, 270.0) self.assertEqual(s.elevation, 30.0) self.assertEqual(s.signalToNoiseRatio, 25.0) self.assertEqual( repr(s), "<Satellite (1), azimuth: 270.0, " "elevation: 30.0, snr: 25.0>" ) PK Mb�Z�}_�`� `� positioning/test/test_nmea.pynu �[��� # Copyright (c) 2009-2011 Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for using NMEA sentences. """ import datetime from operator import attrgetter from zope.interface import implementer from twisted.positioning import base, ipositioning, nmea from twisted.positioning.base import Angles from twisted.positioning.test.receiver import MockPositioningReceiver from twisted.trial.unittest import TestCase # Sample sentences GPGGA = b"$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47" GPRMC = b"$GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A" GPGSA = b"$GPGSA,A,3,19,28,14,18,27,22,31,39,,,,,1.7,1.0,1.3*34" GPHDT = b"$GPHDT,038.005,T*3B" GPGLL = b"$GPGLL,4916.45,N,12311.12,W,225444,A*31" GPGLL_PARTIAL = b"$GPGLL,3751.65,S,14507.36,E*77" GPGSV_SINGLE = b"$GPGSV,1,1,11,03,03,111,00,04,15,270,00,06,01,010,00,,,,*4b" GPGSV_EMPTY_MIDDLE = b"$GPGSV,1,1,11,03,03,111,00,,,,,,,,,13,06,292,00*75" GPGSV_SEQ = ( GPGSV_FIRST, GPGSV_MIDDLE, GPGSV_LAST, ) = b""" $GPGSV,3,1,11,03,03,111,00,04,15,270,00,06,01,010,00,13,06,292,00*74 $GPGSV,3,2,11,14,25,170,00,16,57,208,39,18,67,296,40,19,40,246,00*74 $GPGSV,3,3,11,22,42,067,42,24,14,311,43,27,05,244,00,,,,*4D """.split() @implementer(ipositioning.INMEAReceiver) class NMEATestReceiver: """ An NMEA receiver for testing. Remembers the last sentence it has received. """ def __init__(self): self.clear() def clear(self): """ Forgets the received sentence (if any), by setting C{self.receivedSentence} to L{None}. """ self.receivedSentence = None def sentenceReceived(self, sentence): self.receivedSentence = sentence class CallbackTests(TestCase): """ Tests if the NMEA protocol correctly calls its sentence callback. @ivar protocol: The NMEA protocol under test. @type protocol: L{nmea.NMEAProtocol} @ivar sentenceTypes: The set of sentence types of all sentences the test's sentence callback function has been called with. @type sentenceTypes: C{set} """ def setUp(self): receiver = NMEATestReceiver() self.protocol = nmea.NMEAProtocol(receiver, self._sentenceCallback) self.sentenceTypes = set() def _sentenceCallback(self, sentence): """ Remembers that a sentence of this type was fired. """ self.sentenceTypes.add(sentence.type) def test_callbacksCalled(self): """ The correct callbacks fire, and that *only* those fire. """ sentencesByType = { "GPGGA": [b"$GPGGA*56"], "GPGLL": [b"$GPGLL*50"], "GPGSA": [b"$GPGSA*42"], "GPGSV": [b"$GPGSV*55"], "GPHDT": [b"$GPHDT*4f"], "GPRMC": [b"$GPRMC*4b"], } for sentenceType, sentences in sentencesByType.items(): for sentence in sentences: self.protocol.lineReceived(sentence) self.assertEqual(self.sentenceTypes, {sentenceType}) self.sentenceTypes.clear() class BrokenSentenceCallbackTests(TestCase): """ Tests for broken NMEA sentence callbacks. """ def setUp(self): receiver = NMEATestReceiver() self.protocol = nmea.NMEAProtocol(receiver, self._sentenceCallback) def _sentenceCallback(self, sentence): """ Raises C{AttributeError}. """ raise AttributeError("ERROR!!!") def test_dontSwallowCallbackExceptions(self): """ An C{AttributeError} in the sentence callback of an C{NMEAProtocol} doesn't get swallowed. """ lineReceived = self.protocol.lineReceived self.assertRaises(AttributeError, lineReceived, b"$GPGGA*56") class SplitTests(TestCase): """ Checks splitting of NMEA sentences. """ def test_withChecksum(self): """ An NMEA sentence with a checksum gets split correctly. """ splitSentence = nmea._split(b"$GPGGA,spam,eggs*00") self.assertEqual(splitSentence, [b"GPGGA", b"spam", b"eggs"]) def test_noCheckum(self): """ An NMEA sentence without a checksum gets split correctly. """ splitSentence = nmea._split(b"$GPGGA,spam,eggs*") self.assertEqual(splitSentence, [b"GPGGA", b"spam", b"eggs"]) class ChecksumTests(TestCase): """ NMEA sentence checksum verification tests. """ def test_valid(self): """ Sentences with valid checksums get validated. """ nmea._validateChecksum(GPGGA) def test_missing(self): """ Sentences with missing checksums get validated. """ nmea._validateChecksum(GPGGA[:-2]) def test_invalid(self): """ Sentences with a bad checksum raise L{base.InvalidChecksum} when attempting to validate them. """ validate = nmea._validateChecksum bareSentence, checksum = GPGGA.split(b"*") badChecksum = b"%d" % (int(checksum, 16) + 1,) sentences = [bareSentence + b"*" + badChecksum] for s in sentences: self.assertRaises(base.InvalidChecksum, validate, s) class NMEAReceiverSetup: """ A mixin for tests that need an NMEA receiver (and a protocol attached to it). @ivar receiver: An NMEA receiver that remembers the last sentence. @type receiver: L{NMEATestReceiver} @ivar protocol: An NMEA protocol attached to the receiver. @type protocol: L{twisted.positioning.nmea.NMEAProtocol} """ def setUp(self): """ Sets up an NMEA receiver. """ self.receiver = NMEATestReceiver() self.protocol = nmea.NMEAProtocol(self.receiver) class GSVSequenceTests(NMEAReceiverSetup, TestCase): """ Tests for the interpretation of GSV sequences. """ def test_firstSentence(self): """ The first sentence in a GSV sequence is correctly identified. """ self.protocol.lineReceived(GPGSV_FIRST) sentence = self.receiver.receivedSentence self.assertTrue(sentence._isFirstGSVSentence()) self.assertFalse(sentence._isLastGSVSentence()) def test_middleSentence(self): """ A sentence in the middle of a GSV sequence is correctly identified (as being neither the last nor the first). """ self.protocol.lineReceived(GPGSV_MIDDLE) sentence = self.receiver.receivedSentence self.assertFalse(sentence._isFirstGSVSentence()) self.assertFalse(sentence._isLastGSVSentence()) def test_lastSentence(self): """ The last sentence in a GSV sequence is correctly identified. """ self.protocol.lineReceived(GPGSV_LAST) sentence = self.receiver.receivedSentence self.assertFalse(sentence._isFirstGSVSentence()) self.assertTrue(sentence._isLastGSVSentence()) class BogusSentenceTests(NMEAReceiverSetup, TestCase): """ Tests for verifying predictable failure for bogus NMEA sentences. """ def assertRaisesOnSentence(self, exceptionClass, sentence): """ Asserts that the protocol raises C{exceptionClass} when it receives C{sentence}. @param exceptionClass: The exception class expected to be raised. @type exceptionClass: C{Exception} subclass @param sentence: The (bogus) NMEA sentence. @type sentence: C{str} """ self.assertRaises(exceptionClass, self.protocol.lineReceived, sentence) def test_raiseOnUnknownSentenceType(self): """ Receiving a well-formed sentence of unknown type raises C{ValueError}. """ self.assertRaisesOnSentence(ValueError, b"$GPBOGUS*5b") def test_raiseOnMalformedSentences(self): """ Receiving a malformed sentence raises L{base.InvalidSentence}. """ self.assertRaisesOnSentence(base.InvalidSentence, "GPBOGUS") class NMEASentenceTests(NMEAReceiverSetup, TestCase): """ Tests for L{nmea.NMEASentence} objects. """ def test_repr(self): """ The C{repr} of L{nmea.NMEASentence} objects is correct. """ sentencesWithExpectedRepr = [ ( GPGSA, "<NMEASentence (GPGSA) {" "dataMode: A, " "fixType: 3, " "horizontalDilutionOfPrecision: 1.0, " "positionDilutionOfPrecision: 1.7, " "usedSatellitePRN_0: 19, " "usedSatellitePRN_1: 28, " "usedSatellitePRN_2: 14, " "usedSatellitePRN_3: 18, " "usedSatellitePRN_4: 27, " "usedSatellitePRN_5: 22, " "usedSatellitePRN_6: 31, " "usedSatellitePRN_7: 39, " "verticalDilutionOfPrecision: 1.3" "}>", ), ] for sentence, expectedRepr in sentencesWithExpectedRepr: self.protocol.lineReceived(sentence) received = self.receiver.receivedSentence self.assertEqual(repr(received), expectedRepr) class ParsingTests(NMEAReceiverSetup, TestCase): """ Tests if raw NMEA sentences get parsed correctly. This doesn't really involve any interpretation, just turning ugly raw NMEA representations into objects that are more pleasant to work with. """ def _parserTest(self, sentence, expected): """ Passes a sentence to the protocol and gets the parsed sentence from the receiver. Then verifies that the parsed sentence contains the expected data. """ self.protocol.lineReceived(sentence) received = self.receiver.receivedSentence self.assertEqual(expected, received._sentenceData) def test_fullRMC(self): """ A full RMC sentence is correctly parsed. """ expected = { "type": "GPRMC", "latitudeFloat": "4807.038", "latitudeHemisphere": "N", "longitudeFloat": "01131.000", "longitudeHemisphere": "E", "magneticVariation": "003.1", "magneticVariationDirection": "W", "speedInKnots": "022.4", "timestamp": "123519", "datestamp": "230394", "trueHeading": "084.4", "dataMode": "A", } self._parserTest(GPRMC, expected) def test_fullGGA(self): """ A full GGA sentence is correctly parsed. """ expected = { "type": "GPGGA", "altitude": "545.4", "altitudeUnits": "M", "heightOfGeoidAboveWGS84": "46.9", "heightOfGeoidAboveWGS84Units": "M", "horizontalDilutionOfPrecision": "0.9", "latitudeFloat": "4807.038", "latitudeHemisphere": "N", "longitudeFloat": "01131.000", "longitudeHemisphere": "E", "numberOfSatellitesSeen": "08", "timestamp": "123519", "fixQuality": "1", } self._parserTest(GPGGA, expected) def test_fullGLL(self): """ A full GLL sentence is correctly parsed. """ expected = { "type": "GPGLL", "latitudeFloat": "4916.45", "latitudeHemisphere": "N", "longitudeFloat": "12311.12", "longitudeHemisphere": "W", "timestamp": "225444", "dataMode": "A", } self._parserTest(GPGLL, expected) def test_partialGLL(self): """ A partial GLL sentence is correctly parsed. """ expected = { "type": "GPGLL", "latitudeFloat": "3751.65", "latitudeHemisphere": "S", "longitudeFloat": "14507.36", "longitudeHemisphere": "E", } self._parserTest(GPGLL_PARTIAL, expected) def test_fullGSV(self): """ A full GSV sentence is correctly parsed. """ expected = { "type": "GPGSV", "GSVSentenceIndex": "1", "numberOfGSVSentences": "3", "numberOfSatellitesSeen": "11", "azimuth_0": "111", "azimuth_1": "270", "azimuth_2": "010", "azimuth_3": "292", "elevation_0": "03", "elevation_1": "15", "elevation_2": "01", "elevation_3": "06", "satellitePRN_0": "03", "satellitePRN_1": "04", "satellitePRN_2": "06", "satellitePRN_3": "13", "signalToNoiseRatio_0": "00", "signalToNoiseRatio_1": "00", "signalToNoiseRatio_2": "00", "signalToNoiseRatio_3": "00", } self._parserTest(GPGSV_FIRST, expected) def test_partialGSV(self): """ A partial GSV sentence is correctly parsed. """ expected = { "type": "GPGSV", "GSVSentenceIndex": "3", "numberOfGSVSentences": "3", "numberOfSatellitesSeen": "11", "azimuth_0": "067", "azimuth_1": "311", "azimuth_2": "244", "elevation_0": "42", "elevation_1": "14", "elevation_2": "05", "satellitePRN_0": "22", "satellitePRN_1": "24", "satellitePRN_2": "27", "signalToNoiseRatio_0": "42", "signalToNoiseRatio_1": "43", "signalToNoiseRatio_2": "00", } self._parserTest(GPGSV_LAST, expected) def test_fullHDT(self): """ A full HDT sentence is correctly parsed. """ expected = { "type": "GPHDT", "trueHeading": "038.005", } self._parserTest(GPHDT, expected) def test_typicalGSA(self): """ A typical GSA sentence is correctly parsed. """ expected = { "type": "GPGSA", "dataMode": "A", "fixType": "3", "usedSatellitePRN_0": "19", "usedSatellitePRN_1": "28", "usedSatellitePRN_2": "14", "usedSatellitePRN_3": "18", "usedSatellitePRN_4": "27", "usedSatellitePRN_5": "22", "usedSatellitePRN_6": "31", "usedSatellitePRN_7": "39", "positionDilutionOfPrecision": "1.7", "horizontalDilutionOfPrecision": "1.0", "verticalDilutionOfPrecision": "1.3", } self._parserTest(GPGSA, expected) class FixUnitsTests(TestCase): """ Tests for the generic unit fixing method, L{nmea.NMEAAdapter._fixUnits}. @ivar adapter: The NMEA adapter. @type adapter: L{nmea.NMEAAdapter} """ def setUp(self): self.adapter = nmea.NMEAAdapter(base.BasePositioningReceiver()) def test_noValueKey(self): """ Tests that when no C{valueKey} is provided, C{unitKey} is used, minus C{"Units"} at the end. """ class FakeSentence: """ A fake sentence that just has a "foo" attribute. """ def __init__(self): self.foo = 1 self.adapter.currentSentence = FakeSentence() self.adapter._fixUnits(unitKey="fooUnits", unit="N") self.assertNotEqual(self.adapter._sentenceData["foo"], 1) def test_unitKeyButNoUnit(self): """ Tests that if a unit key is provided but the unit isn't, the unit is automatically determined from the unit key. """ class FakeSentence: """ A fake sentence that just has "foo" and "fooUnits" attributes. """ def __init__(self): self.foo = 1 self.fooUnits = "N" self.adapter.currentSentence = FakeSentence() self.adapter._fixUnits(unitKey="fooUnits") self.assertNotEqual(self.adapter._sentenceData["foo"], 1) def test_noValueKeyAndNoUnitKey(self): """ Tests that when a unit is specified but neither C{valueKey} nor C{unitKey} is provided, C{ValueError} is raised. """ self.assertRaises(ValueError, self.adapter._fixUnits, unit="K") class FixerTestMixin: """ Mixin for tests for the fixers on L{nmea.NMEAAdapter} that adapt from NMEA-specific notations to generic Python objects. @ivar adapter: The NMEA adapter. @type adapter: L{nmea.NMEAAdapter} """ def setUp(self): self.adapter = nmea.NMEAAdapter(base.BasePositioningReceiver()) def _fixerTest(self, sentenceData, expected=None, exceptionClass=None): """ A generic adapter fixer test. Creates a sentence from the C{sentenceData} and sends that to the adapter. If C{exceptionClass} is not passed, this is assumed to work, and C{expected} is compared with the adapter's internal state. Otherwise, passing the sentence to the adapter is checked to raise C{exceptionClass}. @param sentenceData: Raw sentence content. @type sentenceData: C{dict} mapping C{str} to C{str} @param expected: The expected state of the adapter. @type expected: C{dict} or L{None} @param exceptionClass: The exception to be raised by the adapter. @type exceptionClass: subclass of C{Exception} """ sentence = nmea.NMEASentence(sentenceData) def receiveSentence(): self.adapter.sentenceReceived(sentence) if exceptionClass is None: receiveSentence() self.assertEqual(self.adapter._state, expected) else: self.assertRaises(exceptionClass, receiveSentence) self.adapter.clear() class TimestampFixerTests(FixerTestMixin, TestCase): """ Tests conversion from NMEA timestamps to C{datetime.time} objects. """ def test_simple(self): """ A simple timestamp is converted correctly. """ data = {"timestamp": "123456"} # 12:34:56Z expected = {"_time": datetime.time(12, 34, 56)} self._fixerTest(data, expected) def test_broken(self): """ A broken timestamp raises C{ValueError}. """ badTimestamps = "993456", "129956", "123499" for t in badTimestamps: self._fixerTest({"timestamp": t}, exceptionClass=ValueError) class DatestampFixerTests(FixerTestMixin, TestCase): def test_defaultYearThreshold(self): """ The default year threshold is 1980. """ self.assertEqual(self.adapter.yearThreshold, 1980) def test_beforeThreshold(self): """ Dates before the threshold are interpreted as being in the century after the threshold. (Since the threshold is the earliest possible date.) """ datestring, date = "010115", datetime.date(2015, 1, 1) self._fixerTest({"datestamp": datestring}, {"_date": date}) def test_afterThreshold(self): """ Dates after the threshold are interpreted as being in the same century as the threshold. """ datestring, date = "010195", datetime.date(1995, 1, 1) self._fixerTest({"datestamp": datestring}, {"_date": date}) def test_invalidMonth(self): """ A datestring with an invalid month (> 12) raises C{ValueError}. """ self._fixerTest({"datestamp": "011301"}, exceptionClass=ValueError) def test_invalidDay(self): """ A datestring with an invalid day (more days than there are in that month) raises C{ValueError}. """ self._fixerTest({"datestamp": "320101"}, exceptionClass=ValueError) self._fixerTest({"datestamp": "300201"}, exceptionClass=ValueError) def _nmeaFloat(degrees, minutes): """ Builds an NMEA float representation for a given angle in degrees and decimal minutes. @param degrees: The integer degrees for this angle. @type degrees: C{int} @param minutes: The decimal minutes value for this angle. @type minutes: C{float} @return: The NMEA float representation for this angle. @rtype: C{str} """ return "%i%0.3f" % (degrees, minutes) def _coordinateSign(hemisphere): """ Return the sign of a coordinate. This is C{1} if the coordinate is in the northern or eastern hemispheres, C{-1} otherwise. @param hemisphere: NMEA shorthand for the hemisphere. One of "NESW". @type hemisphere: C{str} @return: The sign of the coordinate value. @rtype: C{int} """ return 1 if hemisphere in "NE" else -1 def _coordinateType(hemisphere): """ Return the type of a coordinate. This is L{Angles.LATITUDE} if the coordinate is in the northern or southern hemispheres, L{Angles.LONGITUDE} otherwise. @param hemisphere: NMEA shorthand for the hemisphere. One of "NESW". @type hemisphere: C{str} @return: The type of the coordinate (L{Angles.LATITUDE} or L{Angles.LONGITUDE}) """ return Angles.LATITUDE if hemisphere in "NS" else Angles.LONGITUDE class CoordinateFixerTests(FixerTestMixin, TestCase): """ Tests turning NMEA coordinate notations into something more pleasant. """ def test_north(self): """ NMEA coordinate representations in the northern hemisphere convert correctly. """ sentenceData = {"latitudeFloat": "1030.000", "latitudeHemisphere": "N"} state = {"latitude": base.Coordinate(10.5, Angles.LATITUDE)} self._fixerTest(sentenceData, state) def test_south(self): """ NMEA coordinate representations in the southern hemisphere convert correctly. """ sentenceData = {"latitudeFloat": "1030.000", "latitudeHemisphere": "S"} state = {"latitude": base.Coordinate(-10.5, Angles.LATITUDE)} self._fixerTest(sentenceData, state) def test_east(self): """ NMEA coordinate representations in the eastern hemisphere convert correctly. """ sentenceData = {"longitudeFloat": "1030.000", "longitudeHemisphere": "E"} state = {"longitude": base.Coordinate(10.5, Angles.LONGITUDE)} self._fixerTest(sentenceData, state) def test_west(self): """ NMEA coordinate representations in the western hemisphere convert correctly. """ sentenceData = {"longitudeFloat": "1030.000", "longitudeHemisphere": "W"} state = {"longitude": base.Coordinate(-10.5, Angles.LONGITUDE)} self._fixerTest(sentenceData, state) def test_badHemisphere(self): """ NMEA coordinate representations for nonexistent hemispheres raise C{ValueError} when you attempt to parse them. """ sentenceData = {"longitudeHemisphere": "Q"} self._fixerTest(sentenceData, exceptionClass=ValueError) def test_badHemisphereSign(self): """ NMEA coordinate repesentation parsing fails predictably when you pass nonexistent coordinate types (not latitude or longitude). """ getSign = lambda: self.adapter._getHemisphereSign("BOGUS_VALUE") self.assertRaises(ValueError, getSign) class AltitudeFixerTests(FixerTestMixin, TestCase): """ Tests that NMEA representations of altitudes are correctly converted. """ def test_fixAltitude(self): """ The NMEA representation of an altitude (above mean sea level) is correctly converted. """ key, value = "altitude", "545.4" altitude = base.Altitude(float(value)) self._fixerTest({key: value}, {key: altitude}) def test_heightOfGeoidAboveWGS84(self): """ The NMEA representation of an altitude of the geoid (above the WGS84 reference level) is correctly converted. """ key, value = "heightOfGeoidAboveWGS84", "46.9" altitude = base.Altitude(float(value)) self._fixerTest({key: value}, {key: altitude}) class SpeedFixerTests(FixerTestMixin, TestCase): """ Tests that NMEA representations of speeds are correctly converted. """ def test_speedInKnots(self): """ Speeds reported in knots correctly get converted to meters per second. """ key, value, targetKey = "speedInKnots", "10", "speed" speed = base.Speed(float(value) * base.MPS_PER_KNOT) self._fixerTest({key: value}, {targetKey: speed}) class VariationFixerTests(FixerTestMixin, TestCase): """ Tests if the absolute values of magnetic variations on the heading and their sign get combined correctly, and if that value gets combined with a heading correctly. """ def test_west(self): """ Tests westward (negative) magnetic variation. """ variation, direction = "1.34", "W" heading = base.Heading.fromFloats(variationValue=-1 * float(variation)) sentenceData = { "magneticVariation": variation, "magneticVariationDirection": direction, } self._fixerTest(sentenceData, {"heading": heading}) def test_east(self): """ Tests eastward (positive) magnetic variation. """ variation, direction = "1.34", "E" heading = base.Heading.fromFloats(variationValue=float(variation)) sentenceData = { "magneticVariation": variation, "magneticVariationDirection": direction, } self._fixerTest(sentenceData, {"heading": heading}) def test_withHeading(self): """ Variation values get combined with headings correctly. """ trueHeading, variation, direction = "123.12", "1.34", "E" sentenceData = { "trueHeading": trueHeading, "magneticVariation": variation, "magneticVariationDirection": direction, } heading = base.Heading.fromFloats( float(trueHeading), variationValue=float(variation) ) self._fixerTest(sentenceData, {"heading": heading}) class PositionErrorFixerTests(FixerTestMixin, TestCase): """ Position errors in NMEA are passed as dilutions of precision (DOP). This is a measure relative to some specified value of the GPS device as its "reference" precision. Unfortunately, there are very few ways of figuring this out from just the device (sans manual). There are two basic DOP values: vertical and horizontal. HDOP tells you how precise your location is on the face of the earth (pretending it's flat, at least locally). VDOP tells you how precise your altitude is known. PDOP (position DOP) is a dependent value defined as the Euclidean norm of those two, and gives you a more generic "goodness of fix" value. """ def test_simple(self): self._fixerTest( {"horizontalDilutionOfPrecision": "11"}, {"positionError": base.PositionError(hdop=11.0)}, ) def test_mixing(self): pdop, hdop, vdop = "1", "1", "1" positionError = base.PositionError( pdop=float(pdop), hdop=float(hdop), vdop=float(vdop) ) sentenceData = { "positionDilutionOfPrecision": pdop, "horizontalDilutionOfPrecision": hdop, "verticalDilutionOfPrecision": vdop, } self._fixerTest(sentenceData, {"positionError": positionError}) class ValidFixTests(FixerTestMixin, TestCase): """ Tests that data reported from a valid fix is used. """ def test_GGA(self): """ GGA data with a valid fix is used. """ sentenceData = { "type": "GPGGA", "altitude": "545.4", "fixQuality": nmea.GPGGAFixQualities.GPS_FIX, } expectedState = {"altitude": base.Altitude(545.4)} self._fixerTest(sentenceData, expectedState) def test_GLL(self): """ GLL data with a valid data mode is used. """ sentenceData = { "type": "GPGLL", "altitude": "545.4", "dataMode": nmea.GPGLLGPRMCFixQualities.ACTIVE, } expectedState = {"altitude": base.Altitude(545.4)} self._fixerTest(sentenceData, expectedState) class InvalidFixTests(FixerTestMixin, TestCase): """ Tests that data being reported from a bad or incomplete fix isn't used. Although the specification dictates that GPSes shouldn't produce NMEA sentences with real-looking values for altitude or position in them unless they have at least some semblance of a GPS fix, this is widely ignored. """ def _invalidFixTest(self, sentenceData): """ Sentences with an invalid fix or data mode result in empty state (ie, the data isn't used). """ self._fixerTest(sentenceData, {}) def test_GGA(self): """ GGA sentence data is unused when there is no fix. """ sentenceData = { "type": "GPGGA", "altitude": "545.4", "fixQuality": nmea.GPGGAFixQualities.INVALID_FIX, } self._invalidFixTest(sentenceData) def test_GLL(self): """ GLL sentence data is unused when the data is flagged as void. """ sentenceData = { "type": "GPGLL", "altitude": "545.4", "dataMode": nmea.GPGLLGPRMCFixQualities.VOID, } self._invalidFixTest(sentenceData) def test_badGSADataMode(self): """ GSA sentence data is not used when there is no GPS fix, but the data mode claims the data is "active". Some GPSes do this, unfortunately, and that means you shouldn't use the data. """ sentenceData = { "type": "GPGSA", "altitude": "545.4", "dataMode": nmea.GPGLLGPRMCFixQualities.ACTIVE, "fixType": nmea.GPGSAFixTypes.GSA_NO_FIX, } self._invalidFixTest(sentenceData) def test_badGSAFixType(self): """ GSA sentence data is not used when the fix claims to be valid (albeit only 2D), but the data mode says the data is void. Some GPSes do this, unfortunately, and that means you shouldn't use the data. """ sentenceData = { "type": "GPGSA", "altitude": "545.4", "dataMode": nmea.GPGLLGPRMCFixQualities.VOID, "fixType": nmea.GPGSAFixTypes.GSA_2D_FIX, } self._invalidFixTest(sentenceData) def test_badGSADataModeAndFixType(self): """ GSA sentence data is not use when neither the fix nor the data mode is any good. """ sentenceData = { "type": "GPGSA", "altitude": "545.4", "dataMode": nmea.GPGLLGPRMCFixQualities.VOID, "fixType": nmea.GPGSAFixTypes.GSA_NO_FIX, } self._invalidFixTest(sentenceData) class NMEAReceiverTests(TestCase): """ Tests for the NMEA receiver. """ def setUp(self): self.receiver = MockPositioningReceiver() self.adapter = nmea.NMEAAdapter(self.receiver) self.protocol = nmea.NMEAProtocol(self.adapter) def test_onlyFireWhenCurrentSentenceHasNewInformation(self): """ If the current sentence does not contain any new fields for a particular callback, that callback is not called; even if all necessary information is still in the state from one or more previous messages. """ self.protocol.lineReceived(GPGGA) gpggaCallbacks = { "positionReceived", "positionErrorReceived", "altitudeReceived", } self.assertEqual(set(self.receiver.called.keys()), gpggaCallbacks) self.receiver.clear() self.assertNotEqual(self.adapter._state, {}) # GPHDT contains heading information but not position, # altitude or anything like that; but that information is # still in the state. self.protocol.lineReceived(GPHDT) gphdtCallbacks = {"headingReceived"} self.assertEqual(set(self.receiver.called.keys()), gphdtCallbacks) def _receiverTest(self, sentences, expectedFired=(), extraTest=None): """ A generic test for NMEA receiver behavior. @param sentences: The sequence of sentences to simulate receiving. @type sentences: iterable of C{str} @param expectedFired: The names of the callbacks expected to fire. @type expectedFired: iterable of C{str} @param extraTest: An optional extra test hook. @type extraTest: nullary callable """ for sentence in sentences: self.protocol.lineReceived(sentence) actuallyFired = self.receiver.called.keys() self.assertEqual(set(actuallyFired), set(expectedFired)) if extraTest is not None: extraTest() self.receiver.clear() self.adapter.clear() def test_positionErrorUpdateAcrossStates(self): """ The positioning error is updated across multiple states. """ sentences = [GPGSA] + GPGSV_SEQ callbacksFired = ["positionErrorReceived", "beaconInformationReceived"] def _getIdentifiers(beacons): return sorted(map(attrgetter("identifier"), beacons)) def checkBeaconInformation(): beaconInformation = self.adapter._state["beaconInformation"] seenIdentifiers = _getIdentifiers(beaconInformation.seenBeacons) expected = [3, 4, 6, 13, 14, 16, 18, 19, 22, 24, 27] self.assertEqual(seenIdentifiers, expected) usedIdentifiers = _getIdentifiers(beaconInformation.usedBeacons) # These are not actually all the PRNs in the sample GPGSA: # only the ones also reported by the GPGSV sequence. This # is just because the sample data doesn't come from the # same reporting cycle of a GPS device. self.assertEqual(usedIdentifiers, [14, 18, 19, 22, 27]) self._receiverTest(sentences, callbacksFired, checkBeaconInformation) def test_emptyMiddleGSV(self): """ A GSV sentence with empty entries in any position does not mean that entries in subsequent positions of the same GSV sentence are ignored. """ sentences = [GPGSV_EMPTY_MIDDLE] callbacksFired = ["beaconInformationReceived"] def checkBeaconInformation(): beaconInformation = self.adapter._state["beaconInformation"] seenBeacons = beaconInformation.seenBeacons self.assertEqual(len(seenBeacons), 2) self.assertIn(13, [b.identifier for b in seenBeacons]) self._receiverTest(sentences, callbacksFired, checkBeaconInformation) def test_GGASentences(self): """ A sequence of GGA sentences fires C{positionReceived}, C{positionErrorReceived} and C{altitudeReceived}. """ sentences = [GPGGA] callbacksFired = [ "positionReceived", "positionErrorReceived", "altitudeReceived", ] self._receiverTest(sentences, callbacksFired) def test_GGAWithDateInState(self): """ When receiving a GPGGA sentence and a date was already in the state, the new time (from the GPGGA sentence) is combined with that date. """ self.adapter._state["_date"] = datetime.date(2014, 1, 1) sentences = [GPGGA] callbacksFired = [ "positionReceived", "positionErrorReceived", "altitudeReceived", "timeReceived", ] self._receiverTest(sentences, callbacksFired) def test_RMCSentences(self): """ A sequence of RMC sentences fires C{positionReceived}, C{speedReceived}, C{headingReceived} and C{timeReceived}. """ sentences = [GPRMC] callbacksFired = [ "headingReceived", "speedReceived", "positionReceived", "timeReceived", ] self._receiverTest(sentences, callbacksFired) def test_GSVSentences(self): """ A complete sequence of GSV sentences fires C{beaconInformationReceived}. """ sentences = [GPGSV_FIRST, GPGSV_MIDDLE, GPGSV_LAST] callbacksFired = ["beaconInformationReceived"] def checkPartialInformation(): self.assertNotIn("_partialBeaconInformation", self.adapter._state) self._receiverTest(sentences, callbacksFired, checkPartialInformation) def test_emptyMiddleEntriesGSVSequence(self): """ A complete sequence of GSV sentences with empty entries in the middle still fires C{beaconInformationReceived}. """ sentences = [GPGSV_EMPTY_MIDDLE] self._receiverTest(sentences, ["beaconInformationReceived"]) def test_incompleteGSVSequence(self): """ An incomplete sequence of GSV sentences does not fire any callbacks. """ sentences = [GPGSV_FIRST] self._receiverTest(sentences) def test_singleSentenceGSVSequence(self): """ The parser does not fail badly when the sequence consists of only one sentence (but is otherwise complete). """ sentences = [GPGSV_SINGLE] self._receiverTest(sentences, ["beaconInformationReceived"]) def test_GLLSentences(self): """ GLL sentences fire C{positionReceived}. """ sentences = [GPGLL_PARTIAL, GPGLL] self._receiverTest(sentences, ["positionReceived"]) def test_HDTSentences(self): """ HDT sentences fire C{headingReceived}. """ sentences = [GPHDT] self._receiverTest(sentences, ["headingReceived"]) def test_mixedSentences(self): """ A mix of sentences fires the correct callbacks. """ sentences = [GPRMC, GPGGA] callbacksFired = [ "altitudeReceived", "speedReceived", "positionReceived", "positionErrorReceived", "timeReceived", "headingReceived", ] def checkTime(): expectedDateTime = datetime.datetime(1994, 3, 23, 12, 35, 19) self.assertEqual(self.adapter._state["time"], expectedDateTime) self._receiverTest(sentences, callbacksFired, checkTime) def test_lotsOfMixedSentences(self): """ Sends an entire gamut of sentences and verifies the appropriate callbacks fire. These are more than you'd expect from your average consumer GPS device. They have most of the important information, including beacon information and visibility. """ sentences = [GPGSA] + GPGSV_SEQ + [GPRMC, GPGGA, GPGLL] callbacksFired = [ "headingReceived", "beaconInformationReceived", "speedReceived", "positionReceived", "timeReceived", "altitudeReceived", "positionErrorReceived", ] self._receiverTest(sentences, callbacksFired) PK Mb�Z�v^] ] positioning/test/receiver.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Receivers for use in tests. """ from twisted.positioning import base, ipositioning class MockPositioningReceiver(base.BasePositioningReceiver): """ A mock positioning receiver. Mocks all the L{IPositioningReceiver} methods with stubs that don't do anything but register that they were called. @ivar called: A mapping of names of callbacks that have been called to C{True}. @type called: C{dict} """ def __init__(self): self.clear() for methodName in ipositioning.IPositioningReceiver: self._addCallback(methodName) def clear(self): """ Forget all the methods that have been called on this receiver, by emptying C{self.called}. """ self.called = {} def _addCallback(self, name): """ Adds a callback of the given name, setting C{self.called[name]} to C{True} when called. """ def callback(*a, **kw): self.called[name] = True setattr(self, name, callback) PK Mb�Z�`� Z Z ! positioning/test/test_sentence.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for positioning sentences. """ import itertools from twisted.positioning import _sentence from twisted.trial.unittest import TestCase sentinelValueOne = "someStringValue" sentinelValueTwo = "someOtherStringValue" class DummyProtocol: """ A simple, fake protocol. """ @staticmethod def getSentenceAttributes(): return ["type", sentinelValueOne, sentinelValueTwo] class DummySentence(_sentence._BaseSentence): """ A sentence for L{DummyProtocol}. """ ALLOWED_ATTRIBUTES = DummyProtocol.getSentenceAttributes() class MixinProtocol(_sentence._PositioningSentenceProducerMixin): """ A simple, fake protocol that declaratively tells you the sentences it produces using L{base.PositioningSentenceProducerMixin}. """ _SENTENCE_CONTENTS = { None: [ sentinelValueOne, sentinelValueTwo, None, # See MixinTests.test_noNoneInSentenceAttributes ], } class MixinSentence(_sentence._BaseSentence): """ A sentence for L{MixinProtocol}. """ ALLOWED_ATTRIBUTES = MixinProtocol.getSentenceAttributes() class SentenceTestsMixin: """ Tests for positioning protocols and their respective sentences. """ def test_attributeAccess(self): """ A sentence attribute gets the correct value, and accessing an unset attribute (which is specified as being a valid sentence attribute) gets L{None}. """ thisSentinel = object() sentence = self.sentenceClass({sentinelValueOne: thisSentinel}) self.assertEqual(getattr(sentence, sentinelValueOne), thisSentinel) self.assertIsNone(getattr(sentence, sentinelValueTwo)) def test_raiseOnMissingAttributeAccess(self): """ Accessing a nonexistent attribute raises C{AttributeError}. """ sentence = self.sentenceClass({}) self.assertRaises(AttributeError, getattr, sentence, "BOGUS") def test_raiseOnBadAttributeAccess(self): """ Accessing bogus attributes raises C{AttributeError}, *even* when that attribute actually is in the sentence data. """ sentence = self.sentenceClass({"BOGUS": None}) self.assertRaises(AttributeError, getattr, sentence, "BOGUS") sentenceType = "tummies" reprTemplate = "<%s (%s) {%s}>" def _expectedRepr(self, sentenceType="unknown type", dataRepr=""): """ Builds the expected repr for a sentence. @param sentenceType: The name of the sentence type (e.g "GPGGA"). @type sentenceType: C{str} @param dataRepr: The repr of the data in the sentence. @type dataRepr: C{str} @return: The expected repr of the sentence. @rtype: C{str} """ clsName = self.sentenceClass.__name__ return self.reprTemplate % (clsName, sentenceType, dataRepr) def test_unknownTypeRepr(self): """ Test the repr of an empty sentence of unknown type. """ sentence = self.sentenceClass({}) expectedRepr = self._expectedRepr() self.assertEqual(repr(sentence), expectedRepr) def test_knownTypeRepr(self): """ Test the repr of an empty sentence of known type. """ sentence = self.sentenceClass({"type": self.sentenceType}) expectedRepr = self._expectedRepr(self.sentenceType) self.assertEqual(repr(sentence), expectedRepr) class MixinTests(TestCase, SentenceTestsMixin): """ Tests for protocols deriving from L{base.PositioningSentenceProducerMixin} and their sentences. """ def setUp(self): self.protocol = MixinProtocol() self.sentenceClass = MixinSentence def test_noNoneInSentenceAttributes(self): """ L{None} does not appear in the sentence attributes of the protocol, even though it's in the specification. This is because L{None} is a placeholder for parts of the sentence you don't really need or want, but there are some bits later on in the sentence that you do want. The alternative would be to have to specify things like "_UNUSED0", "_UNUSED1"... which would end up cluttering the sentence data and eventually adapter state. """ sentenceAttributes = self.protocol.getSentenceAttributes() self.assertNotIn(None, sentenceAttributes) sentenceContents = self.protocol._SENTENCE_CONTENTS sentenceSpecAttributes = itertools.chain(*sentenceContents.values()) self.assertIn(None, sentenceSpecAttributes) PK Mb�Z��} } positioning/test/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for the Twisted positioning framework. """ PK Mb�ZSf��p p positioning/_sentence.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Generic sentence handling tools: hopefully reusable. """ from typing import Set class _BaseSentence: """ A base sentence class for a particular protocol. Using this base class, specific sentence classes can almost automatically be created for a particular protocol. To do this, fill the ALLOWED_ATTRIBUTES class attribute using the C{getSentenceAttributes} class method of the producer:: class FooSentence(BaseSentence): \"\"\" A sentence for integalactic transmodulator sentences. @ivar transmogrificationConstant: The value used in the transmogrifier while producing this sentence, corrected for gravitational fields. @type transmogrificationConstant: C{Tummy} \"\"\" ALLOWED_ATTRIBUTES = FooProtocol.getSentenceAttributes() @ivar presentAttributes: An iterable containing the names of the attributes that are present in this sentence. @type presentAttributes: iterable of C{str} @cvar ALLOWED_ATTRIBUTES: A set of attributes that are allowed in this sentence. @type ALLOWED_ATTRIBUTES: C{set} of C{str} """ ALLOWED_ATTRIBUTES: Set[str] = set() def __init__(self, sentenceData): """ Initializes a sentence with parsed sentence data. @param sentenceData: The parsed sentence data. @type sentenceData: C{dict} (C{str} -> C{str} or L{None}) """ self._sentenceData = sentenceData @property def presentAttributes(self): """ An iterable containing the names of the attributes that are present in this sentence. @return: The iterable of names of present attributes. @rtype: iterable of C{str} """ return iter(self._sentenceData) def __getattr__(self, name): """ Gets an attribute of this sentence. """ if name in self.ALLOWED_ATTRIBUTES: return self._sentenceData.get(name, None) else: className = self.__class__.__name__ msg = f"{className} sentences have no {name} attributes" raise AttributeError(msg) def __repr__(self) -> str: """ Returns a textual representation of this sentence. @return: A textual representation of this sentence. @rtype: C{str} """ items = self._sentenceData.items() data = [f"{k}: {v}" for k, v in sorted(items) if k != "type"] dataRepr = ", ".join(data) typeRepr = self._sentenceData.get("type") or "unknown type" className = self.__class__.__name__ return f"<{className} ({typeRepr}) {{{dataRepr}}}>" class _PositioningSentenceProducerMixin: """ A mixin for certain protocols that produce positioning sentences. This mixin helps protocols that store the layout of sentences that they consume in a C{_SENTENCE_CONTENTS} class variable provide all sentence attributes that can ever occur. It does this by providing a class method, C{getSentenceAttributes}, which iterates over all sentence types and collects the possible sentence attributes. """ @classmethod def getSentenceAttributes(cls): """ Returns a set of all attributes that might be found in the sentences produced by this protocol. This is basically a set of all the attributes of all the sentences that this protocol can produce. @return: The set of all possible sentence attribute names. @rtype: C{set} of C{str} """ attributes = {"type"} for attributeList in cls._SENTENCE_CONTENTS.values(): for attribute in attributeList: if attribute is None: continue attributes.add(attribute) return attributes PK Mb�Z) �n� n� positioning/nmea.pynu �[��� # -*- test-case-name: twisted.positioning.test.test_nmea -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Classes for working with NMEA 0183 sentence producing devices. This standard is generally just called "NMEA", which is actually the name of the body that produces the standard, not the standard itself.. For more information, read the blog post on NMEA by ESR (the gpsd maintainer) at U{http://esr.ibiblio.org/?p=801}. Unfortunately, official specifications on NMEA 0183 are only available at a cost. More information can be found on the Wikipedia page: U{https://en.wikipedia.org/wiki/NMEA_0183}. The official standard may be obtained through the NMEA's website: U{http://www.nmea.org/content/nmea_standards/nmea_0183_v_410.asp}. @since: 14.0 """ import datetime import operator from functools import reduce from zope.interface import implementer from constantly import ValueConstant, Values # type: ignore[import] from twisted.positioning import _sentence, base, ipositioning from twisted.positioning.base import Angles from twisted.protocols.basic import LineReceiver from twisted.python.compat import iterbytes, nativeString class GPGGAFixQualities(Values): """ The possible fix quality indications for GPGGA sentences. @cvar INVALID_FIX: The fix is invalid. @cvar GPS_FIX: There is a fix, acquired using GPS. @cvar DGPS_FIX: There is a fix, acquired using differential GPS (DGPS). @cvar PPS_FIX: There is a fix, acquired using the precise positioning service (PPS). @cvar RTK_FIX: There is a fix, acquired using fixed real-time kinematics. This means that there was a sufficient number of shared satellites with the base station, usually yielding a resolution in the centimeter range. This was added in NMEA 0183 version 3.0. This is also called Carrier-Phase Enhancement or CPGPS, particularly when used in combination with GPS. @cvar FLOAT_RTK_FIX: There is a fix, acquired using floating real-time kinematics. The same comments apply as for a fixed real-time kinematics fix, except that there were insufficient shared satellites to acquire it, so instead you got a slightly less good floating fix. Typical resolution in the decimeter range. @cvar DEAD_RECKONING: There is currently no more fix, but this data was computed using a previous fix and some information about motion (either from that fix or from other sources) using simple dead reckoning. Not particularly reliable, but better-than-nonsense data. @cvar MANUAL: There is no real fix from this device, but the location has been manually entered, presumably with data obtained from some other positioning method. @cvar SIMULATED: There is no real fix, but instead it is being simulated. """ INVALID_FIX = "0" GPS_FIX = "1" DGPS_FIX = "2" PPS_FIX = "3" RTK_FIX = "4" FLOAT_RTK_FIX = "5" DEAD_RECKONING = "6" MANUAL = "7" SIMULATED = "8" class GPGLLGPRMCFixQualities(Values): """ The possible fix quality indications in GPGLL and GPRMC sentences. Unfortunately, these sentences only indicate whether data is good or void. They provide no other information, such as what went wrong if the data is void, or how good the data is if the data is not void. @cvar ACTIVE: The data is okay. @cvar VOID: The data is void, and should not be used. """ ACTIVE = ValueConstant("A") VOID = ValueConstant("V") class GPGSAFixTypes(Values): """ The possible fix types of a GPGSA sentence. @cvar GSA_NO_FIX: The sentence reports no fix at all. @cvar GSA_2D_FIX: The sentence reports a 2D fix: position but no altitude. @cvar GSA_3D_FIX: The sentence reports a 3D fix: position with altitude. """ GSA_NO_FIX = ValueConstant("1") GSA_2D_FIX = ValueConstant("2") GSA_3D_FIX = ValueConstant("3") def _split(sentence): """ Returns the split version of an NMEA sentence, minus header and checksum. >>> _split(b"$GPGGA,spam,eggs*00") [b'GPGGA', b'spam', b'eggs'] @param sentence: The NMEA sentence to split. @type sentence: C{bytes} """ if sentence[-3:-2] == b"*": # Sentence with checksum return sentence[1:-3].split(b",") elif sentence[-1:] == b"*": # Sentence without checksum return sentence[1:-1].split(b",") else: raise base.InvalidSentence(f"malformed sentence {sentence}") def _validateChecksum(sentence): """ Validates the checksum of an NMEA sentence. @param sentence: The NMEA sentence to check the checksum of. @type sentence: C{bytes} @raise ValueError: If the sentence has an invalid checksum. Simply returns on sentences that either don't have a checksum, or have a valid checksum. """ if sentence[-3:-2] == b"*": # Sentence has a checksum reference, source = int(sentence[-2:], 16), sentence[1:-3] computed = reduce(operator.xor, [ord(x) for x in iterbytes(source)]) if computed != reference: raise base.InvalidChecksum(f"{computed:02x} != {reference:02x}") class NMEAProtocol(LineReceiver, _sentence._PositioningSentenceProducerMixin): """ A protocol that parses and verifies the checksum of an NMEA sentence (in string form, not L{NMEASentence}), and delegates to a receiver. It receives lines and verifies these lines are NMEA sentences. If they are, verifies their checksum and unpacks them into their components. It then wraps them in L{NMEASentence} objects and calls the appropriate receiver method with them. @cvar _SENTENCE_CONTENTS: Has the field names in an NMEA sentence for each sentence type (in order, obviously). @type _SENTENCE_CONTENTS: C{dict} of bytestrings to C{list}s of C{str} @param receiver: A receiver for NMEAProtocol sentence objects. @type receiver: L{INMEAReceiver} @param sentenceCallback: A function that will be called with a new L{NMEASentence} when it is created. Useful for massaging data from particularly misbehaving NMEA receivers. @type sentenceCallback: unary callable """ def __init__(self, receiver, sentenceCallback=None): """ Initializes an NMEAProtocol. @param receiver: A receiver for NMEAProtocol sentence objects. @type receiver: L{INMEAReceiver} @param sentenceCallback: A function that will be called with a new L{NMEASentence} when it is created. Useful for massaging data from particularly misbehaving NMEA receivers. @type sentenceCallback: unary callable """ self._receiver = receiver self._sentenceCallback = sentenceCallback def lineReceived(self, rawSentence): """ Parses the data from the sentence and validates the checksum. @param rawSentence: The NMEA positioning sentence. @type rawSentence: C{bytes} """ sentence = rawSentence.strip() _validateChecksum(sentence) splitSentence = _split(sentence) sentenceType = nativeString(splitSentence[0]) contents = [nativeString(x) for x in splitSentence[1:]] try: keys = self._SENTENCE_CONTENTS[sentenceType] except KeyError: raise ValueError("unknown sentence type %s" % sentenceType) sentenceData = {"type": sentenceType} for key, value in zip(keys, contents): if key is not None and value != "": sentenceData[key] = value sentence = NMEASentence(sentenceData) if self._sentenceCallback is not None: self._sentenceCallback(sentence) self._receiver.sentenceReceived(sentence) _SENTENCE_CONTENTS = { "GPGGA": [ "timestamp", "latitudeFloat", "latitudeHemisphere", "longitudeFloat", "longitudeHemisphere", "fixQuality", "numberOfSatellitesSeen", "horizontalDilutionOfPrecision", "altitude", "altitudeUnits", "heightOfGeoidAboveWGS84", "heightOfGeoidAboveWGS84Units", # The next parts are DGPS information, currently unused. None, # Time since last DGPS update None, # DGPS reference source id ], "GPRMC": [ "timestamp", "dataMode", "latitudeFloat", "latitudeHemisphere", "longitudeFloat", "longitudeHemisphere", "speedInKnots", "trueHeading", "datestamp", "magneticVariation", "magneticVariationDirection", ], "GPGSV": [ "numberOfGSVSentences", "GSVSentenceIndex", "numberOfSatellitesSeen", "satellitePRN_0", "elevation_0", "azimuth_0", "signalToNoiseRatio_0", "satellitePRN_1", "elevation_1", "azimuth_1", "signalToNoiseRatio_1", "satellitePRN_2", "elevation_2", "azimuth_2", "signalToNoiseRatio_2", "satellitePRN_3", "elevation_3", "azimuth_3", "signalToNoiseRatio_3", ], "GPGLL": [ "latitudeFloat", "latitudeHemisphere", "longitudeFloat", "longitudeHemisphere", "timestamp", "dataMode", ], "GPHDT": [ "trueHeading", ], "GPTRF": [ "datestamp", "timestamp", "latitudeFloat", "latitudeHemisphere", "longitudeFloat", "longitudeHemisphere", "elevation", "numberOfIterations", # Unused "numberOfDopplerIntervals", # Unused "updateDistanceInNauticalMiles", # Unused "satellitePRN", ], "GPGSA": [ "dataMode", "fixType", "usedSatellitePRN_0", "usedSatellitePRN_1", "usedSatellitePRN_2", "usedSatellitePRN_3", "usedSatellitePRN_4", "usedSatellitePRN_5", "usedSatellitePRN_6", "usedSatellitePRN_7", "usedSatellitePRN_8", "usedSatellitePRN_9", "usedSatellitePRN_10", "usedSatellitePRN_11", "positionDilutionOfPrecision", "horizontalDilutionOfPrecision", "verticalDilutionOfPrecision", ], } class NMEASentence(_sentence._BaseSentence): """ An object representing an NMEA sentence. The attributes of this objects are raw NMEA protocol data, which are all ASCII bytestrings. This object contains all the raw NMEA protocol data in a single sentence. Not all of these necessarily have to be present in the sentence. Missing attributes are L{None} when accessed. @ivar type: The sentence type (C{"GPGGA"}, C{"GPGSV"}...). @ivar numberOfGSVSentences: The total number of GSV sentences in a sequence. @ivar GSVSentenceIndex: The index of this GSV sentence in the GSV sequence. @ivar timestamp: A timestamp. (C{"123456"} -> 12:34:56Z) @ivar datestamp: A datestamp. (C{"230394"} -> 23 Mar 1994) @ivar latitudeFloat: Latitude value. (for example: C{"1234.567"} -> 12 degrees, 34.567 minutes). @ivar latitudeHemisphere: Latitudinal hemisphere (C{"N"} or C{"S"}). @ivar longitudeFloat: Longitude value. See C{latitudeFloat} for an example. @ivar longitudeHemisphere: Longitudinal hemisphere (C{"E"} or C{"W"}). @ivar altitude: The altitude above mean sea level. @ivar altitudeUnits: Units in which altitude is expressed. (Always C{"M"} for meters.) @ivar heightOfGeoidAboveWGS84: The local height of the geoid above the WGS84 ellipsoid model. @ivar heightOfGeoidAboveWGS84Units: The units in which the height above the geoid is expressed. (Always C{"M"} for meters.) @ivar trueHeading: The true heading. @ivar magneticVariation: The magnetic variation. @ivar magneticVariationDirection: The direction of the magnetic variation. One of C{"E"} or C{"W"}. @ivar speedInKnots: The ground speed, expressed in knots. @ivar fixQuality: The quality of the fix. @type fixQuality: One of L{GPGGAFixQualities}. @ivar dataMode: Signals if the data is usable or not. @type dataMode: One of L{GPGLLGPRMCFixQualities}. @ivar numberOfSatellitesSeen: The number of satellites seen by the receiver. @ivar numberOfSatellitesUsed: The number of satellites used in computing the fix. @ivar horizontalDilutionOfPrecision: The dilution of the precision of the position on a plane tangential to the geoid. (HDOP) @ivar verticalDilutionOfPrecision: As C{horizontalDilutionOfPrecision}, but for a position on a plane perpendicular to the geoid. (VDOP) @ivar positionDilutionOfPrecision: Euclidean norm of HDOP and VDOP. @ivar satellitePRN: The unique identifcation number of a particular satellite. Optionally suffixed with C{_N} if multiple satellites are referenced in a sentence, where C{N in range(4)}. @ivar elevation: The elevation of a satellite in decimal degrees. Optionally suffixed with C{_N}, as with C{satellitePRN}. @ivar azimuth: The azimuth of a satellite in decimal degrees. Optionally suffixed with C{_N}, as with C{satellitePRN}. @ivar signalToNoiseRatio: The SNR of a satellite signal, in decibels. Optionally suffixed with C{_N}, as with C{satellitePRN}. @ivar usedSatellitePRN_N: Where C{int(N) in range(12)}. The PRN of a satellite used in computing the fix. """ ALLOWED_ATTRIBUTES = NMEAProtocol.getSentenceAttributes() def _isFirstGSVSentence(self): """ Tests if this current GSV sentence is the first one in a sequence. @return: C{True} if this is the first GSV sentence. @rtype: C{bool} """ return self.GSVSentenceIndex == "1" def _isLastGSVSentence(self): """ Tests if this current GSV sentence is the final one in a sequence. @return: C{True} if this is the last GSV sentence. @rtype: C{bool} """ return self.GSVSentenceIndex == self.numberOfGSVSentences @implementer(ipositioning.INMEAReceiver) class NMEAAdapter: """ An adapter from NMEAProtocol receivers to positioning receivers. @cvar _STATEFUL_UPDATE: Information on how to update partial information in the sentence data or internal adapter state. For more information, see C{_statefulUpdate}'s docstring. @type _STATEFUL_UPDATE: See C{_statefulUpdate}'s docstring @cvar _ACCEPTABLE_UNITS: A set of NMEA notations of units that are already acceptable (metric), and therefore don't need to be converted. @type _ACCEPTABLE_UNITS: C{frozenset} of bytestrings @cvar _UNIT_CONVERTERS: Mapping of NMEA notations of units that are not acceptable (not metric) to converters that take a quantity in that unit and produce a metric quantity. @type _UNIT_CONVERTERS: C{dict} of bytestrings to unary callables @cvar _SPECIFIC_SENTENCE_FIXES: A mapping of sentece types to specific fixes that are required to extract useful information from data from those sentences. @type _SPECIFIC_SENTENCE_FIXES: C{dict} of sentence types to callables that take self and modify it in-place @cvar _FIXERS: Set of unary callables that take an NMEAAdapter instance and extract useful data from the sentence data, usually modifying the adapter's sentence data in-place. @type _FIXERS: C{dict} of native strings to unary callables @ivar yearThreshold: The earliest possible year that data will be interpreted as. For example, if this value is C{1990}, an NMEA 0183 two-digit year of "96" will be interpreted as 1996, and a two-digit year of "13" will be interpreted as 2013. @type yearThreshold: L{int} @ivar _state: The current internal state of the receiver. @type _state: C{dict} @ivar _sentenceData: The data present in the sentence currently being processed. Starts empty, is filled as the sentence is parsed. @type _sentenceData: C{dict} @ivar _receiver: The positioning receiver that will receive parsed data. @type _receiver: L{ipositioning.IPositioningReceiver} """ def __init__(self, receiver): """ Initializes a new NMEA adapter. @param receiver: The receiver for positioning sentences. @type receiver: L{ipositioning.IPositioningReceiver} """ self._state = {} self._sentenceData = {} self._receiver = receiver def _fixTimestamp(self): """ Turns the NMEAProtocol timestamp notation into a datetime.time object. The time in this object is expressed as Zulu time. """ timestamp = self.currentSentence.timestamp.split(".")[0] timeObject = datetime.datetime.strptime(timestamp, "%H%M%S").time() self._sentenceData["_time"] = timeObject yearThreshold = 1980 def _fixDatestamp(self): """ Turns an NMEA datestamp format into a C{datetime.date} object. @raise ValueError: When the day or month value was invalid, e.g. 32nd day, or 13th month, or 0th day or month. """ date = self.currentSentence.datestamp day, month, year = map(int, [date[0:2], date[2:4], date[4:6]]) year += self.yearThreshold - (self.yearThreshold % 100) if year < self.yearThreshold: year += 100 self._sentenceData["_date"] = datetime.date(year, month, day) def _fixCoordinateFloat(self, coordinateType): """ Turns the NMEAProtocol coordinate format into Python float. @param coordinateType: The coordinate type. @type coordinateType: One of L{Angles.LATITUDE} or L{Angles.LONGITUDE}. """ if coordinateType is Angles.LATITUDE: coordinateName = "latitude" else: # coordinateType is Angles.LONGITUDE coordinateName = "longitude" nmeaCoordinate = getattr(self.currentSentence, coordinateName + "Float") left, right = nmeaCoordinate.split(".") degrees, minutes = int(left[:-2]), float(f"{left[-2:]}.{right}") angle = degrees + minutes / 60 coordinate = base.Coordinate(angle, coordinateType) self._sentenceData[coordinateName] = coordinate def _fixHemisphereSign(self, coordinateType, sentenceDataKey=None): """ Fixes the sign for a hemisphere. This method must be called after the magnitude for the thing it determines the sign of has been set. This is done by the following functions: - C{self.FIXERS['magneticVariation']} - C{self.FIXERS['latitudeFloat']} - C{self.FIXERS['longitudeFloat']} @param coordinateType: Coordinate type. One of L{Angles.LATITUDE}, L{Angles.LONGITUDE} or L{Angles.VARIATION}. @param sentenceDataKey: The key name of the hemisphere sign being fixed in the sentence data. If unspecified, C{coordinateType} is used. @type sentenceDataKey: C{str} (unless L{None}) """ sentenceDataKey = sentenceDataKey or coordinateType sign = self._getHemisphereSign(coordinateType) self._sentenceData[sentenceDataKey].setSign(sign) def _getHemisphereSign(self, coordinateType): """ Returns the hemisphere sign for a given coordinate type. @param coordinateType: The coordinate type to find the hemisphere for. @type coordinateType: L{Angles.LATITUDE}, L{Angles.LONGITUDE} or L{Angles.VARIATION}. @return: The sign of that hemisphere (-1 or 1). @rtype: C{int} """ if coordinateType is Angles.LATITUDE: hemisphereKey = "latitudeHemisphere" elif coordinateType is Angles.LONGITUDE: hemisphereKey = "longitudeHemisphere" elif coordinateType is Angles.VARIATION: hemisphereKey = "magneticVariationDirection" else: raise ValueError(f"unknown coordinate type {coordinateType}") hemisphere = getattr(self.currentSentence, hemisphereKey).upper() if hemisphere in "NE": return 1 elif hemisphere in "SW": return -1 else: raise ValueError(f"bad hemisphere/direction: {hemisphere}") def _convert(self, key, converter): """ A simple conversion fix. @param key: The attribute name of the value to fix. @type key: native string (Python identifier) @param converter: The function that converts the value. @type converter: unary callable """ currentValue = getattr(self.currentSentence, key) self._sentenceData[key] = converter(currentValue) _STATEFUL_UPDATE = { # sentenceKey: (stateKey, factory, attributeName, converter), "trueHeading": ("heading", base.Heading, "_angle", float), "magneticVariation": ( "heading", base.Heading, "variation", lambda angle: base.Angle(float(angle), Angles.VARIATION), ), "horizontalDilutionOfPrecision": ( "positionError", base.PositionError, "hdop", float, ), "verticalDilutionOfPrecision": ( "positionError", base.PositionError, "vdop", float, ), "positionDilutionOfPrecision": ( "positionError", base.PositionError, "pdop", float, ), } def _statefulUpdate(self, sentenceKey): """ Does a stateful update of a particular positioning attribute. Specifically, this will mutate an object in the current sentence data. Using the C{sentenceKey}, this will get a tuple containing, in order, the key name in the current state and sentence data, a factory for new values, the attribute to update, and a converter from sentence data (in NMEA notation) to something useful. If the sentence data doesn't have this data yet, it is grabbed from the state. If that doesn't have anything useful yet either, the factory is called to produce a new, empty object. Either way, the object ends up in the sentence data. @param sentenceKey: The name of the key in the sentence attributes, C{NMEAAdapter._STATEFUL_UPDATE} dictionary and the adapter state. @type sentenceKey: C{str} """ key, factory, attr, converter = self._STATEFUL_UPDATE[sentenceKey] if key not in self._sentenceData: try: self._sentenceData[key] = self._state[key] except KeyError: # state does not have this partial data yet self._sentenceData[key] = factory() newValue = converter(getattr(self.currentSentence, sentenceKey)) setattr(self._sentenceData[key], attr, newValue) _ACCEPTABLE_UNITS = frozenset(["M"]) _UNIT_CONVERTERS = { "N": lambda inKnots: base.Speed(float(inKnots) * base.MPS_PER_KNOT), "K": lambda inKPH: base.Speed(float(inKPH) * base.MPS_PER_KPH), } def _fixUnits(self, unitKey=None, valueKey=None, sourceKey=None, unit=None): """ Fixes the units of a certain value. If the units are already acceptable (metric), does nothing. None of the keys are allowed to be the empty string. @param unit: The unit that is being converted I{from}. If unspecified or L{None}, asks the current sentence for the C{unitKey}. If that also fails, raises C{AttributeError}. @type unit: C{str} @param unitKey: The name of the key/attribute under which the unit can be found in the current sentence. If the C{unit} parameter is set, this parameter is not used. @type unitKey: C{str} @param sourceKey: The name of the key/attribute that contains the current value to be converted (expressed in units as defined according to the C{unit} parameter). If unset, will use the same key as the value key. @type sourceKey: C{str} @param valueKey: The key name in which the data will be stored in the C{_sentenceData} instance attribute. If unset, attempts to remove "Units" from the end of the C{unitKey} parameter. If that fails, raises C{ValueError}. @type valueKey: C{str} """ if unit is None: unit = getattr(self.currentSentence, unitKey) if valueKey is None: if unitKey is not None and unitKey.endswith("Units"): valueKey = unitKey[:-5] else: raise ValueError("valueKey unspecified and couldn't be guessed") if sourceKey is None: sourceKey = valueKey if unit not in self._ACCEPTABLE_UNITS: converter = self._UNIT_CONVERTERS[unit] currentValue = getattr(self.currentSentence, sourceKey) self._sentenceData[valueKey] = converter(currentValue) def _fixGSV(self): """ Parses partial visible satellite information from a GSV sentence. """ # To anyone who knows NMEA, this method's name should raise a chuckle's # worth of schadenfreude. 'Fix' GSV? Hah! Ludicrous. beaconInformation = base.BeaconInformation() self._sentenceData["_partialBeaconInformation"] = beaconInformation keys = "satellitePRN", "azimuth", "elevation", "signalToNoiseRatio" for index in range(4): prn, azimuth, elevation, snr = ( getattr(self.currentSentence, attr) for attr in ("%s_%i" % (key, index) for key in keys) ) if prn is None or snr is None: # The peephole optimizer optimizes the jump away, meaning that # coverage.py thinks it isn't covered. It is. Replace it with # break, and watch the test case fail. # ML thread about this issue: http://goo.gl/1KNUi # Related CPython bug: http://bugs.python.org/issue2506 continue satellite = base.Satellite(prn, azimuth, elevation, snr) beaconInformation.seenBeacons.add(satellite) def _fixGSA(self): """ Extracts the information regarding which satellites were used in obtaining the GPS fix from a GSA sentence. Precondition: A GSA sentence was fired. Postcondition: The current sentence data (C{self._sentenceData} will contain a set of the currently used PRNs (under the key C{_usedPRNs}. """ self._sentenceData["_usedPRNs"] = set() for key in ("usedSatellitePRN_%d" % (x,) for x in range(12)): prn = getattr(self.currentSentence, key, None) if prn is not None: self._sentenceData["_usedPRNs"].add(int(prn)) _SPECIFIC_SENTENCE_FIXES = { "GPGSV": _fixGSV, "GPGSA": _fixGSA, } def _sentenceSpecificFix(self): """ Executes a fix for a specific type of sentence. """ fixer = self._SPECIFIC_SENTENCE_FIXES.get(self.currentSentence.type) if fixer is not None: fixer(self) _FIXERS = { "type": lambda self: self._sentenceSpecificFix(), "timestamp": lambda self: self._fixTimestamp(), "datestamp": lambda self: self._fixDatestamp(), "latitudeFloat": lambda self: self._fixCoordinateFloat(Angles.LATITUDE), "latitudeHemisphere": lambda self: self._fixHemisphereSign( Angles.LATITUDE, "latitude" ), "longitudeFloat": lambda self: self._fixCoordinateFloat(Angles.LONGITUDE), "longitudeHemisphere": lambda self: self._fixHemisphereSign( Angles.LONGITUDE, "longitude" ), "altitude": lambda self: self._convert( "altitude", converter=lambda strRepr: base.Altitude(float(strRepr)) ), "altitudeUnits": lambda self: self._fixUnits(unitKey="altitudeUnits"), "heightOfGeoidAboveWGS84": lambda self: self._convert( "heightOfGeoidAboveWGS84", converter=lambda strRepr: base.Altitude(float(strRepr)), ), "heightOfGeoidAboveWGS84Units": lambda self: self._fixUnits( unitKey="heightOfGeoidAboveWGS84Units" ), "trueHeading": lambda self: self._statefulUpdate("trueHeading"), "magneticVariation": lambda self: self._statefulUpdate("magneticVariation"), "magneticVariationDirection": lambda self: self._fixHemisphereSign( Angles.VARIATION, "heading" ), "speedInKnots": lambda self: self._fixUnits( valueKey="speed", sourceKey="speedInKnots", unit="N" ), "positionDilutionOfPrecision": lambda self: self._statefulUpdate( "positionDilutionOfPrecision" ), "horizontalDilutionOfPrecision": lambda self: self._statefulUpdate( "horizontalDilutionOfPrecision" ), "verticalDilutionOfPrecision": lambda self: self._statefulUpdate( "verticalDilutionOfPrecision" ), } def clear(self): """ Resets this adapter. This will empty the adapter state and the current sentence data. """ self._state = {} self._sentenceData = {} def sentenceReceived(self, sentence): """ Called when a sentence is received. Will clean the received NMEAProtocol sentence up, and then update the adapter's state, followed by firing the callbacks. If the received sentence was invalid, the state will be cleared. @param sentence: The sentence that is received. @type sentence: L{NMEASentence} """ self.currentSentence = sentence self._sentenceData = {} try: self._validateCurrentSentence() self._cleanCurrentSentence() except base.InvalidSentence: self.clear() self._updateState() self._fireSentenceCallbacks() def _validateCurrentSentence(self): """ Tests if a sentence contains a valid fix. """ if ( self.currentSentence.fixQuality is GPGGAFixQualities.INVALID_FIX or self.currentSentence.dataMode is GPGLLGPRMCFixQualities.VOID or self.currentSentence.fixType is GPGSAFixTypes.GSA_NO_FIX ): raise base.InvalidSentence("bad sentence") def _cleanCurrentSentence(self): """ Cleans the current sentence. """ for key in sorted(self.currentSentence.presentAttributes): fixer = self._FIXERS.get(key, None) if fixer is not None: fixer(self) def _updateState(self): """ Updates the current state with the new information from the sentence. """ self._updateBeaconInformation() self._combineDateAndTime() self._state.update(self._sentenceData) def _updateBeaconInformation(self): """ Updates existing beacon information state with new data. """ new = self._sentenceData.get("_partialBeaconInformation") if new is None: return self._updateUsedBeacons(new) self._mergeBeaconInformation(new) if self.currentSentence._isLastGSVSentence(): if not self.currentSentence._isFirstGSVSentence(): # not a 1-sentence sequence, get rid of partial information del self._state["_partialBeaconInformation"] bi = self._sentenceData.pop("_partialBeaconInformation") self._sentenceData["beaconInformation"] = bi def _updateUsedBeacons(self, beaconInformation): """ Searches the adapter state and sentence data for information about which beacons where used, then adds it to the provided beacon information object. If no new beacon usage information is available, does nothing. @param beaconInformation: The beacon information object that beacon usage information will be added to (if necessary). @type beaconInformation: L{twisted.positioning.base.BeaconInformation} """ for source in [self._state, self._sentenceData]: usedPRNs = source.get("_usedPRNs") if usedPRNs is not None: break else: # No used PRN info to update return for beacon in beaconInformation.seenBeacons: if beacon.identifier in usedPRNs: beaconInformation.usedBeacons.add(beacon) def _mergeBeaconInformation(self, newBeaconInformation): """ Merges beacon information in the adapter state (if it exists) into the provided beacon information. Specifically, this merges used and seen beacons. If the adapter state has no beacon information, does nothing. @param newBeaconInformation: The beacon information object that beacon information will be merged into (if necessary). @type newBeaconInformation: L{twisted.positioning.base.BeaconInformation} """ old = self._state.get("_partialBeaconInformation") if old is None: return for attr in ["seenBeacons", "usedBeacons"]: getattr(newBeaconInformation, attr).update(getattr(old, attr)) def _combineDateAndTime(self): """ Combines a C{datetime.date} object and a C{datetime.time} object, collected from one or more NMEA sentences, into a single C{datetime.datetime} object suitable for sending to the L{IPositioningReceiver}. """ if not any(k in self._sentenceData for k in ["_date", "_time"]): # If the sentence has neither date nor time, there's # nothing new to combine here. return date, time = ( self._sentenceData.get(key) or self._state.get(key) for key in ("_date", "_time") ) if date is None or time is None: return dt = datetime.datetime.combine(date, time) self._sentenceData["time"] = dt def _fireSentenceCallbacks(self): """ Fires sentence callbacks for the current sentence. A callback will only fire if all of the keys it requires are present in the current state and at least one such field was altered in the current sentence. The callbacks will only be fired with data from L{_state}. """ iface = ipositioning.IPositioningReceiver for name, method in iface.namesAndDescriptions(): callback = getattr(self._receiver, name) kwargs = {} atLeastOnePresentInSentence = False try: for field in method.positional: if field in self._sentenceData: atLeastOnePresentInSentence = True kwargs[field] = self._state[field] except KeyError: continue if atLeastOnePresentInSentence: callback(**kwargs) __all__ = ["NMEAProtocol", "NMEASentence", "NMEAAdapter"] PK Mb�Zk�$4� � positioning/__init__.pynu �[��� # -*- test-case-name: twisted.positioning.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted Positioning: Framework for applications that make use of positioning. @since: 14.0 """ PK Mb�ZpU�;� � _threads/_pool.pynu �[��� # -*- test-case-name: twisted._threads.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Top level thread pool interface, used to implement L{twisted.python.threadpool}. """ from queue import Queue from threading import Lock, Thread, local as LocalStorage from twisted.python.log import err from ._team import Team from ._threadworker import LockWorker, ThreadWorker def pool(currentLimit, threadFactory=Thread): """ Construct a L{Team} that spawns threads as a thread pool, with the given limiting function. @note: Future maintainers: while the public API for the eventual move to twisted.threads should look I{something} like this, and while this function is necessary to implement the API described by L{twisted.python.threadpool}, I am starting to think the idea of a hard upper limit on threadpool size is just bad (turning memory performance issues into correctness issues well before we run into memory pressure), and instead we should build something with reactor integration for slowly releasing idle threads when they're not needed and I{rate} limiting the creation of new threads rather than just hard-capping it. @param currentLimit: a callable that returns the current limit on the number of workers that the returned L{Team} should create; if it already has more workers than that value, no new workers will be created. @type currentLimit: 0-argument callable returning L{int} @param threadFactory: Factory that, when given a C{target} keyword argument, returns a L{threading.Thread} that will run that target. @type threadFactory: callable returning a L{threading.Thread} @return: a new L{Team}. """ def startThread(target): return threadFactory(target=target).start() def limitedWorkerCreator(): stats = team.statistics() if stats.busyWorkerCount + stats.idleWorkerCount >= currentLimit(): return None return ThreadWorker(startThread, Queue()) team = Team( coordinator=LockWorker(Lock(), LocalStorage()), createWorker=limitedWorkerCreator, logException=err, ) return team PK Mb�Zz,��( ( 2 _threads/__pycache__/_threadworker.cpython-310.pycnu �[��� o �b� � @ s^ d Z ddlmZ ddlmZ ddlmZ e� Zee�G dd� d��Z ee�G dd � d ��Z d S ) zE Implementation of an L{IWorker} based on native threads and queues. � )� implementer� )�Quit)�IExclusiveWorkerc @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) � ThreadWorkerz� An L{IExclusiveWorker} implemented based on a single thread and a queue. This worker ensures exclusivity (i.e. it is an L{IExclusiveWorker} and not an L{IWorker}) by performing all of the work passed to C{do} on the I{same} thread. c s& � | _ t� | _� fdd�}||� dS )a� Create a L{ThreadWorker} with a function to start a thread and a queue to use to communicate with that thread. @param startThread: a callable that takes a callable to run in another thread. @type startThread: callable taking a 0-argument callable and returning nothing. @param queue: A L{Queue} to use to give tasks to the thread created by C{startThread}. @type queue: L{Queue} c s t � jt�D ]} | � qd S )N)�iter�get�_stop)�task��queue� �@/usr/lib/python3/dist-packages/twisted/_threads/_threadworker.py�work- s �z#ThreadWorker.__init__.<locals>.workN)�_qr �_hasQuit)�self� startThreadr r r r r �__init__ s zThreadWorker.__init__c C s | j �� | j�|� dS )z� Perform the given task on the thread owned by this L{ThreadWorker}. @param task: the function to call on a thread. N)r �checkr �put)r r r r r �do3 � zThreadWorker.doc C s | j �� | j�t� dS )zT Reject all future work and stop the thread started by C{__init__}. N)r �setr r r �r r r r �quit< r zThreadWorker.quitN��__name__� __module__� __qualname__�__doc__r r r r r r r r s r c @ r ) � LockWorkerzE An L{IWorker} implemented based on a mutual-exclusion lock. c C s t � | _|| _|| _dS )z� @param lock: A mutual-exclusion lock, with C{acquire} and C{release} methods. @type lock: L{threading.Lock} @param local: Local storage. @type local: L{threading.local} N)r �_quit�_lock�_local)r �lock�localr r r r L s zLockWorker.__init__c C s� | j }| j}| j�� t|dd�}|du rJg }|_|�|� |�� z |r8|�d�� |s&W |� � d|_dS W |� � d|_dS |� � d|_w |�|� dS )z� Do the given work on this thread, with the mutex acquired. If this is called re-entrantly, return and wait for the outer invocation to do the work. @param work: the work to do with the lock held. �workingNr ) r$ r% r# r �getattrr( �append�acquire�pop�release)r r r& r' r( r r r r Y s( � � �z LockWorker.doc C s | j �� d| _dS )z* Quit this L{LockWorker}. N)r# r r$ r r r r r r s zLockWorker.quitNr r r r r r" F s r" N) r! �zope.interfacer � _conveniencer � _ithreadsr �objectr r r" r r r r �<module> s 3PK Mb�Z����� � * _threads/__pycache__/_team.cpython-310.pycnu �[��� o �b� � @ s\ d Z ddlmZ ddlmZ ddlmZ ddlmZ G dd� d�Z ee�G d d � d ��Z d S ) zZ Implementation of a L{Team} of workers; a thread-pool that can allocate work to workers. � )�deque)� implementer� )�IWorker)�Quitc @ s e Zd ZdZdd� ZdS )� Statisticsa� Statistics about a L{Team}'s current activity. @ivar idleWorkerCount: The number of idle workers. @type idleWorkerCount: L{int} @ivar busyWorkerCount: The number of busy workers. @type busyWorkerCount: L{int} @ivar backloggedWorkCount: The number of work items passed to L{Team.do} which have not yet been sent to a worker to be performed because not enough workers are available. @type backloggedWorkCount: L{int} c C s || _ || _|| _d S �N)�idleWorkerCount�busyWorkerCount�backloggedWorkCount)�selfr r r � r �8/usr/lib/python3/dist-packages/twisted/_threads/_team.py�__init__# s zStatistics.__init__N)�__name__� __module__� __qualname__�__doc__r r r r r r s r c @ s\ e Zd ZdZdd� Zdd� Zdd� Zdd d �Zdd d �Zd d� Z dd� Z dd� Z dd� Z dS )�Teamax A composite L{IWorker} implementation. @ivar _quit: A L{Quit} flag indicating whether this L{Team} has been quit yet. This may be set by an arbitrary thread since L{Team.quit} may be called from anywhere. @ivar _coordinator: the L{IExclusiveWorker} coordinating access to this L{Team}'s internal resources. @ivar _createWorker: a callable that will create new workers. @ivar _logException: a 0-argument callable called in an exception context when there is an unhandled error from a task passed to L{Team.do} @ivar _idle: a L{set} of idle workers. @ivar _busyCount: the number of workers currently busy. @ivar _pending: a C{deque} of tasks - that is, 0-argument callables passed to L{Team.do} - that are outstanding. @ivar _shouldQuitCoordinator: A flag indicating that the coordinator should be quit at the next available opportunity. Unlike L{Team._quit}, this flag is only set by the coordinator. @ivar _toShrink: the number of workers to shrink this L{Team} by at the next available opportunity; set in the coordinator. c C s@ t � | _|| _|| _|| _t� | _d| _t� | _ d| _ d| _ dS )a� @param coordinator: an L{IExclusiveWorker} which will coordinate access to resources on this L{Team}; that is to say, an L{IExclusiveWorker} whose C{do} method ensures that its given work will be executed in a mutually exclusive context, not in parallel with other work enqueued by C{do} (although possibly in parallel with the caller). @param createWorker: A 0-argument callable that will create an L{IWorker} to perform work. @param logException: A 0-argument callable called in an exception context when the work passed to C{do} raises an exception. r FN) r �_quit� _coordinator� _createWorker� _logException�set�_idle� _busyCountr �_pending�_shouldQuitCoordinator� _toShrink)r � coordinator� createWorker� logExceptionr r r r I s z Team.__init__c C s t t| j�| jt| j��S )z� Gather information on the current status of this L{Team}. @return: a L{Statistics} describing the current state of this L{Team}. )r �lenr r r �r r r r � statisticsd s zTeam.statisticsc s$ �j �� �jj� �fdd��}dS )z� Increase the the number of idle workers by C{n}. @param n: The number of new idle workers to create. @type n: L{int} c s2 t � �D ]} ��� }|d u r d S ��|� qd S r )�ranger �_recycleWorker)�x�worker��nr r r �createOneWorkeru s �z"Team.grow.<locals>.createOneWorkerN�r �checkr �do)r r* r+ r r) r �growl s z Team.growNc s$ �j �� �j�� �fdd�� dS )z� Decrease the number of idle workers by C{n}. @param n: The number of idle workers to shut down, or L{None} (or unspecified) to shut down all workers. @type n: L{int} or L{None} c s �� � �S r )� _quitIdlersr r) r r �<lambda>� � z Team.shrink.<locals>.<lambda>Nr, )r r* r r) r �shrink} s z Team.shrinkc C sp |du r t | j�| j }t|�D ]}| jr | j�� �� q| jd7 _q| jr4| jdkr6| j�� dS dS dS )z| The implmentation of C{shrink}, performed by the coordinator worker. @param n: see L{Team.shrink} Nr r ) r" r r r% �pop�quitr r r )r r* r' r r r r0 � s �zTeam._quitIdlersc s$ � j �� � j�� �fdd�� dS )zu Perform some work in a worker created by C{createWorker}. @param task: the callable to run c s � � ��S r )�_coordinateThisTaskr �r �taskr r r1 � r2 zTeam.do.<locals>.<lambda>Nr, r7 r r7 r r. � s zTeam.doc sX � j r� j �� n� �� ��du r� j��� dS � jd7 _�j� ��fdd��}dS )z� Select a worker to dispatch to, either an idle one or a new one, and perform it. This method should run on the coordinator worker. @param task: the task to dispatch @type task: 0-argument callable Nr c s@ z�� W n t y � �� Y nw � jj� �fdd��} d S )Nc s � j d8 _ � ��� d S )Nr )r r& r �r r( r r �idleAndPending� s z@Team._coordinateThisTask.<locals>.doWork.<locals>.idleAndPending)� BaseExceptionr r r. )r: �r r8 r( r r �doWork� s �z(Team._coordinateThisTask.<locals>.doWork)r r4 r r �appendr r. )r r8 r= r r< r r6 � s zTeam._coordinateThisTaskc C sl | j �|� | jr| �| j�� � dS | jr | �� dS | jdkr4| jd8 _| j �|� |� � dS dS )z� Called only from coordinator. Recycle the given worker into the idle pool. @param worker: a worker created by C{createWorker} and now idle. @type worker: L{IWorker} r r N) r �addr r6 �popleftr r0 r �remover5 r9 r r r r& � s �zTeam._recycleWorkerc s" � j �� � jj� fdd��}dS )zA Stop doing work and shut down all idle workers. c s d� _ � �� d S )NT)r r0 r r# r r �startFinishing� s z!Team.quit.<locals>.startFinishingN)r r r r. )r rB r r# r r5 � s z Team.quitr ) r r r r r r$ r/ r3 r0 r. r6 r& r5 r r r r r ) s r N) r � collectionsr �zope.interfacer � r � _conveniencer r r r r r r �<module> s PK Mb�Zi���� � 1 _threads/__pycache__/_convenience.cpython-310.pycnu �[��� o �b~ � @ s" d Z ddlmZ G dd� d�ZdS )zI Common functionality used within the implementation of various workers. � )� AlreadyQuitc @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �Quitz� A flag representing whether a worker has been quit. @ivar isSet: Whether this flag is set. @type isSet: L{bool} c C s d| _ dS )z* Create a L{Quit} un-set. FN)�isSet��self� r �?/usr/lib/python3/dist-packages/twisted/_threads/_convenience.py�__init__ s z Quit.__init__c C s | � � d| _dS )zg Set the flag if it has not been set. @raise AlreadyQuit: If it has been set. TN)�checkr r r r r �set s zQuit.setc C s | j rt� �dS )zb Check if the flag has been set. @raise AlreadyQuit: If it has been set. N)r r r r r r r $ s �z Quit.checkN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r N)r � _ithreadsr r r r r r �<module> s PK Mb�Zk� � - _threads/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ sT d Z ddlmZmZ ddlmZ ddlmZ ddlm Z ddl m Z m Z g d�Z dS ) z4 Twisted integration with operating system threads. � )� AlreadyQuit�IWorker)�createMemoryWorker)�pool)�Team)� LockWorker� ThreadWorker)r r r r r r r N)�__doc__� _ithreadsr r �_memoryr �_poolr �_teamr � _threadworkerr r �__all__� r r �;/usr/lib/python3/dist-packages/twisted/_threads/__init__.py�<module> s PK Mb�Z\aa�� � , _threads/__pycache__/_memory.cpython-310.pycnu �[��� o �b9 � @ sP d Z ddlmZ ddlmZ ddlmZ e� Zee�G dd� d��Z dd � Z d S ) z> Implementation of an in-memory worker that defers execution. � )� implementer� )�IWorker)�Quitc @ s, e Zd ZdZefdd�Zdd� Zdd� ZdS ) � MemoryWorkerz| An L{IWorker} that queues work for later performance. @ivar _quit: a flag indicating @type _quit: L{Quit} c C s t � | _|� | _dS )z+ Create a L{MemoryWorker}. N)r �_quit�_pending)�self�pending� r �:/usr/lib/python3/dist-packages/twisted/_threads/_memory.py�__init__ s zMemoryWorker.__init__c C s | j �� | j�|� dS )z} Queue some work for to perform later; see L{createMemoryWorker}. @param work: The work to perform. N)r �checkr �append)r �workr r r �do" s zMemoryWorker.doc C s | j �� | j�t� dS )z# Quit this worker. N)r �setr r � NoMoreWork)r r r r �quit+ s zMemoryWorker.quitN)�__name__� __module__� __qualname__�__doc__�listr r r r r r r r s r c s � fdd�} t � � � | fS )a Create an L{IWorker} that does nothing but defer work, to be performed later. @return: a worker that will enqueue work to perform later, and a callable that will perform one element of that work. @rtype: 2-L{tuple} of (L{IWorker}, L{callable}) c s. � j sdS � j d tu rdS � j �d�� dS )NFr T)r r �popr ��workerr r �perform= s z#createMemoryWorker.<locals>.perform)r )r r r r �createMemoryWorker3 s r N) r �zope.interfacer � r � _conveniencer �objectr r r r r r r �<module> s PK Mb�Z��� � � * _threads/__pycache__/_pool.cpython-310.pycnu �[��� o �b� � @ s\ d Z ddlmZ ddlmZmZmZ ddlm Z ddl m Z ddl m Z mZ efdd �Zd S ) zR Top level thread pool interface, used to implement L{twisted.python.threadpool}. � )�Queue)�Lock�Thread�local)�err� )�Team)� LockWorker� ThreadWorkerc s8 �fdd��� ��fdd�}t tt� t� �|td���S )a; Construct a L{Team} that spawns threads as a thread pool, with the given limiting function. @note: Future maintainers: while the public API for the eventual move to twisted.threads should look I{something} like this, and while this function is necessary to implement the API described by L{twisted.python.threadpool}, I am starting to think the idea of a hard upper limit on threadpool size is just bad (turning memory performance issues into correctness issues well before we run into memory pressure), and instead we should build something with reactor integration for slowly releasing idle threads when they're not needed and I{rate} limiting the creation of new threads rather than just hard-capping it. @param currentLimit: a callable that returns the current limit on the number of workers that the returned L{Team} should create; if it already has more workers than that value, no new workers will be created. @type currentLimit: 0-argument callable returning L{int} @param threadFactory: Factory that, when given a C{target} keyword argument, returns a L{threading.Thread} that will run that target. @type threadFactory: callable returning a L{threading.Thread} @return: a new L{Team}. c s � | d�� � S )N��target)�startr )� threadFactory� �8/usr/lib/python3/dist-packages/twisted/_threads/_pool.py� startThread0 s zpool.<locals>.startThreadc s* �� � } | j| j � � krd S t�t� �S )N)� statistics�busyWorkerCount�idleWorkerCountr r )�stats)� currentLimitr �teamr r �limitedWorkerCreator3 s z"pool.<locals>.limitedWorkerCreator)� coordinator� createWorker� logException)r r r � LocalStorager )r r r r )r r r r r �pool s �r N)�__doc__�queuer � threadingr r r r �twisted.python.logr �_teamr � _threadworkerr r r r r r r �<module> s PK Mb�Z*xv�� � . _threads/__pycache__/_ithreads.cpython-310.pycnu �[��� o �b� � @ sD d Z ddlmZ G dd� de�ZG dd� de�ZG dd� de�Zd S ) z Interfaces related to threads. � )� Interfacec @ � e Zd ZdZdS )� AlreadyQuitzJ This worker worker is dead and cannot execute more instructions. N��__name__� __module__� __qualname__�__doc__� r r �</usr/lib/python3/dist-packages/twisted/_threads/_ithreads.pyr � r c @ s e Zd ZdZdd� Zdd� ZdS )�IWorkerzs A worker that can perform some work concurrently. All methods on this interface must be thread-safe. c C � dS )a; Perform the given task. As an interface, this method makes no specific claims about concurrent execution. An L{IWorker}'s C{do} implementation may defer execution for later on the same thread, immediately on a different thread, or some combination of the two. It is valid for a C{do} method to schedule C{task} in such a way that it may never be executed. It is important for some implementations to provide specific properties with respect to where C{task} is executed, of course, and client code may rely on a more specific implementation of C{do} than L{IWorker}. @param task: a task to call in a thread or other concurrent context. @type task: 0-argument callable @raise AlreadyQuit: if C{quit} has been called. Nr )�taskr r r �do � z IWorker.doc C r )z� Free any resources associated with this L{IWorker} and cause it to reject all future work. @raise AlreadyQuit: if this method has already been called. Nr r r r r �quit. r z IWorker.quitN)r r r r r r r r r r r s r c @ r )�IExclusiveWorkerz� Like L{IWorker}, but with the additional guarantee that the callables passed to C{do} will not be called exclusively with each other. Nr r r r r r 7 r r N)r �zope.interfacer � Exceptionr r r r r r r �<module> s $PK Mb�Zk<� �$ �$ _threads/test/test_team.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted._threads._team}. """ from twisted.python.components import proxyForInterface from twisted.python.context import call, get from twisted.python.failure import Failure from twisted.trial.unittest import SynchronousTestCase from .. import AlreadyQuit, IWorker, Team, createMemoryWorker class ContextualWorker(proxyForInterface(IWorker, "_realWorker")): # type: ignore[misc] """ A worker implementation that supplies a context. """ def __init__(self, realWorker, **ctx): """ Create with a real worker and a context. """ self._realWorker = realWorker self._context = ctx def do(self, work): """ Perform the given work with the context given to __init__. @param work: the work to pass on to the real worker. """ super().do(lambda: call(self._context, work)) class TeamTests(SynchronousTestCase): """ Tests for L{Team} """ def setUp(self): """ Set up a L{Team} with inspectable, synchronous workers that can be single-stepped. """ coordinator, self.coordinateOnce = createMemoryWorker() self.coordinator = ContextualWorker(coordinator, worker="coordinator") self.workerPerformers = [] self.allWorkersEver = [] self.allUnquitWorkers = [] self.activePerformers = [] self.noMoreWorkers = lambda: False def createWorker(): if self.noMoreWorkers(): return None worker, performer = createMemoryWorker() self.workerPerformers.append(performer) self.activePerformers.append(performer) cw = ContextualWorker(worker, worker=len(self.workerPerformers)) self.allWorkersEver.append(cw) self.allUnquitWorkers.append(cw) realQuit = cw.quit def quitAndRemove(): realQuit() self.allUnquitWorkers.remove(cw) self.activePerformers.remove(performer) cw.quit = quitAndRemove return cw self.failures = [] def logException(): self.failures.append(Failure()) self.team = Team(coordinator, createWorker, logException) def coordinate(self): """ Perform all work currently scheduled in the coordinator. @return: whether any coordination work was performed; if the coordinator was idle when this was called, return L{False} (otherwise L{True}). @rtype: L{bool} """ did = False while self.coordinateOnce(): did = True return did def performAllOutstandingWork(self): """ Perform all work on the coordinator and worker performers that needs to be done. """ continuing = True while continuing: continuing = self.coordinate() for performer in self.workerPerformers: if performer in self.activePerformers: performer() continuing = continuing or self.coordinate() def test_doDoesWorkInWorker(self): """ L{Team.do} does the work in a worker created by the createWorker callable. """ def something(): something.who = get("worker") self.team.do(something) self.coordinate() self.assertEqual(self.team.statistics().busyWorkerCount, 1) self.performAllOutstandingWork() self.assertEqual(something.who, 1) self.assertEqual(self.team.statistics().busyWorkerCount, 0) def test_initialStatistics(self): """ L{Team.statistics} returns an object with idleWorkerCount, busyWorkerCount, and backloggedWorkCount integer attributes. """ stats = self.team.statistics() self.assertEqual(stats.idleWorkerCount, 0) self.assertEqual(stats.busyWorkerCount, 0) self.assertEqual(stats.backloggedWorkCount, 0) def test_growCreatesIdleWorkers(self): """ L{Team.grow} increases the number of available idle workers. """ self.team.grow(5) self.performAllOutstandingWork() self.assertEqual(len(self.workerPerformers), 5) def test_growCreateLimit(self): """ L{Team.grow} increases the number of available idle workers until the C{createWorker} callable starts returning None. """ self.noMoreWorkers = lambda: len(self.allWorkersEver) >= 3 self.team.grow(5) self.performAllOutstandingWork() self.assertEqual(len(self.allWorkersEver), 3) self.assertEqual(self.team.statistics().idleWorkerCount, 3) def test_shrinkQuitsWorkers(self): """ L{Team.shrink} will quit the given number of workers. """ self.team.grow(5) self.performAllOutstandingWork() self.team.shrink(3) self.performAllOutstandingWork() self.assertEqual(len(self.allUnquitWorkers), 2) def test_shrinkToZero(self): """ L{Team.shrink} with no arguments will stop all outstanding workers. """ self.team.grow(10) self.performAllOutstandingWork() self.assertEqual(len(self.allUnquitWorkers), 10) self.team.shrink() self.assertEqual(len(self.allUnquitWorkers), 10) self.performAllOutstandingWork() self.assertEqual(len(self.allUnquitWorkers), 0) def test_moreWorkWhenNoWorkersAvailable(self): """ When no additional workers are available, the given work is backlogged, and then performed later when the work was. """ self.team.grow(3) self.coordinate() def something(): something.times += 1 something.times = 0 self.assertEqual(self.team.statistics().idleWorkerCount, 3) for i in range(3): self.team.do(something) # Make progress on the coordinator but do _not_ actually complete the # work, yet. self.coordinate() self.assertEqual(self.team.statistics().idleWorkerCount, 0) self.noMoreWorkers = lambda: True self.team.do(something) self.coordinate() self.assertEqual(self.team.statistics().idleWorkerCount, 0) self.assertEqual(self.team.statistics().backloggedWorkCount, 1) self.performAllOutstandingWork() self.assertEqual(self.team.statistics().backloggedWorkCount, 0) self.assertEqual(something.times, 4) def test_exceptionInTask(self): """ When an exception is raised in a task passed to L{Team.do}, the C{logException} given to the L{Team} at construction is invoked in the exception context. """ self.team.do(lambda: 1 / 0) self.performAllOutstandingWork() self.assertEqual(len(self.failures), 1) self.assertEqual(self.failures[0].type, ZeroDivisionError) def test_quit(self): """ L{Team.quit} causes future invocations of L{Team.do} and L{Team.quit} to raise L{AlreadyQuit}. """ self.team.quit() self.assertRaises(AlreadyQuit, self.team.quit) self.assertRaises(AlreadyQuit, self.team.do, list) def test_quitQuits(self): """ L{Team.quit} causes all idle workers, as well as the coordinator worker, to quit. """ for x in range(10): self.team.do(list) self.performAllOutstandingWork() self.team.quit() self.performAllOutstandingWork() self.assertEqual(len(self.allUnquitWorkers), 0) self.assertRaises(AlreadyQuit, self.coordinator.quit) def test_quitQuitsLaterWhenBusy(self): """ L{Team.quit} causes all busy workers to be quit once they've finished the work they've been given. """ self.team.grow(10) for x in range(5): self.team.do(list) self.coordinate() self.team.quit() self.coordinate() self.assertEqual(len(self.allUnquitWorkers), 5) self.performAllOutstandingWork() self.assertEqual(len(self.allUnquitWorkers), 0) self.assertRaises(AlreadyQuit, self.coordinator.quit) def test_quitConcurrentWithWorkHappening(self): """ If work happens after L{Team.quit} sets its C{Quit} flag, but before any other work takes place, the L{Team} should still exit gracefully. """ self.team.do(list) originalSet = self.team._quit.set def performWorkConcurrently(): originalSet() self.performAllOutstandingWork() self.team._quit.set = performWorkConcurrently self.team.quit() self.assertRaises(AlreadyQuit, self.team.quit) self.assertRaises(AlreadyQuit, self.team.do, list) def test_shrinkWhenBusy(self): """ L{Team.shrink} will wait for busy workers to finish being busy and then quit them. """ for x in range(10): self.team.do(list) self.coordinate() self.assertEqual(len(self.allUnquitWorkers), 10) # There should be 10 busy workers at this point. self.team.shrink(7) self.performAllOutstandingWork() self.assertEqual(len(self.allUnquitWorkers), 3) PK Mb�Z��p�\ \ ! _threads/test/test_convenience.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for convenience functionality in L{twisted._threads._convenience}. """ from twisted.trial.unittest import SynchronousTestCase from .._convenience import Quit from .._ithreads import AlreadyQuit class QuitTests(SynchronousTestCase): """ Tests for L{Quit} """ def test_isInitiallySet(self): """ L{Quit.isSet} starts as L{False}. """ quit = Quit() self.assertEqual(quit.isSet, False) def test_setSetsSet(self): """ L{Quit.set} sets L{Quit.isSet} to L{True}. """ quit = Quit() quit.set() self.assertEqual(quit.isSet, True) def test_checkDoesNothing(self): """ L{Quit.check} initially does nothing and returns L{None}. """ quit = Quit() self.assertIs(quit.check(), None) def test_checkAfterSetRaises(self): """ L{Quit.check} raises L{AlreadyQuit} if L{Quit.set} has been called. """ quit = Quit() quit.set() self.assertRaises(AlreadyQuit, quit.check) def test_setTwiceRaises(self): """ L{Quit.set} raises L{AlreadyQuit} if it has been called previously. """ quit = Quit() quit.set() self.assertRaises(AlreadyQuit, quit.set) PK Mb�Z#7[�� � : _threads/test/__pycache__/test_convenience.cpython-310.pycnu �[��� o �b\ � @ s< d Z ddlmZ ddlmZ ddlmZ G dd� de�ZdS ) zO Test cases for convenience functionality in L{twisted._threads._convenience}. � )�SynchronousTestCase� )�Quit)� AlreadyQuitc @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � QuitTestsz Tests for L{Quit} c C s t � }| �|jd� dS )z3 L{Quit.isSet} starts as L{False}. FN)r � assertEqual�isSet��self�quit� r �H/usr/lib/python3/dist-packages/twisted/_threads/test/test_convenience.py�test_isInitiallySet s z QuitTests.test_isInitiallySetc C s t � }|�� | �|jd� dS )z< L{Quit.set} sets L{Quit.isSet} to L{True}. TN)r �setr r r r r r �test_setSetsSet � zQuitTests.test_setSetsSetc C s t � }| �|�� d� dS )zK L{Quit.check} initially does nothing and returns L{None}. N)r �assertIs�checkr r r r �test_checkDoesNothing" s z QuitTests.test_checkDoesNothingc C s t � }|�� | �t|j� dS )zU L{Quit.check} raises L{AlreadyQuit} if L{Quit.set} has been called. N)r r � assertRaisesr r r r r r �test_checkAfterSetRaises) r z"QuitTests.test_checkAfterSetRaisesc C s t � }|�� | �t|j� dS )zU L{Quit.set} raises L{AlreadyQuit} if it has been called previously. N)r r r r r r r r �test_setTwiceRaises1 r z QuitTests.test_setTwiceRaisesN) �__name__� __module__� __qualname__�__doc__r r r r r r r r r r s r N)r �twisted.trial.unittestr � _conveniencer � _ithreadsr r r r r r �<module> s PK Mb�Z�Z��� � 2 _threads/test/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z Tests for L{twisted._threads}. N)�__doc__� r r �@/usr/lib/python3/dist-packages/twisted/_threads/test/__init__.py�<module> s PK Mb�Z����B B 5 _threads/test/__pycache__/test_memory.cpython-310.pycnu �[��� o �b# � @ sD d Z ddlmZ ddlmZ ddlmZmZmZ G dd� de�Z dS ) z( Tests for L{twisted._threads._memory}. � )� verifyObject)�SynchronousTestCase� )� AlreadyQuit�IWorker�createMemoryWorkerc @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �MemoryWorkerTestsz$ Tests for L{MemoryWorker}. c s� t � \}}tt|� g � |�� fdd�� |�� fdd�� | �� g � | �|� d� | �� dg� | �|� d� | �� ddg� dS )z� L{createMemoryWorker} creates an L{IWorker} and a callable that can perform work on it. The performer returns C{True} if it accomplished useful work. c � � � d�S )N� ��append� ��doner �C/usr/lib/python3/dist-packages/twisted/_threads/test/test_memory.py�<lambda> � z?MemoryWorkerTests.test_createWorkerAndPerform.<locals>.<lambda>c r )N� r r r r r r r Tr r N)r r r �do� assertEqual��self�worker� performerr r r �test_createWorkerAndPerform s z-MemoryWorkerTests.test_createWorkerAndPerformc sp t � \}}g � � fdd�}|�|� |�� | �t|j|� | �t|j� |� | �� dg� | �|� d� dS )a Calling C{quit} on the worker returned by L{createMemoryWorker} causes its C{do} and C{quit} methods to raise L{AlreadyQuit}; its C{perform} callable will start raising L{AlreadyQuit} when the work already provided to C{do} has been exhausted. c s � � d� d S )N� r r r r r �moreWork. s z2MemoryWorkerTests.test_quitQuits.<locals>.moreWorkr FN)r r �quit� assertRaisesr r )r r r r r r r �test_quitQuits$ s z MemoryWorkerTests.test_quitQuitsc C s t � \}}| �|� d� dS )z� The C{perform} callable returned by L{createMemoryWorker} will return no result when there's no work to do yet. Since there is no work to do, the performer returns C{False}. FN)r r r r r r � test_performWhenNothingToDoYet9 s z0MemoryWorkerTests.test_performWhenNothingToDoYetN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r N) r$ �zope.interface.verifyr �twisted.trial.unittestr � r r r r r r r r �<module> s PK Mb�Z ����& �& ; _threads/test/__pycache__/test_threadworker.cpython-310.pycnu �[��� o �b1 � @ s� d Z ddlZddlZddlmZmZ ddlmZ ddlm Z m Z m Z G dd� de �Z G d d � d e �ZG d d � d �ZG d d� d�ZG dd� d�ZG dd� de�ZG dd� de�ZdS )z. Tests for L{twisted._threads._threadworker}. � N)� ThreadError�local)�SynchronousTestCase� )� AlreadyQuit� LockWorker� ThreadWorkerc @ � e Zd ZdZdS )�FakeQueueEmptyz8 L{FakeQueue}'s C{get} has exhausted the queue. N��__name__� __module__� __qualname__�__doc__� r r �I/usr/lib/python3/dist-packages/twisted/_threads/test/test_threadworker.pyr � r c @ r )� WouldDeadlockzf If this were a real lock, you'd be deadlocked because the lock would be double-acquired. Nr r r r r r r r c @ s e Zd ZdZdd� Zdd� ZdS )� FakeThreadz� A fake L{threading.Thread}. @ivar target: A target function to run. @type target: L{callable} @ivar started: Has this thread been started? @type started: L{bool} c C s || _ d| _dS )z7 Create a L{FakeThread} with a target. FN)�target�started)�selfr r r r �__init__) s zFakeThread.__init__c C � d| _ dS )z) Set the "started" flag. TN)r �r r r r �start0 � zFakeThread.startN)r r r r r r r r r r r s r c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) � FakeQueuez� A fake L{Queue} implementing C{put} and C{get}. @ivar items: A lit of items placed by C{put} but not yet retrieved by C{get}. @type items: L{list} c C s g | _ dS )z( Create a L{FakeQueue}. N)�itemsr r r r r @ r zFakeQueue.__init__c C s | j �|� dS )zv Put an item into the queue for later retrieval by L{FakeQueue.get}. @param item: any object N)r �append)r �itemr r r �putF s z FakeQueue.putc C s | j st� �| j �d�S )zR Get an item. @return: an item previously put by C{put}. r )r r �popr r r r �getN s z FakeQueue.getN)r r r r r r" r$ r r r r r 7 s r c @ r ) �FakeLockzi A stand-in for L{threading.Lock}. @ivar acquired: Whether this lock is presently acquired. c C r )z9 Create a lock in the un-acquired state. FN)�acquiredr r r r r ` r zFakeLock.__init__c C s | j rt� �d| _ dS )zX Acquire the lock. Raise an exception if the lock is already acquired. TN)r& r r r r r �acquiref s zFakeLock.acquirec C s | j st� �d| _ dS )zf Release the lock. Raise an exception if the lock is not presently acquired. FN)r& r r r r r �releasen s zFakeLock.releaseN)r r r r r r' r( r r r r r% Y s r% c @ r ) �ThreadWorkerTestsz$ Tests for L{ThreadWorker}. c s, g � _ t� � _� fdd�}t|� j�� _dS )z4 Create a worker with fake threads. c s" t | d�}|�� � j�|� |S )N)r )r r � fakeThreadsr )r � newThreadr r r � startThread� s z,ThreadWorkerTests.setUp.<locals>.startThreadN)r* r � fakeQueuer �worker)r r, r r r �setUp} s zThreadWorkerTests.setUpc sx | � t| j�d� | � | jd jd� � fdd�� d� _| j�� � | � � jd� | �t| jd j � | � � jd� dS )z� L{ThreadWorker} calls its C{createThread} callable to create a thread, its C{createQueue} callable to create a queue, and then the thread's target pulls work from that queue. � r Tc s d� _ d S �NT)�doner ��doItr r r4 � s z@ThreadWorkerTests.test_startsThreadAndPerformsWork.<locals>.doItFN) � assertEqual�lenr* r r2 r. �do� assertRaisesr r r r r3 r � test_startsThreadAndPerformsWork� s z2ThreadWorkerTests.test_startsThreadAndPerformsWorkc C s0 | j �� | �t| j j� | �t| j jt� dS )z� L{ThreadWorker.quit} causes future calls to L{ThreadWorker.do} and L{ThreadWorker.quit} to raise L{AlreadyQuit}. N)r. �quitr8 r r7 �listr r r r � test_quitPreventsFutureCalls� s z.ThreadWorkerTests.test_quitPreventsFutureCallsN)r r r r r/ r9 r< r r r r r) x s r) c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�LockWorkerTestsz" Tests for L{LockWorker}. c C s t � }|�� | �t|j� dS )ze The L{FakeLock} test fixture will alert us if there's a potential deadlock. N)r% r' r8 r �r �lockr r r �test_fakeDeadlock� s z!LockWorkerTests.test_fakeDeadlockc C s> t � }| �t|j� |�� | �d|�� � | �t|j� dS )zk The L{FakeLock} test fixture will alert us if there's a potential double-release. N)r% r8 r r( r' r5 r> r r r �test_fakeDoubleRelease� s z&LockWorkerTests.test_fakeDoubleReleasec sb t � }t� � t� |�}� �fdd��d�_|��� | ��jd� | ��jd� | �� jd� dS )zp L{LockWorker.do} immediately performs the work it's given, while the lock is acquired. c � d�_ � j�_d S r1 )r2 r& r �r? �workr r rD � � z@LockWorkerTests.test_doExecutesImmediatelyWithLock.<locals>.workFTN)r r% r r2 r7 r5 r& )r �storager. r rC r �"test_doExecutesImmediatelyWithLock� s z2LockWorkerTests.test_doExecutesImmediatelyWithLockc sb t � �t�t� ��g �g � � ����fdd��d�_���� | ��ddg� | �� ddg� dS )z� If L{LockWorker.do} is called recursively, it postpones the inner call until the outer one is complete. c sN � j d7 _ ���j � � ��j� t��dk r ���� � j d8 _ d S )Nr0 r )�levelr r& r6 r7 r �r& �levelsr? rD r. r r rD � s z6LockWorkerTests.test_doUnwindsReentrancy.<locals>.workr r0 TN)r% r r rH r7 r5 r r rI r �test_doUnwindsReentrancy� s z(LockWorkerTests.test_doUnwindsReentrancyc C sn t � }t�|�}t|t� �}d}| �|� d� |�� t�� | � |� d� | � t |j� | � t |j t � dS )z� L{LockWorker.quit} frees the resources associated with its lock and causes further calls to C{do} and C{quit} to fail. N)r% �weakref�refr r � assertIsNotr: �gc�collect�assertIsr8 r r7 r; )r r? rM r. r r r � test_quit� s zLockWorkerTests.test_quitc s� t � � t�� �}t� t� ������fdd��d�_� �fdd��d�_���� ���jd� ���jd� ��� jd� d� t � � �� |� d� dS )z� If L{LockWorker.quit} is invoked during a call to L{LockWorker.do}, all recursive work scheduled with L{LockWorker.do} will be completed and the lock will be released. c s, �� �� ��� ��t�j t� d� _d S r1 )r7 r: r8 r r; �completer )�phase1�phase2r r. r r rT s z5LockWorkerTests.test_quitWhileWorking.<locals>.phase1Fc rB r1 )rS r& r )r? rU r r rU rE z5LockWorkerTests.test_quitWhileWorking.<locals>.phase2TN) r% rL rM r r rS r7 r5 r& rO rP rQ )r rM r )r? rT rU r r. r �test_quitWhileWorking� s z%LockWorkerTests.test_quitWhileWorkingc C s2 G dd� dt �}|t� t� �}| �t|jt� dS )z� If L{LockWorker.do} is called concurrently with L{LockWorker.quit}, and C{quit} wins the race before C{do} gets the lock attribute, then L{AlreadyQuit} will be raised. c @ s& e Zd Zedd� �Zejdd� �ZdS )zALockWorkerTests.test_quitWhileGettingLock.<locals>.RacyLockWorkerc S s | � � | jd S �N�_lock)r: �__dict__r r r r rX " s zGLockWorkerTests.test_quitWhileGettingLock.<locals>.RacyLockWorker._lockc S s || j d< d S rW )rY )r �valuer r r rX ' s N)r r r �propertyrX �setterr r r r �RacyLockWorker! s r] N)r r% r r8 r r7 r; )r r] r. r r r �test_quitWhileGettingLock s z)LockWorkerTests.test_quitWhileGettingLockN) r r r r r@ rA rG rK rR rV r^ r r r r r= � s r= )r rO rL � threadingr r �twisted.trial.unittestr � r r r � Exceptionr r r r r% r) r= r r r r �<module> s " 0PK Mb�Z67a �( �( 3 _threads/test/__pycache__/test_team.cpython-310.pycnu �[��� o �b�$ � @ sz d Z ddlmZ ddlmZmZ ddlmZ ddlm Z ddl m Z m Z m Z mZ G dd � d ee d ��ZG d d � d e �Zd S )z& Tests for L{twisted._threads._team}. � )�proxyForInterface)�call�get)�Failure)�SynchronousTestCase� )� AlreadyQuit�IWorker�Team�createMemoryWorkerc s( e Zd ZdZdd� Z� fdd�Z� ZS )�ContextualWorkerz: A worker implementation that supplies a context. c K s || _ || _dS )z: Create with a real worker and a context. N)� _realWorker�_context)�self� realWorker�ctx� r �A/usr/lib/python3/dist-packages/twisted/_threads/test/test_team.py�__init__ s zContextualWorker.__init__c s t � �� �fdd�� dS )z� Perform the given work with the context given to __init__. @param work: the work to pass on to the real worker. c s t � j��S �N)r r r �r �workr r �<lambda>" s z%ContextualWorker.do.<locals>.<lambda>N)�super�dor �� __class__r r r s zContextualWorker.do)�__name__� __module__� __qualname__�__doc__r r � __classcell__r r r r r s r r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#� TeamTestsz Tests for L{Team} c sl t � \}� _t|dd�� _g � _g � _g � _g � _dd� � _� fdd�}g � _ � fdd�}t |||�� _ d S ) zl Set up a L{Team} with inspectable, synchronous workers that can be single-stepped. � coordinator��workerc S � dS )NFr r r r r r 5 � z!TeamTests.setUp.<locals>.<lambda>c sz �� � rd S t� \} ��j��� �j��� t| t�j�d�� �j�� � �j�� � � j �� ���fdd�}|� _ � S )Nr$ c s" �� �j �� � �j��� d S r )�allUnquitWorkers�remove�activePerformersr )�cw� performer�realQuitr r r � quitAndRemoveB s z<TeamTests.setUp.<locals>.createWorker.<locals>.quitAndRemove) � noMoreWorkersr �workerPerformers�appendr* r �len�allWorkersEverr( �quit)r% r. �r )r+ r, r- r � createWorker7 s z%TeamTests.setUp.<locals>.createWorkerc s � j �t� � d S r )�failuresr1 r r r5 r r � logExceptionL � z%TeamTests.setUp.<locals>.logExceptionN) r �coordinateOncer r# r0 r3 r( r* r/ r7 r �team)r r# r6 r8 r r5 r �setUp* s zTeamTests.setUpc C s d}| � � r d}| � � s|S )a Perform all work currently scheduled in the coordinator. @return: whether any coordination work was performed; if the coordinator was idle when this was called, return L{False} (otherwise L{True}). @rtype: L{bool} FT)r: )r �didr r r � coordinateQ s �zTeamTests.coordinatec C sD d}|r | � � }| jD ] }|| jv r|� q |p| � � }|sdS dS )zj Perform all work on the coordinator and worker performers that needs to be done. TN)r> r0 r* )r � continuingr, r r r �performAllOutstandingWork_ s � �z#TeamTests.performAllOutstandingWorkc sb � fdd�� | j �� � | �� | �| j �� jd� | �� | �� jd� | �| j �� jd� dS )zd L{Team.do} does the work in a worker created by the createWorker callable. c s t d�� _d S )Nr% )r �whor �� somethingr r rC r s z4TeamTests.test_doDoesWorkInWorker.<locals>.something� r N)r; r r> � assertEqual� statistics�busyWorkerCountr@ rA r5 r rB r �test_doDoesWorkInWorkerl s z!TeamTests.test_doDoesWorkInWorkerc C s8 | j �� }| �|jd� | �|jd� | �|jd� dS )z� L{Team.statistics} returns an object with idleWorkerCount, busyWorkerCount, and backloggedWorkCount integer attributes. r N)r; rF rE �idleWorkerCountrG �backloggedWorkCount)r �statsr r r �test_initialStatistics| s z TeamTests.test_initialStatisticsc C s* | j �d� | �� | �t| j�d� dS )zN L{Team.grow} increases the number of available idle workers. � N)r; �growr@ rE r2 r0 r5 r r r �test_growCreatesIdleWorkers� s z%TeamTests.test_growCreatesIdleWorkersc sL � fdd�� _ � j�d� � �� � �t� j�d� � �� j�� jd� dS )z� L{Team.grow} increases the number of available idle workers until the C{createWorker} callable starts returning None. c s t � j�dkS )N� )r2 r3 r r5 r r r � s z0TeamTests.test_growCreateLimit.<locals>.<lambda>rM rP N) r/ r; rN r@ rE r2 r3 rF rI r5 r r5 r �test_growCreateLimit� s z TeamTests.test_growCreateLimitc C s> | j �d� | �� | j �d� | �� | �t| j�d� dS )zG L{Team.shrink} will quit the given number of workers. rM rP r N)r; rN r@ �shrinkrE r2 r( r5 r r r �test_shrinkQuitsWorkers� s z!TeamTests.test_shrinkQuitsWorkersc C s` | j �d� | �� | �t| j�d� | j �� | �t| j�d� | �� | �t| j�d� dS )zU L{Team.shrink} with no arguments will stop all outstanding workers. � r N)r; rN r@ rE r2 r( rR r5 r r r �test_shrinkToZero� s zTeamTests.test_shrinkToZeroc s� | j �d� | �� � fdd�� d� _| �| j �� jd� td�D ]}| j �� � q!| �� | �| j �� jd� dd� | _ | j �� � | �� | �| j �� jd� | �| j �� j d� | � � | �| j �� j d� | �� jd� d S ) z� When no additional workers are available, the given work is backlogged, and then performed later when the work was. rP c s � j d7 _ d S )NrD )�timesr rB r r rC � r9 z@TeamTests.test_moreWorkWhenNoWorkersAvailable.<locals>.somethingr c S r& )NTr r r r r r � r' z?TeamTests.test_moreWorkWhenNoWorkersAvailable.<locals>.<lambda>rD � N) r; rN r> rV rE rF rI �ranger r/ rJ r@ )r �ir rB r �#test_moreWorkWhenNoWorkersAvailable� s" z-TeamTests.test_moreWorkWhenNoWorkersAvailablec C sB | j �dd� � | �� | �t| j�d� | �| jd jt� dS )z� When an exception is raised in a task passed to L{Team.do}, the C{logException} given to the L{Team} at construction is invoked in the exception context. c S s dd S )NrD r r r r r r r � s z0TeamTests.test_exceptionInTask.<locals>.<lambda>rD r N)r; r r@ rE r2 r7 �type�ZeroDivisionErrorr5 r r r �test_exceptionInTask� s z TeamTests.test_exceptionInTaskc C s0 | j �� | �t| j j� | �t| j jt� dS )zx L{Team.quit} causes future invocations of L{Team.do} and L{Team.quit} to raise L{AlreadyQuit}. N)r; r4 � assertRaisesr r �listr5 r r r � test_quit� s zTeamTests.test_quitc C sZ t d�D ]}| j�t� q| �� | j�� | �� | �t| j�d� | � t | j j� dS )zk L{Team.quit} causes all idle workers, as well as the coordinator worker, to quit. rT r N) rX r; r r_ r@ r4 rE r2 r( r^ r r# �r �xr r r �test_quitQuits� s zTeamTests.test_quitQuitsc C s� | j �d� td�D ]}| j �t� q | �� | j �� | �� | �t| j �d� | � � | �t| j �d� | � t | j j� dS )z| L{Team.quit} causes all busy workers to be quit once they've finished the work they've been given. rT rM r N)r; rN rX r r_ r> r4 rE r2 r( r@ r^ r r# ra r r r �test_quitQuitsLaterWhenBusy� s z%TeamTests.test_quitQuitsLaterWhenBusyc s^ �j �t� �j jj� � �fdd�}|�j j_�j �� ��t�j j� ��t�j jt� dS )z� If work happens after L{Team.quit} sets its C{Quit} flag, but before any other work takes place, the L{Team} should still exit gracefully. c s � � �� � d S r )r@ r �� originalSetr r r �performWorkConcurrently s zOTeamTests.test_quitConcurrentWithWorkHappening.<locals>.performWorkConcurrentlyN)r; r r_ �_quit�setr4 r^ r )r rg r re r �$test_quitConcurrentWithWorkHappening� s z.TeamTests.test_quitConcurrentWithWorkHappeningc C s^ t d�D ]}| j�t� q| �� | �t| j�d� | j�d� | � � | �t| j�d� dS )zl L{Team.shrink} will wait for busy workers to finish being busy and then quit them. rT � rP N) rX r; r r_ r> rE r2 r( rR r@ ra r r r �test_shrinkWhenBusy s z TeamTests.test_shrinkWhenBusyN)r r r r r< r> r@ rH rL rO rQ rS rU rZ r] r` rc rd rj rl r r r r r" % s$ ' r" N)r �twisted.python.componentsr �twisted.python.contextr r �twisted.python.failurer �twisted.trial.unittestr � r r r r r r" r r r r �<module> s PK Mb�Z�=K\1 1 " _threads/test/test_threadworker.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted._threads._threadworker}. """ import gc import weakref from threading import ThreadError, local from twisted.trial.unittest import SynchronousTestCase from .. import AlreadyQuit, LockWorker, ThreadWorker class FakeQueueEmpty(Exception): """ L{FakeQueue}'s C{get} has exhausted the queue. """ class WouldDeadlock(Exception): """ If this were a real lock, you'd be deadlocked because the lock would be double-acquired. """ class FakeThread: """ A fake L{threading.Thread}. @ivar target: A target function to run. @type target: L{callable} @ivar started: Has this thread been started? @type started: L{bool} """ def __init__(self, target): """ Create a L{FakeThread} with a target. """ self.target = target self.started = False def start(self): """ Set the "started" flag. """ self.started = True class FakeQueue: """ A fake L{Queue} implementing C{put} and C{get}. @ivar items: A lit of items placed by C{put} but not yet retrieved by C{get}. @type items: L{list} """ def __init__(self): """ Create a L{FakeQueue}. """ self.items = [] def put(self, item): """ Put an item into the queue for later retrieval by L{FakeQueue.get}. @param item: any object """ self.items.append(item) def get(self): """ Get an item. @return: an item previously put by C{put}. """ if not self.items: raise FakeQueueEmpty() return self.items.pop(0) class FakeLock: """ A stand-in for L{threading.Lock}. @ivar acquired: Whether this lock is presently acquired. """ def __init__(self): """ Create a lock in the un-acquired state. """ self.acquired = False def acquire(self): """ Acquire the lock. Raise an exception if the lock is already acquired. """ if self.acquired: raise WouldDeadlock() self.acquired = True def release(self): """ Release the lock. Raise an exception if the lock is not presently acquired. """ if not self.acquired: raise ThreadError() self.acquired = False class ThreadWorkerTests(SynchronousTestCase): """ Tests for L{ThreadWorker}. """ def setUp(self): """ Create a worker with fake threads. """ self.fakeThreads = [] self.fakeQueue = FakeQueue() def startThread(target): newThread = FakeThread(target=target) newThread.start() self.fakeThreads.append(newThread) return newThread self.worker = ThreadWorker(startThread, self.fakeQueue) def test_startsThreadAndPerformsWork(self): """ L{ThreadWorker} calls its C{createThread} callable to create a thread, its C{createQueue} callable to create a queue, and then the thread's target pulls work from that queue. """ self.assertEqual(len(self.fakeThreads), 1) self.assertEqual(self.fakeThreads[0].started, True) def doIt(): doIt.done = True doIt.done = False self.worker.do(doIt) self.assertEqual(doIt.done, False) self.assertRaises(FakeQueueEmpty, self.fakeThreads[0].target) self.assertEqual(doIt.done, True) def test_quitPreventsFutureCalls(self): """ L{ThreadWorker.quit} causes future calls to L{ThreadWorker.do} and L{ThreadWorker.quit} to raise L{AlreadyQuit}. """ self.worker.quit() self.assertRaises(AlreadyQuit, self.worker.quit) self.assertRaises(AlreadyQuit, self.worker.do, list) class LockWorkerTests(SynchronousTestCase): """ Tests for L{LockWorker}. """ def test_fakeDeadlock(self): """ The L{FakeLock} test fixture will alert us if there's a potential deadlock. """ lock = FakeLock() lock.acquire() self.assertRaises(WouldDeadlock, lock.acquire) def test_fakeDoubleRelease(self): """ The L{FakeLock} test fixture will alert us if there's a potential double-release. """ lock = FakeLock() self.assertRaises(ThreadError, lock.release) lock.acquire() self.assertEqual(None, lock.release()) self.assertRaises(ThreadError, lock.release) def test_doExecutesImmediatelyWithLock(self): """ L{LockWorker.do} immediately performs the work it's given, while the lock is acquired. """ storage = local() lock = FakeLock() worker = LockWorker(lock, storage) def work(): work.done = True work.acquired = lock.acquired work.done = False worker.do(work) self.assertEqual(work.done, True) self.assertEqual(work.acquired, True) self.assertEqual(lock.acquired, False) def test_doUnwindsReentrancy(self): """ If L{LockWorker.do} is called recursively, it postpones the inner call until the outer one is complete. """ lock = FakeLock() worker = LockWorker(lock, local()) levels = [] acquired = [] def work(): work.level += 1 levels.append(work.level) acquired.append(lock.acquired) if len(levels) < 2: worker.do(work) work.level -= 1 work.level = 0 worker.do(work) self.assertEqual(levels, [1, 1]) self.assertEqual(acquired, [True, True]) def test_quit(self): """ L{LockWorker.quit} frees the resources associated with its lock and causes further calls to C{do} and C{quit} to fail. """ lock = FakeLock() ref = weakref.ref(lock) worker = LockWorker(lock, local()) lock = None self.assertIsNot(ref(), None) worker.quit() gc.collect() self.assertIs(ref(), None) self.assertRaises(AlreadyQuit, worker.quit) self.assertRaises(AlreadyQuit, worker.do, list) def test_quitWhileWorking(self): """ If L{LockWorker.quit} is invoked during a call to L{LockWorker.do}, all recursive work scheduled with L{LockWorker.do} will be completed and the lock will be released. """ lock = FakeLock() ref = weakref.ref(lock) worker = LockWorker(lock, local()) def phase1(): worker.do(phase2) worker.quit() self.assertRaises(AlreadyQuit, worker.do, list) phase1.complete = True phase1.complete = False def phase2(): phase2.complete = True phase2.acquired = lock.acquired phase2.complete = False worker.do(phase1) self.assertEqual(phase1.complete, True) self.assertEqual(phase2.complete, True) self.assertEqual(lock.acquired, False) lock = None gc.collect() self.assertIs(ref(), None) def test_quitWhileGettingLock(self): """ If L{LockWorker.do} is called concurrently with L{LockWorker.quit}, and C{quit} wins the race before C{do} gets the lock attribute, then L{AlreadyQuit} will be raised. """ class RacyLockWorker(LockWorker): @property def _lock(self): self.quit() return self.__dict__["_lock"] @_lock.setter def _lock(self, value): self.__dict__["_lock"] = value worker = RacyLockWorker(FakeLock(), local()) self.assertRaises(AlreadyQuit, worker.do, list) PK Mb�Z) �!# # _threads/test/test_memory.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted._threads._memory}. """ from zope.interface.verify import verifyObject from twisted.trial.unittest import SynchronousTestCase from .. import AlreadyQuit, IWorker, createMemoryWorker class MemoryWorkerTests(SynchronousTestCase): """ Tests for L{MemoryWorker}. """ def test_createWorkerAndPerform(self): """ L{createMemoryWorker} creates an L{IWorker} and a callable that can perform work on it. The performer returns C{True} if it accomplished useful work. """ worker, performer = createMemoryWorker() verifyObject(IWorker, worker) done = [] worker.do(lambda: done.append(3)) worker.do(lambda: done.append(4)) self.assertEqual(done, []) self.assertEqual(performer(), True) self.assertEqual(done, [3]) self.assertEqual(performer(), True) self.assertEqual(done, [3, 4]) def test_quitQuits(self): """ Calling C{quit} on the worker returned by L{createMemoryWorker} causes its C{do} and C{quit} methods to raise L{AlreadyQuit}; its C{perform} callable will start raising L{AlreadyQuit} when the work already provided to C{do} has been exhausted. """ worker, performer = createMemoryWorker() done = [] def moreWork(): done.append(7) worker.do(moreWork) worker.quit() self.assertRaises(AlreadyQuit, worker.do, moreWork) self.assertRaises(AlreadyQuit, worker.quit) performer() self.assertEqual(done, [7]) self.assertEqual(performer(), False) def test_performWhenNothingToDoYet(self): """ The C{perform} callable returned by L{createMemoryWorker} will return no result when there's no work to do yet. Since there is no work to do, the performer returns C{False}. """ worker, performer = createMemoryWorker() self.assertEqual(performer(), False) PK Mb�ZF��Ҡ � _threads/test/__init__.pynu �[��� # -*- test-case-name: twisted._threads.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted._threads}. """ PK Mb�Z�gr� � _threads/_team.pynu �[��� # -*- test-case-name: twisted._threads.test.test_team -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Implementation of a L{Team} of workers; a thread-pool that can allocate work to workers. """ from collections import deque from zope.interface import implementer from . import IWorker from ._convenience import Quit class Statistics: """ Statistics about a L{Team}'s current activity. @ivar idleWorkerCount: The number of idle workers. @type idleWorkerCount: L{int} @ivar busyWorkerCount: The number of busy workers. @type busyWorkerCount: L{int} @ivar backloggedWorkCount: The number of work items passed to L{Team.do} which have not yet been sent to a worker to be performed because not enough workers are available. @type backloggedWorkCount: L{int} """ def __init__(self, idleWorkerCount, busyWorkerCount, backloggedWorkCount): self.idleWorkerCount = idleWorkerCount self.busyWorkerCount = busyWorkerCount self.backloggedWorkCount = backloggedWorkCount @implementer(IWorker) class Team: """ A composite L{IWorker} implementation. @ivar _quit: A L{Quit} flag indicating whether this L{Team} has been quit yet. This may be set by an arbitrary thread since L{Team.quit} may be called from anywhere. @ivar _coordinator: the L{IExclusiveWorker} coordinating access to this L{Team}'s internal resources. @ivar _createWorker: a callable that will create new workers. @ivar _logException: a 0-argument callable called in an exception context when there is an unhandled error from a task passed to L{Team.do} @ivar _idle: a L{set} of idle workers. @ivar _busyCount: the number of workers currently busy. @ivar _pending: a C{deque} of tasks - that is, 0-argument callables passed to L{Team.do} - that are outstanding. @ivar _shouldQuitCoordinator: A flag indicating that the coordinator should be quit at the next available opportunity. Unlike L{Team._quit}, this flag is only set by the coordinator. @ivar _toShrink: the number of workers to shrink this L{Team} by at the next available opportunity; set in the coordinator. """ def __init__(self, coordinator, createWorker, logException): """ @param coordinator: an L{IExclusiveWorker} which will coordinate access to resources on this L{Team}; that is to say, an L{IExclusiveWorker} whose C{do} method ensures that its given work will be executed in a mutually exclusive context, not in parallel with other work enqueued by C{do} (although possibly in parallel with the caller). @param createWorker: A 0-argument callable that will create an L{IWorker} to perform work. @param logException: A 0-argument callable called in an exception context when the work passed to C{do} raises an exception. """ self._quit = Quit() self._coordinator = coordinator self._createWorker = createWorker self._logException = logException # Don't touch these except from the coordinator. self._idle = set() self._busyCount = 0 self._pending = deque() self._shouldQuitCoordinator = False self._toShrink = 0 def statistics(self): """ Gather information on the current status of this L{Team}. @return: a L{Statistics} describing the current state of this L{Team}. """ return Statistics(len(self._idle), self._busyCount, len(self._pending)) def grow(self, n): """ Increase the the number of idle workers by C{n}. @param n: The number of new idle workers to create. @type n: L{int} """ self._quit.check() @self._coordinator.do def createOneWorker(): for x in range(n): worker = self._createWorker() if worker is None: return self._recycleWorker(worker) def shrink(self, n=None): """ Decrease the number of idle workers by C{n}. @param n: The number of idle workers to shut down, or L{None} (or unspecified) to shut down all workers. @type n: L{int} or L{None} """ self._quit.check() self._coordinator.do(lambda: self._quitIdlers(n)) def _quitIdlers(self, n=None): """ The implmentation of C{shrink}, performed by the coordinator worker. @param n: see L{Team.shrink} """ if n is None: n = len(self._idle) + self._busyCount for x in range(n): if self._idle: self._idle.pop().quit() else: self._toShrink += 1 if self._shouldQuitCoordinator and self._busyCount == 0: self._coordinator.quit() def do(self, task): """ Perform some work in a worker created by C{createWorker}. @param task: the callable to run """ self._quit.check() self._coordinator.do(lambda: self._coordinateThisTask(task)) def _coordinateThisTask(self, task): """ Select a worker to dispatch to, either an idle one or a new one, and perform it. This method should run on the coordinator worker. @param task: the task to dispatch @type task: 0-argument callable """ worker = self._idle.pop() if self._idle else self._createWorker() if worker is None: # The createWorker method may return None if we're out of resources # to create workers. self._pending.append(task) return self._busyCount += 1 @worker.do def doWork(): try: task() except BaseException: self._logException() @self._coordinator.do def idleAndPending(): self._busyCount -= 1 self._recycleWorker(worker) def _recycleWorker(self, worker): """ Called only from coordinator. Recycle the given worker into the idle pool. @param worker: a worker created by C{createWorker} and now idle. @type worker: L{IWorker} """ self._idle.add(worker) if self._pending: # Re-try the first enqueued thing. # (Explicitly do _not_ honor _quit.) self._coordinateThisTask(self._pending.popleft()) elif self._shouldQuitCoordinator: self._quitIdlers() elif self._toShrink > 0: self._toShrink -= 1 self._idle.remove(worker) worker.quit() def quit(self): """ Stop doing work and shut down all idle workers. """ self._quit.set() # In case all the workers are idle when we do this. @self._coordinator.do def startFinishing(): self._shouldQuitCoordinator = True self._quitIdlers() PK Mb�Z���~ ~ _threads/_convenience.pynu �[��� # -*- test-case-name: twisted._threads.test.test_convenience -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Common functionality used within the implementation of various workers. """ from ._ithreads import AlreadyQuit class Quit: """ A flag representing whether a worker has been quit. @ivar isSet: Whether this flag is set. @type isSet: L{bool} """ def __init__(self): """ Create a L{Quit} un-set. """ self.isSet = False def set(self): """ Set the flag if it has not been set. @raise AlreadyQuit: If it has been set. """ self.check() self.isSet = True def check(self): """ Check if the flag has been set. @raise AlreadyQuit: If it has been set. """ if self.isSet: raise AlreadyQuit() PK Mb�Z��^�� � _threads/_ithreads.pynu �[��� # -*- test-case-name: twisted._threads.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Interfaces related to threads. """ from zope.interface import Interface class AlreadyQuit(Exception): """ This worker worker is dead and cannot execute more instructions. """ class IWorker(Interface): """ A worker that can perform some work concurrently. All methods on this interface must be thread-safe. """ def do(task): """ Perform the given task. As an interface, this method makes no specific claims about concurrent execution. An L{IWorker}'s C{do} implementation may defer execution for later on the same thread, immediately on a different thread, or some combination of the two. It is valid for a C{do} method to schedule C{task} in such a way that it may never be executed. It is important for some implementations to provide specific properties with respect to where C{task} is executed, of course, and client code may rely on a more specific implementation of C{do} than L{IWorker}. @param task: a task to call in a thread or other concurrent context. @type task: 0-argument callable @raise AlreadyQuit: if C{quit} has been called. """ def quit(): """ Free any resources associated with this L{IWorker} and cause it to reject all future work. @raise AlreadyQuit: if this method has already been called. """ class IExclusiveWorker(IWorker): """ Like L{IWorker}, but with the additional guarantee that the callables passed to C{do} will not be called exclusively with each other. """ PK Mb�Z��z� � _threads/_threadworker.pynu �[��� # -*- test-case-name: twisted._threads.test.test_threadworker -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Implementation of an L{IWorker} based on native threads and queues. """ from zope.interface import implementer from ._convenience import Quit from ._ithreads import IExclusiveWorker _stop = object() @implementer(IExclusiveWorker) class ThreadWorker: """ An L{IExclusiveWorker} implemented based on a single thread and a queue. This worker ensures exclusivity (i.e. it is an L{IExclusiveWorker} and not an L{IWorker}) by performing all of the work passed to C{do} on the I{same} thread. """ def __init__(self, startThread, queue): """ Create a L{ThreadWorker} with a function to start a thread and a queue to use to communicate with that thread. @param startThread: a callable that takes a callable to run in another thread. @type startThread: callable taking a 0-argument callable and returning nothing. @param queue: A L{Queue} to use to give tasks to the thread created by C{startThread}. @type queue: L{Queue} """ self._q = queue self._hasQuit = Quit() def work(): for task in iter(queue.get, _stop): task() startThread(work) def do(self, task): """ Perform the given task on the thread owned by this L{ThreadWorker}. @param task: the function to call on a thread. """ self._hasQuit.check() self._q.put(task) def quit(self): """ Reject all future work and stop the thread started by C{__init__}. """ # Reject all future work. Set this _before_ enqueueing _stop, so # that no work is ever enqueued _after_ _stop. self._hasQuit.set() self._q.put(_stop) @implementer(IExclusiveWorker) class LockWorker: """ An L{IWorker} implemented based on a mutual-exclusion lock. """ def __init__(self, lock, local): """ @param lock: A mutual-exclusion lock, with C{acquire} and C{release} methods. @type lock: L{threading.Lock} @param local: Local storage. @type local: L{threading.local} """ self._quit = Quit() self._lock = lock self._local = local def do(self, work): """ Do the given work on this thread, with the mutex acquired. If this is called re-entrantly, return and wait for the outer invocation to do the work. @param work: the work to do with the lock held. """ lock = self._lock local = self._local self._quit.check() working = getattr(local, "working", None) if working is None: working = local.working = [] working.append(work) lock.acquire() try: while working: working.pop(0)() finally: lock.release() local.working = None else: working.append(work) def quit(self): """ Quit this L{LockWorker}. """ self._quit.set() self._lock = None PK Mb�Z�b�9 9 _threads/_memory.pynu �[��� # -*- test-case-name: twisted._threads.test.test_memory -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Implementation of an in-memory worker that defers execution. """ from zope.interface import implementer from . import IWorker from ._convenience import Quit NoMoreWork = object() @implementer(IWorker) class MemoryWorker: """ An L{IWorker} that queues work for later performance. @ivar _quit: a flag indicating @type _quit: L{Quit} """ def __init__(self, pending=list): """ Create a L{MemoryWorker}. """ self._quit = Quit() self._pending = pending() def do(self, work): """ Queue some work for to perform later; see L{createMemoryWorker}. @param work: The work to perform. """ self._quit.check() self._pending.append(work) def quit(self): """ Quit this worker. """ self._quit.set() self._pending.append(NoMoreWork) def createMemoryWorker(): """ Create an L{IWorker} that does nothing but defer work, to be performed later. @return: a worker that will enqueue work to perform later, and a callable that will perform one element of that work. @rtype: 2-L{tuple} of (L{IWorker}, L{callable}) """ def perform(): if not worker._pending: return False if worker._pending[0] is NoMoreWork: return False worker._pending.pop(0)() return True worker = MemoryWorker() return (worker, perform) PK Mb�Z*\f�� � _threads/__init__.pynu �[��� # -*- test-case-name: twisted.test.test_paths -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted integration with operating system threads. """ from ._ithreads import AlreadyQuit, IWorker from ._memory import createMemoryWorker from ._pool import pool from ._team import Team from ._threadworker import LockWorker, ThreadWorker __all__ = [ "ThreadWorker", "LockWorker", "IWorker", "AlreadyQuit", "Team", "createMemoryWorker", "pool", ] PK Mb�Z��(H� H� protocols/sip.pynu �[��� # -*- test-case-name: twisted.test.test_sip -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Session Initialization Protocol. Documented in RFC 2543. [Superseded by 3261] """ import socket import time import warnings from collections import OrderedDict from typing import Dict, List from zope.interface import Interface, implementer from twisted import cred from twisted.internet import defer, protocol, reactor from twisted.protocols import basic from twisted.python import log PORT = 5060 # SIP headers have short forms shortHeaders = { "call-id": "i", "contact": "m", "content-encoding": "e", "content-length": "l", "content-type": "c", "from": "f", "subject": "s", "to": "t", "via": "v", } longHeaders = {} for k, v in shortHeaders.items(): longHeaders[v] = k del k, v statusCodes = { 100: "Trying", 180: "Ringing", 181: "Call Is Being Forwarded", 182: "Queued", 183: "Session Progress", 200: "OK", 300: "Multiple Choices", 301: "Moved Permanently", 302: "Moved Temporarily", 303: "See Other", 305: "Use Proxy", 380: "Alternative Service", 400: "Bad Request", 401: "Unauthorized", 402: "Payment Required", 403: "Forbidden", 404: "Not Found", 405: "Method Not Allowed", 406: "Not Acceptable", 407: "Proxy Authentication Required", 408: "Request Timeout", 409: "Conflict", # Not in RFC3261 410: "Gone", 411: "Length Required", # Not in RFC3261 413: "Request Entity Too Large", 414: "Request-URI Too Large", 415: "Unsupported Media Type", 416: "Unsupported URI Scheme", 420: "Bad Extension", 421: "Extension Required", 423: "Interval Too Brief", 480: "Temporarily Unavailable", 481: "Call/Transaction Does Not Exist", 482: "Loop Detected", 483: "Too Many Hops", 484: "Address Incomplete", 485: "Ambiguous", 486: "Busy Here", 487: "Request Terminated", 488: "Not Acceptable Here", 491: "Request Pending", 493: "Undecipherable", 500: "Internal Server Error", 501: "Not Implemented", 502: "Bad Gateway", # No donut 503: "Service Unavailable", 504: "Server Time-out", 505: "SIP Version not supported", 513: "Message Too Large", 600: "Busy Everywhere", 603: "Decline", 604: "Does not exist anywhere", 606: "Not Acceptable", } specialCases = { "cseq": "CSeq", "call-id": "Call-ID", "www-authenticate": "WWW-Authenticate", } def dashCapitalize(s): """ Capitalize a string, making sure to treat '-' as a word separator """ return "-".join([x.capitalize() for x in s.split("-")]) def unq(s): if s[0] == s[-1] == '"': return s[1:-1] return s _absent = object() class Via: """ A L{Via} is a SIP Via header, representing a segment of the path taken by the request. See RFC 3261, sections 8.1.1.7, 18.2.2, and 20.42. @ivar transport: Network protocol used for this leg. (Probably either "TCP" or "UDP".) @type transport: C{str} @ivar branch: Unique identifier for this request. @type branch: C{str} @ivar host: Hostname or IP for this leg. @type host: C{str} @ivar port: Port used for this leg. @type port C{int}, or None. @ivar rportRequested: Whether to request RFC 3581 client processing or not. @type rportRequested: C{bool} @ivar rportValue: Servers wishing to honor requests for RFC 3581 processing should set this parameter to the source port the request was received from. @type rportValue: C{int}, or None. @ivar ttl: Time-to-live for requests on multicast paths. @type ttl: C{int}, or None. @ivar maddr: The destination multicast address, if any. @type maddr: C{str}, or None. @ivar hidden: Obsolete in SIP 2.0. @type hidden: C{bool} @ivar otherParams: Any other parameters in the header. @type otherParams: C{dict} """ def __init__( self, host, port=PORT, transport="UDP", ttl=None, hidden=False, received=None, rport=_absent, branch=None, maddr=None, **kw, ): """ Set parameters of this Via header. All arguments correspond to attributes of the same name. To maintain compatibility with old SIP code, the 'rport' argument is used to determine the values of C{rportRequested} and C{rportValue}. If None, C{rportRequested} is set to True. (The deprecated method for doing this is to pass True.) If an integer, C{rportValue} is set to the given value. Any arguments not explicitly named here are collected into the C{otherParams} dict. """ self.transport = transport self.host = host self.port = port self.ttl = ttl self.hidden = hidden self.received = received if rport is True: warnings.warn( "rport=True is deprecated since Twisted 9.0.", DeprecationWarning, stacklevel=2, ) self.rportValue = None self.rportRequested = True elif rport is None: self.rportValue = None self.rportRequested = True elif rport is _absent: self.rportValue = None self.rportRequested = False else: self.rportValue = rport self.rportRequested = False self.branch = branch self.maddr = maddr self.otherParams = kw @property def rport(self): """ Returns the rport value expected by the old SIP code. """ if self.rportRequested == True: return True elif self.rportValue is not None: return self.rportValue else: return None @rport.setter def rport(self, newRPort): """ L{Base._fixupNAT} sets C{rport} directly, so this method sets C{rportValue} based on that. @param newRPort: The new rport value. @type newRPort: C{int} """ self.rportValue = newRPort self.rportRequested = False def toString(self): """ Serialize this header for use in a request or response. """ s = f"SIP/2.0/{self.transport} {self.host}:{self.port}" if self.hidden: s += ";hidden" for n in "ttl", "branch", "maddr", "received": value = getattr(self, n) if value is not None: s += f";{n}={value}" if self.rportRequested: s += ";rport" elif self.rportValue is not None: s += f";rport={self.rport}" etc = sorted(self.otherParams.items()) for k, v in etc: if v is None: s += ";" + k else: s += f";{k}={v}" return s def parseViaHeader(value): """ Parse a Via header. @return: The parsed version of this header. @rtype: L{Via} """ parts = value.split(";") sent, params = parts[0], parts[1:] protocolinfo, by = sent.split(" ", 1) by = by.strip() result = {} pname, pversion, transport = protocolinfo.split("/") if pname != "SIP" or pversion != "2.0": raise ValueError(f"wrong protocol or version: {value!r}") result["transport"] = transport if ":" in by: host, port = by.split(":") result["port"] = int(port) result["host"] = host else: result["host"] = by for p in params: # It's the comment-striping dance! p = p.strip().split(" ", 1) if len(p) == 1: p, comment = p[0], "" else: p, comment = p if p == "hidden": result["hidden"] = True continue parts = p.split("=", 1) if len(parts) == 1: name, value = parts[0], None else: name, value = parts if name in ("rport", "ttl"): value = int(value) result[name] = value return Via(**result) class URL: """ A SIP URL. """ def __init__( self, host, username=None, password=None, port=None, transport=None, usertype=None, method=None, ttl=None, maddr=None, tag=None, other=None, headers=None, ): self.username = username self.host = host self.password = password self.port = port self.transport = transport self.usertype = usertype self.method = method self.tag = tag self.ttl = ttl self.maddr = maddr if other == None: self.other = [] else: self.other = other if headers == None: self.headers = {} else: self.headers = headers def toString(self) -> str: l: List[str] = [] w = l.append w("sip:") if self.username != None: w(self.username) if self.password != None: w(":%s" % self.password) w("@") w(self.host) if self.port != None: w(":%d" % self.port) if self.usertype != None: w(";user=%s" % self.usertype) for n in ("transport", "ttl", "maddr", "method", "tag"): v = getattr(self, n) if v != None: w(f";{n}={v}") for v in self.other: w(";%s" % v) if self.headers: w("?") w( "&".join( [ (f"{specialCases.get(h) or dashCapitalize(h)}={v}") for (h, v) in self.headers.items() ] ) ) return "".join(l) def __str__(self) -> str: return self.toString() def __repr__(self) -> str: return "<URL {}:{}@{}:{!r}/{}>".format( self.username, self.password, self.host, self.port, self.transport, ) def parseURL(url, host=None, port=None): """ Return string into URL object. URIs are of form 'sip:user@example.com'. """ d = {} if not url.startswith("sip:"): raise ValueError("unsupported scheme: " + url[:4]) parts = url[4:].split(";") userdomain, params = parts[0], parts[1:] udparts = userdomain.split("@", 1) if len(udparts) == 2: userpass, hostport = udparts upparts = userpass.split(":", 1) if len(upparts) == 1: d["username"] = upparts[0] else: d["username"] = upparts[0] d["password"] = upparts[1] else: hostport = udparts[0] hpparts = hostport.split(":", 1) if len(hpparts) == 1: d["host"] = hpparts[0] else: d["host"] = hpparts[0] d["port"] = int(hpparts[1]) if host != None: d["host"] = host if port != None: d["port"] = port for p in params: if p == params[-1] and "?" in p: d["headers"] = h = {} p, headers = p.split("?", 1) for header in headers.split("&"): k, v = header.split("=") h[k] = v nv = p.split("=", 1) if len(nv) == 1: d.setdefault("other", []).append(p) continue name, value = nv if name == "user": d["usertype"] = value elif name in ("transport", "ttl", "maddr", "method", "tag"): if name == "ttl": value = int(value) d[name] = value else: d.setdefault("other", []).append(p) return URL(**d) def cleanRequestURL(url): """ Clean a URL from a Request line. """ url.transport = None url.maddr = None url.ttl = None url.headers = {} def parseAddress(address, host=None, port=None, clean=0): """ Return (name, uri, params) for From/To/Contact header. @param clean: remove unnecessary info, usually for From and To headers. """ address = address.strip() # Simple 'sip:foo' case if address.startswith("sip:"): return "", parseURL(address, host=host, port=port), {} params = {} name, url = address.split("<", 1) name = name.strip() if name.startswith('"'): name = name[1:] if name.endswith('"'): name = name[:-1] url, paramstring = url.split(">", 1) url = parseURL(url, host=host, port=port) paramstring = paramstring.strip() if paramstring: for l in paramstring.split(";"): if not l: continue k, v = l.split("=") params[k] = v if clean: # RFC 2543 6.21 url.ttl = None url.headers = {} url.transport = None url.maddr = None return name, url, params class SIPError(Exception): def __init__(self, code, phrase=None): if phrase is None: phrase = statusCodes[code] Exception.__init__(self, "SIP error (%d): %s" % (code, phrase)) self.code = code self.phrase = phrase class RegistrationError(SIPError): """ Registration was not possible. """ class Message: """ A SIP message. """ length = None def __init__(self): self.headers = OrderedDict() # Map name to list of values self.body = "" self.finished = 0 def addHeader(self, name, value): name = name.lower() name = longHeaders.get(name, name) if name == "content-length": self.length = int(value) self.headers.setdefault(name, []).append(value) def bodyDataReceived(self, data): self.body += data def creationFinished(self): if (self.length != None) and (self.length != len(self.body)): raise ValueError("wrong body length") self.finished = 1 def toString(self): s = "%s\r\n" % self._getHeaderLine() for n, vs in self.headers.items(): for v in vs: s += f"{specialCases.get(n) or dashCapitalize(n)}: {v}\r\n" s += "\r\n" s += self.body return s def _getHeaderLine(self): raise NotImplementedError class Request(Message): """ A Request for a URI """ def __init__(self, method, uri, version="SIP/2.0"): Message.__init__(self) self.method = method if isinstance(uri, URL): self.uri = uri else: self.uri = parseURL(uri) cleanRequestURL(self.uri) def __repr__(self) -> str: return "<SIP Request %d:%s %s>" % (id(self), self.method, self.uri.toString()) def _getHeaderLine(self): return f"{self.method} {self.uri.toString()} SIP/2.0" class Response(Message): """ A Response to a URI Request """ def __init__(self, code, phrase=None, version="SIP/2.0"): Message.__init__(self) self.code = code if phrase == None: phrase = statusCodes[code] self.phrase = phrase def __repr__(self) -> str: return "<SIP Response %d:%s>" % (id(self), self.code) def _getHeaderLine(self): return f"SIP/2.0 {self.code} {self.phrase}" class MessagesParser(basic.LineReceiver): """ A SIP messages parser. Expects dataReceived, dataDone repeatedly, in that order. Shouldn't be connected to actual transport. """ version = "SIP/2.0" acceptResponses = 1 acceptRequests = 1 state = "firstline" # Or "headers", "body" or "invalid" debug = 0 def __init__(self, messageReceivedCallback): self.messageReceived = messageReceivedCallback self.reset() def reset(self, remainingData=""): self.state = "firstline" self.length = None # Body length self.bodyReceived = 0 # How much of the body we received self.message = None self.header = None self.setLineMode(remainingData) def invalidMessage(self): self.state = "invalid" self.setRawMode() def dataDone(self): """ Clear out any buffered data that may be hanging around. """ self.clearLineBuffer() if self.state == "firstline": return if self.state != "body": self.reset() return if self.length == None: # No content-length header, so end of data signals message done self.messageDone() elif self.length < self.bodyReceived: # Aborted in the middle self.reset() else: # We have enough data and message wasn't finished? something is wrong raise RuntimeError("this should never happen") def dataReceived(self, data): try: if isinstance(data, str): data = data.encode("utf-8") basic.LineReceiver.dataReceived(self, data) except Exception: log.err() self.invalidMessage() def handleFirstLine(self, line): """ Expected to create self.message. """ raise NotImplementedError def lineLengthExceeded(self, line): self.invalidMessage() def lineReceived(self, line): if isinstance(line, bytes): line = line.decode("utf-8") if self.state == "firstline": while line.startswith("\n") or line.startswith("\r"): line = line[1:] if not line: return try: a, b, c = line.split(" ", 2) except ValueError: self.invalidMessage() return if a == "SIP/2.0" and self.acceptResponses: # Response try: code = int(b) except ValueError: self.invalidMessage() return self.message = Response(code, c) elif c == "SIP/2.0" and self.acceptRequests: self.message = Request(a, b) else: self.invalidMessage() return self.state = "headers" return else: assert self.state == "headers" if line: # Multiline header if line.startswith(" ") or line.startswith("\t"): name, value = self.header self.header = name, (value + line.lstrip()) else: # New header if self.header: self.message.addHeader(*self.header) self.header = None try: name, value = line.split(":", 1) except ValueError: self.invalidMessage() return self.header = name, value.lstrip() # XXX we assume content-length won't be multiline if name.lower() == "content-length": try: self.length = int(value.lstrip()) except ValueError: self.invalidMessage() return else: # CRLF, we now have message body until self.length bytes, # or if no length was given, until there is no more data # from the connection sending us data. self.state = "body" if self.header: self.message.addHeader(*self.header) self.header = None if self.length == 0: self.messageDone() return self.setRawMode() def messageDone(self, remainingData=""): assert self.state == "body" self.message.creationFinished() self.messageReceived(self.message) self.reset(remainingData) def rawDataReceived(self, data): assert self.state in ("body", "invalid") if isinstance(data, bytes): data = data.decode("utf-8") if self.state == "invalid": return if self.length == None: self.message.bodyDataReceived(data) else: dataLen = len(data) expectedLen = self.length - self.bodyReceived if dataLen > expectedLen: self.message.bodyDataReceived(data[:expectedLen]) self.messageDone(data[expectedLen:]) return else: self.bodyReceived += dataLen self.message.bodyDataReceived(data) if self.bodyReceived == self.length: self.messageDone() class Base(protocol.DatagramProtocol): """ Base class for SIP clients and servers. """ PORT = PORT debug = False def __init__(self): self.messages = [] self.parser = MessagesParser(self.addMessage) def addMessage(self, msg): self.messages.append(msg) def datagramReceived(self, data, addr): self.parser.dataReceived(data) self.parser.dataDone() for m in self.messages: self._fixupNAT(m, addr) if self.debug: log.msg(f"Received {m.toString()!r} from {addr!r}") if isinstance(m, Request): self.handle_request(m, addr) else: self.handle_response(m, addr) self.messages[:] = [] def _fixupNAT(self, message, sourcePeer): # RFC 2543 6.40.2, (srcHost, srcPort) = sourcePeer senderVia = parseViaHeader(message.headers["via"][0]) if senderVia.host != srcHost: senderVia.received = srcHost if senderVia.port != srcPort: senderVia.rport = srcPort message.headers["via"][0] = senderVia.toString() elif senderVia.rport == True: senderVia.received = srcHost senderVia.rport = srcPort message.headers["via"][0] = senderVia.toString() def deliverResponse(self, responseMessage): """ Deliver response. Destination is based on topmost Via header. """ destVia = parseViaHeader(responseMessage.headers["via"][0]) # XXX we don't do multicast yet host = destVia.received or destVia.host port = destVia.rport or destVia.port or self.PORT destAddr = URL(host=host, port=port) self.sendMessage(destAddr, responseMessage) def responseFromRequest(self, code, request): """ Create a response to a request message. """ response = Response(code) for name in ("via", "to", "from", "call-id", "cseq"): response.headers[name] = request.headers.get(name, [])[:] return response def sendMessage(self, destURL, message): """ Send a message. @param destURL: C{URL}. This should be a *physical* URL, not a logical one. @param message: The message to send. """ if destURL.transport not in ("udp", None): raise RuntimeError("only UDP currently supported") if self.debug: log.msg(f"Sending {message.toString()!r} to {destURL!r}") data = message.toString() if isinstance(data, str): data = data.encode("utf-8") self.transport.write(data, (destURL.host, destURL.port or self.PORT)) def handle_request(self, message, addr): """ Override to define behavior for requests received @type message: C{Message} @type addr: C{tuple} """ raise NotImplementedError def handle_response(self, message, addr): """ Override to define behavior for responses received. @type message: C{Message} @type addr: C{tuple} """ raise NotImplementedError class IContact(Interface): """ A user of a registrar or proxy """ class Registration: def __init__(self, secondsToExpiry, contactURL): self.secondsToExpiry = secondsToExpiry self.contactURL = contactURL class IRegistry(Interface): """ Allows registration of logical->physical URL mapping. """ def registerAddress(domainURL, logicalURL, physicalURL): """ Register the physical address of a logical URL. @return: Deferred of C{Registration} or failure with RegistrationError. """ def unregisterAddress(domainURL, logicalURL, physicalURL): """ Unregister the physical address of a logical URL. @return: Deferred of C{Registration} or failure with RegistrationError. """ def getRegistrationInfo(logicalURL): """ Get registration info for logical URL. @return: Deferred of C{Registration} object or failure of LookupError. """ class ILocator(Interface): """ Allow looking up physical address for logical URL. """ def getAddress(logicalURL): """ Return physical URL of server for logical URL of user. @param logicalURL: a logical C{URL}. @return: Deferred which becomes URL or fails with LookupError. """ class Proxy(Base): """ SIP proxy. """ PORT = PORT locator = None # Object implementing ILocator def __init__(self, host=None, port=PORT): """ Create new instance. @param host: our hostname/IP as set in Via headers. @param port: our port as set in Via headers. """ self.host = host or socket.getfqdn() self.port = port Base.__init__(self) def getVia(self): """ Return value of Via header for this proxy. """ return Via(host=self.host, port=self.port) def handle_request(self, message, addr): # Send immediate 100/trying message before processing # self.deliverResponse(self.responseFromRequest(100, message)) f = getattr(self, "handle_%s_request" % message.method, None) if f is None: f = self.handle_request_default try: d = f(message, addr) except SIPError as e: self.deliverResponse(self.responseFromRequest(e.code, message)) except BaseException: log.err() self.deliverResponse(self.responseFromRequest(500, message)) else: if d is not None: d.addErrback( lambda e: self.deliverResponse( self.responseFromRequest(e.code, message) ) ) def handle_request_default(self, message, sourcePeer): """ Default request handler. Default behaviour for OPTIONS and unknown methods for proxies is to forward message on to the client. Since at the moment we are stateless proxy, that's basically everything. """ (srcHost, srcPort) = sourcePeer def _mungContactHeader(uri, message): message.headers["contact"][0] = uri.toString() return self.sendMessage(uri, message) viaHeader = self.getVia() if viaHeader.toString() in message.headers["via"]: # Must be a loop, so drop message log.msg("Dropping looped message.") return message.headers["via"].insert(0, viaHeader.toString()) name, uri, tags = parseAddress(message.headers["to"][0], clean=1) # This is broken and needs refactoring to use cred d = self.locator.getAddress(uri) d.addCallback(self.sendMessage, message) d.addErrback(self._cantForwardRequest, message) def _cantForwardRequest(self, error, message): error.trap(LookupError) del message.headers["via"][0] # This'll be us self.deliverResponse(self.responseFromRequest(404, message)) def deliverResponse(self, responseMessage): """ Deliver response. Destination is based on topmost Via header. """ destVia = parseViaHeader(responseMessage.headers["via"][0]) # XXX we don't do multicast yet host = destVia.received or destVia.host port = destVia.rport or destVia.port or self.PORT destAddr = URL(host=host, port=port) self.sendMessage(destAddr, responseMessage) def responseFromRequest(self, code, request): """ Create a response to a request message. """ response = Response(code) for name in ("via", "to", "from", "call-id", "cseq"): response.headers[name] = request.headers.get(name, [])[:] return response def handle_response(self, message, addr): """ Default response handler. """ v = parseViaHeader(message.headers["via"][0]) if (v.host, v.port) != (self.host, self.port): # We got a message not intended for us? # XXX note this check breaks if we have multiple external IPs # yay for suck protocols log.msg("Dropping incorrectly addressed message") return del message.headers["via"][0] if not message.headers["via"]: # This message is addressed to us self.gotResponse(message, addr) return self.deliverResponse(message) def gotResponse(self, message, addr): """ Called with responses that are addressed at this server. """ pass class IAuthorizer(Interface): def getChallenge(peer): """ Generate a challenge the client may respond to. @type peer: C{tuple} @param peer: The client's address @rtype: C{str} @return: The challenge string """ def decode(response): """ Create a credentials object from the given response. @type response: C{str} """ class RegisterProxy(Proxy): """ A proxy that allows registration for a specific domain. Unregistered users won't be handled. """ portal = None registry = None # Should implement IRegistry authorizers: Dict[str, IAuthorizer] = {} def __init__(self, *args, **kw): Proxy.__init__(self, *args, **kw) self.liveChallenges = {} def handle_ACK_request(self, message, host_port): # XXX # ACKs are a client's way of indicating they got the last message # Responding to them is not a good idea. # However, we should keep track of terminal messages and re-transmit # if no ACK is received. (host, port) = host_port pass def handle_REGISTER_request(self, message, host_port): """ Handle a registration request. Currently registration is not proxied. """ (host, port) = host_port if self.portal is None: # There is no portal. Let anyone in. self.register(message, host, port) else: # There is a portal. Check for credentials. if "authorization" not in message.headers: return self.unauthorized(message, host, port) else: return self.login(message, host, port) def unauthorized(self, message, host, port): m = self.responseFromRequest(401, message) for scheme, auth in self.authorizers.items(): chal = auth.getChallenge((host, port)) if chal is None: value = f'{scheme.title()} realm="{self.host}"' else: value = f'{scheme.title()} {chal},realm="{self.host}"' m.headers.setdefault("www-authenticate", []).append(value) self.deliverResponse(m) def login(self, message, host, port): parts = message.headers["authorization"][0].split(None, 1) a = self.authorizers.get(parts[0].lower()) if a: try: c = a.decode(parts[1]) except SIPError: raise except BaseException: log.err() self.deliverResponse(self.responseFromRequest(500, message)) else: c.username += "@" + self.host self.portal.login(c, None, IContact).addCallback( self._cbLogin, message, host, port ).addErrback(self._ebLogin, message, host, port).addErrback(log.err) else: self.deliverResponse(self.responseFromRequest(501, message)) def _cbLogin(self, i_a_l, message, host, port): # It's stateless, matey. What a joke. (i, a, l) = i_a_l self.register(message, host, port) def _ebLogin(self, failure, message, host, port): failure.trap(cred.error.UnauthorizedLogin) self.unauthorized(message, host, port) def register(self, message, host, port): """ Allow all users to register """ name, toURL, params = parseAddress(message.headers["to"][0], clean=1) contact = None if "contact" in message.headers: contact = message.headers["contact"][0] if message.headers.get("expires", [None])[0] == "0": self.unregister(message, toURL, contact) else: # XXX Check expires on appropriate URL, and pass it to registry # instead of having registry hardcode it. if contact is not None: name, contactURL, params = parseAddress(contact, host=host, port=port) d = self.registry.registerAddress(message.uri, toURL, contactURL) else: d = self.registry.getRegistrationInfo(toURL) d.addCallbacks( self._cbRegister, self._ebRegister, callbackArgs=(message,), errbackArgs=(message,), ) def _cbRegister(self, registration, message): response = self.responseFromRequest(200, message) if registration.contactURL != None: response.addHeader("contact", registration.contactURL.toString()) response.addHeader("expires", "%d" % registration.secondsToExpiry) response.addHeader("content-length", "0") self.deliverResponse(response) def _ebRegister(self, error, message): error.trap(RegistrationError, LookupError) # XXX return error message, and alter tests to deal with # this, currently tests assume no message sent on failure def unregister(self, message, toURL, contact): try: expires = int(message.headers["expires"][0]) except ValueError: self.deliverResponse(self.responseFromRequest(400, message)) else: if expires == 0: if contact == "*": contactURL = "*" else: name, contactURL, params = parseAddress(contact) d = self.registry.unregisterAddress(message.uri, toURL, contactURL) d.addCallback(self._cbUnregister, message).addErrback( self._ebUnregister, message ) def _cbUnregister(self, registration, message): msg = self.responseFromRequest(200, message) msg.headers.setdefault("contact", []).append(registration.contactURL.toString()) msg.addHeader("expires", "0") self.deliverResponse(msg) def _ebUnregister(self, registration, message): pass @implementer(IRegistry, ILocator) class InMemoryRegistry: """ A simplistic registry for a specific domain. """ def __init__(self, domain): self.domain = domain # The domain we handle registration for self.users = {} # Map username to (IDelayedCall for expiry, address URI) def getAddress(self, userURI): if userURI.host != self.domain: return defer.fail(LookupError("unknown domain")) if userURI.username in self.users: dc, url = self.users[userURI.username] return defer.succeed(url) else: return defer.fail(LookupError("no such user")) def getRegistrationInfo(self, userURI): if userURI.host != self.domain: return defer.fail(LookupError("unknown domain")) if userURI.username in self.users: dc, url = self.users[userURI.username] return defer.succeed(Registration(int(dc.getTime() - time.time()), url)) else: return defer.fail(LookupError("no such user")) def _expireRegistration(self, username): try: dc, url = self.users[username] except KeyError: return defer.fail(LookupError("no such user")) else: dc.cancel() del self.users[username] return defer.succeed(Registration(0, url)) def registerAddress(self, domainURL, logicalURL, physicalURL): if domainURL.host != self.domain: log.msg("Registration for domain we don't handle.") return defer.fail(RegistrationError(404)) if logicalURL.host != self.domain: log.msg("Registration for domain we don't handle.") return defer.fail(RegistrationError(404)) if logicalURL.username in self.users: dc, old = self.users[logicalURL.username] dc.reset(3600) else: dc = reactor.callLater(3600, self._expireRegistration, logicalURL.username) log.msg(f"Registered {logicalURL.toString()} at {physicalURL.toString()}") self.users[logicalURL.username] = (dc, physicalURL) return defer.succeed(Registration(int(dc.getTime() - time.time()), physicalURL)) def unregisterAddress(self, domainURL, logicalURL, physicalURL): return self._expireRegistration(logicalURL.username) PK Mb�Z�)с� � protocols/ident.pynu �[��� # -*- test-case-name: twisted.test.test_ident -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Ident protocol implementation. """ import struct from twisted.internet import defer from twisted.protocols import basic from twisted.python import failure, log _MIN_PORT = 1 _MAX_PORT = 2 ** 16 - 1 class IdentError(Exception): """ Can't determine connection owner; reason unknown. """ identDescription = "UNKNOWN-ERROR" def __str__(self) -> str: return self.identDescription class NoUser(IdentError): """ The connection specified by the port pair is not currently in use or currently not owned by an identifiable entity. """ identDescription = "NO-USER" class InvalidPort(IdentError): """ Either the local or foreign port was improperly specified. This should be returned if either or both of the port ids were out of range (TCP port numbers are from 1-65535), negative integers, reals or in any fashion not recognized as a non-negative integer. """ identDescription = "INVALID-PORT" class HiddenUser(IdentError): """ The server was able to identify the user of this port, but the information was not returned at the request of the user. """ identDescription = "HIDDEN-USER" class IdentServer(basic.LineOnlyReceiver): """ The Identification Protocol (a.k.a., "ident", a.k.a., "the Ident Protocol") provides a means to determine the identity of a user of a particular TCP connection. Given a TCP port number pair, it returns a character string which identifies the owner of that connection on the server's system. Server authors should subclass this class and override the lookup method. The default implementation returns an UNKNOWN-ERROR response for every query. """ def lineReceived(self, line): parts = line.split(",") if len(parts) != 2: self.invalidQuery() else: try: portOnServer, portOnClient = map(int, parts) except ValueError: self.invalidQuery() else: if ( _MIN_PORT <= portOnServer <= _MAX_PORT and _MIN_PORT <= portOnClient <= _MAX_PORT ): self.validQuery(portOnServer, portOnClient) else: self._ebLookup( failure.Failure(InvalidPort()), portOnServer, portOnClient ) def invalidQuery(self): self.transport.loseConnection() def validQuery(self, portOnServer, portOnClient): """ Called when a valid query is received to look up and deliver the response. @param portOnServer: The server port from the query. @param portOnClient: The client port from the query. """ serverAddr = self.transport.getHost().host, portOnServer clientAddr = self.transport.getPeer().host, portOnClient defer.maybeDeferred(self.lookup, serverAddr, clientAddr).addCallback( self._cbLookup, portOnServer, portOnClient ).addErrback(self._ebLookup, portOnServer, portOnClient) def _cbLookup(self, result, sport, cport): (sysName, userId) = result self.sendLine("%d, %d : USERID : %s : %s" % (sport, cport, sysName, userId)) def _ebLookup(self, failure, sport, cport): if failure.check(IdentError): self.sendLine("%d, %d : ERROR : %s" % (sport, cport, failure.value)) else: log.err(failure) self.sendLine( "%d, %d : ERROR : %s" % (sport, cport, IdentError(failure.value)) ) def lookup(self, serverAddress, clientAddress): """ Lookup user information about the specified address pair. Return value should be a two-tuple of system name and username. Acceptable values for the system name may be found online at:: U{http://www.iana.org/assignments/operating-system-names} This method may also raise any IdentError subclass (or IdentError itself) to indicate user information will not be provided for the given query. A Deferred may also be returned. @param serverAddress: A two-tuple representing the server endpoint of the address being queried. The first element is a string holding a dotted-quad IP address. The second element is an integer representing the port. @param clientAddress: Like I{serverAddress}, but represents the client endpoint of the address being queried. """ raise IdentError() class ProcServerMixin: """Implements lookup() to grab entries for responses from /proc/net/tcp""" SYSTEM_NAME = "LINUX" try: from pwd import getpwuid def getUsername(self, uid, getpwuid=getpwuid): return getpwuid(uid)[0] del getpwuid except ImportError: def getUsername(self, uid, getpwuid=None): raise IdentError() def entries(self): with open("/proc/net/tcp") as f: f.readline() for L in f: yield L.strip() def dottedQuadFromHexString(self, hexstr): return ".".join( map(str, struct.unpack("4B", struct.pack("=L", int(hexstr, 16)))) ) def unpackAddress(self, packed): addr, port = packed.split(":") addr = self.dottedQuadFromHexString(addr) port = int(port, 16) return addr, port def parseLine(self, line): parts = line.strip().split() localAddr, localPort = self.unpackAddress(parts[1]) remoteAddr, remotePort = self.unpackAddress(parts[2]) uid = int(parts[7]) return (localAddr, localPort), (remoteAddr, remotePort), uid def lookup(self, serverAddress, clientAddress): for ent in self.entries(): localAddr, remoteAddr, uid = self.parseLine(ent) if remoteAddr == clientAddress and localAddr[1] == serverAddress[1]: return (self.SYSTEM_NAME, self.getUsername(uid)) raise NoUser() class IdentClient(basic.LineOnlyReceiver): errorTypes = (IdentError, NoUser, InvalidPort, HiddenUser) def __init__(self): self.queries = [] def lookup(self, portOnServer, portOnClient): """ Lookup user information about the specified address pair. """ self.queries.append((defer.Deferred(), portOnServer, portOnClient)) if len(self.queries) > 1: return self.queries[-1][0] self.sendLine("%d, %d" % (portOnServer, portOnClient)) return self.queries[-1][0] def lineReceived(self, line): if not self.queries: log.msg(f"Unexpected server response: {line!r}") else: d, _, _ = self.queries.pop(0) self.parseResponse(d, line) if self.queries: self.sendLine("%d, %d" % (self.queries[0][1], self.queries[0][2])) def connectionLost(self, reason): for q in self.queries: q[0].errback(IdentError(reason)) self.queries = [] def parseResponse(self, deferred, line): parts = line.split(":", 2) if len(parts) != 3: deferred.errback(IdentError(line)) else: ports, type, addInfo = map(str.strip, parts) if type == "ERROR": for et in self.errorTypes: if et.identDescription == addInfo: deferred.errback(et(line)) return deferred.errback(IdentError(line)) else: deferred.callback((type, addInfo)) __all__ = [ "IdentError", "NoUser", "InvalidPort", "HiddenUser", "IdentServer", "IdentClient", "ProcServerMixin", ] PK Mb�Zf�� � protocols/stateful.pynu �[��� # -*- test-case-name: twisted.test.test_stateful -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. from io import BytesIO from twisted.internet import protocol class StatefulProtocol(protocol.Protocol): """A Protocol that stores state for you. state is a pair (function, num_bytes). When num_bytes bytes of data arrives from the network, function is called. It is expected to return the next state or None to keep same state. Initial state is returned by getInitialState (override it). """ _sful_data = None, None, 0 def makeConnection(self, transport): protocol.Protocol.makeConnection(self, transport) self._sful_data = self.getInitialState(), BytesIO(), 0 def getInitialState(self): raise NotImplementedError def dataReceived(self, data): state, buffer, offset = self._sful_data buffer.seek(0, 2) buffer.write(data) blen = buffer.tell() # how many bytes total is in the buffer buffer.seek(offset) while blen - offset >= state[1]: d = buffer.read(state[1]) offset += state[1] next = state[0](d) if ( self.transport.disconnecting ): # XXX: argh stupid hack borrowed right from LineReceiver return # dataReceived won't be called again, so who cares about consistent state if next: state = next if offset != 0: b = buffer.read() buffer.seek(0) buffer.truncate() buffer.write(b) offset = 0 self._sful_data = state, buffer, offset PK Mb�Zz� , protocols/__pycache__/finger.cpython-310.pycnu �[��� o �b� � @ s& d Z ddlmZ G dd� dej�ZdS )z/The Finger User Information Protocol (RFC 1288)� )�basicc @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �Fingerc C s� |� � }|s dg}t|�dkrd}nd}|d }d|v r6|�d�}|d |� }||d d � }| �|||�S |r>| �||�S | �|�S )N� � r ���� @)�split�len�rfind� forwardQuery�getUser� getDomain)�self�line�parts�slash_w�user� hostPlace�host� r �:/usr/lib/python3/dist-packages/twisted/protocols/finger.py� lineReceived s zFinger.lineReceivedc C s | j �|d � | j �� d S )N� )� transport�write�loseConnection)r �messager r r �_refuseMessage s zFinger._refuseMessagec C � | � d� d S )Ns Finger forwarding service denied�r )r r r r r r r r " � zFinger.forwardQueryc C r )Ns Finger online list deniedr )r r r r r r % r zFinger.getDomainc C s" | j �d| d � | �d� d S )Ns Login: r s No such user)r r r )r r r r r r r ( s zFinger.getUserN)�__name__� __module__� __qualname__r r r r r r r r r r s r N)�__doc__�twisted.protocolsr � LineReceiverr r r r r �<module> s PK Mb�Z���Q�1 �1 . protocols/__pycache__/loopback.cpython-310.pycnu �[��� o �b�. � @ s$ d Z ddlZddlmZ ddlmZmZmZmZ ddl m Z ddl m Z ddl mZ ddlmZ G d d � d �Zee �G d d � d ��Zeejej�G d d� d��Zdd� Zdd� Zefdd�Zdd� Zdd� Zeejej�G dd� d��ZG dd � d ej �Z G d d � d ej �Z d$d d!�Z d%d"d#�Z!dS )&zF Testing support for protocols -- loopback between client and server. � N)� implementer)�defer� interfaces�main�protocol)�IAddress)� deferLater)�policies)�failurec @ s< e Zd ZdZdZdZdd� Zdd� Zdd � ZeZ d d � Z dS ) �_LoopbackQueuez� Trivial wrapper around a list to give it an interface like a queue, which the addition of also sending notifications by way of a Deferred whenever the list has something added to it. NFc C s g | _ d S �N)�_queue��self� r �</usr/lib/python3/dist-packages/twisted/protocols/loopback.py�__init__" � z_LoopbackQueue.__init__c C s6 | j �|� | jd ur| jd }| _|�d � d S d S r )r �append�_notificationDeferred�callback)r �v�dr r r �put% s �z_LoopbackQueue.putc C s t | j�S r )�boolr r r r r � __nonzero__+ r z_LoopbackQueue.__nonzero__c C s | j �d�S �Nr )r �popr r r r �get0 s z_LoopbackQueue.get) �__name__� __module__� __qualname__�__doc__r � disconnectr r r �__bool__r r r r r r s r c @ s e Zd ZdS )�_LoopbackAddressN)r r r! r r r r r% 4 s r% c @ sd e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� ZdS )�_LoopbackTransportFNc C � || _ d S r )�q)r r( r r r r ? r z_LoopbackTransport.__init__c C s" t |t�s td��| j�|� d S )Nz"Can only write bytes to ITransport)� isinstance�bytes� TypeErrorr( r �r �datar r r �writeB s z_LoopbackTransport.writec C s | j �d�|�� d S �N� )r( r �join�r �iovecr r r � writeSequenceG s z _LoopbackTransport.writeSequencec C s d| j _| j �d � d S )NT)r( r# r r r r r �loseConnectionJ s z!_LoopbackTransport.loseConnectionc C s | � � dS )zB Abort the connection. Same as L{loseConnection}. N)r5 r r r r �abortConnectionN s z"_LoopbackTransport.abortConnectionc C � t � S r �r% r r r r �getPeerT � z_LoopbackTransport.getPeerc C r7 r r8 r r r r �getHostW r: z_LoopbackTransport.getHostc C s& | j d u sJ �|| _ || _| �� d S r )�producer�streamingProducer� _pollProducer�r r< � streamingr r r �registerProducer[ s z#_LoopbackTransport.registerProducerc C s | j d usJ �d | _ d S r �r< r r r r �unregisterProducera s z%_LoopbackTransport.unregisterProducerc C s& | j d ur| js| j �� d S d S d S r )r< r= �resumeProducingr r r r r> e s �z _LoopbackTransport._pollProducer)r r r! � disconnectingr< r r. r4 r5 r6 r9 r; rA rC r> r r r r r& 9 s r& c C s. | r| � � }|du r dS |�|� | sdS dS )z� L{identityPumpPolicy} is a policy which delivers each chunk of data written to the given queue as-is to the target. This isn't a particularly realistic policy. @see: L{loopbackAsync} N)r � dataReceived)�queue�targetr* r r r �identityPumpPolicyj s �rI c C sD g }| r| � � }|du r n|�|� | s|r |�d�|�� dS dS )z� L{collapsingPumpPolicy} is a policy which collapses all outstanding chunks into a single string and delivers it to the target. @see: L{loopbackAsync} Nr0 )r r rF r1 )rG rH r* �chunkr r r �collapsingPumpPolicyz s ��rK c C s8 t � }t � }| �t|�� |�t|�� t| ||||�S )a Establish a connection between C{server} and C{client} then transfer data between them until the connection is closed. This is often useful for testing a protocol. @param server: The protocol instance representing the server-side of this connection. @param client: The protocol instance representing the client-side of this connection. @param pumpPolicy: When either C{server} or C{client} writes to its transport, the string passed in is added to a queue of data for the other protocol. Eventually, C{pumpPolicy} will be called with one such queue and the corresponding protocol object. The pump policy callable is responsible for emptying the queue and passing the strings it contains to the given protocol's C{dataReceived} method. The signature of C{pumpPolicy} is C{(queue, protocol)}. C{queue} is an object with a C{get} method which will return the next string written to the transport, or L{None} if the transport has been disconnected, and which evaluates to C{True} if and only if there are more items to be retrieved via C{get}. @return: A L{Deferred} which fires when the connection has been closed and both sides have received notification of this. )r �makeConnectionr& �_loopbackAsyncBody)�server�client� pumpPolicy�serverToClient�clientToServerr r r � loopbackAsync� s �rS c s� � fdd�} d } }}|| ||�}|||| �}|s3|s3t �� } | |_| |_| �t| |||� � | S |jr?d}|| ||� n |jrJd}|||| � |rc| �t�t j �� |�t�t j �� t � d�S q)ak Transfer bytes from the output queue of each protocol to the input of the other. @param server: The protocol instance representing the server-side of this connection. @param serverToClient: The L{_LoopbackQueue} holding the server's output. @param client: The protocol instance representing the client-side of this connection. @param clientToServer: The L{_LoopbackQueue} holding the client's output. @param pumpPolicy: See L{loopbackAsync}. @return: A L{Deferred} which fires when the connection has been closed and both sides have received notification of this. c s, d}|r � ||� d}|r|s| j �� |S )NFT)� transportr> )�sourcer( rH �sent�rP r r �pump� s z _loopbackAsyncBody.<locals>.pump� FTN) r �Deferredr � addCallback�_loopbackAsyncContinuer# �connectionLostr �Failurer �CONNECTION_DONE�succeed) rN rQ rO rR rP rX r# � clientSent� serverSentr r rW r rM � s: � �rM c C s. d |_ d |_ ddlm} t|dt|||||�S )Nr ��reactor)r �twisted.internetrd r rM )�ignoredrN rQ rO rR rP rd r r r r\ � s �r\ c @ sn e Zd ZdZdZdZdZddd�Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dd� Zdd� Zdd� ZdS )� LoopbackRelayr0 r Nc C s || _ || _d S r )rH �logFile)r rH rh r r r r s zLoopbackRelay.__init__c C s. | j | | _ | jr| j�dt|� � d S d S )Nzloopback writing %s )�bufferrh r. �reprr, r r r r. s �zLoopbackRelay.writec C s | � d�|�� d S r/ )r. r1 r2 r r r r4 " s zLoopbackRelay.writeSequencec C s� | j dkrd S | jr| j�� | jr,| jr | j�dt| j� � | j}d| _| j�|� | j dkr@d| _ | j� t � t j �� d S d S )N���zloopback receiving %s r0 rY )� shouldLoser< rD ri rh r. rj rH rF r] r r^ r r_ )r ri r r r � clearBuffer% s �zLoopbackRelay.clearBufferc C s | j dkr d| _ d S d S )Nrk rY )rl r r r r r5 5 s �z LoopbackRelay.loseConnectionc C � dS �N�loopbackr r r r r r; 9 � zLoopbackRelay.getHostc C rn ro r r r r r r9 < rq zLoopbackRelay.getPeerc C r' r rB r? r r r rA ? r z LoopbackRelay.registerProducerc C s d | _ d S r rB r r r r rC B r z LoopbackRelay.unregisterProducerc C s d| j jj�d�S )Nz Loopback(�))rH � __class__r r r r r � logPrefixE s zLoopbackRelay.logPrefixr )r r r! ri rl rE r< r r. r4 rm r5 r; r9 rA rC rt r r r r rg s rg c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�LoopbackClientFactoryc C s d| _ t�� | _|| _d S r )� disconnectedr rZ �deferredr )r r r r r r J s z LoopbackClientFactory.__init__c C s | j S r )r )r �addrr r r � buildProtocolO r: z#LoopbackClientFactory.buildProtocolc C s d| _ | j�d � d S )NrY )rv rw r )r � connector�reasonr r r �clientConnectionLostR s z*LoopbackClientFactory.clientConnectionLostN)r r r! r ry r| r r r r ru I s ru c @ s e Zd Zdd� Zdd� ZdS )� _FireOnClosec C s t j�| ||� t�� | _d S r )r �ProtocolWrapperr r rZ rw )r r �factoryr r r r X s z_FireOnClose.__init__c C s t j�| |� | j�d � d S r )r r~ r] rw r )r r{ r r r r] \ s z_FireOnClose.connectionLostN)r r r! r r] r r r r r} W s r} Tc s� ddl m} t�t�� �}t|| ��||_�fdd�|_|j ||dd�� t |�}||_|� d� � � j |� |j}|��fdd�� |�� fdd�� |S ) zBRun session between server and client protocol instances over TCP.r rc c � � S r r �rx �� serverWrapperr r �<lambda>h � z loopbackTCP.<locals>.<lambda>z 127.0.0.1)� interfacec � � j S r �rw ��xr� r r r� n � c � � � � S r �� stopListeningr� �� serverPortr r r� o � )re rd r �WrappingFactoryr �Factoryr} �noisyry � listenTCPru � connectTCPr; �portrw r[ )rN rO r� r� rd �f�clientFr r �r� r� r � loopbackTCPa s r� c s� t �� }ddlm} t�t�� �}t|| ��||_ �fdd�|_ |� ||�� t |�}||_ |� ||� |j}|��fdd�� |�� fdd�� |S )zJRun session between server and client protocol instances over UNIX socket.r rc c r� r r r� r� r r r� { r� z loopbackUNIX.<locals>.<lambda>c r� r r� r� r� r r r� � r� c r� r r� r� r� r r r� � r� )�tempfile�mktempre rd r r� r r� r} r� ry � listenUNIXru � connectUNIXrw r[ )rN rO r� �pathrd r� r� r r r� r � loopbackUNIXs s r� )r T)T)"r" r� �zope.interfacer re r r r r �twisted.internet.interfacesr �twisted.internet.taskr �twisted.protocolsr �twisted.pythonr r r% � ITransport� IConsumerr& rI rK rS rM r\ rg � ClientFactoryru r~ r} r� r� r r r r �<module> s0 0 &G 6 PK Mb�Z�KnR$0 $0 * protocols/__pycache__/dict.cpython-310.pycnu �[��� o �b�* � @ s� d Z ddlmZ ddlmZmZ ddlmZ ddlm Z dd� Z dd � Z d d � Z d d � Z G dd� d�ZG dd� dej�ZG dd� de�ZG dd� de�ZG dd� dej�Zdd� Zdd� Zd S ) zE Dict client protocol implementation. @author: Pavel Pergamenshchik � )�BytesIO)�defer�protocol)�basic)�logc C s� | dkrdS | dd� dkrd}nd}d}t | �}|dkr"|�d� |�d�}|dkr<|dkr;|�d� ||�� fS n2|dkrN|�d�}|dkrMd| fS n |dkr`|dkr\||�� fS d| fS |d krn|dkrn||�� fS ||7 }q#) zQChew one dqstring or atom from beginning of line and return (param, remaningline)� )Nr r � � "� � \N� )r �read)�line�mode�res�io�a� r �8/usr/lib/python3/dist-packages/twisted/protocols/dict.py� parseParam s< � � �r c C s t dd� | �S )z Munch a string into an 'atom'c S s | t ttd�g d� �vS )N�! ��" �' �\ )�map�chr�range)�xr r r �<lambda>6 s zmakeAtom.<locals>.<lambda>)�filter�r r r r �makeAtom3 s r" c C sL t d�g d� }g }| D ]}t|�|v r|�d� |�|� q d�|�} | S )Nr r r r )r �ord�append�join)�s� mustquote�result�cr r r �makeWord9 s r* c C sD t | �dkr | dkr d S t | �dkr | dd� dkr | dd � } | S )Nr � .r r s ..)�lenr! r r r � parseTextD s r- c @ s e Zd ZdZdd� ZdS )� DefinitionzA word definitionc C s || _ || _|| _|| _d S �N)�name�db�dbdesc�text)�selfr0 r1 r2 r3 r r r �__init__P � zDefinition.__init__N)�__name__� __module__� __qualname__�__doc__r5 r r r r r. M s r. c @ s e Zd ZdZdZdZdZdZdZdZ dd� Z dd� Z dd � Z d d � Z d d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Z d*d+� Z d,d-� Z d.d/� Z d0d1� Z d2d3� Z!d4d5� Z"d6d7� Z#d8d9� Z$d:d;� Z%d<d=� Z&d>d?� Z'dS )@� DictClientzdict (RFC2229) clientNi c C s d | _ d | _d S r/ )�datar( �r4 r r r r5 a � zDictClient.__init__c C s d| _ d| _d S )N�conn�command)�stater r= r r r �connectionMadee r> zDictClient.connectionMadec C s, t |�| jd kr td��tj�| |� dS )z3Throw up if the line is longer than 1022 charactersr z(DictClient tried to send a too long lineN)r, � MAX_LENGTH� ValueErrorr � LineReceiver�sendLine�r4 r r r r rF i s zDictClient.sendLinec C s� z|� d�}W n ty Y d S w | jdkrd}n't|�dk r3t�d| � | �d� | j�� d S t |d d� �}|dd � }t | d|� d| j � �| j �}||� d S ) Nzutf-8r3 � z-DictClient got invalid line from server -- %szInvalid line from server� � dictCode_�_) �decode� UnicodeErrorr r, r �msg� protocolError� transport�LoseConnection�int�getattrrA �dictCode_default)r4 r �code�methodr r r � lineReceivedo s � zDictClient.lineReceivedc C s& t �d| � | �d� | j�� dS )zUnknown messagez3DictClient got unexpected message from server -- %szUnexpected server messageN)r rN rO rP �loseConnectionrG r r r rT � s zDictClient.dictCode_defaultc C � dS )z*We are about to get kicked off, do nothingNr rG r r r �dictCode_221_ready� � z DictClient.dictCode_221_readyc C s d| _ | �� dS )zGreeting message�readyN)rA � dictConnectedrG r r r �dictCode_220_conn� s z DictClient.dictCode_220_connc C � | � d� | j�� d S )Nz Access denied�rO rP rX r= r r r �dictCode_530_conn� � z DictClient.dictCode_530_connc C r_ )Nz Server temporarily unavailabler` r= r r r �dictCode_420_conn� rb z DictClient.dictCode_420_connc C r_ )Nz(Server shutting down at operator requestr` r= r r r �dictCode_421_conn� rb z DictClient.dictCode_421_connc C sR | j dks J d��d| _d| _d| _ d�t|�d��t|�d���}| �|� dS )zSend a dict DEFINE commandr\ z4DictClient.sendDefine called when not in ready stateN�definez DEFINE {} {}�UTF-8)rA r( r< �formatr" �encoder* rF )r4 �database�wordr@ r r r � sendDefine� s �� �zDictClient.sendDefinec C sR | j dks J d��d| _d| _d| _ d�t|�t|�t|��}| �|�d�� dS )zSend a dict MATCH commandr\ z3DictClient.sendMatch called when not in ready stateN�matchzMATCH {} {} {}rf )rA r( r< rg r" rF rh )r4 ri �strategyrj r@ r r r � sendMatch� s ��zDictClient.sendMatchc C � d| _ | �d � dS �zInvalid databaser\ N�r � defineFailedrG r r r �dictCode_550_define� � z DictClient.dictCode_550_definec C ro rp �r � matchFailedrG r r r �dictCode_550_match� rt z DictClient.dictCode_550_matchc C ro )zInvalid strategyr\ Nru rG r r r �dictCode_551_match� rt z DictClient.dictCode_551_matchc C ro �zNo matchr\ Nrq rG r r r �dictCode_552_define� rt z DictClient.dictCode_552_definec C ro ry ru rG r r r �dictCode_552_match� rt z DictClient.dictCode_552_matchc C s g | _ dS )zn definitions retrievedN)r( rG r r r �dictCode_150_define� s z DictClient.dictCode_150_definec C sn d| _ t|�\}}t|�\}}t|�\}}|r|r|s'| �d� | j�� dS | j�t|||g �� g | _dS )zDefinition text followsr3 zInvalid server responseN) r r rO rP rX r( r$ r. r< )r4 r rj r1 r2 r r r �dictCode_151_define� s z DictClient.dictCode_151_definec C s d| _ g | _g | _dS )z n matches found, text followsr3 N)r r( r< rG r r r �dictCode_152_match� s z DictClient.dictCode_152_matchc C s> t |�}|dkrd| _| j| jd _d| _dS | j�|� dS )z"A line of definition text receivedNr@ ���)r- r r< r( r3 r$ )r4 r r r r r �dictCode_text_define� s z DictClient.dictCode_text_definec C sF dd� }t |�}|dkrd| _t|| j�| _d| _dS | j�|� dS )z One line of match text receivedc S s t | �\}}t |�\}}||fS r/ )r )r& �p1�t�p2r r r �l� s z)DictClient.dictCode_text_match.<locals>.lNr@ )r- r r r< r( r$ )r4 r r� r r r r �dictCode_text_match� s z DictClient.dictCode_text_matchc C � | j }d| _ d| _| �|� dS ��okNr\ )r( rA � defineDone�r4 r r� r r r �dictCode_250_define � z DictClient.dictCode_250_definec C r� r� )r( rA � matchDoner� r r r �dictCode_250_match r� z DictClient.dictCode_250_matchc C rY )z5override to catch unexpected dict protocol conditionsNr �r4 �reasonr r r rO r[ zDictClient.protocolErrorc C rY )zCoverride to be notified when the server is ready to accept commandsNr r= r r r r] r[ zDictClient.dictConnectedc C rY )z8override to catch reasonable failure responses to DEFINENr r� r r r rr r[ zDictClient.defineFailedc C rY )z#override to catch successful DEFINENr �r4 r( r r r r� r[ zDictClient.defineDonec C rY )z7override to catch reasonable failure responses to MATCHNr r� r r r rv # r[ zDictClient.matchFailedc C rY )z"override to catch successful MATCHNr r� r r r r� ' r[ zDictClient.matchDone)(r7 r8 r9 r: r< rC rA r r( �factoryr5 rB rF rW rT rZ r^ ra rc rd rk rn rs rw rx rz r{ r| r} r~ r� r� r� r� rO r] rr r� rv r� r r r r r; W sL r; c @ s e Zd ZdS )�InvalidResponseN)r7 r8 r9 r r r r r� , s r� c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� DictLookupzNUtility class for a single dict transaction. To be used with DictLookupFactoryc C s, | j js| j j�t|�� | j �� d S d S r/ )r� �done�d�errbackr� � clientDoner� r r r rO 3 s �zDictLookup.protocolErrorc C s@ | j jdkr| j| j j� d S | j jdkr | j| j j� d S d S )Nre rl )r� � queryTyperk �paramrn r= r r r r] 8 s �zDictLookup.dictConnectedc C �& | j j�g � | j �� | j�� d S r/ �r� r� �callbackr� rP rX r� r r r rr > � zDictLookup.defineFailedc C �& | j j�|� | j �� | j�� d S r/ r� r� r r r r� C r� zDictLookup.defineDonec C r� r/ r� r� r r r rv H r� zDictLookup.matchFailedc C r� r/ r� r� r r r r� M r� zDictLookup.matchDoneN) r7 r8 r9 r: rO r] rr r� rv r� r r r r r� 0 s r� c @ s@ e Zd ZdZeZdZdd� Zdd� Zdd� Z d d � Z d d � Z dS ) �DictLookupFactoryz-Utility factory for a single dict transactionNc C s || _ || _|| _d| _d S )Nr )r� r� r� r� )r4 r� r� r� r r r r5 Y r6 zDictLookupFactory.__init__c C s d| _ | `dS )zCalled by client when done.r N)r� r� r= r r r r� _ s z DictLookupFactory.clientDonec C s | j �|� d S r/ )r� r� �r4 � connector�errorr r r �clientConnectionFailedd s z(DictLookupFactory.clientConnectionFailedc C s | j s | j�|� d S d S r/ )r� r� r� r� r r r �clientConnectionLostg s �z&DictLookupFactory.clientConnectionLostc C s | � � }| |_|S r/ )r r� )r4 �addr�pr r r � buildProtocolk s z DictLookupFactory.buildProtocol) r7 r8 r9 r: r� r r� r5 r� r� r� r� r r r r r� S s r� c C s6 t �� }td||f|�}ddlm} |�| ||� |S )z"Look up a word using a dict serverre r ��reactor�r �Deferredr� �twisted.internetr� � connectTCP)�host�portri rj r� r� r� r r r re q s re c C s8 t �� }td|||f|�}ddlm} |�| ||� |S )z Match a word using a dict serverrl r r� r� )r� r� ri rm rj r� r� r� r r r rl | s rl N)r: r r r� r r �twisted.protocolsr �twisted.pythonr r r" r* r- r. rE r; � Exceptionr� r� � ClientFactoryr� re rl r r r r �<module> s" ! V# PK Mb�Z'=�4�u �u + protocols/__pycache__/basic.cpython-310.pycnu �[��� o �b�{ � @ sd d Z ddlZddlZddlmZ ddlmZmZmZ ddl m Z ddl m Z m Z mZ ddlmZ dd � Zd e_ dZG d d � d e�ZG d d� de�ZG dd� dej�ZG dd� dej�ZG dd� d�ZG dd� deje�ZG dd� de �Z G dd� d�Z G dd � d eje�Z G d d � d e �Z G d d � d e �Z!G d!d"� d"e �Z"G d#d$� d$�Z#e e j$�G d%d&� d&��Z%dS )'zN Basic protocols, such as line-oriented, netstring, and int prefixed strings. � N)�BytesIO)�calcsize�pack�unpack)� implementer)�defer� interfaces�protocol)�logc C s d� tt| ���d�d| dg�S )N� �ascii� :� ,)�join�str�len�encode)�data� r �9/usr/lib/python3/dist-packages/twisted/protocols/basic.py�_formatNetstring s r z_ Convert some C{bytes} into netstring format. @param data: C{bytes} that will be reformatted. c @ � e Zd ZdZdS )�NetstringParseErrorz= The incoming data is not in valid Netstring format. N��__name__� __module__� __qualname__�__doc__r r r r r ) � r c @ r )�IncompleteNetstringz2 Not enough data to complete a netstring. Nr r r r r r / r r c @ s� e Zd ZdZdZe�d�Ze�d�ZdZ dZ dZ dZ e d �\ZZd d � Zd d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Z d$d%� Z d&d'� Z d(d)� Z d*d+� Z d,d-� Z!d.S )/�NetstringReceiveraM A protocol that sends and receives netstrings. See U{http://cr.yp.to/proto/netstrings.txt} for the specification of netstrings. Every netstring starts with digits that specify the length of the data. This length specification is separated from the data by a colon. The data is terminated with a comma. Override L{stringReceived} to handle received netstrings. This method is called with the netstring payload as a single argument whenever a complete netstring is received. Security features: 1. Messages are limited in size, useful if you don't want someone sending you a 500MB netstring (change C{self.MAX_LENGTH} to the maximum length you wish to accept). 2. The connection is lost if an illegal message is received. @ivar MAX_LENGTH: Defines the maximum length of netstrings that can be received. @type MAX_LENGTH: C{int} @ivar _LENGTH: A pattern describing all strings that contain a netstring length specification. Examples for length specifications are C{b'0:'}, C{b'12:'}, and C{b'179:'}. C{b'007:'} is not a valid length specification, since leading zeros are not allowed. @type _LENGTH: C{re.Match} @ivar _LENGTH_PREFIX: A pattern describing all strings that contain the first part of a netstring length specification (without the trailing comma). Examples are '0', '12', and '179'. '007' does not start a netstring length specification, since leading zeros are not allowed. @type _LENGTH_PREFIX: C{re.Match} @ivar _PARSING_LENGTH: Indicates that the C{NetstringReceiver} is in the state of parsing the length portion of a netstring. @type _PARSING_LENGTH: C{int} @ivar _PARSING_PAYLOAD: Indicates that the C{NetstringReceiver} is in the state of parsing the payload portion (data and trailing comma) of a netstring. @type _PARSING_PAYLOAD: C{int} @ivar brokenPeer: Indicates if the connection is still functional @type brokenPeer: C{int} @ivar _state: Indicates if the protocol is consuming the length portion (C{PARSING_LENGTH}) or the payload (C{PARSING_PAYLOAD}) of a netstring @type _state: C{int} @ivar _remainingData: Holds the chunk of data that has not yet been consumed @type _remainingData: C{string} @ivar _payload: Holds the payload portion of a netstring including the trailing comma @type _payload: C{BytesIO} @ivar _expectedPayloadSize: Holds the payload size plus one for the trailing comma. @type _expectedPayloadSize: C{int} 韆 s (0|[1-9]\d*)(:)s (0|[1-9]\d*)$zBThe received netstring does not start with a length specification.zpThe length specification of the received netstring cannot be represented in Python - it causes an OverflowError!zQThe received netstring is longer than the maximum %s specified by self.MAX_LENGTHz4The received netstring is not terminated by a comma.� c C s: t j�| |� d| _d| _t� | _| j| _d| _ d| _ dS )z+ Initializes the protocol. r r N) r �Protocol�makeConnection�_remainingData�_currentPayloadSizer �_payload�_PARSING_LENGTH�_state�_expectedPayloadSize� brokenPeer)�self� transportr r r r$ � s z NetstringReceiver.makeConnectionc C s | j �t|�� dS )a1 Sends a netstring. Wraps up C{string} by adding length information and a trailing comma; writes the result to the transport. @param string: The string to send. The necessary framing (length prefix, etc) will be added. @type string: C{bytes} N)r- �writer �r, �stringr r r � sendString� s z NetstringReceiver.sendStringc C s^ | j |7 _ | j r-z| �� W n ty Y dS ty' | �� Y dS w | j s dS dS )a= Receives some characters of a netstring. Whenever a complete netstring is received, this method extracts its payload and calls L{stringReceived} to process it. @param data: A chunk of data representing a (possibly partial) netstring @type data: C{bytes} N)r% � _consumeDatar r �_handleParseError�r, r r r r � dataReceived� s ��z NetstringReceiver.dataReceivedc C s t � �)a^ Override this for notification when each complete string is received. @param string: The complete string which was received with all framing (length prefix, etc) removed. @type string: C{bytes} @raise NotImplementedError: because the method has to be implemented by the child class. ��NotImplementedErrorr/ r r r �stringReceived� s z NetstringReceiver.stringReceivedc C s t �t �| j��d S )z� Calculate and return the string size of C{self.MAX_LENGTH}. @return: The size of the string representation for C{self.MAX_LENGTH} @rtype: C{float} � )�math�ceil�log10� MAX_LENGTH�r, r r r �_maxLengthSize� s z NetstringReceiver._maxLengthSizec C s8 | j | jkr| �� | �� | j | jkr| �� dS dS )a0 Consumes the content of C{self._remainingData}. @raise IncompleteNetstring: if C{self._remainingData} does not contain enough data to complete the current netstring. @raise NetstringParseError: if the received data do not form a valid netstring. N)r) r( �_consumeLength� _prepareForPayloadConsumption�_PARSING_PAYLOAD�_consumePayloadr> r r r r2 � s �z NetstringReceiver._consumeDatac C s. | j �| j�}|s| �� t� �| �|� dS )aL Consumes the length portion of C{self._remainingData}. @raise IncompleteNetstring: if C{self._remainingData} contains a partial length specification (digits without trailing comma). @raise NetstringParseError: if the received data do not form a valid netstring. N)�_LENGTH�matchr% � _checkPartialLengthSpecificationr �_processLength)r, � lengthMatchr r r r@ � s z NetstringReceiver._consumeLengthc C s4 | j �| j�}|st| j��|�d�}| �|� dS )aB Makes sure that the received data represents a valid number. Checks if C{self._remainingData} represents a number smaller or equal to C{self.MAX_LENGTH}. @raise NetstringParseError: if C{self._remainingData} is no number or is too big (checked by L{_extractLength}). r9 N)�_LENGTH_PREFIXrE r% r �_MISSING_LENGTH�group�_extractLength)r, �partialLengthMatch�lengthSpecificationr r r rF � s z2NetstringReceiver._checkPartialLengthSpecificationc C sF |� d�}|� d�}| jd|� }| �|�d | _| j|d� | _dS )aY Processes the length definition of a netstring. Extracts and stores in C{self._expectedPayloadSize} the number representing the netstring size. Removes the prefix representing the length specification from C{self._remainingData}. @raise NetstringParseError: if the received netstring does not start with a number or the number is bigger than C{self.MAX_LENGTH}. @param lengthMatch: A regular expression match object matching a netstring length specification @type lengthMatch: C{re.Match} r9 r" N)�endr% rL r* )r, rH � endOfNumber� startOfData� lengthStringr r r rG s z NetstringReceiver._processLengthc C s2 | � |� t|�}|| jkrt| j| jf ��|S )ay Attempts to extract the length information of a netstring. @raise NetstringParseError: if the number is bigger than C{self.MAX_LENGTH}. @param lengthAsString: A chunk of data starting with a length specification @type lengthAsString: C{bytes} @return: The length of the netstring @rtype: C{int} )�_checkStringSize�intr= r � _TOO_LONG)r, �lengthAsString�lengthr r r rL s z NetstringReceiver._extractLengthc C s& t |�| �� krt| j| jf ��dS )a> Checks the sanity of lengthAsString. Checks if the size of the length specification exceeds the size of the string representing self.MAX_LENGTH. If this is not the case, the number represented by lengthAsString is certainly bigger than self.MAX_LENGTH, and a NetstringParseError can be raised. This method should make sure that netstrings with extremely long length specifications are refused before even attempting to convert them to an integer (which might trigger a MemoryError). N)r r? r rU r= )r, rV r r r rS ) s �z"NetstringReceiver._checkStringSizec C s( | j | _d| _| j�d� | j�� dS )zW Sets up variables necessary for consuming the payload of a netstring. r N)rB r) r& r' �seek�truncater> r r r rA ; s z/NetstringReceiver._prepareForPayloadConsumptionc C s6 | � � | j| jk r t� �| �� | j| _| �� dS )a� Consumes the payload portion of C{self._remainingData}. If the payload is complete, checks for the trailing comma and processes the payload. If not, raises an L{IncompleteNetstring} exception. @raise IncompleteNetstring: if the payload received so far contains fewer characters than expected. @raise NetstringParseError: if the payload does not end with a comma. N)�_extractPayloadr& r* r �_checkForTrailingCommar( r) �_processPayloadr> r r r rC D s z!NetstringReceiver._consumePayloadc C sr | � � r#| j| j }| j�| jd|� � | j|d� | _| j| _dS | j�| j� | jt| j�7 _d| _dS )a Extracts payload information from C{self._remainingData}. Splits C{self._remainingData} at the end of the netstring. The first part becomes C{self._payload}, the second part is stored in C{self._remainingData}. If the netstring is not yet complete, the whole content of C{self._remainingData} is moved to C{self._payload}. Nr )�_payloadCompleter* r& r' r. r% r )r, �remainingPayloadSizer r r rZ X s z!NetstringReceiver._extractPayloadc C s t | j�| j | jkS )a Checks if enough data have been received to complete the netstring. @return: C{True} iff the received data contain at least as many characters as specified in the length section of the netstring @rtype: C{bool} )r r% r& r* r> r r r r] m s ��z"NetstringReceiver._payloadCompletec C s | � | j�� dd� � dS )z� Processes the actual payload with L{stringReceived}. Strips C{self._payload} of the trailing comma and calls L{stringReceived} with the result. N���)r8 r' �getvaluer> r r r r\ { s z!NetstringReceiver._processPayloadc C s$ | j �� dd� dkrt| j��dS )z� Checks if the netstring has a trailing comma at the expected position. @raise NetstringParseError: if the last payload character is anything but a comma. r_ Nr )r' r` r �_MISSING_COMMAr> r r r r[ � s �z(NetstringReceiver._checkForTrailingCommac C s | j �� d| _dS )zQ Terminates the connection and sets the flag C{self.brokenPeer}. r9 N)r- �loseConnectionr+ r> r r r r3 � s z#NetstringReceiver._handleParseErrorN)"r r r r r= �re�compilerD rI rJ � _OVERFLOWrU ra �ranger( rB r$ r1 r5 r8 r? r2 r@ rF rG rL rS rA rC rZ r] r\ r[ r3 r r r r r 5 s> ? ��� r c @ s< e Zd ZdZdZdZdZdd� Zdd� Zd d � Z d d � Z d S )�LineOnlyReceivera� A protocol that receives only lines. This is purely a speed optimisation over LineReceiver, for the cases that raw mode is known to be unnecessary. @cvar delimiter: The line-ending delimiter to use. By default this is C{b'\r\n'}. @cvar MAX_LENGTH: The maximum length of a line to allow (If a sent line is longer than this, the connection is dropped). Default is 16384. r � � @ c C s| | j | �| j�}|�d�| _ |D ] }| jjr dS t|�| jkr(| �|� S | � |� qt| j �| jkr<| �| j �S dS )zF Translates bytes into lines, and calls lineReceived. r_ N) �_buffer�split� delimiter�popr- � disconnectingr r= �lineLengthExceeded� lineReceived)r, r �lines�liner r r r5 � s �z LineOnlyReceiver.dataReceivedc C � t ��z� Override this for when each line is received. @param line: The line which was received with the delimiter removed. @type line: C{bytes} r6 �r, rr r r r rp � � z LineOnlyReceiver.lineReceivedc C s | j �|| jf�S �z� Sends a line to the other end of the connection. @param line: The line to send, not including the delimiter. @type line: C{bytes} )r- � writeSequencerl ru r r r �sendLine� � zLineOnlyReceiver.sendLinec C � | j �� S )z� Called when the maximum line length has been reached. Override if it needs to be dealt with in some special way. �r- rb ru r r r ro � s z#LineOnlyReceiver.lineLengthExceededN) r r r r rj rl r= r5 rp ry ro r r r r rg � s rg c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �_PauseableMixinFc C � d| _ | j�� d S �NT)�pausedr- �pauseProducingr> r r r r� � � z _PauseableMixin.pauseProducingc C s d| _ | j�� | �d� d S )NFr )r� r- �resumeProducingr5 r> r r r r� � s z _PauseableMixin.resumeProducingc C r~ r )r� r- � stopProducingr> r r r r� � r� z _PauseableMixin.stopProducingN)r r r r� r� r� r� r r r r r} � s r} c @ sf e Zd ZdZdZdZdZdZdZdd� Z d d � Z dd d �Z d d� Z dd� Z dd� Zdd� Zdd� ZdS )� LineReceivera� A protocol that receives lines and/or raw data, depending on mode. In line mode, each line that's received becomes a callback to L{lineReceived}. In raw data mode, each chunk of raw data becomes a callback to L{LineReceiver.rawDataReceived}. The L{setLineMode} and L{setRawMode} methods switch between the two modes. This is useful for line-oriented protocols such as IRC, HTTP, POP, etc. @cvar delimiter: The line-ending delimiter to use. By default this is C{b'\r\n'}. @cvar MAX_LENGTH: The maximum length of a line to allow (If a sent line is longer than this, the connection is dropped). Default is 16384. r9 r Frh ri c C s | j d}| _ |S )zs Clear buffered data. @return: All of the cleared buffered data. @rtype: C{bytes} r )rj )r, �br r r �clearLineBuffer� s z LineReceiver.clearLineBufferc C s� | j r | j|7 _dS z�d| _ | j|7 _| jr�| js�| jr�z | j�| jd�\}| _W n- tyZ t| j�| jt| j� krS| jd}| _| � |� Y W d| _ S Y W d| _ dS w t|�}|| jkrx|| j | j }d| _| � |�W d| _ S | � |�}|s�| j r�| j j r�|W d| _ S n| j}d| _| � |�}|r�|W d| _ S | jr�| jr W d| _ dS W d| _ dS W d| _ dS W d| _ dS d| _ w )z� Protocol.dataReceived. Translates bytes into lines, and calls lineReceived (or rawDataReceived, depending on mode.) NTr9 r F)�_busyReceivingrj r� � line_moderk rl � ValueErrorr r= ro rp r- rn �rawDataReceived)r, r rr � lineLength�exceeded�whyr r r r5 sV � � ��� � � � �zLineReceiver.dataReceivedc C s d| _ |r | �|�S dS )a� Sets the line-mode of this receiver. If you are calling this from a rawDataReceived callback, you can pass in extra unhandled data, and that data will be parsed for lines. Further data received will be sent to lineReceived rather than rawDataReceived. Do not pass extra data if calling this function from within a lineReceived callback. r9 N)r� r5 )r, �extrar r r � setLineMode1 s �zLineReceiver.setLineModec C s d| _ dS )z� Sets the raw mode of this receiver. Further data received will be sent to rawDataReceived rather than lineReceived. r N)r� r> r r r � setRawModeA s zLineReceiver.setRawModec C rs )z> Override this for when raw data is received. r6 r4 r r r r� I s z LineReceiver.rawDataReceivedc C rs rt r6 ru r r r rp O rv zLineReceiver.lineReceivedc C s | j �|| j �S rw )r- r. rl ru r r r ry X rz zLineReceiver.sendLinec C r{ )aw Called when the maximum line length has been reached. Override if it needs to be dealt with in some special way. The argument 'line' contains the remainder of the buffer, starting with (at least some part) of the line which is too long. This may be more than one line, or may be only the initial portion of the line. r| ru r r r ro a s z LineReceiver.lineLengthExceededN)r )r r r r r� rj r� rl r= r� r5 r� r� r� rp ry ro r r r r r� � s ( r� c @ r )�StringTooLongErrorzZ Raised when trying to send a string too long for a length prefixed protocol. Nr r r r r r� n r r� c @ s e Zd ZdZddd�ZdS )�_RecvdCompatHackaK Emulates the to-be-deprecated C{IntNStringReceiver.recvd} attribute. The C{recvd} attribute was where the working buffer for buffering and parsing netstrings was kept. It was updated each time new data arrived and each time some of that data was parsed and delivered to application code. The piecemeal updates to its string value were expensive and have been removed from C{IntNStringReceiver} in the normal case. However, for applications directly reading this attribute, this descriptor restores that behavior. It only copies the working buffer when necessary (ie, when accessed). This avoids the cost for applications not using the data. This is a custom descriptor rather than a property, because we still need the default __set__ behavior in both new-style and old-style subclasses. Nc C s |j |jd � S �N)� _unprocessed�_compatibilityOffset)r, �oself�typer r r �__get__� s z_RecvdCompatHack.__get__r� )r r r r r� r r r r r� u s r� c @ sB e Zd ZdZdZdZdZe� Zdd� Z dd� Z d d � Z d d � Z d S )�IntNStringReceivera, Generic class for length prefixed protocols. @ivar _unprocessed: bytes received, but not yet broken up into messages / sent to stringReceived. _compatibilityOffset must be updated when this value is updated so that the C{recvd} attribute can be generated correctly. @type _unprocessed: C{bytes} @ivar structFormat: format used for struct packing/unpacking. Define it in subclass. @type structFormat: C{str} @ivar prefixLength: length of the prefix, in bytes. Define it in subclass, using C{struct.calcsize(structFormat)} @type prefixLength: C{int} @ivar _compatibilityOffset: the offset within C{_unprocessed} to the next message to be parsed. (used to generate the recvd attribute) @type _compatibilityOffset: C{int} r! r r c C rs )z� Override this for notification when each complete string is received. @param string: The complete string which was received with all framing (length prefix, etc) removed. @type string: C{bytes} r6 r/ r r r r8 � s z!IntNStringReceiver.stringReceivedc C s | j �� dS )a Callback invoked when a length prefix greater than C{MAX_LENGTH} is received. The default implementation disconnects the transport. Override this. @param length: The length prefix which was received. @type length: C{int} Nr| )r, rW r r r �lengthLimitExceeded� s z&IntNStringReceiver.lengthLimitExceededc C s | j | }d}| j}| j}|| _ t|�|| kry| jsy|| }t||||� �\}|| jkr;|| _ || _| �|� dS || }t|�|k rFn3|||� } |}|| _| � | � d| j v rn| j � d�}|| _ d | _}|rlqdS t|�|| kry| jr||d� | _ d| _dS )zL Convert int prefixed strings into calls to stringReceived. r N�recvd) r� � prefixLength� structFormatr r� r r= r� r� r8 �__dict__rm ) r, r �alldata� currentOffsetr� �fmt� messageStartrW � messageEnd�packetr r r r5 � s< �! z IntNStringReceiver.dataReceivedc C sT t |�dd| j krtdt |�dd| j f ��| j�t| jt |��| � dS )z� Send a prefixed string to the other end of the connection. @param string: The string to send. The necessary framing (length prefix, etc) will be added. @type string: C{bytes} r" � z*Try to send %s bytes whereas maximum is %sN)r r� r� r- r. r r� r/ r r r r1 � s �� z IntNStringReceiver.sendStringN) r r r r r= r� r� r� r� r8 r� r5 r1 r r r r r� � s 1r� c @ � e Zd ZdZdZee�ZdS )�Int32StringReceiverz� A receiver for int32-prefixed strings. An int32 string is a string prefixed by 4 bytes, the 32-bit length of the string encoded in network byte order. This class publishes the same interface as NetstringReceiver. z!IN�r r r r r� r r� r r r r r� � � r� c @ r� )�Int16StringReceiverz� A receiver for int16-prefixed strings. An int16 string is a string prefixed by 2 bytes, the 16-bit length of the string encoded in network byte order. This class publishes the same interface as NetstringReceiver. z!HNr� r r r r r� r� r� c @ r� )�Int8StringReceiverz� A receiver for int8-prefixed strings. An int8 string is a string prefixed by 1 byte, the 8-bit length of the string. This class publishes the same interface as NetstringReceiver. z!BNr� r r r r r� r� r� c @ s e Zd ZdZdZdd� ZdS )�StatefulStringProtocola� A stateful string protocol. This is a mixin for string protocols (L{Int32StringReceiver}, L{NetstringReceiver}) which translates L{stringReceived} into a callback (prefixed with C{'proto_'}) depending on state. The state C{'done'} is special; if a C{proto_*} method returns it, the connection will be closed immediately. @ivar state: Current state of the protocol. Defaults to C{'init'}. @type state: C{str} �initc C sd z d| j }t| |�}W n ty t�d| j d� Y dS w ||�| _ | j dkr0| j�� dS dS )a� Choose a protocol phase function and call it. Call back to the appropriate protocol phase; this begins with the function C{proto_init} and moves on to C{proto_*} depending on what each C{proto_*} function returns. (For example, if C{self.proto_init} returns 'foo', then C{self.proto_foo} will be the next function called when a protocol message is received. �proto_�callbackz not found�doneN)�state�getattr�AttributeErrorr �msgr- rb )r, r0 �pto� statehandlerr r r r8 : s � �z%StatefulStringProtocol.stringReceivedN)r r r r r� r8 r r r r r� ) s r� c @ s> e Zd ZdZdZdZdZd dd�Zdd� Zd d � Z d d � Z dS )� FileSendera A producer that sends the contents of a file to a consumer. This is a helper for protocols that, at some point, will take a file-like object, read its contents, and write them out to the network, optionally performing some transformation on the bytes in between. ri � Nc C s2 || _ || _|| _t�� | _}| j�| d� |S )a� Begin transferring a file @type file: Any file-like object @param file: The file object to read data from @type consumer: Any implementor of IConsumer @param consumer: The object to write data to @param transform: A callable taking one string argument and returning the same. All bytes read from the file are passed through this before being written to the consumer. @rtype: C{Deferred} @return: A deferred whose callback will be invoked when the file has been completely written to the consumer. The last byte written to the consumer is passed to the callback. F)�file�consumer� transformr �Deferred�deferred�registerProducer)r, r� r� r� r� r r r �beginFileTransfer^ s z FileSender.beginFileTransferc C sx d}| j r | j �| j�}|s%d | _ | j�� | jr#| j�| j� d | _d S | jr-| �|�}| j� |� |dd � | _d S )Nr� r_ ) r� �read� CHUNK_SIZEr� �unregisterProducerr� r� �lastSentr� r. )r, �chunkr r r r� y s zFileSender.resumeProducingc C s d S r� r r> r r r r� � s zFileSender.pauseProducingc C s$ | j r| j �td�� d | _ d S d S )Nz#Consumer asked us to stop producing)r� �errback� Exceptionr> r r r r� � s �zFileSender.stopProducingr� ) r r r r r� r� r� r� r� r� r� r r r r r� O s r� )&r r: rc �ior �structr r r �zope.interfacer �twisted.internetr r r �twisted.pythonr r �DEBUGr� r r� r r# r rg r} r� �AssertionErrorr� r� r� r� r� r� r� � IProducerr� r r r r �<module> s: c@ u&PK Mb�Z� ϩ� � . protocols/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s8 d Z ddlmZ ddlmZ eedddd�ddd � d S ) zG Twisted Protocols: A collection of internet protocol implementations. � )�Version)�deprecatedModuleAttribute�Twisted� � z(There is no replacement for this module.ztwisted.protocols�dictN)�__doc__� incrementalr �twisted.python.deprecater � r r �</usr/lib/python3/dist-packages/twisted/protocols/__init__.py�<module> s �PK Mb�Z9 �Z� � * protocols/__pycache__/wire.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlmZ ddlmZmZ G dd� dej�Z G dd� dej�Z eej �G d d � d ej��Z G d d � d ej�Z G d d� dej�ZG dd� dej�ZG dd� dej�Zg d�ZdS )zzImplement standard (and unused) TCP protocols. These protocols are either provided by inetd, or are not provided at all. � N)� implementer)� interfaces�protocolc @ � e Zd ZdZdd� ZdS )�EchozC As soon as any data is received, write it back (RFC 862). c C s | j �|� d S �N)� transport�write��self�data� r �8/usr/lib/python3/dist-packages/twisted/protocols/wire.py� dataReceived s zEcho.dataReceivedN��__name__� __module__� __qualname__�__doc__r r r r r r � r c @ r )�Discardz. Discard any received data (RFC 863). c C � d S r r r r r r r s zDiscard.dataReceivedNr r r r r r r r c @ s4 e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd S ) �Chargenz- Generate repeating noise (RFC 864). sG @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&?c C s | j �| d� d S )Nr )r �registerProducer�r r r r �connectionMade- � zChargen.connectionMadec C s | j �| j� d S r )r r �noiser r r r �resumeProducing0 r zChargen.resumeProducingc C r r r r r r r �pauseProducing3 � zChargen.pauseProducingc C r r r r r r r � stopProducing6 r zChargen.stopProducingN) r r r r r r r r r! r r r r r % s r c @ � e Zd ZdZdd� Zdd� ZdS )�QOTDz. Return a quote of the day (RFC 865). c C � | j �| �� � | j �� d S r )r r �getQuote�loseConnectionr r r r r ? � zQOTD.connectionMadec C � dS )zB Return a quote. May be overrriden in subclasses. s' An apple a day keeps the doctor away. r r r r r r% C � z QOTD.getQuoteN)r r r r r r% r r r r r# : � r# c @ r" )�Whoz/ Return list of active users (RFC 866) c C r$ r )r r �getUsersr& r r r r r O r' zWho.connectionMadec C r( )z> Return active users. Override in subclasses. s root r r r r r r, S r) z Who.getUsersN)r r r r r r, r r r r r+ J r* r+ c @ r )�Daytimez8 Send back the daytime in ASCII form (RFC 867). c C s. | j �t�t�t�� ��d � | j �� d S )Ns )r r �time�asctime�gmtimer& r r r r r _ s zDaytime.connectionMadeN�r r r r r r r r r r- Z r r- c @ r )�Timez@ Send back the time in machine readable form (RFC 868). c C s. t �dtt�� ��}| j�|� | j�� d S )Nz!i)�struct�pack�intr. r r r& )r �resultr r r r i s zTime.connectionMadeNr1 r r r r r2 d r r2 )r r r r# r+ r- r2 )r r3 r. �zope.interfacer �twisted.internetr r �Protocolr r � IProducerr r# r+ r- r2 �__all__r r r r �<module> s PK Mb�Zc>% �b �b ) protocols/__pycache__/tls.cpython-310.pycnu �[��� o �b�~ � @ sJ d Z ddlmZmZmZmZmZmZ z eee�d� W n ey2 Z z e e �dkr*� e d��dZ [ ww ddl m Z mZmZ ddlmZ ddlmZ dd lmZmZmZmZmZmZmZm Z dd l m Z dd l m Z dd l!m"Z"m#Z# dd l$m%Z% ee�G dd� d��Z&ee e�G dd� de"��Z'eee�G dd� d��Z(G dd� de#�Z)dS )a� Implementation of a TLS transport (L{ISSLTransport}) as an L{IProtocol<twisted.internet.interfaces.IProtocol>} layered on top of any L{ITransport<twisted.internet.interfaces.ITransport>} implementation, based on U{OpenSSL<http://www.openssl.org>}'s memory BIO features. L{TLSMemoryBIOFactory} is a L{WrappingFactory} which wraps protocols created by the factory it wraps with L{TLSMemoryBIOProtocol}. L{TLSMemoryBIOProtocol} intercedes between the underlying transport and the wrapped protocol to implement SSL and TLS. Typical usage of this module looks like this:: from twisted.protocols.tls import TLSMemoryBIOFactory from twisted.internet.protocol import ServerFactory from twisted.internet.ssl import PrivateCertificate from twisted.internet import reactor from someapplication import ApplicationProtocol serverFactory = ServerFactory() serverFactory.protocol = ApplicationProtocol certificate = PrivateCertificate.loadPEM(certPEMData) contextFactory = certificate.options() tlsFactory = TLSMemoryBIOFactory(contextFactory, False, serverFactory) reactor.listenTCP(12345, tlsFactory) reactor.run() This API offers somewhat more flexibility than L{twisted.internet.interfaces.IReactorSSL}; for example, a L{TLSMemoryBIOProtocol} instance can use another instance of L{TLSMemoryBIOProtocol} as its transport, yielding TLS over TLS - useful to implement onion routing. It can also be used to run TLS over unusual transports, such as UNIX sockets and stdio. � )� Connection�Context�Error� TLSv1_METHOD� WantReadError�ZeroReturnErrorNz3argument must be an int, or have a fileno() method.z7twisted.protocols.tls requires pyOpenSSL 0.10 or newer.)�directlyProvides� implementer� providedBy)� _PullToPush)�_setAcceptableProtocols)�IHandshakeListener�ILoggingContext� INegotiated� IOpenSSLClientConnectionCreator� IOpenSSLServerConnectionCreator�IProtocolNegotiationFactory� IPushProducer� ISystemHandle)�CONNECTION_LOST)�Protocol)�ProtocolWrapper�WrappingFactory)�Failurec @ s4 e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd S ) �_ProducerMembranea Stand-in for producer registered with a L{TLSMemoryBIOProtocol} transport. Ensures that producer pause/resume events from the undelying transport are coordinated with pause/resume events from the TLS layer. @ivar _producer: The application-layer producer. Fc C s || _ d S �N)� _producer)�self�producer� r �7/usr/lib/python3/dist-packages/twisted/protocols/tls.py�__init__Y � z_ProducerMembrane.__init__c C s | j rdS d| _ | j�� dS )zP C{pauseProducing} the underlying producer, if it's not paused. NT)�_producerPausedr �pauseProducing�r r r r r$ \ � z _ProducerMembrane.pauseProducingc C s | j sdS d| _ | j�� dS )zM C{resumeProducing} the underlying producer, if it's paused. NF)r# r �resumeProducingr% r r r r' e r& z!_ProducerMembrane.resumeProducingc C s | j �� dS )z� C{stopProducing} the underlying producer. There is only a single source for this event, so it's simply passed on. N)r � stopProducingr% r r r r( n s z _ProducerMembrane.stopProducingN) �__name__� __module__� __qualname__�__doc__r# r! r$ r' r( r r r r r L s r c @ s� e Zd ZdZdZdZdZdZdZd1dd�Z dd� Z d d � Z d d � Z d d� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Ze d+d,� �Z d-d.� Z d/d0� Z dS )2�TLSMemoryBIOProtocola L{TLSMemoryBIOProtocol} is a protocol wrapper which uses OpenSSL via a memory BIO to encrypt bytes written to it before sending them on to the underlying transport and decrypts bytes received from the underlying transport before delivering them to the wrapped protocol. In addition to producer events from the underlying transport, the need to wait for reads before a write can proceed means the L{TLSMemoryBIOProtocol} may also want to pause a producer. Pause/resume events are therefore merged using the L{_ProducerMembrane} wrapper. Non-streaming (pull) producers are supported by wrapping them with L{_PullToPush}. @ivar _tlsConnection: The L{OpenSSL.SSL.Connection} instance which is encrypted and decrypting this connection. @ivar _lostTLSConnection: A flag indicating whether connection loss has already been dealt with (C{True}) or not (C{False}). TLS disconnection is distinct from the underlying connection being lost. @ivar _appSendBuffer: application-level (cleartext) data that is waiting to be transferred to the TLS buffer, but can't be because the TLS connection is handshaking. @type _appSendBuffer: L{list} of L{bytes} @ivar _connectWrapped: A flag indicating whether or not to call C{makeConnection} on the wrapped protocol. This is for the reactor's L{twisted.internet.interfaces.ITLSTransport.startTLS} implementation, since it has a protocol which it has already called C{makeConnection} on, and which has no interest in a new transport. See #3821. @ivar _handshakeDone: A flag indicating whether or not the handshake is known to have completed successfully (C{True}) or not (C{False}). This is used to control error reporting behavior. If the handshake has not completed, the underlying L{OpenSSL.SSL.Error} will be passed to the application's C{connectionLost} method. If it has completed, any unexpected L{OpenSSL.SSL.Error} will be turned into a L{ConnectionLost}. This is weird; however, it is simply an attempt at a faithful re-implementation of the behavior provided by L{twisted.internet.ssl}. @ivar _reason: If an unexpected L{OpenSSL.SSL.Error} occurs which causes the connection to be lost, it is saved here. If appropriate, this may be used as the reason passed to the application protocol's C{connectionLost} method. @ivar _producer: The current producer registered via C{registerProducer}, or L{None} if no producer has been registered or a previous one was unregistered. @ivar _aborted: C{abortConnection} has been called. No further data will be received to the wrapped protocol's C{dataReceived}. @type _aborted: L{bool} NFTc C s t �| ||� || _d S r )r r! �_connectWrapped)r �factory�wrappedProtocolr. r r r r! � s z TLSMemoryBIOProtocol.__init__c C s | j S )ai Return the L{OpenSSL.SSL.Connection} object being used to encrypt and decrypt this connection. This is done for the benefit of L{twisted.internet.ssl.Certificate}'s C{peerFromTransport} and C{hostFromTransport} methods only. A different system handle may be returned by future versions of this method. )�_tlsConnectionr% r r r � getHandle� s z TLSMemoryBIOProtocol.getHandlec C sb | j �| �| _g | _t|�D ]}t| |� qt�| |� | j �| � | j r+t �| |� | � � dS )z� Connect this wrapper to the given transport and initialize the necessary L{OpenSSL.SSL.Connection} with a memory BIO. N) r/ �_createConnectionr1 �_appSendBufferr r r �makeConnection�registerProtocolr. r �_checkHandshakeStatus)r � transport� interfacer r r r5 � s z#TLSMemoryBIOProtocol.makeConnectionc C sx | j rdS z| j�� W n ty | �� Y dS ty) | �t� � Y dS w d| _t � | j �r:| j � � dS dS )a( Ask OpenSSL to proceed with a handshake in progress. Initially, this just sends the ClientHello; after some bytes have been stuffed in to the C{Connection} object by C{dataReceived}, it will then respond to any C{Certificate} or C{KeyExchange} messages. NT) �_abortedr1 � do_handshaker � _flushSendBIOr �_tlsShutdownFinishedr �_handshakeDoner r r0 �handshakeCompletedr% r r r r7 � s � �z*TLSMemoryBIOProtocol._checkHandshakeStatusc C s6 z| j �d�}W n ty Y dS w | j�|� dS )zh Read any bytes out of the send BIO and write them to the underlying transport. � � N)r1 �bio_readr r8 �write�r �bytesr r r r< � s �z"TLSMemoryBIOProtocol._flushSendBIOc C s� | j sBz| j�d�}W n* ty Y n. ty% | �� | �d� Y n ty5 t� }| �|� Y n w | j s?t � | |� | j r| � � dS )ae Try to receive any application-level bytes which are now available because of a previous write into the receive BIO. This will take care of delivering any application-level bytes which are received to the protocol, as well as handling of the various exceptions which can come from trying to get such bytes. r@ N) �_lostTLSConnectionr1 �recvr r � _shutdownTLSr= r r r: r � dataReceivedr< )r rD �failurer r r �_flushReceiveBIO s � � z%TLSMemoryBIOProtocol._flushReceiveBIOc C s> | j �|� | js| �� | jsdS | jr| �� | �� dS )z� Deliver any received bytes to the receive BIO and then read and deliver to the application any application-level data which becomes available as a result of this. N)r1 � bio_writer> r7 r4 �_unbufferPendingWritesrJ rC r r r rH / s z!TLSMemoryBIOProtocol.dataReceivedc C sD z| j �� }W n ty d}Y nw | �� |r | j�� dS dS )zQ Initiate, or reply to, the shutdown handshake of the TLS layer. FN)r1 �shutdownr r< r8 �loseConnection)r �shutdownSuccessr r r rG L s ��z!TLSMemoryBIOProtocol._shutdownTLSc C sT |durt |jjdd� �dkrtt�}| jdu r || _d| _| �� | j� � dS )a� Called when TLS connection has gone away; tell underlying transport to disconnect. @param reason: a L{Failure} whose value is an L{Exception} if we want to report that failure through to the wrapped protocol's C{connectionLost}, or L{None} if the C{reason} that C{connectionLost} should receive should be coming from the underlying transport. @type reason: L{Failure} or L{None} N� )���zUnexpected EOFT) �tuple�value�argsr r �_reasonrE r< r8 rN �r �reasonr r r r= ` s z)TLSMemoryBIOProtocol._tlsShutdownFinishedc C sJ | j s| j�� | �� d| _ | jp|}d| _d| _t�| |� d| _dS )z� Handle the possible repetition of calls to this method (due to either the underlying transport going away or due to an error at the TLS layer) and make sure the base implementation only gets invoked once. TNF)rE r1 � bio_shutdownrJ rU � connectedr �connectionLostrV r r r rZ � s z#TLSMemoryBIOProtocol.connectionLostc C sN | j s| jsdS | js| js| �� d| _ | js#| jdu r%| �� dS dS dS )zM Send a TLS close alert and close the underlying connection. NT)� disconnectingrY r> r4 �abortConnectionr rG r% r r r rN � s �z#TLSMemoryBIOProtocol.loseConnectionc C s" d| _ d| _| �� | j�� dS )z� Tear down TLS state so that if the connection is aborted mid-handshake we don't deliver any further data from the application. TN)r: r[ rG r8 r\ r% r r r r\ � s z$TLSMemoryBIOProtocol.abortConnectionc C s || _ | �� dS )a, Abort the connection during connection setup, giving a reason that certificate verification failed. @param reason: The reason that the verification failed; reported to the application protocol's C{connectionLost} method. @type reason: L{Failure} N)rU r\ rV r r r �failVerification� s z%TLSMemoryBIOProtocol.failVerificationc C s4 t |t�r td��| jr| jdu rdS | �|� dS )z� Process the given application bytes and send any resulting TLS traffic which arrives in the send BIO. If C{loseConnection} was called, subsequent calls to C{write} will drop the bytes on the floor. z-Must write bytes to a TLS transport, not str.N)� isinstance�str� TypeErrorr[ r �_writerC r r r rB � s zTLSMemoryBIOProtocol.writec C s( | j �|� | jdur| j�� dS dS )z� Put the given octets into L{TLSMemoryBIOProtocol._appSendBuffer}, and tell any listening producer that it should pause because we are now buffering. N)r4 �appendr r$ )r �octetsr r r �_bufferedWrite� s �z#TLSMemoryBIOProtocol._bufferedWritec C sZ | j g }| _ |D ]}| �|� q | j rdS | jdur"| j�� dS | jr+| �� dS dS )zY Un-buffer all waiting writes in L{TLSMemoryBIOProtocol._appSendBuffer}. N)r4 ra r r' r[ rG )r � pendingWrites� eachWriter r r rL � s �z+TLSMemoryBIOProtocol._unbufferPendingWritesc C s� | j rdS d}d}|t|�k rR|||| � }z| j�|�}W n" ty2 | �||d� � Y dS tyA | �t� � Y dS w ||7 }| � � |t|�k sdS dS )a^ Process the given application bytes and send any resulting TLS traffic which arrives in the send BIO. This may be called by C{dataReceived} with bytes that were buffered before C{loseConnection} was called, which is why this function doesn't check for disconnection but accepts the bytes regardless. Ni @ r ) rE �lenr1 �sendr rd r r= r r< )r rD � bufferSize� alreadySent�toSend�sentr r r ra � s$ � �zTLSMemoryBIOProtocol._writec C s | � d�|�� dS )z} Write a sequence of application bytes by joining them into one string and passing them to L{write}. � N)rB �join)r �iovecr r r � writeSequence s z"TLSMemoryBIOProtocol.writeSequencec C s | j �� S r )r1 �get_peer_certificater% r r r �getPeerCertificate" r" z'TLSMemoryBIOProtocol.getPeerCertificatec C sl d}z| j �� }W n ttfy Y nw |dvr|S z| j �� }W n ttfy- Y nw |dkr4|S dS )z9 @see: L{INegotiated.negotiatedProtocol} N)rm Nrm )r1 �get_alpn_proto_negotiated�NotImplementedError�AttributeError�get_next_proto_negotiated)r � protocolNamer r r �negotiatedProtocol% s ��z'TLSMemoryBIOProtocol.negotiatedProtocolc C sT | j r |�� d S |st|| � }}t|�}| j�|d� || _|s(|�� d S d S )NT)rE r( r r r8 �registerProducerr �startStreaming)r r � streaming�streamingProducerr r r ry @ s �z%TLSMemoryBIOProtocol.registerProducerc C s^ | j d u rd S t| j j t�r| j j �� d | _ d| _| j�� | jr+| js-| � � d S d S d S )NF) r r^ r � stopStreamingr# r8 �unregisterProducerr[ r4 rG r% r r r r~ S s �z'TLSMemoryBIOProtocol.unregisterProducer)T) r) r* r+ r, rU r> rE r r: r! r2 r5 r7 r< rJ rH rG r= rZ rN r\ r] rB rd rL ra rp rr �propertyrx ry r~ r r r r r- x s< 6 * ! ) r- c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �"_ContextFactoryToConnectionFactorya Adapter wrapping a L{twisted.internet.interfaces.IOpenSSLContextFactory} into a L{IOpenSSLClientConnectionCreator} or L{IOpenSSLServerConnectionCreator}. See U{https://twistedmatrix.com/trac/ticket/7215} for work that should make this unnecessary. c C s |� � || _dS )a( Construct a L{_ContextFactoryToConnectionFactory} with a L{twisted.internet.interfaces.IOpenSSLContextFactory}. Immediately call C{getContext} on C{oldStyleContextFactory} in order to force advance parameter checking, since old-style context factories don't actually check that their arguments to L{OpenSSL} are correct. @param oldStyleContextFactory: A factory that can produce contexts. @type oldStyleContextFactory: L{twisted.internet.interfaces.IOpenSSLContextFactory} N)� getContext�_oldStyleContextFactory)r �oldStyleContextFactoryr r r r! n s z+_ContextFactoryToConnectionFactory.__init__c C s | j �� }t|d�S )z� Create an L{OpenSSL.SSL.Connection} object. @param protocol: The protocol initiating a TLS connection. @type protocol: L{TLSMemoryBIOProtocol} @return: a connection @rtype: L{OpenSSL.SSL.Connection} N)r� r� r )r �protocol�contextr r r �_connectionForTLS~ s z4_ContextFactoryToConnectionFactory._connectionForTLSc C � | � |�S )a� Construct an OpenSSL server connection from the wrapped old-style context factory. @note: Since old-style context factories don't distinguish between clients and servers, this is exactly the same as L{_ContextFactoryToConnectionFactory.clientConnectionForTLS}. @param protocol: The protocol initiating a TLS connection. @type protocol: L{TLSMemoryBIOProtocol} @return: a connection @rtype: L{OpenSSL.SSL.Connection} �r� �r r� r r r �serverConnectionForTLS� � z9_ContextFactoryToConnectionFactory.serverConnectionForTLSc C r� )a� Construct an OpenSSL server connection from the wrapped old-style context factory. @note: Since old-style context factories don't distinguish between clients and servers, this is exactly the same as L{_ContextFactoryToConnectionFactory.serverConnectionForTLS}. @param protocol: The protocol initiating a TLS connection. @type protocol: L{TLSMemoryBIOProtocol} @return: a connection @rtype: L{OpenSSL.SSL.Connection} r� r� r r r �clientConnectionForTLS� r� z9_ContextFactoryToConnectionFactory.clientConnectionForTLSN)r) r* r+ r, r! r� r� r� r r r r r� c s r� c @ s8 e Zd ZdZeZdZdd� Zdd� Zdd� Z d d � Z d S ) �TLSMemoryBIOFactorya� L{TLSMemoryBIOFactory} adds TLS to connections. @ivar _creatorInterface: the interface which L{_connectionCreator} is expected to implement. @type _creatorInterface: L{zope.interface.interfaces.IInterface} @ivar _connectionCreator: a callable which creates an OpenSSL Connection object. @type _connectionCreator: 1-argument callable taking L{TLSMemoryBIOProtocol} and returning L{OpenSSL.SSL.Connection}. Fc C s< t �| |� |r t}nt}|| _|�|�st|�}|| _dS )a2 Create a L{TLSMemoryBIOFactory}. @param contextFactory: Configuration parameters used to create an OpenSSL connection. In order of preference, what you should pass here should be: 1. L{twisted.internet.ssl.CertificateOptions} (if you're writing a server) or the result of L{twisted.internet.ssl.optionsForClientTLS} (if you're writing a client). If you want security you should really use one of these. 2. If you really want to implement something yourself, supply a provider of L{IOpenSSLClientConnectionCreator} or L{IOpenSSLServerConnectionCreator}. 3. If you really have to, supply a L{twisted.internet.ssl.ContextFactory}. This will likely be deprecated at some point so please upgrade to the new interfaces. @type contextFactory: L{IOpenSSLClientConnectionCreator} or L{IOpenSSLServerConnectionCreator}, or, for compatibility with older code, anything implementing L{twisted.internet.interfaces.IOpenSSLContextFactory}. See U{https://twistedmatrix.com/trac/ticket/7215} for information on the upcoming deprecation of passing a L{twisted.internet.ssl.ContextFactory} here. @param isClient: Is this a factory for TLS client connections; in other words, those that will send a C{ClientHello} greeting? L{True} if so, L{False} otherwise. This flag determines what interface is expected of C{contextFactory}. If L{True}, C{contextFactory} should provide L{IOpenSSLClientConnectionCreator}; otherwise it should provide L{IOpenSSLServerConnectionCreator}. @type isClient: L{bool} @param wrappedFactory: A factory which will create the application-level protocol. @type wrappedFactory: L{twisted.internet.interfaces.IProtocolFactory} N)r r! r r �_creatorInterfacer r� �_connectionCreator)r �contextFactory�isClient�wrappedFactory�creatorInterfacer r r r! � s + z TLSMemoryBIOFactory.__init__c C s, t �| j�r | j�� }n| jjj}|� d�S )z� Annotate the wrapped factory's log prefix with some text indicating TLS is in use. @rtype: C{str} z (TLS))r r r� � logPrefix� __class__r) )r r� r r r r� � s z TLSMemoryBIOFactory.logPrefixc C s, t �| j�r| j�� }|�� }t||� dS )a8 Applies ALPN/NPN protocol neogitation to the connection, if the factory supports it. @param connection: The OpenSSL connection object to have ALPN/NPN added to it. @type connection: L{OpenSSL.SSL.Connection} @return: Nothing @rtype: L{None} N)r r r� �acceptableProtocols� get_contextr )r � connection� protocolsr� r r r �_applyProtocolNegotiation s z-TLSMemoryBIOFactory._applyProtocolNegotiationc C sP | j }| jtu r|�|�}| �|� |�� |S |�|�}| �|� |�� |S )a8 Create an OpenSSL connection and set it up good. @param tlsProtocol: The protocol which is establishing the connection. @type tlsProtocol: L{TLSMemoryBIOProtocol} @return: an OpenSSL connection object for C{tlsProtocol} to use @rtype: L{OpenSSL.SSL.Connection} )r� r� r r� r� �set_connect_stater� �set_accept_state)r � tlsProtocol�connectionCreatorr� r r r r3 s � z%TLSMemoryBIOFactory._createConnectionN) r) r* r+ r, r- r� �noisyr! r� r� r3 r r r r r� � s 5 r� )*r, � OpenSSL.SSLr r r r r r r` �er_ � ImportError�zope.interfacer r r �"twisted.internet._producer_helpersr �twisted.internet._sslverifyr �twisted.internet.interfacesr r r r r r r r �twisted.internet.mainr �twisted.internet.protocolr �twisted.protocols.policiesr r �twisted.python.failurer r r- r� r� r r r r �<module> s8 # �� ( + mJPK Mb�Z��M�c c . protocols/__pycache__/stateful.cpython-310.pycnu �[��� o �b� � @ s. d dl mZ d dlmZ G dd� dej�ZdS )� )�BytesIO)�protocolc @ s, e Zd ZdZdZdd� Zdd� Zdd� Zd S ) �StatefulProtocola- A Protocol that stores state for you. state is a pair (function, num_bytes). When num_bytes bytes of data arrives from the network, function is called. It is expected to return the next state or None to keep same state. Initial state is returned by getInitialState (override it). )NNr c C s$ t j�| |� | �� t� df| _d S )Nr )r �Protocol�makeConnection�getInitialStater � _sful_data)�self� transport� r �</usr/lib/python3/dist-packages/twisted/protocols/stateful.pyr s z StatefulProtocol.makeConnectionc C s t �)N)�NotImplementedError)r r r r r s z StatefulProtocol.getInitialStatec C s� | j \}}}|�dd� |�|� |�� }|�|� || |d krG|�|d �}||d 7 }|d |�}| jjr;d S |r?|}|| |d ks"|dkr_|�� }|�d� |�� |�|� d}|||f| _ d S )Nr � � )r �seek�write�tell�readr � disconnecting�truncate) r �data�state�buffer�offset�blen�d�next�br r r � dataReceived s, �� z StatefulProtocol.dataReceivedN)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s r N)�ior �twisted.internetr r r r r r r �<module> s PK Mb�Z��C^�% �% ) protocols/__pycache__/htb.cpython-310.pycnu �[��� o �b�$ � @ s� d Z ddlmZ ddlmZ ddlmZmZ ddlmZ G dd� d�Z G dd � d e�Z ee �G d d � d ��Z G d d � d e �Z G dd� de �Z G dd� dej�ZG dd� de�ZG dd� d�ZdS )a� Hierarchical Token Bucket traffic shaping. Patterned after U{Martin Devera's Hierarchical Token Bucket traffic shaper for the Linux kernel<http://luxik.cdi.cz/~devik/qos/htb/>}. @seealso: U{HTB Linux queuing discipline manual - user guide <http://luxik.cdi.cz/~devik/qos/htb/manual/userg.htm>} @seealso: U{Token Bucket Filter in Linux Advanced Routing & Traffic Control HOWTO<http://lartc.org/howto/lartc.qdisc.classless.html#AEN682>} � )�time)�Optional)� Interface� implementer)�pcpc @ sP e Zd ZU dZdZee ed< dZee ed< dZ d dd�Z dd � Z d d � Z dS ) �Bucketa� Implementation of a Token bucket. A bucket can hold a certain number of tokens and it drains over time. @cvar maxburst: The maximum number of tokens that the bucket can hold at any given time. If this is L{None}, the bucket has an infinite size. @type maxburst: C{int} @cvar rate: The rate at which the bucket drains, in number of tokens per second. If the rate is L{None}, the bucket drains instantaneously. @type rate: C{int} N�maxburst�rater c C s d| _ || _t� | _dS )a( Create a L{Bucket} that may have a parent L{Bucket}. @param parentBucket: If a parent Bucket is specified, all L{add} and L{drip} operations on this L{Bucket} will be applied on the parent L{Bucket} as well. @type parentBucket: L{Bucket} r N)�content� parentBucketr �lastDrip)�selfr � r �7/usr/lib/python3/dist-packages/twisted/protocols/htb.py�__init__3 s zBucket.__init__c C sR | � � | jdu r |}n t|| j| j �}| jdur | j�|�}| j|7 _|S )at Adds tokens to the L{Bucket} and its C{parentBucket}. This will add as many of the C{amount} tokens as will fit into both this L{Bucket} and its C{parentBucket}. @param amount: The number of tokens to try to add. @type amount: C{int} @returns: The number of tokens that actually fit. @returntype: C{int} N)�dripr �minr r �add)r �amount� allowabler r r r @ s z Bucket.addc C sb | j dur | j �� | jdu rd| _nt� }|| j }|| j }td| j| �| _|| _| jdkS )z� Let some of the bucket drain. The L{Bucket} drains at the rate specified by the class variable C{rate}. @returns: C{True} if the bucket is empty after this drip. @returntype: C{bool} Nr )r r r r r r �max)r �now� deltaTime� deltaTokensr r r r X s z Bucket.drip�N) �__name__� __module__� __qualname__�__doc__r r �int�__annotations__r � _refcountr r r r r r r r s r c @ s e Zd Zdd� ZdS )� IBucketFilterc O � dS )zn Return a L{Bucket} corresponding to the provided parameters. @returntype: L{Bucket} Nr )� somethings�some_kwr r r � getBucketForq s zIBucketFilter.getBucketForN)r r r r& r r r r r" p s r" c @ sH e Zd ZU dZeZdZee e d< d dd�Z dd� Z dd � Z d d � Z dS ) �HierarchicalBucketFilterz� Filter things into buckets that can be nested. @cvar bucketFactory: Class of buckets to make. @type bucketFactory: L{Bucket} @cvar sweepInterval: Seconds between sweeping out the bucket cache. @type sweepInterval: C{int} N� sweepIntervalc C s i | _ || _t� | _d S r )�buckets� parentFilterr � lastSweep)r r* r r r r � s z!HierarchicalBucketFilter.__init__c O s� | j durt� | j | j kr| �� | jr#| jj| g|�R i |��}nd}| j|i |��}| j�|�}|du rA| � |�}|| j|< |S )z� Find or create a L{Bucket} corresponding to the provided parameters. Any parameters are passed on to L{getBucketKey}, from them it decides which bucket you get. @returntype: L{Bucket} N) r( r r+ �sweepr* r& � getBucketKeyr) �get� bucketFactory)r �a�kwr �key�bucketr r r r& � s z%HierarchicalBucketFilter.getBucketForc O r# )a% Construct a key based on the input parameters to choose a L{Bucket}. The default implementation returns the same key for all arguments. Override this method to provide L{Bucket} selection. @returns: Something to be used as a key in the bucket cache. Nr )r r0 r1 r r r r- � s z%HierarchicalBucketFilter.getBucketKeyc C s> | j �� D ]\}}|�� }|jdkr|r| j |= qt� | _dS )z' Remove empty buckets. r N)r) �itemsr r! r r+ )r r2 r3 �bucket_is_emptyr r r r, � s � z HierarchicalBucketFilter.sweepr )r r r r r r/ r( r r r r r& r- r, r r r r r' y s r' c @ � e Zd ZdZdZdd� ZdS )� FilterByHostzF A Hierarchical Bucket filter with a L{Bucket} for each host. i� c C � |� � d S �N� )�getPeer�r � transportr r r r- � � zFilterByHost.getBucketKeyN�r r r r r( r- r r r r r7 � � r7 c @ s e Zd ZdZdZdd� ZdS )�FilterByServerzI A Hierarchical Bucket filter with a L{Bucket} for each service. Nc C r8 )N� )�getHostr< r r r r- � r> zFilterByServer.getBucketKeyr? r r r r rA � r@ rA c @ s, e Zd ZdZdZdd� Zdd� Zdd� Zd S ) �ShapedConsumerzL Wraps a C{Consumer} and shapes the rate at which it receives data. Fc C s( t j�| |� || _| j jd7 _d S r9 )r �ProducerConsumerProxyr r3 r! )r �consumerr3 r r r r � s zShapedConsumer.__init__c C s& | j �t|��}tj�| |d |� �S r )r3 r �lenr rE �_writeSomeData)r �datar r r r rH � s z ShapedConsumer._writeSomeDatac C s t j�| � | j jd8 _d S r9 )r rE � stopProducingr3 r! )r r r r rJ � s z ShapedConsumer.stopProducingN)r r r r � iAmStreamingr rH rJ r r r r rD � s rD c @ r6 )�ShapedTransportaR Wraps a C{Transport} and shapes the rate at which it receives data. This is a L{ShapedConsumer} with a little bit of magic to provide for the case where the consumer it wraps is also a C{Transport} and people will be attempting to access attributes this does not proxy as a C{Consumer} (e.g. C{loseConnection}). Fc C s t | j|�S r )�getattrrF )r �namer r r � __getattr__� s zShapedTransport.__getattr__N)r r r r rK rO r r r r rL � s rL c @ s e Zd ZdZdd� Zdd� ZdS )�ShapedProtocolFactorya� Dispense C{Protocols} with traffic shaping on their transports. Usage:: myserver = SomeFactory() myserver.protocol = ShapedProtocolFactory(myserver.protocol, bucketFilter) Where C{SomeServerFactory} is a L{twisted.internet.protocol.Factory}, and C{bucketFilter} is an instance of L{HierarchicalBucketFilter}. c C s || _ || _dS )a� Tell me what to wrap and where to get buckets. @param protoClass: The class of C{Protocol} this will generate wrapped instances of. @type protoClass: L{Protocol<twisted.internet.interfaces.IProtocol>} class @param bucketFilter: The filter which will determine how traffic is shaped. @type bucketFilter: L{HierarchicalBucketFilter}. N)�protocol� bucketFilter)r � protoClassrR r r r r s z ShapedProtocolFactory.__init__c s. �j |i |��}|j� � �fdd�}||_|S )z� Make a C{Protocol} instance with a shaped transport. Any parameters will be passed on to the protocol's initializer. @returns: A C{Protocol} instance with a L{ShapedTransport}. c s �j �| �}t| |�}� |�S r )rR r& rL )r= r3 �shapedTransport��origMakeConnectionr r r �makeConnection, s z6ShapedProtocolFactory.__call__.<locals>.makeConnection)rQ rW )r r0 r1 �protorW r rU r �__call__! s z ShapedProtocolFactory.__call__N)r r r r r rY r r r r rP s rP N)r r �typingr �zope.interfacer r �twisted.protocolsr r r" r' r7 rA rE rD rL rP r r r r �<module> s R C PK Mb�ZP�=�� � 1 protocols/__pycache__/portforward.cpython-310.pycnu �[��� o �bC � @ sv d Z ddlmZ ddlmZ G dd� dej�ZG dd� de�ZG dd � d ej�Z G d d � d e�Z G d d � d ej �Z dS )z A simple port forwarder. � )�protocol)�logc @ s, e Zd ZdZdZdd� Zdd� Zdd� ZdS ) �ProxyTNc C � || _ d S �N)�peer)�selfr � r �?/usr/lib/python3/dist-packages/twisted/protocols/portforward.py�setPeer � z Proxy.setPeerc C s> | j d ur| j j�� d | _ d S | jr t�d|� �� d S d S )NzUnable to connect to peer: )r � transport�loseConnection�noisyr �msg)r �reasonr r r �connectionLost s �zProxy.connectionLostc C s | j j�|� d S r )r r �write)r �datar r r � dataReceived s zProxy.dataReceived)�__name__� __module__� __qualname__r r r r r r r r r r s r c @ s e Zd Zdd� ZdS )� ProxyClientc C s@ | j �| � | j�| j jd� | j j�| jd� | j j�� d S )NT)r r r �registerProducer�resumeProducing)r r r r �connectionMade! s zProxyClient.connectionMadeN)r r r r r r r r r s r c @ s( e Zd ZeZdd� Zdd� Zdd� ZdS )�ProxyClientFactoryc C r r )�server)r r r r r � setServer3 r z ProxyClientFactory.setServerc O s* t jj| g|�R i |��}|�| j� |S r )r � ClientFactory� buildProtocolr r )r �args�kw�protr r r r! 6 s z ProxyClientFactory.buildProtocolc C s | j j�� d S r )r r r )r � connectorr r r r �clientConnectionFailed; s z)ProxyClientFactory.clientConnectionFailedN)r r r r r r r! r& r r r r r / s r c @ s e Zd ZeZdZdd� ZdS )� ProxyServerNc C sT | j �� | �� }|�| � | jd u r ddlm} || _| j�| jj| jj |� d S )Nr )�reactor) r �pauseProducing�clientProtocolFactoryr r( �twisted.internet� connectTCP�factory�host�port)r �clientr( r r r r D s zProxyServer.connectionMade)r r r r r* r( r r r r r r' ? s r' c @ s e Zd ZdZeZdd� ZdS )� ProxyFactoryz% Factory for port forwarder. c C s || _ || _d S r )r. r/ )r r. r/ r r r �__init__Z s zProxyFactory.__init__N)r r r �__doc__r' r r2 r r r r r1 S s r1 N) r3 r+ r �twisted.pythonr �Protocolr r r r r' �Factoryr1 r r r r �<module> s PK Mb�Z�F�K)] )] . protocols/__pycache__/policies.cpython-310.pycnu �[��� o �b{S � @ sB d Z ddlZddlmZmZ ddlmZmZ ddlm Z m Z ddl m Z ddl mZmZmZ ddlmZ d d � ZG d d � d e�ZG d d� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd � d e�Z G d d � d e�Z G d d � d e�Z G d!d"� d"e�Z G d#d$� d$�Z dS )%z] Resource limiting policies. @seealso: See also L{twisted.protocols.htb} for rate limiting. � N)�Optional�Type)�directlyProvides� providedBy)�error� interfaces)�ILoggingContext)� ClientFactory�Protocol� ServerFactory)�logc C s0 t �|�r |�� }n|jj}|� d| jj� d�S )zY Compute a log prefix for a wrapper and the object it wraps. @rtype: C{str} z (�))r r � logPrefix� __class__�__name__)�wrapper�wrappedr � r �</usr/lib/python3/dist-packages/twisted/protocols/policies.py�_wrappedLogPrefix s r c @ s� e Zd ZdZdZdddejfdd�Zdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�ProtocolWrappera� Wraps protocol instances and acts as their transport as well. @ivar wrappedProtocol: An L{IProtocol<twisted.internet.interfaces.IProtocol>} provider to which L{IProtocol<twisted.internet.interfaces.IProtocol>} method calls onto this L{ProtocolWrapper} will be proxied. @ivar factory: The L{WrappingFactory} which created this L{ProtocolWrapper}. r �factory�WrappingFactory�wrappedProtocolc C s || _ || _d S �N)r r )�selfr r r r r �__init__5 s zProtocolWrapper.__init__c C � t | | j�S )zo Use a customized log prefix mentioning both the wrapped protocol and the current one. )r r �r r r r r ; s zProtocolWrapper.logPrefixc C s6 t | t|�� t�| |� | j�| � | j�| � dS )z� When a connection is made, register this wrapper with its factory, save the real transport, and connect the wrapped protocol to this L{ProtocolWrapper} to intercept any transport calls it makes. N)r r r �makeConnectionr �registerProtocolr )r � transportr r r r B s z ProtocolWrapper.makeConnectionc C � | j �|� d S r )r! �write�r �datar r r r# O � zProtocolWrapper.writec C r" r )r! � writeSequencer$ r r r r' R r& z ProtocolWrapper.writeSequencec C s d| _ | j�� d S �N� )� disconnectingr! �loseConnectionr r r r r+ U s z ProtocolWrapper.loseConnectionc C � | j �� S r )r! �getPeerr r r r r- Y � zProtocolWrapper.getPeerc C r, r )r! �getHostr r r r r/ \ r. zProtocolWrapper.getHostc C � | j �||� d S r )r! �registerProducer�r �producer� streamingr r r r1 _ � z ProtocolWrapper.registerProducerc C � | j �� d S r )r! �unregisterProducerr r r r r7 b � z"ProtocolWrapper.unregisterProducerc C r6 r )r! � stopConsumingr r r r r9 e r8 z ProtocolWrapper.stopConsumingc C s t | j|�S r )�getattrr! �r �namer r r � __getattr__h s zProtocolWrapper.__getattr__c C r" r )r � dataReceivedr$ r r r r> m r& z ProtocolWrapper.dataReceivedc C s" | j �| � | j�|� d | _d S r )r �unregisterProtocolr �connectionLost�r �reasonr r r r@ p s z ProtocolWrapper.connectionLostN)r � __module__� __qualname__�__doc__r* r � IProtocolr r r r# r' r+ r- r/ r1 r7 r9 r= r> r@ r r r r r ' s* � � r c @ sr e Zd ZU dZeZee ed< dd� Z dd� Z dd� Z d d � Z d d � Z d d� Zdd� Zdd� Zdd� Zdd� ZdS )r zE Wraps a factory and its protocols, and keeps track of them. �protocolc C s || _ i | _d S r )�wrappedFactory� protocols)r rH r r r r s zWrappingFactory.__init__c C r )zY Generate a log prefix mentioning both the wrapped factory and this one. )r rH r r r r r � � zWrappingFactory.logPrefixc C � | j �� t�| � d S r )rH �doStartr r r r r rL � � zWrappingFactory.doStartc C rK r )rH �doStopr r r r r rN � rM zWrappingFactory.doStopc C r" r )rH �startedConnecting)r � connectorr r r rO � r& z!WrappingFactory.startedConnectingc C r0 r )rH �clientConnectionFailed�r rP rB r r r rQ � r5 z&WrappingFactory.clientConnectionFailedc C r0 r )rH �clientConnectionLostrR r r r rS � r5 z$WrappingFactory.clientConnectionLostc C s | � | | j�|��S r )rG rH � buildProtocol�r �addrr r r rT � s z WrappingFactory.buildProtocolc C s d| j |< dS )z8 Called by protocol to register itself. r) N�rI �r �pr r r r � s z WrappingFactory.registerProtocolc C s | j |= dS )z8 Called by protocols when they go away. NrW rX r r r r? � rJ z"WrappingFactory.unregisterProtocolN)r rC rD rE r rG r r �__annotations__r r rL rN rO rQ rS rT r r? r r r r r x s r c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�ThrottlingProtocolz, Protocol for L{ThrottlingFactory}. c C � | j �t|�� t�| |� d S r )r �registerWritten�lenr r# r$ r r r r# � � zThrottlingProtocol.writec C s& | j �ttt|��� t�| |� d S r )r r] �sum�mapr^ r r' �r �seqr r r r' � s z ThrottlingProtocol.writeSequencec C r\ r )r � registerReadr^ r r> r$ r r r r> � r_ z ThrottlingProtocol.dataReceivedc C s || _ t�| ||� d S r )r3 r r1 r2 r r r r1 � s z#ThrottlingProtocol.registerProducerc C s | ` t�| � d S r )r3 r r7 r r r r r7 � s z%ThrottlingProtocol.unregisterProducerc C r6 r )r! �pauseProducingr r r r � throttleReads� r8 z ThrottlingProtocol.throttleReadsc C r6 r )r! �resumeProducingr r r r �unthrottleReads� r8 z"ThrottlingProtocol.unthrottleReadsc C � t | d�r | j�� d S d S �Nr3 )�hasattrr3 re r r r r �throttleWrites� � �z!ThrottlingProtocol.throttleWritesc C ri rj )rk r3 rg r r r r �unthrottleWrites� rm z#ThrottlingProtocol.unthrottleWritesN) r rC rD rE r# r' r> r1 r7 rf rh rl rn r r r r r[ � s r[ c @ s~ e Zd ZdZeZejddfdd�Zdd� Z dd� Z d d � Z d d � Z d d� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� ZdS )�ThrottlingFactoryz� Throttles bandwidth and number of connections. Write bandwidth will only be throttled if there is a producer registered. Nc C sL t �| |� d| _|| _|| _|| _d| _d| _d | _d | _ d | _ d | _ d S �Nr ) r r �connectionCount�maxConnectionCount� readLimit� writeLimit�readThisSecond�writtenThisSecond�unthrottleReadsID�checkReadBandwidthID�unthrottleWritesID�checkWriteBandwidthID)r rH rr rs rt r r r r � s zThrottlingFactory.__init__c C � ddl m} |�||�S �z� Wrapper around L{reactor.callLater<twisted.internet.interfaces.IReactorTime.callLater>} for test purpose. r )�reactor��twisted.internetr} � callLater�r �period�funcr} r r r r� � � zThrottlingFactory.callLaterc C � | j |7 _ dS )zH Called by protocol to tell us more bytes were written. N)rv �r �lengthr r r r] � � z!ThrottlingFactory.registerWrittenc C r� )zE Called by protocol to tell us more bytes were read. N)ru r� r r r rd r� z ThrottlingFactory.registerReadc C sR | j | jkr | �� t| j �| j d }| �|| j�| _d| _ | �d| j�| _dS )z: Checks if we've passed bandwidth limits. � �?r r) N) ru rs rf �floatr� rh rw �checkReadBandwidthrx �r � throttleTimer r r r� s z$ThrottlingFactory.checkReadBandwidthc C sR | j | jkr | �� t| j �| j d }| �|| j�| _d| _ | �d| j�| _d S )Nr� r r) ) rv rt rl r� r� rn ry �checkWriteBandwidthrz r� r r r r� s �z%ThrottlingFactory.checkWriteBandwidthc C �* t �d| � | j�� D ]}|�� q dS )z2 Throttle reads on all protocols. zThrottling reads on %sN)r �msgrI �keysrf rX r r r rf � �z ThrottlingFactory.throttleReadsc C �0 d| _ t�d| � | j�� D ]}|�� qdS )z9 Stop throttling reads on all protocols. Nz Stopped throttling reads on %s)rw r r� rI r� rh rX r r r rh % � �z!ThrottlingFactory.unthrottleReadsc C r� )z3 Throttle writes on all protocols. zThrottling writes on %sN)r r� rI r� rl rX r r r rl . r� z ThrottlingFactory.throttleWritesc C r� )z: Stop throttling writes on all protocols. Nz Stopped throttling writes on %s)ry r r� rI r� rn rX r r r rn 6 r� z"ThrottlingFactory.unthrottleWritesc C sb | j dkr| jd ur| �� | jd ur| �� | j | jk r*| j d7 _ t�| |�S t� d� d S )Nr r) z Max connection count reached!) rq rs r� rt r� rr r rT r r� rU r r r rT ? s z ThrottlingFactory.buildProtocolc C s� t �| |� | jd8 _| jdkr<| jd ur | j�� | jd ur&| j�� | jd ur0| j�� | jd ur>| j�� d S d S d S �Nr) r )r r? rq rw �cancelrx ry rz rX r r r r? M s �z$ThrottlingFactory.unregisterProtocol)r rC rD rE r[ rG �sys�maxsizer r� r] rd r� r� rf rh rl rn rT r? r r r r ro � s$ � ro c @ s e Zd Zdd� Zdd� ZdS )�SpewingProtocolc C � t �d| � t�| |� d S )Nz Received: %r)r r� r r> r$ r r r r> \ � z SpewingProtocol.dataReceivedc C r� )Nz Sending: %r)r r� r r# r$ r r r r# ` r� zSpewingProtocol.writeN)r rC rD r> r# r r r r r� [ s r� c @ s e Zd ZeZdS )�SpewingFactoryN)r rC rD r� rG r r r r r� e s r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �LimitConnectionsByPeer� c C s i | _ d S r )�peerConnectionsr r r r � startFactorym r. z#LimitConnectionsByPeer.startFactoryc C s> |d }| j �|d�}|| jkrd S |d | j |< t�| |�S )Nr r) )r� �get�maxConnectionsPerPeerr rT )r rV �peerHostrq r r r rT p s z$LimitConnectionsByPeer.buildProtocolc C s< |� � d }| j| d8 < | j| dkr | j|= d S d S r� )r- r� )r rY r� r r r r? x s �z)LimitConnectionsByPeer.unregisterProtocolN)r rC rD r� r� rT r? r r r r r� i s r� c @ sF e Zd ZU dZdZdZdZeee e d< dd� Z dd� Z d d � Z dS ) � LimitTotalConnectionsFactorya� Factory that limits the number of simultaneous connections. @type connectionCount: C{int} @ivar connectionCount: number of current connections. @type connectionLimit: C{int} or L{None} @cvar connectionLimit: maximum number of connections. @type overflowProtocol: L{Protocol} or L{None} @cvar overflowProtocol: Protocol to use for new connections when connectionLimit is exceeded. If L{None} (the default value), excess connections will be closed immediately. r N�overflowProtocolc C sX | j d u s | j| j k r| �� }n | jd u rd S | �� }| |_t| |�}| jd7 _|S r( )�connectionLimitrq rG r� r r )r rV r rG r r r rT � s z*LimitTotalConnectionsFactory.buildProtocolc C s d S r r rX r r r r � s z-LimitTotalConnectionsFactory.registerProtocolc C s | j d8 _ d S r( )rq rX r r r r? � r5 z/LimitTotalConnectionsFactory.unregisterProtocol)r rC rD rE rq r� r� r r r rZ rT r r? r r r r r� s r� c @ sZ e Zd ZdZdd� Zddd�Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dS )�TimeoutProtocolzN Protocol that automatically disconnects when the connection is idle. c C s( t �| ||� d| _d| _| �|� dS )z� Constructor. @param factory: An L{TimeoutFactory}. @param wrappedProtocol: A L{Protocol} to wrapp. @param timeoutPeriod: Number of seconds to wait for activity before timing out. N)r r � timeoutCall� timeoutPeriod� setTimeout)r r r r� r r r r � s zTimeoutProtocol.__init__Nc C s2 | � � || _|dur| j�| j| j�| _dS dS )z� Set a timeout. This will cancel any existing timeouts. @param timeoutPeriod: If not L{None}, change the timeout period. Otherwise, use the existing value. N)� cancelTimeoutr� r r� � timeoutFuncr� )r r� r r r r� � s ��zTimeoutProtocol.setTimeoutc C sD d| _ | jr z| j�� W n tjtjfy Y nw d| _dS dS )zg Cancel the timeout. If the timeout was already cancelled, this does nothing. N)r� r� r� r � AlreadyCalled�AlreadyCancelledr r r r r� � s � �z TimeoutProtocol.cancelTimeoutc C s | j r | j �| j� dS dS )zQ Reset the timeout, usually because some activity just happened. N)r� �resetr� r r r r � resetTimeout� s �z TimeoutProtocol.resetTimeoutc C � | � � t�| |� d S r )r� r r# r$ r r r r# � � zTimeoutProtocol.writec C r� r )r� r r' rb r r r r' � r� z TimeoutProtocol.writeSequencec C r� r )r� r r> r$ r r r r> � r� z TimeoutProtocol.dataReceivedc C r� r )r� r r@ rA r r r r@ � r� z TimeoutProtocol.connectionLostc C s | � � dS )z� This method is called when the timeout is triggered. By default it calls I{loseConnection}. Override this if you want something else to happen. N)r+ r r r r r� � s zTimeoutProtocol.timeoutFuncr ) r rC rD rE r r� r� r� r# r' r> r@ r� r r r r r� � s r� c @ s. e Zd ZdZeZd dd�Zdd� Zdd� Zd S ) �TimeoutFactoryz% Factory for TimeoutWrapper. � c C s || _ t�| |� d S r )r� r r )r rH r� r r r r s zTimeoutFactory.__init__c C s | j | | j�|�| jd�S )N)r� )rG rH rT r� rU r r r rT s �z TimeoutFactory.buildProtocolc C r{ r| r~ r� r r r r� r� zTimeoutFactory.callLaterN)r� ) r rC rD rE r� rG r rT r� r r r r r� � s r� c @ sV e Zd Zddd�Zdd� Zdd� Zd d � Zd d � Zd d� Zdd� Z dd� Z dd� Z dS )�TrafficLoggingProtocolNr c C s$ t �| ||� || _|| _|| _dS )a @param factory: factory which created this protocol. @type factory: L{protocol.Factory}. @param wrappedProtocol: the underlying protocol. @type wrappedProtocol: C{protocol.Protocol}. @param logfile: file opened for writing used to write log messages. @type logfile: C{file} @param lengthLimit: maximum size of the datareceived logged. @type lengthLimit: C{int} @param number: identifier of the connection. @type number: C{int}. N)r r �logfile� lengthLimit�_number)r r r r� r� �numberr r r r s z TrafficLoggingProtocol.__init__c C s | j �|d � | j �� d S )N� )r� r# �flush)r �liner r r �_log* s zTrafficLoggingProtocol._logc C s. | j rt|�| j kr|d | j d � d }|S )N� z <... elided>)r� r^ r$ r r r � _mungeData. s z!TrafficLoggingProtocol._mungeDatac C s | � d� t�| �S )N�*)r� r �connectionMader r r r r� 4 s z%TrafficLoggingProtocol.connectionMadec C �& | � d| j| �|�f � t�| |�S �NzC %d: %r)r� r� r� r r> r$ r r r r> 8 � z#TrafficLoggingProtocol.dataReceivedc C s | � d| j|f � t�| |�S r� )r� r� r r@ rA r r r r@ < s z%TrafficLoggingProtocol.connectionLostc C r� )NzS %d: %r)r� r� r� r r# r$ r r r r# A r� z TrafficLoggingProtocol.writec s. � � d� j� fdd�|D �f � t�� |�S )Nz SV %d: %rc s g | ]}� � |��qS r )r� )�.0�dr r r � <listcomp>F s z8TrafficLoggingProtocol.writeSequence.<locals>.<listcomp>)r� r� r r' )r �iovecr r r r' E s " z$TrafficLoggingProtocol.writeSequencec C s | � d| jf � t�| �S )NzS %d: *)r� r� r r+ r r r r r+ I s z%TrafficLoggingProtocol.loseConnectionrp ) r rC rD r r� r� r� r> r@ r# r' r+ r r r r r� s r� c @ s6 e Zd ZeZdZd dd�Zdd� Zdd� Zd d � Z dS ) �TrafficLoggingFactoryr Nc C s || _ || _t�| |� d S r )� logfilePrefixr� r r )r rH r� r� r r r r S s z TrafficLoggingFactory.__init__c C s t |d�S )N�w)�openr; r r r r� X r. zTrafficLoggingFactory.openc C sF | j d7 _ | �| jd t| j � �}| �| | j�|�|| j| j �S )Nr) �-)�_counterr� r� �strrG rH rT r� )r rV r� r r r rT [ s �z#TrafficLoggingFactory.buildProtocolc C s d| _ dS )zN Reset the value of the counter used to identify connections. r N)r� r r r r � resetCounterf s z"TrafficLoggingFactory.resetCounterr ) r rC rD r� rG r� r r� rT r� r r r r r� N s r� c @ sN e Zd ZU dZdZee ed< dZdd� Z dd� Z dd � Z d d � Z d d � Z dS )� TimeoutMixinaL Mixin for protocols which wish to timeout connections. Protocols that mix this in have a single timeout, set using L{setTimeout}. When the timeout is hit, L{timeoutConnection} is called, which, by default, closes the connection. @cvar timeOut: The number of seconds after which to timeout the connection. N�timeOutc C r{ r| r~ r� r r r r� | r� zTimeoutMixin.callLaterc C s. | j dur| jdur| j �| j� dS dS dS )a� Reset the timeout count down. If the connection has already timed out, then do nothing. If the timeout has been cancelled (probably using C{setTimeout(None)}), also do nothing. It's often a good idea to call this when the protocol has received some meaningful input from the other end of the connection. "I've got some data, they're still there, reset the timeout". N)�_TimeoutMixin__timeoutCallr� r� r r r r r� � s �zTimeoutMixin.resetTimeoutc C s~ | j }|| _ | jdur1|du r)z| j�� W n tjtjfy# Y nw d| _|S | j�|� |S |dur=| �|| j�| _|S )z� Change the timeout period @type period: C{int} or L{None} @param period: The period, in seconds, to change the timeout to, or L{None} to disable the timeout. N) r� r� r� r r� r� r� r� �_TimeoutMixin__timedOut)r r� �prevr r r r� � s � ��zTimeoutMixin.setTimeoutc C s d | _ | �� d S r )r� �timeoutConnectionr r r r � __timedOut� s zTimeoutMixin.__timedOutc C s | j �� dS )z� Called when the connection times out. Override to define behavior other than dropping the connection. N)r! r+ r r r r r� � s z TimeoutMixin.timeoutConnection)r rC rD rE r� r �intrZ r� r� r� r� r� r� r r r r r� m s r� )!rE r� �typingr r �zope.interfacer r r r r �twisted.internet.interfacesr �twisted.internet.protocolr r r �twisted.pythonr r r r r[ ro r� r� r� r� r� r� r� r� r� r r r r �<module> s. Q2* )R 7 PK Mb�Z� ��" �" + protocols/__pycache__/socks.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlZddlZddlmZmZmZ ddl m Z G dd� dej �Z G dd� dej �Z G d d � d ej �ZG d d � d ej�ZG d d� dej�ZdS )z) Implementation of the SOCKSv4 protocol. � N)�defer�protocol�reactor)�logc @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �SOCKSv4Outgoingc C � || _ d S �N)�socks��selfr � r �9/usr/lib/python3/dist-packages/twisted/protocols/socks.py�__init__ � zSOCKSv4Outgoing.__init__c C s. | j �� }| jjdd|j|jd� | | j_d S )N�Z r )�port�ip)� transport�getPeerr � makeReplyr �host� otherConn)r �peerr r r �connectionMade s z SOCKSv4Outgoing.connectionMadec C � | j j�� d S r �r r �loseConnection�r �reasonr r r �connectionLost � z SOCKSv4Outgoing.connectionLostc C � | j �|� d S r �r �write�r �datar r r � dataReceived! r z SOCKSv4Outgoing.dataReceivedc C � | j �| |� | j�|� d S r �r r r r# r$ r r r r# $ � zSOCKSv4Outgoing.writeN)�__name__� __module__� __qualname__r r r r& r# r r r r r s r c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �SOCKSv4Incomingc C s || _ | | j _d S r )r r r r r r r * s zSOCKSv4Incoming.__init__c C r r r r r r r r . r z SOCKSv4Incoming.connectionLostc C r! r r" r$ r r r r& 1 r z SOCKSv4Incoming.dataReceivedc C r' r r( r$ r r r r# 4 r) zSOCKSv4Incoming.writeN)r* r+ r, r r r& r# r r r r r- ) s r- c @ sp e Zd ZdZdefdd�Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z ddd�Z dd� Zdd� ZdS ) �SOCKSv4a� An implementation of the SOCKSv4 protocol. @type logging: L{str} or L{None} @ivar logging: If not L{None}, the name of the logfile to which connection information will be written. @type reactor: object providing L{twisted.internet.interfaces.IReactorTCP} @ivar reactor: The reactor used to create connections. @type buf: L{str} @ivar buf: Part of a SOCKSv4 connection request. @type otherConn: C{SOCKSv4Incoming}, C{SOCKSv4Outgoing} or L{None} @ivar otherConn: Until the connection has been established, C{otherConn} is L{None}. After that, it is the proxy-to-destination protocol instance along which the client's connection is being forwarded. Nc C � || _ || _d S r )�loggingr )r r0 r r r r r M � zSOCKSv4.__init__c C s d| _ d | _d S )N� )�bufr )r r r r r Q r1 zSOCKSv4.connectionMadec C s2 | j r | j �|� dS | j| | _| j}d| jdd� v r�| jdd� | jdd� }| _t�d|dd� �\}}}| j�dd�\}| _|dd� dkr�|dd� dkr�d| jvr^|| _dS | j�dd�\}| _| j�|�} | �| j ||||� | � | fd d �� dS t � |dd� �}| � |||||� dS dS ) z� Called whenever data is received. @type data: L{bytes} @param data: Part or all of a SOCKSv4 packet. N� � �!BBH� � � s c S � |� d�S �N�[ �r ��resultr r r r �<lambda>p � z&SOCKSv4.dataReceived.<locals>.<lambda>) r r# r3 �struct�unpack�splitr �resolve� addCallback�_dataReceived2� addErrback�socket� inet_ntoa) r r% �completeBuffer�head�version�coder �user�server�dr r r r& U s* �zSOCKSv4.dataReceivedc C s� |dks J d| ��| � ||||�s| �d� dS |dkr/| �||t| �}|�| fdd�� n |dkrE| �d t| |�}|�| fd d�� ntd |� ���| j d ksZJ d t | j � ��dS )a4 The second half of the SOCKS connection setup. For a SOCKSv4 packet this is after the server address has been extracted from the header. For a SOCKSv4a packet this is after the host name has been resolved. @type server: L{str} @param server: The IP address of the destination, represented as a dotted quad. @type user: L{str} @param user: The username associated with the connection. @type version: L{int} @param version: The SOCKS protocol version number. @type code: L{int} @param code: The command code. 1 means establish a TCP/IP stream connection, and 2 means establish a TCP/IP port binding. @type port: L{int} @param port: The port number associated with the connection. r7 zBad version code: %sr< Nr8 c S r: r; r= r> r r r r@ � rA z(SOCKSv4._dataReceived2.<locals>.<lambda>� r c S s |� dd| d | d �S )Nr r r8 r= )�xr r r r r@ � s zBad Connect Code: r2 z hmm, still stuff in buffer... %s) � authorizer � connectClassr rH � listenClass�SOCKSv4IncomingFactoryrF � RuntimeErrorr3 �repr)r rP rO rM rN r rQ r r r rG w s zSOCKSv4._dataReceived2c C s | j r | j j�� d S d S r )r r r r r r r r � s �zSOCKSv4.connectionLostc C s t �d||||f � dS )Nz0code %s connection to %s:%s (user %s) authorizedr8 )r �msg)r rN rP r rO r r r rT � s ��zSOCKSv4.authorizec G s t jt|g|�R � �||�S r )r � ClientCreatorr � connectTCP)r r r �klass�argsr r r rU � s zSOCKSv4.connectClassc G s& t �|||� �}t�|�� dd � �S )Nr8 )r � listenTCPr �succeed�getHost)r r r] r^ �servr r r rV � s zSOCKSv4.listenClassr �0.0.0.0c C s< | j �t�d|||�t�|� � |dkr | j �� d S d S )Nr6 r )r r# rB �packrI � inet_atonr )r �replyrM r r r r r r � s ��zSOCKSv4.makeReplyc C s | � | |� | j�|� d S r )r r r# r$ r r r r# � s z SOCKSv4.writec C s | j sd S | j�� }| jj�� }t| j d�}|�dt�� |j|j || kr&dp'd|j|j f � |rz|d d� |dd � }}|�t � t dd� |�d�d � |�dt |� d d � |D ]}t t|��d krm|�d � q]|�|� q]|�d � |s1|�d � |�� d S ) N�az%s %s:%d %s %s:%d �<�>� c S s dt | � S )Nz%02X)�ord)rS r r r r@ � s z SOCKSv4.log.<locals>.<lambda>� � �.� )r0 r r r �openr# �time�ctimer r �string�join�map�lenrY �close)r �protor% r � their_peer�f�p�cr r r r � s8 ��� � z SOCKSv4.log)r r rc )r* r+ r, �__doc__r r r r& rG r rT rU rV r r# r r r r r r. 9 s "% r. c @ � e Zd ZdZdd� Zdd� ZdS )�SOCKSv4Factoryz` A factory for a SOCKSv4 proxy. Constructor accepts one argument, a log file name. c C r r )r0 )r r r r r r � r zSOCKSv4Factory.__init__c C s t | jt�S r )r. r0 r �r �addrr r r � buildProtocol� s z SOCKSv4Factory.buildProtocolN�r* r+ r, r} r r� r r r r r � s r c @ r~ )rW zJ A utility class for building protocols for incoming connections. c C r/ r )r r )r r r r r r r � r1 z SOCKSv4IncomingFactory.__init__c C sR |d | j krd| _ | j�dd� t| j�S | j dkr d S | j�dd� d| _ d S )Nr � r r< )r r r r- r� r r r r� � s z$SOCKSv4IncomingFactory.buildProtocolNr� r r r r rW � s rW )r} rI rs rB rq �twisted.internetr r r �twisted.pythonr �Protocolr r- r. �Factoryr rW r r r r �<module> s PK Mb�Z�-�j j - protocols/__pycache__/postfix.cpython-310.pycnu �[��� o �b1 � @ s� d Z ddlZddlmZ ddlmZmZ ddl m Z m Z ddl m Z mZ ddlmZ dd � Zd d � ZG d d � d e jej�ZG dd� dee j�ZG dd� de j�ZdS )z1 Postfix mail transport agent related protocols. � N)�UserDict)�quote�unquote)�defer�protocol)�basic�policies)�logc C s t | �}t|t�r|�d�}|S �N�ascii)�_quote� isinstance�str�encode��s�quoted� r �;/usr/lib/python3/dist-packages/twisted/protocols/postfix.pyr s r c C s& t | t�r | �d�} t| �}|�d�S r )r �bytes�decode�_unquoter r r r r r s r c @ sR e Zd ZdZdZdZdd� Zddd�Zd d � Zd d � Z d d� Z dd� Z dd� Z dS )�PostfixTCPMapServera Postfix mail transport agent TCP map protocol implementation. Receive requests for data matching given key via lineReceived, asks it's factory for the data with self.factory.get(key), and returns the data to the requester. None means no entry found. You can use postfix's postmap to test the map service:: /usr/sbin/postmap -q KEY tcp:localhost:4242 iX � c C s | � | j� d S �N)� setTimeout�timeout)�selfr r r �connectionMade3 s z"PostfixTCPMapServer.connectionMade� c C s | � t|��d�d | � dS )z8 Send an SMTP-like code with a message. r � N)�sendLiner r )r �code�messager r r �sendCode6 s z PostfixTCPMapServer.sendCodec C s� | � � z |�d d�\}}W n ty |}d }Y nw z t| d|�d� �}W n ty8 | �dd� Y d S w z||� W d S tya tt � � d �� d�}| �dd| d | � Y d S w )N� �do_r � s unknown commands Command s failed: ) � resetTimeout�split� ValueError�getattrr �AttributeErrorr$ � BaseExceptionr �sys�exc_infor )r �line�request�params�f�excInfor r r � lineReceived< s$ � � �z PostfixTCPMapServer.lineReceivedc C sH |d u r | � dd� d S t�| jj|�}|�| j| j� |�t j � d S )Nr' s! Command 'get' takes 1 parameters.) r$ r � maybeDeferred�factory�get� addCallbacks�_cbGot�_cbNot� addErrbackr �err)r �key�dr r r �do_getN s zPostfixTCPMapServer.do_getc C s |� � �d�}| �d|� d S )Nr r' )�getErrorMessager r$ )r �fail�msgr r r r; V s zPostfixTCPMapServer._cbNotc C s* |d u r | � d� d S | � dt|�� d S )N�� �� )r$ r )r �valuer r r r: Z s zPostfixTCPMapServer._cbGotc C s^ |d u r | � dd� d S z |�d d�\}}W n ty& | � dd� Y d S w | � dd� d S )Nr' s! Command 'put' takes 2 parameters.r% rD s put is not implemented yet.)r$ r) r* )r � keyAndValuer> rF r r r �do_put` s �zPostfixTCPMapServer.do_putN)r ) �__name__� __module__� __qualname__�__doc__r � delimiterr r$ r5 r@ r; r: rH r r r r r " s r c @ s e Zd ZdZeZdS )� PostfixTCPMapDictServerFactory�B An in-memory dictionary factory for PostfixTCPMapServer. N)rI rJ rK rL r r r r r r rN l s rN c @ s& e Zd ZdZeZddd�Zdd� ZdS )�'PostfixTCPMapDeferringDictServerFactoryrO Nc C s" i | _ |d ur| j �|� d S d S r )�data�update)r rQ r r r �__init__{ s �z0PostfixTCPMapDeferringDictServerFactory.__init__c C s t �| j�|��S r )r �succeedrQ r8 )r r> r r r r8 � s z+PostfixTCPMapDeferringDictServerFactory.getr )rI rJ rK rL r r rS r8 r r r r rP t s rP )rL r. � collectionsr � urllib.parser r r r �twisted.internetr r �twisted.protocolsr r �twisted.pythonr � LineReceiver� TimeoutMixinr � ServerFactoryrN rP r r r r �<module> s JPK Mb�ZQ"�k�� �� ) protocols/__pycache__/ftp.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlZddlZddlZddlZz ddlZddlZW n e y1 d ZZY nw ddl m Z m Z ddl mZ ddlmZmZmZmZ ddlmZmZmZmZmZ ddlmZm Z ddl m Z m Z m Z d Z!d Z"d Z#d Z$d Z%dZ&dZ'dZ(dZ)dZ*dZ+dZ,dZ-dZ.dZ/dZ0dZ1dZ2dZ3d Z4d Z5d Z6d Z7d Z8d!Z9d"Z:d#Z;d$Z<d%Z=d&Z>d'Z?d(Z@d)ZAd*ZBd+ZCd,ZDd-ZEd.ZFd/ZGd0ZHd1ZId2ZJd3ZKd4ZLd5ZMd6ZNd7ZOd8ZPd9ZQd:ZRd;ZSd<ZTd=ZUd>ZVd?ZWd@ZXdAZYdBZZi e!dC�e"dD�e#dE�e$dF�e%dG�e&dH�e'dI�e(dJ�e)dK�e*dLdMg�e+dN�e,dO�e-dP�e.dQ�e0dR�e/dS�e1dT�i e2dU�e3dV�e4dW�e5dX�e6dY�e7dZ�e8d[�e9d\�e:d]�e;d^�e<d_�e=d`�e>da�e?db�e@dc�eAdd�eBde��i eCdf�eDdg�eEdh�eFdi�eGdj�eHdk�eIdl�eJdm�eKdn�eLdo�eMdp�eNdq�eOdr�ePds�eQdt�eRdu�eSdv��eTdweVdxeWdyeUdzeXd{eYd|eZd}i�Z[G d~d� de\�Z]d�d�� Z^d�d�� Z_e�`d��Zad�d�d��ZbG d�d�� d�e\�ZcG d�d�� d�ec�ZdG d�d�� d�ec�ZeG d�d�� d�ec�ZfG d�d�� d�ec�ZgG d�d�� d�ec�ZhG d�d�� d�ec�ZiG d�d�� d�ec�ZjG d�d�� d�ec�ZkG d�d�� d�ec�ZlG d�d�� d�ec�ZmG d�d�� d�e\�ZnG d�d�� d�e\�ZoG d�d�� d�ec�ZpG d�d�� d�ec�Zqd�d�� Zrg d��Zse ejt�G d�d�� d�eju��ZvG d�d�� d�ejw�ZxG d�d�� d��Zye ejt�G d�d�� d���ZzG d�d�� d�ej{�Z|G d�d�� d�ej{e j}�Z~G d�d�� d�e j�Z�G d�d�� d�e �Z�G d�d�� d�e �Z�G d�d�� d�e �Z�d�d�� Z�d�d�d��Z�e e��G d�d d�Z�e e��G d�dĄ dă�Z�G d�dƄ d�e��Z�e e��G d�dȄ dȃ�Z�e ej��G d�dʄ dʃ�Z�G d�d̄ d�e��Z�G d�d΄ d�e��Z�G d�dЄ d�en�Z�G d�d҄ d�en�Z�G d�dԄ d�en�Z�G d�dք d�en�Z�G d�d d�en�Z�G d�dڄ dڃZ�G d�d܄ d�eju�Z�G d�dބ d�ejt�Z�e e��G d�d� d�eju��Z�d�d� Z�d�d� Z�d�d� Z�G d�d� d�ej��Z�G d�d� d�ej{�Z�G d�d� d�ejw�Z�G d�d� d�e��Z�G d�d� d�ej{�Z�d�d� Z�dS )�z An FTP protocol implementation � N)� Interface� implementer)� copyright)�checkers� credentials�error�portal)�deferr � interfaces�protocol�reactor)�basic�policies)�failure�filepath�log�100�120�125�150z200.1z200.2z200.3�202z211.1z211.2�212�213�214�215z220.1z220.2z221.1z221.2�225z226.1z226.2�227�229z230.1z230.2�250z257.1z257.2z331.1z331.2�332�350z421.1z421.2�425�426�450�451�452�500�501z502.1z502.2�503�504z530.1z530.2�532z550.1z550.2z550.3z550.4z550.5z550.6z550.7�551�552�553z110 MARK yyyy-mmmmz 120 service ready in %s minutesz3125 Data connection already open, starting transferz4150 File status okay; about to open data connection.z200 Command OKz200 Type set to %s.z 200 PORT OKz5202 Command not implemented, superfluous at this sitez211 System status replyz 211-Features:z211 Endz212 %sz213 %sz 214 help: %sz215 UNIX Type: L8z220 %sz220 Service readyz&221 Service closing control connectionz 221 Goodbye.z1225 data connection open, no transfer in progressz226 Abort successfulz226 Transfer Complete.z 227 Entering Passive Mode (%s).z,229 Entering Extended Passive Mode (|||%s|).z230 User logged in, proceedz2230 Anonymous login ok, access restrictions apply.z&250 Requested File Action Completed OKz257 "%s"z257 "%s" createdz 331 Password required for %s.z8331 Guest login ok, type your email address as password.z332 Need account for login.z6350 Requested file action pending further information.z6421 Service not available, closing control connection.z9421 Too many users right now, try again in a few minutes.z 425 Can't open data connection.z.426 Transfer aborted. Data connection closed.z/450 Requested action aborted. File unavailable.z8451 Requested action aborted. Local error in processing.z3452 Requested action aborted. Insufficient storage.z500 Syntax error: %sz#501 syntax error in argument(s) %s.z 502 Command '%s' not implementedz 502 Option '%s' not implemented.z&503 Incorrect sequence of commands: %sz'504 Not implemented for parameter '%s'.z$530 Please login with USER and PASS.z!530 Sorry, Authentication failed.z%532 Need an account for storing filesz"550 %s: No such file or directory.z550 %s: Permission denied.z:550 Anonymous users are forbidden to change the filesystemz%550 Cannot rmd, %s is not a directoryz550 %s: File existsz550 %s: is a directoryz"550 Requested action not taken: %sz551 Page type unknownzC552 Requested file action aborted, exceeded file storage allocationz5553 Requested action not taken, file name not allowedc @ s e Zd ZdZdS )� InvalidPathzL Internal exception used to signify an error during parsing a path. N)�__name__� __module__� __qualname__�__doc__� r3 r3 �7/usr/lib/python3/dist-packages/twisted/protocols/ftp.pyr. � s r. c C s� |� d�rg }n| dd� }|�d�D ]-}|dks |dkr q|dkr.|r)|�� qt| |��d|v s6d|v r;t| |��|�|� q|S )zn Normalize a path, as represented by a list of strings each representing one segment of the path. �/N�.� �..� )� startswith�split�popr. �append)�cwd�path�segs�sr3 r3 r4 � toSegments� s rB c C s� | t jkr t�t|��S | t jks| t jkr t�t|��S | t jkr)t�t |��S | t j kr5t�t |��S | t j krAt�t |��S t�� S )z? Map C{OSError} and C{IOError} to standard FTP errors. )�errno�ENOENTr �fail�FileNotFoundError�EACCES�EPERM�PermissionDeniedError�ENOTDIR�IsNotADirectoryError�EEXIST�FileExistsError�EISDIR�IsADirectoryError)�er? r3 r3 r4 �errnoToFailure� s rQ �TESTc C s8 | sdS | d }t �|�}t�d|d�}||krdS dS )a� Helper for checking if a FTPShell `segments` contains a wildcard Unix expression. Only filename globbing is supported. This means that wildcards can only be presents in the last element of `segments`. @type segments: C{list} @param segments: List of path elements as used by the FTP server protocol. @rtype: Boolean @return: True if `segments` contains a globbing expression. F���rR � T)�fnmatch� translate�_testTranslation�replace)�segments� globCandidate�globTranslations�nonGlobTranslationsr3 r3 r4 �_isGlobbingExpression� s r] c @ � e Zd ZdZdd� Zdd� ZdS )� FTPCmdErrorz- Generic exception for FTP commands. c G s t j| g|�R � || _d S �N)� Exception�__init__� errorMessage)�self�msgr3 r3 r4 rb s zFTPCmdError.__init__c C s t | j | j S )zA Generate a FTP response message for this error. )�RESPONSE� errorCoderc �rd r3 r3 r4 �response s zFTPCmdError.responseN)r/ r0 r1 r2 rb ri r3 r3 r3 r4 r_ s r_ c @ � e Zd ZdZeZdS )rF zH Raised when trying to access a non existent file or directory. N)r/ r0 r1 r2 �FILE_NOT_FOUNDrg r3 r3 r3 r4 rF � rF c @ rj )�AnonUserDeniedErrorz[ Raised when an anonymous user issues a command that will alter the filesystem N)r/ r0 r1 r2 �ANON_USER_DENIEDrg r3 r3 r3 r4 rm " � rm c @ rj )rI z[ Raised when access is attempted to a resource to which access is not allowed. N)r/ r0 r1 r2 �PERMISSION_DENIEDrg r3 r3 r3 r4 rI + ro rI c @ rj )rK zE Raised when RMD is called on a path that isn't a directory. N)r/ r0 r1 r2 � IS_NOT_A_DIRrg r3 r3 r3 r4 rK 4 rl rK c @ rj )rM zA Raised when attempted to override an existing resource. N)r/ r0 r1 r2 � FILE_EXISTSrg r3 r3 r3 r4 rM < rl rM c @ rj )rO zC Raised when DELE is called on a path that is a directory. N)r/ r0 r1 r2 �IS_A_DIRrg r3 r3 r3 r4 rO D rl rO c @ rj )�CmdSyntaxErrorz0 Raised when a command syntax is wrong. N)r/ r0 r1 r2 � SYNTAX_ERRrg r3 r3 r3 r4 rt L rl rt c @ rj )�CmdArgSyntaxErrorz^ Raised when a command is called with wrong value or a wrong number of arguments. N)r/ r0 r1 r2 �SYNTAX_ERR_IN_ARGSrg r3 r3 r3 r4 rv T ro rv c @ rj )�CmdNotImplementedErrorzF Raised when an unimplemented command is given to the server. N)r/ r0 r1 r2 �CMD_NOT_IMPLMNTDrg r3 r3 r3 r4 rx ] rl rx c @ rj )� CmdNotImplementedForArgErrorze Raised when the handling of a parameter for a command is not implemented by the server. N)r/ r0 r1 r2 �CMD_NOT_IMPLMNTD_FOR_PARAMrg r3 r3 r3 r4 rz e ro rz c @ � e Zd ZdS )�FTPErrorN�r/ r0 r1 r3 r3 r3 r4 r} n � r} c @ r| )�PortConnectionErrorNr~ r3 r3 r3 r4 r� r r r� c @ rj )�BadCmdSequenceErrorzS Raised when a client sends a series of commands in an illogical sequence. N)r/ r0 r1 r2 � BAD_CMD_SEQrg r3 r3 r3 r4 r� v rl r� c @ rj )�AuthorizationErrorz2 Raised when client authentication fails. N)r/ r0 r1 r2 � AUTH_FAILURErg r3 r3 r3 r4 r� ~ rl r� c G s t jdt|� dd� d S )NzdebugDeferred(): %sT��debug)r re �str)rd �_r3 r3 r4 � debugDeferred� s r� ) N�Jan�Feb�Mar�Apr�May�Jun�Jul�Aug�Sep�Oct�Nov�Decc @ s� e Zd ZdZdZdZdZdZdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� ZdS )"�DTPFN�latin-1c C s d| _ | jj�d � g | _d S �NT)� isConnected�factory�deferred�callback�_bufferrh r3 r3 r4 �connectionMade� s zDTP.connectionMadec C s$ d| _ | jd ur| j�d � d S d S �NF)r� � _onConnLostr� �rd �reasonr3 r3 r4 �connectionLost� s �zDTP.connectionLostc C s | j �|d � dS )zv Send a line to data channel. @param line: The line to be sent. @type line: L{bytes} s N�� transport�write�rd �liner3 r3 r4 �sendLine� s z DTP.sendLinec C sZ dd� } d} | |r dp d|� � ||dd� |dd� || t�|��d� �| j�} | | S ) a Helper method to format one entry's info into a text entry like: 'drwxrwxrwx 0 user group 0 Jan 01 1970 filename.txt' @param name: C{bytes} name of the entry (file or directory or link) @param size: C{int} size of the entry @param directory: evals to C{bool} - whether the entry is a directory @param permissions: L{twisted.python.filepath.Permissions} object representing that entry's permissions @param hardlinks: C{int} number of hardlinks @param modified: C{float} - entry's last modified time in seconds since the epoch @param owner: C{str} username of the owner @param group: C{str} group name of the owner @return: C{str} in the requisite format c S sB t �� }t| j | j| j| j| jd�}|j| jkr d| S d| S )N)�month�day�year�hour�minutez %(month)s %(day)02d %(year)5dz+%(month)s %(day)02d %(hour)02d:%(minute)02d)�time�gmtime�_months�tm_mon�tm_mday�tm_year�tm_hour�tm_min)�mtime�now�infor3 r3 r4 � formatDate� s � z.DTP._formatOneListResponse.<locals>.formatDatezY%(directory)s%(permissions)s%(hardlinks)4d %(owner)-9s %(group)-9s %(size)15d %(date)12s �d�-N� )� directory� permissions� hardlinks�owner�group�size�date)� shorthandr� r� �encode� _encoding) rd �namer� r� r� r� �modifiedr� r� r� �formatre r3 r3 r4 �_formatOneListResponse� s � �� � zDTP._formatOneListResponsec C s | � | j|g|�R � � d S r` )r� r� )rd r� ri r3 r3 r4 �sendListResponse� s zDTP.sendListResponsec C s | j �||�S r` �r� �registerProducer�rd �producer� streamingr3 r3 r4 r� � � zDTP.registerProducerc C s | j �� | j �� d S r` )r� �unregisterProducer�loseConnectionrh r3 r3 r4 r� � s zDTP.unregisterProducerc C s | j r | j�|�S td��)Nz Crap damn crap damn crap damn)r� r� r� ra �rd �datar3 r3 r4 r� � s z DTP.writec C s2 z | j �|� W d S ty | j�� Y d S w r` )�_consr� � BaseExceptionr� �errback�rd �bytesr3 r3 r4 � _conswrite s �zDTP._conswritec C s( | j d ur | �|� d S | j�|� d S r` )r� r� r� r= r� r3 r3 r4 � dataReceived s zDTP.dataReceivedc C s | j �� d | _ | `|S r` )r� r� r� �rd �ignoredr3 r3 r4 �_unregConsumer s zDTP._unregConsumerc C s| | j d u sJ �|| _ | j �| d� | jD ]}| �|� qd | _| jr1t�� | _}|�| j � |S | j � � d | _ t� d �S r� ) r� r� r� r� r� r �Deferredr� �addBothr� r� �succeed)rd �cons�chunkr� r3 r3 r4 �registerConsumer s zDTP.registerConsumerc C � | j �� d S r` )r� �resumeProducingrh r3 r3 r4 r� # r� zDTP.resumeProducingc C r� r` )r� �pauseProducingrh r3 r3 r4 r� & r� zDTP.pauseProducingc C r� r` )r� � stopProducingrh r3 r3 r4 r� ) r� zDTP.stopProducing)r/ r0 r1 r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r3 r3 r3 r4 r� � s* 6 r� c @ sd e Zd ZdZe� Ze� Ze� ZeZdZ ddd�Z dd� Z dd � Z d d � Z d d � Zdd� Zdd� ZdS )� DTPFactorya Client factory for I{data transfer process} protocols. @ivar peerCheck: perform checks to make sure the ftp-pi's peer is the same as the dtp's @ivar pi: a reference to this factory's protocol interpreter @ivar _state: Indicates the current state of the DTPFactory. Initially, this is L{_IN_PROGRESS}. If the connection fails or times out, it is L{_FAILED}. If the connection succeeds before the timeout, it is L{_FINISHED}. @cvar _IN_PROGRESS: Token to signal that connection is active. @type _IN_PROGRESS: L{object}. @cvar _FAILED: Token to signal that connection has failed. @type _FAILED: L{object}. @cvar _FINISHED: Token to signal that connection was successfully closed. @type _FINISHED: L{object}. FNc C s: || _ || _t�� | _d| _|du rddlm} || _dS )z� Constructor @param pi: this factory's protocol interpreter @param peerHost: if peerCheck is True, this is the tuple that the generated instance will use to perform security checks Nr �r ) �pi�peerHostr r� r� � delayedCall�twisted.internetr �_reactor)rd r� r� r r3 r3 r4 rb N s zDTPFactory.__init__c C sN t jddd� | j| jurd S | j| _| �� t� }| |_| j|_|| j_ |S )N�DTPFactory.buildProtocolTr� ) r re �_state� _IN_PROGRESS� _FINISHED� cancelTimeoutr� r� r� � dtpInstance�rd �addr�pr3 r3 r4 � buildProtocol_ s r� c C s t jddd� | �� d S )NzdtpFactory.stopFactoryTr� )r re r� rh r3 r3 r4 � stopFactorym s zDTPFactory.stopFactoryc C sF t �d� | j| jur d S | j| _| j}d | _|�tt� d��� d S )Nz$timed out waiting for DTP connectionzDTPFactory timeout) r re r� r� �_FAILEDr� r� r� r � TimeoutError)rd r� r3 r3 r4 �timeoutFactoryq s zDTPFactory.timeoutFactoryc C s8 | j d ur| j �� rtjddd� | j �� d S d S d S )Nzcancelling DTP timeoutTr� )r� �activer re �cancelrh r3 r3 r4 r� { s �zDTPFactory.cancelTimeoutc C s$ t �d| � | j�|| j�| _d S )Nz'DTPFactory.setTimeout set to %s seconds)r re r� � callLaterr� r� )rd �secondsr3 r3 r4 � setTimeout� s zDTPFactory.setTimeoutc C s6 | j | jurd S | j| _ | j}d | _|�t|�� d S r` )r� r� r� r� r� r� )rd � connectorr� r� r3 r3 r4 �clientConnectionFailed� s z!DTPFactory.clientConnectionFailed)NN)r/ r0 r1 r2 �objectr� r� r� r� � peerCheckrb r� r� r� r� r r r3 r3 r3 r4 r� - s r� c @ s e Zd Zdd� Zdd� ZdS )�ASCIIConsumerWrapperc C sP || _ |j| _|j| _tjdksttj�dksJ d��tjdkr&|j| _d S d S )N� rT z6Unsupported platform (yea right like this even exists))r� r� r� �os�linesep�lenr� )rd r� r3 r3 r4 rb � s � �z ASCIIConsumerWrapper.__init__c C s | j �|�tjd��S )Nr )r� r� rX r r r� r3 r3 r4 r� � s zASCIIConsumerWrapper.writeN)r/ r0 r1 rb r� r3 r3 r3 r4 r � s r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � FileConsumerz� A consumer for FTP input that writes data to a file. @ivar fObj: a file object opened for writing, used to write data received. @type fObj: C{file} c C � || _ d S r` )�fObj�rd r r3 r3 r4 rb � � zFileConsumer.__init__c C s || _ |sJ �d S r` )r� r� r3 r3 r4 r� � � z FileConsumer.registerProducerc C s d | _ | j�� d S r` )r� r �closerh r3 r3 r4 r� � s z FileConsumer.unregisterProducerc C � | j �|� d S r` )r r� r� r3 r3 r4 r� � � zFileConsumer.writeN)r/ r0 r1 r2 rb r� r� r� r3 r3 r3 r4 r � s r c @ � e Zd ZdZdZdd� ZdS )�FTPOverflowProtocolz:FTP mini-protocol for when there are too many connections.r� c C s$ | � tt �| j�� | j�� d S r` )r� rf �TOO_MANY_CONNECTIONSr� r� r� r� rh r3 r3 r4 r� � s z"FTPOverflowProtocol.connectionMadeN)r/ r0 r1 r2 r� r� r3 r3 r3 r4 r � s r c s� e Zd ZdZdZed�\ZZZZ dZ dZ dZ dZ dZdZdZddgZg d �Zed d �ZejZd Zd d� Z� fdd�Zdd� Zdd� Zdd� Z dd� Z dd� Z dd � Z d d � Z d d � Z!d!d"� Z"d#d$� Z#d%d&� Z$d\d(d)�Z%d*d+� Z&d,d-� Z'd.d/� Z(d0d1� Z)d2d3� Z*d4d5� Z+d6d7� Z,d8d9� Z-d:d;� Z.d<d=� Z/d>d?� Z0d@dA� Z1dBdC� Z2dDdE� Z3dFdG� Z4dHdI� Z5dJdK� Z6dLdM� Z7dNdO� Z8dPdQ� Z9dRdS� Z:dTdU� Z;dVdW� Z<dXdY� Z=dZd[� Z>� Z?S )]�FTPa; Protocol Interpreter for the File Transfer Protocol @ivar state: The current server state. One of L{UNAUTH}, L{INAUTH}, L{AUTHED}, L{RENAMING}. @ivar shell: The connected avatar @ivar binary: The transfer mode. If false, ASCII. @ivar dtpFactory: Generates a single DTP for this session @ivar dtpPort: Port returned from listenTCP @ivar listenFactory: A callable with the signature of L{twisted.internet.interfaces.IReactorTCP.listenTCP} which will be used to create Ports for passive connections (mainly for testing). @ivar passivePortRange: iterator used as source of passive port numbers. @type passivePortRange: C{iterator} @cvar UNAUTH: Command channel is not yet authenticated. @type UNAUTH: L{int} @cvar INAUTH: Command channel is in the process of being authenticated. @type INAUTH: L{int} @cvar AUTHED: Command channel was successfully authenticated. @type AUTHED: L{int} @cvar RENAMING: Command channel is between the renaming command sequence. @type RENAMING: L{int} F� � NT�FEAT�QUIT)r �MDTM�PASV�SIZEzTYPE A;Ir rT r� c G s t | | }| �|� d S r` )rf r� )rd �key�argsre r3 r3 r4 �reply� s z FTP.replyc s& t |t�r |�| j�}t� �|� dS )za (Private) Encodes and sends a line @param line: L{bytes} or L{unicode} N)� isinstancer� r� r� �superr� r� �� __class__r3 r4 r� � s z FTP.sendLinec C s( | j | _| �| j� | �t| jj� d S r` )�UNAUTH�stater �timeOutr$ � WELCOME_MSGr� �welcomeMessagerh r3 r3 r4 r� s zFTP.connectionMadec C sJ | j r| �� | �d � t| jd�r | jjd ur | j�� d | _d | _d S )N�logout)� dtpFactory� cleanupDTPr �hasattr�shellr. r� r� r3 r3 r4 r� s zFTP.connectionLostc C r� r` �r� r� rh r3 r3 r4 �timeoutConnection r� zFTP.timeoutConnectionc s� �� � ��� ttkr|��j�}� �fdd�}�fdd�}�fdd�}|�d�}|dkr>|d |� � ||d d � f}n|� d }tj�j � g|�R � }|� ||� |� t j � d d lm} |�d |j|� d S ) Nc sx � � t�r��� j�� � d S � � t�r*t� fdd�dD ��r*��t�� d�� d S t � d� t � � � ��t d� d S )Nc 3 s � | ] }|� j jd v V qdS )r N)�valuer# )�.0re ��errr3 r4 � <genexpr># s � � �z:FTP.lineReceived.<locals>.processFailed.<locals>.<genexpr>)z takes exactlyz required positional argumentz requires an argument.zUnexpected FTP errorzinternal server error) �checkr_ r� r5 ri � TypeError�anyr$ ru r re r8 �REQ_ACTN_NOT_TAKENr7 ��cmdrd r7 r4 � processFailed s � z'FTP.lineReceived.<locals>.processFailedc s2 t | t�r � j| � d S | d ur� �| � d S d S r` )r% �tupler$ ��resultrh r3 r4 �processSucceeded- s �z*FTP.lineReceived.<locals>.processSucceededc s � j s � �� d S d S r` )� disconnectedr� �r� rh r3 r4 �allDone3 s �z!FTP.lineReceived.<locals>.allDone� rS rT r3 r r� )� resetTimeoutr� r� r� �decoder� �findr � maybeDeferred�processCommand� addCallbacks� addErrbackr r8 r� r r r� ) rd r� r@ rD rG � spaceIndexr# r� r r3 r> r4 � lineReceived s$ zFTP.lineReceivedc s� � �fdd�}|� � }|�jv r||�S �j�jkr-|dkr#�j� � S |dkr+tdfS tS �j�jkr@|dkr<�j� � S tdfS �j�j krJ||�S �j�j kr]|dkrY�j � � S tdfS d S ) Nc s. t �d| d �}|d ur|� � S t�t| ��S )N�ftp_)�getattrr rE rx )�command�method��paramsrd r3 r4 �call_ftp_commandJ s z,FTP.processCommand.<locals>.call_ftp_command�USER�PASSzUSER required before PASSzPASS required after USER�RNTOzRNTO required after RNFR) �upper�PUBLIC_COMMANDSr* r) �ftp_USERr� � NOT_LOGGED_IN�INAUTH�ftp_PASS�AUTHED�RENAMING�ftp_RNTO)rd r? rW rX r3 rV r4 rM I s* �zFTP.processCommandc C sL | j D ]}z | �||�}W | S tjy Y qw t�d|d| j � ���)ze Return a port for passive access, using C{self.passivePortRange} attribute. r7 zNo port available in range )�passivePortRange� listenFactoryr �CannotListenError)rd r� �portn�dtpPortr3 r3 r4 � getDTPPortl s ���zFTP.getDTPPortc C sB |s t �td��S || _| j| _| jjr | j| jjkr t S t |fS )zc First part of login. Get the username the peer wants to authenticate as. zUSER requires an argument) r rE rt �_userr` r* r� �allowAnonymous� userAnonymous�GUEST_NAME_OK_NEED_EMAIL�USR_NAME_OK_NEED_PASS)rd �usernamer3 r3 r4 r^ | s z FTP.ftp_USERc st �j jr�j�j jkrt�� }t� n t��j|�}t� �`� �fdd�}�fdd�}�j � |dt �}|� ||� |S )zf Second part of login. Get the password the peer wants to authenticate with. c s8 | \}}}|t u s J d��|�_|�_g �_�j�_� S )NzThe realm is busted, jerk.)� IFTPShellr2 r. �workingDirectoryrb r* )rC � interface�avatarr. �r$ rd r3 r4 �_cbLogin� s z FTP.ftp_PASS.<locals>._cbLoginc s | � tjtj� � j� _t�r` )�trap� cred_error�UnauthorizedLogin�UnhandledCredentialsr) r* r� �r rh r3 r4 �_ebLogin� s z FTP.ftp_PASS.<locals>._ebLoginN) r� rl rk rm r � Anonymous�GUEST_LOGGED_IN_PROCEED�UsernamePassword�USR_LOGGED_IN_PROCEEDr �loginrq rN )rd �password�credsrv r| r� r3 ru r4 ra � s z FTP.ftp_PASSc C sv | j dur | �� t| d�| _ | j �| j� | �| j �| _| j�� j }| j�� j }| � t t ||�� | j j�dd� �S )a� Request for a passive connection from the rfc:: This command requests the server-DTP to "listen" on a data port (which is not its default data port) and to wait for a connection rather than initiate one upon receipt of a transfer command. The response to this command includes the host and port address this server is listening on. N)r� c S � d S r` r3 ��ignr3 r3 r4 �<lambda>� � z FTP.ftp_PASV.<locals>.<lambda>)r/ r0 r� r � dtpTimeoutrj ri r� �getHost�host�portr$ �ENTERING_PASV_MODE�encodeHostPortr� � addCallback)rd r� r� r3 r3 r4 �ftp_PASV� s z FTP.ftp_PASVc C s� t tt|�d���}dt |d d� � }|d d> |d B }| jd ur'| �� t| | j�� j d�| _| j� | j � t � ||| j�| _dd� }d d � }| jj�||�S ) N�,z %d.%d.%d.%dr r� � )r� r� c S � t S r` )�ENTERING_PORT_MODErF r3 r3 r4 � connected� � z FTP.ftp_PORT.<locals>.connectedc S s | � t� tS r` )rw r� �CANT_OPEN_DATA_CNXr7 r3 r3 r4 � connFailed� s z FTP.ftp_PORT.<locals>.connFailed)rA �map�intr; r/ r0 r� r� �getPeerr� r r� r � connectTCPri r� rN )rd �addressr� �ipr� r� r� r3 r3 r4 �ftp_PORT� s z FTP.ftp_PORTc C s t |t�r |�d�S |S )a� Encode C{name} to be sent over the wire. This encodes L{unicode} objects as UTF-8 and leaves L{bytes} as-is. As described by U{RFC 3659 section 2.2<https://tools.ietf.org/html/rfc3659#section-2.2>}:: Various FTP commands take pathnames as arguments, or return pathnames in responses. When the MLST command is supported, as indicated in the response to the FEAT command, pathnames are to be transferred in one of the following two formats. pathname = utf-8-name / raw utf-8-name = <a UTF-8 encoded Unicode string> raw = <any string that is not a valid UTF-8 encoding> Which format is used is at the option of the user-PI or server-PI sending the pathname. @param name: Name to be encoded. @type name: L{bytes} or L{unicode} @return: Wire format of C{name}. @rtype: L{bytes} zutf-8)r% r� r� )rd r� r3 r3 r4 � _encodeName� s zFTP._encodeNamer7 c s� � j du s � j jst�td��S |�� dv rd}� fdd�}zt� j|�}W n ty6 t�t |�� Y S w � j � |d�}|� |� |S )a� This command causes a list to be sent from the server to the passive DTP. If the pathname specifies a directory or other group of files, the server should transfer a list of files in the specified directory. If the pathname specifies a file then the server should send current information on the file. A null argument implies the user's current working or default directory. N�"must send PORT or PASV before RETR)z-az-lz-laz-alr7 c sB � � t� | D ]\}}� �|�}� j�||� q� jj�� tfS r` )r$ � DATA_CNX_ALREADY_OPEN_START_XFRr� r� r� r� r� �TXFR_COMPLETE_OK)�resultsr� �attrsrh r3 r4 � gotListing s z FTP.ftp_LIST.<locals>.gotListing)r� r� r� r� r� r� r� ) r� r� r rE r� �lowerrB rr r. rF r2 �listr� )rd r? r� rY r� r3 rh r4 �ftp_LIST� s �� z FTP.ftp_LISTc s� � j du s � j jst�td��S zt� j|�}W n ty( t�t|�� Y S w � fdd�}� fdd�}t |�r>|� � }nd}� j � |�}|� ||� |�|� |S )a\ This command causes a directory listing to be sent from the server to the client. The pathname should specify a directory or other system-specific file group descriptor. An empty path implies the current working directory. If the path is non-existent, send nothing. If the path is to a file, send only the file name. @type path: C{str} @param path: The path for which a directory listing should be returned. @rtype: L{Deferred} @return: a L{Deferred} which will be fired when the listing request is finished. Nr� c sT � � t� | D ]\}}|r|r t�||�r � �|�}� j�|� q� jj�� tfS )a� Send, line by line, each matching file in the directory listing, and then close the connection. @type results: A C{list} of C{tuple}. The first element of each C{tuple} is a C{str} and the second element is a C{list}. @param results: The names of the files in the directory. @param glob: A shell-style glob through which to filter results (see U{http://docs.python.org/2/library/fnmatch.html}), or L{None} for no filtering. @type glob: L{str} or L{None} @return: A C{tuple} containing the status code for a successful transfer. @rtype: C{tuple} ) r$ r� rU r� r� r� r� r� r� )r� �globr� r� rh r3 r4 �cbListC s � z FTP.ftp_NLST.<locals>.cbListc s � j j�� tfS )a RFC 959 specifies that an NLST request may only return directory listings. Thus, send nothing and just close the connection. @type results: L{Failure} @param results: The L{Failure} wrapping a L{FileNotFoundError} that occurred while trying to list the contents of a nonexistent directory. @returns: A C{tuple} containing the status code for a successful transfer. @rtype: C{tuple} )r� r� r� r� )r� rh r3 r4 �listErr] s z FTP.ftp_NLST.<locals>.listErr)r� r� r rE r� rB rr r. rF r] r< r2 r� r� rO )rd r? rY r� r� r� r� r3 rh r4 �ftp_NLST+ s � z FTP.ftp_NLSTc sR zt �j|�� W n ty t�t|�� Y S w � �fdd�}�j�� ��|�S )Nc s � �_ tfS r` )rr �REQ_FILE_ACTN_COMPLETED_OKrB �rY rd r3 r4 � accessGranted� s z"FTP.ftp_CWD.<locals>.accessGranted) rB rr r. r rE rF r2 �accessr� )rd r? r� r3 r� r4 �ftp_CWD{ s �z FTP.ftp_CWDc C � | � d�S )Nr8 )r� rh r3 r3 r4 �ftp_CDUP� r z FTP.ftp_CDUPc C s t dd�| j� fS )Nr5 )� PWD_REPLY�joinrr rh r3 r3 r4 �ftp_PWD� s z FTP.ftp_PWDc s� �j du r td��zt�j|��W n ty! t�t|�� Y S w ��d� �fdd�}�j s6t �j ��n�j �dd� � dd� �� ���fd d �}�fd d �}�j � ��}|� ||� |�|� |S ) a� This command causes the content of a file to be sent over the data transfer channel. If the path is to a folder, an error will be raised. @type path: C{str} @param path: The path to the file which should be transferred over the data transfer channel. @rtype: L{Deferred} @return: a L{Deferred} which will be fired when the transfer is done. Nz!PORT or PASV required before RETRc � � � � jj� | S r` �r r� r+ rB rh r3 r4 � enableTimeout� � z#FTP.ftp_RETR.<locals>.enableTimeoutc S � t fS r` �r� rB r3 r3 r4 �cbSent� � z FTP.ftp_RETR.<locals>.cbSentc S s( t �d� t �| � | �t�r| S tfS )Nz7Unexpected error attempting to transmit file to client:)r re r8 r: r_ �CNX_CLOSED_TXFR_ABORTEDr7 r3 r3 r4 �ebSent� s z FTP.ftp_RETR.<locals>.ebSentc s8 �j jr ��t� n��t� | ���}|�� �� |S r` )r� r� r$ r� � FILE_STATUS_OK_OPEN_DATA_CNX�sendrN ��filer� )r� r� r� rd r3 r4 �cbOpened� s z FTP.ftp_RETR.<locals>.cbOpenedc sL | � ttt�st�d� t�| � | � t�r | jj d� � �fS t d� � �fS )Nz:Unexpected error attempting to open file for transmission:r5 ) r: rI rF rO r re r8 r_ r5 rg r� rk r7 ��newsegsr3 r4 �ebOpened� s � z FTP.ftp_RETR.<locals>.ebOpened)r� r� rB rr r. r rE rF r �binaryr r2 �openForReadingrN r� �rd r? r� r� r� r� r3 )r� r� r� r� rd r4 �ftp_RETR� s( � z FTP.ftp_RETRc s� �j du r td��zt�j|��W n ty! t�t|�� Y S w ��d� �fdd�}� ��fdd�}�fdd�}�fd d �� d d � �d d� ��j � ��}|� ||� |� |� |S )a� STORE (STOR) This command causes the server-DTP to accept the data transferred via the data connection and to store the data as a file at the server site. If the file specified in the pathname exists at the server site, then its contents shall be replaced by the data being transferred. A new file is created at the server site if the file specified in the pathname does not already exist. Nz!PORT or PASV required before STORc r� r` r� rB rh r3 r4 r� � r� z#FTP.ftp_STOR.<locals>.enableTimeoutc s4 � � � }|��� |�� fdd�� |���� |S )zx File was open for reading. Launch the data transfer channel via the file consumer. c s � � � S r` )r rF �r� r3 r4 r� � � z0FTP.ftp_STOR.<locals>.cbOpened.<locals>.<lambda>)�receiver� rN r� )� cbConsumerr� r� r� r4 r� � s z FTP.ftp_STOR.<locals>.cbOpenedc s8 t | jt�r| jjd�� �fS t�| d� td�� �fS )z� Called when failed to open the file for reading. For known errors, return the FTP error code. For all other, return a file not found error. r5 z-Unexpected error received while opening file:)r% r5 r_ rg r� r r8 rk r7 r� r3 r4 r� s z FTP.ftp_STOR.<locals>.ebOpenedc s> � j st| �} � j�| �}� jjr� �t� |S � �t� |S )z� Called after the file was opended for reading. Prepare the data transfer channel and send the response to the command channel. )r� r r� r� r� r$ r� r� )r� r� rh r3 r4 r� s �z FTP.ftp_STOR.<locals>.cbConsumerc S r� )zK Called from data transport when transfer is done. r� rB r3 r3 r4 r� ! s z FTP.ftp_STOR.<locals>.cbSentc S s t �| d� | �t�r | S tfS )zk Called from data transport when there are errors during the transfer. z*Unexpected error received during transfer:)r r8 r: r_ r� r7 r3 r3 r4 r� ' s z FTP.ftp_STOR.<locals>.ebSent) r� r� rB rr r. r rE rF r r2 �openForWritingrN r� r� r3 )r� r� r� r� rd r4 �ftp_STOR� s$ � z FTP.ftp_STORc C �N zt | j|�}W n ty t�t|�� Y S w dd� }| j�|d��|�S )ab File SIZE The FTP command, SIZE OF FILE (SIZE), is used to obtain the transfer size of a file from the server-FTP process. This is the exact number of octets (8 bit bytes) that would be transmitted over the data connection should that file be transmitted. This value will change depending on the current STRUcture, MODE, and TYPE of the data connection or of a data connection that would be created were one created now. Thus, the result of the SIZE command is dependent on the currently established STRU, MODE, and TYPE parameters. The SIZE command returns how many octets would be transferred if the file were to be transferred using the current transfer structure, mode, and type. This command is normally used in conjunction with the RESTART (REST) command when STORing a file to a remote server in STREAM mode, to determine the restart point. The server-PI might need to read the partially transferred file, do any appropriate conversion, and count the number of octets that would be generated when sending the file in order to correctly respond to this command. Estimates of the file transfer size MUST NOT be returned; only precise information is acceptable. http://tools.ietf.org/html/rfc3659 c S s | \}t t|�fS r` )� FILE_STATUSr� )rC r� r3 r3 r4 �cbStatW r z FTP.ftp_SIZE.<locals>.cbStat)r� � rB rr r. r rE rF r2 �statr� �rd r? r� r� r3 r3 r4 �ftp_SIZE8 s �z FTP.ftp_SIZEc C r� )a! File Modification Time (MDTM) The FTP command, MODIFICATION TIME (MDTM), can be used to determine when a file in the server NVFS was last modified. This command has existed in many FTP servers for many years, as an adjunct to the REST command for STREAM mode, thus is widely available. However, where supported, the "modify" fact that can be provided in the result from the new MLST command is recommended as a superior alternative. http://tools.ietf.org/html/rfc3659 c S s | \}t t�dt�|��fS )Nz %Y%m%d%H%M%S)r� r� �strftimer� )rC r� r3 r3 r4 r� o s z FTP.ftp_MDTM.<locals>.cbStat)r� r� r� r3 r3 r4 �ftp_MDTM] s �z FTP.ftp_MDTMc C sH |� � }|r!t| d|d d�}|dur ||dd� �S | �|�S tfS )a REPRESENTATION TYPE (TYPE) The argument specifies the representation type as described in the Section on Data Representation and Storage. Several types take a second parameter. The first parameter is denoted by a single Telnet character, as is the second Format parameter for ASCII and EBCDIC; the second parameter for local byte is a decimal integer to indicate Bytesize. The parameters are separated by a <SP> (Space, ASCII code 32). �type_r NrT )r\ rS � type_UNKNOWNru )rd �typer� �fr3 r3 r4 �ftp_TYPEu s z FTP.ftp_TYPEc C s0 |dks|dkrd| _ td| fS t�t|��S )Nr7 �NF�A�r� � TYPE_SET_OKr rE rv �rd �coder3 r3 r4 �type_A� s z FTP.type_Ac C s$ |dkr d| _ tdfS t�t|��S )Nr7 T�Ir� r� r3 r3 r4 �type_I� s z FTP.type_Ic C s t �t|��S r` )r rE rz r� r3 r3 r4 r� � r� zFTP.type_UNKNOWNc C r� r` )� NAME_SYS_TYPErh r3 r3 r4 �ftp_SYST� r� z FTP.ftp_SYSTc C �$ |� � }|dkr tfS t�t|��S )N�F�r\ �CMD_OKr rE rz )rd � structurer� r3 r3 r4 �ftp_STRU� � z FTP.ftp_STRUc C r� )N�Sr� )rd �moder� r3 r3 r4 �ftp_MODE� r� z FTP.ftp_MODEc sL zt | j� �}W n ty t�t� �� Y S w | j�|��� fdd��S )Nc s t � fS r` )� MKD_REPLYr� �r? r3 r4 r� � r� z FTP.ftp_MKD.<locals>.<lambda>) rB rr r. r rE rF r2 � makeDirectoryr� �rd r? r� r3 r� r4 �ftp_MKD� s � �z FTP.ftp_MKDc C �H zt | j|�}W n ty t�t|�� Y S w | j�|��dd� �S )Nc S r� r` �r� r� r3 r3 r4 r� � � z FTP.ftp_RMD.<locals>.<lambda>) rB rr r. r rE rF r2 �removeDirectoryr� r� r3 r3 r4 �ftp_RMD� � � �z FTP.ftp_RMDc C r� )Nc S r� r` r� r� r3 r3 r4 r� � r� z FTP.ftp_DELE.<locals>.<lambda>) rB rr r. r rE rF r2 � removeFiler� r� r3 r3 r4 �ftp_DELE� r z FTP.ftp_DELEc C r� r` )r� rh r3 r3 r4 �ftp_NOOP� r� z FTP.ftp_NOOPc C s || _ | j| _tfS r` )� _fromNamerc r* �"REQ_FILE_ACTN_PENDING_FURTHER_INFO)rd �fromNamer3 r3 r4 �ftp_RNFR� s z FTP.ftp_RNFRc C sh | j }| ` | j| _zt| j|�}t| j|�}W n ty' t�t|�� Y S w | j � ||�� dd� �S )Nc S r� r` r� r� r3 r3 r4 r� � r� z FTP.ftp_RNTO.<locals>.<lambda>) r rb r* rB rr r. r rE rF r2 �renamer� )rd �toNamer �fromsegs�tosegsr3 r3 r4 rd � s ��z FTP.ftp_RNTOc C sB | � tt d � | jD ] }| � d| � q | � tt d � dS )zm Advertise the features supported by the server. http://tools.ietf.org/html/rfc2389 r rH rT N)r� rf �FEAT_OK�FEATURES)rd �featurer3 r3 r4 �ftp_FEAT� s z FTP.ftp_FEATc C s | � t|�S )zl Handle OPTS command. http://tools.ietf.org/html/draft-ietf-ftpext-utf-8-option-00 )r$ �OPTS_NOT_IMPLEMENTED)rd �optionr3 r3 r4 �ftp_OPTS� s z FTP.ftp_OPTSc C s | � t� | j�� d| _d S r� )r$ � GOODBYE_MSGr� r� rE rh r3 r3 r4 �ftp_QUIT� s z FTP.ftp_QUITc C s� t jddd� t �| j� | jd}| _tj�|�r |�� ntj�|�r*|�� nJ d|f ��| j � � d| _ | j durCd| _ dS dS )z0 Call when DTP connection exits r0 Tr� NFz@dtpPort should be an IListeningPort or IConnector, instead is %r) r re ri r �IListeningPort� providedBy� stopListening� IConnector� disconnectr/ r� r� )rd ri r3 r3 r4 r0 � s" �� �zFTP.cleanupDTP)r7 )@r/ r0 r1 r2 rE �ranger) r` rb rc r� r r2 r/ ri r� r� r] r re r � listenTCPrf r� r$ r� r� r� r4 rQ rM rj r^ ra r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r rd r r r r0 � __classcell__r3 r3 r' r4 r � sn /#! -P J`% r c @ sV e Zd ZdZeZeZdZdZ dZ de j � d�Z edd�Zdd d �Zd d � Zdd� Zd S )� FTPFactorya A factory for producing ftp protocol instances @ivar timeOut: the protocol interpreter's idle timeout time in seconds, default is 600 seconds. @ivar passivePortRange: value forwarded to C{protocol.passivePortRange}. @type passivePortRange: C{iterator} T� anonymousiX zTwisted z FTP Serverr rT Nc C s || _ || _g | _d S r` )r rm � instances)rd r rm r3 r3 r4 rb ! s zFTPFactory.__init__c C s8 t j�| |�}|d ur| j|j_| j|j_| j|j_|S r` )r � LimitTotalConnectionsFactoryr� r �wrappedProtocolr+ re r� r3 r3 r4 r� & s zFTPFactory.buildProtocolc C s dd� | j D � tj�| � d S )Nc S s g | ] }|j d ur|�d ��qS r` )r+ r �r6 r� r3 r3 r4 � <listcomp>1 s z*FTPFactory.stopFactory.<locals>.<listcomp>)r r r! r� rh r3 r3 r4 r� . s zFTPFactory.stopFactory)Nr )r/ r0 r1 r2 r r r �overflowProtocolrl rm r+ r �versionr- r re rb r� r� r3 r3 r3 r4 r s r c @ s\ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zdd d�Z ddd�Z dd� Z dd� Z dS )rq z� An abstraction of the shell commands used by the FTP protocol for a given user account. All path names must be absolute. c C � dS )a Create a directory. @param path: The path, as a list of segments, to create @type path: C{list} of C{unicode} @return: A Deferred which fires when the directory has been created, or which fails if the directory cannot be created. Nr3 r� r3 r3 r4 r� @ r� zIFTPShell.makeDirectoryc C r' )a Remove a directory. @param path: The path, as a list of segments, to remove @type path: C{list} of C{unicode} @return: A Deferred which fires when the directory has been removed, or which fails if the directory cannot be removed. Nr3 r� r3 r3 r4 r� K r� zIFTPShell.removeDirectoryc C r' )a Remove a file. @param path: The path, as a list of segments, to remove @type path: C{list} of C{unicode} @return: A Deferred which fires when the file has been removed, or which fails if the file cannot be removed. Nr3 r� r3 r3 r4 r V r� zIFTPShell.removeFilec C r' )ax Rename a file or directory. @param fromPath: The current name of the path. @type fromPath: C{list} of C{unicode} @param toPath: The desired new name of the path. @type toPath: C{list} of C{unicode} @return: A Deferred which fires when the path has been renamed, or which fails if the path cannot be renamed. Nr3 )�fromPath�toPathr3 r3 r4 r a r� zIFTPShell.renamec C r' )a Determine whether access to the given path is allowed. @param path: The path, as a list of segments @return: A Deferred which fires with None if access is allowed or which fails with a specific exception type if access is denied. Nr3 r� r3 r3 r4 r� o r� zIFTPShell.accessr3 c C r' )z� Retrieve information about the given path. This is like list, except it will never return results about child paths. Nr3 �r? �keysr3 r3 r4 r� z r� zIFTPShell.statc C r' )ae Retrieve information about the given path. If the path represents a non-directory, the result list should have only one entry with information about that non-directory. Otherwise, the result list should have an element for each child of the directory. @param path: The path, as a list of segments, to list @type path: C{list} of C{unicode} or C{bytes} @param keys: A tuple of keys desired in the resulting dictionaries. @return: A Deferred which fires with a list of (name, list), where the name is the name of the entry as a unicode string or bytes and each list contains values corresponding to the requested keys. The following are possible elements of keys, and the values which should be returned for them: - C{'size'}: size in bytes, as an integer (this is kinda required) - C{'directory'}: boolean indicating the type of this entry - C{'permissions'}: a bitvector (see os.stat(foo).st_mode) - C{'hardlinks'}: Number of hard links to this entry - C{'modified'}: number of seconds since the epoch since entry was modified - C{'owner'}: string indicating the user owner of this entry - C{'group'}: string indicating the group owner of this entry Nr3 r* r3 r3 r4 r� � r� zIFTPShell.listc C r' )z� @param path: The path, as a list of segments, to open @type path: C{list} of C{unicode} @rtype: C{Deferred} which will fire with L{IReadFile} Nr3 r� r3 r3 r4 r� � r� zIFTPShell.openForReadingc C r' )z� @param path: The path, as a list of segments, to open @type path: C{list} of C{unicode} @rtype: C{Deferred} which will fire with L{IWriteFile} Nr3 r� r3 r3 r4 r� � r� zIFTPShell.openForWritingN�r3 ) r/ r0 r1 r2 r� r� r r r� r� r� r� r� r3 r3 r3 r4 rq 8 s % rq c @ � e Zd ZdZdd� ZdS )� IReadFilez0 A file out of which bytes may be read. c C r' )a Produce the contents of the given path to the given consumer. This method may only be invoked once on each provider. @type consumer: C{IConsumer} @return: A Deferred which fires when the file has been consumed completely. Nr3 )�consumerr3 r3 r4 r� � r� zIReadFile.sendN)r/ r0 r1 r2 r� r3 r3 r3 r4 r. � s r. c @ r^ )� IWriteFilez1 A file into which bytes may be written. c C r' )z� Create a consumer which will write to this file. This method may only be invoked once on each provider. @rtype: C{Deferred} of C{IConsumer} Nr3 r3 r3 r3 r4 r� � r� zIWriteFile.receivec C r' )ae Perform any post-write work that needs to be done. This method may only be invoked once on each provider, and will always be invoked after receive(). @rtype: C{Deferred} of anything: the value is ignored. The FTP client will not see their upload request complete until this Deferred has been fired. Nr3 r3 r3 r3 r4 r � r� zIWriteFile.closeN)r/ r0 r1 r2 r� r r3 r3 r3 r4 r0 � s r0 c C sD g }t �| �}|�|j� t�� D ]}|j|jv r |�|j� q|S )z_ Return the primary and supplementary groups for the given UID. @type uid: C{int} ) �pwd�getpwuidr= �pw_gid�grp�getgrall�pw_name�gr_mem�gr_gid)�uidrC �pwent�grentr3 r3 r4 � _getgroups� s �r< �rc C s� |dkrt j}t j}t j}tj}n|dkr"t j}t j}t j}tj }nt d|�d���d}tj � |�r`| dkr9d}n't� |�} || j @ rK| | jkrKd}n|| j @ rY|t| �v rYd}n|| j @ r`d}|rut�||�sud}t�d| t�� f � |S ) a� checks to see if uid has proper permissions to access path with mode @type uid: C{int} @param uid: numeric user id @type gid: C{int} @param gid: numeric group id @type spath: C{str} @param spath: the path on the server to test @type mode: C{str} @param mode: 'r' or 'w' (read or write) @rtype: C{bool} @return: True if the given credentials have the specified form of access to the given path r= �wz Invalid mode z: must specify 'r' or 'w'Fr TzUFilesystem grants permission to UID %d but it is inaccessible to me running as UID %d)r� �S_IRUSR�S_IRGRP�S_IROTHr �R_OK�S_IWUSR�S_IWGRP�S_IWOTH�W_OK� ValueErrorr? �exists�st_mode�st_uidr< r� r re �getuid) r9 �gid�spathr� �usrr4 �oth�amoder� rA r3 r3 r4 �_testPermissions� s> ��rQ c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z d,dd�Zd,dd�Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+S )-�FTPAnonymousShellz� An anonymous implementation of IFTPShell @type filesystemRoot: L{twisted.python.filepath.FilePath} @ivar filesystemRoot: The path which is considered the root of this shell. c C r r` )�filesystemRoot)rd rS r3 r3 r4 rb 6 r zFTPAnonymousShell.__init__c C � | j �|�S r` )rS � descendant�rd r? r3 r3 r4 �_path9 � zFTPAnonymousShell._pathc C � t �t� �S r` �r rE rm rV r3 r3 r4 r� < rX z FTPAnonymousShell.makeDirectoryc C rY r` rZ rV r3 r3 r4 r� ? rX z!FTPAnonymousShell.removeDirectoryc C rY r` rZ rV r3 r3 r4 r B rX z FTPAnonymousShell.removeFilec C rY r` rZ )rd r( r) r3 r3 r4 r E rX zFTPAnonymousShell.renamec C s | � |�}t�t� �S r` )rW r rE rm rV r3 r3 r4 r� H s zFTPAnonymousShell.receivec C � | � |�}|�� rt�t|��S z|�d�}W n$ ty/ } z t|j|�W Y d}~S d}~w t y; t�� Y S w t� t |��S )a� Open C{path} for reading. @param path: The path, as a list of segments, to open. @type path: C{list} of C{unicode} @return: A L{Deferred} is returned that will fire with an object implementing L{IReadFile} if the file is successfully opened. If C{path} is a directory, or if an exception is raised while trying to open the file, the L{Deferred} will fire with an error. r= N) rW �isdirr rE rO �open�OSErrorrQ rC r� r� � _FileReader)rd r? r� r� rP r3 r3 r4 r� L s � �z FTPAnonymousShell.openForReadingc C s t �td��S )za Reject write attempts by anonymous users with L{PermissionDeniedError}. zSTOR not allowed)r rE rI rV r3 r3 r4 r� e s z FTPAnonymousShell.openForWritingc C s� | � |�}|�� st�t|��S z|�� W n$ ty. } z t|j|�W Y d }~S d }~w t y: t�� Y S w t� d �S r` ) rW rH r rE rF �listdirr^ rQ rC r� r� �rd r? r� rP r3 r3 r4 r� l s � � zFTPAnonymousShell.accessr3 c C s� | � |�}|�� r;z| �||�}W n$ ty) } z t|j|�W Y d }~S d }~w ty5 t�� Y S w t� |�S | � ||�� dd� �S )Nc S s | d d S )Nr rT r3 )�resr3 r3 r4 r� � s z(FTPAnonymousShell.stat.<locals>.<lambda>) rW r\ � _statNoder^ rQ rC r� r rE r� r� r� )rd r? r+ r� � statResultrP r3 r3 r4 r� | s � � zFTPAnonymousShell.statc s | � |�� � �� r� �� }� fdd�|D �}n� �� r*tjj� �| j�� g}� g}nt � t |��S g }t ||�D ]C\}� g }|� ||f� |r{z |�| �� |�� W q8 tyl } zt|j|�W Y d}~ S d}~w tyz t � � Y S w q8t �|�S )a Return the list of files at given C{path}, adding C{keys} stat informations if specified. @param path: the directory or file to check. @type path: C{str} @param keys: the list of desired metadata @type keys: C{list} of C{str} c s g | ]}� � |��qS r3 )�childr# ��filePathr3 r4 r$ � s z*FTPAnonymousShell.list.<locals>.<listcomp>N)rW r\ r` �isfiler r? r� � segmentsFromrS r rE rF �zipr= �extendrc r^ rQ rC r� r� ) rd r? r+ �entries� fileEntriesr� �fileName�entrP r3 rf r4 r� � s. � �� zFTPAnonymousShell.listc s � � � � �fdd�|D �S )z� Shortcut method to get stat info on a node. @param filePath: the node to stat. @type filePath: C{filepath.FilePath} @param keys: the stat keys to get. @type keys: C{iterable} c s g | ] }t �d | �� ��qS )�_stat_)rS )r6 �k�rg rd r3 r4 r$ � s z/FTPAnonymousShell._statNode.<locals>.<listcomp>)�restat)rd rg r+ r3 rr r4 rc � s zFTPAnonymousShell._statNodec C � |� � S )z� Get the filepath's size as an int @param fp: L{twisted.python.filepath.FilePath} @return: C{int} representing the size )�getsize�rd �fpr3 r3 r4 � _stat_size� � z FTPAnonymousShell._stat_sizec C rt )z� Get the filepath's permissions object @param fp: L{twisted.python.filepath.FilePath} @return: L{twisted.python.filepath.Permissions} of C{fp} )�getPermissionsrv r3 r3 r4 �_stat_permissions� ry z#FTPAnonymousShell._stat_permissionsc C s z|� � W S ty Y dS w )a� Get the number of hardlinks for the filepath - if the number of hardlinks is not yet implemented (say in Windows), just return 0 since stat-ing a file in Windows seems to return C{st_nlink=0}. (Reference: U{http://stackoverflow.com/questions/5275731/os-stat-on-windows}) @param fp: L{twisted.python.filepath.FilePath} @return: C{int} representing the number of hardlinks r )�getNumberOfHardLinks�NotImplementedErrorrv r3 r3 r4 �_stat_hardlinks� s �z!FTPAnonymousShell._stat_hardlinksc C rt )z� Get the filepath's last modified date @param fp: L{twisted.python.filepath.FilePath} @return: C{int} as seconds since the epoch )�getModificationTimerv r3 r3 r4 �_stat_modified� ry z FTPAnonymousShell._stat_modifiedc C �\ z|� � }W n ty Y dS w tdur*zt�|�d W S ty) Y t|�S w t|�S )a� Get the filepath's owner's username. If this is not implemented (say in Windows) return the string "0" since stat-ing a file in Windows seems to return C{st_uid=0}. (Reference: U{http://stackoverflow.com/questions/5275731/os-stat-on-windows}) @param fp: L{twisted.python.filepath.FilePath} @return: C{str} representing the owner's username �0Nr )� getUserIDr} r1 r2 �KeyErrorr� )rd rw �userIDr3 r3 r4 � _stat_owner� � � �z FTPAnonymousShell._stat_ownerc C r� )a� Get the filepath's owner's group. If this is not implemented (say in Windows) return the string "0" since stat-ing a file in Windows seems to return C{st_gid=0}. (Reference: U{http://stackoverflow.com/questions/5275731/os-stat-on-windows}) @param fp: L{twisted.python.filepath.FilePath} @return: C{str} representing the owner's group r� Nr )� getGroupIDr} r4 �getgrgidr� r� )rd rw �groupIDr3 r3 r4 � _stat_group� r� z FTPAnonymousShell._stat_groupc C rt )z� Get whether the filepath is a directory @param fp: L{twisted.python.filepath.FilePath} @return: C{bool} )r\ rv r3 r3 r4 �_stat_directory ry z!FTPAnonymousShell._stat_directoryNr, )r/ r0 r1 r2 rb rW r� r� r r r� r� r� r� r� r� rc rx r{ r~ r� r� r� r� r3 r3 r3 r4 rR , s, # rR c @ �$ e Zd Zdd� Zdd� Zdd� ZdS )r_ c C � || _ d| _d S r� )r �_sendr r3 r3 r4 rb " � z_FileReader.__init__c C s d| _ | j�� |S r� )r� r r )rd � passthroughr3 r3 r4 �_close& s z_FileReader._closec C s6 | j rJ d��d| _ t�� �| j|�}|�| j� |S )Nz0Can only call IReadFile.send *once* per instanceT)r� r � FileSender�beginFileTransferr r� r� )rd r/ r� r3 r3 r4 r� + s z_FileReader.sendN)r/ r0 r1 rb r� r� r3 r3 r3 r4 r_ s r_ c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �FTPShellz: An authenticated implementation of L{IFTPShell}. c C sj | � |�}z|�� W n$ ty# } z t|j|�W Y d }~S d }~w ty/ t�� Y S w t�d �S r` ) rW �makedirsr^ rQ rC r� r rE r� ra r3 r3 r4 r� 8 s � � zFTPShell.makeDirectoryc C s� | � |�}|�� rt�t|��S zt�|j� W n$ ty0 } z t |j |�W Y d }~S d }~w t y< t�� Y S w t� d �S r` ) rW rh r rE rK r �rmdirr? r^ rQ rC r� r� ra r3 r3 r4 r� C s � � zFTPShell.removeDirectoryc C s� | � |�}|�� rt�t|��S z|�� W n$ ty. } z t|j|�W Y d }~S d }~w t y: t�� Y S w t� d �S r` ) rW r\ r rE rO �remover^ rQ rC r� r� ra r3 r3 r4 r S s � � zFTPShell.removeFilec C s| | � |�}| � |�}z t�|j|j� W n$ ty, } z t|j|�W Y d }~S d }~w ty8 t� � Y S w t� d �S r` ) rW r r r? r^ rQ rC r� r rE r� )rd r( r) rw �tprP r3 r3 r4 r c s � � zFTPShell.renamec C r[ )a� Open C{path} for writing. @param path: The path, as a list of segments, to open. @type path: C{list} of C{unicode} @return: A L{Deferred} is returned that will fire with an object implementing L{IWriteFile} if the file is successfully opened. If C{path} is a directory, or if an exception is raised while trying to open the file, the L{Deferred} will fire with an error. r> N) rW r\ r rE rO r] r^ rQ rC r� r� � _FileWriter)rd r? r� r rP r3 r3 r4 r� o s � �zFTPShell.openForWritingN) r/ r0 r1 r2 r� r� r r r� r3 r3 r3 r4 r� 3 s r� c @ r� )r� c C r� r� )r �_receiver r3 r3 r4 rb � r� z_FileWriter.__init__c C s$ | j rJ d��d| _ t�t| j��S )Nz4Can only call IWriteFile.receive *once* per instanceT)r� r r� r r rh r3 r3 r4 r� � s z_FileWriter.receivec C s t �d �S r` )r r� rh r3 r3 r4 r � r z_FileWriter.closeN)r/ r0 r1 rb r� r r3 r3 r3 r4 r� � s r� c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) � BaseFTPRealmz{ Base class for simple FTP realms which provides an easy hook for specifying the home directory for each user. c C s t �|�| _d S r` )r �FilePath� anonymousRoot)rd r� r3 r3 r4 rb � r zBaseFTPRealm.__init__c C s t | j�d���)a Return a L{FilePath} representing the home directory of the given avatar. Override this in a subclass. @param avatarId: A user identifier returned from a credentials checker. @type avatarId: C{str} @rtype: L{FilePath} z" did not override getHomeDirectory)r} r( �rd �avatarIdr3 r3 r4 �getHomeDirectory� s �z BaseFTPRealm.getHomeDirectoryc G sX |D ]%}|t u r'|tju rt| j�}nt| �|��}t |t|ddd� �f S qtd��)Nr. c S r� r` r3 r3 r3 r3 r4 r� � r� z,BaseFTPRealm.requestAvatar.<locals>.<lambda>z3Only IFTPShell interface is supported by this realm) rq r � ANONYMOUSrR r� r� r� rS r} )rd r� �mindr �ifacert r3 r3 r4 � requestAvatar� s �zBaseFTPRealm.requestAvatarN)r/ r0 r1 r2 rb r� r� r3 r3 r3 r4 r� � s r� c @ s" e Zd ZdZddd�Zdd� ZdS ) �FTPRealma" @type anonymousRoot: L{twisted.python.filepath.FilePath} @ivar anonymousRoot: Root of the filesystem to which anonymous users will be granted access. @type userHome: L{filepath.FilePath} @ivar userHome: Root of the filesystem containing user home directories. �/homec C s t �| |� t�|�| _d S r` )r� rb r r� �userHome)rd r� r� r3 r3 r4 rb � s zFTPRealm.__init__c C rT )z� Use C{avatarId} as a single path segment to construct a child of C{self.userHome} and return that child. )r� re r� r3 r3 r4 r� � � zFTPRealm.getHomeDirectoryN)r� )r/ r0 r1 r2 rb r� r3 r3 r3 r4 r� � s r� c @ r- )�SystemFTPRealmz� L{SystemFTPRealm} uses system user account information to decide what the home directory for a particular avatarId is. This works on POSIX but probably is not reliable on Windows. c C s, t j�d| �}|�d�rt�� �t�|�S )zx Return the system-defined home directory of the system user account with the name C{avatarId}. �~)r r? � expanduserr: rx ry r r� )rd r� r? r3 r3 r4 r� � s z SystemFTPRealm.getHomeDirectoryN)r/ r0 r1 r2 r� r3 r3 r3 r4 r� � s r� c @ r| )�ConnectionLostNr~ r3 r3 r3 r4 r� � r r� c @ r| )� CommandFailedNr~ r3 r3 r3 r4 r� � r r� c @ r| )� BadResponseNr~ r3 r3 r3 r4 r� � r r� c @ r| )�UnexpectedResponseNr~ r3 r3 r3 r4 r� r r� c @ r| )�UnexpectedDataNr~ r3 r3 r3 r4 r� r r� c @ s e Zd Zddd�Zdd� ZdS )� FTPCommandNr c C s& || _ t�� | _d| _|| _d | _d S )NrT )�textr r� r� �ready�public�transferDeferred)rd r� r� r3 r3 r4 rb s zFTPCommand.__init__c C s | j r | j�|� d S d S r` )r� r� r� )rd r r3 r3 r4 rE s �zFTPCommand.fail�Nr )r/ r0 r1 rb rE r3 r3 r3 r4 r� s r� c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �ProtocolWrapperc C s || _ || _d S r` )�originalr� )rd r� r� r3 r3 r4 rb r� zProtocolWrapper.__init__c C r r` )r� �makeConnection�rd r� r3 r3 r4 r� r z ProtocolWrapper.makeConnectionc C r r` )r� r� r� r3 r3 r4 r� r z ProtocolWrapper.dataReceivedc C s | j �|� | j�d � d S r` )r� r� r� r� r� r3 r3 r4 r� " s z ProtocolWrapper.connectionLostN)r/ r0 r1 rb r� r� r� r3 r3 r3 r4 r� s r� c @ r- )�IFinishableConsumerzA A Consumer for producers that finish. @since: 11.0 c C r' )z6 The producer has finished producing. Nr3 r3 r3 r3 r4 �finish/ r� zIFinishableConsumer.finishN)r/ r0 r1 r2 r� r3 r3 r3 r4 r� ( s r� c @ sL e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dS )�SenderProtocolc C s t �� | _t �� | _d S r` )r r� �connectedDeferredr� rh r3 r3 r4 rb 7 s zSenderProtocol.__init__c C s t d��)Nz<Received data from the server on a send-only data-connection)r� r� r3 r3 r4 r� ? s �zSenderProtocol.dataReceivedc C s t j�| |� | j�| � d S r` )r �Protocolr� r� r� r� r3 r3 r4 r� D s z SenderProtocol.makeConnectionc C s, |� tj�r| j�d� d S | j�|� d S )Nzconnection done)r: r �ConnectionDoner� r� r� r� r3 r3 r4 r� H s z SenderProtocol.connectionLostc C r r` r� r� r3 r3 r4 r� O r zSenderProtocol.writec C s | j �||� dS )zA Register the given producer with our transport. Nr� r� r3 r3 r4 r� R s z SenderProtocol.registerProducerc C s | j �� dS )z@ Unregister the previously registered producer. N)r� r� rh r3 r3 r4 r� X � z!SenderProtocol.unregisterProducerc C r� r` r3 rh r3 r3 r4 r� ^ r� zSenderProtocol.finishN) r/ r0 r1 rb r� r� r� r� r� r� r� r3 r3 r3 r4 r� 5 s r� c C s� t �dd| �}dd� |�d�D �}|D ]}|dk s |dkr#td| |��q|\}}}}}} |� d |� d |� d |� �} t|�d > t| � } | | fS ) ze Decode an FTP response specifying a host and port. @return: a 2-tuple of (host, port). z[^0-9, ]r7 c S s g | ]}t |�� ��qS r3 )r� �stripr# r3 r3 r4 r$ i � z"decodeHostPort.<locals>.<listcomp>r� r � z Out of ranger6 r� )�re�subr; rG r� ) r� �abcdef�parsed�x�a�b�cr� rP r� r� r� r3 r3 r4 �decodeHostPortb s �r� c C s, | � d�t|d? �t|d �g }d�|�S )Nr6 r� � r� )r; r� r� )r� r� �numbersr3 r3 r4 r� s s " r� c C s | � tj� | jjS r` )rw r � FirstErrorr5 � subFailurer{ r3 r3 r4 �_unwrapFirstErrorx s r� c @ r )�FTPDataPortFactoryz_ Factory for data connections that use the PORT command (i.e. "active" transfers) Fc C s | | j _| j�� | j S r` )r r� r� r� )rd r� r3 r3 r4 r� � s z FTPDataPortFactory.buildProtocolN)r/ r0 r1 r2 �noisyr� r3 r3 r3 r4 r� } s r� c @ sz e Zd ZdZdZdZdd� Zdd� Zdd � Zd d � Z d d � Z dd� Z dd� Z d dd�Z dd� Zdd� Zdd� Zdd � Zd S ) �FTPClientBasicz' Foundations of an FTP client. Fr� c C s< g | _ d | _t�� �| j�| _| j�| j� g | _ d| _ d S r� ) � actionQueue�greetingr r� r� � _cb_greeting� nextDeferredrO rE ri �_failedrh r3 r3 r4 rb � s zFTPClientBasic.__init__c C s | � |� dS )z8 Give an error to any queued deferreds. N��_fail�rd r r3 r3 r4 rE � r� zFTPClientBasic.failc C sn | j r|S d| _ | jr$z| j�t�td|��� W n tjy# Y nw | jD ] }|� t�td|��� q'|S )z/ Errback all queued deferreds. rT zFTP connection lost) r� r� r� r �Failurer� r �AlreadyCalledErrorr� rE )rd r � ftpCommandr3 r3 r4 r� � s �� �zFTPClientBasic._failc C r r` )r� )rd r� r3 r3 r4 r� � r zFTPClientBasic._cb_greetingc C s4 |du rdS t |t�r|�| j�}tj�| |� dS )z� Sends a line, unless line is None. @param line: Line to send @type line: L{bytes} or L{unicode} N)r% r� r� r� r � LineReceiverr� r� r3 r3 r4 r� � s zFTPClientBasic.sendLinec C s� | � � }|du r d| _dS |js#| j�d|� t�d| j� d| _dS |jdkr-| � |� | j r8t � d|j � |j | _| �|j� dS )zD (Private) Processes the next command in the queue. Nr g �?�PORTz<-- %s)�popCommandQueuer� r� r� �insertr r �sendNextCommandr� �generatePortCommandr� r re r� r� �rd r� r3 r3 r4 r� � s z FTPClientBasic.sendNextCommandc C sF | j �|� t| j �dkr | jdur | jdu r!| �� dS dS dS dS )a Add an FTPCommand object to the queue. If it's the only thing in the queue, and we are connected and we aren't waiting for a response of an earlier command, the command will be sent immediately. @param ftpCommand: an L{FTPCommand} rT N)r� r= r r� r� r� r� r3 r3 r4 � queueCommand� s �zFTPClientBasic.queueCommandrT c C s t ||�}| �|� |jS )au Queues a string to be issued as an FTP command @param command: string of an FTP command to queue @param public: a flag intended for internal use by FTPClient. Don't change it unless you know what you're doing. @return: a L{Deferred} that will be called when the response to the command has been received. )r� r� r� )rd rT r� r� r3 r3 r4 �queueStringCommand� s z!FTPClientBasic.queueStringCommandc C s | j r | j �d�S dS )zR Return the front element of the command queue, or None if empty. r N)r� r< rh r3 r3 r4 r� s z FTPClientBasic.popCommandQueuec s� g }�j d| dd�}|�|� |dur3td| dd�� ��� � |�� j� � �fdd�}|�|� |D ]}|��j� |�dd � � q5dS ) a Login: send the username, send the password. If the password is L{None}, the PASS command won't be sent. Also, if the response to the USER command has a response code of 230 (User logged in), then PASS won't be sent either. zUSER r �r� NzPASS c s | d � d�r �j�� � | S )Nr �230)r: r� r� )ri �� passwordCmdrd r3 r4 �cancelPasswordIfNotNeeded" s z<FTPClientBasic.queueLogin.<locals>.cancelPasswordIfNotNeededc S r� r` r3 �r� r3 r3 r4 r� / r� z+FTPClientBasic.queueLogin.<locals>.<lambda>)r� r= r� r� r� r� rO rE )rd rp r� � deferreds� userDeferredr� r� r3 r� r4 � queueLogin s �zFTPClientBasic.queueLoginc C s� t tkr |�| j�}| jrt�d| � | j�|� t � d|�}|s$dS |dd� }|d dkr2dS | j du rA| � t | j�� dS | j}g | _|d dv rT| j �|� n%|d dv rf| j �t�t|��� nt�d |� �� | j �t�t|��� | �� dS ) zM (Private) Parses the response messages from the FTP server. z--> %sz\d{3} Nr � �1)�2�3)�4�5z"Server sent invalid response code )r� r� rJ r� r� r re ri r= r� �matchr� rE r� r� r� r r� r� r� r� )rd r� � codeIsValidr� ri r3 r3 r4 rQ 1 s. zFTPClientBasic.lineReceivedc C s | � |� d S r` r� r� r3 r3 r4 r� a r� z FTPClientBasic.connectionLostN)rT )r/ r0 r1 r2 r� r� rb rE r� r� r� r� r� r� r� r� rQ r� r3 r3 r3 r4 r� � s $ 0r� c @ r� ) �_PassiveConnectionFactoryFc C r r` )� protoInstance)rd r� r3 r3 r4 rb h r z"_PassiveConnectionFactory.__init__c C s | | j _| j S r` )r� r� r� r3 r3 r4 r� k s z'_PassiveConnectionFactory.buildProtocolc C s t d|�}| jj�|� d S )NzConnection Failed)r} r� r� r� )rd r r� rP r3 r3 r4 r o s z0_PassiveConnectionFactory.clientConnectionFailedN)r/ r0 r1 r� rb r� r r3 r3 r3 r4 r� e s r� c @ s� e Zd ZdZejZ d1dd�Zdd� Zd d � Z d d � Z d d� Z dd� Z dd� Z dd� Zd2dd�ZeZd2dd�ZeZdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Z d.d/� Z d0S )3� FTPClientaI L{FTPClient} is a client implementation of the FTP protocol which exposes FTP commands as methods which return L{Deferred}s. Each command method returns a L{Deferred} which is called back when a successful response code (2xx or 3xx) is received from the server or which is error backed if an error response code (4xx or 5xx) is received from the server or if a protocol violation occurs. If an error response code is received, the L{Deferred} fires with a L{Failure} wrapping a L{CommandFailed} instance. The L{CommandFailed} instance is created with a list of the response lines received from the server. See U{RFC 959<http://www.ietf.org/rfc/rfc959.txt>} for error code definitions. Both active and passive transfers are supported. @ivar passive: See description in __init__. r �twisted@twistedmatrix.comrT c C s t �| � | �||� || _dS )ay Constructor. I will login as soon as I receive the welcome message from the server. @param username: FTP username @param password: FTP password @param passive: flag that controls if I use active or passive data connections. You can also change this after construction by assigning to C{self.passive}. N)r� rb r� �passive)rd rp r� r r3 r3 r4 rb � s zFTPClient.__init__c C s | j �� | �|� dS )zM Disconnect, and also give an error to any queued deferreds. N)r� r� r� r� r3 r3 r4 rE � s zFTPClient.failc C s$ t �|�}t|t�� �}| �||�S )a� Retrieves a file or listing generated by the given command, feeding it to the given protocol. @param commands: list of strings of FTP commands to execute then receive the results of (e.g. C{LIST}, C{RETR}) @param protocol: A L{Protocol} B{instance} e.g. an L{FTPFileListProtocol}, or something that can be adapted to one. Typically this will be an L{IConsumer} implementation. @return: L{Deferred}. )r � IProtocolr� r r� �_openDataConnection)rd �commandsr �wrapperr3 r3 r4 �receiveFromConnection� s z FTPClient.receiveFromConnectionc C s: t �| ||� | jddd�}|�| j� |�dd� � dS )zg Login: send the username, send the password, and set retrieval mode to binary zTYPE Ir r� c S r� r` r3 r� r3 r3 r4 r� � r� z&FTPClient.queueLogin.<locals>.<lambda>N)r� r� r� rO rE )rd rp r� r� r3 r3 r4 r� � s zFTPClient.queueLoginc C s t � }| �||�}|j|fS )aQ XXX @return: A tuple of two L{Deferred}s: - L{Deferred} L{IFinishableConsumer}. You must call the C{finish} method on the IFinishableConsumer when the file is completely transferred. - L{Deferred} list of control-connection responses. )r� r r� )rd r rA r= r3 r3 r4 �sendToConnection� s zFTPClient.sendToConnectionc sJ dd� |D �}t jdd� |D �ddd�}|�t� �jrZdg� � ��fdd�}td �}��|� |j�|���j � ||j�jg}t j|ddd�}|�t� � fd d �} |� | � n?td �} �j| _ �| _ | j�| j j � ��| � d d� | _dd� | _ |�| fdd�� || j| j g}t j|ddd�}|�t� |D ]} ��| � q�|S )z5 This method returns a DeferredList. c S s g | ]}t |d d��qS )rT r� )r� )r6 rT r3 r3 r4 r$ � r� z1FTPClient._openDataConnection.<locals>.<listcomp>c S s g | ]}|j �qS r3 )r� )r6 r? r3 r3 r4 r$ � s T)�fireOnOneErrback� consumeErrorsNc s6 t | d dd� �\}}t��}��|||�� d< dS )z5Connect to the port specified in the response to PASVrS r Nr )r� r� �connectFactory)ri r� r� r� ��_mutabler rd r3 r4 � doPassive� s z0FTPClient._openDataConnection.<locals>.doPassiver c S s |d o |d � � | S | S r� )r )r� �mr3 r3 r4 r � s �z,FTPClient._openDataConnection.<locals>.closer� c S � | S r` r3 rB r3 r3 r4 r� r� z/FTPClient._openDataConnection.<locals>.<lambda>c S r r` r3 )r r3 r3 r4 r� r� c S s |� | �p| S r` )rE )rP �pcr3 r3 r4 r� s )r � DeferredListrO r� r r� r� r� r� rE r� r� r r� r� ) rd r r �cmds� cmdsDeferredr �pasvCmdr� r� r �portCmdr? r3 r r4 r � s< � z FTPClient._openDataConnectionc C s\ t � }|j|_t�d|�}||_|fdd�}||_| j�� j}|�� j}dt ||� |_ dS )zG (Private) Generates the text of a given PORT command. r c S s |j r|�� | S r` )r� r� )r �listenerr3 r3 r4 � listenerFail. s z3FTPClient.generatePortCommand.<locals>.listenerFailzPORT N) r� r r r r� rE r� r� r� r� r� )rd r r� r r r� r� r3 r3 r4 r� s z FTPClient.generatePortCommandc C s |� dd�S )zK Returns a FTP escaped path (replace newlines with nulls). � r9 )rX rV r3 r3 r4 � escapePath: r� zFTPClient.escapePathr c C s4 d| � |� g}|r|�ddt|� � | �||�S )a� Retrieve a file from the given path This method issues the 'RETR' FTP command. The file is fed into the given Protocol instance. The data connection will be passive if self.passive is set. @param path: path to file that you wish to receive. @param protocol: a L{Protocol} instance. @param offset: offset to start downloading from @return: L{Deferred} zRETR r �REST )r r� r� r )rd r? r �offsetr r3 r3 r4 � retrieveFileA s zFTPClient.retrieveFilec C s2 d| � |� g}|r|�ddt|� � | �|�S )a� Store a file at the given path. This method issues the 'STOR' FTP command. @return: A tuple of two L{Deferred}s: - L{Deferred} L{IFinishableConsumer}. You must call the C{finish} method on the IFinishableConsumer when the file is completely transferred. - L{Deferred} list of control-connection responses. zSTOR r r )r r� r� r )rd r? r r r3 r3 r4 � storeFileW s zFTPClient.storeFilec sp �� d��|� �}�� d��|� �}g � t�� ���� fdd�� ��fdd�}|�� j|� |��� �S )a] Rename a file. This method issues the I{RNFR}/I{RNTO} command sequence to rename C{pathFrom} to C{pathTo}. @param pathFrom: the absolute path to the file to be renamed @type pathFrom: C{str} @param pathTo: the absolute path to rename the file to. @type pathTo: C{str} @return: A L{Deferred} which fires when the rename operation has succeeded or failed. If it succeeds, the L{Deferred} is called back with a two-tuple of lists. The first list contains the responses to the I{RNFR} command. The second list contains the responses to the I{RNTO} command. If either I{RNFR} or I{RNTO} fails, the L{Deferred} is errbacked with L{CommandFailed} or L{BadResponse}. @rtype: L{Deferred} @since: 8.2 zRNFR zRNTO c s � | fS r` r3 )� toResponse)� fromResponser3 r4 r� � r� z"FTPClient.rename.<locals>.<lambda>c s �� � � �| � d S r` )r� r� r{ )rC rd r3 r4 �ebFrom� s z FTPClient.rename.<locals>.ebFrom)r� r r r� r� rN rk � chainDeferred)rd �pathFrom�pathTo� renameFrom�renameTor r3 )r rC rd r4 r j s zFTPClient.renamec C �$ |du rd}| � d| �|� g|�S )a| Retrieve a file listing into the given protocol instance. This method issues the 'LIST' FTP command. @param path: path to get a file listing for. @param protocol: a L{Protocol} instance, probably a L{FTPFileListProtocol} instance. It can cope with most common file listing formats. @return: L{Deferred} Nr7 zLIST �r r �rd r? r r3 r3 r4 r� � s zFTPClient.listc C r& )a1 Retrieve a short file listing into the given protocol instance. This method issues the 'NLST' FTP command. NLST (should) return a list of filenames, one per line. @param path: path to get short file listing for. @param protocol: a L{Protocol} instance. Nr7 zNLST r' r( r3 r3 r4 �nlst� s zFTPClient.nlstc C � | � d| �|� �S )z� Issues the CWD (Change Working Directory) command. @return: a L{Deferred} that will be called when done. zCWD �r� r rV r3 r3 r4 r> � s z FTPClient.cwdc C r* )a@ Make a directory This method issues the MKD command. @param path: The path to the directory to create. @type path: C{str} @return: A L{Deferred} which fires when the server responds. If the directory is created, the L{Deferred} is called back with the server response. If the server response indicates the directory was not created, the L{Deferred} is errbacked with a L{Failure} wrapping L{CommandFailed} or L{BadResponse}. @rtype: L{Deferred} @since: 8.2 zMKD r+ rV r3 r3 r4 r� � � zFTPClient.makeDirectoryc C r* )a^ Delete a file on the server. L{removeFile} issues a I{DELE} command to the server to remove the indicated file. Note that this command cannot remove a directory. @param path: The path to the file to delete. May be relative to the current dir. @type path: C{str} @return: A L{Deferred} which fires when the server responds. On error, it is errbacked with either L{CommandFailed} or L{BadResponse}. On success, it is called back with a list of response lines. @rtype: L{Deferred} @since: 8.2 zDELE r+ rV r3 r3 r4 r � r, zFTPClient.removeFilec C r* )a` Delete a directory on the server. L{removeDirectory} issues a I{RMD} command to the server to remove the indicated directory. Described in RFC959. @param path: The path to the directory to delete. May be relative to the current working directory. @type path: C{str} @return: A L{Deferred} which fires when the server responds. On error, it is errbacked with either L{CommandFailed} or L{BadResponse}. On success, it is called back with a list of response lines. @rtype: L{Deferred} @since: 11.1 zRMD r+ rV r3 r3 r4 r� � r, zFTPClient.removeDirectoryc C r� )z Issues the CDUP (Change Directory UP) command. @return: a L{Deferred} that will be called when done. �CDUP�r� rh r3 r3 r4 �cdup� s zFTPClient.cdupc C r� )ah Issues the PWD (Print Working Directory) command. The L{getDirectory} does the same job but automatically parses the result. @return: a L{Deferred} that will be called when done. It is up to the caller to interpret the response, but the L{parsePWDResponse} method in this module should work. �PWDr. rh r3 r3 r4 r1 s z FTPClient.pwdc C s dd� }| � � �|�S )a Returns the current remote directory. @return: a L{Deferred} that will be called back with a C{str} giving the remote directory or which will errback with L{CommandFailed} if an error response is returned. c S sp zt | d �dd�d �dkrt�W n ttfy$ t�t| �� Y S w t| d �}|d u r6t�t| ��S |S )Nr rH rT i )r� r; rG � IndexErrorr r� r� �parsePWDResponse)rC r? r3 r3 r4 �cbParse s �� z'FTPClient.getDirectory.<locals>.cbParse)r1 r� )rd r3 r3 r3 r4 � getDirectory s zFTPClient.getDirectoryc C r� )z� Issues the I{QUIT} command. @return: A L{Deferred} that fires when the server acknowledges the I{QUIT} command. The transport should not be disconnected until this L{Deferred} fires. r r. rh r3 r3 r4 �quit* s zFTPClient.quitN)r r rT )r ) r/ r0 r1 r2 r r� r rb rE r r� r r r� r r �retrr �storr r� r) r> r� r r� r/ r1 r4 r5 r3 r3 r3 r4 r� t s6 � G# 0 r� c @ sJ e Zd ZdZe�d�ZdZdZdd� Z dd� Z d d � Z d d � Z d d� Z dS )�FTPFileListProtocola� Parser for standard FTP file listings This is the evil required to match:: -rw-r--r-- 1 root other 531 Jan 29 03:26 README If you need different evil for a wacky FTP server, you can override either C{fileLinePattern} or C{parseDirectoryLine()}. It populates the instance attribute self.files, which is a list containing dicts with the following keys (examples from the above line): - filetype: e.g. 'd' for directories, or '-' for an ordinary file - perms: e.g. 'rw-r--r--' - nlinks: e.g. 1 - owner: e.g. 'root' - group: e.g. 'other' - size: e.g. 531 - date: e.g. 'Jan 29 03:26' - filename: e.g. 'README' - linktarget: e.g. 'some/file' Note that the 'date' value will be formatted differently depending on the date. Check U{http://cr.yp.to/ftp.html} if you really want to try to parse it. It also matches the following:: -rw-r--r-- 1 root other 531 Jan 29 03:26 I HAVE\ SPACE - filename: e.g. 'I HAVE SPACE' -rw-r--r-- 1 root other 531 Jan 29 03:26 LINK -> TARGET - filename: e.g. 'LINK' - linktarget: e.g. 'TARGET' -rw-r--r-- 1 root other 531 Jan 29 03:26 N S -> L S - filename: e.g. 'N S' - linktarget: e.g. 'L S' @ivar files: list of dicts describing the files in this listing z�^(?P<filetype>.)(?P<perms>.{9})\s+(?P<nlinks>\d*)\s*(?P<owner>\S+)\s+(?P<group>\S+)\s+(?P<size>\d+)\s+(?P<date>...\s+\d+\s+[\d:]+)\s+(?P<filename>.{1,}?)( -> (?P<linktarget>[^\r]*))?\r?$� r� c C s g | _ d S r` )�filesrh r3 r3 r4 rb h r z FTPFileListProtocol.__init__c C sB t tkr |�| j�}| �|�}|d u r| �|� d S | �|� d S r` )r� r� rJ r� �parseDirectoryLine� unknownLine�addFile)rd r� r� r3 r3 r4 rQ k s z FTPFileListProtocol.lineReceivedc C st | j �|�}|du r dS |�� }|d �dd�|d< t|d �|d< t|d �|d< |d r8|d �dd�|d< |S )z� Return a dictionary of fields, or None if line cannot be parsed. @param line: line of text expected to contain a directory entry @type line: str @return: dict N�filenamez\ rH �nlinksr� � linktarget)�fileLinePatternr� � groupdictrX r� )rd r� r� r� r3 r3 r4 r; t s z&FTPFileListProtocol.parseDirectoryLinec C s | j �|� dS )a� Append file information dictionary to the list of known files. Subclasses can override or extend this method to handle file information differently without affecting the parsing of data from the server. @param info: dictionary containing the parsed representation of the file information @type info: dict N)r: r= )rd r� r3 r3 r4 r= � s zFTPFileListProtocol.addFilec C r' )a Deal with received lines which could not be parsed as file information. Subclasses can override this to perform any special processing needed. @param line: unparsable line as received @type line: str Nr3 r� r3 r3 r4 r< � s z FTPFileListProtocol.unknownLineN)r/ r0 r1 r2 r� �compilerA � delimiterr� rb rQ r; r= r< r3 r3 r3 r4 r8 5 s )� r8 c C s t �d| �}|r|�� d S dS )z� Returns the path from a response to a PWD command. Responses typically look like:: 257 "/home/andrew" is current directory. For this example, I will return C{'/home/andrew'}. If I can't find the path, I return L{None}. z"(.*)"r N)r� �search�groups)ri r� r3 r3 r4 r2 � s r2 r` )r= )�r2 rC rU r r� r� r� r4 r1 � ImportError�zope.interfacer r �twistedr � twisted.credr r r rx r r� r r r r �twisted.protocolsr r �twisted.pythonr r r �RESTART_MARKER_REPLY�SERVICE_READY_IN_N_MINUTESr� r� r� r� r� � CMD_NOT_IMPLMNTD_SUPERFLUOUS�SYS_STATUS_OR_HELP_REPLYr � DIR_STATUSr� �HELP_MSGr� �SVC_READY_FOR_NEW_USERr, �SVC_CLOSING_CTRL_CNXr � DATA_CNX_OPEN_NO_XFR_IN_PROGRESS�CLOSING_DATA_CNXr� r� �ENTERING_EPSV_MODEr� r~ r� r� r� ro rn �NEED_ACCT_FOR_LOGINr � SVC_NOT_AVAIL_CLOSING_CTRL_CNXr r� r� �REQ_ACTN_ABRTD_FILE_UNAVAIL�REQ_ACTN_ABRTD_LOCAL_ERR� REQ_ACTN_ABRTD_INSUFF_STORAGEru rw ry r r� r{ r_ r� �NEED_ACCT_FOR_STORrk rp rn rq r= rr rs � PAGE_TYPE_UNK�EXCEEDED_STORAGE_ALLOC�FILENAME_NOT_ALLOWEDrf ra r. rB rQ rV rW r] r_ rF rm rI rK rM rO rt rv rx rz r} r� r� r� r� r� � IConsumerr� r� � ClientFactoryr� r r r� r � TimeoutMixinr r! r rq r. r0 r< rQ rR r_ r� r� �IRealmr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� � ServerFactoryr� r� r� r� r8 r2 r3 r3 r3 r4 �<module> s � ���� � � � ������������� � � � �!�#�$�%�'�(�*�+�.�0�2�3�4�5�7�:�;�<�=�>�?�@�A�B�C�D�E�F�Q ! c O, 8 tU"% , V D pPK Mb�ZcxS��u �u ) protocols/__pycache__/amp.cpython-310.pycnu �[��� o �b�x � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl m Z ddl m Z ddlmZmZmZmZmZmZmZmZ dd lmZmZ dd lmZm Z m Z dd l m Z m Z m!Z! dd l"m#Z# dd l$m%Z% ddl&m'Z' ddl(m)Z)m*Z* ddl+m,Z,m-Z- ddl.m/Z0m1Z2 ddl3m4Z4 ddl5m6Z6 ddl7m8Z8 zddl9m:Z; e;j<r�ddl=m>Z>m?Z?m@Z@mAZA ndZ:W n eBy� dZ:Y nw e;Z:g d�ZCdZDdZEdZFdZGd ZHd ZId ZJd ZKd ZLd!ZMG d"d#� d#e�ZNG d$d%� d%e�ZOG d&d'� d'e�ZPG d(d)� d)e�ZQG d*d+� d+eR�ZSG d,d-� d-eR�ZTG d.d/� d/eS�ZUG d0d1� d1eS�ZVG d2d3� d3eS�ZWG d4d5� d5eS�ZXG d6d7� d7eS�ZYG d8d9� d9eS�ZZG d:d;� d;eZ�Z[G d<d=� d=eS�Z\G d>d?� d?eS�Z]G d@dA� dAeS�Z^eKe]iZ_G dBdC� dCe`�ZaeaZbG dDdE� dEea�ZcG dFdG� dGea�ZdeeP�G dHdI� dI��ZeG dJdK� dKef�ZgeeQ�G dLdM� dMegdN��ZheeQ�G dOdP� dP��Zig dQ�ZjdRdS� ZkeeN�G dTdU� dU��ZlG dVdW� dWel�ZmG dXdY� dYel�ZnG dZd[� d[el�ZoG d\d]� d]el�ZpG d^d_� d_en�ZqG d`da� daeq�ZrG dbdc� dcel�ZsG ddde� deel�ZtG dfdg� dgem�ZuG dhdi� dief�ZvG djdk� dkevdN�ZwG dldm� dm�ZxG dndo� doea�ZyG dpdq� dqen�ZzG drds� dsew�Z{G dtdu� duew�Z|ee#�G dvdw� dw��Z}eeO�G dxdy� dye*e)e}��Z~G dzd{� d{e~eeehei�ZG d|d}� d}�Z�e�j�Z�e�j�Z�d~d� Z�d�d�� Z�G d�d�� d�el�Z�G d�d�� d�el�Z�dS )�a� This module implements AMP, the Asynchronous Messaging Protocol. AMP is a protocol for sending multiple asynchronous request/response pairs over the same connection. Requests and responses are both collections of key/value pairs. AMP is a very simple protocol which is not an application. This module is a "protocol construction kit" of sorts; it attempts to be the simplest wire-level implementation of Deferreds. AMP provides the following base-level features: - Asynchronous request/response handling (hence the name) - Requests and responses are both key/value pairs - Binary transfer of all data: all data is length-prefixed. Your application will never need to worry about quoting. - Command dispatching (like HTTP Verbs): the protocol is extensible, and multiple AMP sub-protocols can be grouped together easily. The protocol implementation also provides a few additional features which are not part of the core wire protocol, but are nevertheless very useful: - Tight TLS integration, with an included StartTLS command. - Handshaking to other protocols: because AMP has well-defined message boundaries and maintains all incoming and outgoing requests for you, you can start a connection over AMP and then switch to another protocol. This makes it ideal for firewall-traversal applications where you may have only one forwarded port but multiple applications that want to use it. Using AMP with Twisted is simple. Each message is a command, with a response. You begin by defining a command type. Commands specify their input and output in terms of the types that they expect to see in the request and response key-value pairs. Here's an example of a command that adds two integers, 'a' and 'b':: class Sum(amp.Command): arguments = [('a', amp.Integer()), ('b', amp.Integer())] response = [('total', amp.Integer())] Once you have specified a command, you need to make it part of a protocol, and define a responder for it. Here's a 'JustSum' protocol that includes a responder for our 'Sum' command:: class JustSum(amp.AMP): def sum(self, a, b): total = a + b print 'Did a sum: %d + %d = %d' % (a, b, total) return {'total': total} Sum.responder(sum) Later, when you want to actually do a sum, the following expression will return a L{Deferred} which will fire with the result:: ClientCreator(reactor, amp.AMP).connectTCP(...).addCallback( lambda p: p.callRemote(Sum, a=13, b=81)).addCallback( lambda result: result['total']) Command responders may also return Deferreds, causing the response to be sent only once the Deferred fires:: class DelayedSum(amp.AMP): def slowSum(self, a, b): total = a + b result = defer.Deferred() reactor.callLater(3, result.callback, {'total': total}) return result Sum.responder(slowSum) This is transparent to the caller. You can also define the propagation of specific errors in AMP. For example, for the slightly more complicated case of division, we might have to deal with division by zero:: class Divide(amp.Command): arguments = [('numerator', amp.Integer()), ('denominator', amp.Integer())] response = [('result', amp.Float())] errors = {ZeroDivisionError: 'ZERO_DIVISION'} The 'errors' mapping here tells AMP that if a responder to Divide emits a L{ZeroDivisionError}, then the other side should be informed that an error of the type 'ZERO_DIVISION' has occurred. Writing a responder which takes advantage of this is very simple - just raise your exception normally:: class JustDivide(amp.AMP): def divide(self, numerator, denominator): result = numerator / denominator print 'Divided: %d / %d = %d' % (numerator, denominator, total) return {'result': result} Divide.responder(divide) On the client side, the errors mapping will be used to determine what the 'ZERO_DIVISION' error means, and translated into an asynchronous exception, which can be handled normally as any L{Deferred} would be:: def trapZero(result): result.trap(ZeroDivisionError) print "Divided by zero: returning INF" return 1e1000 ClientCreator(reactor, amp.AMP).connectTCP(...).addCallback( lambda p: p.callRemote(Divide, numerator=1234, denominator=0) ).addErrback(trapZero) For a complete, runnable example of both of these commands, see the files in the Twisted repository:: doc/core/examples/ampserver.py doc/core/examples/ampclient.py On the wire, AMP is a protocol which uses 2-byte lengths to prefix keys and values, and empty keys to separate messages:: <2-byte length><key><2-byte length><value> <2-byte length><key><2-byte length><value> ... <2-byte length><key><2-byte length><value> <NUL><NUL> # Empty Key == End of Message And so on. Because it's tedious to refer to lengths and NULs constantly, the documentation will refer to packets as if they were newline delimited, like so:: C: _command: sum C: _ask: ef639e5c892ccb54 C: a: 13 C: b: 81 S: _answer: ef639e5c892ccb54 S: total: 94 Notes: In general, the order of keys is arbitrary. Specific uses of AMP may impose an ordering requirement, but unless this is specified explicitly, any ordering may be generated and any ordering must be accepted. This applies to the command-related keys I{_command} and I{_ask} as well as any other keys. Values are limited to the maximum encodable size in a 16-bit length, 65535 bytes. Keys are limited to the maximum encodable size in a 8-bit length, 255 bytes. Note that we still use 2-byte lengths to encode keys. This small redundancy has several features: - If an implementation becomes confused and starts emitting corrupt data, or gets keys confused with values, many common errors will be signalled immediately instead of delivering obviously corrupt packets. - A single NUL will separate every key, and a double NUL separates messages. This provides some redundancy when debugging traffic dumps. - NULs will be present at regular intervals along the protocol, providing some padding for otherwise braindead C implementations of the protocol, so that <stdio.h> string functions will see the NUL and stop. - This makes it possible to run an AMP server on a port also used by a plain-text protocol, and easily distinguish between non-AMP clients (like web browsers) which issue non-NUL as the first byte, and AMP clients, which always issue NUL as the first byte. @var MAX_VALUE_LENGTH: The maximum length of a message. @type MAX_VALUE_LENGTH: L{int} @var ASK: Marker for an Ask packet. @type ASK: L{bytes} @var ANSWER: Marker for an Answer packet. @type ANSWER: L{bytes} @var COMMAND: Marker for a Command packet. @type COMMAND: L{bytes} @var ERROR: Marker for an AMP box of error type. @type ERROR: L{bytes} @var ERROR_CODE: Marker for an AMP box containing the code of an error. @type ERROR_CODE: L{bytes} @var ERROR_DESCRIPTION: Marker for an AMP box containing the description of the error. @type ERROR_DESCRIPTION: L{bytes} � N)�partial)�BytesIO)�count)�pack)� MethodType)�Any�Callable�Dict�List�Optional�Tuple�Type�Union)� Interface� implementer)�Deferred�fail� maybeDeferred)�ConnectionClosed�ConnectionLost�PeerVerifyError)�IFileDescriptorReceiver)�CONNECTION_LOST)�Protocol)�Int16StringReceiver�StatefulStringProtocol)�filepath�log)�UTC�FixedOffsetTimeZone)� nativeString)�Failure)�accumulateClassDict)�ssl)�DN� Certificate�CertificateOptions�KeyPair)5�AMP�ANSWER�ASK�AmpBox�AmpError�AmpList�Argument�BadLocalReturn�BinaryBoxProtocol�Boolean�Box� BoxDispatcher�COMMAND�Command�CommandLocator�Decimal� Descriptor�ERROR� ERROR_CODE�ERROR_DESCRIPTION�Float� IArgumentType� IBoxReceiver� IBoxSender�IResponderLocator�IncompatibleVersions�Integer�InvalidSignature�ListOf�MAX_KEY_LENGTH�MAX_VALUE_LENGTH�MalformedAmpBox� NoEmptyBoxes� OnlyOneTLS�PROTOCOL_ERRORS�PYTHON_KEYWORDS�Path�ProtocolSwitchCommand�ProtocolSwitched�QuitBox�RemoteAmpError�SimpleStringLocator�StartTLS�String�TooLong�UNHANDLED_ERROR_CODE�UNKNOWN_ERROR_CODE�UnhandledCommand�utc�Unicode�UnknownRemoteError�parse� parseStrings _asks _answers _commands _errors _error_codes _error_descriptions UNKNOWNs UNHANDLED� � c @ � e Zd ZdZdd� Zdd� ZdS )r= z� An L{IArgumentType} can serialize a Python object into an AMP box and deserialize information from an AMP box back into a Python object. @since: 9.0 c C � dS )a Given an argument name and an AMP box containing serialized values, extract one or more Python objects and add them to the C{objects} dictionary. @param name: The name associated with this argument. Most commonly this is the key which can be used to find a serialized value in C{strings}. @type name: C{bytes} @param strings: The AMP box from which to extract one or more values. @type strings: C{dict} @param objects: The output dictionary to populate with the value for this argument. The key used will be derived from C{name}. It may differ; in Python 3, for example, the key will be a Unicode/native string. See L{_wireNameToPythonIdentifier}. @type objects: C{dict} @param proto: The protocol instance which received the AMP box being interpreted. Most likely this is an instance of L{AMP}, but this is not guaranteed. @return: L{None} N� ��name�strings�objects�protora ra �7/usr/lib/python3/dist-packages/twisted/protocols/amp.py�fromBox; � zIArgumentType.fromBoxc C r` )a= Given an argument name and a dictionary containing structured Python objects, serialize values into one or more strings and add them to the C{strings} dictionary. @param name: The name associated with this argument. Most commonly this is the key in C{strings} to associate with a C{bytes} giving the serialized form of that object. @type name: C{bytes} @param strings: The AMP box into which to insert one or more strings. @type strings: C{dict} @param objects: The input dictionary from which to extract Python objects to serialize. The key used will be derived from C{name}. It may differ; in Python 3, for example, the key will be a Unicode/native string. See L{_wireNameToPythonIdentifier}. @type objects: C{dict} @param proto: The protocol instance which will send the AMP box once it is fully populated. Most likely this is an instance of L{AMP}, but this is not guaranteed. @return: L{None} Nra rb ra ra rg �toBoxW ri zIArgumentType.toBoxN)�__name__� __module__� __qualname__�__doc__rh rj ra ra ra rg r= 3 s r= c @ r_ )r? z7 A transport which can send L{AmpBox} objects. c C r` )z� Send an L{AmpBox}. @raise ProtocolSwitched: if the underlying protocol has been switched. @raise ConnectionLost: if the underlying connection has already been lost. Nra ��boxra ra rg �sendBoxx ri zIBoxSender.sendBoxc C r` )z� An unhandled error occurred in response to a box. Log it appropriately. @param failure: a L{Failure} describing the error that occurred. Nra )�failurera ra rg �unhandledError� ri zIBoxSender.unhandledErrorN)rk rl rm rn rq rs ra ra ra rg r? s s r? c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) r> zh An application object which can receive L{AmpBox} objects and dispatch them appropriately. c C r` )z� The L{IBoxReceiver.ampBoxReceived} method will start being called; boxes may be responded to by responding to the given L{IBoxSender}. @param boxSender: an L{IBoxSender} provider. Nra �� boxSenderra ra rg �startReceivingBoxes� ri z IBoxReceiver.startReceivingBoxesc C r` )zS A box was received from the transport; dispatch it appropriately. Nra ro ra ra rg �ampBoxReceived� ri zIBoxReceiver.ampBoxReceivedc C r` )zi No further boxes will be received on this connection. @type reason: L{Failure} Nra )�reasonra ra rg �stopReceivingBoxes� ri z IBoxReceiver.stopReceivingBoxesN)rk rl rm rn rw rx rz ra ra ra rg r> � s r> c @ � e Zd ZdZdd� ZdS )r@ ze An application object which can look up appropriate responder methods for AMP commands. c C r` )a� Locate a responder method appropriate for the named command. @param name: the wire-level name (commandName) of the AMP command to be responded to. @type name: C{bytes} @return: a 1-argument callable that takes an L{AmpBox} with argument values for the given command, and returns an L{AmpBox} containing argument values for the named command, or a L{Deferred} that fires the same. Nra )rc ra ra rg �locateResponder� ri z!IResponderLocator.locateResponderN)rk rl rm rn r| ra ra ra rg r@ � � r@ c @ � e Zd ZdZdS )r, z3 Base class of all Amp-related exceptions. N�rk rl rm rn ra ra ra rg r, � � r, c @ r~ )rN z� Connections which have been switched to other protocols can no longer accept traffic at the AMP level. This is raised when you try to send it. Nr ra ra ra rg rN � r� rN c @ r~ )rI z` This is an implementation limitation; TLS may only be started once per connection. Nr ra ra ra rg rI � r� rI c @ r~ )rH zt You can't have empty boxes on the connection. This is raised when you receive or attempt to send one. Nr ra ra ra rg rH � r� rH c @ r~ )rC z5 You didn't pass all the required arguments. Nr ra ra ra rg rC � r� rC c @ s( e Zd ZdZddd�Zdefdd�ZdS ) rT a One of the protocol's length limitations was violated. @ivar isKey: true if the string being encoded in a key position, false if it was in a value position. @ivar isLocal: Was the string encoded locally, or received too long from the network? (It's only physically possible to encode "too long" values on the network for keys.) @ivar value: The string that was too long. @ivar keyName: If the string being encoded was in a value position, what key was it being encoded for? Nc C s& t �| � || _|| _|| _|| _d S �N)r, �__init__�isKey�isLocal�value�keyName)�selfr� r� r� r� ra ra rg r� � s zTooLong.__init__�returnc C sH | j rdpd}| j s|dt| j� 7 }| jrdpd}d||t| j�f S )N�keyr� � �local�remotez%s %s too long: %d)r� �reprr� r� �lenr� )r� �hdr�lclra ra rg �__repr__� s zTooLong.__repr__r� )rk rl rm rn r� �strr� ra ra ra rg rT � s rT c @ s8 e Zd ZdZdededdfdd�Zdefdd �ZeZdS ) r/ zU A bad value was returned from a local command; we were unable to coerce it. �message�enclosedr� Nc C s t �| � || _|| _d S r� )r, r� r� r� )r� r� r� ra ra rg r� s zBadLocalReturn.__init__c C s | j d | j�� S )Nr� )r� r� �getBriefTraceback�r� ra ra rg r� s zBadLocalReturn.__repr__) rk rl rm rn r� r! r� r� �__str__ra ra ra rg r/ � s r/ c s" e Zd ZdZd� fdd� Z� ZS )rP z� This error indicates that something went wrong on the remote end of the connection, and the error was serialized and transmitted to you. FNc sz |r d}|� � }nd}d}d�dd� |D ��}|r"d�||||�}nd�|||�}t� �|� || _|| _|| _|| _dS )a� Create a remote error with an error code and description. @param errorCode: the AMP error code of this error. @type errorCode: C{bytes} @param description: some text to show to the user. @type description: C{str} @param fatal: a boolean, true if this error should terminate the connection. @param local: a local Failure, if one exists. z (local)� c s s, � | ]}|d krd|d��nt |�V qdS )� z\x�2xN)�chr)�.0�cra ra rg � <genexpr>* s � �z*RemoteAmpError.__init__.<locals>.<genexpr>zCode<{}>{}: {} {}zCode<{}>{}: {}N) r� �join�format�superr� r� � errorCode� description�fatal) r� r� r� r� r� � localwhat�othertb�errorCodeForMessager� �� __class__ra rg r� s. ��� zRemoteAmpError.__init__)FN)rk rl rm rn r� � __classcell__ra ra r� rg rP s rP c @ r{ )rZ zc This means that an error whose type we can't identify was raised from the other side. c C s t }t�| ||� d S r� )rV rP r� )r� r� r� ra ra rg r� G s zUnknownRemoteError.__init__N)rk rl rm rn r� ra ra ra rg rZ A r} rZ c @ r~ )rG zJ This error indicates that the wire-level protocol was malformed. Nr ra ra ra rg rG L r� rG c @ r~ )rW z= A command received via amp could not be dispatched. Nr ra ra ra rg rW R r� rW c @ r~ )rA zw It was impossible to negotiate a compatible version of the protocol with the other end of the connection. Nr ra ra ra rg rA X r� rA c sX e Zd ZU dZg Zee ed< � fdd�Zdd� Z dd� Z d d � Z d efd d �Z � Z S )r+ z\ I am a packet in the AMP protocol, much like a regular bytes:bytes dictionary. � __slots__c sF t � j|i |�� dd� | D �}|D ]}|�d�}| �|�| |< qdS )a Initialize a new L{AmpBox}. In Python 3, keyword arguments MUST be Unicode/native strings whereas in Python 2 they could be either byte strings or Unicode strings. However, all keys of an L{AmpBox} MUST be byte strings, or possible to transparently coerce into byte strings (i.e. Python 2). In Python 3, therefore, native string keys are coerced to byte strings by encoding as ASCII. This can result in C{UnicodeEncodeError} being raised. @param args: See C{dict}, but all keys and values should be C{bytes}. On Python 3, native strings may be used as keys provided they contain only ASCII characters. @param kw: See C{dict}, but all keys and values should be C{bytes}. On Python 3, native strings may be used as keys provided they contain only ASCII characters. @raise UnicodeEncodeError: When a native string key cannot be coerced to an ASCII byte string (Python 3 only). c S s g | ] }t |t�s|�qS ra �� isinstance�bytes)r� �nra ra rg � <listcomp>� � z#AmpBox.__init__.<locals>.<listcomp>�asciiN)r� r� �encode�pop)r� �args�kw� nonByteNames� nonByteName�byteNamer� ra rg r� l s �zAmpBox.__init__c C s | � � }|�| � |S )z5 Return another AmpBox just like me. )r� �update)r� �newBoxra ra rg �copy� s z AmpBox.copyc C s� t | �� �}g }|j}|D ]N\}}t|�tkr td| ��t|�tkr-td|�d|����t|�tkr:tdd|d��t|�t krGtdd||��||fD ]}|t dt|��� ||� qKq |t dd�� d � |�S ) z� Convert me into a wire-encoded string. @return: a C{bytes} encoded according to the rules described in the module docstring. zUnicode key not allowed: %rzUnicode value for key z not allowed: TNF�!Hr � ) �sorted�items�append�typer� � TypeErrorr� rE rT rF r r� )r� �i�L�w�k�v�kvra ra rg � serialize� s$ � zAmpBox.serializec C s |� | � dS )aW Serialize and send this box to an Amp instance. By the time it is being sent, several keys are required. I must have exactly ONE of:: _ask _answer _error If the '_ask' key is set, then the '_command' key must also be set. @param proto: an AMP instance. N)rq �r� rf ra ra rg �_sendTo� s zAmpBox._sendTor� c C s dt �| �� d�S )NzAmpBox(�))�dictr� r� ra ra rg r� � � zAmpBox.__repr__)rk rl rm rn r� r r� �__annotations__r� r� r� r� r� r� ra ra r� rg r+ b s r+ c sD e Zd ZU dZg Zee ed< def� fdd� Z� fdd�Z � Z S )rO zJ I am an AmpBox that, upon being sent, terminates the connection. r� r� c s dt � �� � d�S )Nz QuitBox(**r� )r� r� r� r� ra rg r� � r� zQuitBox.__repr__c s t � �|� |j�� dS )z@ Immediately call loseConnection after sending. N)r� r� � transport�loseConnectionr� r� ra rg r� � s zQuitBox._sendTo) rk rl rm rn r� r r� r� r� r� r� ra ra r� rg rO � s rO c s: e Zd ZdZ� fdd�Zdefdd�Z� fdd�Z� ZS ) � _SwitchBoxz| Implementation detail of ProtocolSwitchCommand: I am an AmpBox which sets up state for the protocol to switch. c s t � jdi |�� || _dS )z� Create a _SwitchBox with the protocol to switch to after being sent. @param innerProto: the protocol instance to switch to. @type innerProto: an IProtocol provider. Nra )r� r� � innerProto)r� r� r� r� ra rg r� � s z_SwitchBox.__init__r� c C s d� | jt�| ��S )Nz_SwitchBox({!r}, **{}))r� r� r� r� r� ra ra rg r� � s �z_SwitchBox.__repr__c s$ t � �|� |�� |�| j� dS )z{ Send me; I am the last box on the connection. All further traffic will be over the new protocol. N)r� r� �_lockForSwitch� _switchTor� r� r� ra rg r� � s z_SwitchBox._sendTo) rk rl rm rn r� r� r� r� r� ra ra r� rg r� � s r� c @ s� e Zd ZdZdZdZdZdZdd� Zdd� Z dd � Z d d � Z d d � Z d#dd�Z d#dd�Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� ZdS )$r3 a A L{BoxDispatcher} dispatches '_ask', '_answer', and '_error' L{AmpBox}es, both incoming and outgoing, to their appropriate destinations. Outgoing commands are converted into L{Deferred}s and outgoing boxes, and associated tracking state to fire those L{Deferred} when '_answer' boxes come back. Incoming '_answer' and '_error' boxes are converted into callbacks and errbacks on those L{Deferred}s, respectively. Incoming '_ask' boxes are converted into method calls on a supplied method locator. @ivar _outstandingRequests: a dictionary mapping request IDs to L{Deferred}s which were returned for those requests. @ivar locator: an object with a L{CommandLocator.locateResponder} method that locates a responder function that takes a Box and returns a result (either a Box or a Deferred which fires one). @ivar boxSender: an object which can send boxes, via the L{_sendBoxCommand} method, such as an L{AMP} instance. @type boxSender: L{IBoxSender} Nr c C s i | _ || _d S r� )�_outstandingRequests�locator)r� r� ra ra rg r� s zBoxDispatcher.__init__c C � || _ dS )z� The given boxSender is going to start calling boxReceived on this L{BoxDispatcher}. @param boxSender: The L{IBoxSender} to send command responses to. Nru )r� rv ra ra rg rw � z!BoxDispatcher.startReceivingBoxesc C s | � |� dS )z� No further boxes will be received here. Terminate all currently outstanding command deferreds with the given reason. N)�failAllOutgoing�r� ry ra ra rg rz % s z BoxDispatcher.stopReceivingBoxesc C s2 || _ | j�� }d| _|D ] \}}|�|� q dS )z� Call the errback on all outstanding requests awaiting responses. @param reason: the Failure instance to pass to those errbacks. N)�_failAllReasonr� r� �errback)r� ry �ORr� r� ra ra rg r� , s �z BoxDispatcher.failAllOutgoingc C s | j d7 _ d| j f S )z� Generate protocol-local serial numbers for _ask keys. @return: a string that has not yet been used on this connection. � s %x)�_counterr� ra ra rg �_nextTag8 s zBoxDispatcher._nextTagTc C sd | j dur|r t| j �S dS ||t< | �� }|r ||t< |�| j� |r.t� }| j|< |S d}|S )a� Send a command across the wire with the given C{amp.Box}. Mutate the given box to give it any additional keys (_command, _ask) required for the command and request/response machinery, then send it. If requiresAnswer is True, returns a C{Deferred} which fires when a response is received. The C{Deferred} is fired with an C{amp.Box} on success, or with an C{amp.RemoteAmpError} if an error is received. If the Deferred fails and the error is not handled by the caller of this method, the failure will be logged and the connection dropped. @param command: a C{bytes}, the name of the command to issue. @param box: an AmpBox with the arguments for the command. @param requiresAnswer: a boolean. Defaults to True. If True, return a Deferred which will fire when the other side responds to this command. If False, return None and do not ask the other side for acknowledgement. @return: a Deferred which fires the AmpBox that holds the response to this command, or None, as specified by requiresAnswer. @raise ProtocolSwitched: if the protocol has been switched. N) r� r r4 r� r* r� rv r r� )r� �commandrp �requiresAnswer�tag�resultra ra rg �_sendBoxCommandA s �z BoxDispatcher._sendBoxCommandc K s t |�}| �|||�S )at This is a low-level API, designed only for optimizing simple messages for which the overhead of parsing is too great. @param command: a C{bytes} naming the command. @param kw: arguments to the amp box. @param requiresAnswer: a boolean. Defaults to True. If True, return a Deferred which will fire when the other side responds to this command. If False, return None and do not ask the other side for acknowledgement. @return: a Deferred which fires the AmpBox that holds the response to this command, or None, as specified by requiresAnswer. )r2 r� )r� r� r� r� rp ra ra rg �callRemoteStringl s z BoxDispatcher.callRemoteStringc O s6 z ||i |��}W n t y t� Y S w |�| �S )ah This is the primary high-level API for sending messages via AMP. Invoke it with a command and appropriate arguments to send a message to this connection's peer. @param commandType: a subclass of Command. @type commandType: L{type} @param a: Positional (special) parameters taken by the command. Positional parameters will typically not be sent over the wire. The only command included with AMP which uses positional parameters is L{ProtocolSwitchCommand}, which takes the protocol that will be switched to as its first argument. @param kw: Keyword arguments taken by the command. These are the arguments declared in the command's 'arguments' attribute. They will be encoded and sent to the peer as arguments for the L{commandType}. @return: If L{commandType} has a C{requiresAnswer} attribute set to L{False}, then return L{None}. Otherwise, return a L{Deferred} which fires with a dictionary of objects representing the result of this call. Additionally, this L{Deferred} may fail with an exception representing a connection failure, with L{UnknownRemoteError} if the other end of the connection fails for an unknown reason, or with any error specified as a key in L{commandType}'s C{errors} dictionary. )� BaseExceptionr � _doCommand)r� � commandType�ar� �cora ra rg � callRemote s % � zBoxDispatcher.callRemotec C s | j �|�S )zy This is a terminal callback called after application code has had a chance to quash any errors. )rv rs �r� rr ra ra rg rs � s z BoxDispatcher.unhandledErrorc C s* | j �|t �}|�| j� |�|� dS )z� An AMP box was received that answered a command previously sent with L{callRemote}. @param box: an AmpBox with a value for its L{ANSWER} key. N)r� r� r) � addErrbackrs �callback)r� rp �questionra ra rg �_answerReceived� s z BoxDispatcher._answerReceivedc C sv | j �|t �}|�| j� |t }|t }t|t�r!|� dd�}|t v r-t | ||�}nt ||�}|� t |�� dS )z� An AMP box was received that answered a command previously sent with L{callRemote}, with an error. @param box: an L{AmpBox} with a value for its L{ERROR}, L{ERROR_CODE}, and L{ERROR_DESCRIPTION} keys. �utf-8�replaceN)r� r� r9 r� rs r: r; r� r� �decoderJ rP r� r! )r� rp r� r� r� �excra ra rg �_errorReceived� s z BoxDispatcher._errorReceivedc sR � fdd�}� fdd�}| � � �}t� v r!|�||� |�| j� |�| j� dS )zc @param box: an L{AmpBox} with a value for its L{COMMAND} and L{ASK} keys. c s � t | t< | S r� )r* r) )� answerBoxro ra rg � formatAnswer� s z4BoxDispatcher._commandReceived.<locals>.formatAnswerc s� | � t�r$| jj}| jj}t|t�r|�dd�}| jjr t � }nt � }n t � }t � | � t }d}� t |t< ||t< ||t< |S )Nr� r� s Unknown Error)�checkrP r� r� r� r� r� r� r� rO r+ r �errrV r* r9 r; r: )�error�code�desc�errorBoxro ra rg � formatError� s z3BoxDispatcher._commandReceived.<locals>.formatErrorN)�dispatchCommandr* � addCallbacks� addCallback� _safeEmitr� rs )r� rp r� r �deferredra ro rg �_commandReceived� s z BoxDispatcher._commandReceivedc C sJ t |v r | �|� dS t|v r| �|� dS t|v r!| �|� dS t|��)a� An AmpBox was received, representing a command, or an answer to a previously issued command (either successful or erroneous). Respond to it according to its contents. @param box: an AmpBox @raise NoEmptyBoxes: when a box is received that does not contain an '_answer', '_command' / '_ask', or '_error' key; i.e. one which does not fit into the command / response protocol defined by AMP. N)r) r� r9 r� r4 r rH �r� rp ra ra rg rx � s z BoxDispatcher.ampBoxReceivedc C s, z |� | j� W dS ttfy Y dS w )z� Emit a box, ignoring L{ProtocolSwitched} and L{ConnectionLost} errors which cannot be usefully handled. N)r� rv rN r )r� �aBoxra ra rg r s �zBoxDispatcher._safeEmitc C sJ |t }| j�|�}|du r d|��}ttt|dtt� �d��S t||�S )z� A box with a _command key was received. Dispatch it to a local handler call it. @param box: an AmpBox to be dispatched. NzUnhandled Command: F�r� ) r4 r� r| r rP rU r! rW r )r� rp �cmd� responderr� ra ra rg r s �� z BoxDispatcher.dispatchCommand)T)rk rl rm rn r� r� r� rv r� rw rz r� r� r� r� r� rs r� r� r rx r r ra ra ra rg r3 � s* ++ % r3 c @ s& e Zd ZU dZg Zded< dd� ZdS )�_CommandLocatorMetaa� This metaclass keeps track of all of the Command.responder-decorated methods defined since the last CommandLocator subclass was defined. It assumes (usually correctly, but unfortunately not necessarily so) that those commands responders were all declared as methods of the class being defined. Note that this list can be incorrect if users use the Command.responder decorator outside the context of a CommandLocator class declaration. Command responders defined on subclasses are given precedence over those inherited from a base class. The Command.responder decorator explicitly cooperates with this metaclass. z List[Tuple[Command, Callable]]�_currentClassCommandsc C s� | j d d � }g | j d d �< i }|d< t�| |||�}t|jdd � �}|�� |D ] }|�t|di �� q+|D ] \} } | | f|| j< q9|rT|j t j krTdd� } | |_ |S )N�_commandDispatchr� c S s t jdtdd� | �|�S )Nz-Override locateResponder, not lookupFunction.� ��category� stacklevel)�warnings�warn�PendingDeprecationWarning�lookupFunction�r� rc ra ra rg r| K s � z4_CommandLocatorMeta.__new__.<locals>.locateResponder) r r� �__new__�list�__mro__�reverser� �getattr� commandNamer r6 r| ) �clsrc �bases�attrs�commands�cd�subcls� ancestors�ancestor� commandClass� responderFuncr| ra ra rg r > s z_CommandLocatorMeta.__new__N)rk rl rm rn r r� r ra ra ra rg r + s r c @ rt ) r6 z� A L{CommandLocator} is a collection of responders to AMP L{Command}s, with the help of the L{Command.responder} decorator. c s � ��fdd�}|S )a< Wrap aCallable with its command's argument de-serialization and result serialization logic. @param aCallable: a callable with a 'command' attribute, designed to be called with keyword arguments. @param command: the command class whose serialization to use. @return: a 1-arg callable which, when invoked with an AmpBox, will deserialize the argument list and invoke appropriate user code for the callable's command, returning a Deferred which fires with the result or fails with an error. c sD �� | ��}�fdd�}� ��fdd�}t� fi |���|��|�S )Nc s: | j � j� }� j| }t| j�}tt|||� jv | d��S )Nr )�trap� allErrorsr� r� r! rP � fatalErrors)r� r� r� r� )r� ra rg �checkKnownErrorsq s �zMCommandLocator._wrapWithSerialization.<locals>.doit.<locals>.checkKnownErrorsc s8 z�� | ��W S ty t� }td� | �f |��w )Nz,%r returned %r and %r could not serialize it)� makeResponser� r! r/ )re �originalFailure�� aCallabler� r� ra rg �makeResponseFory s ���zLCommandLocator._wrapWithSerialization.<locals>.doit.<locals>.makeResponseFor)�parseArgumentsr r r� )rp r� r, r1 r/ ra rg �doitn s �z3CommandLocator._wrapWithSerialization.<locals>.doitra )r� r0 r� r3 ra r/ rg �_wrapWithSerialization^ s z%CommandLocator._wrapWithSerializationc C s4 | j jtjkr t�| |�S tjdtdd� | �|�S )zJ Deprecated synonym for L{CommandLocator.locateResponder} z)Call locateResponder, not lookupFunction.r r )r� r r6 r| r r r r ra ra rg r � s � z CommandLocator.lookupFunctionc C s4 | j }||v r|| \}}t|| �}| �||�S dS )a� Locate a callable to invoke when executing the named command. @param name: the normalized name (from the wire) of the command. @type name: C{bytes} @return: a 1-argument function that takes a Box and returns a box or a Deferred which fires a Box, for handling the command identified by the given name, or None, if no appropriate responder can be found. N)r r r4 )r� rc r# r' r( �responderMethodra ra rg r| � s �z CommandLocator.locateResponderN)rk rl rm rn r4 r r| ra ra ra rg r6 W s / r6 )� metaclassc @ s e Zd ZdZdZdd� ZdS )rQ z^ Implement the L{AMP.locateResponder} method to do simple, string-based dispatch. s amp_c C s t | j|�� �}t| |d�S )a� Locate a callable to invoke when executing the named command. @return: a function with the name C{"amp_" + name} on the same instance, or None if no such function exists. This function will then be called with the L{AmpBox} itself as an argument. @param name: the normalized name (from the wire) of the command. @type name: C{bytes} N)r �baseDispatchPrefix�upperr )r� rc �fNamera ra rg r| � s z#SimpleStringLocator.locateResponderN)rk rl rm rn r7 r| ra ra ra rg rQ � s rQ ) �and�del�for�is�raise�assert�elif�from�lambdar� �break�else�global�not�try�class�except�if�or�while�continue�exec�import�pass�yield�def�finally�in�printc C s$ t | �dd��}|tv r|�� S |S )a| (Private) Normalize an argument name from the wire for use with Python code. If the return value is going to be a python keyword it will be capitalized. If it contains any dashes they will be replaced with underscores. The rationale behind this method is that AMP should be an inherently multi-language protocol, so message keys may contain all manner of bizarre bytes. This is not a complete solution; there are still forms of arguments that this implementation will be unable to parse. However, Python identifiers share a huge raft of properties with identifiers from many other languages, so this is a 'good enough' effort for now. We deal explicitly with dashes because that is the most likely departure: Lisps commonly use dashes to separate method names, so protocols initially implemented in a lisp amp dialect may use dashes in argument or command names. @param key: a C{bytes}, looking something like 'foo-bar-baz' or 'from' @type key: C{bytes} @return: a native string which is a valid python identifier, looking something like 'foo_bar_baz' or 'From'. � -� _)r r� rK �title)r� �lkeyra ra rg �_wireNameToPythonIdentifier� s rZ c @ sV e Zd ZdZdZddd�Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dS )r. a� Base-class of all objects that take values from Amp packets and convert them into objects for Python functions. This implementation of L{IArgumentType} provides several higher-level hooks for subclasses to override. See L{toString} and L{fromString} which will be used to define the behavior of L{IArgumentType.toBox} and L{IArgumentType.fromBox}, respectively. Fc C r� )z� Create an Argument. @param optional: a boolean indicating whether this argument can be omitted in the protocol. N��optional)r� r\ ra ra rg r� r� zArgument.__init__c C s0 | j r|�|�}|dur||= |S |�|�}|S )a/ Retrieve the given key from the given dictionary, removing it if found. @param d: a dictionary. @param name: a key in I{d}. @param proto: an instance of an AMP. @raise KeyError: if I am not optional and no value was found. @return: d[name]. N)r\ �getr� )r� �drc rf r� ra ra rg �retrieve s �zArgument.retrievec C sD | � |||�}t|�}| jr|du rd||< dS | �||�||< dS )aG Populate an 'out' dictionary with mapping names to Python values decoded from an 'in' AmpBox mapping strings to string values. @param name: the argument name to retrieve @type name: C{bytes} @param strings: The AmpBox to read string(s) from, a mapping of argument names to string values. @type strings: AmpBox @param objects: The dictionary to write object(s) to, a mapping of names to Python objects. Keys will be native strings. @type objects: dict @param proto: an AMP instance. N)r_ rZ r\ �fromStringProto)r� rc rd re rf �st�nkra ra rg rh 4 s zArgument.fromBoxc C s8 | � |t|�|�}| jr|du rdS | �||�||< dS )a] Populate an 'out' AmpBox with strings encoded from an 'in' dictionary mapping names to Python values. @param name: the argument name to retrieve @type name: C{bytes} @param strings: The AmpBox to write string(s) to, a mapping of argument names to string values. @type strings: AmpBox @param objects: The dictionary to read object(s) from, a mapping of names to Python objects. Keys should be native strings. @type objects: dict @param proto: the protocol we are converting for. @type proto: AMP N)r_ rZ r\ � toStringProto)r� rc rd re rf �objra ra rg rj M s zArgument.toBoxc C � | � |�S )z� Convert a string to a Python value. @param inString: the string to convert. @type inString: C{bytes} @param proto: the protocol we are converting for. @type proto: AMP @return: a Python object. )� fromString�r� �inStringrf ra ra rg r` h s zArgument.fromStringProtoc C re )z� Convert a Python object to a string. @param inObject: the object to convert. @param proto: the protocol we are converting for. @type proto: AMP )�toString�r� �inObjectrf ra ra rg rc v s zArgument.toStringProtoc C r` )z� Convert a string to a Python object. Subclasses must implement this. @param inString: the string to convert. @type inString: C{bytes} @return: the decoded value from C{inString} Nra �r� rh ra ra rg rf � ri zArgument.fromStringc C r` )a Convert a Python object into a string for passing over the network. @param inObject: an object of the type that this Argument is intended to deal with. @return: the wire encoding of inObject @rtype: C{bytes} Nra �r� rk ra ra rg ri � ri zArgument.toStringN�F) rk rl rm rn r\ r� r_ rh rj r` rc rf ri ra ra ra rg r. s r. c @ � e Zd ZdZeZdd� ZdS )rB z� Encode any integer values of any size on the wire as the string representation. Example: C{123} becomes C{"123"} c C s d|f S )Ns %dra rm ra ra rg ri � � zInteger.toStringN)rk rl rm rn �intrf ri ra ra ra rg rB � s rB c @ r_ )rS zB Don't do any conversion at all; just pass through 'str'. c C � |S r� ra rm ra ra rg ri � � zString.toStringc C rr r� ra rl ra ra rg rf � rs zString.fromStringN�rk rl rm rn ri rf ra ra ra rg rS � � rS c @ ro )r< zA Encode floating-point values on the wire as their repr. c C s& t |t�s td|����t|��d�S )NzBad float value r� )r� �float� ValueErrorr� r� rl ra ra rg ri � s zFloat.toStringN)rk rl rm rn rv rf ri ra ra ra rg r< � s r< c @ r_ )r1 z@ Encode True or False as "True" or "False" on the wire. c C s& |dkrdS |dkr dS t d|����)N� TrueT� FalseFzBad boolean value: )r� rl ra ra rg rf � s zBoolean.fromStringc C s |rdS dS )Nrx ry ra rm ra ra rg ri � s zBoolean.toStringN�rk rl rm rn rf ri ra ra ra rg r1 � s r1 c @ r_ )rY z7 Encode a unicode string on the wire as UTF-8. c C s t �| |�d��S �Nr� )rS ri r� rm ra ra rg ri � r� zUnicode.toStringc C s t �| |��d�S r{ )rS rf r� rl ra ra rg rf � r� zUnicode.fromStringNrt ra ra ra rg rY � ru rY c @ r_ )rL aY Encode and decode L{filepath.FilePath} instances as paths on the wire. This is really intended for use with subprocess communication tools: exchanging pathnames on different machines over a network is not generally meaningful, but neither is it disallowed; you can use this to communicate about NFS paths, for example. c C s t �t�| |��S r� )r �FilePathrY rf rl ra ra rg rf � r� zPath.fromStringc C s t �| |�� j�S r� )rY ri � asTextMode�pathrm ra ra rg ri � r� z Path.toStringNrz ra ra ra rg rL � s rL c @ �* e Zd ZdZd dd�Zdd� Zdd� Zd S ) rD a� Encode and decode lists of instances of a single other argument type. For example, if you want to pass:: [3, 7, 9, 15] You can create an argument like this:: ListOf(Integer()) The serialized form of the entire list is subject to the limit imposed by L{MAX_VALUE_LENGTH}. List elements are represented as 16-bit length prefixed strings. The argument type passed to the L{ListOf} initializer is responsible for producing the serialized form of each element. @ivar elementType: The L{Argument} instance used to encode and decode list elements (note, not an arbitrary L{IArgumentType} implementation: arguments must be implemented using only the C{fromString} and C{toString} methods, not the C{fromBox} and C{toBox} methods). @param optional: a boolean indicating whether this argument can be omitted in the protocol. @since: 10.0 Fc C s || _ t�| |� d S r� )� elementTyper. r� )r� r� r\ ra ra rg r� s zListOf.__init__c s6 g }t � }|j|_|�|� | jj� � fdd�|D �S )zn Convert the serialized form of a list of instances of some type back into that list. c s g | ]}� |��qS ra ra )r� �string��elementFromStringra rg r� s z%ListOf.fromString.<locals>.<listcomp>)r r� �stringReceived� dataReceivedr� rf )r� rh rd �parserra r� rg rf s zListOf.fromStringc C sB g }|D ]}| j �|�}|�tdt|��� |�|� qd�|�S )zI Serialize the given list of objects to a single string. r� r� )r� ri r� r r� r� )r� rk rd rd � serializedra ra rg ri s zListOf.toStringNrn )rk rl rm rn r� rf ri ra ra ra rg rD � s rD c @ r ) r- aI Convert a list of dictionaries into a list of AMP boxes on the wire. For example, if you want to pass:: [{'a': 7, 'b': u'hello'}, {'a': 9, 'b': u'goodbye'}] You might use an AmpList like this in your arguments or response list:: AmpList([('a', Integer()), ('b', Unicode())]) Fc C s6 t dd� |D ��sJ d|f ��|| _t�| |� dS )ag Create an AmpList. @param subargs: a list of 2-tuples of ('name', argument) describing the schema of the dictionaries in the sequence of amp boxes. @type subargs: A C{list} of (C{bytes}, L{Argument}) tuples. @param optional: a boolean indicating whether this argument can be omitted in the protocol. c s s � | ] \}}t |t�V qd S r� r� )r� rc �_ra ra rg r� @ s � z#AmpList.__init__.<locals>.<genexpr>zgAmpList should be defined with a list of (name, argument) tuples where `name' is a byte string, got: %rN)�all�subargsr. r� )r� r� r\ ra ra rg r� 5 s ��zAmpList.__init__c s t |�}� �fdd�|D �}|S )Nc s g | ] }t |�j� ��qS ra )�_stringsToObjectsr� )r� rp �rf r� ra rg r� I r� z+AmpList.fromStringProto.<locals>.<listcomp>)r\ )r� rh rf �boxes�valuesra r� rg r` G s zAmpList.fromStringProtoc s d� � �fdd�|D ��S )Nr� c s" g | ] }t |�jt� � ��� �qS ra )�_objectsToStringsr� r2 r� )r� re r� ra rg r� N s ��z)AmpList.toStringProto.<locals>.<listcomp>)r� rj ra r� rg rc L s ��zAmpList.toStringProtoNrn )rk rl rm rn r� r` rc ra ra ra rg r- ' s r- c @ r_ )r8 aO Encode and decode file descriptors for exchange over a UNIX domain socket. This argument type requires an AMP connection set up over an L{IUNIXTransport<twisted.internet.interfaces.IUNIXTransport>} provider (for example, the kind of connection created by L{IReactorUNIX.connectUNIX<twisted.internet.interfaces.IReactorUNIX.connectUNIX>} and L{UNIXClientEndpoint<twisted.internet.endpoints.UNIXClientEndpoint>}). There is no correspondence between the integer value of the file descriptor on the sending and receiving sides, therefore an alternate approach is taken to matching up received descriptors with particular L{Descriptor} parameters. The argument is encoded to an ordinal (unique per connection) for inclusion in the AMP command or response box. The descriptor itself is sent using L{IUNIXTransport.sendFileDescriptor<twisted.internet.interfaces.IUNIXTransport.sendFileDescriptor>}. The receiver uses the order in which file descriptors are received and the ordinal value to come up with the received copy of the descriptor. c C s |� t|��S )a� Take a unique identifier associated with a file descriptor which must have been received by now and use it to look up that descriptor in a dictionary where they are kept. @param inString: The base representation (as a byte string) of an ordinal indicating which file descriptor corresponds to this usage of this argument. @type inString: C{str} @param proto: The protocol used to receive this descriptor. This protocol must be connected via a transport providing L{IUNIXTransport<twisted.internet.interfaces.IUNIXTransport>}. @type proto: L{BinaryBoxProtocol} @return: The file descriptor represented by C{inString}. @rtype: C{int} )�_getDescriptorrq rg ra ra rg r` j s zDescriptor.fromStringProtoc C s |� |�}t�| ||�}|S )a� Send C{inObject}, an integer file descriptor, over C{proto}'s connection and return a unique identifier which will allow the receiver to associate the file descriptor with this argument. @param inObject: A file descriptor to duplicate over an AMP connection as the value for this argument. @type inObject: C{int} @param proto: The protocol which will be used to send this descriptor. This protocol must be connected via a transport providing L{IUNIXTransport<twisted.internet.interfaces.IUNIXTransport>}. @return: A byte string which can be used by the receiver to reconstruct the file descriptor. @rtype: C{bytes} )�_sendFileDescriptorrB rc )r� rk rf � identifier� outStringra ra rg rc s zDescriptor.toStringProtoN)rk rl rm rn r` rc ra ra ra rg r8 U s r8 c @ r{ )� _CommandMetazh Metaclass hack to establish reverse-mappings for 'errors' and 'fatalErrors' as class vars. c C s� i }|d< i }|d< d|vr|� d�|d< t�| |||�}t|jt�s-td�|j���|jD ]\}}t|t�s@td|����q0|j D ]\}}t|t�sTtd|����qDi }i } t |d|� t |d | � t|j t �sqt |j �|_ t|j t �s}t |j �|_ |�� D ] \} } | || < | || < q�| �� D ] \} } | || < | || < q�|j �� D ]\}}t|t�s�td |����q�|j �� D ]\}}t|t�s�td |����q�|S ) N� reverseErrorsr* r r� z-Command names must be byte strings, got: {!r}z*Argument names must be byte strings, got: z*Response names must be byte strings, got: �errorsr+ z'Error names must be byte strings, got: z-Fatal error names must be byte strings, got: )r� r� r r� r r� r� r� � arguments�responser" r� r� r+ r� ) r rc r r! r� �er�newtyper� r� r+ r� r� ra ra rg r � sX �� � � � ��z_CommandMeta.__new__N)rk rl rm rn r ra ra ra rg r� � r} r� c @ s� e Zd ZU dZg Zeeeef e d< g Z eeeef e d< g Z ee e d< i Z eee ef e d< i Zeee ef e d< eZde d< eZee e d < d Zd d � Zed d� �Zedd� �Zedd� �Zedd� �Z edd� �Z dd� Z dS )r5 a� Subclass me to specify an AMP Command. @cvar arguments: A list of 2-tuples of (name, Argument-subclass-instance), specifying the names and values of the parameters which are required for this command. @cvar response: A list like L{arguments}, but instead used for the return value. @cvar errors: A mapping of subclasses of L{Exception} to wire-protocol tags for errors represented as L{str}s. Responders which raise keys from this dictionary will have the error translated to the corresponding tag on the wire. Invokers which receive Deferreds from invoking this command with L{BoxDispatcher.callRemote} will potentially receive Failures with keys from this mapping as their value. This mapping is inherited; if you declare a command which handles C{FooError} as 'FOO_ERROR', then subclass it and specify C{BarError} as 'BAR_ERROR', responders to the subclass may raise either C{FooError} or C{BarError}, and invokers must be able to deal with either of those exceptions. @cvar fatalErrors: like 'errors', but errors in this list will always terminate the connection, despite being of a recognizable error type. @cvar commandType: The type of Box used to issue commands; useful only for protocol-modifying behavior like startTLS or protocol switching. Defaults to a plain vanilla L{Box}. @cvar responseType: The type of Box used to respond to this command; only useful for protocol-modifying behavior like startTLS or protocol switching. Defaults to a plain vanilla L{Box}. @ivar requiresAnswer: a boolean; defaults to True. Set it to False on your subclass if you want callRemote to return None. Note: this is a hint only to the client side of the protocol. The return-type of a command responder method must always be a dictionary adhering to the contract specified by L{response}, because clients are always free to request a response if they want one. r� r� �extrar� r+ z Union[Type[Command], Type[Box]]r� � responseTypeTc K s` || _ g }| jD ]\}}t|�}|| j vr |js |�|� q|r,td�d�|�| j���g }dS )a5 Create an instance of this command with specified values for its parameters. In Python 3, keyword arguments MUST be Unicode/native strings whereas in Python 2 they could be either byte strings or Unicode strings. A L{Command}'s arguments are defined in its schema using C{bytes} names. The values for those arguments are plucked from the keyword arguments using the name returned from L{_wireNameToPythonIdentifier}. In other words, keyword arguments should be named using the Python-side equivalent of the on-wire (C{bytes}) name. @param kw: a dict containing an appropriate value for each name specified in the L{arguments} attribute of my class. @raise InvalidSignature: if you forgot any required arguments. zforgot {} for {}z, N) � structuredr� rZ r\ r� rC r� r� r )r� r� � forgottenrc �arg� pythonNamera ra rg r� s ��zCommand.__init__c C s6 z| � � }W n ty t� Y S w t|| j||�S )a` Serialize a mapping of arguments using this L{Command}'s response schema. @param objects: a dict with keys matching the names specified in self.response, having values of the types that the Argument objects in self.response can format. @param proto: an L{AMP}. @return: an L{AmpBox}. )r� r� r r� r� )r re rf r� ra ra rg r- " s �zCommand.makeResponsec C sX t � }| jD ] \}}|�t|�� q|D ] }||vr!t|� d���qt|| j| �� |�S )a� Serialize a mapping of arguments using this L{Command}'s argument schema. @param objects: a dict with keys similar to the names specified in self.arguments, having values of the types that the Argument objects in self.arguments can parse. @param proto: an L{AMP}. @return: An instance of this L{Command}'s C{commandType}. z is not a valid argument)�setr� �addrZ rC r� r� )r re rf � allowedNames�argName�ignored� intendedArgra ra rg � makeArguments6 s �zCommand.makeArgumentsc C � t || j|�S )aZ Parse a mapping of serialized arguments using this L{Command}'s response schema. @param box: A mapping of response-argument names to the serialized forms of those arguments. @param protocol: The L{AMP} protocol. @return: A mapping of response-argument names to the parsed forms. )r� r� �r rp �protocolra ra rg � parseResponseM s zCommand.parseResponsec C r� )a? Parse a mapping of serialized arguments using this L{Command}'s argument schema. @param box: A mapping of argument names to the seralized forms of those arguments. @param protocol: The L{AMP} protocol. @return: A mapping of argument names to the parsed forms. )r� r� r� ra ra rg r2 \ s zCommand.parseArgumentsc C s t j�| |f� |S )a Declare a method to be a responder for a particular command. This is a decorator. Use like so:: class MyCommand(Command): arguments = [('a', ...), ('b', ...)] class MyProto(AMP): def myFunMethod(self, a, b): ... MyCommand.responder(myFunMethod) Notes: Although decorator syntax is not used within Twisted, this function returns its argument and is therefore safe to use with decorator syntax. This is not thread safe. Don't declare AMP subclasses in other threads. Don't declare responders outside the scope of AMP subclasses; the behavior is undefined. @param methodfunc: A function which will later become a method, which has a keyword signature compatible with this command's L{arguments} list and returns a dictionary with a set of keys compatible with this command's L{response} list. @return: the methodfunc parameter. )r6 r r� )r � methodfuncra ra rg r j s zCommand.responderc sJ � fdd�}|� � j� �� j|�� j�}� jr#|�� j|� |�|� |S )aL Encode and send this Command to the given protocol. @param proto: an AMP, representing the connection to send to. @return: a Deferred which will fire or error appropriately when the other side responds to the command (or error if the connection is lost before it is responded to). c s. | � t� | j}� j�|jt�}t||j��S r� ) r) rP r� r� r] r� rZ r! r� )r� �rje� errorTyper� ra rg � _massageError� s z)Command._doCommand.<locals>._massageError)r� r r� r� r� r r� r� )r� rf r� r^ ra r� rg r� � s � zCommand._doCommandN) rk rl rm rn r� r r r� r. r� r� r� r r� r r � Exceptionr+ r2 r� r� r+ r� r� � classmethodr- r� r� r2 r r� ra ra ra rg r5 � s, * #r5 c @ r_ )�_NoCertificatea This is for peers which don't want to use a local certificate. Used by AMP because AMP's internal language is all about certificates and this duck-types in the appropriate place; this API isn't really stable though, so it's not exposed anywhere public. For clients, it will use ephemeral DH keys, or whatever the default is for certificate-less clients in OpenSSL. For servers, it will generate a temporary self-signed certificate with garbage values in the DN and use that. c C r� )aT Create a _NoCertificate which either is or isn't for the client side of the connection. @param client: True if we are a client and should truly have no certificate and be anonymous, False if we are a server and actually have to generate a temporary certificate. @type client: bool N)�client)r� r� ra ra rg r� � s z_NoCertificate.__init__c G s� | j s%tdd�}t�� }|�|�}|�||dd� d�}|�|�}|j|� S t� }|r9|� tdddd� |D �d �� t d i |��}|S ) zT Behaves like L{twisted.internet.ssl.PrivateCertificate.options}(). zTEMPORARY CERTIFICATE)�CNc S r` �NTra )�dnra ra rg �<lambda>� ri z(_NoCertificate.options.<locals>.<lambda>r� Tc S s g | ]}|j �qS ra )�original)r� �authra ra rg r� � s z*_NoCertificate.options.<locals>.<listcomp>)�verify�requireCertificate�caCertsNra ) r� r$ r' �generate�certificateRequest�signCertificateRequest�newCertificate�optionsr� r� r& ) r� � authorities�sharedDNr� �cr�sscrd�certr� �occora ra rg r� � s$ ��z_NoCertificate.optionsN)rk rl rm rn r� r� ra ra ra rg r� � s r� c @ sJ e Zd ZU dZg Zee ed< dd� Ze dd� �Z e dd� �Z d d � Z d S ) �_TLSBoxzK I am an AmpBox that, upon being sent, initiates a TLS connection. r� c C s t d u r tdd��t�| � d S )Ns TLS_ERRORzTLS not available)r# rP r+ r� r� ra ra rg r� � s z_TLSBox.__init__c C s | � dtd��S )N� tls_localCertificateF)r] r� r� ra ra rg � certificate� s z_TLSBox.certificatec C s | � dd �S )N� tls_verifyAuthorities)r] r� ra ra rg r� � s z_TLSBox.verifyc C s< t | �}dD ]}|�|d� q|�|� |�| j| j� dS )zK Send my encoded value to the protocol, then initiate TLS. )r� r� N)r+ r� r� � _startTLSr� r� )r� rf �abr� ra ra rg r� � s z_TLSBox._sendToN) rk rl rm rn r� r r� r� r� �propertyr� r� r� ra ra ra rg r� � s r� c @ r{ )�_LocalArgumentz� Local arguments are never actually relayed across the wire. This is just a shim so that StartTLS can pretend to have some arguments: if arguments acquire documentation properties, replace this with something nicer later. c C s d S r� ra )r� rc rd re rf ra ra rg rh rs z_LocalArgument.fromBoxN)rk rl rm rn rh ra ra ra rg r� s r� c @ sd e Zd ZdZdedd�fdedd�fgZdedd�fdedd�fgZeZddd�dd �Z d d � Z dS ) rR az Use, or subclass, me to implement a command that starts TLS. Callers of StartTLS may pass several special arguments, which affect the TLS negotiation: - tls_localCertificate: This is a twisted.internet.ssl.PrivateCertificate which will be used to secure the side of the connection it is returned on. - tls_verifyAuthorities: This is a list of twisted.internet.ssl.Certificate objects that will be used as the certificate authorities to verify our peer's certificate. Each of those special parameters may also be present as a key in the response dictionary. r� Tr[ r� N)�tls_localCertificate�tls_verifyAuthoritiesc K sB t du rtd��|du rtd�n|| _|| _tj| fi |�� dS )a� Create a StartTLS command. (This is private. Use AMP.callRemote.) @param tls_localCertificate: the PrivateCertificate object to use to secure the connection. If it's L{None}, or unspecified, an ephemeral DH key is used instead. @param tls_verifyAuthorities: a list of Certificate objects which represent root certificates to verify our peer with. NzTLS not available.T)r# � RuntimeErrorr� r� r� r5 r� )r� r� r� r� ra ra rg r� - s ��zStartTLS.__init__c s8 t ��� �}� ��j�j� � �fdd�}|�|� |S )z� When a StartTLS command is sent, prepare to start TLS, but don't actually do it; wait for the acknowledgement, then initiate the TLS handshake. c s � � �j�j� | S r� )r� r� r� )r� r� ra rg � actuallystartK s z*StartTLS._doCommand.<locals>.actuallystart)r5 r� � _prepareTLSr� r� r )r� rf r^ r� ra r� rg r� B s zStartTLS._doCommand) rk rl rm rn r� r� r� r� r� r� r� ra ra ra rg rR s � � rR c s8 e Zd ZdZ� fdd�Zedd� �Z� fdd�Z� ZS )rM a� Use this command to switch from something Amp-derived to a different protocol mid-connection. This can be useful to use amp as the connection-startup negotiation phase. Since TLS is a different layer entirely, you can use Amp to negotiate the security parameters of your connection, then switch to a different protocol, and the connection will remain secured. c s || _ t� jdi |�� dS )a Create a ProtocolSwitchCommand. @param _protoToSwitchToFactory: a ProtocolFactory which will generate the Protocol to switch to. @param kw: Keyword arguments, encoded and handled normally as L{Command} would. Nra )�protoToSwitchToFactoryr� r� )r� �_protoToSwitchToFactoryr� r� ra rg r� ] s z ProtocolSwitchCommand.__init__c C s t |�S r� )r� )r r� rf ra ra rg r- k s z"ProtocolSwitchCommand.makeResponsec s< t � �� �}� �� � �fdd�}� �fdd�}|�||�S )z� When we emit a ProtocolSwitchCommand, lock the protocol, but don't actually switch to the new protocol unless an acknowledgement is received. If an error is received, switch back. c s$ �j �� j�� �}� �|�j � | S r� )r� � buildProtocolr� �getPeerr� )�ignr� r� ra rg � switchNowx s �z3ProtocolSwitchCommand._doCommand.<locals>.switchNowc s � � � �j�d tt�� | S r� )�_unlockFromSwitchr� �clientConnectionFailedr! r )r� r� ra rg �handle s �z0ProtocolSwitchCommand._doCommand.<locals>.handle)r� r� r� r )r� rf r^ r� r� r� r� rg r� o s z ProtocolSwitchCommand._doCommand) rk rl rm rn r� r� r- r� r� ra ra r� rg rM S s rM c @ rt ) �_DescriptorExchangera L{_DescriptorExchanger} is a mixin for L{BinaryBoxProtocol} which adds support for receiving file descriptors, a feature offered by L{IUNIXTransport<twisted.internet.interfaces.IUNIXTransport>}. @ivar _descriptors: Temporary storage for all file descriptors received. Values in this dictionary are the file descriptors (as integers). Keys in this dictionary are ordinals giving the order in which each descriptor was received. The ordering information is used to allow L{Descriptor} to determine which is the correct descriptor for any particular usage of that argument type. @type _descriptors: C{dict} @ivar _sendingDescriptorCounter: A no-argument callable which returns the ordinals, starting from 0. This is used to construct values for C{_sendFileDescriptor}. @ivar _receivingDescriptorCounter: A no-argument callable which returns the ordinals, starting from 0. This is used to construct values for C{fileDescriptorReceived}. c C s0 i | _ | j j| _ttt� �| _ttt� �| _d S r� )� _descriptorsr� r� r �nextr �_sendingDescriptorCounter�_receivingDescriptorCounterr� ra ra rg r� � s z _DescriptorExchanger.__init__c C s | j �|� | �� S )z� Assign and return the next ordinal to the given descriptor after sending the descriptor over this protocol's transport. )r� �sendFileDescriptorr� �r� � descriptorra ra rg r� � s z(_DescriptorExchanger._sendFileDescriptorc C s || j | �� < dS )z� Collect received file descriptors to be claimed later by L{Descriptor}. @param descriptor: The received file descriptor. @type descriptor: C{int} N)r� r� r� ra ra rg �fileDescriptorReceived� s z+_DescriptorExchanger.fileDescriptorReceivedN)rk rl rm rn r� r� r� ra ra ra rg r� � s r� c @ s� e Zd ZU dZdZdZdZdZdZdZ dZ dZ dZ e e ed< dZdd� Zd)dd�Zd d � Zd d � Zd d� Zdd� ZdZdZeZdd� Zdd� Zdd� Z dd� Z dd � Z d d � Z d d � Z d!d"� Z!e"d#d$� �Z#d%d&� Z$d'd(� Z%e&�'e%� dS )*r0 a� A protocol for receiving L{AmpBox}es - key/value pairs - via length-prefixed strings. A box is composed of: - any number of key-value pairs, described by: - a 2-byte network-endian packed key length (of which the first byte must be null, and the second must be non-null: i.e. the value of the length must be 1-255) - a key, comprised of that many bytes - a 2-byte network-endian unsigned value length (up to the maximum of 65535) - a value, comprised of that many bytes - 2 null bytes In other words, an even number of strings prefixed with packed unsigned 16-bit integers, and then a 0-length string to indicate the end of the box. This protocol also implements 2 extra private bits of functionality related to the byte boundaries between messages; it can start TLS between two given boxes or switch to an entirely different protocol. However, due to some tricky elements of the implementation, the public interface to this functionality is L{ProtocolSwitchCommand} and L{StartTLS}. @ivar _keyLengthLimitExceeded: A flag which is only true when the connection is being closed because a key length prefix which was longer than allowed by the protocol was received. @ivar boxReceiver: an L{IBoxReceiver} provider, whose L{IBoxReceiver.ampBoxReceived} method will be invoked for each L{AmpBox} that is received. FN� innerProtocolc C s t �| � || _d S r� )r� r� � boxReceiver)r� r� ra ra rg r� � s zBinaryBoxProtocol.__init__c C s: | j }d| _ || _|| _|�| j� |r|�|� dS dS )a� Switch this BinaryBoxProtocol's transport to a new protocol. You need to do this 'simultaneously' on both ends of a connection; the easiest way to do this is to use a subclass of ProtocolSwitchCommand. @param newProto: the new protocol instance to switch to. @param clientFactory: the ClientFactory to send the L{twisted.internet.protocol.ClientFactory.clientConnectionLost} notification to. r� N)�recvdr� �innerProtocolClientFactory�makeConnectionr� r� )r� �newProto� clientFactory� newProtoDatara ra rg r� � s �zBinaryBoxProtocol._switchToc C sL | j rtd��| jdu rt� �| jdur | j�|� dS | j�|�� � dS )a/ Send a amp.Box to my peer. Note: transport.write is never called outside of this method. @param box: an AmpBox. @raise ProtocolSwitched: if the protocol has previously been switched. @raise ConnectionLost: if the connection has previously been lost. z5This connection has switched: no AMP traffic allowed.N)�_lockedrN r� r �_startingTLSBufferr� �writer� r ra ra rg rq s � zBinaryBoxProtocol.sendBoxc C s || _ | j�| � | �� dS )z� Notify L{boxReceiver} that it is about to receive boxes from this protocol by invoking L{IBoxReceiver.startReceivingBoxes}. N)r� r� rw �connectionMade�r� r� ra ra rg r� " s z BinaryBoxProtocol.makeConnectionc C s2 | j rd| _ | jdur| j�|� dS t�| |�S )zg Either parse incoming data as L{AmpBox}es or relay it to our nested protocol. FN)�_justStartedTLSr� r� r )r� �datara ra rg r� + s z BinaryBoxProtocol.dataReceivedc C sv | j dur| j �|� | jdur| j�d|� | jr$ttdddd��}n|�t�r1| j r1t d�}n|}| j � |� dS )zF The connection was lost; notify any nested protocol. NTFz4Peer rejected our certificate for an unknown reason.) r� �connectionLostr� �clientConnectionLost�_keyLengthLimitExceededr! rT r� r r� r r� rz )r� ry � failReasonra ra rg r� 9 s �z BinaryBoxProtocol.connectionLostr] r^ c C s t � | _| �|�S )z6 String received in the 'init' state. )r+ � _currentBox� proto_key�r� r� ra ra rg � proto_initY s z BinaryBoxProtocol.proto_initc C s. |r || _ | j| _dS | j�| j� d| _dS )zu String received in the 'key' state. If the key is empty, a complete box has been received. r� N�init)� _currentKey�_MAX_VALUE_LENGTH� MAX_LENGTHr� rx r� r� ra ra rg r� ` s zBinaryBoxProtocol.proto_keyc C s || j | j< d| _| j| _dS )z7 String received in the 'value' state. Nr� )r� r� �_MAX_KEY_LENGTHr r� ra ra rg � proto_valuen s z BinaryBoxProtocol.proto_valuec C s d| _ | j�� dS )z� The key length limit was exceeded. Disconnect the transport and make sure a meaningful exception is reported. TN)r� r� r� )r� �lengthra ra rg �lengthLimitExceededw s z%BinaryBoxProtocol.lengthLimitExceededc C s d| _ dS )a Lock this binary protocol so that no further boxes may be sent. This is used when sending a request to switch underlying protocols. You probably want to subclass ProtocolSwitchCommand rather than calling this directly. TN)r� r� ra ra rg r� r� z BinaryBoxProtocol._lockForSwitchc C s | j dur td��d| _dS )z� Unlock this locked binary protocol so that further boxes may be sent again. This is used after an attempt to switch protocols has failed for some reason. Nz*Protocol already switched. Cannot unlock.F)r� rN r� r� ra ra rg r� � s z#BinaryBoxProtocol._unlockFromSwitchc C s. g | _ | jdurtd| j| j||ff ��dS )z� Used by StartTLSCommand to put us into the state where we don't actually send things that get sent, instead we buffer them. see L{_sendBoxCommand}. NzUPreviously authenticated connection between %s and %s is trying to re-establish as %s)r� �hostCertificaterI �peerCertificate)r� r� �verifyAuthoritiesra ra rg r� � s ����z BinaryBoxProtocol._prepareTLSc C sZ || _ d| _|du r d}| j�|j|� � | j}|dur)d| _|D ] }| �|� q!dS dS )a< Used by TLSBox to initiate the SSL handshake. @param certificate: a L{twisted.internet.ssl.PrivateCertificate} for use locally. @param verifyAuthorities: L{twisted.internet.ssl.Certificate} instances representing certificate authorities which will verify our peer. TNra )r r� r� �startTLSr� r� rq )r� r� r �stlsbrp ra ra rg r� � s �zBinaryBoxProtocol._startTLSc C s | j rd S t�| j�S r� )�noPeerCertificater% �peerFromTransportr� r� ra ra rg r � s z!BinaryBoxProtocol.peerCertificatec C s( t �|d� | jdur| j�� dS dS )zv The buck stops here. This error was completely unhandled, time to terminate the connection. z�Amp server or network failure unhandled by client application. Dropping connection! To avoid, add errbacks to ALL remote commands!N)r r� r� r� r� ra ra rg rs � s � �z BinaryBoxProtocol.unhandledErrorc C s i S )aX The default TLS responder doesn't specify any certificate or anything. From a security perspective, it's little better than a plain-text connection - but it is still a *bit* better, so it's included for convenience. You probably want to override this by providing your own StartTLS.responder. ra r� ra ra rg �_defaultStartTLSResponder� s z+BinaryBoxProtocol._defaultStartTLSResponderr� )(rk rl rm rn r� r� r� r� r� r� r r r� r r r� r� r� r� rq r� r� r� r r r r� r� r r r� r� r� r� r� r rs r rR r ra ra ra rg r0 � sD r0 c @ sD e Zd ZdZdZddd�Zdd� Zdefd d �Zd d � Z d d� Z dS )r( za This protocol is an AMP connection. See the module docstring for protocol details. FNc C s: d| _ |d u r | }|d u r| }t�| |� t�| |� d S r� )�_ampInitializedr3 r� r0 )r� r� r� ra ra rg r� � s z AMP.__init__c C s( t �| |�}|dur |S t�| |�}|S )z� Unify the implementations of L{CommandLocator} and L{SimpleStringLocator} to perform both kinds of dispatch, preferring L{CommandLocator}. @type name: C{bytes} N)r6 r| rQ )r� rc �firstResponder�secondResponderra ra rg r| � s zAMP.locateResponderr� c C s< | j dur d| j ��}nd}d| jj� |� dt| �d�d�S )zo A verbose string representation which gives us information about this AMP connection. Nz inner r� �<z at 0x�x�>)r� r� rk �id)r� � innerReprra ra rg r� s z AMP.__repr__c C sP | j st�| � |�� | _|�� | _t�d| j j | j| jf � t � | |� dS )zI Emit a helpful log message when the connection is made. z+%s connection established (HOST:%s PEER:%s)N) r r( r� r� �_transportPeer�getHost�_transportHostr �msgr� rk r0 r� r� ra ra rg r� s ��zAMP.makeConnectionc C s2 t �d| jj| j| jf � t�| |� d| _dS )zI Emit a helpful log message when the connection is lost. z$%s connection lost (HOST:%s PEER:%s)N) r r r� rk r r r0 r� r� r� ra ra rg r� s �� zAMP.connectionLost)NN) rk rl rm rn r r� r| r� r� r� r� ra ra ra rg r( � s r( c @ sT e Zd ZdZdd� Zdd� Zdd� ZdZd d � Zd d � Z e d d� �Z e dd� �Z dS )� _ParserHelperz: A box receiver which records all boxes received. c C s g | _ d S r� )r� r� ra ra rg r� . rp z_ParserHelper.__init__c C r` �Nr� ra r� ra ra rg r� 1 rs z_ParserHelper.getPeerc C r` r ra r� ra ra rg r 4 rs z_ParserHelper.getHostFc C r` )z0 No initialization is required. Nra )r� �senderra ra rg rw 9 ri z!_ParserHelper.startReceivingBoxesc C s | j �|� d S r� )r� r� r ra ra rg rx > s z _ParserHelper.ampBoxReceivedc C s. | � }t |d�}|�|� |�|�� � |jS )z� Parse some amp data stored in a file. @param fileObj: a file-like object. @return: a list of AmpBoxes encoded in the given file. )r� )r0 r� r� �readr� )r �fileObj� parserHelper�bbpra ra rg r[ B s z_ParserHelper.parsec C s | � t|��S )z� Parse some amp data stored in a string. @param data: a str holding some amp-encoded data. @return: a list of AmpBoxes encoded in the given string. )r[ r )r r� ra ra rg r\ Q s z_ParserHelper.parseStringN) rk rl rm rn r� r� r � disconnectingrw rx r� r[ r\ ra ra ra rg r ) s r c C s. i }| � � }|D ] \}}|�||||� q|S )a~ Convert an AmpBox to a dictionary of python objects, converting through a given arglist. @param strings: an AmpBox (or dict of strings) @param arglist: a list of 2-tuples of strings and Argument objects, as described in L{Command.arguments}. @param proto: an L{AMP} instance. @return: the converted dictionary mapping names to argument objects. )r� rh )rd �arglistrf re � myStrings�argname� argparserra ra rg r� a s r� c C s* | � � }|D ] \}}|�||||� q|S )a- Convert a dictionary of python objects to an AmpBox, converting through a given arglist. @param objects: a dict mapping names to python objects @param arglist: a list of 2-tuples of strings and Argument objects, as described in L{Command.arguments}. @param strings: [OUT PARAMETER] An object providing the L{dict} interface which will be populated with serialized data. @param proto: an L{AMP} instance. @return: The converted dictionary mapping names to encoded argument strings (identical to C{strings}). )r� rj )re r" rd rf � myObjectsr$ r% ra ra rg r� v s r� c @ r_ )r7 a� Encodes C{decimal.Decimal} instances. There are several ways in which a decimal value might be encoded. Special values are encoded as special strings:: - Positive infinity is encoded as C{"Infinity"} - Negative infinity is encoded as C{"-Infinity"} - Quiet not-a-number is encoded as either C{"NaN"} or C{"-NaN"} - Signalling not-a-number is encoded as either C{"sNaN"} or C{"-sNaN"} Normal values are encoded using the base ten string representation, using engineering notation to indicate magnitude without precision, and "normal" digits to indicate precision. For example:: - C{"1"} represents the value I{1} with precision to one place. - C{"-1"} represents the value I{-1} with precision to one place. - C{"1.0"} represents the value I{1} with precision to two places. - C{"10"} represents the value I{10} with precision to two places. - C{"1E+2"} represents the value I{10} with precision to one place. - C{"1E-1"} represents the value I{0.1} with precision to one place. - C{"1.5E+2"} represents the value I{15} with precision to two places. U{http://speleotrove.com/decimal/} should be considered the authoritative specification for the format. c C s t |�}t�|�S r� )r �decimalr7 rl ra ra rg rf � s zDecimal.fromStringc C s" t |tj�r t|��d�S td��)zW Serialize a C{decimal.Decimal} instance to the specified wire format. r� z8amp.Decimal can only encode instances of decimal.Decimal)r� r' r7 r� r� rw rm ra ra rg ri � s zDecimal.toStringNrz ra ra ra rg r7 � s r7 c @ sl e Zd ZdZedd�edd�edd�edd �ed d �ed d �edd�edd�edd�g Zdd� Zdd� ZdS )�DateTimeaO Encodes C{datetime.datetime} instances. Wire format: '%04i-%02i-%02iT%02i:%02i:%02i.%06i%s%02i:%02i'. Fields in order are: year, month, day, hour, minute, second, microsecond, timezone direction (+ or -), timezone hour, timezone minute. Encoded string is always exactly 32 characters long. This format is compatible with ISO 8601, but that does not mean all ISO 8601 dates can be accepted. Also, note that the datetime module's notion of a "timezone" can be complex, but the wire format includes only a fixed offset, so the conversion is not lossless. A lossless transmission of a C{datetime} instance is not feasible since the receiving end would require a Python interpreter. @ivar _positions: A sequence of slices giving the positions of various interesting parts of the wire format. r � � � � � � � � � � � � � � � � � c sp t � �� t� �dkrtd� ����� fdd�| jD �}� d }tj|g|dd� �R � }|g|dd�< tj|� S )z| Parse a string containing a date and time in the wire format into a C{datetime.datetime} instance. r9 zinvalid date format c s g | ]}t � | ��qS ra )rq )r� �p��sra rg r� � s z'DateTime.fromString.<locals>.<listcomp>r5 r+ N)r r� rw � _positions�_FixedOffsetTZInfo�fromSignHoursMinutes�datetime)r� r< r� �sign�timezonera r; rg rf � s zDateTime.fromStringc C s� |� � }|du r td��|jd |j d }|dkr d}nd}d|j|j|j|j|j|j |j |t |�d t |�d f }|� d �S ) zm Serialize a C{datetime.datetime} instance to a string in the specified wire format. NzUamp.DateTime cannot serialize naive datetime instances. You may find amp.utc useful.i�Q �< r �+�-z-%04i-%02i-%02iT%02i:%02i:%02i.%06i%s%02i:%02ir� ) � utcoffsetrw �days�seconds�year�month�day�hour�minute�second� microsecond�absr� )r� r� �offset� minutesOffsetrA �packedra ra rg ri � s, � � zDateTime.toStringN)rk rl rm rn �slicer= rf ri ra ra ra rg r( � s � r( )�rn r@ r' r � functoolsr �ior � itertoolsr �structr �typesr �typingr r r r r r r r �zope.interfacer r �twisted.internet.deferr r r �twisted.internet.errorr r r �twisted.internet.interfacesr �twisted.internet.mainr �twisted.internet.protocolr �twisted.protocols.basicr r �twisted.pythonr r �twisted.python._tzhelperr rX r r> �twisted.python.compatr �twisted.python.failurer! �twisted.python.reflectr" �twisted.internetr# �_ssl� supported�twisted.internet.sslr$ r% r& r' � ImportError�__all__r* r) r4 r9 r: r; rV rU rE rF r= r? r> r@ r� r, rN rI rH rC rT r/ rP rZ rG rW rA rJ r� r+ r2 rO r� r3 r� r r6 rQ rK rZ r. rB rS r< r1 rY rL rD r- r8 r� r5 r� r� r� rR rM r� r0 r( r r[ r\ r� r� r7 r( ra ra ra rg �<module> s� @ ( � �9@ 4 `" 3,W! 8.A7 `8 E6/ � $M4+PK Mb�Zga�BZ BZ . protocols/__pycache__/memcache.cpython-310.pycnu �[��� o �bc\ � @ s� d Z ddlmZ ddlmZmZmZ ddlmZ ddl m Z ddl m Z ddl mZmZ dZG d d � d e�ZG d d � d e�ZG d d� de�ZG dd� d�ZG dd� dee �Zg d�ZdS )ap Memcache client protocol. Memcached is a caching server, storing data in the form of pairs key/value, and memcache is the protocol to talk with it. To connect to a server, create a factory for L{MemCacheProtocol}:: from twisted.internet import reactor, protocol from twisted.protocols.memcache import MemCacheProtocol, DEFAULT_PORT d = protocol.ClientCreator(reactor, MemCacheProtocol ).connectTCP("localhost", DEFAULT_PORT) def doSomething(proto): # Here you call the memcache operations return proto.set("mykey", "a lot of data") d.addCallback(doSomething) reactor.run() All the operations of the memcache protocol are present, but L{MemCacheProtocol.set} and L{MemCacheProtocol.get} are the more important. See U{http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt} for more information about the protocol. � )�deque)�Deferred� TimeoutError�fail)� LineReceiver)� TimeoutMixin)�log)� nativeString� networkStringi�+ c @ � e Zd ZdZdS )� NoSuchCommandzA Exception raised when a non existent command is called. N��__name__� __module__� __qualname__�__doc__� r r �</usr/lib/python3/dist-packages/twisted/protocols/memcache.pyr ( � r c @ r )� ClientErrorz1 Error caused by an invalid client call. Nr r r r r r . r r c @ r )� ServerErrorz* Problem happening on the server. Nr r r r r r 4 r r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �Commanda8 Wrap a client action into an object, that holds the values used in the protocol. @ivar _deferred: the L{Deferred} object that will be fired when the result arrives. @type _deferred: L{Deferred} @ivar command: name of the command sent to the server. @type command: L{bytes} c K s0 || _ t� | _|�� D ] \}}t| ||� q dS )z� Create a command. @param command: the name of the command. @type command: L{bytes} @param kwargs: this values will be stored as attributes of the object for future use N)�commandr � _deferred�items�setattr)�selfr �kwargs�k�vr r r �__init__G s �zCommand.__init__c C � | j �|� dS )zB Shortcut method to fire the underlying deferred. N)r �callback)r �valuer r r �successV � zCommand.successc C r! )z5 Make the underlying deferred fails. N)r �errback)r �errorr r r r \ r% z Command.failN)r r r r r r$ r r r r r r : s r c @ sT e Zd ZdZdZdZdRdd�Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� ZdSd.d/�ZdSd0d1�Zd2d3� Z dTd5d6�Z dTd7d8�Z dTd9d:�Z dTd;d<�Z d=d>� Z!d?d@� Z"dAdB� Z#dUdCdD�Z$dUdEdF�Z%dGdH� Z&dVdJdK�Z'dLdM� Z(dNdO� Z)dPdQ� Z*dIS )W�MemCacheProtocola1 MemCache protocol: connect to a memcached server to store/retrieve values. @ivar persistentTimeOut: the timeout period used to wait for a response. @type persistentTimeOut: L{int} @ivar _current: current list of requests waiting for an answer from the server. @type _current: L{deque} of L{Command} @ivar _lenExpected: amount of data expected in raw mode, when reading for a value. @type _lenExpected: L{int} @ivar _getBuffer: current buffer of data, used to store temporary data when reading in raw mode. @type _getBuffer: L{list} @ivar _bufferLength: the total amount of bytes in C{_getBuffer}. @type _bufferLength: L{int} @ivar _disconnected: indicate if the connectionLost has been called or not. @type _disconnected: L{bool} � F�< c C s* t � | _d| _d| _d| _| | _| _dS )z� Create the protocol. @param timeOut: the timeout to wait before detecting that the connection is dead and close it. It's expressed in seconds. @type timeOut: L{int} N)r �_current� _lenExpected� _getBuffer� _bufferLength�persistentTimeOut�timeOut)r r0 r r r r � s zMemCacheProtocol.__init__c C s( | j r| j �� }|�|� | j sdS dS )zW Cancel all the outstanding commands, making them fail with C{reason}. N)r+ �popleftr )r �reason�cmdr r r �_cancelCommands� s �z MemCacheProtocol._cancelCommandsc C s | � td�� | j�� dS )z: Close the connection in case of timeout. zConnection timeoutN)r4 r � transport�loseConnection�r r r r �timeoutConnection� s z"MemCacheProtocol.timeoutConnectionc C s d| _ | �|� t�| |� dS )z9 Cause any outstanding commands to fail. TN)� _disconnectedr4 r �connectionLost)r r2 r r r r: � s z MemCacheProtocol.connectionLostc C s" | j s | �| j� t�| |� dS )zA Override sendLine to add a timeout to response. N)r+ � setTimeoutr/ r �sendLine)r �liner r r r< � s zMemCacheProtocol.sendLinec C s� | � � | j�|� | jt|�7 _| j| jd kr`d�| j�}|d| j� }|| jd d� }|}d| _d| _d| _| jd }|jrV|j |j \}}|||f|j |j < n||_ | � |� dS dS )z) Collect data for a get. � � Nr ) � resetTimeoutr- �appendr. �lenr, �joinr+ �multiple�values� currentKeyr# � setLineMode)r �data�buf�rem�valr3 �flags�casr r r �rawDataReceived� s$ �z MemCacheProtocol.rawDataReceivedc C � | j �� �d� dS )z? Manage a success response to a set operation. TN�r+ r1 r$ r7 r r r � cmd_STORED� � zMemCacheProtocol.cmd_STOREDc C rO )z� Manage a specific 'not stored' response to a set operation: this is not an error, but some condition wasn't met. FNrP r7 r r r �cmd_NOT_STORED� s z MemCacheProtocol.cmd_NOT_STOREDc C s� | j �� }|jdkr)|jr dd� |j�� D �}|�|� dS |�|j|jf� dS |jdkrF|jr9|�|j� dS |�|j|j |jf� dS |jdkrS|�|j� dS t d� t |j����)zB This the end token to a get or a stat operation. � getc S s i | ] \}}||d d d� �qS )Nr> r )�.0�keyrK r r r � <dictcomp>� s z,MemCacheProtocol.cmd_END.<locals>.<dictcomp>� gets� statsz%Unexpected END response to {} commandN) r+ r1 r rD rE r r$ rL r# rM � RuntimeError�formatr )r r3 rE r r r �cmd_END� s" ��zMemCacheProtocol.cmd_ENDc C rO )z= Manage error response for incr/decr/delete. FNrP r7 r r r � cmd_NOT_FOUND� rR z MemCacheProtocol.cmd_NOT_FOUNDc C s� | j d }|jdkr|�� \}}}d}n|�� \}}}}t|�| _g | _d| _|jr@||jvr3t d��||_ t|�|g|j |< n|j |krIt d��t|�|_ ||_| �� dS )z: Prepare the reading a value after a get. r rT r? zUnexpected commands answer.N)r+ r �split�intr, r- r. rD �keysrZ rF rE rV rL rM � setRawMode)r r= r3 rV rL �lengthrM r r r � cmd_VALUE� s$ zMemCacheProtocol.cmd_VALUEc C s( | j d }|�dd�\}}||j|< dS )z- Reception of one stat line. r � � N)r+ r^ rE )r r= r3 rV rK r r r �cmd_STAT s zMemCacheProtocol.cmd_STATc C s | j �� �|� dS )z% Read version token. NrP )r � versionDatar r r � cmd_VERSION rR z MemCacheProtocol.cmd_VERSIONc C s$ t �d� | j�� }|�t� � dS )z7 A non-existent command has been sent. zNon-existent command sent.N)r �errr+ r1 r r )r r3 r r r � cmd_ERROR s zMemCacheProtocol.cmd_ERRORc C �2 t |�}t�d| � | j�� }|�t|�� dS )z0 An invalid input as been sent. zInvalid input: N)�reprr ri r+ r1 r r �r �errTextr3 r r r �cmd_CLIENT_ERROR � z!MemCacheProtocol.cmd_CLIENT_ERRORc C rk )z4 An error has happened server-side. zServer error: N)rl r ri r+ r1 r r rm r r r �cmd_SERVER_ERROR( rp z!MemCacheProtocol.cmd_SERVER_ERRORc C rO )z> A delete command has completed successfully. TNrP r7 r r r � cmd_DELETED1 rR z MemCacheProtocol.cmd_DELETEDc C rO )z6 The last command has been completed. TNrP r7 r r r �cmd_OK7 rR zMemCacheProtocol.cmd_OKc C rO )z5 A C{checkAndSet} update has failed. FNrP r7 r r r � cmd_EXISTS= rR zMemCacheProtocol.cmd_EXISTSc C s� | � � |�dd�d }t| dt|� d�}|dur1|�dd�dd� }|r-||d � n*|� n&|�dd�}t| dt|� d�}|durI|� n| j�� }t|�}|�|� | jsa| � d� dS dS )z8 Receive line commands from the server. rd re r �cmd_N� _) r@ r^ �getattrr �replacer+ r1 r_ r$ r; )r r= �tokenr3 �argsrK r r r � lineReceivedC s$ �z MemCacheProtocol.lineReceivedre c C � | � d||�S )a� Increment the value of C{key} by given value (default to 1). C{key} must be consistent with an int. Return the new value. @param key: the key to modify. @type key: L{bytes} @param val: the value to increment. @type val: L{int} @return: a deferred with will be called back with the new value associated with the key (after the increment). @rtype: L{Deferred} s incr�� _incrdecr�r rV rK r r r � increment` s zMemCacheProtocol.incrementc C r| )a� Decrement the value of C{key} by given value (default to 1). C{key} must be consistent with an int. Return the new value, coerced to 0 if negative. @param key: the key to modify. @type key: L{bytes} @param val: the value to decrement. @type val: L{int} @return: a deferred with will be called back with the new value associated with the key (after the decrement). @rtype: L{Deferred} s decrr} r r r r � decrementq s zMemCacheProtocol.decrementc C s� | j r ttd��S t|t�sttdt|�� d���S t|�| jkr'ttd��S d� ||dt |�f g�}| � |� t ||d�}| j �|� |jS )z1 Internal wrapper for incr/decr. � not connected�Invalid type for key: �, expecting bytes� Key too longrd s %d�rV )r9 r rZ � isinstance�bytesr �typerB �MAX_KEY_LENGTHrC r_ r< r r+ rA r )r r3 rV rK �fullcmd�cmdObjr r r r~ � s � zMemCacheProtocol._incrdecrr c C � | � d||||d�S )a� Replace the given C{key}. It must already exist in the server. @param key: the key to replace. @type key: L{bytes} @param val: the new value associated with the key. @type val: L{bytes} @param flags: the flags to store with the key. @type flags: L{int} @param expireTime: if different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: a deferred that will fire with C{True} if the operation has succeeded, and C{False} with the key didn't previously exist. @rtype: L{Deferred} s replacer? ��_set�r rV rK rL � expireTimer r r rx � � zMemCacheProtocol.replacec C r� )a� Add the given C{key}. It must not exist in the server. @param key: the key to add. @type key: L{bytes} @param val: the value associated with the key. @type val: L{bytes} @param flags: the flags to store with the key. @type flags: L{int} @param expireTime: if different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: a deferred that will fire with C{True} if the operation has succeeded, and C{False} with the key already exists. @rtype: L{Deferred} s addr? r� r� r r r �add� r� zMemCacheProtocol.addc C r� )a9 Set the given C{key}. @param key: the key to set. @type key: L{bytes} @param val: the value associated with the key. @type val: L{bytes} @param flags: the flags to store with the key. @type flags: L{int} @param expireTime: if different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: a deferred that will fire with C{True} if the operation has succeeded. @rtype: L{Deferred} s setr? r� r� r r r �set� r� zMemCacheProtocol.setc C s | � d|||||�S )am Change the content of C{key} only if the C{cas} value matches the current one associated with the key. Use this to store a value which hasn't been modified since last time you fetched it. @param key: The key to set. @type key: L{bytes} @param val: The value associated with the key. @type val: L{bytes} @param cas: Unique 64-bit value returned by previous call of C{get}. @type cas: L{bytes} @param flags: The flags to store with the key. @type flags: L{int} @param expireTime: If different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: A deferred that will fire with C{True} if the operation has succeeded, C{False} otherwise. @rtype: L{Deferred} s casr� )r rV rK rM rL r� r r r � checkAndSet� s z MemCacheProtocol.checkAndSetc C s� | j r ttd��S t|t�sttdt|�� d���S t|�| jkr'ttd��S t|t�s8ttdt|�� d���S |r>d| }t|�}d� ||t d|||f �g�| }| � |� | � |� t ||||d�} | j �| � | jS ) z6 Internal wrapper for setting values. r� r� r� r� zInvalid type for value: rd z%d %d %d)rV rL rb )r9 r rZ r� r� r r� rB r� rC r r< r r+ rA r ) r r3 rV rK rL r� rM rb r� r� r r r r� � s4 � ���� zMemCacheProtocol._setc C � | � d||ddd�S )a� Append given data to the value of an existing key. @param key: The key to modify. @type key: L{bytes} @param val: The value to append to the current value associated with the key. @type val: L{bytes} @return: A deferred that will fire with C{True} if the operation has succeeded, C{False} otherwise. @rtype: L{Deferred} s appendr r? r� r r r r rA � zMemCacheProtocol.appendc C r� )a� Prepend given data to the value of an existing key. @param key: The key to modify. @type key: L{bytes} @param val: The value to prepend to the current value associated with the key. @type val: L{bytes} @return: A deferred that will fire with C{True} if the operation has succeeded, C{False} otherwise. @rtype: L{Deferred} s prependr r? r� r r r r �prepend' r� zMemCacheProtocol.prependc C s | � |g|d�S )a� Get the given C{key}. It doesn't support multiple keys. If C{withIdentifier} is set to C{True}, the command issued is a C{gets}, that will return the current identifier associated with the value. This identifier has to be used when issuing C{checkAndSet} update later, using the corresponding method. @param key: The key to retrieve. @type key: L{bytes} @param withIdentifier: If set to C{True}, retrieve the current identifier along with the value and the flags. @type withIdentifier: L{bool} @return: A deferred that will fire with the tuple (flags, value) if C{withIdentifier} is C{False}, or (flags, cas identifier, value) if C{True}. If the server indicates there is no value associated with C{key}, the returned value will be L{None} and the returned flags will be C{0}. @rtype: L{Deferred} F��_get)r rV �withIdentifierr r r �get9 s zMemCacheProtocol.getc C s | � ||d�S )a Get the given list of C{keys}. If C{withIdentifier} is set to C{True}, the command issued is a C{gets}, that will return the identifiers associated with each values. This identifier has to be used when issuing C{checkAndSet} update later, using the corresponding method. @param keys: The keys to retrieve. @type keys: L{list} of L{bytes} @param withIdentifier: If set to C{True}, retrieve the identifiers along with the values and the flags. @type withIdentifier: L{bool} @return: A deferred that will fire with a dictionary with the elements of C{keys} as keys and the tuples (flags, value) as values if C{withIdentifier} is C{False}, or (flags, cas identifier, value) if C{True}. If the server indicates there is no value associated with C{key}, the returned values will be L{None} and the returned flags will be C{0}. @rtype: L{Deferred} @since: 9.0 Tr� )r r` r� r r r � getMultipleQ s z MemCacheProtocol.getMultiplec C s� t |�}| jr ttd��S |D ]$}t|t�s$ttdt|�� d��� S t|�| j kr3ttd�� S q|r9d}nd}d� |g| �}| � |� |rZdd � |D �}t |||d d �}n t ||d d d ddd�}| j �|� |jS )z> Helper method for C{get} and C{getMultiple}. r� r� r� r� rX rT rd c S s i | ]}|d �qS ))r r? Nr )rU rV r r r rW � s z)MemCacheProtocol._get.<locals>.<dictcomp>T)r` rE rD r Nr? F)rV r# rL rM rD )�listr9 r rZ r� r� r r� rB r� rC r< r r+ rA r ) r r` r� rD rV r3 r� rE r� r r r r� k s0 �� � zMemCacheProtocol._getNc C sL |rd| }nd}| j rttd��S | �|� tdi d�}| j�|� |jS )a� Get some stats from the server. It will be available as a dict. @param arg: An optional additional string which will be sent along with the I{stats} command. The interpretation of this value by the server is left undefined by the memcache protocol specification. @type arg: L{None} or L{bytes} @return: a deferred that will fire with a L{dict} of the available statistics. @rtype: L{Deferred} s stats rY r� )rE �r9 r rZ r< r r+ rA r )r �argr3 r� r r r �stats� s zMemCacheProtocol.statsc C �6 | j r ttd��S | �d� td�}| j�|� |jS )z� Get the version of the server. @return: a deferred that will fire with the string value of the version. @rtype: L{Deferred} r� s versionr� �r r� r r r �version� � zMemCacheProtocol.versionc C s` | j r ttd��S t|t�sttdt|�� d���S | �d| � td|d�}| j � |� |j S )a Delete an existing C{key}. @param key: the key to delete. @type key: L{bytes} @return: a deferred that will be called back with C{True} if the key was successfully deleted, or C{False} if not. @rtype: L{Deferred} r� r� r� s delete s deleter� ) r9 r rZ r� r� r r� r< r r+ rA r )r rV r� r r r �delete� s � zMemCacheProtocol.deletec C r� )z� Flush all cached values. @return: a deferred that will be called back with C{True} when the operation has succeeded. @rtype: L{Deferred} r� s flush_allr� r� r r r �flushAll� r� zMemCacheProtocol.flushAll)r* )re )r r )F)N)+r r r r r� r9 r r4 r8 r: r< rN rQ rS r\ r] rc rf rh rj ro rq rr rs rt r{ r� r� r~ rx r� r� r� r� rA r� r� r� r� r� r� r� r� r r r r r( c sR r( )r( � DEFAULT_PORTr r r N)r � collectionsr �twisted.internet.deferr r r �twisted.protocols.basicr �twisted.protocols.policiesr �twisted.pythonr �twisted.python.compatr r r� � Exceptionr r r r r( �__all__r r r r �<module> s$ ) xPK Mb�Zn1�" " + protocols/__pycache__/ident.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlmZ ddlmZ ddlmZmZ dZ dZ G dd � d e �Z G d d � d e �Z G d d � d e �ZG dd� de �ZG dd� dej�ZG dd� d�ZG dd� dej�Zg d�ZdS )z Ident protocol implementation. � N)�defer)�basic)�failure�log� i�� c @ s" e Zd ZdZdZdefdd�ZdS )� IdentErrorz; Can't determine connection owner; reason unknown. z UNKNOWN-ERROR�returnc C s | j S �N)�identDescription��self� r �9/usr/lib/python3/dist-packages/twisted/protocols/ident.py�__str__ � zIdentError.__str__N)�__name__� __module__� __qualname__�__doc__r �strr r r r r r s r c @ � e Zd ZdZdZdS )�NoUserz� The connection specified by the port pair is not currently in use or currently not owned by an identifiable entity. zNO-USERN�r r r r r r r r r r � r c @ r )� InvalidPorta Either the local or foreign port was improperly specified. This should be returned if either or both of the port ids were out of range (TCP port numbers are from 1-65535), negative integers, reals or in any fashion not recognized as a non-negative integer. z INVALID-PORTNr r r r r r ' s r c @ r )� HiddenUserz� The server was able to identify the user of this port, but the information was not returned at the request of the user. z HIDDEN-USERNr r r r r r 2 r r c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� IdentServera� The Identification Protocol (a.k.a., "ident", a.k.a., "the Ident Protocol") provides a means to determine the identity of a user of a particular TCP connection. Given a TCP port number pair, it returns a character string which identifies the owner of that connection on the server's system. Server authors should subclass this class and override the lookup method. The default implementation returns an UNKNOWN-ERROR response for every query. c C s� |� d�}t|�dkr| �� d S z tt|�\}}W n ty( | �� Y d S w t| kr3tkrIn nt| kr?tkrIn n| �||� d S | � t � t � �||� d S )N�,� ) �split�len� invalidQuery�map�int� ValueError� _MIN_PORT� _MAX_PORT� validQuery� _ebLookupr �Failurer )r �line�parts� portOnServer� portOnClientr r r � lineReceivedH s ��zIdentServer.lineReceivedc C s | j �� d S r )� transport�loseConnectionr r r r r! \ s zIdentServer.invalidQueryc C sL | j �� j|f}| j �� j|f}t�| j||��| j||�� | j ||� dS )z� Called when a valid query is received to look up and deliver the response. @param portOnServer: The server port from the query. @param portOnClient: The client port from the query. N) r/ �getHost�host�getPeerr � maybeDeferred�lookup� addCallback� _cbLookup� addErrbackr( )r r, r- � serverAddr� clientAddrr r r r' _ s �zIdentServer.validQueryc C s" |\}}| � d||||f � d S )Nz%d, %d : USERID : %s : %s)�sendLine)r �result�sport�cport�sysName�userIdr r r r7 m s zIdentServer._cbLookupc C sL |� t�r| �d|||jf � d S t�|� | �d||t|j�f � d S )Nz%d, %d : ERROR : %s)�checkr r; �valuer �err)r r r= r> r r r r( q s �zIdentServer._ebLookupc C � t � �)aq Lookup user information about the specified address pair. Return value should be a two-tuple of system name and username. Acceptable values for the system name may be found online at:: U{http://www.iana.org/assignments/operating-system-names} This method may also raise any IdentError subclass (or IdentError itself) to indicate user information will not be provided for the given query. A Deferred may also be returned. @param serverAddress: A two-tuple representing the server endpoint of the address being queried. The first element is a string holding a dotted-quad IP address. The second element is an integer representing the port. @param clientAddress: Like I{serverAddress}, but represents the client endpoint of the address being queried. �r )r � serverAddress� clientAddressr r r r5 z s zIdentServer.lookupN) r r r r r. r! r' r7 r( r5 r r r r r ; s r c @ sx e Zd ZdZdZzddlmZ efdd�Z[W n ey% ddd�ZY nw d d � Z d d � Z d d� Z dd� Z dd� Z dS )�ProcServerMixinzDImplements lookup() to grab entries for responses from /proc/net/tcp�LINUXr )�getpwuidc C s ||�d S �Nr r �r �uidrJ r r r � getUsername� s zProcServerMixin.getUsernameNc C rD r rE rL r r r rN � r c c sL � t d��}|�� |D ]}|�� V q W d � d S 1 s w Y d S )Nz /proc/net/tcp)�open�readline�strip)r �f�Lr r r �entries� s � �"�zProcServerMixin.entriesc C s& d� ttt�dt�dt|d�����S )N�.�4Bz=L� )�joinr" r �struct�unpack�packr# )r �hexstrr r r �dottedQuadFromHexString� s �z'ProcServerMixin.dottedQuadFromHexStringc C s* |� d�\}}| �|�}t|d�}||fS )N�:rW )r r] r# )r �packed�addr�portr r r � unpackAddress� s z ProcServerMixin.unpackAddressc C sN |� � �� }| �|d �\}}| �|d �\}}t|d �}||f||f|fS )Nr r � )rQ r rb r# )r r* r+ � localAddr� localPort� remoteAddr� remotePortrM r r r � parseLine� s zProcServerMixin.parseLinec C sP | � � D ] }| �|�\}}}||kr$|d |d kr$| j| �|�f S qt� �)Nr )rT rh � SYSTEM_NAMErN r )r rF rG �entrd rf rM r r r r5 � s �zProcServerMixin.lookupr )r r r r ri �pwdrJ rN � ImportErrorrT r] rb rh r5 r r r r rH � s � rH c @ s@ e Zd ZeeeefZdd� Zdd� Z dd� Z dd� Z d d � Z d S ) � IdentClientc C s g | _ d S r )�queriesr r r r �__init__� s zIdentClient.__init__c C sR | j �t�� ||f� t| j �dkr| j d d S | �d||f � | j d d S )zK Lookup user information about the specified address pair. r ���r �%d, %d)rn �appendr �Deferredr r; )r r, r- r r r r5 � s zIdentClient.lookupc C sl | j s t�d|��� d S | j �d�\}}}| �||� | j r4| �d| j d d | j d d f � d S d S )Nz Unexpected server response: r rq r r )rn r �msg�pop� parseResponser; )r r* �d�_r r r r. � s *�zIdentClient.lineReceivedc C s( | j D ] }|d �t|�� qg | _ d S rK )rn �errbackr )r �reason�qr r r �connectionLost� s zIdentClient.connectionLostc C s� |� dd�}t|�dkr|�t|�� d S ttj|�\}}}|dkr@| jD ]}|j|kr6|�||�� d S q%|�t|�� d S |� ||f� d S )Nr^ r � �ERROR) r r ry r r" r rQ � errorTypesr �callback)r �deferredr* r+ �ports�type�addInfo�etr r r rv � s �zIdentClient.parseResponseN) r r r r r r r r ro r5 r. r| rv r r r r rm � s rm )r r r r r rm rH )r rY �twisted.internetr �twisted.protocolsr �twisted.pythonr r r% r& � Exceptionr r r r �LineOnlyReceiverr rH rm �__all__r r r r �<module> s Y2 0PK Mb�Z��{� � ) protocols/__pycache__/pcp.cpython-310.pycnu �[��� o �b � @ sL d Z ddlmZ ddlmZ eejej�G dd� d��ZG dd� de�ZdS ) z Producer-Consumer Proxy. � )� implementer)� interfacesc @ sz e Zd ZdZdZdZdZdZdZdZ dZ dd� Z dd� Z d d � Z d d � Zd d� Zdd� Zdd� Zdd� Zdefdd�ZdS )�BasicProducerConsumerProxyaa I can act as a man in the middle between any Producer and Consumer. @ivar producer: the Producer I subscribe to. @type producer: L{IProducer<interfaces.IProducer>} @ivar consumer: the Consumer I publish to. @type consumer: L{IConsumer<interfaces.IConsumer>} @ivar paused: As a Producer, am I paused? @type paused: bool NTFc C s* g | _ |d ur|| _|�| | j� d S d S �N)�_buffer�consumer�registerProducer� iAmStreaming)�selfr � r �7/usr/lib/python3/dist-packages/twisted/protocols/pcp.py�__init__# s �z#BasicProducerConsumerProxy.__init__c C s d| _ | jr | j�� d S d S �NT)�paused�producer�pauseProducing�r r r r r + s �z)BasicProducerConsumerProxy.pauseProducingc C sX d| _ | jr| j�d�| j�� g | jd d �< n| js d| _| jd ur*| j�� d S d S )NF� T) r r r �write�joinr �outstandingPullr �resumeProducingr r r r r 0 s �z*BasicProducerConsumerProxy.resumeProducingc C s* | j d ur | j �� | jd ur| `d S d S r )r � stopProducingr r r r r r = s �z(BasicProducerConsumerProxy.stopProducingc C sF | j s | js| js| j�|� d S | jd ur!| j�|� d| _d S d S �NF)r r r r �appendr r �r �datar r r r E s �z BasicProducerConsumerProxy.writec C s | j d ur | j �� | �� d S r )r �finish�unregisterProducerr r r r r N s z!BasicProducerConsumerProxy.finishc C s || _ || _d S r )r �producerIsStreaming�r r � streamingr r r r S s z+BasicProducerConsumerProxy.registerProducerc C s* | j d ur | ` | `| jr| j�� d S d S r )r r r r r r r r r W s �z-BasicProducerConsumerProxy.unregisterProducer�returnc C s" d| j � dt| �d�d| j� d�S )N�<�@�xz around �>)� __class__�idr r r r r �__repr__^ s "z#BasicProducerConsumerProxy.__repr__)�__name__� __module__� __qualname__�__doc__r r r r r r �stoppedr r r r r r r r �strr) r r r r r s$ r c @ sL e Zd ZdZdZdZdZdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dS )�ProducerConsumerProxyz�ProducerConsumerProxy with a finite buffer. When my buffer fills up, I have my parent Producer pause until my buffer has room in it again. i Fc C s d| _ d S r )r r r r r r o s z$ProducerConsumerProxy.pauseProducingc C s� d| _ | jr5d�| j�}| �|�}|t|�k r-||d � }| jr$J d��|g| jd d �< n g | jd d �< nd}| jrI|rI| jsI| jd urI| j�� | jsP| | _ | j d ur{t dd� | jD ��}| j rq|| j k rqd| _ | j �� d S | j r}| j �� d S d S d S )NFr �.Streaming producer did not write all its data.r c s � � | ]}t |�V qd S r ��len��.0�sr r r � <genexpr>� � � z8ProducerConsumerProxy.resumeProducing.<locals>.<genexpr>)r r r �_writeSomeDatar4 r � unregisteredr r r r �sum�producerPaused� bufferSizer )r r � bytesSent�unsent� bytesBufferedr r r r t s@ ����� � z%ProducerConsumerProxy.resumeProducingc C s� | j s | js| js| j�|� n+| jd ur;| jr J d��| �|�}d| _|t|�ks;| jr1J d��| j�||d � � | jd ur\| j r^t dd� | jD ��}|| j kr`| j� � d| _ d S d S d S d S )Nz9Writing fresh data to consumer before my buffer is empty!Fr1 c s r2 r r3 r5 r r r r8 � r9 z.ProducerConsumerProxy.write.<locals>.<genexpr>T)r r r r r r r: r4 r r r< r> r r= )r r r? rA r r r r � s, �� �� �zProducerConsumerProxy.writec C s( d| _ t�| ||� |s|�� d S d S r )r; r r r r r r r r � s �z&ProducerConsumerProxy.registerProducerc C s: | j d ur | ` | `d| _| jr| js| j�� d S d S d S r )r r r; r r r r r r r r � s �z(ProducerConsumerProxy.unregisterProducerc C s" | j du rdS | j �|� t|�S )z`Write as much of this data as possible. @returns: The number of bytes written. Nr )r r r4 r r r r r: � s z$ProducerConsumerProxy._writeSomeDataN) r* r+ r, r- r> r= r; r r r r r r: r r r r r0 b s - r0 N) r- �zope.interfacer �twisted.internetr � IProducer� IConsumerr r0 r r r r �<module> s SPK Mb�Z�Q�� � / protocols/__pycache__/shoutcast.cpython-310.pycnu �[��� o �b� � @ s2 d Z ddlmZ ddlmZ G dd� dej�ZdS )z@ Chop up shoutcast stream into MP3s and metadata, if available. � )� copyright)�httpc @ s| e Zd ZdZdej Zd dd�Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zd S ) �ShoutcastClientz� Shoutcast HTTP stream. Modes can be 'length', 'meta' and 'mp3'. See U{http://www.smackfu.com/stuff/programming/shoutcast.html} for details on the protocol. zTwisted Shoutcast client �/c C s" || _ d| _d | _d| _d| _d S )NF�mp3� )�path� got_metadata�metaint�metamode� databuffer)�selfr � r �=/usr/lib/python3/dist-packages/twisted/protocols/shoutcast.py�__init__ s zShoutcastClient.__init__c C s4 | � d| j� | �d| j� | �dd� | �� d S )N�GETz User-Agentz Icy-MetaData�1)� sendCommandr � sendHeader� userAgent� endHeaders�r r r r �connectionMade s z ShoutcastClient.connectionMadec C s> | j s|rt|�dd��dkr|�ddd�}tj�| |� d S )Nz: � �:)� firstLine�len�split�replacer � HTTPClient� lineReceived)r �liner r r r % s z ShoutcastClient.lineReceivedc C s$ |� � dkrt|�| _d| _d S d S )Nz icy-metaintT)�lower�intr r )r �key�valuer r r � handleHeader, s �z ShoutcastClient.handleHeaderc C s | j r | j| _d S | j| _d S )N)r � handleResponsePart_with_metadata�handleResponsePart� gotMP3Datar r r r �handleEndHeaders1 s z ShoutcastClient.handleEndHeadersc C s< | j |7 _ | j r t| d| j �� }|rd S | j s d S d S )Nz handle_%s)r �getattrr )r �data�stopr r r r' ; s �z0ShoutcastClient.handleResponsePart_with_metadatac C s. t | jd �d | _| jdd � | _d| _d S )Nr � r �meta)�ordr � remainingr r r r r � handle_lengthB s z ShoutcastClient.handle_lengthc C sF t | j�| jkr!| �| jd | j� � | j| jd � | _d| _d S dS )N�lengthr )r r r r) r r r r r � handle_mp3G s zShoutcastClient.handle_mp3c C sV t | j�| jkr)| jr| jd | j� }| �| �|�� | j| jd � | _d| _d S dS )Nr r )r r r1 � gotMetaData� parseMetadatar �r r, r r r � handle_metaO s zShoutcastClient.handle_metac C sl g }|� d�D ],}|�� �dd�}|sq|� dd�\}}|�d�r,|�d�r,|dd� }|�||f� q|S )N�;� r �=r �'���)r �stripr � startswith�endswith�append)r r, r/ �chunkr$ r% r r r r6 Y s z ShoutcastClient.parseMetadatac C � t d��)z�Called with a list of (key, value) pairs of metadata, if metadata is available on the server. Will only be called on non-empty metadata. �implement in subclass��NotImplementedError)r �metadatar r r r5 e s zShoutcastClient.gotMetaDatac C rC )z Called with chunk of MP3 data.rD rE r7 r r r r) m s zShoutcastClient.gotMP3DataN)r )�__name__� __module__� __qualname__�__doc__r �versionr r r r r& r* r' r2 r4 r8 r6 r5 r) r r r r r s r N)rK �twistedr � twisted.webr r r r r r r �<module> s PK Mb�Zq�|�� �� ) protocols/__pycache__/sip.cpython-310.pycnu �[��� o �bH� � @ sd d Z ddlZddlZddlZddlmZ ddlmZmZ ddl m Z m Z ddl m Z ddlmZmZmZ ddlmZ dd lmZ d Zd d d ddddddd� Zi Ze�� D ]\ZZeee< qT[[i dd�dd�dd�dd �d d �d d �d!d"�d#d$�d%d&�d'd(�d)d*�d+d,�d-d.�d/d0�d1d2�d3d4�d5d6�i d7d8�d9d:�d;d<�d=d>�d?d@�dAdB�dCdD�dEdF�dGdH�dIdJ�dKdL�dMdN�dOdP�dQdR�dSdT�dUdV�dWdX��i dYdZ�d[d\�d]d^�d_d`�dadb�dcdd�dedf�dgdh�didj�dkdl�dmdn�dodp�dqdr�dsdt�dudv�dwdx�dydz��d{d:d|��Z d}d~dd��Z d�d�� Z d�d�� Z e � Z!G d�d�� d��Z"d�d�� Z#G d�d�� d��Z$d�d�d��Z%d�d�� Z&d�d�d��Z'G d�d�� d�e(�Z)G d�d�� d�e)�Z*G d�d�� d��Z+G d�d�� d�e+�Z,G d�d�� d�e+�Z-G d�d�� d�ej.�Z/G d�d�� d�ej0�Z1G d�d�� d�e �Z2G d�d�� d��Z3G d�d�� d�e �Z4G d�d�� d�e �Z5G d�d�� d�e1�Z6G d�d�� d�e �Z7G d�d�� d�e6�Z8e e4e5�G d�d�� d���Z9dS )�zP Session Initialization Protocol. Documented in RFC 2543. [Superseded by 3261] � N)� OrderedDict)�Dict�List)� Interface� implementer)�cred)�defer�protocol�reactor)�basic)�logi� �i�m�e�l�c�f�s�t�v) �call-id�contactzcontent-encoding�content-lengthz content-type�from�subject�to�via�d �Trying� �Ringing� zCall Is Being Forwarded� �Queued� zSession Progress�� �OKi, zMultiple Choicesi- zMoved Permanentlyi. zMoved Temporarilyi/ z See Otheri1 z Use Proxyi| zAlternative Service� z Bad Request� � Unauthorizedi� zPayment Requiredi� � Forbidden� z Not Foundi� zMethod Not Allowedi� zNot Acceptablei� z Proxy Authentication Requiredi� zRequest Timeouti� �Conflicti� �Gonei� zLength Requiredi� zRequest Entity Too Largei� zRequest-URI Too Largei� zUnsupported Media Typei� zUnsupported URI Schemei� z Bad Extensioni� zExtension Requiredi� zInterval Too Briefi� zTemporarily Unavailablei� z Call/Transaction Does Not Existi� z Loop Detectedi� z Too Many Hopsi� zAddress Incompletei� � Ambiguousi� z Busy Herei� zRequest Terminatedi� zNot Acceptable Herei� zRequest Pendingi� �Undecipherable�� zInternal Server Error� zNot Implementedi� z Bad Gatewayi� zService Unavailablei� zServer Time-outi� zSIP Version not supportedi zMessage Too LargeiX zBusy Everywherei[ �DeclinezDoes not exist anywhere)i\ i^ �CSeqzCall-IDzWWW-Authenticate)�cseqr �www-authenticatec C s d� dd� | �d�D ��S )zK Capitalize a string, making sure to treat '-' as a word separator �-c S s g | ]}|� � �qS � )� capitalize)�.0�xr7 r7 �7/usr/lib/python3/dist-packages/twisted/protocols/sip.py� <listcomp>p s z"dashCapitalize.<locals>.<listcomp>)�join�split�r r7 r7 r; �dashCapitalizel s r@ c C s2 | d | d krdkrn | S | dd� S | S )Nr ����"� r7 r? r7 r7 r; �unqs s �rD c @ sL e Zd ZdZeddddeddfdd�Zedd� �Zej d d� �Zd d � Z dS ) �Viaa� A L{Via} is a SIP Via header, representing a segment of the path taken by the request. See RFC 3261, sections 8.1.1.7, 18.2.2, and 20.42. @ivar transport: Network protocol used for this leg. (Probably either "TCP" or "UDP".) @type transport: C{str} @ivar branch: Unique identifier for this request. @type branch: C{str} @ivar host: Hostname or IP for this leg. @type host: C{str} @ivar port: Port used for this leg. @type port C{int}, or None. @ivar rportRequested: Whether to request RFC 3581 client processing or not. @type rportRequested: C{bool} @ivar rportValue: Servers wishing to honor requests for RFC 3581 processing should set this parameter to the source port the request was received from. @type rportValue: C{int}, or None. @ivar ttl: Time-to-live for requests on multicast paths. @type ttl: C{int}, or None. @ivar maddr: The destination multicast address, if any. @type maddr: C{str}, or None. @ivar hidden: Obsolete in SIP 2.0. @type hidden: C{bool} @ivar otherParams: Any other parameters in the header. @type otherParams: C{dict} �UDPNFc K s� || _ || _|| _|| _|| _|| _|du r%tjdtdd� d| _ d| _ n |du r0d| _ d| _ n|t u r;d| _ d| _ n|| _ d| _ || _ | | _ | | _dS )a( Set parameters of this Via header. All arguments correspond to attributes of the same name. To maintain compatibility with old SIP code, the 'rport' argument is used to determine the values of C{rportRequested} and C{rportValue}. If None, C{rportRequested} is set to True. (The deprecated method for doing this is to pass True.) If an integer, C{rportValue} is set to the given value. Any arguments not explicitly named here are collected into the C{otherParams} dict. Tz+rport=True is deprecated since Twisted 9.0.� )� stacklevelNF)� transport�host�port�ttl�hidden�received�warnings�warn�DeprecationWarning� rportValue�rportRequested�_absent�branch�maddr� otherParams) �selfrJ rK rI rL rM rN �rportrU rV �kwr7 r7 r; �__init__� s2 � z Via.__init__c C s" | j dkrdS | jdur| jS dS )zG Returns the rport value expected by the old SIP code. TN)rS rR �rX r7 r7 r; rY � s z Via.rportc C s || _ d| _dS )z� L{Base._fixupNAT} sets C{rport} directly, so this method sets C{rportValue} based on that. @param newRPort: The new rport value. @type newRPort: C{int} FN)rR rS )rX �newRPortr7 r7 r; rY � s c C s� d| j � d| j� d| j� �}| jr|d7 }dD ]}t| |�}|dur,|d|� d|� �7 }q| jr5|d 7 }n | jdurB|d | j� �7 }t| j � � �}|D ]\}}|du rZ|d| 7 }qK|d|� d|� �7 }qK|S ) zI Serialize this header for use in a request or response. zSIP/2.0/� �:z;hidden)rL rU rV rN N�;�=z;rportz;rport=) rI rJ rK rM �getattrrS rR rY �sortedrW �items)rX r �n�value�etc�kr r7 r7 r; �toString� s$ � z Via.toString) �__name__� __module__� __qualname__�__doc__�PORTrT r[ �propertyrY �setterri r7 r7 r7 r; rE | s # �6 rE c C sL | � d�}|d |dd� }}|� dd�\}}|�� }i }|� d�\}}} |dks.|dkr5td | ����| |d < d |v rO|� d �\} } t| �|d < | |d < n||d < |D ]I} | �� � dd�} t| �dkrm| d d} } n| \} } | dkrzd|d< qU| � dd�}t|�dkr�|d d}} n |\}} |dv r�t| �} | ||< qUtdi |��S )za Parse a Via header. @return: The parsed version of this header. @rtype: L{Via} r` r rC Nr^ �/�SIPz2.0zwrong protocol or version: rI r_ rK rJ � rM Tra )rY rL r7 )r> �strip� ValueError�int�lenrE )rf �parts�sent�params� protocolinfo�by�result�pname�pversionrI rJ rK �p�comment�namer7 r7 r; �parseViaHeader s< r� c @ sZ e Zd ZdZ d dd�Zdefdd�Zdefdd �Zdefd d �ZdS ) �URLz A SIP URL. Nc C sn || _ || _|| _|| _|| _|| _|| _| | _|| _| | _ | d kr&g | _ n| | _ | d kr2i | _ d S | | _ d S �N) �usernamerJ �passwordrK rI �usertype�method�tagrL rV �other�headers) rX rJ r� r� rK rI r� r� rL rV r� r� r� r7 r7 r; r[ 4 s z URL.__init__�returnc C s� g }|j }|d� | jd kr#|| j� | jd kr |d| j � |d� || j� | jd kr4|d| j � | jd kr@|d| j � dD ]}t| |�}|d krW|d|� d|� �� qB| jD ]}|d | � q[| jrz|d � |d � d d � | j� � D ��� d� |�S )N�sip:z:%s�@z:%dz;user=%s�rI rL rV r� r� r` ra z;%s�?�&c S s, g | ]\}}t �|�pt|�� d |� ��qS )ra )� specialCases�getr@ )r9 �hr r7 r7 r; r< n s ��z URL.toString.<locals>.<listcomp>rs ) �appendr� r� rJ rK r� rb r� r� r= rd )rX r �wre r r7 r7 r; ri V s< � ��� z URL.toStringc C s | � � S r� )ri r\ r7 r7 r; �__str__v s z URL.__str__c C s d� | j| j| j| j| j�S )Nz<URL {}:{}@{}:{!r}/{}>)�formatr� r� rJ rK rI r\ r7 r7 r; �__repr__y s �z URL.__repr__) NNNNNNNNNNN) rj rk rl rm r[ �strri r� r� r7 r7 r7 r; r� / s" �" r� c C s� i }| � d�std| dd� ��| dd� �d�}|d |dd� }}|�dd�}t|�d krU|\}} |�d d�} t| �dkrH| d |d < n| d |d < | d |d < n|d } | �d d�} t| �dkrl| d |d < n| d |d < t| d �|d< |dkr�||d < |dkr�||d< |D ]j} | |d kr�d| v r�i |d< } | �dd�\} }|�d�D ] }|�d�\}}|| |< q�| �dd�}t|�dkr�|�dg ��| � q�|\}}|dkr�||d< q�|dv r�|dkr�t|�}|||< q�|�dg ��| � q�tdi |��S )zV Return string into URL object. URIs are of form 'sip:user@example.com'. r� zunsupported scheme: N� r` r rC r� rG r_ r� r� rJ rK rA r� r� r� ra r� �userr� r� rL r7 )� startswithru r> rw rv � setdefaultr� r� )�urlrJ rK �drx � userdomainrz �udparts�userpass�hostport�upparts�hppartsr� r� r� �headerrh r �nvr� rf r7 r7 r; �parseURL� sV r� c C s d| _ d| _d| _i | _dS )z* Clean a URL from a Request line. N)rI rV rL r� )r� r7 r7 r; �cleanRequestURL� s r� c C s� | � � } | �d�rdt| ||d�i fS i }| �dd�\}}|� � }|�d�r,|dd� }|�d�r7|dd� }|�d d�\}}t|||d�}|� � }|rb|�d �D ]}|sVqQ|�d �\} } | || < qQ|rpd|_i |_d|_d|_|||fS ) z� Return (name, uri, params) for From/To/Contact header. @param clean: remove unnecessary info, usually for From and To headers. r� rs �rJ rK �<rC rB NrA �>r` ra ) rt r� r� r> �endswithrL r� rI rV ) �addressrJ rK �cleanrz r� r� � paramstringr rh r r7 r7 r; � parseAddress� s2 r� c @ s e Zd Zddd�ZdS )�SIPErrorNc C s4 |d u rt | }t�| d||f � || _|| _d S )NzSIP error (%d): %s)� statusCodes� Exceptionr[ �code�phrase)rX r� r� r7 r7 r; r[ � s zSIPError.__init__r� �rj rk rl r[ r7 r7 r7 r; r� � s r� c @ � e Zd ZdZdS )�RegistrationErrorz( Registration was not possible. N�rj rk rl rm r7 r7 r7 r; r� � � r� c @ sD e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dS )�Messagez A SIP message. Nc C s t � | _d| _d| _d S )Nrs r )r r� �body�finishedr\ r7 r7 r; r[ � s zMessage.__init__c C s> |� � }t�||�}|dkrt|�| _| j�|g ��|� d S )Nr )�lower� longHeadersr� rv �lengthr� r� r� )rX r� rf r7 r7 r; � addHeader s zMessage.addHeaderc C s | j |7 _ d S r� )r� �rX �datar7 r7 r; �bodyDataReceived � zMessage.bodyDataReceivedc C s, | j d kr| j t| j�krtd��d| _d S )Nzwrong body lengthrC )r� rw r� ru r� r\ r7 r7 r; �creationFinished s zMessage.creationFinishedc C sb d| � � }| j�� D ]\}}|D ]}|t�|�p t|�� d|� d�7 }qq |d7 }|| j7 }|S )Nz%s z: z )�_getHeaderLiner� rd r� r� r@ r� )rX r re �vsr r7 r7 r; ri s $� zMessage.toStringc C � t �r� ��NotImplementedErrorr\ r7 r7 r; r� � zMessage._getHeaderLine) rj rk rl rm r� r[ r� r� r� ri r� r7 r7 r7 r; r� � s r� c @ s0 e Zd ZdZd dd�Zdefdd�Zdd � Zd S ) �Requestz A Request for a URI �SIP/2.0c C s< t �| � || _t|t�r|| _d S t|�| _t| j� d S r� )r� r[ r� � isinstancer� �urir� r� )rX r� r� �versionr7 r7 r; r[ # s zRequest.__init__r� c C s dt | �| j| j�� f S )Nz<SIP Request %d:%s %s>)�idr� r� ri r\ r7 r7 r; r� , s zRequest.__repr__c C s | j � d| j�� � d�S )Nr^ z SIP/2.0)r� r� ri r\ r7 r7 r; r� / s zRequest._getHeaderLineN)r� �rj rk rl rm r[ r� r� r� r7 r7 r7 r; r� s r� c @ s0 e Zd ZdZd dd�Zdefdd�Zd d � ZdS ) �Responsez% A Response to a URI Request Nr� c C s* t �| � || _|d krt| }|| _d S r� )r� r[ r� r� r� )rX r� r� r� r7 r7 r; r[ 8 s zResponse.__init__r� c C s dt | �| jf S )Nz<SIP Response %d:%s>)r� r� r\ r7 r7 r; r� ? r� zResponse.__repr__c C s d| j � d| j� �S )NzSIP/2.0 r^ )r� r� r\ r7 r7 r; r� B s zResponse._getHeaderLine)Nr� r� r7 r7 r7 r; r� 3 s r� c @ sx e Zd ZdZdZdZdZdZdZdd� Z d d d �Z d d � Z d d� Z dd� Z dd� Zdd� Zdd� Zd dd�Zdd� ZdS ) �MessagesParserz� A SIP messages parser. Expects dataReceived, dataDone repeatedly, in that order. Shouldn't be connected to actual transport. r� rC � firstliner c C s || _ | �� d S r� )�messageReceived�reset)rX �messageReceivedCallbackr7 r7 r; r[ U � zMessagesParser.__init__rs c C s, d| _ d | _d| _d | _d | _| �|� d S )Nr� r )�stater� � bodyReceived�messager� � setLineMode�rX � remainingDatar7 r7 r; r� Y s zMessagesParser.resetc C s d| _ | �� d S )N�invalid)r� � setRawModer\ r7 r7 r; �invalidMessagea r� z MessagesParser.invalidMessagec C sb | � � | jdkr dS | jdkr| �� dS | jdkr!| �� dS | j| jk r-| �� dS td��)zI Clear out any buffered data that may be hanging around. r� Nr� zthis should never happen)�clearLineBufferr� r� r� � messageDoner� � RuntimeErrorr\ r7 r7 r; �dataDonee s zMessagesParser.dataDonec C sN zt |t�r |�d�}tj�| |� W d S ty& t�� | � � Y d S w )N�utf-8) r� r� �encoder � LineReceiver� dataReceivedr� r �errr� r� r7 r7 r; r� y s �zMessagesParser.dataReceivedc C r� )z2 Expected to create self.message. r� �rX �liner7 r7 r; �handleFirstLine� � z MessagesParser.handleFirstLinec C s | � � d S r� )r� r� r7 r7 r; �lineLengthExceeded� � z!MessagesParser.lineLengthExceededc C s. t |t�r |�d�}| jdkr�|�d�s|�d�r)|dd � }|�d�s|�d�s|s-d S z |�dd�\}}}W n tyF | �� Y d S w |dkrj| jrjzt |�}W n tyb | �� Y d S w t ||�| _ n|dkrx| j rxt ||�| _ n| �� d S d | _d S | jd ks�J �|r�|�d�s�|�d �r�| j\}}|||�� f| _d S | jr�| j j| j� d | _z |�d d�\}}W n ty� | �� Y d S w ||�� f| _|�� d kr�z t |�� �| _W d S ty� | �� Y d S w d S d | _| j�r| j j| j� d | _| jdk�r| �� d S | �� d S )Nr� r� � � rC r^ rG r� r� � r_ r r� r )r� �bytes�decoder� r� r> ru r� �acceptResponsesrv r� r� �acceptRequestsr� r� �lstripr� r� r� r� r� )rX r� �a�br r� r� rf r7 r7 r; � lineReceived� sv � � � � �� zMessagesParser.lineReceivedc C s2 | j dksJ �| j�� | �| j� | �|� d S )Nr� )r� r� r� r� r� r� r7 r7 r; r� � s zMessagesParser.messageDonec C s� | j dv sJ �t|t�r|�d�}| j dkrd S | jd kr%| j�|� d S t|�}| j| j }||krH| j�|d |� � | � ||d � � d S | j|7 _| j�|� | j| jkra| � � d S d S )N)r� r� r� r� ) r� r� r� r� r� r� r� rw r� r� )rX r� �dataLen� expectedLenr7 r7 r; �rawDataReceived� s$ �z MessagesParser.rawDataReceivedN)rs )rj rk rl rm r� r� r� r� �debugr[ r� r� r� r� r� r� r r� r r7 r7 r7 r; r� F s" C r� c @ s` e Zd ZdZeZdZdd� Zdd� Zdd� Zd d � Z d d � Z d d� Z dd� Z dd� Z dd� ZdS )�Basez1 Base class for SIP clients and servers. Fc C s g | _ t| j�| _d S r� )�messagesr� � addMessage�parserr\ r7 r7 r; r[ � s z Base.__init__c C s | j �|� d S r� )r r� )rX �msgr7 r7 r; r � � zBase.addMessagec C s� | j �|� | j �� | jD ]*}| �||� | jr&t�d|�� �d|��� t |t �r2| � ||� q| � ||� qg | jd d �< d S )Nz Received z from ) r r� r� r � _fixupNATr r r ri r� r� �handle_request�handle_response)rX r� �addrr r7 r7 r; �datagramReceived� s zBase.datagramReceivedc C s� |\}}t |jd d �}|j|kr(||_|j|kr ||_|�� |jd d< d S |jdkr>||_||_|�� |jd d< d S d S )Nr r T)r� r� rJ rN rK rY ri )rX r� � sourcePeer�srcHost�srcPort� senderViar7 r7 r; r s �zBase._fixupNATc C �L t |jd d �}|jp|j}|jp|jp| j}t||d�}| �||� dS �zX Deliver response. Destination is based on topmost Via header. r r r� N� r� r� rN rJ rY rK rn r� � sendMessage�rX �responseMessage�destViarJ rK �destAddrr7 r7 r; �deliverResponse s zBase.deliverResponsec C �2 t |�}dD ]}|j�|g �dd� |j|< q|S �z9 Create a response to a request message. )r r r r r4 N�r� r� r� �rX r� �request�responser� r7 r7 r; �responseFromRequest! s zBase.responseFromRequestc C sn |j dvr td��| jrt�d|�� �d|��� |�� }t|t�r'|�d�}| j � ||j |j p2| j f� dS )z� Send a message. @param destURL: C{URL}. This should be a *physical* URL, not a logical one. @param message: The message to send. )�udpNz only UDP currently supportedzSending z to r� N) rI r� r r r ri r� r� r� �writerJ rK rn )rX �destURLr� r� r7 r7 r; r + s zBase.sendMessagec C r� )z� Override to define behavior for requests received @type message: C{Message} @type addr: C{tuple} r� �rX r� r r7 r7 r; r ; � zBase.handle_requestc C r� )z� Override to define behavior for responses received. @type message: C{Message} @type addr: C{tuple} r� r' r7 r7 r; r D r( zBase.handle_responseN)rj rk rl rm rn r r[ r r r r r# r r r r7 r7 r7 r; r � s r c @ r� )�IContactz( A user of a registrar or proxy Nr� r7 r7 r7 r; r) N r� r) c @ s e Zd Zdd� ZdS )� Registrationc C s || _ || _d S r� )�secondsToExpiry� contactURL)rX r+ r, r7 r7 r; r[ U � zRegistration.__init__Nr� r7 r7 r7 r; r* T s r* c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � IRegistryz? Allows registration of logical->physical URL mapping. c C � dS )z� Register the physical address of a logical URL. @return: Deferred of C{Registration} or failure with RegistrationError. Nr7 �� domainURL� logicalURL� physicalURLr7 r7 r; �registerAddress_ � zIRegistry.registerAddressc C r/ )z� Unregister the physical address of a logical URL. @return: Deferred of C{Registration} or failure with RegistrationError. Nr7 r0 r7 r7 r; �unregisterAddressf r5 zIRegistry.unregisterAddressc C r/ )z� Get registration info for logical URL. @return: Deferred of C{Registration} object or failure of LookupError. Nr7 �r2 r7 r7 r; �getRegistrationInfom r5 z IRegistry.getRegistrationInfoN)rj rk rl rm r4 r6 r8 r7 r7 r7 r; r. Z s r. c @ s e Zd ZdZdd� ZdS )�ILocatorz< Allow looking up physical address for logical URL. c C r/ )z� Return physical URL of server for logical URL of user. @param logicalURL: a logical C{URL}. @return: Deferred which becomes URL or fails with LookupError. Nr7 r7 r7 r7 r; � getAddressz r5 zILocator.getAddressN)rj rk rl rm r: r7 r7 r7 r; r9 u s r9 c @ sf e Zd ZdZeZdZdefdd�Zdd� Zdd� Zd d � Z d d � Z d d� Z dd� Z dd� Z dd� ZdS )�Proxyz SIP proxy. Nc C s" |pt �� | _|| _t�| � dS )z� Create new instance. @param host: our hostname/IP as set in Via headers. @param port: our port as set in Via headers. N)�socket�getfqdnrJ rK r r[ )rX rJ rK r7 r7 r; r[ � s zProxy.__init__c C s t | j| jd�S )z< Return value of Via header for this proxy. r� )rE rJ rK r\ r7 r7 r; �getVia� s z Proxy.getViac s� t �d� j d �}|d u r�j}z|� |�}W n3 ty4 } z����|j� �� W Y d }~d S d }~w tyJ t� � ����d� �� Y d S w |d ur[|� � �fdd�� d S d S )Nzhandle_%s_requestr0 c s �� ��| j� ��S r� )r r# r� )r �r� rX r7 r; �<lambda>� s �z&Proxy.handle_request.<locals>.<lambda>) rb r� �handle_request_defaultr� r r# r� � BaseExceptionr r� � addErrback)rX r� r r r� r r7 r? r; r � s" "� � ��zProxy.handle_requestc s� |\}}� fdd�}� � � }|�� |jd v r t�d� dS |jd �d|�� � t|jd d dd �\}}} � j�|�} | � � j |� | � � j |� dS ) z� Default request handler. Default behaviour for OPTIONS and unknown methods for proxies is to forward message on to the client. Since at the moment we are stateless proxy, that's basically everything. c s | � � |jd d< � �| |�S )Nr r )ri r� r )r� r� r\ r7 r; �_mungContactHeader� s z8Proxy.handle_request_default.<locals>._mungContactHeaderr zDropping looped message.Nr r rC �r� ) r> ri r� r r �insertr� �locatorr: � addCallbackr rC �_cantForwardRequest) rX r� r r r rD � viaHeaderr� r� �tagsr� r7 r\ r; rA � s z Proxy.handle_request_defaultc C s, |� t� |jd d= | �| �d|�� d S )Nr r r+ )�trap� LookupErrorr� r r# �rX �errorr� r7 r7 r; rI � s zProxy._cantForwardRequestc C r r r r r7 r7 r; r � s zProxy.deliverResponsec C r r r r r7 r7 r; r# � s zProxy.responseFromRequestc C sl t |jd d �}|j|jf| j| jfkr t�d� dS |jd d= |jd s/| �||� dS | �|� dS )z+ Default response handler. r r z&Dropping incorrectly addressed messageN)r� r� rJ rK r r � gotResponser )rX r� r r r7 r7 r; r � s zProxy.handle_responsec C r/ )zJ Called with responses that are addressed at this server. Nr7 r' r7 r7 r; rP � r� zProxy.gotResponse)rj rk rl rm rn rG r[ r> r rA rI r r# r rP r7 r7 r7 r; r; � s r; c @ s e Zd Zdd� Zdd� ZdS )� IAuthorizerc C r/ )z� Generate a challenge the client may respond to. @type peer: C{tuple} @param peer: The client's address @rtype: C{str} @return: The challenge string Nr7 )�peerr7 r7 r; � getChallenge r5 zIAuthorizer.getChallengec C r/ )zf Create a credentials object from the given response. @type response: C{str} Nr7 )r" r7 r7 r; r� r5 zIAuthorizer.decodeN)rj rk rl rS r� r7 r7 r7 r; rQ s rQ c @ s� e Zd ZU dZdZdZi Zeee f e d< dd� Z dd� Z dd � Z d d � Zd d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � ZdS ) � RegisterProxyzk A proxy that allows registration for a specific domain. Unregistered users won't be handled. N� authorizersc O s" t j| g|�R i |�� i | _d S r� )r; r[ �liveChallenges)rX �argsrZ r7 r7 r; r[ & s zRegisterProxy.__init__c C s |\}}d S r� r7 �rX r� � host_portrJ rK r7 r7 r; �handle_ACK_request* s z RegisterProxy.handle_ACK_requestc C sJ |\}}| j du r| �|||� dS d|jvr | �|||�S | �|||�S )z` Handle a registration request. Currently registration is not proxied. N� authorization)�portal�registerr� � unauthorized�loginrX r7 r7 r; �handle_REGISTER_request3 s z%RegisterProxy.handle_REGISTER_requestc C s� | � d|�}| j�� D ]3\}}|�||f�}|d u r&|�� � d| j� d�}n|�� � d|� d| j� d�}|j�dg ��|� q | � |� d S )Nr( z realm="rB r^ z,realm="r5 ) r# rU rd rS �titlerJ r� r� r� r ) rX r� rJ rK r �scheme�auth�chalrf r7 r7 r; r^ D s zRegisterProxy.unauthorizedc C s� |j d d �d d�}| j�|d �� �}|rez |�|d �}W n ty( � ty> t� � | � | � d|�� Y d S w | j d| j 7 _ | j�|d t��| j|||��| j|||��tj � d S | � | � d|�� d S )Nr[ r rC r0 r� r1 )r� r> rU r� r� r� r� rB r r� r r# r� rJ r\ r_ r) rH �_cbLoginrC �_ebLogin)rX r� rJ rK rx r� r r7 r7 r; r_ O s" � � zRegisterProxy.loginc C s |\}}}| � |||� d S r� )r] )rX �i_a_lr� rJ rK r r� r r7 r7 r; re b s zRegisterProxy._cbLoginc C s |� tjj� | �|||� d S r� )rL r rO �UnauthorizedLoginr^ )rX �failurer� rJ rK r7 r7 r; rf g s zRegisterProxy._ebLoginc C s� t |jd d dd�\}}}d}d|jv r |jd d }|j�ddg�d dkr1| �|||� dS |durIt |||d �\}}}| j�|j||�} n| j�|�} | j| j | j |f|fd � dS ) z- Allow all users to register r r rC rE Nr �expires�0r� )� callbackArgs� errbackArgs) r� r� r� � unregister�registryr4 r� r8 � addCallbacks� _cbRegister� _ebRegister) rX r� rJ rK r� �toURLrz r r, r� r7 r7 r; r] k s �zRegisterProxy.registerc C sT | � d|�}|jd kr |�d|j�� � |�dd|j � |�dd� | �|� d S )Nr% r rj z%dr rk )r# r, r� ri r+ r )rX � registrationr� r" r7 r7 r; rq � s zRegisterProxy._cbRegisterc C s |� tt� d S r� )rL r� rM rN r7 r7 r; rr � r zRegisterProxy._ebRegisterc C s� z t |jd d �}W n ty | �| �d|�� Y d S w |dkrH|dkr*d}nt|�\}}}| j�|j||�}|� | j |�� | j |� d S d S )Nrj r r' �*) rv r� ru r r# r� ro r6 r� rH � _cbUnregisterrC � _ebUnregister) rX r� rs r rj r, r� rz r� r7 r7 r; rn � s ���zRegisterProxy.unregisterc C s@ | � d|�}|j�dg ��|j�� � |�dd� | �|� d S )Nr% r rj rk )r# r� r� r� r, ri r� r )rX rt r� r r7 r7 r; rv � s zRegisterProxy._cbUnregisterc C s d S r� r7 )rX rt r� r7 r7 r; rw � r� zRegisterProxy._ebUnregister)rj rk rl rm r\ ro rU r r� rQ �__annotations__r[ rZ r` r^ r_ re rf r] rq rr rn rv rw r7 r7 r7 r; rT s$ rT c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�InMemoryRegistryz6 A simplistic registry for a specific domain. c C s || _ i | _d S r� )�domain�users)rX rz r7 r7 r; r[ � r- zInMemoryRegistry.__init__c C sN |j | jkr t�td��S |j| jv r | j|j \}}t�|�S t�td��S �Nzunknown domain� no such user)rJ rz r �failrM r� r{ �succeed�rX �userURI�dcr� r7 r7 r; r: � s zInMemoryRegistry.getAddressc C sd |j | jkr t�td��S |j| jv r+| j|j \}}t�tt |� � t � � �|��S t�td��S r| ) rJ rz r r~ rM r� r{ r r* rv �getTime�timer� r7 r7 r; r8 � s z$InMemoryRegistry.getRegistrationInfoc C sT z | j | \}}W n ty t�td�� Y S w |�� | j |= t�td|��S )Nr} r )r{ �KeyErrorr r~ rM �cancelr r* )rX r� r� r� r7 r7 r; �_expireRegistration� s �z$InMemoryRegistry._expireRegistrationc C s� |j | jkrt�d� t�td��S |j | jkr$t�d� t�td��S |j| jv r8| j|j \}}|� d� n t � d| j |j�}t�d|� � � d|� � � �� ||f| j|j< t�tt|�� t�� �|��S )Nz(Registration for domain we don't handle.r+ i z Registered z at )rJ rz r r r r~ r� r� r{ r� r � callLaterr� ri r r* rv r� r� )rX r1 r2 r3 r� �oldr7 r7 r; r4 � s z InMemoryRegistry.registerAddressc C s | � |j�S r� )r� r� )rX r1 r2 r3 r7 r7 r; r6 � r� z"InMemoryRegistry.unregisterAddressN) rj rk rl rm r[ r: r8 r� r4 r6 r7 r7 r7 r; ry � s ry )NN)NNr ):rm r< r� rO � collectionsr �typingr r �zope.interfacer r �twistedr �twisted.internetr r r �twisted.protocolsr �twisted.pythonr rn � shortHeadersr� rd rh r r� r� r@ rD �objectrT rE r� r� r� r� r� r� r� r� r� r� r� r� r� �DatagramProtocolr r) r* r. r9 r; rQ rT ry r7 r7 r7 r; �<module> sJ � �������� � � � � ��������������� � � � � �!�"�#�$�%�&�'�(�)�*�+�,�-�.�/�0�1�2�3�4�9� + T7 # ( %d PK Mb�Z�)i�. �. protocols/loopback.pynu �[��� # -*- test-case-name: twisted.test.test_loopback -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Testing support for protocols -- loopback between client and server. """ # system imports import tempfile from zope.interface import implementer from twisted.internet import defer, interfaces, main, protocol from twisted.internet.interfaces import IAddress from twisted.internet.task import deferLater # Twisted Imports from twisted.protocols import policies from twisted.python import failure class _LoopbackQueue: """ Trivial wrapper around a list to give it an interface like a queue, which the addition of also sending notifications by way of a Deferred whenever the list has something added to it. """ _notificationDeferred = None disconnect = False def __init__(self): self._queue = [] def put(self, v): self._queue.append(v) if self._notificationDeferred is not None: d, self._notificationDeferred = self._notificationDeferred, None d.callback(None) def __nonzero__(self): return bool(self._queue) __bool__ = __nonzero__ def get(self): return self._queue.pop(0) @implementer(IAddress) class _LoopbackAddress: pass @implementer(interfaces.ITransport, interfaces.IConsumer) class _LoopbackTransport: disconnecting = False producer = None # ITransport def __init__(self, q): self.q = q def write(self, data): if not isinstance(data, bytes): raise TypeError("Can only write bytes to ITransport") self.q.put(data) def writeSequence(self, iovec): self.q.put(b"".join(iovec)) def loseConnection(self): self.q.disconnect = True self.q.put(None) def abortConnection(self): """ Abort the connection. Same as L{loseConnection}. """ self.loseConnection() def getPeer(self): return _LoopbackAddress() def getHost(self): return _LoopbackAddress() # IConsumer def registerProducer(self, producer, streaming): assert self.producer is None self.producer = producer self.streamingProducer = streaming self._pollProducer() def unregisterProducer(self): assert self.producer is not None self.producer = None def _pollProducer(self): if self.producer is not None and not self.streamingProducer: self.producer.resumeProducing() def identityPumpPolicy(queue, target): """ L{identityPumpPolicy} is a policy which delivers each chunk of data written to the given queue as-is to the target. This isn't a particularly realistic policy. @see: L{loopbackAsync} """ while queue: bytes = queue.get() if bytes is None: break target.dataReceived(bytes) def collapsingPumpPolicy(queue, target): """ L{collapsingPumpPolicy} is a policy which collapses all outstanding chunks into a single string and delivers it to the target. @see: L{loopbackAsync} """ bytes = [] while queue: chunk = queue.get() if chunk is None: break bytes.append(chunk) if bytes: target.dataReceived(b"".join(bytes)) def loopbackAsync(server, client, pumpPolicy=identityPumpPolicy): """ Establish a connection between C{server} and C{client} then transfer data between them until the connection is closed. This is often useful for testing a protocol. @param server: The protocol instance representing the server-side of this connection. @param client: The protocol instance representing the client-side of this connection. @param pumpPolicy: When either C{server} or C{client} writes to its transport, the string passed in is added to a queue of data for the other protocol. Eventually, C{pumpPolicy} will be called with one such queue and the corresponding protocol object. The pump policy callable is responsible for emptying the queue and passing the strings it contains to the given protocol's C{dataReceived} method. The signature of C{pumpPolicy} is C{(queue, protocol)}. C{queue} is an object with a C{get} method which will return the next string written to the transport, or L{None} if the transport has been disconnected, and which evaluates to C{True} if and only if there are more items to be retrieved via C{get}. @return: A L{Deferred} which fires when the connection has been closed and both sides have received notification of this. """ serverToClient = _LoopbackQueue() clientToServer = _LoopbackQueue() server.makeConnection(_LoopbackTransport(serverToClient)) client.makeConnection(_LoopbackTransport(clientToServer)) return _loopbackAsyncBody( server, serverToClient, client, clientToServer, pumpPolicy ) def _loopbackAsyncBody(server, serverToClient, client, clientToServer, pumpPolicy): """ Transfer bytes from the output queue of each protocol to the input of the other. @param server: The protocol instance representing the server-side of this connection. @param serverToClient: The L{_LoopbackQueue} holding the server's output. @param client: The protocol instance representing the client-side of this connection. @param clientToServer: The L{_LoopbackQueue} holding the client's output. @param pumpPolicy: See L{loopbackAsync}. @return: A L{Deferred} which fires when the connection has been closed and both sides have received notification of this. """ def pump(source, q, target): sent = False if q: pumpPolicy(q, target) sent = True if sent and not q: # A write buffer has now been emptied. Give any producer on that # side an opportunity to produce more data. source.transport._pollProducer() return sent while 1: disconnect = clientSent = serverSent = False # Deliver the data which has been written. serverSent = pump(server, serverToClient, client) clientSent = pump(client, clientToServer, server) if not clientSent and not serverSent: # Neither side wrote any data. Wait for some new data to be added # before trying to do anything further. d = defer.Deferred() clientToServer._notificationDeferred = d serverToClient._notificationDeferred = d d.addCallback( _loopbackAsyncContinue, server, serverToClient, client, clientToServer, pumpPolicy, ) return d if serverToClient.disconnect: # The server wants to drop the connection. Flush any remaining # data it has. disconnect = True pump(server, serverToClient, client) elif clientToServer.disconnect: # The client wants to drop the connection. Flush any remaining # data it has. disconnect = True pump(client, clientToServer, server) if disconnect: # Someone wanted to disconnect, so okay, the connection is gone. server.connectionLost(failure.Failure(main.CONNECTION_DONE)) client.connectionLost(failure.Failure(main.CONNECTION_DONE)) return defer.succeed(None) def _loopbackAsyncContinue( ignored, server, serverToClient, client, clientToServer, pumpPolicy ): # Clear the Deferred from each message queue, since it has already fired # and cannot be used again. clientToServer._notificationDeferred = None serverToClient._notificationDeferred = None # Schedule some more byte-pushing to happen. This isn't done # synchronously because no actual transport can re-enter dataReceived as # a result of calling write, and doing this synchronously could result # in that. from twisted.internet import reactor return deferLater( reactor, 0, _loopbackAsyncBody, server, serverToClient, client, clientToServer, pumpPolicy, ) @implementer(interfaces.ITransport, interfaces.IConsumer) class LoopbackRelay: buffer = b"" shouldLose = 0 disconnecting = 0 producer = None def __init__(self, target, logFile=None): self.target = target self.logFile = logFile def write(self, data): self.buffer = self.buffer + data if self.logFile: self.logFile.write("loopback writing %s\n" % repr(data)) def writeSequence(self, iovec): self.write(b"".join(iovec)) def clearBuffer(self): if self.shouldLose == -1: return if self.producer: self.producer.resumeProducing() if self.buffer: if self.logFile: self.logFile.write("loopback receiving %s\n" % repr(self.buffer)) buffer = self.buffer self.buffer = b"" self.target.dataReceived(buffer) if self.shouldLose == 1: self.shouldLose = -1 self.target.connectionLost(failure.Failure(main.CONNECTION_DONE)) def loseConnection(self): if self.shouldLose != -1: self.shouldLose = 1 def getHost(self): return "loopback" def getPeer(self): return "loopback" def registerProducer(self, producer, streaming): self.producer = producer def unregisterProducer(self): self.producer = None def logPrefix(self): return f"Loopback({self.target.__class__.__name__!r})" class LoopbackClientFactory(protocol.ClientFactory): def __init__(self, protocol): self.disconnected = 0 self.deferred = defer.Deferred() self.protocol = protocol def buildProtocol(self, addr): return self.protocol def clientConnectionLost(self, connector, reason): self.disconnected = 1 self.deferred.callback(None) class _FireOnClose(policies.ProtocolWrapper): def __init__(self, protocol, factory): policies.ProtocolWrapper.__init__(self, protocol, factory) self.deferred = defer.Deferred() def connectionLost(self, reason): policies.ProtocolWrapper.connectionLost(self, reason) self.deferred.callback(None) def loopbackTCP(server, client, port=0, noisy=True): """Run session between server and client protocol instances over TCP.""" from twisted.internet import reactor f = policies.WrappingFactory(protocol.Factory()) serverWrapper = _FireOnClose(f, server) f.noisy = noisy f.buildProtocol = lambda addr: serverWrapper serverPort = reactor.listenTCP(port, f, interface="127.0.0.1") clientF = LoopbackClientFactory(client) clientF.noisy = noisy reactor.connectTCP("127.0.0.1", serverPort.getHost().port, clientF) d = clientF.deferred d.addCallback(lambda x: serverWrapper.deferred) d.addCallback(lambda x: serverPort.stopListening()) return d def loopbackUNIX(server, client, noisy=True): """Run session between server and client protocol instances over UNIX socket.""" path = tempfile.mktemp() from twisted.internet import reactor f = policies.WrappingFactory(protocol.Factory()) serverWrapper = _FireOnClose(f, server) f.noisy = noisy f.buildProtocol = lambda addr: serverWrapper serverPort = reactor.listenUNIX(path, f) clientF = LoopbackClientFactory(client) clientF.noisy = noisy reactor.connectUNIX(path, clientF) d = clientF.deferred d.addCallback(lambda x: serverWrapper.deferred) d.addCallback(lambda x: serverPort.stopListening()) return d PK Mb�Z�ќ protocols/pcp.pynu �[��� # -*- test-case-name: twisted.test.test_pcp -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Producer-Consumer Proxy. """ from zope.interface import implementer from twisted.internet import interfaces @implementer(interfaces.IProducer, interfaces.IConsumer) class BasicProducerConsumerProxy: """ I can act as a man in the middle between any Producer and Consumer. @ivar producer: the Producer I subscribe to. @type producer: L{IProducer<interfaces.IProducer>} @ivar consumer: the Consumer I publish to. @type consumer: L{IConsumer<interfaces.IConsumer>} @ivar paused: As a Producer, am I paused? @type paused: bool """ consumer = None producer = None producerIsStreaming = None iAmStreaming = True outstandingPull = False paused = False stopped = False def __init__(self, consumer): self._buffer = [] if consumer is not None: self.consumer = consumer consumer.registerProducer(self, self.iAmStreaming) # Producer methods: def pauseProducing(self): self.paused = True if self.producer: self.producer.pauseProducing() def resumeProducing(self): self.paused = False if self._buffer: # TODO: Check to see if consumer supports writeSeq. self.consumer.write("".join(self._buffer)) self._buffer[:] = [] else: if not self.iAmStreaming: self.outstandingPull = True if self.producer is not None: self.producer.resumeProducing() def stopProducing(self): if self.producer is not None: self.producer.stopProducing() if self.consumer is not None: del self.consumer # Consumer methods: def write(self, data): if self.paused or (not self.iAmStreaming and not self.outstandingPull): # We could use that fifo queue here. self._buffer.append(data) elif self.consumer is not None: self.consumer.write(data) self.outstandingPull = False def finish(self): if self.consumer is not None: self.consumer.finish() self.unregisterProducer() def registerProducer(self, producer, streaming): self.producer = producer self.producerIsStreaming = streaming def unregisterProducer(self): if self.producer is not None: del self.producer del self.producerIsStreaming if self.consumer: self.consumer.unregisterProducer() def __repr__(self) -> str: return f"<{self.__class__}@{id(self):x} around {self.consumer}>" class ProducerConsumerProxy(BasicProducerConsumerProxy): """ProducerConsumerProxy with a finite buffer. When my buffer fills up, I have my parent Producer pause until my buffer has room in it again. """ # Copies much from abstract.FileDescriptor bufferSize = 2 ** 2 ** 2 ** 2 producerPaused = False unregistered = False def pauseProducing(self): # Does *not* call up to ProducerConsumerProxy to relay the pause # message through to my parent Producer. self.paused = True def resumeProducing(self): self.paused = False if self._buffer: data = "".join(self._buffer) bytesSent = self._writeSomeData(data) if bytesSent < len(data): unsent = data[bytesSent:] assert ( not self.iAmStreaming ), "Streaming producer did not write all its data." self._buffer[:] = [unsent] else: self._buffer[:] = [] else: bytesSent = 0 if ( self.unregistered and bytesSent and not self._buffer and self.consumer is not None ): self.consumer.unregisterProducer() if not self.iAmStreaming: self.outstandingPull = not bytesSent if self.producer is not None: bytesBuffered = sum(len(s) for s in self._buffer) # TODO: You can see here the potential for high and low # watermarks, where bufferSize would be the high mark when we # ask the upstream producer to pause, and we wouldn't have # it resume again until it hit the low mark. Or if producer # is Pull, maybe we'd like to pull from it as much as necessary # to keep our buffer full to the low mark, so we're never caught # without something to send. if self.producerPaused and (bytesBuffered < self.bufferSize): # Now that our buffer is empty, self.producerPaused = False self.producer.resumeProducing() elif self.outstandingPull: # I did not have any data to write in response to a pull, # so I'd better pull some myself. self.producer.resumeProducing() def write(self, data): if self.paused or (not self.iAmStreaming and not self.outstandingPull): # We could use that fifo queue here. self._buffer.append(data) elif self.consumer is not None: assert ( not self._buffer ), "Writing fresh data to consumer before my buffer is empty!" # I'm going to use _writeSomeData here so that there is only one # path to self.consumer.write. But it doesn't actually make sense, # if I am streaming, for some data to not be all data. But maybe I # am not streaming, but I am writing here anyway, because there was # an earlier request for data which was not answered. bytesSent = self._writeSomeData(data) self.outstandingPull = False if not bytesSent == len(data): assert ( not self.iAmStreaming ), "Streaming producer did not write all its data." self._buffer.append(data[bytesSent:]) if (self.producer is not None) and self.producerIsStreaming: bytesBuffered = sum(len(s) for s in self._buffer) if bytesBuffered >= self.bufferSize: self.producer.pauseProducing() self.producerPaused = True def registerProducer(self, producer, streaming): self.unregistered = False BasicProducerConsumerProxy.registerProducer(self, producer, streaming) if not streaming: producer.resumeProducing() def unregisterProducer(self): if self.producer is not None: del self.producer del self.producerIsStreaming self.unregistered = True if self.consumer and not self._buffer: self.consumer.unregisterProducer() def _writeSomeData(self, data): """Write as much of this data as possible. @returns: The number of bytes written. """ if self.consumer is None: return 0 self.consumer.write(data) return len(data) PK Mb�ZX,�~ �~ protocols/tls.pynu �[��� # -*- test-case-name: twisted.protocols.test.test_tls,twisted.internet.test.test_tls,twisted.test.test_sslverify -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Implementation of a TLS transport (L{ISSLTransport}) as an L{IProtocol<twisted.internet.interfaces.IProtocol>} layered on top of any L{ITransport<twisted.internet.interfaces.ITransport>} implementation, based on U{OpenSSL<http://www.openssl.org>}'s memory BIO features. L{TLSMemoryBIOFactory} is a L{WrappingFactory} which wraps protocols created by the factory it wraps with L{TLSMemoryBIOProtocol}. L{TLSMemoryBIOProtocol} intercedes between the underlying transport and the wrapped protocol to implement SSL and TLS. Typical usage of this module looks like this:: from twisted.protocols.tls import TLSMemoryBIOFactory from twisted.internet.protocol import ServerFactory from twisted.internet.ssl import PrivateCertificate from twisted.internet import reactor from someapplication import ApplicationProtocol serverFactory = ServerFactory() serverFactory.protocol = ApplicationProtocol certificate = PrivateCertificate.loadPEM(certPEMData) contextFactory = certificate.options() tlsFactory = TLSMemoryBIOFactory(contextFactory, False, serverFactory) reactor.listenTCP(12345, tlsFactory) reactor.run() This API offers somewhat more flexibility than L{twisted.internet.interfaces.IReactorSSL}; for example, a L{TLSMemoryBIOProtocol} instance can use another instance of L{TLSMemoryBIOProtocol} as its transport, yielding TLS over TLS - useful to implement onion routing. It can also be used to run TLS over unusual transports, such as UNIX sockets and stdio. """ from OpenSSL.SSL import ( Connection, Context, Error, TLSv1_METHOD, WantReadError, ZeroReturnError, ) try: Connection(Context(TLSv1_METHOD), None) except TypeError as e: if str(e) != "argument must be an int, or have a fileno() method.": raise raise ImportError("twisted.protocols.tls requires pyOpenSSL 0.10 or newer.") from zope.interface import directlyProvides, implementer, providedBy from twisted.internet._producer_helpers import _PullToPush from twisted.internet._sslverify import _setAcceptableProtocols from twisted.internet.interfaces import ( IHandshakeListener, ILoggingContext, INegotiated, IOpenSSLClientConnectionCreator, IOpenSSLServerConnectionCreator, IProtocolNegotiationFactory, IPushProducer, ISystemHandle, ) from twisted.internet.main import CONNECTION_LOST from twisted.internet.protocol import Protocol from twisted.protocols.policies import ProtocolWrapper, WrappingFactory from twisted.python.failure import Failure @implementer(IPushProducer) class _ProducerMembrane: """ Stand-in for producer registered with a L{TLSMemoryBIOProtocol} transport. Ensures that producer pause/resume events from the undelying transport are coordinated with pause/resume events from the TLS layer. @ivar _producer: The application-layer producer. """ _producerPaused = False def __init__(self, producer): self._producer = producer def pauseProducing(self): """ C{pauseProducing} the underlying producer, if it's not paused. """ if self._producerPaused: return self._producerPaused = True self._producer.pauseProducing() def resumeProducing(self): """ C{resumeProducing} the underlying producer, if it's paused. """ if not self._producerPaused: return self._producerPaused = False self._producer.resumeProducing() def stopProducing(self): """ C{stopProducing} the underlying producer. There is only a single source for this event, so it's simply passed on. """ self._producer.stopProducing() @implementer(ISystemHandle, INegotiated) class TLSMemoryBIOProtocol(ProtocolWrapper): """ L{TLSMemoryBIOProtocol} is a protocol wrapper which uses OpenSSL via a memory BIO to encrypt bytes written to it before sending them on to the underlying transport and decrypts bytes received from the underlying transport before delivering them to the wrapped protocol. In addition to producer events from the underlying transport, the need to wait for reads before a write can proceed means the L{TLSMemoryBIOProtocol} may also want to pause a producer. Pause/resume events are therefore merged using the L{_ProducerMembrane} wrapper. Non-streaming (pull) producers are supported by wrapping them with L{_PullToPush}. @ivar _tlsConnection: The L{OpenSSL.SSL.Connection} instance which is encrypted and decrypting this connection. @ivar _lostTLSConnection: A flag indicating whether connection loss has already been dealt with (C{True}) or not (C{False}). TLS disconnection is distinct from the underlying connection being lost. @ivar _appSendBuffer: application-level (cleartext) data that is waiting to be transferred to the TLS buffer, but can't be because the TLS connection is handshaking. @type _appSendBuffer: L{list} of L{bytes} @ivar _connectWrapped: A flag indicating whether or not to call C{makeConnection} on the wrapped protocol. This is for the reactor's L{twisted.internet.interfaces.ITLSTransport.startTLS} implementation, since it has a protocol which it has already called C{makeConnection} on, and which has no interest in a new transport. See #3821. @ivar _handshakeDone: A flag indicating whether or not the handshake is known to have completed successfully (C{True}) or not (C{False}). This is used to control error reporting behavior. If the handshake has not completed, the underlying L{OpenSSL.SSL.Error} will be passed to the application's C{connectionLost} method. If it has completed, any unexpected L{OpenSSL.SSL.Error} will be turned into a L{ConnectionLost}. This is weird; however, it is simply an attempt at a faithful re-implementation of the behavior provided by L{twisted.internet.ssl}. @ivar _reason: If an unexpected L{OpenSSL.SSL.Error} occurs which causes the connection to be lost, it is saved here. If appropriate, this may be used as the reason passed to the application protocol's C{connectionLost} method. @ivar _producer: The current producer registered via C{registerProducer}, or L{None} if no producer has been registered or a previous one was unregistered. @ivar _aborted: C{abortConnection} has been called. No further data will be received to the wrapped protocol's C{dataReceived}. @type _aborted: L{bool} """ _reason = None _handshakeDone = False _lostTLSConnection = False _producer = None _aborted = False def __init__(self, factory, wrappedProtocol, _connectWrapped=True): ProtocolWrapper.__init__(self, factory, wrappedProtocol) self._connectWrapped = _connectWrapped def getHandle(self): """ Return the L{OpenSSL.SSL.Connection} object being used to encrypt and decrypt this connection. This is done for the benefit of L{twisted.internet.ssl.Certificate}'s C{peerFromTransport} and C{hostFromTransport} methods only. A different system handle may be returned by future versions of this method. """ return self._tlsConnection def makeConnection(self, transport): """ Connect this wrapper to the given transport and initialize the necessary L{OpenSSL.SSL.Connection} with a memory BIO. """ self._tlsConnection = self.factory._createConnection(self) self._appSendBuffer = [] # Add interfaces provided by the transport we are wrapping: for interface in providedBy(transport): directlyProvides(self, interface) # Intentionally skip ProtocolWrapper.makeConnection - it might call # wrappedProtocol.makeConnection, which we want to make conditional. Protocol.makeConnection(self, transport) self.factory.registerProtocol(self) if self._connectWrapped: # Now that the TLS layer is initialized, notify the application of # the connection. ProtocolWrapper.makeConnection(self, transport) # Now that we ourselves have a transport (initialized by the # ProtocolWrapper.makeConnection call above), kick off the TLS # handshake. self._checkHandshakeStatus() def _checkHandshakeStatus(self): """ Ask OpenSSL to proceed with a handshake in progress. Initially, this just sends the ClientHello; after some bytes have been stuffed in to the C{Connection} object by C{dataReceived}, it will then respond to any C{Certificate} or C{KeyExchange} messages. """ # The connection might already be aborted (eg. by a callback during # connection setup), so don't even bother trying to handshake in that # case. if self._aborted: return try: self._tlsConnection.do_handshake() except WantReadError: self._flushSendBIO() except Error: self._tlsShutdownFinished(Failure()) else: self._handshakeDone = True if IHandshakeListener.providedBy(self.wrappedProtocol): self.wrappedProtocol.handshakeCompleted() def _flushSendBIO(self): """ Read any bytes out of the send BIO and write them to the underlying transport. """ try: bytes = self._tlsConnection.bio_read(2 ** 15) except WantReadError: # There may be nothing in the send BIO right now. pass else: self.transport.write(bytes) def _flushReceiveBIO(self): """ Try to receive any application-level bytes which are now available because of a previous write into the receive BIO. This will take care of delivering any application-level bytes which are received to the protocol, as well as handling of the various exceptions which can come from trying to get such bytes. """ # Keep trying this until an error indicates we should stop or we # close the connection. Looping is necessary to make sure we # process all of the data which was put into the receive BIO, as # there is no guarantee that a single recv call will do it all. while not self._lostTLSConnection: try: bytes = self._tlsConnection.recv(2 ** 15) except WantReadError: # The newly received bytes might not have been enough to produce # any application data. break except ZeroReturnError: # TLS has shut down and no more TLS data will be received over # this connection. self._shutdownTLS() # Passing in None means the user protocol's connnectionLost # will get called with reason from underlying transport: self._tlsShutdownFinished(None) except Error: # Something went pretty wrong. For example, this might be a # handshake failure during renegotiation (because there were no # shared ciphers, because a certificate failed to verify, etc). # TLS can no longer proceed. failure = Failure() self._tlsShutdownFinished(failure) else: if not self._aborted: ProtocolWrapper.dataReceived(self, bytes) # The received bytes might have generated a response which needs to be # sent now. For example, the handshake involves several round-trip # exchanges without ever producing application-bytes. self._flushSendBIO() def dataReceived(self, bytes): """ Deliver any received bytes to the receive BIO and then read and deliver to the application any application-level data which becomes available as a result of this. """ # Let OpenSSL know some bytes were just received. self._tlsConnection.bio_write(bytes) # If we are still waiting for the handshake to complete, try to # complete the handshake with the bytes we just received. if not self._handshakeDone: self._checkHandshakeStatus() # If the handshake still isn't finished, then we've nothing left to # do. if not self._handshakeDone: return # If we've any pending writes, this read may have un-blocked them, so # attempt to unbuffer them into the OpenSSL layer. if self._appSendBuffer: self._unbufferPendingWrites() # Since the handshake is complete, the wire-level bytes we just # processed might turn into some application-level bytes; try to pull # those out. self._flushReceiveBIO() def _shutdownTLS(self): """ Initiate, or reply to, the shutdown handshake of the TLS layer. """ try: shutdownSuccess = self._tlsConnection.shutdown() except Error: # Mid-handshake, a call to shutdown() can result in a # WantWantReadError, or rather an SSL_ERR_WANT_READ; but pyOpenSSL # doesn't allow us to get at the error. See: # https://github.com/pyca/pyopenssl/issues/91 shutdownSuccess = False self._flushSendBIO() if shutdownSuccess: # Both sides have shutdown, so we can start closing lower-level # transport. This will also happen if we haven't started # negotiation at all yet, in which case shutdown succeeds # immediately. self.transport.loseConnection() def _tlsShutdownFinished(self, reason): """ Called when TLS connection has gone away; tell underlying transport to disconnect. @param reason: a L{Failure} whose value is an L{Exception} if we want to report that failure through to the wrapped protocol's C{connectionLost}, or L{None} if the C{reason} that C{connectionLost} should receive should be coming from the underlying transport. @type reason: L{Failure} or L{None} """ if reason is not None: # Squash an EOF in violation of the TLS protocol into # ConnectionLost, so that applications which might run over # multiple protocols can recognize its type. if tuple(reason.value.args[:2]) == (-1, "Unexpected EOF"): reason = Failure(CONNECTION_LOST) if self._reason is None: self._reason = reason self._lostTLSConnection = True # We may need to send a TLS alert regarding the nature of the shutdown # here (for example, why a handshake failed), so always flush our send # buffer before telling our lower-level transport to go away. self._flushSendBIO() # Using loseConnection causes the application protocol's # connectionLost method to be invoked non-reentrantly, which is always # a nice feature. However, for error cases (reason != None) we might # want to use abortConnection when it becomes available. The # loseConnection call is basically tested by test_handshakeFailure. # At least one side will need to do it or the test never finishes. self.transport.loseConnection() def connectionLost(self, reason): """ Handle the possible repetition of calls to this method (due to either the underlying transport going away or due to an error at the TLS layer) and make sure the base implementation only gets invoked once. """ if not self._lostTLSConnection: # Tell the TLS connection that it's not going to get any more data # and give it a chance to finish reading. self._tlsConnection.bio_shutdown() self._flushReceiveBIO() self._lostTLSConnection = True reason = self._reason or reason self._reason = None self.connected = False ProtocolWrapper.connectionLost(self, reason) # Breaking reference cycle between self._tlsConnection and self. self._tlsConnection = None def loseConnection(self): """ Send a TLS close alert and close the underlying connection. """ if self.disconnecting or not self.connected: return # If connection setup has not finished, OpenSSL 1.0.2f+ will not shut # down the connection until we write some data to the connection which # allows the handshake to complete. However, since no data should be # written after loseConnection, this means we'll be stuck forever # waiting for shutdown to complete. Instead, we simply abort the # connection without trying to shut down cleanly: if not self._handshakeDone and not self._appSendBuffer: self.abortConnection() self.disconnecting = True if not self._appSendBuffer and self._producer is None: self._shutdownTLS() def abortConnection(self): """ Tear down TLS state so that if the connection is aborted mid-handshake we don't deliver any further data from the application. """ self._aborted = True self.disconnecting = True self._shutdownTLS() self.transport.abortConnection() def failVerification(self, reason): """ Abort the connection during connection setup, giving a reason that certificate verification failed. @param reason: The reason that the verification failed; reported to the application protocol's C{connectionLost} method. @type reason: L{Failure} """ self._reason = reason self.abortConnection() def write(self, bytes): """ Process the given application bytes and send any resulting TLS traffic which arrives in the send BIO. If C{loseConnection} was called, subsequent calls to C{write} will drop the bytes on the floor. """ if isinstance(bytes, str): raise TypeError("Must write bytes to a TLS transport, not str.") # Writes after loseConnection are not supported, unless a producer has # been registered, in which case writes can happen until the producer # is unregistered: if self.disconnecting and self._producer is None: return self._write(bytes) def _bufferedWrite(self, octets): """ Put the given octets into L{TLSMemoryBIOProtocol._appSendBuffer}, and tell any listening producer that it should pause because we are now buffering. """ self._appSendBuffer.append(octets) if self._producer is not None: self._producer.pauseProducing() def _unbufferPendingWrites(self): """ Un-buffer all waiting writes in L{TLSMemoryBIOProtocol._appSendBuffer}. """ pendingWrites, self._appSendBuffer = self._appSendBuffer, [] for eachWrite in pendingWrites: self._write(eachWrite) if self._appSendBuffer: # If OpenSSL ran out of buffer space in the Connection on our way # through the loop earlier and re-buffered any of our outgoing # writes, then we're done; don't consider any future work. return if self._producer is not None: # If we have a registered producer, let it know that we have some # more buffer space. self._producer.resumeProducing() return if self.disconnecting: # Finally, if we have no further buffered data, no producer wants # to send us more data in the future, and the application told us # to end the stream, initiate a TLS shutdown. self._shutdownTLS() def _write(self, bytes): """ Process the given application bytes and send any resulting TLS traffic which arrives in the send BIO. This may be called by C{dataReceived} with bytes that were buffered before C{loseConnection} was called, which is why this function doesn't check for disconnection but accepts the bytes regardless. """ if self._lostTLSConnection: return # A TLS payload is 16kB max bufferSize = 2 ** 14 # How far into the input we've gotten so far alreadySent = 0 while alreadySent < len(bytes): toSend = bytes[alreadySent : alreadySent + bufferSize] try: sent = self._tlsConnection.send(toSend) except WantReadError: self._bufferedWrite(bytes[alreadySent:]) break except Error: # Pretend TLS connection disconnected, which will trigger # disconnect of underlying transport. The error will be passed # to the application protocol's connectionLost method. The # other SSL implementation doesn't, but losing helpful # debugging information is a bad idea. self._tlsShutdownFinished(Failure()) break else: # We've successfully handed off the bytes to the OpenSSL # Connection object. alreadySent += sent # See if OpenSSL wants to hand any bytes off to the underlying # transport as a result. self._flushSendBIO() def writeSequence(self, iovec): """ Write a sequence of application bytes by joining them into one string and passing them to L{write}. """ self.write(b"".join(iovec)) def getPeerCertificate(self): return self._tlsConnection.get_peer_certificate() @property def negotiatedProtocol(self): """ @see: L{INegotiated.negotiatedProtocol} """ protocolName = None try: # If ALPN is not implemented that's ok, NPN might be. protocolName = self._tlsConnection.get_alpn_proto_negotiated() except (NotImplementedError, AttributeError): pass if protocolName not in (b"", None): # A protocol was selected using ALPN. return protocolName try: protocolName = self._tlsConnection.get_next_proto_negotiated() except (NotImplementedError, AttributeError): pass if protocolName != b"": return protocolName return None def registerProducer(self, producer, streaming): # If we've already disconnected, nothing to do here: if self._lostTLSConnection: producer.stopProducing() return # If we received a non-streaming producer, wrap it so it becomes a # streaming producer: if not streaming: producer = streamingProducer = _PullToPush(producer, self) producer = _ProducerMembrane(producer) # This will raise an exception if a producer is already registered: self.transport.registerProducer(producer, True) self._producer = producer # If we received a non-streaming producer, we need to start the # streaming wrapper: if not streaming: streamingProducer.startStreaming() def unregisterProducer(self): # If we have no producer, we don't need to do anything here. if self._producer is None: return # If we received a non-streaming producer, we need to stop the # streaming wrapper: if isinstance(self._producer._producer, _PullToPush): self._producer._producer.stopStreaming() self._producer = None self._producerPaused = False self.transport.unregisterProducer() if self.disconnecting and not self._appSendBuffer: self._shutdownTLS() @implementer(IOpenSSLClientConnectionCreator, IOpenSSLServerConnectionCreator) class _ContextFactoryToConnectionFactory: """ Adapter wrapping a L{twisted.internet.interfaces.IOpenSSLContextFactory} into a L{IOpenSSLClientConnectionCreator} or L{IOpenSSLServerConnectionCreator}. See U{https://twistedmatrix.com/trac/ticket/7215} for work that should make this unnecessary. """ def __init__(self, oldStyleContextFactory): """ Construct a L{_ContextFactoryToConnectionFactory} with a L{twisted.internet.interfaces.IOpenSSLContextFactory}. Immediately call C{getContext} on C{oldStyleContextFactory} in order to force advance parameter checking, since old-style context factories don't actually check that their arguments to L{OpenSSL} are correct. @param oldStyleContextFactory: A factory that can produce contexts. @type oldStyleContextFactory: L{twisted.internet.interfaces.IOpenSSLContextFactory} """ oldStyleContextFactory.getContext() self._oldStyleContextFactory = oldStyleContextFactory def _connectionForTLS(self, protocol): """ Create an L{OpenSSL.SSL.Connection} object. @param protocol: The protocol initiating a TLS connection. @type protocol: L{TLSMemoryBIOProtocol} @return: a connection @rtype: L{OpenSSL.SSL.Connection} """ context = self._oldStyleContextFactory.getContext() return Connection(context, None) def serverConnectionForTLS(self, protocol): """ Construct an OpenSSL server connection from the wrapped old-style context factory. @note: Since old-style context factories don't distinguish between clients and servers, this is exactly the same as L{_ContextFactoryToConnectionFactory.clientConnectionForTLS}. @param protocol: The protocol initiating a TLS connection. @type protocol: L{TLSMemoryBIOProtocol} @return: a connection @rtype: L{OpenSSL.SSL.Connection} """ return self._connectionForTLS(protocol) def clientConnectionForTLS(self, protocol): """ Construct an OpenSSL server connection from the wrapped old-style context factory. @note: Since old-style context factories don't distinguish between clients and servers, this is exactly the same as L{_ContextFactoryToConnectionFactory.serverConnectionForTLS}. @param protocol: The protocol initiating a TLS connection. @type protocol: L{TLSMemoryBIOProtocol} @return: a connection @rtype: L{OpenSSL.SSL.Connection} """ return self._connectionForTLS(protocol) class TLSMemoryBIOFactory(WrappingFactory): """ L{TLSMemoryBIOFactory} adds TLS to connections. @ivar _creatorInterface: the interface which L{_connectionCreator} is expected to implement. @type _creatorInterface: L{zope.interface.interfaces.IInterface} @ivar _connectionCreator: a callable which creates an OpenSSL Connection object. @type _connectionCreator: 1-argument callable taking L{TLSMemoryBIOProtocol} and returning L{OpenSSL.SSL.Connection}. """ protocol = TLSMemoryBIOProtocol noisy = False # disable unnecessary logging. def __init__(self, contextFactory, isClient, wrappedFactory): """ Create a L{TLSMemoryBIOFactory}. @param contextFactory: Configuration parameters used to create an OpenSSL connection. In order of preference, what you should pass here should be: 1. L{twisted.internet.ssl.CertificateOptions} (if you're writing a server) or the result of L{twisted.internet.ssl.optionsForClientTLS} (if you're writing a client). If you want security you should really use one of these. 2. If you really want to implement something yourself, supply a provider of L{IOpenSSLClientConnectionCreator} or L{IOpenSSLServerConnectionCreator}. 3. If you really have to, supply a L{twisted.internet.ssl.ContextFactory}. This will likely be deprecated at some point so please upgrade to the new interfaces. @type contextFactory: L{IOpenSSLClientConnectionCreator} or L{IOpenSSLServerConnectionCreator}, or, for compatibility with older code, anything implementing L{twisted.internet.interfaces.IOpenSSLContextFactory}. See U{https://twistedmatrix.com/trac/ticket/7215} for information on the upcoming deprecation of passing a L{twisted.internet.ssl.ContextFactory} here. @param isClient: Is this a factory for TLS client connections; in other words, those that will send a C{ClientHello} greeting? L{True} if so, L{False} otherwise. This flag determines what interface is expected of C{contextFactory}. If L{True}, C{contextFactory} should provide L{IOpenSSLClientConnectionCreator}; otherwise it should provide L{IOpenSSLServerConnectionCreator}. @type isClient: L{bool} @param wrappedFactory: A factory which will create the application-level protocol. @type wrappedFactory: L{twisted.internet.interfaces.IProtocolFactory} """ WrappingFactory.__init__(self, wrappedFactory) if isClient: creatorInterface = IOpenSSLClientConnectionCreator else: creatorInterface = IOpenSSLServerConnectionCreator self._creatorInterface = creatorInterface if not creatorInterface.providedBy(contextFactory): contextFactory = _ContextFactoryToConnectionFactory(contextFactory) self._connectionCreator = contextFactory def logPrefix(self): """ Annotate the wrapped factory's log prefix with some text indicating TLS is in use. @rtype: C{str} """ if ILoggingContext.providedBy(self.wrappedFactory): logPrefix = self.wrappedFactory.logPrefix() else: logPrefix = self.wrappedFactory.__class__.__name__ return f"{logPrefix} (TLS)" def _applyProtocolNegotiation(self, connection): """ Applies ALPN/NPN protocol neogitation to the connection, if the factory supports it. @param connection: The OpenSSL connection object to have ALPN/NPN added to it. @type connection: L{OpenSSL.SSL.Connection} @return: Nothing @rtype: L{None} """ if IProtocolNegotiationFactory.providedBy(self.wrappedFactory): protocols = self.wrappedFactory.acceptableProtocols() context = connection.get_context() _setAcceptableProtocols(context, protocols) return def _createConnection(self, tlsProtocol): """ Create an OpenSSL connection and set it up good. @param tlsProtocol: The protocol which is establishing the connection. @type tlsProtocol: L{TLSMemoryBIOProtocol} @return: an OpenSSL connection object for C{tlsProtocol} to use @rtype: L{OpenSSL.SSL.Connection} """ connectionCreator = self._connectionCreator if self._creatorInterface is IOpenSSLClientConnectionCreator: connection = connectionCreator.clientConnectionForTLS(tlsProtocol) self._applyProtocolNegotiation(connection) connection.set_connect_state() else: connection = connectionCreator.serverConnectionForTLS(tlsProtocol) self._applyProtocolNegotiation(connection) connection.set_accept_state() return connection PK Mb�Z?4�qc\ c\ protocols/memcache.pynu �[��� # -*- test-case-name: twisted.test.test_memcache -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Memcache client protocol. Memcached is a caching server, storing data in the form of pairs key/value, and memcache is the protocol to talk with it. To connect to a server, create a factory for L{MemCacheProtocol}:: from twisted.internet import reactor, protocol from twisted.protocols.memcache import MemCacheProtocol, DEFAULT_PORT d = protocol.ClientCreator(reactor, MemCacheProtocol ).connectTCP("localhost", DEFAULT_PORT) def doSomething(proto): # Here you call the memcache operations return proto.set("mykey", "a lot of data") d.addCallback(doSomething) reactor.run() All the operations of the memcache protocol are present, but L{MemCacheProtocol.set} and L{MemCacheProtocol.get} are the more important. See U{http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt} for more information about the protocol. """ from collections import deque from twisted.internet.defer import Deferred, TimeoutError, fail from twisted.protocols.basic import LineReceiver from twisted.protocols.policies import TimeoutMixin from twisted.python import log from twisted.python.compat import nativeString, networkString DEFAULT_PORT = 11211 class NoSuchCommand(Exception): """ Exception raised when a non existent command is called. """ class ClientError(Exception): """ Error caused by an invalid client call. """ class ServerError(Exception): """ Problem happening on the server. """ class Command: """ Wrap a client action into an object, that holds the values used in the protocol. @ivar _deferred: the L{Deferred} object that will be fired when the result arrives. @type _deferred: L{Deferred} @ivar command: name of the command sent to the server. @type command: L{bytes} """ def __init__(self, command, **kwargs): """ Create a command. @param command: the name of the command. @type command: L{bytes} @param kwargs: this values will be stored as attributes of the object for future use """ self.command = command self._deferred = Deferred() for k, v in kwargs.items(): setattr(self, k, v) def success(self, value): """ Shortcut method to fire the underlying deferred. """ self._deferred.callback(value) def fail(self, error): """ Make the underlying deferred fails. """ self._deferred.errback(error) class MemCacheProtocol(LineReceiver, TimeoutMixin): """ MemCache protocol: connect to a memcached server to store/retrieve values. @ivar persistentTimeOut: the timeout period used to wait for a response. @type persistentTimeOut: L{int} @ivar _current: current list of requests waiting for an answer from the server. @type _current: L{deque} of L{Command} @ivar _lenExpected: amount of data expected in raw mode, when reading for a value. @type _lenExpected: L{int} @ivar _getBuffer: current buffer of data, used to store temporary data when reading in raw mode. @type _getBuffer: L{list} @ivar _bufferLength: the total amount of bytes in C{_getBuffer}. @type _bufferLength: L{int} @ivar _disconnected: indicate if the connectionLost has been called or not. @type _disconnected: L{bool} """ MAX_KEY_LENGTH = 250 _disconnected = False def __init__(self, timeOut=60): """ Create the protocol. @param timeOut: the timeout to wait before detecting that the connection is dead and close it. It's expressed in seconds. @type timeOut: L{int} """ self._current = deque() self._lenExpected = None self._getBuffer = None self._bufferLength = None self.persistentTimeOut = self.timeOut = timeOut def _cancelCommands(self, reason): """ Cancel all the outstanding commands, making them fail with C{reason}. """ while self._current: cmd = self._current.popleft() cmd.fail(reason) def timeoutConnection(self): """ Close the connection in case of timeout. """ self._cancelCommands(TimeoutError("Connection timeout")) self.transport.loseConnection() def connectionLost(self, reason): """ Cause any outstanding commands to fail. """ self._disconnected = True self._cancelCommands(reason) LineReceiver.connectionLost(self, reason) def sendLine(self, line): """ Override sendLine to add a timeout to response. """ if not self._current: self.setTimeout(self.persistentTimeOut) LineReceiver.sendLine(self, line) def rawDataReceived(self, data): """ Collect data for a get. """ self.resetTimeout() self._getBuffer.append(data) self._bufferLength += len(data) if self._bufferLength >= self._lenExpected + 2: data = b"".join(self._getBuffer) buf = data[: self._lenExpected] rem = data[self._lenExpected + 2 :] val = buf self._lenExpected = None self._getBuffer = None self._bufferLength = None cmd = self._current[0] if cmd.multiple: flags, cas = cmd.values[cmd.currentKey] cmd.values[cmd.currentKey] = (flags, cas, val) else: cmd.value = val self.setLineMode(rem) def cmd_STORED(self): """ Manage a success response to a set operation. """ self._current.popleft().success(True) def cmd_NOT_STORED(self): """ Manage a specific 'not stored' response to a set operation: this is not an error, but some condition wasn't met. """ self._current.popleft().success(False) def cmd_END(self): """ This the end token to a get or a stat operation. """ cmd = self._current.popleft() if cmd.command == b"get": if cmd.multiple: values = {key: val[::2] for key, val in cmd.values.items()} cmd.success(values) else: cmd.success((cmd.flags, cmd.value)) elif cmd.command == b"gets": if cmd.multiple: cmd.success(cmd.values) else: cmd.success((cmd.flags, cmd.cas, cmd.value)) elif cmd.command == b"stats": cmd.success(cmd.values) else: raise RuntimeError( "Unexpected END response to {} command".format( nativeString(cmd.command) ) ) def cmd_NOT_FOUND(self): """ Manage error response for incr/decr/delete. """ self._current.popleft().success(False) def cmd_VALUE(self, line): """ Prepare the reading a value after a get. """ cmd = self._current[0] if cmd.command == b"get": key, flags, length = line.split() cas = b"" else: key, flags, length, cas = line.split() self._lenExpected = int(length) self._getBuffer = [] self._bufferLength = 0 if cmd.multiple: if key not in cmd.keys: raise RuntimeError("Unexpected commands answer.") cmd.currentKey = key cmd.values[key] = [int(flags), cas] else: if cmd.key != key: raise RuntimeError("Unexpected commands answer.") cmd.flags = int(flags) cmd.cas = cas self.setRawMode() def cmd_STAT(self, line): """ Reception of one stat line. """ cmd = self._current[0] key, val = line.split(b" ", 1) cmd.values[key] = val def cmd_VERSION(self, versionData): """ Read version token. """ self._current.popleft().success(versionData) def cmd_ERROR(self): """ A non-existent command has been sent. """ log.err("Non-existent command sent.") cmd = self._current.popleft() cmd.fail(NoSuchCommand()) def cmd_CLIENT_ERROR(self, errText): """ An invalid input as been sent. """ errText = repr(errText) log.err("Invalid input: " + errText) cmd = self._current.popleft() cmd.fail(ClientError(errText)) def cmd_SERVER_ERROR(self, errText): """ An error has happened server-side. """ errText = repr(errText) log.err("Server error: " + errText) cmd = self._current.popleft() cmd.fail(ServerError(errText)) def cmd_DELETED(self): """ A delete command has completed successfully. """ self._current.popleft().success(True) def cmd_OK(self): """ The last command has been completed. """ self._current.popleft().success(True) def cmd_EXISTS(self): """ A C{checkAndSet} update has failed. """ self._current.popleft().success(False) def lineReceived(self, line): """ Receive line commands from the server. """ self.resetTimeout() token = line.split(b" ", 1)[0] # First manage standard commands without space cmd = getattr(self, "cmd_" + nativeString(token), None) if cmd is not None: args = line.split(b" ", 1)[1:] if args: cmd(args[0]) else: cmd() else: # Then manage commands with space in it line = line.replace(b" ", b"_") cmd = getattr(self, "cmd_" + nativeString(line), None) if cmd is not None: cmd() else: # Increment/Decrement response cmd = self._current.popleft() val = int(line) cmd.success(val) if not self._current: # No pending request, remove timeout self.setTimeout(None) def increment(self, key, val=1): """ Increment the value of C{key} by given value (default to 1). C{key} must be consistent with an int. Return the new value. @param key: the key to modify. @type key: L{bytes} @param val: the value to increment. @type val: L{int} @return: a deferred with will be called back with the new value associated with the key (after the increment). @rtype: L{Deferred} """ return self._incrdecr(b"incr", key, val) def decrement(self, key, val=1): """ Decrement the value of C{key} by given value (default to 1). C{key} must be consistent with an int. Return the new value, coerced to 0 if negative. @param key: the key to modify. @type key: L{bytes} @param val: the value to decrement. @type val: L{int} @return: a deferred with will be called back with the new value associated with the key (after the decrement). @rtype: L{Deferred} """ return self._incrdecr(b"decr", key, val) def _incrdecr(self, cmd, key, val): """ Internal wrapper for incr/decr. """ if self._disconnected: return fail(RuntimeError("not connected")) if not isinstance(key, bytes): return fail( ClientError(f"Invalid type for key: {type(key)}, expecting bytes") ) if len(key) > self.MAX_KEY_LENGTH: return fail(ClientError("Key too long")) fullcmd = b" ".join([cmd, key, b"%d" % (int(val),)]) self.sendLine(fullcmd) cmdObj = Command(cmd, key=key) self._current.append(cmdObj) return cmdObj._deferred def replace(self, key, val, flags=0, expireTime=0): """ Replace the given C{key}. It must already exist in the server. @param key: the key to replace. @type key: L{bytes} @param val: the new value associated with the key. @type val: L{bytes} @param flags: the flags to store with the key. @type flags: L{int} @param expireTime: if different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: a deferred that will fire with C{True} if the operation has succeeded, and C{False} with the key didn't previously exist. @rtype: L{Deferred} """ return self._set(b"replace", key, val, flags, expireTime, b"") def add(self, key, val, flags=0, expireTime=0): """ Add the given C{key}. It must not exist in the server. @param key: the key to add. @type key: L{bytes} @param val: the value associated with the key. @type val: L{bytes} @param flags: the flags to store with the key. @type flags: L{int} @param expireTime: if different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: a deferred that will fire with C{True} if the operation has succeeded, and C{False} with the key already exists. @rtype: L{Deferred} """ return self._set(b"add", key, val, flags, expireTime, b"") def set(self, key, val, flags=0, expireTime=0): """ Set the given C{key}. @param key: the key to set. @type key: L{bytes} @param val: the value associated with the key. @type val: L{bytes} @param flags: the flags to store with the key. @type flags: L{int} @param expireTime: if different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: a deferred that will fire with C{True} if the operation has succeeded. @rtype: L{Deferred} """ return self._set(b"set", key, val, flags, expireTime, b"") def checkAndSet(self, key, val, cas, flags=0, expireTime=0): """ Change the content of C{key} only if the C{cas} value matches the current one associated with the key. Use this to store a value which hasn't been modified since last time you fetched it. @param key: The key to set. @type key: L{bytes} @param val: The value associated with the key. @type val: L{bytes} @param cas: Unique 64-bit value returned by previous call of C{get}. @type cas: L{bytes} @param flags: The flags to store with the key. @type flags: L{int} @param expireTime: If different from 0, the relative time in seconds when the key will be deleted from the store. @type expireTime: L{int} @return: A deferred that will fire with C{True} if the operation has succeeded, C{False} otherwise. @rtype: L{Deferred} """ return self._set(b"cas", key, val, flags, expireTime, cas) def _set(self, cmd, key, val, flags, expireTime, cas): """ Internal wrapper for setting values. """ if self._disconnected: return fail(RuntimeError("not connected")) if not isinstance(key, bytes): return fail( ClientError(f"Invalid type for key: {type(key)}, expecting bytes") ) if len(key) > self.MAX_KEY_LENGTH: return fail(ClientError("Key too long")) if not isinstance(val, bytes): return fail( ClientError(f"Invalid type for value: {type(val)}, expecting bytes") ) if cas: cas = b" " + cas length = len(val) fullcmd = ( b" ".join( [cmd, key, networkString("%d %d %d" % (flags, expireTime, length))] ) + cas ) self.sendLine(fullcmd) self.sendLine(val) cmdObj = Command(cmd, key=key, flags=flags, length=length) self._current.append(cmdObj) return cmdObj._deferred def append(self, key, val): """ Append given data to the value of an existing key. @param key: The key to modify. @type key: L{bytes} @param val: The value to append to the current value associated with the key. @type val: L{bytes} @return: A deferred that will fire with C{True} if the operation has succeeded, C{False} otherwise. @rtype: L{Deferred} """ # Even if flags and expTime values are ignored, we have to pass them return self._set(b"append", key, val, 0, 0, b"") def prepend(self, key, val): """ Prepend given data to the value of an existing key. @param key: The key to modify. @type key: L{bytes} @param val: The value to prepend to the current value associated with the key. @type val: L{bytes} @return: A deferred that will fire with C{True} if the operation has succeeded, C{False} otherwise. @rtype: L{Deferred} """ # Even if flags and expTime values are ignored, we have to pass them return self._set(b"prepend", key, val, 0, 0, b"") def get(self, key, withIdentifier=False): """ Get the given C{key}. It doesn't support multiple keys. If C{withIdentifier} is set to C{True}, the command issued is a C{gets}, that will return the current identifier associated with the value. This identifier has to be used when issuing C{checkAndSet} update later, using the corresponding method. @param key: The key to retrieve. @type key: L{bytes} @param withIdentifier: If set to C{True}, retrieve the current identifier along with the value and the flags. @type withIdentifier: L{bool} @return: A deferred that will fire with the tuple (flags, value) if C{withIdentifier} is C{False}, or (flags, cas identifier, value) if C{True}. If the server indicates there is no value associated with C{key}, the returned value will be L{None} and the returned flags will be C{0}. @rtype: L{Deferred} """ return self._get([key], withIdentifier, False) def getMultiple(self, keys, withIdentifier=False): """ Get the given list of C{keys}. If C{withIdentifier} is set to C{True}, the command issued is a C{gets}, that will return the identifiers associated with each values. This identifier has to be used when issuing C{checkAndSet} update later, using the corresponding method. @param keys: The keys to retrieve. @type keys: L{list} of L{bytes} @param withIdentifier: If set to C{True}, retrieve the identifiers along with the values and the flags. @type withIdentifier: L{bool} @return: A deferred that will fire with a dictionary with the elements of C{keys} as keys and the tuples (flags, value) as values if C{withIdentifier} is C{False}, or (flags, cas identifier, value) if C{True}. If the server indicates there is no value associated with C{key}, the returned values will be L{None} and the returned flags will be C{0}. @rtype: L{Deferred} @since: 9.0 """ return self._get(keys, withIdentifier, True) def _get(self, keys, withIdentifier, multiple): """ Helper method for C{get} and C{getMultiple}. """ keys = list(keys) if self._disconnected: return fail(RuntimeError("not connected")) for key in keys: if not isinstance(key, bytes): return fail( ClientError(f"Invalid type for key: {type(key)}, expecting bytes") ) if len(key) > self.MAX_KEY_LENGTH: return fail(ClientError("Key too long")) if withIdentifier: cmd = b"gets" else: cmd = b"get" fullcmd = b" ".join([cmd] + keys) self.sendLine(fullcmd) if multiple: values = {key: (0, b"", None) for key in keys} cmdObj = Command(cmd, keys=keys, values=values, multiple=True) else: cmdObj = Command( cmd, key=keys[0], value=None, flags=0, cas=b"", multiple=False ) self._current.append(cmdObj) return cmdObj._deferred def stats(self, arg=None): """ Get some stats from the server. It will be available as a dict. @param arg: An optional additional string which will be sent along with the I{stats} command. The interpretation of this value by the server is left undefined by the memcache protocol specification. @type arg: L{None} or L{bytes} @return: a deferred that will fire with a L{dict} of the available statistics. @rtype: L{Deferred} """ if arg: cmd = b"stats " + arg else: cmd = b"stats" if self._disconnected: return fail(RuntimeError("not connected")) self.sendLine(cmd) cmdObj = Command(b"stats", values={}) self._current.append(cmdObj) return cmdObj._deferred def version(self): """ Get the version of the server. @return: a deferred that will fire with the string value of the version. @rtype: L{Deferred} """ if self._disconnected: return fail(RuntimeError("not connected")) self.sendLine(b"version") cmdObj = Command(b"version") self._current.append(cmdObj) return cmdObj._deferred def delete(self, key): """ Delete an existing C{key}. @param key: the key to delete. @type key: L{bytes} @return: a deferred that will be called back with C{True} if the key was successfully deleted, or C{False} if not. @rtype: L{Deferred} """ if self._disconnected: return fail(RuntimeError("not connected")) if not isinstance(key, bytes): return fail( ClientError(f"Invalid type for key: {type(key)}, expecting bytes") ) self.sendLine(b"delete " + key) cmdObj = Command(b"delete", key=key) self._current.append(cmdObj) return cmdObj._deferred def flushAll(self): """ Flush all cached values. @return: a deferred that will be called back with C{True} when the operation has succeeded. @rtype: L{Deferred} """ if self._disconnected: return fail(RuntimeError("not connected")) self.sendLine(b"flush_all") cmdObj = Command(b"flush_all") self._current.append(cmdObj) return cmdObj._deferred __all__ = [ "MemCacheProtocol", "DEFAULT_PORT", "NoSuchCommand", "ClientError", "ServerError", ] PK Mb�Z)�� � protocols/test/test_basic.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.protocols.basic}. """ import struct import sys from io import BytesIO from typing import List, Optional, Type from zope.interface.verify import verifyObject from twisted.internet import protocol, task from twisted.internet.interfaces import IProducer from twisted.internet.protocol import connectionDone from twisted.protocols import basic from twisted.python.compat import iterbytes from twisted.python.failure import Failure from twisted.test import proto_helpers from twisted.trial import unittest class FlippingLineTester(basic.LineReceiver): """ A line receiver that flips between line and raw data modes after one byte. """ delimiter = b"\n" def __init__(self): self.lines = [] def lineReceived(self, line): """ Set the mode to raw. """ self.lines.append(line) self.setRawMode() def rawDataReceived(self, data): """ Set the mode back to line. """ self.setLineMode(data[1:]) class LineTester(basic.LineReceiver): """ A line receiver that parses data received and make actions on some tokens. @type delimiter: C{bytes} @ivar delimiter: character used between received lines. @type MAX_LENGTH: C{int} @ivar MAX_LENGTH: size of a line when C{lineLengthExceeded} will be called. @type clock: L{twisted.internet.task.Clock} @ivar clock: clock simulating reactor callLater. Pass it to constructor if you want to use the pause/rawpause functionalities. """ delimiter = b"\n" MAX_LENGTH = 64 def __init__(self, clock=None): """ If given, use a clock to make callLater calls. """ self.clock = clock def connectionMade(self): """ Create/clean data received on connection. """ self.received = [] def lineReceived(self, line): """ Receive line and make some action for some tokens: pause, rawpause, stop, len, produce, unproduce. """ self.received.append(line) if line == b"": self.setRawMode() elif line == b"pause": self.pauseProducing() self.clock.callLater(0, self.resumeProducing) elif line == b"rawpause": self.pauseProducing() self.setRawMode() self.received.append(b"") self.clock.callLater(0, self.resumeProducing) elif line == b"stop": self.stopProducing() elif line[:4] == b"len ": self.length = int(line[4:]) elif line.startswith(b"produce"): self.transport.registerProducer(self, False) elif line.startswith(b"unproduce"): self.transport.unregisterProducer() def rawDataReceived(self, data): """ Read raw data, until the quantity specified by a previous 'len' line is reached. """ data, rest = data[: self.length], data[self.length :] self.length = self.length - len(data) self.received[-1] = self.received[-1] + data if self.length == 0: self.setLineMode(rest) def lineLengthExceeded(self, line): """ Adjust line mode when long lines received. """ if len(line) > self.MAX_LENGTH + 1: self.setLineMode(line[self.MAX_LENGTH + 1 :]) class LineOnlyTester(basic.LineOnlyReceiver): """ A buffering line only receiver. """ delimiter = b"\n" MAX_LENGTH = 64 def connectionMade(self): """ Create/clean data received on connection. """ self.received = [] def lineReceived(self, line): """ Save received data. """ self.received.append(line) class LineReceiverTests(unittest.SynchronousTestCase): """ Test L{twisted.protocols.basic.LineReceiver}, using the C{LineTester} wrapper. """ buffer = b"""\ len 10 0123456789len 5 1234 len 20 foo 123 0123456789 012345678len 0 foo 5 1234567890123456789012345678901234567890123456789012345678901234567890 len 1 a""" output = [ b"len 10", b"0123456789", b"len 5", b"1234\n", b"len 20", b"foo 123", b"0123456789\n012345678", b"len 0", b"foo 5", b"", b"67890", b"len 1", b"a", ] def test_buffer(self): """ Test buffering for different packet size, checking received matches expected data. """ for packet_size in range(1, 10): t = proto_helpers.StringIOWithoutClosing() a = LineTester() a.makeConnection(protocol.FileWrapper(t)) for i in range(len(self.buffer) // packet_size + 1): s = self.buffer[i * packet_size : (i + 1) * packet_size] a.dataReceived(s) self.assertEqual(self.output, a.received) pauseBuf = b"twiddle1\ntwiddle2\npause\ntwiddle3\n" pauseOutput1 = [b"twiddle1", b"twiddle2", b"pause"] pauseOutput2 = pauseOutput1 + [b"twiddle3"] def test_pausing(self): """ Test pause inside data receiving. It uses fake clock to see if pausing/resuming work. """ for packet_size in range(1, 10): t = proto_helpers.StringIOWithoutClosing() clock = task.Clock() a = LineTester(clock) a.makeConnection(protocol.FileWrapper(t)) for i in range(len(self.pauseBuf) // packet_size + 1): s = self.pauseBuf[i * packet_size : (i + 1) * packet_size] a.dataReceived(s) self.assertEqual(self.pauseOutput1, a.received) clock.advance(0) self.assertEqual(self.pauseOutput2, a.received) rawpauseBuf = b"twiddle1\ntwiddle2\nlen 5\nrawpause\n12345twiddle3\n" rawpauseOutput1 = [b"twiddle1", b"twiddle2", b"len 5", b"rawpause", b""] rawpauseOutput2 = [ b"twiddle1", b"twiddle2", b"len 5", b"rawpause", b"12345", b"twiddle3", ] def test_rawPausing(self): """ Test pause inside raw date receiving. """ for packet_size in range(1, 10): t = proto_helpers.StringIOWithoutClosing() clock = task.Clock() a = LineTester(clock) a.makeConnection(protocol.FileWrapper(t)) for i in range(len(self.rawpauseBuf) // packet_size + 1): s = self.rawpauseBuf[i * packet_size : (i + 1) * packet_size] a.dataReceived(s) self.assertEqual(self.rawpauseOutput1, a.received) clock.advance(0) self.assertEqual(self.rawpauseOutput2, a.received) stop_buf = b"twiddle1\ntwiddle2\nstop\nmore\nstuff\n" stop_output = [b"twiddle1", b"twiddle2", b"stop"] def test_stopProducing(self): """ Test stop inside producing. """ for packet_size in range(1, 10): t = proto_helpers.StringIOWithoutClosing() a = LineTester() a.makeConnection(protocol.FileWrapper(t)) for i in range(len(self.stop_buf) // packet_size + 1): s = self.stop_buf[i * packet_size : (i + 1) * packet_size] a.dataReceived(s) self.assertEqual(self.stop_output, a.received) def test_lineReceiverAsProducer(self): """ Test produce/unproduce in receiving. """ a = LineTester() t = proto_helpers.StringIOWithoutClosing() a.makeConnection(protocol.FileWrapper(t)) a.dataReceived(b"produce\nhello world\nunproduce\ngoodbye\n") self.assertEqual( a.received, [b"produce", b"hello world", b"unproduce", b"goodbye"] ) def test_clearLineBuffer(self): """ L{LineReceiver.clearLineBuffer} removes all buffered data and returns it as a C{bytes} and can be called from beneath C{dataReceived}. """ class ClearingReceiver(basic.LineReceiver): def lineReceived(self, line): self.line = line self.rest = self.clearLineBuffer() protocol = ClearingReceiver() protocol.dataReceived(b"foo\r\nbar\r\nbaz") self.assertEqual(protocol.line, b"foo") self.assertEqual(protocol.rest, b"bar\r\nbaz") # Deliver another line to make sure the previously buffered data is # really gone. protocol.dataReceived(b"quux\r\n") self.assertEqual(protocol.line, b"quux") self.assertEqual(protocol.rest, b"") def test_stackRecursion(self): """ Test switching modes many times on the same data. """ proto = FlippingLineTester() transport = proto_helpers.StringIOWithoutClosing() proto.makeConnection(protocol.FileWrapper(transport)) limit = sys.getrecursionlimit() proto.dataReceived(b"x\nx" * limit) self.assertEqual(b"x" * limit, b"".join(proto.lines)) def test_maximumLineLength(self): """ C{LineReceiver} disconnects the transport if it receives a line longer than its C{MAX_LENGTH}. """ proto = basic.LineReceiver() transport = proto_helpers.StringTransport() proto.makeConnection(transport) proto.dataReceived(b"x" * (proto.MAX_LENGTH + 1) + b"\r\nr") self.assertTrue(transport.disconnecting) def test_maximumLineLengthPartialDelimiter(self): """ C{LineReceiver} doesn't disconnect the transport when it receives a finished line as long as its C{MAX_LENGTH}, when the second-to-last packet ended with a pattern that could have been -- and turns out to have been -- the start of a delimiter, and that packet causes the total input to exceed C{MAX_LENGTH} + len(delimiter). """ proto = LineTester() proto.MAX_LENGTH = 4 t = proto_helpers.StringTransport() proto.makeConnection(t) line = b"x" * (proto.MAX_LENGTH - 1) proto.dataReceived(line) proto.dataReceived(proto.delimiter[:-1]) proto.dataReceived(proto.delimiter[-1:] + line) self.assertFalse(t.disconnecting) self.assertEqual(len(proto.received), 1) self.assertEqual(line, proto.received[0]) def test_notQuiteMaximumLineLengthUnfinished(self): """ C{LineReceiver} doesn't disconnect the transport it if receives a non-finished line whose length, counting the delimiter, is longer than its C{MAX_LENGTH} but shorter than its C{MAX_LENGTH} + len(delimiter). (When the first part that exceeds the max is the beginning of the delimiter.) """ proto = basic.LineReceiver() # '\r\n' is the default, but we set it just to be explicit in # this test. proto.delimiter = b"\r\n" transport = proto_helpers.StringTransport() proto.makeConnection(transport) proto.dataReceived( (b"x" * proto.MAX_LENGTH) + proto.delimiter[: len(proto.delimiter) - 1] ) self.assertFalse(transport.disconnecting) def test_rawDataError(self): """ C{LineReceiver.dataReceived} forwards errors returned by C{rawDataReceived}. """ proto = basic.LineReceiver() proto.rawDataReceived = lambda data: RuntimeError("oops") transport = proto_helpers.StringTransport() proto.makeConnection(transport) proto.setRawMode() why = proto.dataReceived(b"data") self.assertIsInstance(why, RuntimeError) def test_rawDataReceivedNotImplemented(self): """ When L{LineReceiver.rawDataReceived} is not overridden in a subclass, calling it raises C{NotImplementedError}. """ proto = basic.LineReceiver() self.assertRaises(NotImplementedError, proto.rawDataReceived, "foo") def test_lineReceivedNotImplemented(self): """ When L{LineReceiver.lineReceived} is not overridden in a subclass, calling it raises C{NotImplementedError}. """ proto = basic.LineReceiver() self.assertRaises(NotImplementedError, proto.lineReceived, "foo") class ExcessivelyLargeLineCatcher(basic.LineReceiver): """ Helper for L{LineReceiverLineLengthExceededTests}. @ivar longLines: A L{list} of L{bytes} giving the values C{lineLengthExceeded} has been called with. """ def connectionMade(self): self.longLines = [] def lineReceived(self, line): """ Disregard any received lines. """ def lineLengthExceeded(self, data): """ Record any data that exceeds the line length limits. """ self.longLines.append(data) class LineReceiverLineLengthExceededTests(unittest.SynchronousTestCase): """ Tests for L{twisted.protocols.basic.LineReceiver.lineLengthExceeded}. """ def setUp(self): self.proto = ExcessivelyLargeLineCatcher() self.proto.MAX_LENGTH = 6 self.transport = proto_helpers.StringTransport() self.proto.makeConnection(self.transport) def test_longUnendedLine(self): """ If more bytes than C{LineReceiver.MAX_LENGTH} arrive containing no line delimiter, all of the bytes are passed as a single string to L{LineReceiver.lineLengthExceeded}. """ excessive = b"x" * (self.proto.MAX_LENGTH * 2 + 2) self.proto.dataReceived(excessive) self.assertEqual([excessive], self.proto.longLines) def test_longLineAfterShortLine(self): """ If L{LineReceiver.dataReceived} is called with bytes representing a short line followed by bytes that exceed the length limit without a line delimiter, L{LineReceiver.lineLengthExceeded} is called with all of the bytes following the short line's delimiter. """ excessive = b"x" * (self.proto.MAX_LENGTH * 2 + 2) self.proto.dataReceived(b"x" + self.proto.delimiter + excessive) self.assertEqual([excessive], self.proto.longLines) def test_longLineWithDelimiter(self): """ If L{LineReceiver.dataReceived} is called with more than C{LineReceiver.MAX_LENGTH} bytes containing a line delimiter somewhere not in the first C{MAX_LENGTH} bytes, the entire byte string is passed to L{LineReceiver.lineLengthExceeded}. """ excessive = self.proto.delimiter.join( [b"x" * (self.proto.MAX_LENGTH * 2 + 2)] * 2 ) self.proto.dataReceived(excessive) self.assertEqual([excessive], self.proto.longLines) def test_multipleLongLines(self): """ If L{LineReceiver.dataReceived} is called with more than C{LineReceiver.MAX_LENGTH} bytes containing multiple line delimiters somewhere not in the first C{MAX_LENGTH} bytes, the entire byte string is passed to L{LineReceiver.lineLengthExceeded}. """ excessive = (b"x" * (self.proto.MAX_LENGTH * 2 + 2) + self.proto.delimiter) * 2 self.proto.dataReceived(excessive) self.assertEqual([excessive], self.proto.longLines) def test_maximumLineLength(self): """ C{LineReceiver} disconnects the transport if it receives a line longer than its C{MAX_LENGTH}. """ proto = basic.LineReceiver() transport = proto_helpers.StringTransport() proto.makeConnection(transport) proto.dataReceived(b"x" * (proto.MAX_LENGTH + 1) + b"\r\nr") self.assertTrue(transport.disconnecting) def test_maximumLineLengthRemaining(self): """ C{LineReceiver} disconnects the transport it if receives a non-finished line longer than its C{MAX_LENGTH}. """ proto = basic.LineReceiver() transport = proto_helpers.StringTransport() proto.makeConnection(transport) proto.dataReceived(b"x" * (proto.MAX_LENGTH + len(proto.delimiter))) self.assertTrue(transport.disconnecting) class LineOnlyReceiverTests(unittest.SynchronousTestCase): """ Tests for L{twisted.protocols.basic.LineOnlyReceiver}. """ buffer = b"""foo bleakness desolation plastic forks """ def test_buffer(self): """ Test buffering over line protocol: data received should match buffer. """ t = proto_helpers.StringTransport() a = LineOnlyTester() a.makeConnection(t) for c in iterbytes(self.buffer): a.dataReceived(c) self.assertEqual(a.received, self.buffer.split(b"\n")[:-1]) def test_greaterThanMaximumLineLength(self): """ C{LineOnlyReceiver} disconnects the transport if it receives a line longer than its C{MAX_LENGTH} + len(delimiter). """ proto = LineOnlyTester() transport = proto_helpers.StringTransport() proto.makeConnection(transport) proto.dataReceived( b"x" * (proto.MAX_LENGTH + len(proto.delimiter) + 1) + b"\r\nr" ) self.assertTrue(transport.disconnecting) def test_lineReceivedNotImplemented(self): """ When L{LineOnlyReceiver.lineReceived} is not overridden in a subclass, calling it raises C{NotImplementedError}. """ proto = basic.LineOnlyReceiver() self.assertRaises(NotImplementedError, proto.lineReceived, "foo") class TestMixin: def connectionMade(self): self.received = [] def stringReceived(self, s): self.received.append(s) MAX_LENGTH = 50 closed = 0 def connectionLost(self, reason: Failure = connectionDone) -> None: self.closed = 1 class TestNetstring(TestMixin, basic.NetstringReceiver): def stringReceived(self, s): self.received.append(s) self.transport.write(s) class LPTestCaseMixin: illegalStrings: Optional[List[bytes]] = [] protocol: "Optional[Type[protocol.Protocol]]" = None def getProtocol(self): """ Return a new instance of C{self.protocol} connected to a new instance of L{proto_helpers.StringTransport}. """ t = proto_helpers.StringTransport() a = self.protocol() a.makeConnection(t) return a def test_illegal(self): """ Assert that illegal strings cause the transport to be closed. """ for s in self.illegalStrings: r = self.getProtocol() for c in iterbytes(s): r.dataReceived(c) self.assertTrue(r.transport.disconnecting) class NetstringReceiverTests(unittest.SynchronousTestCase, LPTestCaseMixin): """ Tests for L{twisted.protocols.basic.NetstringReceiver}. """ strings = [b"hello", b"world", b"how", b"are", b"you123", b":today", b"a" * 515] illegalStrings = [ b"9999999999999999999999", b"abc", b"4:abcde", b"51:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab,", ] protocol = TestNetstring def setUp(self): self.transport = proto_helpers.StringTransport() self.netstringReceiver = TestNetstring() self.netstringReceiver.makeConnection(self.transport) def test_buffer(self): """ Strings can be received in chunks of different lengths. """ for packet_size in range(1, 10): t = proto_helpers.StringTransport() a = TestNetstring() a.MAX_LENGTH = 699 a.makeConnection(t) for s in self.strings: a.sendString(s) out = t.value() for i in range(len(out) // packet_size + 1): s = out[i * packet_size : (i + 1) * packet_size] if s: a.dataReceived(s) self.assertEqual(a.received, self.strings) def test_receiveEmptyNetstring(self): """ Empty netstrings (with length '0') can be received. """ self.netstringReceiver.dataReceived(b"0:,") self.assertEqual(self.netstringReceiver.received, [b""]) def test_receiveOneCharacter(self): """ One-character netstrings can be received. """ self.netstringReceiver.dataReceived(b"1:a,") self.assertEqual(self.netstringReceiver.received, [b"a"]) def test_receiveTwoCharacters(self): """ Two-character netstrings can be received. """ self.netstringReceiver.dataReceived(b"2:ab,") self.assertEqual(self.netstringReceiver.received, [b"ab"]) def test_receiveNestedNetstring(self): """ Netstrings with embedded netstrings. This test makes sure that the parser does not become confused about the ',' and ':' characters appearing inside the data portion of the netstring. """ self.netstringReceiver.dataReceived(b"4:1:a,,") self.assertEqual(self.netstringReceiver.received, [b"1:a,"]) def test_moreDataThanSpecified(self): """ Netstrings containing more data than expected are refused. """ self.netstringReceiver.dataReceived(b"2:aaa,") self.assertTrue(self.transport.disconnecting) def test_moreDataThanSpecifiedBorderCase(self): """ Netstrings that should be empty according to their length specification are refused if they contain data. """ self.netstringReceiver.dataReceived(b"0:a,") self.assertTrue(self.transport.disconnecting) def test_missingNumber(self): """ Netstrings without leading digits that specify the length are refused. """ self.netstringReceiver.dataReceived(b":aaa,") self.assertTrue(self.transport.disconnecting) def test_missingColon(self): """ Netstrings without a colon between length specification and data are refused. """ self.netstringReceiver.dataReceived(b"3aaa,") self.assertTrue(self.transport.disconnecting) def test_missingNumberAndColon(self): """ Netstrings that have no leading digits nor a colon are refused. """ self.netstringReceiver.dataReceived(b"aaa,") self.assertTrue(self.transport.disconnecting) def test_onlyData(self): """ Netstrings consisting only of data are refused. """ self.netstringReceiver.dataReceived(b"aaa") self.assertTrue(self.transport.disconnecting) def test_receiveNetstringPortions_1(self): """ Netstrings can be received in two portions. """ self.netstringReceiver.dataReceived(b"4:aa") self.netstringReceiver.dataReceived(b"aa,") self.assertEqual(self.netstringReceiver.received, [b"aaaa"]) self.assertTrue(self.netstringReceiver._payloadComplete()) def test_receiveNetstringPortions_2(self): """ Netstrings can be received in more than two portions, even if the length specification is split across two portions. """ for part in [b"1", b"0:01234", b"56789", b","]: self.netstringReceiver.dataReceived(part) self.assertEqual(self.netstringReceiver.received, [b"0123456789"]) def test_receiveNetstringPortions_3(self): """ Netstrings can be received one character at a time. """ for part in [b"2", b":", b"a", b"b", b","]: self.netstringReceiver.dataReceived(part) self.assertEqual(self.netstringReceiver.received, [b"ab"]) def test_receiveTwoNetstrings(self): """ A stream of two netstrings can be received in two portions, where the first portion contains the complete first netstring and the length specification of the second netstring. """ self.netstringReceiver.dataReceived(b"1:a,1") self.assertTrue(self.netstringReceiver._payloadComplete()) self.assertEqual(self.netstringReceiver.received, [b"a"]) self.netstringReceiver.dataReceived(b":b,") self.assertEqual(self.netstringReceiver.received, [b"a", b"b"]) def test_maxReceiveLimit(self): """ Netstrings with a length specification exceeding the specified C{MAX_LENGTH} are refused. """ tooLong = self.netstringReceiver.MAX_LENGTH + 1 self.netstringReceiver.dataReceived( b"".join((bytes(tooLong), b":", b"a" * tooLong)) ) self.assertTrue(self.transport.disconnecting) def test_consumeLength(self): """ C{_consumeLength} returns the expected length of the netstring, including the trailing comma. """ self.netstringReceiver._remainingData = b"12:" self.netstringReceiver._consumeLength() self.assertEqual(self.netstringReceiver._expectedPayloadSize, 13) def test_consumeLengthBorderCase1(self): """ C{_consumeLength} works as expected if the length specification contains the value of C{MAX_LENGTH} (border case). """ self.netstringReceiver._remainingData = b"12:" self.netstringReceiver.MAX_LENGTH = 12 self.netstringReceiver._consumeLength() self.assertEqual(self.netstringReceiver._expectedPayloadSize, 13) def test_consumeLengthBorderCase2(self): """ C{_consumeLength} raises a L{basic.NetstringParseError} if the length specification exceeds the value of C{MAX_LENGTH} by 1 (border case). """ self.netstringReceiver._remainingData = b"12:" self.netstringReceiver.MAX_LENGTH = 11 self.assertRaises( basic.NetstringParseError, self.netstringReceiver._consumeLength ) def test_consumeLengthBorderCase3(self): """ C{_consumeLength} raises a L{basic.NetstringParseError} if the length specification exceeds the value of C{MAX_LENGTH} by more than 1. """ self.netstringReceiver._remainingData = b"1000:" self.netstringReceiver.MAX_LENGTH = 11 self.assertRaises( basic.NetstringParseError, self.netstringReceiver._consumeLength ) def test_stringReceivedNotImplemented(self): """ When L{NetstringReceiver.stringReceived} is not overridden in a subclass, calling it raises C{NotImplementedError}. """ proto = basic.NetstringReceiver() self.assertRaises(NotImplementedError, proto.stringReceived, "foo") class IntNTestCaseMixin(LPTestCaseMixin): """ TestCase mixin for int-prefixed protocols. """ protocol: "Optional[Type[protocol.Protocol]]" = None strings: Optional[List[bytes]] = None illegalStrings: Optional[List[bytes]] = None partialStrings: Optional[List[bytes]] = None def test_receive(self): """ Test receiving data find the same data send. """ r = self.getProtocol() for s in self.strings: for c in iterbytes(struct.pack(r.structFormat, len(s)) + s): r.dataReceived(c) self.assertEqual(r.received, self.strings) def test_partial(self): """ Send partial data, nothing should be definitely received. """ for s in self.partialStrings: r = self.getProtocol() for c in iterbytes(s): r.dataReceived(c) self.assertEqual(r.received, []) def test_send(self): """ Test sending data over protocol. """ r = self.getProtocol() r.sendString(b"b" * 16) self.assertEqual( r.transport.value(), struct.pack(r.structFormat, 16) + b"b" * 16 ) def test_lengthLimitExceeded(self): """ When a length prefix is received which is greater than the protocol's C{MAX_LENGTH} attribute, the C{lengthLimitExceeded} method is called with the received length prefix. """ length = [] r = self.getProtocol() r.lengthLimitExceeded = length.append r.MAX_LENGTH = 10 r.dataReceived(struct.pack(r.structFormat, 11)) self.assertEqual(length, [11]) def test_longStringNotDelivered(self): """ If a length prefix for a string longer than C{MAX_LENGTH} is delivered to C{dataReceived} at the same time as the entire string, the string is not passed to C{stringReceived}. """ r = self.getProtocol() r.MAX_LENGTH = 10 r.dataReceived(struct.pack(r.structFormat, 11) + b"x" * 11) self.assertEqual(r.received, []) def test_stringReceivedNotImplemented(self): """ When L{IntNStringReceiver.stringReceived} is not overridden in a subclass, calling it raises C{NotImplementedError}. """ proto = basic.IntNStringReceiver() self.assertRaises(NotImplementedError, proto.stringReceived, "foo") class RecvdAttributeMixin: """ Mixin defining tests for string receiving protocols with a C{recvd} attribute which should be settable by application code, to be combined with L{IntNTestCaseMixin} on a L{TestCase} subclass """ def makeMessage(self, protocol, data): """ Return C{data} prefixed with message length in C{protocol.structFormat} form. """ return struct.pack(protocol.structFormat, len(data)) + data def test_recvdContainsRemainingData(self): """ In stringReceived, recvd contains the remaining data that was passed to dataReceived that was not part of the current message. """ result = [] r = self.getProtocol() def stringReceived(receivedString): result.append(r.recvd) r.stringReceived = stringReceived completeMessage = struct.pack(r.structFormat, 5) + (b"a" * 5) incompleteMessage = struct.pack(r.structFormat, 5) + (b"b" * 4) # Receive a complete message, followed by an incomplete one r.dataReceived(completeMessage + incompleteMessage) self.assertEqual(result, [incompleteMessage]) def test_recvdChanged(self): """ In stringReceived, if recvd is changed, messages should be parsed from it rather than the input to dataReceived. """ r = self.getProtocol() result = [] payloadC = b"c" * 5 messageC = self.makeMessage(r, payloadC) def stringReceived(receivedString): if not result: r.recvd = messageC result.append(receivedString) r.stringReceived = stringReceived payloadA = b"a" * 5 payloadB = b"b" * 5 messageA = self.makeMessage(r, payloadA) messageB = self.makeMessage(r, payloadB) r.dataReceived(messageA + messageB) self.assertEqual(result, [payloadA, payloadC]) def test_switching(self): """ Data already parsed by L{IntNStringReceiver.dataReceived} is not reparsed if C{stringReceived} consumes some of the L{IntNStringReceiver.recvd} buffer. """ proto = self.getProtocol() mix = [] SWITCH = b"\x00\x00\x00\x00" for s in self.strings: mix.append(self.makeMessage(proto, s)) mix.append(SWITCH) result = [] def stringReceived(receivedString): result.append(receivedString) proto.recvd = proto.recvd[len(SWITCH) :] proto.stringReceived = stringReceived proto.dataReceived(b"".join(mix)) # Just another byte, to trigger processing of anything that might have # been left in the buffer (should be nothing). proto.dataReceived(b"\x01") self.assertEqual(result, self.strings) # And verify that another way self.assertEqual(proto.recvd, b"\x01") def test_recvdInLengthLimitExceeded(self): """ The L{IntNStringReceiver.recvd} buffer contains all data not yet processed by L{IntNStringReceiver.dataReceived} if the C{lengthLimitExceeded} event occurs. """ proto = self.getProtocol() DATA = b"too long" proto.MAX_LENGTH = len(DATA) - 1 message = self.makeMessage(proto, DATA) result = [] def lengthLimitExceeded(length): result.append(length) result.append(proto.recvd) proto.lengthLimitExceeded = lengthLimitExceeded proto.dataReceived(message) self.assertEqual(result[0], len(DATA)) self.assertEqual(result[1], message) class TestInt32(TestMixin, basic.Int32StringReceiver): """ A L{basic.Int32StringReceiver} storing received strings in an array. @ivar received: array holding received strings. """ class Int32Tests(unittest.SynchronousTestCase, IntNTestCaseMixin, RecvdAttributeMixin): """ Test case for int32-prefixed protocol """ protocol = TestInt32 strings = [b"a", b"b" * 16] illegalStrings = [b"\x10\x00\x00\x00aaaaaa"] partialStrings = [b"\x00\x00\x00", b"hello there", b""] def test_data(self): """ Test specific behavior of the 32-bits length. """ r = self.getProtocol() r.sendString(b"foo") self.assertEqual(r.transport.value(), b"\x00\x00\x00\x03foo") r.dataReceived(b"\x00\x00\x00\x04ubar") self.assertEqual(r.received, [b"ubar"]) class TestInt16(TestMixin, basic.Int16StringReceiver): """ A L{basic.Int16StringReceiver} storing received strings in an array. @ivar received: array holding received strings. """ class Int16Tests(unittest.SynchronousTestCase, IntNTestCaseMixin, RecvdAttributeMixin): """ Test case for int16-prefixed protocol """ protocol = TestInt16 strings = [b"a", b"b" * 16] illegalStrings = [b"\x10\x00aaaaaa"] partialStrings = [b"\x00", b"hello there", b""] def test_data(self): """ Test specific behavior of the 16-bits length. """ r = self.getProtocol() r.sendString(b"foo") self.assertEqual(r.transport.value(), b"\x00\x03foo") r.dataReceived(b"\x00\x04ubar") self.assertEqual(r.received, [b"ubar"]) def test_tooLongSend(self): """ Send too much data: that should cause an error. """ r = self.getProtocol() tooSend = b"b" * (2 ** (r.prefixLength * 8) + 1) self.assertRaises(AssertionError, r.sendString, tooSend) class TestInt8(TestMixin, basic.Int8StringReceiver): """ A L{basic.Int8StringReceiver} storing received strings in an array. @ivar received: array holding received strings. """ class Int8Tests(unittest.SynchronousTestCase, IntNTestCaseMixin, RecvdAttributeMixin): """ Test case for int8-prefixed protocol """ protocol = TestInt8 strings = [b"a", b"b" * 16] illegalStrings = [b"\x00\x00aaaaaa"] partialStrings = [b"\x08", b"dzadz", b""] def test_data(self): """ Test specific behavior of the 8-bits length. """ r = self.getProtocol() r.sendString(b"foo") self.assertEqual(r.transport.value(), b"\x03foo") r.dataReceived(b"\x04ubar") self.assertEqual(r.received, [b"ubar"]) def test_tooLongSend(self): """ Send too much data: that should cause an error. """ r = self.getProtocol() tooSend = b"b" * (2 ** (r.prefixLength * 8) + 1) self.assertRaises(AssertionError, r.sendString, tooSend) class OnlyProducerTransport: """ Transport which isn't really a transport, just looks like one to someone not looking very hard. """ paused = False disconnecting = False def __init__(self): self.data = [] def pauseProducing(self): self.paused = True def resumeProducing(self): self.paused = False def write(self, bytes): self.data.append(bytes) class ConsumingProtocol(basic.LineReceiver): """ Protocol that really, really doesn't want any more bytes. """ def lineReceived(self, line): self.transport.write(line) self.pauseProducing() class ProducerTests(unittest.SynchronousTestCase): """ Tests for L{basic._PausableMixin} and L{basic.LineReceiver.paused}. """ def test_pauseResume(self): """ When L{basic.LineReceiver} is paused, it doesn't deliver lines to L{basic.LineReceiver.lineReceived} and delivers them immediately upon being resumed. L{ConsumingProtocol} is a L{LineReceiver} that pauses itself after every line, and writes that line to its transport. """ p = ConsumingProtocol() t = OnlyProducerTransport() p.makeConnection(t) # Deliver a partial line. # This doesn't trigger a pause and doesn't deliver a line. p.dataReceived(b"hello, ") self.assertEqual(t.data, []) self.assertFalse(t.paused) self.assertFalse(p.paused) # Deliver the rest of the line. # This triggers the pause, and the line is echoed. p.dataReceived(b"world\r\n") self.assertEqual(t.data, [b"hello, world"]) self.assertTrue(t.paused) self.assertTrue(p.paused) # Unpausing doesn't deliver more data, and the protocol is unpaused. p.resumeProducing() self.assertEqual(t.data, [b"hello, world"]) self.assertFalse(t.paused) self.assertFalse(p.paused) # Deliver two lines at once. # The protocol is paused after receiving and echoing the first line. p.dataReceived(b"hello\r\nworld\r\n") self.assertEqual(t.data, [b"hello, world", b"hello"]) self.assertTrue(t.paused) self.assertTrue(p.paused) # Unpausing delivers the waiting line, and causes the protocol to # pause again. p.resumeProducing() self.assertEqual(t.data, [b"hello, world", b"hello", b"world"]) self.assertTrue(t.paused) self.assertTrue(p.paused) # Deliver a line while paused. # This doesn't have a visible effect. p.dataReceived(b"goodbye\r\n") self.assertEqual(t.data, [b"hello, world", b"hello", b"world"]) self.assertTrue(t.paused) self.assertTrue(p.paused) # Unpausing delivers the waiting line, and causes the protocol to # pause again. p.resumeProducing() self.assertEqual(t.data, [b"hello, world", b"hello", b"world", b"goodbye"]) self.assertTrue(t.paused) self.assertTrue(p.paused) # Unpausing doesn't deliver more data, and the protocol is unpaused. p.resumeProducing() self.assertEqual(t.data, [b"hello, world", b"hello", b"world", b"goodbye"]) self.assertFalse(t.paused) self.assertFalse(p.paused) class FileSenderTests(unittest.TestCase): """ Tests for L{basic.FileSender}. """ def test_interface(self): """ L{basic.FileSender} implements the L{IPullProducer} interface. """ sender = basic.FileSender() self.assertTrue(verifyObject(IProducer, sender)) def test_producerRegistered(self): """ When L{basic.FileSender.beginFileTransfer} is called, it registers itself with provided consumer, as a non-streaming producer. """ source = BytesIO(b"Test content") consumer = proto_helpers.StringTransport() sender = basic.FileSender() sender.beginFileTransfer(source, consumer) self.assertEqual(consumer.producer, sender) self.assertFalse(consumer.streaming) def test_transfer(self): """ L{basic.FileSender} sends the content of the given file using a C{IConsumer} interface via C{beginFileTransfer}. It returns a L{Deferred} which fires with the last byte sent. """ source = BytesIO(b"Test content") consumer = proto_helpers.StringTransport() sender = basic.FileSender() d = sender.beginFileTransfer(source, consumer) sender.resumeProducing() # resumeProducing only finishes after trying to read at eof sender.resumeProducing() self.assertIsNone(consumer.producer) self.assertEqual(b"t", self.successResultOf(d)) self.assertEqual(b"Test content", consumer.value()) def test_transferMultipleChunks(self): """ L{basic.FileSender} reads at most C{CHUNK_SIZE} every time it resumes producing. """ source = BytesIO(b"Test content") consumer = proto_helpers.StringTransport() sender = basic.FileSender() sender.CHUNK_SIZE = 4 d = sender.beginFileTransfer(source, consumer) # Ideally we would assertNoResult(d) here, but <http://tm.tl/6291> sender.resumeProducing() self.assertEqual(b"Test", consumer.value()) sender.resumeProducing() self.assertEqual(b"Test con", consumer.value()) sender.resumeProducing() self.assertEqual(b"Test content", consumer.value()) # resumeProducing only finishes after trying to read at eof sender.resumeProducing() self.assertEqual(b"t", self.successResultOf(d)) self.assertEqual(b"Test content", consumer.value()) def test_transferWithTransform(self): """ L{basic.FileSender.beginFileTransfer} takes a C{transform} argument which allows to manipulate the data on the fly. """ def transform(chunk): return chunk.swapcase() source = BytesIO(b"Test content") consumer = proto_helpers.StringTransport() sender = basic.FileSender() d = sender.beginFileTransfer(source, consumer, transform) sender.resumeProducing() # resumeProducing only finishes after trying to read at eof sender.resumeProducing() self.assertEqual(b"T", self.successResultOf(d)) self.assertEqual(b"tEST CONTENT", consumer.value()) def test_abortedTransfer(self): """ The C{Deferred} returned by L{basic.FileSender.beginFileTransfer} fails with an C{Exception} if C{stopProducing} when the transfer is not complete. """ source = BytesIO(b"Test content") consumer = proto_helpers.StringTransport() sender = basic.FileSender() d = sender.beginFileTransfer(source, consumer) # Abort the transfer right away sender.stopProducing() failure = self.failureResultOf(d) failure.trap(Exception) self.assertEqual("Consumer asked us to stop producing", str(failure.value)) PK Mb�Zh�{r� � 3 protocols/test/__pycache__/__init__.cpython-310.pycnu �[��� o �bv � @ s d Z dS )z& Unit tests for L{twisted.protocols}. N)�__doc__� r r �A/usr/lib/python3/dist-packages/twisted/protocols/test/__init__.py�<module> s PK Mb�Z1��ʩ ʩ 5 protocols/test/__pycache__/test_basic.cpython-310.pycnu �[��� o �b� � @ sJ d Z ddlZddlZddlmZ ddlmZmZmZ ddl m Z ddl m Z m Z ddlmZ ddlmZ dd lmZ dd lmZ dd lmZ dd lmZ dd lmZ G dd� dej �Z G dd� dej �Z G dd� dej �Z G dd� dej!�Z"G dd� dej �Z#G dd� dej!�Z$G dd� dej!�Z%G d d � d �Z&G d d � d e&ej'�Z(G d d!� d!�Z)G d"d#� d#ej!e)�Z*G d$d%� d%e)�Z+G d&d'� d'�Z,G d(d)� d)e&ej-�Z.G d*d+� d+ej!e+e,�Z/G d,d-� d-e&ej0�Z1G d.d/� d/ej!e+e,�Z2G d0d1� d1e&ej3�Z4G d2d3� d3ej!e+e,�Z5G d4d5� d5�Z6G d6d7� d7ej �Z7G d8d9� d9ej!�Z8G d:d;� d;ej9�Z:dS )<z, Test cases for L{twisted.protocols.basic}. � N)�BytesIO)�List�Optional�Type)� verifyObject)�protocol�task)� IProducer)�connectionDone)�basic)� iterbytes)�Failure)� proto_helpers)�unittestc @ �, e Zd ZdZdZdd� Zdd� Zdd� Zd S ) �FlippingLineTesterzT A line receiver that flips between line and raw data modes after one byte. � c C � g | _ d S �N)�lines��self� r �C/usr/lib/python3/dist-packages/twisted/protocols/test/test_basic.py�__init__! � zFlippingLineTester.__init__c C s | j �|� | �� dS )z& Set the mode to raw. N)r �append� setRawMode�r �liner r r � lineReceived$ s z FlippingLineTester.lineReceivedc C s | � |dd� � dS )z, Set the mode back to line. � N)� setLineMode�r �datar r r �rawDataReceived+ s z"FlippingLineTester.rawDataReceivedN)�__name__� __module__� __qualname__�__doc__� delimiterr r r% r r r r r s r c @ sB e Zd ZdZdZdZddd�Zdd� Zd d � Zd d � Z d d� Z dS )� LineTestera� A line receiver that parses data received and make actions on some tokens. @type delimiter: C{bytes} @ivar delimiter: character used between received lines. @type MAX_LENGTH: C{int} @ivar MAX_LENGTH: size of a line when C{lineLengthExceeded} will be called. @type clock: L{twisted.internet.task.Clock} @ivar clock: clock simulating reactor callLater. Pass it to constructor if you want to use the pause/rawpause functionalities. r �@ Nc C s || _ dS )z@ If given, use a clock to make callLater calls. N)�clock)r r- r r r r B � zLineTester.__init__c C � g | _ dS �z; Create/clean data received on connection. N��receivedr r r r �connectionMadeH r. zLineTester.connectionMadec C s� | j �|� |dkr| �� dS |dkr"| �� | j�d| j� dS |dkr>| �� | �� | j �d� | j�d| j� dS |dkrH| �� dS |dd� dkr[t|dd� �| _ dS |� d �ri| j � | d � dS |� d �ru| j � � dS dS ) z| Receive line and make some action for some tokens: pause, rawpause, stop, len, produce, unproduce. � � pauser � rawpause� stopN� s len � produceF� unproduce)r2 r r �pauseProducingr- � callLater�resumeProducing� stopProducing�int�length� startswith� transport�registerProducer�unregisterProducerr r r r r N s( �zLineTester.lineReceivedc C s^ |d| j � || j d� }}| j t|� | _ | jd | | jd< | j dkr-| �|� dS dS )zj Read raw data, until the quantity specified by a previous 'len' line is reached. N���r )r@ �lenr2 r" )r r$ �restr r r r% g s �zLineTester.rawDataReceivedc C s2 t |�| jd kr| �|| jd d� � dS dS )z< Adjust line mode when long lines received. r! N)rF � MAX_LENGTHr" r r r r �lineLengthExceededr s �z LineTester.lineLengthExceededr ) r& r' r( r) r* rH r r3 r r% rI r r r r r+ 2 s r+ c @ s( e Zd ZdZdZdZdd� Zdd� ZdS ) �LineOnlyTesterz) A buffering line only receiver. r r, c C r/ r0 r1 r r r r r3 � r. z LineOnlyTester.connectionMadec C � | j �|� dS )z% Save received data. N�r2 r r r r r r � � zLineOnlyTester.lineReceivedN)r& r' r( r) r* rH r3 r r r r r rJ z s rJ c @ s� e Zd ZdZdZg d�Zdd� ZdZg d�Zedg Z d d � Z d Z g d �Z g d �Z dd� ZdZg d�Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&S )'�LineReceiverTestsz\ Test L{twisted.protocols.basic.LineReceiver}, using the C{LineTester} wrapper. s� len 10 0123456789len 5 1234 len 20 foo 123 0123456789 012345678len 0 foo 5 1234567890123456789012345678901234567890123456789012345678901234567890 len 1 a) s len 10� 0123456789� len 5s 1234 s len 20s foo 123s 0123456789 012345678s len 0s foo 5r4 s 67890s len 1� ac C � t dd�D ]9}t�� }t� }|�t�|�� t t| j�| d �D ]}| j|| |d | � }|� |� q!| � | j |j � qdS )zl Test buffering for different packet size, checking received matches expected data. r! � N) �ranger �StringIOWithoutClosingr+ �makeConnectionr � FileWrapperrF �buffer� dataReceived� assertEqual�outputr2 �r � packet_size�t�a�i�sr r r � test_buffer� s �z LineReceiverTests.test_buffers! twiddle1 twiddle2 pause twiddle3 )� twiddle1� twiddle2r5 � twiddle3c C � t dd�D ]K}t�� }t�� }t|�}|�t�|�� t t | j �| d �D ]}| j || |d | � }|� |� q&| � | j |j� |�d� | � | j|j� qdS )zo Test pause inside data receiving. It uses fake clock to see if pausing/resuming work. r! rS r N)rT r rU r �Clockr+ rV r rW rF �pauseBufrY rZ � pauseOutput1r2 �advance� pauseOutput2�r r] r^ r- r_ r` ra r r r � test_pausing� s �z LineReceiverTests.test_pausings/ twiddle1 twiddle2 len 5 rawpause 12345twiddle3 )rc rd rP r6 r4 )rc rd rP r6 s 12345re c C rf )z7 Test pause inside raw date receiving. r! rS r N)rT r rU r rg r+ rV r rW rF � rawpauseBufrY rZ �rawpauseOutput1r2 rj �rawpauseOutput2rl r r r �test_rawPausing� s �z!LineReceiverTests.test_rawPausings" twiddle1 twiddle2 stop more stuff )rc rd r7 c C rR )z- Test stop inside producing. r! rS N) rT r rU r+ rV r rW rF �stop_bufrY rZ � stop_outputr2 r\ r r r �test_stopProducing� s �z$LineReceiverTests.test_stopProducingc C s> t � }t�� }|�t�|�� |�d� | �|jg d�� dS )z6 Test produce/unproduce in receiving. s& produce hello world unproduce goodbye )r9 s hello worldr: � goodbyeN) r+ r rU rV r rW rY rZ r2 )r r_ r^ r r r �test_lineReceiverAsProducer s �z-LineReceiverTests.test_lineReceiverAsProducerc C sh G dd� dt j�}|� }|�d� | �|jd� | �|jd� |�d� | �|jd� | �|jd� d S ) z� L{LineReceiver.clearLineBuffer} removes all buffered data and returns it as a C{bytes} and can be called from beneath C{dataReceived}. c @ � e Zd Zdd� ZdS )z@LineReceiverTests.test_clearLineBuffer.<locals>.ClearingReceiverc S s || _ | �� | _d S r )r �clearLineBufferrG r r r r r s zMLineReceiverTests.test_clearLineBuffer.<locals>.ClearingReceiver.lineReceivedN)r& r' r( r r r r r �ClearingReceiver � ry s foo bar baz� foos bar bazs quux s quuxr4 N)r � LineReceiverrY rZ r rG )r ry r r r r �test_clearLineBuffer s z&LineReceiverTests.test_clearLineBufferc C sP t � }t�� }|�t�|�� t�� }|�d| � | � d| d� |j �� dS )zC Test switching modes many times on the same data. s x x� xr4 N) r r rU rV r rW �sys�getrecursionlimitrY rZ �joinr )r �protorB �limitr r r �test_stackRecursion* s z%LineReceiverTests.test_stackRecursionc C �B t �� }t�� }|�|� |�d|jd d � | �|j� dS �zx C{LineReceiver} disconnects the transport if it receives a line longer than its C{MAX_LENGTH}. r~ r! � rN� r r| r �StringTransportrV rY rH � assertTrue� disconnecting�r r� rB r r r �test_maximumLineLength5 � z(LineReceiverTests.test_maximumLineLengthc C s� t � }d|_t�� }|�|� d|jd }|�|� |�|jdd� � |�|jdd� | � | �|j� | � t |j �d� | � ||j d � dS )a~ C{LineReceiver} doesn't disconnect the transport when it receives a finished line as long as its C{MAX_LENGTH}, when the second-to-last packet ended with a pattern that could have been -- and turns out to have been -- the start of a delimiter, and that packet causes the total input to exceed C{MAX_LENGTH} + len(delimiter). r8 r~ r! NrE r ) r+ rH r r� rV rY r* � assertFalser� rZ rF r2 )r r� r^ r r r r �&test_maximumLineLengthPartialDelimiter@ s z8LineReceiverTests.test_maximumLineLengthPartialDelimiterc C sX t �� }d|_t�� }|�|� |�d|j |jdt|j�d � � | � |j � dS )aO C{LineReceiver} doesn't disconnect the transport it if receives a non-finished line whose length, counting the delimiter, is longer than its C{MAX_LENGTH} but shorter than its C{MAX_LENGTH} + len(delimiter). (When the first part that exceeds the max is the beginning of the delimiter.) s r~ Nr! ) r r| r* r r� rV rY rH rF r� r� r� r r r �(test_notQuiteMaximumLineLengthUnfinishedV s �z:LineReceiverTests.test_notQuiteMaximumLineLengthUnfinishedc C sF t �� }dd� |_t�� }|�|� |�� |�d�}| �|t � dS )zf C{LineReceiver.dataReceived} forwards errors returned by C{rawDataReceived}. c S s t d�S )N�oops)� RuntimeError�r$ r r r �<lambda>o s z5LineReceiverTests.test_rawDataError.<locals>.<lambda>s dataN) r r| r% r r� rV r rY �assertIsInstancer� )r r� rB �whyr r r �test_rawDataErrori s z#LineReceiverTests.test_rawDataErrorc C � t �� }| �t|jd� dS )z� When L{LineReceiver.rawDataReceived} is not overridden in a subclass, calling it raises C{NotImplementedError}. �fooN)r r| � assertRaises�NotImplementedErrorr% �r r� r r r �"test_rawDataReceivedNotImplementedv � z4LineReceiverTests.test_rawDataReceivedNotImplementedc C r� )z� When L{LineReceiver.lineReceived} is not overridden in a subclass, calling it raises C{NotImplementedError}. r� N)r r| r� r� r r� r r r � test_lineReceivedNotImplemented~ r� z1LineReceiverTests.test_lineReceivedNotImplementedN)r& r' r( r) rX r[ rb rh ri rk rm rn ro rp rq rr rs rt rv r} r� r� r� r� r� r� r� r r r r rN � s2 rN c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �ExcessivelyLargeLineCatcherz� Helper for L{LineReceiverLineLengthExceededTests}. @ivar longLines: A L{list} of L{bytes} giving the values C{lineLengthExceeded} has been called with. c C r r )� longLinesr r r r r3 � r z*ExcessivelyLargeLineCatcher.connectionMadec C s dS )z/ Disregard any received lines. Nr r r r r r � s z(ExcessivelyLargeLineCatcher.lineReceivedc C rK )zF Record any data that exceeds the line length limits. N)r� r r# r r r rI � rM z.ExcessivelyLargeLineCatcher.lineLengthExceededN)r& r' r( r) r3 r rI r r r r r� � s r� c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�#LineReceiverLineLengthExceededTestszO Tests for L{twisted.protocols.basic.LineReceiver.lineLengthExceeded}. c C s, t � | _d| j_t�� | _| j�| j� d S )N� )r� r� rH r r� rB rV r r r r �setUp� s z)LineReceiverLineLengthExceededTests.setUpc C s6 d| j jd d }| j �|� | �|g| j j� dS )z� If more bytes than C{LineReceiver.MAX_LENGTH} arrive containing no line delimiter, all of the bytes are passed as a single string to L{LineReceiver.lineLengthExceeded}. r~ � N)r� rH rY rZ r� �r � excessiver r r �test_longUnendedLine� s z8LineReceiverLineLengthExceededTests.test_longUnendedLinec C sB d| j jd d }| j �d| j j | � | �|g| j j� dS )a* If L{LineReceiver.dataReceived} is called with bytes representing a short line followed by bytes that exceed the length limit without a line delimiter, L{LineReceiver.lineLengthExceeded} is called with all of the bytes following the short line's delimiter. r~ r� N)r� rH rY r* rZ r� r� r r r �test_longLineAfterShortLine� s z?LineReceiverLineLengthExceededTests.test_longLineAfterShortLinec C sF | j j�d| j jd d gd �}| j �|� | �|g| j j� dS )a If L{LineReceiver.dataReceived} is called with more than C{LineReceiver.MAX_LENGTH} bytes containing a line delimiter somewhere not in the first C{MAX_LENGTH} bytes, the entire byte string is passed to L{LineReceiver.lineLengthExceeded}. r~ r� N)r� r* r� rH rY rZ r� r� r r r �test_longLineWithDelimiter� s � z>LineReceiverLineLengthExceededTests.test_longLineWithDelimiterc C sB d| j jd d | j j d }| j �|� | �|g| j j� dS )a If L{LineReceiver.dataReceived} is called with more than C{LineReceiver.MAX_LENGTH} bytes containing multiple line delimiters somewhere not in the first C{MAX_LENGTH} bytes, the entire byte string is passed to L{LineReceiver.lineLengthExceeded}. r~ r� N)r� rH r* rY rZ r� r� r r r �test_multipleLongLines� s z:LineReceiverLineLengthExceededTests.test_multipleLongLinesc C r� r� r� r� r r r r� � r� z:LineReceiverLineLengthExceededTests.test_maximumLineLengthc C sD t �� }t�� }|�|� |�d|jt|j� � | � |j � dS )z� C{LineReceiver} disconnects the transport it if receives a non-finished line longer than its C{MAX_LENGTH}. r~ N) r r| r r� rV rY rH rF r* r� r� r� r r r � test_maximumLineLengthRemaining� s zCLineReceiverLineLengthExceededTests.test_maximumLineLengthRemainingN) r& r' r( r) r� r� r� r� r� r� r� r r r r r� � s r� c @ r ) �LineOnlyReceiverTestsz@ Tests for L{twisted.protocols.basic.LineOnlyReceiver}. s7 foo bleakness desolation plastic forks c C sT t �� }t� }|�|� t| j�D ]}|�|� q| �|j| j� d�dd� � dS )zW Test buffering over line protocol: data received should match buffer. r NrE ) r r� rJ rV r rX rY rZ r2 �split)r r^ r_ �cr r r rb � s "z!LineOnlyReceiverTests.test_bufferc C sJ t � }t�� }|�|� |�d|jt|j� d d � | �|j � dS )z� C{LineOnlyReceiver} disconnects the transport if it receives a line longer than its C{MAX_LENGTH} + len(delimiter). r~ r! r� N) rJ r r� rV rY rH rF r* r� r� r� r r r �!test_greaterThanMaximumLineLength s �z7LineOnlyReceiverTests.test_greaterThanMaximumLineLengthc C r� )z� When L{LineOnlyReceiver.lineReceived} is not overridden in a subclass, calling it raises C{NotImplementedError}. r� N)r �LineOnlyReceiverr� r� r r� r r r r� r� z5LineOnlyReceiverTests.test_lineReceivedNotImplementedN)r& r' r( r) rX rb r� r� r r r r r� � s r� c @ s: e Zd Zdd� Zdd� ZdZdZefdedd fd d �Z d S ) � TestMixinc C r r r1 r r r r r3 r zTestMixin.connectionMadec C � | j �|� d S r rL �r ra r r r �stringReceived � zTestMixin.stringReceived�2 r �reason�returnNc C � d| _ d S )Nr! )�closed)r r� r r r �connectionLost# r zTestMixin.connectionLost) r& r' r( r3 r� rH r� r r r� r r r r r� s r� c @ rw )� TestNetstringc C s | j �|� | j�|� d S r )r2 r rB �writer� r r r r� ( s z TestNetstring.stringReceivedN)r& r' r( r� r r r r r� ' rz r� c @ s> e Zd ZU g Zeee ed< dZded< dd� Z dd� Z dS ) �LPTestCaseMixin�illegalStringsN�!Optional[Type[protocol.Protocol]]r c C s t �� }| �� }|�|� |S )z� Return a new instance of C{self.protocol} connected to a new instance of L{proto_helpers.StringTransport}. )r r� r rV )r r^ r_ r r r � getProtocol2 s zLPTestCaseMixin.getProtocolc C s> | j D ]}| �� }t|�D ]}|�|� q | �|jj� qdS )zO Assert that illegal strings cause the transport to be closed. N)r� r� r rY r� rB r� �r ra �rr� r r r � test_illegal< � �z LPTestCaseMixin.test_illegal) r& r' r( r� r r �bytes�__annotations__r r� r� r r r r r� - s r� c @ s� e Zd ZdZg d�Zg d�ZeZdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Z d.d/� Z d0S )1�NetstringReceiverTestszA Tests for L{twisted.protocols.basic.NetstringReceiver}. )� hello� worlds hows ares you123s :todays aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)s 9999999999999999999999s abcs 4:abcdes7 51:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab,c C s$ t �� | _t� | _| j�| j� d S r )r r� rB r� �netstringReceiverrV r r r r r� W s z NetstringReceiverTests.setUpc C s� t dd�D ]H}t�� }t� }d|_|�|� | jD ]}|�|� q|�� }t t |�| d �D ]}||| |d | � }|rD|� |� q/| � |j | j� qdS )zI Strings can be received in chunks of different lengths. r! rS i� N) rT r r� r� rH rV �strings� sendString�valuerF rY rZ r2 )r r] r^ r_ ra �outr` r r r rb \ s ��z"NetstringReceiverTests.test_bufferc C �" | j �d� | �| j jdg� dS )zE Empty netstrings (with length '0') can be received. s 0:,r4 N�r� rY rZ r2 r r r r �test_receiveEmptyNetstringn � z1NetstringReceiverTests.test_receiveEmptyNetstringc C r� )z; One-character netstrings can be received. � 1:a,rQ Nr� r r r r �test_receiveOneCharacteru r� z/NetstringReceiverTests.test_receiveOneCharacterc C r� )z; Two-character netstrings can be received. s 2:ab,� abNr� r r r r �test_receiveTwoCharacters| r� z0NetstringReceiverTests.test_receiveTwoCharactersc C r� )z� Netstrings with embedded netstrings. This test makes sure that the parser does not become confused about the ',' and ':' characters appearing inside the data portion of the netstring. s 4:1:a,,r� Nr� r r r r �test_receiveNestedNetstring� s z2NetstringReceiverTests.test_receiveNestedNetstringc C � | j �d� | �| jj� dS )zL Netstrings containing more data than expected are refused. s 2:aaa,N�r� rY r� rB r� r r r r �test_moreDataThanSpecified� � z1NetstringReceiverTests.test_moreDataThanSpecifiedc C r� )z� Netstrings that should be empty according to their length specification are refused if they contain data. s 0:a,Nr� r r r r �$test_moreDataThanSpecifiedBorderCase� � z;NetstringReceiverTests.test_moreDataThanSpecifiedBorderCasec C r� )z` Netstrings without leading digits that specify the length are refused. s :aaa,Nr� r r r r �test_missingNumber� r� z)NetstringReceiverTests.test_missingNumberc C r� )zg Netstrings without a colon between length specification and data are refused. s 3aaa,Nr� r r r r �test_missingColon� r� z(NetstringReceiverTests.test_missingColonc C r� )zY Netstrings that have no leading digits nor a colon are refused. s aaa,Nr� r r r r �test_missingNumberAndColon� r� z1NetstringReceiverTests.test_missingNumberAndColonc C r� )zA Netstrings consisting only of data are refused. s aaaNr� r r r r � test_onlyData� r� z$NetstringReceiverTests.test_onlyDatac C s> | j �d� | j �d� | �| j jdg� | �| j �� � dS )z= Netstrings can be received in two portions. s 4:aas aa,s aaaaN)r� rY rZ r2 r� �_payloadCompleter r r r � test_receiveNetstringPortions_1� s z6NetstringReceiverTests.test_receiveNetstringPortions_1c C �, dD ]}| j �|� q| �| j jdg� dS )z� Netstrings can be received in more than two portions, even if the length specification is split across two portions. )� 1s 0:01234s 56789� ,rO Nr� �r �partr r r � test_receiveNetstringPortions_2� s z6NetstringReceiverTests.test_receiveNetstringPortions_2c C r� )zE Netstrings can be received one character at a time. )� 2� :rQ � br� r� Nr� r� r r r � test_receiveNetstringPortions_3� s z6NetstringReceiverTests.test_receiveNetstringPortions_3c C sR | j �d� | �| j �� � | �| j jdg� | j �d� | �| j jddg� dS )z� A stream of two netstrings can be received in two portions, where the first portion contains the complete first netstring and the length specification of the second netstring. s 1:a,1rQ s :b,r� N)r� rY r� r� rZ r2 r r r r �test_receiveTwoNetstrings� s z0NetstringReceiverTests.test_receiveTwoNetstringsc C s> | j jd }| j �d�t|�dd| f�� | �| jj� dS )zs Netstrings with a length specification exceeding the specified C{MAX_LENGTH} are refused. r! r4 r� rQ N)r� rH rY r� r� r� rB r� )r �tooLongr r r �test_maxReceiveLimit� s �z+NetstringReceiverTests.test_maxReceiveLimitc C s& d| j _| j �� | �| j jd� dS )zw C{_consumeLength} returns the expected length of the netstring, including the trailing comma. � 12:� N)r� �_remainingData�_consumeLengthrZ �_expectedPayloadSizer r r r �test_consumeLength� s z)NetstringReceiverTests.test_consumeLengthc C s. d| j _d| j _| j �� | �| j jd� dS )z� C{_consumeLength} works as expected if the length specification contains the value of C{MAX_LENGTH} (border case). r� � r� N)r� r� rH r� rZ r� r r r r � test_consumeLengthBorderCase1� s z4NetstringReceiverTests.test_consumeLengthBorderCase1c C �& d| j _d| j _| �tj| j j� dS )z� C{_consumeLength} raises a L{basic.NetstringParseError} if the length specification exceeds the value of C{MAX_LENGTH} by 1 (border case). r� � N�r� r� rH r� r �NetstringParseErrorr� r r r r � test_consumeLengthBorderCase2� � �z4NetstringReceiverTests.test_consumeLengthBorderCase2c C r� )z� C{_consumeLength} raises a L{basic.NetstringParseError} if the length specification exceeds the value of C{MAX_LENGTH} by more than 1. s 1000:r� Nr� r r r r � test_consumeLengthBorderCase3 r z4NetstringReceiverTests.test_consumeLengthBorderCase3c C r� )z� When L{NetstringReceiver.stringReceived} is not overridden in a subclass, calling it raises C{NotImplementedError}. r� N)r �NetstringReceiverr� r� r� r� r r r �!test_stringReceivedNotImplemented r� z8NetstringReceiverTests.test_stringReceivedNotImplementedN) r& r' r( r) r� r� r� r r� rb r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r� G s6 r� c @ s� e Zd ZU dZdZded< dZeee ed< dZ eee ed< dZ eee ed< dd � Z d d � Z d d � Zdd� Zdd� Zdd� ZdS )�IntNTestCaseMixinz4 TestCase mixin for int-prefixed protocols. Nr� r r� r� �partialStringsc C sR | � � }| jD ]}tt�|jt|��| �D ]}|�|� qq| �|j | j� dS )z> Test receiving data find the same data send. N) r� r� r �struct�pack� structFormatrF rY rZ r2 )r r� ra r� r r r � test_receive) s �z IntNTestCaseMixin.test_receivec C s> | j D ]}| �� }t|�D ]}|�|� q | �|jg � qdS )zK Send partial data, nothing should be definitely received. N)r r� r rY rZ r2 r� r r r � test_partial3 r� z IntNTestCaseMixin.test_partialc C s6 | � � }|�d� | �|j�� t�|jd�d � dS )z2 Test sending data over protocol. � bbbbbbbbbbbbbbbb� N)r� r� rZ rB r� r r r �r r� r r r � test_send= s �zIntNTestCaseMixin.test_sendc C s@ g }| � � }|j|_d|_|�t�|jd�� | �|dg� dS )z� When a length prefix is received which is greater than the protocol's C{MAX_LENGTH} attribute, the C{lengthLimitExceeded} method is called with the received length prefix. rS r� N) r� r �lengthLimitExceededrH rY r r r rZ )r r@ r� r r r �test_lengthLimitExceededG s z*IntNTestCaseMixin.test_lengthLimitExceededc C s8 | � � }d|_|�t�|jd�d � | �|jg � dS )z� If a length prefix for a string longer than C{MAX_LENGTH} is delivered to C{dataReceived} at the same time as the entire string, the string is not passed to C{stringReceived}. rS r� s xxxxxxxxxxxN)r� rH rY r r r rZ r2 r r r r �test_longStringNotDeliveredT s z-IntNTestCaseMixin.test_longStringNotDeliveredc C r� )z� When L{IntNStringReceiver.stringReceived} is not overridden in a subclass, calling it raises C{NotImplementedError}. r� N)r �IntNStringReceiverr� r� r� r� r r r r _ r� z3IntNTestCaseMixin.test_stringReceivedNotImplemented)r& r' r( r) r r� r� r r r� r� r r r r r r r r r r r r s r c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �RecvdAttributeMixinz� Mixin defining tests for string receiving protocols with a C{recvd} attribute which should be settable by application code, to be combined with L{IntNTestCaseMixin} on a L{TestCase} subclass c C s t �|jt|��| S )zg Return C{data} prefixed with message length in C{protocol.structFormat} form. )r r r rF )r r r$ r r r � makeMessageo s z RecvdAttributeMixin.makeMessagec sd g �| � � � � �fdd�}|� _t�� jd�d }t�� jd�d }� �|| � | ��|g� dS )z� In stringReceived, recvd contains the remaining data that was passed to dataReceived that was not part of the current message. c s �� � j� d S r �r �recvd��receivedString�r� �resultr r r� ~ r� zKRecvdAttributeMixin.test_recvdContainsRemainingData.<locals>.stringReceived� � aaaaas bbbbN)r� r� r r r rY rZ )r r� �completeMessage�incompleteMessager r r � test_recvdContainsRemainingDatav s z3RecvdAttributeMixin.test_recvdContainsRemainingDatac st | � � �g �d}| ��|�� � ��fdd�}|�_d}d}| ��|�}| ��|�}��|| � | ��||g� dS )z� In stringReceived, if recvd is changed, messages should be parsed from it rather than the input to dataReceived. s cccccc s �s� �_ ��| � d S r )r r r ��messageCr� r r r r� � s z=RecvdAttributeMixin.test_recvdChanged.<locals>.stringReceivedr s bbbbbN)r� r r� rY rZ )r �payloadCr� �payloadA�payloadB�messageA�messageBr r! r �test_recvdChanged� s z%RecvdAttributeMixin.test_recvdChangedc s� | � � �g }d� | jD ]}|�| ��|�� |�� � q g �� ��fdd�}|�_��d�|�� ��d� | ��| j� | ��jd� dS )z� Data already parsed by L{IntNStringReceiver.dataReceived} is not reparsed if C{stringReceived} consumes some of the L{IntNStringReceiver.recvd} buffer. s c s" �� | � �jt� �d � �_d S r )r r rF r ��SWITCHr� r r r r� � s z:RecvdAttributeMixin.test_switching.<locals>.stringReceivedr4 � N) r� r� r r r� rY r� rZ r )r �mixra r� r r) r �test_switching� s z"RecvdAttributeMixin.test_switchingc sp | � � � d}t|�d � _| �� |�}g �� �fdd�}|� _� �|� | ��d t|�� | ��d |� dS )z� The L{IntNStringReceiver.recvd} buffer contains all data not yet processed by L{IntNStringReceiver.dataReceived} if the C{lengthLimitExceeded} event occurs. s too longr! c s �� | � �� � j� d S r r )r@ �r� r r r r � s zPRecvdAttributeMixin.test_recvdInLengthLimitExceeded.<locals>.lengthLimitExceededr N)r� rF rH r r rY rZ )r �DATA�messager r r. r � test_recvdInLengthLimitExceeded� s z3RecvdAttributeMixin.test_recvdInLengthLimitExceededN) r& r' r( r) r r r( r- r1 r r r r r h s r c @ � e Zd ZdZdS )� TestInt32z� A L{basic.Int32StringReceiver} storing received strings in an array. @ivar received: array holding received strings. N�r& r' r( r) r r r r r3 � � r3 c @ s2 e Zd ZdZeZddgZdgZg d�Zdd� Z dS ) � Int32Testsz/ Test case for int32-prefixed protocol rQ r s aaaaaa)s � hello therer4 c C �B | � � }|�d� | �|j�� d� |�d� | �|jdg� dS )z? Test specific behavior of the 32-bits length. r{ s foos ubar� ubarN�r� r� rZ rB r� rY r2 r r r r � test_data� � zInt32Tests.test_dataN) r& r' r( r) r3 r r� r� r r; r r r r r6 � s r6 c @ r2 )� TestInt16z� A L{basic.Int16StringReceiver} storing received strings in an array. @ivar received: array holding received strings. Nr4 r r r r r= � r5 r= c @ �: e Zd ZdZeZddgZdgZg d�Zdd� Z dd � Z d S ) � Int16Testsz/ Test case for int16-prefixed protocol rQ r s aaaaaa)� r7 r4 c C r8 )z? Test specific behavior of the 16-bits length. r{ s foos ubarr9 Nr: r r r r r; r< zInt16Tests.test_datac C �2 | � � }dd|jd d }| �t|j|� dS �zA Send too much data: that should cause an error. r� r� � r! N�r� � prefixLengthr� �AssertionErrorr� �r r� �tooSendr r r �test_tooLongSend � zInt16Tests.test_tooLongSendN) r& r' r( r) r= r r� r� r r; rI r r r r r? � � r? c @ r2 )�TestInt8z� A L{basic.Int8StringReceiver} storing received strings in an array. @ivar received: array holding received strings. Nr4 r r r r rL r5 rL c @ r> ) � Int8Testsz. Test case for int8-prefixed protocol rQ r s aaaaaa)� s dzadzr4 c C r8 )z> Test specific behavior of the 8-bits length. r{ s foos ubarr9 Nr: r r r r r; & r< zInt8Tests.test_datac C rA rB rD rG r r r rI 0 rJ zInt8Tests.test_tooLongSendN) r& r' r( r) rL r r� r� r r; rI r r r r rM rK rM c @ s8 e Zd ZdZdZdZdd� Zdd� Zdd� Zd d � Z d S ) �OnlyProducerTransportzm Transport which isn't really a transport, just looks like one to someone not looking very hard. Fc C r r r� r r r r r B r z OnlyProducerTransport.__init__c C r� )NT��pausedr r r r r; E r z$OnlyProducerTransport.pauseProducingc C r� )NFrP r r r r r= H r z%OnlyProducerTransport.resumeProducingc C r� r )r$ r )r r� r r r r� K r� zOnlyProducerTransport.writeN) r& r' r( r) rQ r� r r; r= r� r r r r rO 9 s rO c @ � e Zd ZdZdd� ZdS )�ConsumingProtocolzC Protocol that really, really doesn't want any more bytes. c C s | j �|� | �� d S r )rB r� r; r r r r r T s z ConsumingProtocol.lineReceivedN)r& r' r( r) r r r r r rS O � rS c @ rR )� ProducerTestszM Tests for L{basic._PausableMixin} and L{basic.LineReceiver.paused}. c C s� t � }t� }|�|� |�d� | �|jg � | �|j� | �|j� |�d� | �|jdg� | �|j� | �|j� |� � | �|jdg� | �|j� | �|j� |�d� | �|jddg� | �|j� | �|j� |� � | �|jg d�� | �|j� | �|j� |�d� | �|jg d�� | �|j� | �|j� |� � | �|jg d�� | �|j� | �|j� |� � | �|jg d�� | �|j� | �|j� d S ) a? When L{basic.LineReceiver} is paused, it doesn't deliver lines to L{basic.LineReceiver.lineReceived} and delivers them immediately upon being resumed. L{ConsumingProtocol} is a L{LineReceiver} that pauses itself after every line, and writes that line to its transport. s hello, s world � hello, worlds hello world r� )rV r� r� s goodbye )rV r� r� ru N) rS rO rV rY rZ r$ r� rQ r� r= )r �pr^ r r r �test_pauseResume^ sF z ProducerTests.test_pauseResumeN)r& r' r( r) rX r r r r rU Y rT rU c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�FileSenderTestsz( Tests for L{basic.FileSender}. c C s t �� }| �tt|�� dS )zP L{basic.FileSender} implements the L{IPullProducer} interface. N)r � FileSenderr� r r )r �senderr r r �test_interface� s z FileSenderTests.test_interfacec C sB t d�}t�� }t�� }|�||� | �|j|� | �|j � dS )z� When L{basic.FileSender.beginFileTransfer} is called, it registers itself with provided consumer, as a non-streaming producer. � Test contentN) r r r� r rZ �beginFileTransferrZ �producerr� � streaming)r �source�consumerr[ r r r �test_producerRegistered� s z'FileSenderTests.test_producerRegisteredc C sf t d�}t�� }t�� }|�||�}|�� |�� | �|j� | � d| � |�� | � d|� � � dS )z� L{basic.FileSender} sends the content of the given file using a C{IConsumer} interface via C{beginFileTransfer}. It returns a L{Deferred} which fires with the last byte sent. r] � tN) r r r� r rZ r^ r= � assertIsNoner_ rZ �successResultOfr� �r ra rb r[ �dr r r � test_transfer� s z FileSenderTests.test_transferc C s� t d�}t�� }t�� }d|_|�||�}|�� | �d|� � � |�� | �d|� � � |�� | �d|� � � |�� | �d| � |�� | �d|� � � dS )zj L{basic.FileSender} reads at most C{CHUNK_SIZE} every time it resumes producing. r] r8 s Tests Test conrd N) r r r� r rZ � CHUNK_SIZEr^ r= rZ r� rf rg r r r �test_transferMultipleChunks� s z+FileSenderTests.test_transferMultipleChunksc C sd dd� }t d�}t�� }t�� }|�|||�}|�� |�� | �d| �|�� | �d|� � � dS )z� L{basic.FileSender.beginFileTransfer} takes a C{transform} argument which allows to manipulate the data on the fly. c S s | � � S r )�swapcase)�chunkr r r � transform� s z=FileSenderTests.test_transferWithTransform.<locals>.transformr] � Ts tEST CONTENTN) r r r� r rZ r^ r= rZ rf r� )r rn ra rb r[ rh r r r �test_transferWithTransform� s z*FileSenderTests.test_transferWithTransformc C sV t d�}t�� }t�� }|�||�}|�� | �|�}|�t � | � dt |j �� dS )z� The C{Deferred} returned by L{basic.FileSender.beginFileTransfer} fails with an C{Exception} if C{stopProducing} when the transfer is not complete. r] z#Consumer asked us to stop producingN) r r r� r rZ r^ r> �failureResultOf�trap� ExceptionrZ �strr� )r ra rb r[ rh �failurer r r �test_abortedTransfer� s z$FileSenderTests.test_abortedTransferN) r& r' r( r) r\ rc ri rk rp rv r r r r rY � s rY );r) r r �ior �typingr r r �zope.interface.verifyr �twisted.internetr r �twisted.internet.interfacesr �twisted.internet.protocolr �twisted.protocolsr �twisted.python.compatr �twisted.python.failurer � twisted.testr � twisted.trialr r| r r+ r� rJ �SynchronousTestCaserN r� r� r� r� r r� r� r� r r �Int32StringReceiverr3 r6 �Int16StringReceiverr= r? �Int8StringReceiverrL rM rO rS rU �TestCaserY r r r r �<module> sN H yO, YIj IPK Mb�Z�ЎXD� D� 3 protocols/test/__pycache__/test_tls.cpython-310.pycnu �[��� o �bk � @ sf d Z ddlZddlmZmZmZ ddlmZ ddlm Z z&ddl m Z ddl m Z mZmZmZmZmZmZ ddlmZmZmZmZ W n eyS d Zd Z ZZY nw dd lm Z m Z dd l m Z m Z m!Z! dd l"m#Z# dd l$m%Z%m&Z& ddl'm(Z(m)Z) ddl*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 ddl2m3Z3m4Z4m5Z5m6Z6 ddl7m8Z8 ddl9m:Z:m;Z; ddl<m=Z= ddl>m?Z? ddl@mAZA ddlBmCZC ddlDmEZEmFZF ddlGmHZH ddlImJZJmKZK G dd� d�ZLG d d � d e5�ZM d1d d �ZNG d!d"� d"eK�ZO d2d#d$�ZPG d%d&� d&eJ�ZQG d'd(� d(eK�ZRG d)d*� d*eK�ZSG d+d,� d,eK�ZTee.�G d-d.� d.e3��ZUee.�G d/d0� d0e6��ZVdS )3z% Tests for L{twisted.protocols.tls}. � N)� Interface�directlyProvides� implementer)� verifyObject)� iterbytes)�crypto)� Connection�Context�Error�TLSv1_1_METHOD�TLSv1_2_METHOD� TLSv1_METHOD� WantReadError)�TLSMemoryBIOFactory�TLSMemoryBIOProtocol�_ProducerMembrane� _PullToPushz;pyOpenSSL 16.0.0 or newer required for twisted.protocol.tls)�PrivateCertificate�optionsForClientTLS)�ClientTLSContext�ServerTLSContext�certPath)�!certificatesForAuthorityAndServer)�Deferred� gatherResults)�ConnectionDone�ConnectionLost)�IHandshakeListener� IOpenSSLClientConnectionCreator� IOpenSSLServerConnectionCreator�IProtocolNegotiationFactory� IPushProducer� ISSLTransport� ISystemHandle)� ClientFactory�Factory�Protocol� ServerFactory)� TaskStopped)�collapsingPumpPolicy� loopbackAsync)�log)�Failure)�FilePath)�connectedServerAndClient)�NonStreamingProducer�StringTransport�� ConnectionLostNotifyingProtocol)�SynchronousTestCase�TestCasec @ s< e Zd ZdZdZefdd�Zedd� �Zdd� Z d d � Z d S ) � HandshakeCallbackContextFactorya L{HandshakeCallbackContextFactory} is a factory for SSL contexts which allows applications to get notification when the SSL handshake completes. @ivar _finished: A L{Deferred} which will be called back when the handshake is done. � c C s t � | _|| _d S �N)r � _finished�_method)�self�method� r< �A/usr/lib/python3/dist-packages/twisted/protocols/test/test_tls.py�__init__O s z(HandshakeCallbackContextFactory.__init__c C s | � }||j fS )z� Create a new L{HandshakeCallbackContextFactory} and return a two-tuple of it and a L{Deferred} which will fire when a connection created with it completes a TLS handshake. )r8 )�cls�contextFactoryr< r< r= �factoryAndDeferredS s z2HandshakeCallbackContextFactory.factoryAndDeferredc C s || j @ r | j�d� dS dS )a This is the "info callback" on the context. It will be called periodically by pyOpenSSL with information about the state of a connection. When it indicates the handshake is complete, it will fire C{self._finished}. N)�SSL_CB_HANDSHAKE_DONEr8 �callback)r: � connection�where�retr< r< r= �_info] s �z%HandshakeCallbackContextFactory._infoc C s t | j�}|�| j� |S )zp Create and return an SSL context configured to use L{self._info} as the info callback. )r r9 �set_info_callbackrG )r: �contextr< r< r= � getContextg s z*HandshakeCallbackContextFactory.getContextN) �__name__� __module__� __qualname__�__doc__rB r r> � classmethodrA rG rJ r< r< r< r= r5 B s r5 c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �AccumulatingProtocola. A protocol which collects the bytes it receives and closes its connection after receiving a certain minimum of data. @ivar howMany: The number of bytes of data to wait for before closing the connection. @ivar received: A L{list} of L{bytes} of the bytes received so far. c C � || _ d S r7 )�howMany)r: rR r< r< r= r> | � z AccumulatingProtocol.__init__c C � g | _ d S r7 )�received�r: r< r< r= �connectionMade rS z#AccumulatingProtocol.connectionMadec C s4 | j �|� ttt| j ��| jkr| j�� d S d S r7 )rU �append�sum�map�lenrR � transport�loseConnection�r: �datar< r< r= � dataReceived� s �z!AccumulatingProtocol.dataReceivedc C s |� t�s t�|� d S d S r7 )�checkr r+ �err�r: �reasonr< r< r= �connectionLost� s �z#AccumulatingProtocol.connectionLostN)rK rL rM rN r> rW r` re r< r< r< r= rP q s rP Fc s� t d�� t� }� fdd�|_�r"ttt�G �fdd�d��}|� }n | r*t|d�}nt� }t|| |�}|� d�}|du r@t � }|� |� � |fS )a Create a protocol hooked up to a TLS transport hooked up to a StringTransport. @param serverMethod: The TLS method accepted by the server-side and used by the created protocol. Set to to C{None} to use the default method used by your OpenSSL library. l �J)�c � � S r7 r< r< ��clientProtocolr< r= �<lambda>� � z"buildTLSProtocol.<locals>.<lambda>c s e Zd Z� fdd�ZeZdS )z-buildTLSProtocol.<locals>.HardCodedConnectionc rf r7 r< )r: � tlsProtocol��fakeConnectionr< r= �clientConnectionForTLS� � zDbuildTLSProtocol.<locals>.HardCodedConnection.clientConnectionForTLSN)rK rL rM rn �serverConnectionForTLSr< rl r< r= �HardCodedConnection� s rq �r; N) rP r$ �protocolr r r r r r � buildProtocolr0 �makeConnection) �serverr\ rm � serverMethod� clientFactoryrq r@ �wrapperFactory� sslProtocolr< )rh rm r= �buildTLSProtocol� s r{ c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �TLSMemoryBIOFactoryTestsz< Ensure TLSMemoryBIOFactory logging acts correctly. c C sn t � }g }|j}t�|� | �tj|� t� }dd� |_dd� |_t |d|�}|�� |�� | � |g � dS )zs L{TLSMemoryBIOFactory.doStart} and L{TLSMemoryBIOFactory.doStop} do not log any messages. c S � d S r7 r< r< r< r< r= ri � rj z5TLSMemoryBIOFactoryTests.test_quiet.<locals>.<lambda>c S r} r7 r< r< r< r< r= ri � rj FN) r rX r+ � addObserver� addCleanup�removeObserverr' �doStart�doStopr � assertEqual)r: r@ �logs�logger�wrappedFactory�factoryr< r< r= � test_quiet� s z#TLSMemoryBIOFactoryTests.test_quietc C s( t � }t|dt� �}| �d|�� � dS )z� L{TLSMemoryBIOFactory.logPrefix} amends the wrapped factory's log prefix with a short string (C{"TLS"}) indicating the wrapping, rather than its full class name. FzServerFactory (TLS)N)r r r' r� � logPrefix)r: r@ r� r< r< r= �test_logPrefix� s z'TLSMemoryBIOFactoryTests.test_logPrefixc C s6 G dd� d�}t � }t|d|� �}| �d|�� � dS )z� If the wrapped factory does not provide L{ILoggingContext}, L{TLSMemoryBIOFactory.logPrefix} uses the wrapped factory's class name. c @ � e Zd ZdS )zBTLSMemoryBIOFactoryTests.test_logPrefixFallback.<locals>.NoFactoryN�rK rL rM r< r< r< r= � NoFactory� � r� FzNoFactory (TLS)N)r r r� r� )r: r� r@ r� r< r< r= �test_logPrefixFallback� s z/TLSMemoryBIOFactoryTests.test_logPrefixFallbackN)rK rL rM rN r� r� r� r< r< r< r= r| � s r| c s� t � \}}tt�G ��fdd�dt��� tt�G dd� dt���ttd|d�dt�� fdd ��d ��t|�� d t ��fd d ��d ��t �fd d ��fdd �d d�\}}}|||fS )a Construct a client and server L{TLSMemoryBIOProtocol} connected by an IO pump. @param greetingData: The data which should be written in L{connectionMade}. @type greetingData: L{bytes} @return: 3-tuple of client, server, L{twisted.test.iosim.IOPump} c s: e Zd ZdZdZ� �fdd�Z�fdd�Zdd� Z� ZS ) z*handshakingClientAndServer.<locals>.ClientFNc s& t � �� �d ur| j��� d S d S r7 )�superrW r\ �writerV )� __class__�clientGreetingDatar< r= rW � s �z9handshakingClientAndServer.<locals>.Client.connectionMadec s( d| _ | j�� | _� r| j�� d S d S �NT)� handshookr\ �getPeerCertificate�peerAfterHandshake�abortConnectionrV )�clientAbortAfterHandshaker< r= �handshakeCompleted� s �z=handshakingClientAndServer.<locals>.Client.handshakeCompletedc S r} r7 r< rc r< r< r= re ro z9handshakingClientAndServer.<locals>.Client.connectionLost) rK rL rM r� r� rW r� re � __classcell__r< )r� r� )r� r= �Client� s r� c @ � e Zd ZdZdd� Zdd� ZdS )z*handshakingClientAndServer.<locals>.ServerFc S � d| _ d S r� )� handshakedrV r< r< r= r� rS z=handshakingClientAndServer.<locals>.Server.handshakeCompletedc S r} r7 r< rc r< r< r= re ro z9handshakingClientAndServer.<locals>.Server.connectionLostN)rK rL rM r� r� re r< r< r< r= �Server s r� � example.com�� trustRootTc � � d�S �Ni?B r< r< )r� r< r= ri � z,handshakingClientAndServer.<locals>.<lambda>)�isClientr� Fc r� r� r< r< )r� r< r= ri r� c � � � d �S r7 �rt r< )�serverFr< r= ri � c r� r7 r� r< )�clientFr< r= ri r� )�greet) r r r rP r r r$ � forProtocol�optionsr' r. )r� r� �authCert� serverCert�clientrv �pumpr< )r� r� r� r� r� r� r= �handshakingClientAndServer� s* �� � r� c @ r� )� DeterministicTLSMemoryBIOTestsz� Test for the implementation of L{ISSLTransport} which runs over another transport. @note: Prefer to add test cases to this suite, in this style, using L{connectedServerAndClient}, rather than returning L{Deferred}s. c C sh t � \}}}| �|jjd� | �|jjd� |�� | �|jjd� | �|jjd� | �|jjd� dS )a The completion of the TLS handshake calls C{handshakeCompleted} on L{Protocol} objects that provide L{IHandshakeListener}. At the time C{handshakeCompleted} is invoked, the transport's peer certificate will have been initialized. FTN)r� r� �wrappedProtocolr� r� �flush� assertIsNotr� )r: r� rv r� r< r< r= �test_handshakeNotification) s z9DeterministicTLSMemoryBIOTests.test_handshakeNotificationc C s0 t dd�\}}}|j}|�� | �|jg � dS )a If some data is written to the transport in C{connectionMade}, but C{handshakeDone} doesn't like something it sees about the handshake, it can use C{abortConnection} to ensure that the application never receives that data. s untrustworthyTN)r� r� r� r� rU )r: r� rv r� �wrappedServerProtocolr< r< r= �test_handshakeStopWriting8 s z8DeterministicTLSMemoryBIOTests.test_handshakeStopWritingN)rK rL rM rN r� r� r< r< r< r= r� s r� c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zefd d!�Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Z d2d3� Z d4d5� Z d6d7� Z d8S )9�TLSMemoryBIOTestsze Tests for the implementation of L{ISSLTransport} which runs over another L{ITransport}. c C s. t dd�}| �t�|�� | �t�|�� dS )zj L{TLSMemoryBIOProtocol} instances provide L{ISSLTransport} and L{ISystemHandle}. N)r � assertTruer" � providedByr# )r: �protor< r< r= �test_interfacesK s z!TLSMemoryBIOTests.test_interfacesc C sp G dd� dt �}G dd� d�}t� }t� }t|d|�}|� }t||� t|t� �}|�|� | �|� |�� dS )zw L{TLSMemoryBIOProtocol} instances provide the interfaces provided by the transport they wrap. c @ r� )zDTLSMemoryBIOTests.test_wrappedProtocolInterfaces.<locals>.ITransportNr� r< r< r< r= � ITransportZ r� r� c @ � e Zd Zdd� ZdS )zETLSMemoryBIOTests.test_wrappedProtocolInterfaces.<locals>.MyTransportc S r} r7 r< r^ r< r< r= r� ^ ro zKTLSMemoryBIOTests.test_wrappedProtocolInterfaces.<locals>.MyTransport.writeN)rK rL rM r� r< r< r< r= � MyTransport] � r� TN) r r$ r r r r r& ru r� r� )r: r� r� rx r@ ry r\ rk r< r< r= � test_wrappedProtocolInterfacesT s z0TLSMemoryBIOTests.test_wrappedProtocolInterfacesc C sH t � }t� }t|d|�}t|t� �}t� }|�|� | �|�� t � dS )a/ L{TLSMemoryBIOProtocol.getHandle} returns the L{OpenSSL.SSL.Connection} instance it uses to actually implement TLS. This may seem odd. In fact, it is. The L{OpenSSL.SSL.Connection} is not actually the "system handle" here, nor even an object the reactor knows about directly. However, L{twisted.internet.ssl.Certificate}'s C{peerFromTransport} and C{hostFromTransport} methods depend on being able to get an L{OpenSSL.SSL.Connection} object in order to work properly. Implementing L{ISystemHandle.getHandle} like this is the easiest way for those APIs to be made to work. If they are changed, then it may make sense to get rid of this implementation of L{ISystemHandle} and return the underlying socket instead. TN) r$ r r r r& r0 ru �assertIsInstance� getHandler )r: r� r@ ry r� r\ r< r< r= �test_getHandlek s z TLSMemoryBIOTests.test_getHandlec sr t � � t� }� fdd�|_t� }t|d|�}|�d�}t� }|�|� | �� j � | � � j |� | � � j |� dS )z� When L{TLSMemoryBIOProtocol} is connected to a transport, it connects the protocol it wraps to a transport. c rf r7 r< r< rg r< r= ri � rj z7TLSMemoryBIOTests.test_makeConnection.<locals>.<lambda>TN) r& r$ rs r r rt r0 ru �assertIsNotNoner\ r� �assertIs)r: rx r@ ry rz r\ r< rg r= �test_makeConnection� s z%TLSMemoryBIOTests.test_makeConnectionc C sl t � }t|_t�� \}}t|d|�}|�d�}t� }t|_t� }t|d|�}|�d�}t ||�} |||| fS )z@ Start handshake between TLS client and server. TNF) r$ r& rs r5 rA r rt r' r r* ) r: rx �clientContextFactory�handshakeDeferredry �sslClientProtocol� serverFactory�serverContextFactory�sslServerProtocol�connectionDeferredr< r< r= �handshakeProtocols� s& � �z$TLSMemoryBIOTests.handshakeProtocolsc C s | � � \}}}}|S )zr The TLS handshake is performed when L{TLSMemoryBIOProtocol} is connected to a transport. )r� )r: � tlsClient� tlsServerr� �_r< r< r= �test_handshake� s z TLSMemoryBIOTests.test_handshakec s� t � � t� }� fdd�|_t� }t|d|�}|�d�}t � �t� }�fdd�|_tt�� � }t � |�}|� |�}t|d|�}|�d�} t | |�} dd� } � �| � ��| � t� �| g�S ) z� L{TLSMemoryBIOProtocol} reports errors in the handshake process to the application-level protocol object using its C{connectionLost} method and disconnects the underlying transport. c � t � �S r7 r1 r< ��clientConnectionLostr< r= ri � � �z9TLSMemoryBIOTests.test_handshakeFailure.<locals>.<lambda>TNc r� r7 r1 r< )�serverConnectionLostr< r= ri � r� Fc S s | j �t� d S r7 )�lostConnectionReason�trapr )rs r< r< r= �cbConnectionLost� s zATLSMemoryBIOTests.test_handshakeFailure.<locals>.cbConnectionLost)r r$ rs r5 r rt r' r- r � getContentr �loadPEMr� r* � addCallbackr ) r: rx r� ry r� r� �certificateData� certificater� r� r� r� r< )r� r� r= �test_handshakeFailure� s* �z'TLSMemoryBIOTests.test_handshakeFailurec s| t � }t|_t�� \}}t|d|�}|�d��t� }t|_t� }t|d|�}|�d�}t |�� � �fdd�}|� |� |S )z� L{TLSMemoryBIOProtocol.getPeerCertificate} returns the L{OpenSSL.crypto.X509} instance representing the peer's certificate. TNFc s, �� � }� �|tj� � �|�d�d� d S )N�sha1s; 23:4B:72:99:2E:5D:5E:2B:02:C3:BC:1B:7C:50:67:05:4F:60:FF:C9)r� r� r �X509r� �digest)�ignored�cert�r: r� r< r= � cbHandshook s �z>TLSMemoryBIOTests.test_getPeerCertificate.<locals>.cbHandshook) r$ r& rs r5 rA r rt r' r r* r� ) r: rx r� r� ry r� r� r� r� r< r� r= �test_getPeerCertificate� s" � z)TLSMemoryBIOTests.test_getPeerCertificatec s� d�t � � t� }� fdd�|_t�� \}}t|d|�}|�d�}tt����t � }�fdd�|_t � }t|d|�}|�d�}t ||��� ��fdd �} |� | � ���fd d �} |� | � |S ) �� Bytes written to L{TLSMemoryBIOProtocol} before the handshake is complete are received by the protocol on the other side of the connection once the handshake succeeds. � some bytesc rf r7 r< r< rg r< r= ri rj z<TLSMemoryBIOTests.test_writeAfterHandshake.<locals>.<lambda>TNc rf r7 r< r< ��serverProtocolr< r= ri + rj Fc s � j ��� �S r7 �r\ r� �r� )rh r� r_ r< r= r� 4 s z?TLSMemoryBIOTests.test_writeAfterHandshake.<locals>.cbHandshookc � �� d��j�� � d S �N� �r� �joinrU r� �r_ r: r� r< r= �cbDisconnected> � zBTLSMemoryBIOTests.test_writeAfterHandshake.<locals>.cbDisconnected) r& r$ rs r5 rA r rt rP r[ r' r r* r� ) r: rx r� r� ry r� r� r� r� r� r� r< )rh r� r_ r: r� r= �test_writeAfterHandshake s, � z*TLSMemoryBIOTests.test_writeAfterHandshakec s� t � }||_t�� \}}t|d|�}|�d�}tt� ���t� }�fdd�|_t � } t| d|�}|�d�} t | |�} � ��fdd�} | � | � | S )z{ Run test where client sends data before handshake, given the sending protocol and expected bytes. TNc rf r7 r< r< r� r< r= ri V rj z<TLSMemoryBIOTests.writeBeforeHandshakeTest.<locals>.<lambda>Fc r� r� r� r� r� r< r= �cbConnectionDone` r� zDTLSMemoryBIOTests.writeBeforeHandshakeTest.<locals>.cbConnectionDone) r$ rs r5 rA r rt rP r[ r' r r* r� ) r: �sendingProtocolr_ rx r� r� ry r� r� r� r� r� r� r< r� r= �writeBeforeHandshakeTestE s$ � z*TLSMemoryBIOTests.writeBeforeHandshakeTestc �$ d� G � fdd�dt �}| �|� �S )r� r� c � e Zd Z� fdd�ZdS )zJTLSMemoryBIOTests.test_writeBeforeHandshake.<locals>.SimpleSendingProtocolc s | j �� � d S r7 r� rV �r_ r< r= rW o � zYTLSMemoryBIOTests.test_writeBeforeHandshake.<locals>.SimpleSendingProtocol.connectionMadeN�rK rL rM rW r< r r< r= �SimpleSendingProtocoln � r �r& r� �r: r r< r r= �test_writeBeforeHandshakef s z+TLSMemoryBIOTests.test_writeBeforeHandshakec r )z� Bytes written to L{TLSMemoryBIOProtocol} with C{writeSequence} are received by the protocol on the other side of the connection. r� c r )zCTLSMemoryBIOTests.test_writeSequence.<locals>.SimpleSendingProtocolc s | j �tt� ��� d S r7 )r\ � writeSequence�listr rV r r< r= rW | r� zRTLSMemoryBIOTests.test_writeSequence.<locals>.SimpleSendingProtocol.connectionMadeNr r< r r< r= r { r r r r r< r r= �test_writeSequencet s z$TLSMemoryBIOTests.test_writeSequencec r )z� Bytes written to L{TLSMemoryBIOProtocol} after C{loseConnection} is called are not transmitted (unless there is a registered producer, which will be tested elsewhere). r� c r )zNTLSMemoryBIOTests.test_writeAfterLoseConnection.<locals>.SimpleSendingProtocolc s4 | j �� � | j �� | j �d� | j �dg� d S )N� hello� world)r\ r� r] r rV r r< r= rW � s z]TLSMemoryBIOTests.test_writeAfterLoseConnection.<locals>.SimpleSendingProtocol.connectionMadeNr r< r r< r= r � r r r r r< r r= � test_writeAfterLoseConnection� s z/TLSMemoryBIOTests.test_writeAfterLoseConnectionc s> d� g �G � �fdd�dt �}��|d�}|���fdd��S )zV Writing C{unicode} to L{TLSMemoryBIOProtocol} throws a C{TypeError}. �helloc � e Zd Z� �fdd�ZdS )zQTLSMemoryBIOTests.test_writeUnicodeRaisesTypeError.<locals>.SimpleSendingProtocolc sH z| j �� � W n ty ��d� Y nw | j �d� | j �� d S )NT� bytes)r\ r� � TypeErrorrX r] rV ��notBytes�resultr< r= rW � s � z`TLSMemoryBIOTests.test_writeUnicodeRaisesTypeError.<locals>.SimpleSendingProtocol.connectionMadeNr r< r r< r= r � � r r c s �� � dg�S r� )r� ��ign)r r: r< r= ri � s zDTLSMemoryBIOTests.test_writeUnicodeRaisesTypeError.<locals>.<lambda>)r& r� r� )r: r �dr< )r r r: r= � test_writeUnicodeRaisesTypeError� s z2TLSMemoryBIOTests.test_writeUnicodeRaisesTypeErrorc s� g d�� G � fdd�dt �}t� }||_t� }t|d|�}|�d�}tttt � ����t � }�fdd�|_t � }t|d|�}|�d�}t ||t �} � ��fd d �} | �| � | S ) z� If multiple separate TLS messages are received in a single chunk from the underlying transport, all of the application bytes from each message are delivered to the application-level protocol. ) � a� b� c� d� e� f� g� h� ic r )zDTLSMemoryBIOTests.test_multipleWrites.<locals>.SimpleSendingProtocolc s � D ]}| j �|� qd S r7 r� )r: �br r< r= rW � s �zSTLSMemoryBIOTests.test_multipleWrites.<locals>.SimpleSendingProtocol.connectionMadeNr r< r r< r= r � r r TNc rf r7 r< r< r� r< r= ri � rj z7TLSMemoryBIOTests.test_multipleWrites.<locals>.<lambda>Fc s �� d��j�d�� �� d S r� r� r� r� r< r= r� � � z?TLSMemoryBIOTests.test_multipleWrites.<locals>.cbConnectionDone)r& r$ rs r5 r rt rP rY rZ r[ r' r r* r) r� ) r: r rx r� ry r� r� r� r� r� r� r< r� r= �test_multipleWrites� s& � z%TLSMemoryBIOTests.test_multipleWritesc s� d� d�G � �fdd�dt �}t� }||_t|d�}t|d|�}|�d�}tt� �� ��t� }�fdd �|_t |d�}t|d |�}|�d�} t | |�} � ���fd d �} | � | � | S ) z� If a very long string is passed to L{TLSMemoryBIOProtocol.write}, any trailing part of it which cannot be send immediately is buffered and sent later. r� i c r )z:TLSMemoryBIOTests.hugeWrite.<locals>.SimpleSendingProtocolc s | j �� � � d S r7 r� rV �r_ �factorr< r= rW � s zITLSMemoryBIOTests.hugeWrite.<locals>.SimpleSendingProtocol.connectionMadeNr r< r( r< r= r � r r rr TNc rf r7 r< r< r� r< r= ri � rj z-TLSMemoryBIOTests.hugeWrite.<locals>.<lambda>Fc s �� d��j�� � � d S r� r� r� �r_ r) r: r� r< r= r� � s z5TLSMemoryBIOTests.hugeWrite.<locals>.cbConnectionDone) r& r$ rs r5 r rt rP r[ r' r r* r� ) r: r; r rx r� ry r� r� r� r� r� r� r< r* r= � hugeWrite� s$ zTLSMemoryBIOTests.hugeWritec C s | � � S r7 )r+ rV r< r< r= �test_hugeWrite_TLSv1� � z&TLSMemoryBIOTests.test_hugeWrite_TLSv1c C � | j td�S �Nrr )r+ r rV r< r< r= �test_hugeWrite_TLSv1_1� � z(TLSMemoryBIOTests.test_hugeWrite_TLSv1_1c C r. r/ )r+ r rV r< r< r= �test_hugeWrite_TLSv1_2� r1 z(TLSMemoryBIOTests.test_hugeWrite_TLSv1_2c sf t � � t� }� fdd�|_t� }t|d|�}|�d�}t� }t||� |j� � dd� }� � |� � S )z~ If a L{TLSMemoryBIOProtocol} loses its connection unexpectedly, this is reported to the application. c r� r7 r1 r< r� r< r= ri r� z;TLSMemoryBIOTests.test_disorderlyShutdown.<locals>.<lambda>TNc S s | j �tt� d S r7 )r� r� r r rg r< r< r= r� s zATLSMemoryBIOTests.test_disorderlyShutdown.<locals>.cbDisconnected) r r$ rs r5 r rt r& r* r\ r] r� )r: rx r� ry r� r� r� r< r� r= �test_disorderlyShutdown� s z)TLSMemoryBIOTests.test_disorderlyShutdownc s� G dd� dt �}t� �t� }|����fdd�|_t�� \}}t|d|�}|�d�}t� �|���t� }�fdd�|_t � }t|d|�}|�d�} t | |� d d � � ����fd d �} |� | � � �fd d�} |� | � |S )z� L{TLSMemoryBIOProtocol.loseConnection} sends a TLS close alert and shuts down the underlying connection cleanly on both sides, after transmitting all buffered data. c @ s e Zd Zdd� Zdd� ZdS )zNTLSMemoryBIOTests.test_loseConnectionAfterHandshake.<locals>.NotifyingProtocolc S s t �| |� g | _d S r7 )r2 r> r_ )r: �onConnectionLostr< r< r= r> " s zWTLSMemoryBIOTests.test_loseConnectionAfterHandshake.<locals>.NotifyingProtocol.__init__c S s | j �|� d S r7 )r_ rX r^ r< r< r= r` & r z[TLSMemoryBIOTests.test_loseConnectionAfterHandshake.<locals>.NotifyingProtocol.dataReceivedN)rK rL rM r> r` r< r< r< r= �NotifyingProtocol! s r5 c rf r7 r< r< rg r< r= ri , rj zETLSMemoryBIOTests.test_loseConnectionAfterHandshake.<locals>.<lambda>TNc rf r7 r< r< r� r< r= ri 8 rj Fs 123456890i�� c s. �j �� � �j �d� �j �� t��g�S )N� x)r\ r� r] r r� )� chunkOfBytesr� rh r� r� r< r= � cbHandshakeB s zHTLSMemoryBIOTests.test_loseConnectionAfterHandshake.<locals>.cbHandshakec sX | \}}|j �t� |j �t� ��d�|j�� � ��|jjj � ��|jjj � d S r� ) r� r� r r� r� r_ r� r\ �q� disconnect)r rh r� )r7 r: r< r= r� U s zMTLSMemoryBIOTests.test_loseConnectionAfterHandshake.<locals>.cbConnectionDone) r2 r r$ rs r5 rA r rt r' r r* r� ) r: r5 rx r� r� ry r� r� r� r� r8 r� r< )r7 r� rh r: r� r� r= �!test_loseConnectionAfterHandshake s2 � z3TLSMemoryBIOTests.test_loseConnectionAfterHandshakec C s� G dd� dt �}tt� dt� �}|� }t||�}t� }|�|� |�d� | �|j � | � |j � |� t td��� | �|j �t�� | �|j jjd� dS )zz The user protocol's connectionLost is only called when transport underlying TLS is disconnected. c @ s e Zd ZdZdd� ZdS )zTTLSMemoryBIOTests.test_connectionLostOnlyAfterUnderlyingCloses.<locals>.LostProtocolNc S rQ r7 )� disconnectedrc r< r< r= re r rS zcTLSMemoryBIOTests.test_connectionLostOnlyAfterUnderlyingCloses.<locals>.LostProtocol.connectionLost)rK rL rM r< re r< r< r< r= � LostProtocolo � r= TN�ono)r? )r& r r r$ r r0 ru �_tlsShutdownFinishedr� � disconnecting� assertIsNoner< re r, r ra r� �value�args)r: r= ry rs rk r\ r< r< r= �,test_connectionLostOnlyAfterUnderlyingClosesi s z>TLSMemoryBIOTests.test_connectionLostOnlyAfterUnderlyingClosesc s| | � � \}}}}| �|� g � |jf� fdd� }||_|�d� |�� | �|j� | �� dg� |�� | �� dg� |S )z� If TLSMemoryBIOProtocol.loseConnection is called multiple times, all but the first call have no effect. c � � � d� | � S �N� �rX ��shutdown��callsr< r= � _shutdownTLS� � z@TLSMemoryBIOTests.test_loseConnectionTwice.<locals>._shutdownTLSr6 rH )r� �successResultOfrN r� r] r� rA r� )r: r� r� r� �disconnectDeferredrN r< rL r= �test_loseConnectionTwice� s" � z*TLSMemoryBIOTests.test_loseConnectionTwicec s\ �� � \}�}}g � |jf� fdd� }|�_��d� |�� � ��fdd�}|�|� |S )zq If TLSMemoryBIOProtocol.loseConnection is called after connectionLost, it does nothing. c rF rG rI rJ rL r< r= rN � rO zNTLSMemoryBIOTests.test_loseConnectionAfterConnectionLost.<locals>._shutdownTLSr6 c s( �� � dg� ��� �� � dg� d S rG )r� r] �r� �rM r: r� r< r= r< � s zNTLSMemoryBIOTests.test_loseConnectionAfterConnectionLost.<locals>.disconnected)r� rN r� r] r� )r: r� r� rQ rN r< r< rT r= �&test_loseConnectionAfterConnectionLost� s � z8TLSMemoryBIOTests.test_loseConnectionAfterConnectionLostc s` �� � \�}}}|j}g }g � |j|_� j|_�fdd�}|�|� � �fdd�}|�|� |S )zP Unexpected disconnects get converted to ConnectionLost errors. c s � � d� � j�� d S �Nr )r� r\ r] r �r� r< r= � handshakeDone� s z;TLSMemoryBIOTests.test_unexpectedEOF.<locals>.handshakeDonec � �� � d �t�� d � d S �Nr )r� ra r r �rd r: r< r= r< � r& z:TLSMemoryBIOTests.test_unexpectedEOF.<locals>.disconnected)r� r� rX r` re r� )r: r� r� rQ r� r_ rX r< r< �rd r: r� r= �test_unexpectedEOF� s � z$TLSMemoryBIOTests.test_unexpectedEOFc sj �� � \�}}}g � � j�j_G dd� d�}|�j��_�fdd�}|�|� � �fdd�}|�|� |S )zN Errors while writing cause the protocols to be disconnected. c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )z4TLSMemoryBIOTests.test_errorWriting.<locals>.Wrapperc S rQ r7 )�_wrapped)r: �wrappedr< r< r= r> � rS z=TLSMemoryBIOTests.test_errorWriting.<locals>.Wrapper.__init__c S s t | j|�S r7 )�getattrr^ )r: �attrr< r< r= � __getattr__� r1 z@TLSMemoryBIOTests.test_errorWriting.<locals>.Wrapper.__getattr__c W s t d��)NzONO!)r )r: rD r< r< r= �send r- z9TLSMemoryBIOTests.test_errorWriting.<locals>.Wrapper.sendN)rK rL rM r> rb rc r< r< r< r= �Wrapper� s rd c � � � d� d S rV )r� r rW r< r= rX � z:TLSMemoryBIOTests.test_errorWriting.<locals>.handshakeDonec rY rZ )r� ra r r r[ r< r= r< r& z9TLSMemoryBIOTests.test_errorWriting.<locals>.disconnected)r� rX r� re �_tlsConnectionr� )r: r� r� rQ rd rX r< r< r\ r= �test_errorWriting� s � z#TLSMemoryBIOTests.test_errorWritingc C s� dd� }| � tj� t�� G dd� dt�}G dd� dt�}|t�}||�}t� \}}t|�� dt � |��}tt d|d �d t � |��} t t||� �t| |� �� |t�} ||�} | � | |� | � | |� d S ) z� TLSMemoryBIOProtocol doesn't leave circular references that keep it in memory after connection is closed. c s t � fdd�t�� D ��S )z� Return the number of instances of a given type in memory. @param type: Type whose instances to find. @return: The number of instances found. c 3 s � | ] }t |� �rd V qdS )rH N)� isinstance)�.0�x��typer< r= � <genexpr>! s � zVTLSMemoryBIOTests.test_noCircularReferences.<locals>.nObjectsOfType.<locals>.<genexpr>)rY �gc� get_objectsrl r< rl r= �nObjectsOfType s zCTLSMemoryBIOTests.test_noCircularReferences.<locals>.nObjectsOfTypec @ r� )zCTLSMemoryBIOTests.test_noCircularReferences.<locals>.CloserProtocolc S s | j �� d S r7 )r\ r] r^ r< r< r= r` ' rf zPTLSMemoryBIOTests.test_noCircularReferences.<locals>.CloserProtocol.dataReceivedN)rK rL rM r` r< r< r< r= �CloserProtocol& r� rr c @ r� )zDTLSMemoryBIOTests.test_noCircularReferences.<locals>.GreeterProtocolc S s | j �d� d S rV r� rV r< r< r= rW + r zSTLSMemoryBIOTests.test_noCircularReferences.<locals>.GreeterProtocol.connectionMadeNr r< r< r< r= �GreeterProtocol* r� rs Fr� r� TN)r ro �enable�disabler& r r r r� r% r� r r* r� ) r: rq rr rs � origTLSProtos�origServerProtosr� r� r� rx � newTLSProtos�newServerProtosr< r< r= �test_noCircularReferences s0 � � � z+TLSMemoryBIOTests.test_noCircularReferencesN) rK rL rM rN r� r� r� r� r� r� r� r� r� r� r r r r r' r r+ r, r0 r2 r3 r; rE rR rU r] rh rz r< r< r< r= r� E s: 0(/! (& O !# 'r� c @ s� e Zd ZdZd.dd�Z d/dd�Zdd � Zd d � Zd d � Zdd� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� ZdS )0�TLSProducerTestszA The TLS transport must support the IConsumer interface. Fc C s( |� � }|�� | �t|p|�d� |S )a� Drain the bytes currently pending write from a L{StringTransport}, then clear it, since those bytes have been consumed. @param transport: The L{StringTransport} to get the bytes from. @type transport: L{StringTransport} @param allowEmpty: Allow the test to pass even if the transport has no outgoing bytes in it. @type allowEmpty: L{bool} @return: the outgoing bytes from the given transport @rtype: L{bytes} T)rC �clearr� �bool)r: r\ � allowEmptyrC r< r< r= �drainJ s zTLSProducerTests.drainNc C sP G dd� dt �}t||||d�\}}|� }|j�|d� | �|jj� |||fS )a� Create a new client-side protocol that is connected to a remote TLS server. @param serverMethod: The TLS method accepted by the server-side. Set to to C{None} to use the default method used by your OpenSSL library. @return: A tuple with high level client protocol, the low-level client-side TLS protocol, and a producer that is used to send data to the client. c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) zGTLSProducerTests.setupStreamingProducer.<locals>.HistoryStringTransportc S s t �| � g | _d S r7 )r0 r> �producerHistoryrV r< r< r= r> j s zPTLSProducerTests.setupStreamingProducer.<locals>.HistoryStringTransport.__init__c S � | j �d� t�| � d S )N�pause)r� rX r0 �pauseProducingrV r< r< r= r� n � zVTLSProducerTests.setupStreamingProducer.<locals>.HistoryStringTransport.pauseProducingc S r� )N�resume)r� rX r0 �resumeProducingrV r< r< r= r� r r� zWTLSProducerTests.setupStreamingProducer.<locals>.HistoryStringTransport.resumeProducingc S r� )N�stop)r� rX r0 � stopProducingrV r< r< r= r� v r� zUTLSProducerTests.setupStreamingProducer.<locals>.HistoryStringTransport.stopProducingN)rK rL rM r> r� r� r� r< r< r< r= �HistoryStringTransporti s r� )r\ rm rv rw T)r0 r{ r\ �registerProducerr� � streaming) r: r\ rm rv rw r� �applicationProtocolrk �producerr< r< r= �setupStreamingProducer^ s � z'TLSProducerTests.setupStreamingProducerc C sz t d�D ]$}| �|jd�}|r|�|� | �|jd�}|r"|�|� |s(|s( nq| �|j�� d� | �|j�� d� dS )zJ Transfer bytes back and forth between two TLS protocols. � Tr� N)�ranger r\ r` r� rC )r: rk �serverTLSProtocol�i� clientData� serverDatar< r< r= �flushTwoTLSProtocols� s �z%TLSProducerTests.flushTwoTLSProtocolsc C s� | � � \}}}| j dtd�\}}}| �||� |j�d� |j�d� | �||� | �dg|j� | �dg|j� |j}| �d|�� � |� � | � t |j � |� � |�| �|j�� d}|j�|� |j�� |�| �|j�� | �|j�} | dd� | dd � | d d � fD ]} |�| � q�| �|jjd � |j�� | �||� | �|jjd� | �ddg|j� | �|jd d g� d S )z� If we write some data to a TLS connection that is blocked waiting for a renegotiation with its peer, it will pause and resume its registered producer exactly once. Renegotiation only works on TLSv1.2 or less. T)rv rw s data from clients data from serverzTLSv1.2s payloadr rH � NFr� r� )r� r r� r\ r� r� rU rg �get_cipher_version� renegotiate� assertRaisesr � do_handshake� _flushSendBIOr` r r] rA �unregisterProducerr� ) r: rh �clientTransportr� r� �serverTransport�serverProducer�tlsc�payload� messageThatUnblocksTheServer�fragmentr< r< r= � test_producerDuringRenegotiation� s@ � � z1TLSProducerTests.test_producerDuringRenegotiationc C sJ | � � \}}}|jj�� | �|jd� | �|jdg� | �|jj � dS )z� When the TLS transport is not blocked on reads, it correctly calls pauseProducing on the registered producer. �pausedr� N) r� r\ r� r� r� � producerStater� r� � _producer�_producerPaused�r: r� rk r� r< r< r= �(test_streamingProducerPausedInNormalMode� s z9TLSProducerTests.test_streamingProducerPausedInNormalModec C sh | � � \}}}|jj�� | �|jdg� |jj�� | �|jd� | �|jddg� | �|j j � dS )z� When the TLS transport is not blocked on reads, it correctly calls resumeProducing on the registered producer. r� � producingr� N) r� r\ r� r� r� r� r� r� � assertFalser� r� r� r< r< r= �)test_streamingProducerResumedInNormalMode� s z:TLSProducerTests.test_streamingProducerResumedInNormalModec C sJ | � � \}}}|j�d� | �|jd� | �|jdg� | �|jj� dS )z� When the TLS transport is blocked on reads, it correctly calls pauseProducing on the registered producer. r r� r� N) r� r\ r� r� r� r� r� r� r� �r: rh rk r� r< r< r= �4test_streamingProducerPausedInWriteBlockedOnReadMode� s zETLSProducerTests.test_streamingProducerPausedInWriteBlockedOnReadModec C s� | � � \}}}|j�dd � | �|jdg� tdd�\}}| �||� | �|jddg� | �|jj � | �|jj � | �|j d� dS ) z� When the TLS transport is blocked on reads, it correctly calls resumeProducing on the registered producer. s hello worldi � r� T�rv r� r� N) r� r\ r� r� r� r{ r� r� r� r� rA r� )r: rh rk r� r� r� r< r< r= �5test_streamingProducerResumedInWriteBlockedOnReadMode� s zFTLSProducerTests.test_streamingProducerResumedInWriteBlockedOnReadModec C s@ | � � \}}}|j}t� }| �t|jj|d� | �|j|� dS )zM Registering a streaming producer twice throws an exception. TN)r� r� �objectr� � RuntimeErrorr\ r� r� )r: rh rk r� �originalProducer� producer2r< r< r= �test_streamingProducerTwice s �z,TLSProducerTests.test_streamingProducerTwicec C s6 | � � \}}}|j�� | �|j� | �|jj� dS )z\ Unregistering a streaming producer removes it, reverting to initial state. N�r� r\ r� rB r� r� r� r< r< r= � test_streamingProducerUnregister" s z1TLSProducerTests.test_streamingProducerUnregisterc C s@ | � � \}}}|j�� |j�� | �|j� | �|jj� dS )zd Unregistering a streaming producer when no producer is registered is safe. Nr� r� r< r< r= �%test_streamingProducerUnregisterTwice+ s z6TLSProducerTests.test_streamingProducerUnregisterTwicec C s | � � \}}}tdd�\}}|s| �||� n |j�d� |j�� | �||� | �|jj� | �d|jv � |j�d� |j� ddg� |j� � | � |j� � d� | �|jj� |j�d � |j� d g� | �||� | � |jj� | �d�|j�d � d S ) zl Common code for tests involving writes by producer after loseConnection is called. Tr� s x r� r � r r� s won'ts won't!s x hello worldN)r� r{ r� r\ r� r] r� rA r� r r� �assertNotEqualrC r� r� r� rU )r: �writeBlockedOnReadrh rk r� r� r� r< r< r= �loseConnectionWithProducer6 s( z+TLSProducerTests.loseConnectionWithProducerc C � | � d�S )z� loseConnection() waits for the producer to unregister itself, then does a clean TLS close alert, then closes the underlying connection. F�r� rV r< r< r= �0test_streamingProducerLoseConnectionWithProducerf s zATLSProducerTests.test_streamingProducerLoseConnectionWithProducerc C r� )z� Even when writes are blocked on reading, loseConnection() waits for the producer to unregister itself, then does a clean TLS close alert, then closes the underlying connection. Tr� rV r< r< r= �4test_streamingProducerLoseConnectionWithProducerWBORm s zETLSProducerTests.test_streamingProducerLoseConnectionWithProducerWBORc C s� G dd� dt �}G dd� d�}|� }| j||� d�\}}}| �|jd� |j�d� | �|jd� | �|jd g� |jj�� | �|jd� | �|jd d g� |� d� | �|jd� | �|jd d g� d S ) z� pauseProducing() events can come from both the TLS transport layer and the underlying transport. In this case, both decide to pause, underlying first. c @ � e Zd ZdZdd� ZdS )zbTLSProducerTests.test_streamingProducerBothTransportsDecideToPause.<locals>.PausingStringTransportFc S s0 | j s| jd urd| _ | j�� t�| |� d S r� )� _didPauser� r� r0 r� r^ r< r< r= r� s zhTLSProducerTests.test_streamingProducerBothTransportsDecideToPause.<locals>.PausingStringTransport.writeN)rK rL rM r� r� r< r< r< r= �PausingStringTransport| r> r� c @ sD e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dS )zYTLSProducerTests.test_streamingProducerBothTransportsDecideToPause.<locals>.TLSConnectionc S rT r7 )�lrV r< r< r= r> � rS zbTLSProducerTests.test_streamingProducerBothTransportsDecideToPause.<locals>.TLSConnection.__init__c S sF | j s |d d� }t| j �dkr| j �d� t� �| j �|� t|�S )N���rH r� )r� r[ rX r r^ r< r< r= rc � s z^TLSProducerTests.test_streamingProducerBothTransportsDecideToPause.<locals>.TLSConnection.sendc S r} r7 r< rV r< r< r= �set_connect_state� ro zkTLSProducerTests.test_streamingProducerBothTransportsDecideToPause.<locals>.TLSConnection.set_connect_statec S r} r7 r< rV r< r< r= r� � ro zfTLSProducerTests.test_streamingProducerBothTransportsDecideToPause.<locals>.TLSConnection.do_handshakec S r} r7 r< r^ r< r< r= � bio_write� ro zcTLSProducerTests.test_streamingProducerBothTransportsDecideToPause.<locals>.TLSConnection.bio_writec S s dS )N� Xr< �r: �sizer< r< r= �bio_read� ro zbTLSProducerTests.test_streamingProducerBothTransportsDecideToPause.<locals>.TLSConnection.bio_readc S � t � �r7 )r r� r< r< r= �recv� � z^TLSProducerTests.test_streamingProducerBothTransportsDecideToPause.<locals>.TLSConnection.recvN) rK rL rM r> rc r� r� r� r� r� r< r< r< r= � TLSConnection� s r� rl r� r r� r� r� N) r0 r� r� r� r\ r� r� r� r� r` )r: r� r� r\ rh rk r� r< r< r= �1test_streamingProducerBothTransportsDecideToPauseu s � zBTLSProducerTests.test_streamingProducerBothTransportsDecideToPausec C s, | � � \}}}|jj�� | �|jd� dS )z� If the underlying transport tells its producer to stopProducing(), this is passed on to the high-level producer. �stoppedN)r� r\ r� r� r� r� r� r< r< r= �#test_streamingProducerStopProducing� s z4TLSProducerTests.test_streamingProducerStopProducingc s� t � \}�t|j�� |j�� d� �jjj����t� ���j� � ���j |j� �� �jj � � ���fdd�}� j � |� t dd�\}}���|� � j S )zM Non-streaming producers get wrapped as streaming producers. Fc s* �� � j� �� �jj� ���j� d S r7 )rB �consumerr\ r� r� r8 ��ignore�r� r: �streamingProducerrk r< r= �done� s z8TLSProducerTests.test_nonStreamingProducer.<locals>.doneTr� )r{ r/ r\ r� r� r� r� r r� � _consumerr� r� r r� r� )r: rh r� r� r� r< r� r= �test_nonStreamingProducer� s z*TLSProducerTests.test_nonStreamingProducerc C s" t � }t|�}| �tt|�� dS )zC L{_ProducerMembrane} implements L{IPushProducer}. N)r0 r r� r r! )r: r� �membraner< r< r= �test_interface� s z TLSProducerTests.test_interfacec C sb t � \}}dd� |_G dd� d�}|�tt� �� |� }|�|d� | �|jj� | �|j � dS )z� If a producer is registered after the transport has disconnected, the producer is not used, and its stopProducing method is called. c S s | � tt�S r7 )r� r r �rd r< r< r= ri � s �zFTLSProducerTests.registerProducerAfterConnectionLost.<locals>.<lambda>c @ r� )zFTLSProducerTests.registerProducerAfterConnectionLost.<locals>.ProducerFc S s dd S )NrH r r< rV r< r< r= r� � r- zVTLSProducerTests.registerProducerAfterConnectionLost.<locals>.Producer.resumeProducingc S r� r� )r� rV r< r< r= r� � rS zTTLSProducerTests.registerProducerAfterConnectionLost.<locals>.Producer.stopProducingN)rK rL rM r� r� r� r< r< r< r= �Producer� s r� FN) r{ re r, r r� rB r\ r� r� r� )r: r� rh rk r� r� r< r< r= �#registerProducerAfterConnectionLost� s z4TLSProducerTests.registerProducerAfterConnectionLostc C � | � d� dS )z� If a streaming producer is registered after the transport has disconnected, the producer is not used, and its stopProducing method is called. TN�r� rV r< r< r= �)test_streamingProducerAfterConnectionLost � z:TLSProducerTests.test_streamingProducerAfterConnectionLostc C r� )z� If a non-streaming producer is registered after the transport has disconnected, the producer is not used, and its stopProducing method is called. FNr� rV r< r< r= �,test_nonStreamingProducerAfterConnectionLost r� z=TLSProducerTests.test_nonStreamingProducerAfterConnectionLost)F)NNFN)rK rL rM rN r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r< r< r< r= r{ E s0 �'8 0G r{ c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )�NonStreamingProducerTestszP Non-streaming producers can be adapted into being streaming producers. c sb t � �}t|� ��� ��d� � jf�fdd� }|� _|j}� ��fdd�}|�|� ��� |S )zd Verify the consumer writes out all its data, but is not called after that. Tc � | � � � � d S r7 �� stopStreaming��orig�r� r< r= � unregister- � z<NonStreamingProducerTests.streamUntilEnd.<locals>.unregisterc s, �� � �� d� ��� j� ���j� d S )Ns 0123456789)r� rC rB r� r� r8 rS �r� r: r� r< r= � doneStreaming5 � z?NonStreamingProducerTests.streamUntilEnd.<locals>.doneStreaming)r/ r r� r� r r� �startStreaming)r: r� � nsProducerr� r� r� r< r� r= �streamUntilEnd s z(NonStreamingProducerTests.streamUntilEndc C s t � }| �|�S )z� When converted to a streaming producer, the non-streaming producer writes out all its data, but is not called after that. �r0 r� )r: r� r< r< r= �test_writeUntilDoneB s z-NonStreamingProducerTests.test_writeUntilDonec sv G dd� dt �}|� }t|�}t||��|��d� � fdd�}|j�|� |j}� �fdd�}|�|� ��� |S )z} When the streaming producer is paused, the underlying producer stops getting resumeProducing calls. c @ r� )zDNonStreamingProducerTests.test_pause.<locals>.PausingStringTransportr c S s t �| � t� | _d S r7 )r0 r> r r� rV r< r< r= r> S s zMNonStreamingProducerTests.test_pause.<locals>.PausingStringTransport.__init__c S sJ | j d7 _ t�| |� | j dkr#| j�� | j}| `|�d � d S d S �NrH r� )�writesr0 r� r� r� r� rC )r: r_ r r< r< r= r� W s �zJNonStreamingProducerTests.test_pause.<locals>.PausingStringTransport.writeN)rK rL rM r� r> r� r< r< r< r= r� P s r� Tc re )Nz$BUG: The producer should not finish!)�failr� rV r< r= �shouldNotBeCalledf rf z?NonStreamingProducerTests.test_pause.<locals>.shouldNotBeCalledc s � � �jjd� d S rG )r� � _coopTask� _pauseCountr� �r: r� r< r= r� m s z4NonStreamingProducerTests.test_pause.<locals>.paused)r0 r/ r r� r r� r� r� )r: r� r� r� r� r� r� r< r� r= � test_pauseJ s z$NonStreamingProducerTests.test_pausec C s G dd� dt �}|� }| �|�S )a When the streaming producer is paused and then resumed, the underlying producer starts getting resumeProducing calls again after the resume. The test will never finish (or rather, time out) if the resume producing call is not working. c @ r� )zENonStreamingProducerTests.test_resume.<locals>.PausingStringTransportr c S s@ | j d7 _ t�| |� | j dkr | j�� | j�� d S d S r� )r� r0 r� r� r� r� r^ r< r< r= r� � s �zKNonStreamingProducerTests.test_resume.<locals>.PausingStringTransport.writeN�rK rL rM r� r� r< r< r< r= r� � r> r� r� )r: r� r� r< r< r= � test_resumew s z%NonStreamingProducerTests.test_resumec sb G dd� dt �}|� � t� ��t�� ��� ��d� �j}� ���fdd�}|�|� ��� |S )z� When the streaming producer is stopped by the consumer, the underlying producer is stopped, and streaming is stopped. c @ r� )zMNonStreamingProducerTests.test_stopProducing.<locals>.StoppingStringTransportr c S s6 | j d7 _ t�| |� | j dkr| j�� d S d S r� )r� r0 r� r� r� r^ r< r< r= r� � s �zSNonStreamingProducerTests.test_stopProducing.<locals>.StoppingStringTransport.writeNr� r< r< r< r= �StoppingStringTransport� r> r Tc s, �� � �� d� ���j� ���j� d S )Ns 012)r� rC r� r� r8 rS �r� r� r: r� r< r= r� � r� zCNonStreamingProducerTests.test_stopProducing.<locals>.doneStreaming)r0 r/ r r� r r� r� )r: r r� r� r< r r= �test_stopProducing� s z,NonStreamingProducerTests.test_stopProducingc s� G dd� dt �}|� �}t|� ��� ��d� g �t��j� ��tj�j� � jf�fdd� }|� _�� � �j � � }|� dd� � � ����fdd �}|� |� |S ) z� Common implementation for tests where the underlying producer throws an exception when its resumeProducing is called. c @ r� )zINonStreamingProducerTests.resumeProducingRaises.<locals>.ThrowingProducerc S s | j dkr dd S t�| � d S )Nr� rH r )�counterr/ r� rV r< r< r= r� � s zYNonStreamingProducerTests.resumeProducingRaises.<locals>.ThrowingProducer.resumeProducingN)rK rL rM r� r< r< r< r= �ThrowingProducer� r� r Tc r� r7 r� r� r� r< r= r� � r� zCNonStreamingProducerTests.resumeProducingRaises.<locals>.unregisterc S s | � t�S r7 )r� r( r� r< r< r= ri � r� zANonStreamingProducerTests.resumeProducingRaises.<locals>.<lambda>c sx �� � �� d� ��� }�� t|�t��� t|���D ]\}\}}}��|�|�� ��||d � q ���j� d S )Ns 01�why) r� rC �flushLoggedErrorsr[ �zipr� ra �assertInr8 )r �errors�f�expected�msg�logMsg�r� �expectedExceptions� loggedMsgsr: r� r< r= r� � s �z@NonStreamingProducerTests.resumeProducingRaises.<locals>.stopped)r/ r r� r+ r~ rX r r� r� r� r� �whenDone� addErrbackr� )r: r� r r r� r� r� r� r< r r= �resumeProducingRaises� s z/NonStreamingProducerTests.resumeProducingRaisesc s4 t � � ��� tdfg�}� �fdd�}|�|� |S )z� If the underlying producer raises an exception when resumeProducing is called, the streaming wrapper should log the error, unregister from the consumer and stop streaming. �!failed, producing will be stoppedc s �� � j� d S r7 )rB r� r� �r� r: r< r= � cleanShutdown� s zKNonStreamingProducerTests.test_resumeProducingRaises.<locals>.cleanShutdown)r0 r �ZeroDivisionErrorr� )r: r� r r< r r= �test_resumeProducingRaises� s � z4NonStreamingProducerTests.test_resumeProducingRaisesc C s, t � }dd� }||_| �|tdftdfg�S )a If the underlying producer raises an exception when resumeProducing is called, the streaming wrapper should log the error, unregister from the consumer and stop streaming even if the unregisterProducer call also raise. c S r� r7 )r� r< r< r< r= �raiser� r� z^NonStreamingProducerTests.test_resumeProducingRaiseAndUnregisterProducerRaises.<locals>.raiserr z failed to unregister producer)r0 r� r r r� )r: r� r r< r< r= �4test_resumeProducingRaiseAndUnregisterProducerRaises� s ��zNNonStreamingProducerTests.test_resumeProducingRaiseAndUnregisterProducerRaisesc C s@ t � }t|�}t||�}|�� |�� |�� | �|j� dS )z� stopStreaming() can be called more than once without blowing up. This is useful for error-handling paths. N)r0 r/ r r� r� r� r8 �r: r� r� r� r< r< r= �test_stopStreamingTwice s z1NonStreamingProducerTests.test_stopStreamingTwicec C s, t � }t|�}t||�}| �tt|�� dS )z= L{_PullToPush} implements L{IPushProducer}. N)r0 r/ r r� r r! r r< r< r= r� s z(NonStreamingProducerTests.test_interfaceN)rK rL rM rN r� r� r� r r r r r r r� r< r< r< r= r� s "-#3 r� c @ r� )�ClientNegotiationFactoryza A L{ClientFactory} that has a set of acceptable protocols for NPN/ALPN negotiation. c C � || _ dS )z� Create a L{ClientNegotiationFactory}. @param acceptableProtocols: The protocols the client will accept speaking after the TLS handshake is complete. @type acceptableProtocols: L{list} of L{bytes} N��_acceptableProtocols�r: �acceptableProtocolsr< r< r= r> ( � z!ClientNegotiationFactory.__init__c C � | j S �a Returns a list of protocols that can be spoken by the connection factory in the form of ALPN tokens, as laid out in the IANA registry for ALPN tokens. @return: a list of ALPN tokens in order of preference. @rtype: L{list} of L{bytes} r rV r< r< r= r# 2 � z,ClientNegotiationFactory.acceptableProtocolsN�rK rL rM rN r> r# r< r< r< r= r ! � r c @ r� )�ServerNegotiationFactoryza A L{ServerFactory} that has a set of acceptable protocols for NPN/ALPN negotiation. c C r )z� Create a L{ServerNegotiationFactory}. @param acceptableProtocols: The protocols the server will accept speaking after the TLS handshake is complete. @type acceptableProtocols: L{list} of L{bytes} Nr r" r< r< r= r> E r$ z!ServerNegotiationFactory.__init__c C r% r& r rV r< r< r= r# O r' z,ServerNegotiationFactory.acceptableProtocolsNr( r< r< r< r= r* > r) r* )FNNN)NF)WrN ro �zope.interfacer r r �zope.interface.verifyr �twisted.python.compatr �OpenSSLr � OpenSSL.SSLr r r r r r r �twisted.protocols.tlsr r r r � ImportError�skip�twisted.internet.sslr r �twisted.test.ssl_helpersr r r �twisted.test.test_sslverifyr �twisted.internet.deferr r �twisted.internet.errorr r �twisted.internet.interfacesr r r r r! r" r# �twisted.internet.protocolr$ r% r& r' �twisted.internet.taskr( �twisted.protocols.loopbackr) r* �twisted.pythonr+ �twisted.python.failurer, �twisted.python.filepathr- �twisted.test.iosimr. �twisted.test.proto_helpersr/ r0 �twisted.test.test_tcpr2 �twisted.trial.unittestr3 r4 r5 rP r{ r| r� r� r� r{ r� r r* r< r< r< r= �<module> sn $ � $ / �&2 �=% Y PK Mb�Zk)��k k protocols/test/test_tls.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.protocols.tls}. """ import gc from zope.interface import Interface, directlyProvides, implementer from zope.interface.verify import verifyObject from twisted.python.compat import iterbytes try: from OpenSSL import crypto from OpenSSL.SSL import ( Connection, Context, Error, TLSv1_1_METHOD, TLSv1_2_METHOD, TLSv1_METHOD, WantReadError, ) from twisted.protocols.tls import ( TLSMemoryBIOFactory, TLSMemoryBIOProtocol, _ProducerMembrane, _PullToPush, ) except ImportError: # Skip the whole test module if it can't be imported. skip = "pyOpenSSL 16.0.0 or newer required for twisted.protocol.tls" TLSv1_METHOD = TLSv1_1_METHOD = TLSv1_2_METHOD = None # type: ignore[assignment] else: from twisted.internet.ssl import PrivateCertificate, optionsForClientTLS from twisted.test.ssl_helpers import ClientTLSContext, ServerTLSContext, certPath from twisted.test.test_sslverify import certificatesForAuthorityAndServer from twisted.internet.defer import Deferred, gatherResults from twisted.internet.error import ConnectionDone, ConnectionLost from twisted.internet.interfaces import ( IHandshakeListener, IOpenSSLClientConnectionCreator, IOpenSSLServerConnectionCreator, IProtocolNegotiationFactory, IPushProducer, ISSLTransport, ISystemHandle, ) from twisted.internet.protocol import ClientFactory, Factory, Protocol, ServerFactory from twisted.internet.task import TaskStopped from twisted.protocols.loopback import collapsingPumpPolicy, loopbackAsync from twisted.python import log from twisted.python.failure import Failure from twisted.python.filepath import FilePath from twisted.test.iosim import connectedServerAndClient from twisted.test.proto_helpers import NonStreamingProducer, StringTransport from twisted.test.test_tcp import ConnectionLostNotifyingProtocol from twisted.trial.unittest import SynchronousTestCase, TestCase class HandshakeCallbackContextFactory: """ L{HandshakeCallbackContextFactory} is a factory for SSL contexts which allows applications to get notification when the SSL handshake completes. @ivar _finished: A L{Deferred} which will be called back when the handshake is done. """ # pyOpenSSL needs to expose this. # https://bugs.launchpad.net/pyopenssl/+bug/372832 SSL_CB_HANDSHAKE_DONE = 0x20 def __init__(self, method=TLSv1_METHOD): self._finished = Deferred() self._method = method @classmethod def factoryAndDeferred(cls): """ Create a new L{HandshakeCallbackContextFactory} and return a two-tuple of it and a L{Deferred} which will fire when a connection created with it completes a TLS handshake. """ contextFactory = cls() return contextFactory, contextFactory._finished def _info(self, connection, where, ret): """ This is the "info callback" on the context. It will be called periodically by pyOpenSSL with information about the state of a connection. When it indicates the handshake is complete, it will fire C{self._finished}. """ if where & self.SSL_CB_HANDSHAKE_DONE: self._finished.callback(None) def getContext(self): """ Create and return an SSL context configured to use L{self._info} as the info callback. """ context = Context(self._method) context.set_info_callback(self._info) return context class AccumulatingProtocol(Protocol): """ A protocol which collects the bytes it receives and closes its connection after receiving a certain minimum of data. @ivar howMany: The number of bytes of data to wait for before closing the connection. @ivar received: A L{list} of L{bytes} of the bytes received so far. """ def __init__(self, howMany): self.howMany = howMany def connectionMade(self): self.received = [] def dataReceived(self, data): self.received.append(data) if sum(map(len, self.received)) >= self.howMany: self.transport.loseConnection() def connectionLost(self, reason): if not reason.check(ConnectionDone): log.err(reason) def buildTLSProtocol( server=False, transport=None, fakeConnection=None, serverMethod=None ): """ Create a protocol hooked up to a TLS transport hooked up to a StringTransport. @param serverMethod: The TLS method accepted by the server-side and used by the created protocol. Set to to C{None} to use the default method used by your OpenSSL library. """ # We want to accumulate bytes without disconnecting, so set high limit: clientProtocol = AccumulatingProtocol(999999999999) clientFactory = ClientFactory() clientFactory.protocol = lambda: clientProtocol if fakeConnection: @implementer(IOpenSSLServerConnectionCreator, IOpenSSLClientConnectionCreator) class HardCodedConnection: def clientConnectionForTLS(self, tlsProtocol): return fakeConnection serverConnectionForTLS = clientConnectionForTLS contextFactory = HardCodedConnection() else: if server: contextFactory = ServerTLSContext(method=serverMethod) else: contextFactory = ClientTLSContext() wrapperFactory = TLSMemoryBIOFactory(contextFactory, not server, clientFactory) sslProtocol = wrapperFactory.buildProtocol(None) if transport is None: transport = StringTransport() sslProtocol.makeConnection(transport) return clientProtocol, sslProtocol class TLSMemoryBIOFactoryTests(TestCase): """ Ensure TLSMemoryBIOFactory logging acts correctly. """ def test_quiet(self): """ L{TLSMemoryBIOFactory.doStart} and L{TLSMemoryBIOFactory.doStop} do not log any messages. """ contextFactory = ServerTLSContext() logs = [] logger = logs.append log.addObserver(logger) self.addCleanup(log.removeObserver, logger) wrappedFactory = ServerFactory() # Disable logging on the wrapped factory: wrappedFactory.doStart = lambda: None wrappedFactory.doStop = lambda: None factory = TLSMemoryBIOFactory(contextFactory, False, wrappedFactory) factory.doStart() factory.doStop() self.assertEqual(logs, []) def test_logPrefix(self): """ L{TLSMemoryBIOFactory.logPrefix} amends the wrapped factory's log prefix with a short string (C{"TLS"}) indicating the wrapping, rather than its full class name. """ contextFactory = ServerTLSContext() factory = TLSMemoryBIOFactory(contextFactory, False, ServerFactory()) self.assertEqual("ServerFactory (TLS)", factory.logPrefix()) def test_logPrefixFallback(self): """ If the wrapped factory does not provide L{ILoggingContext}, L{TLSMemoryBIOFactory.logPrefix} uses the wrapped factory's class name. """ class NoFactory: pass contextFactory = ServerTLSContext() factory = TLSMemoryBIOFactory(contextFactory, False, NoFactory()) self.assertEqual("NoFactory (TLS)", factory.logPrefix()) def handshakingClientAndServer( clientGreetingData=None, clientAbortAfterHandshake=False ): """ Construct a client and server L{TLSMemoryBIOProtocol} connected by an IO pump. @param greetingData: The data which should be written in L{connectionMade}. @type greetingData: L{bytes} @return: 3-tuple of client, server, L{twisted.test.iosim.IOPump} """ authCert, serverCert = certificatesForAuthorityAndServer() @implementer(IHandshakeListener) class Client(AccumulatingProtocol): handshook = False peerAfterHandshake = None def connectionMade(self): super().connectionMade() if clientGreetingData is not None: self.transport.write(clientGreetingData) def handshakeCompleted(self): self.handshook = True self.peerAfterHandshake = self.transport.getPeerCertificate() if clientAbortAfterHandshake: self.transport.abortConnection() def connectionLost(self, reason): pass @implementer(IHandshakeListener) class Server(AccumulatingProtocol): handshaked = False def handshakeCompleted(self): self.handshaked = True def connectionLost(self, reason): pass clientF = TLSMemoryBIOFactory( optionsForClientTLS("example.com", trustRoot=authCert), isClient=True, wrappedFactory=ClientFactory.forProtocol(lambda: Client(999999)), ) serverF = TLSMemoryBIOFactory( serverCert.options(), isClient=False, wrappedFactory=ServerFactory.forProtocol(lambda: Server(999999)), ) client, server, pump = connectedServerAndClient( lambda: serverF.buildProtocol(None), lambda: clientF.buildProtocol(None), greet=False, ) return client, server, pump class DeterministicTLSMemoryBIOTests(SynchronousTestCase): """ Test for the implementation of L{ISSLTransport} which runs over another transport. @note: Prefer to add test cases to this suite, in this style, using L{connectedServerAndClient}, rather than returning L{Deferred}s. """ def test_handshakeNotification(self): """ The completion of the TLS handshake calls C{handshakeCompleted} on L{Protocol} objects that provide L{IHandshakeListener}. At the time C{handshakeCompleted} is invoked, the transport's peer certificate will have been initialized. """ client, server, pump = handshakingClientAndServer() self.assertEqual(client.wrappedProtocol.handshook, False) self.assertEqual(server.wrappedProtocol.handshaked, False) pump.flush() self.assertEqual(client.wrappedProtocol.handshook, True) self.assertEqual(server.wrappedProtocol.handshaked, True) self.assertIsNot(client.wrappedProtocol.peerAfterHandshake, None) def test_handshakeStopWriting(self): """ If some data is written to the transport in C{connectionMade}, but C{handshakeDone} doesn't like something it sees about the handshake, it can use C{abortConnection} to ensure that the application never receives that data. """ client, server, pump = handshakingClientAndServer(b"untrustworthy", True) wrappedServerProtocol = server.wrappedProtocol pump.flush() self.assertEqual(wrappedServerProtocol.received, []) class TLSMemoryBIOTests(TestCase): """ Tests for the implementation of L{ISSLTransport} which runs over another L{ITransport}. """ def test_interfaces(self): """ L{TLSMemoryBIOProtocol} instances provide L{ISSLTransport} and L{ISystemHandle}. """ proto = TLSMemoryBIOProtocol(None, None) self.assertTrue(ISSLTransport.providedBy(proto)) self.assertTrue(ISystemHandle.providedBy(proto)) def test_wrappedProtocolInterfaces(self): """ L{TLSMemoryBIOProtocol} instances provide the interfaces provided by the transport they wrap. """ class ITransport(Interface): pass class MyTransport: def write(self, data): pass clientFactory = ClientFactory() contextFactory = ClientTLSContext() wrapperFactory = TLSMemoryBIOFactory(contextFactory, True, clientFactory) transport = MyTransport() directlyProvides(transport, ITransport) tlsProtocol = TLSMemoryBIOProtocol(wrapperFactory, Protocol()) tlsProtocol.makeConnection(transport) self.assertTrue(ITransport.providedBy(tlsProtocol)) def test_getHandle(self): """ L{TLSMemoryBIOProtocol.getHandle} returns the L{OpenSSL.SSL.Connection} instance it uses to actually implement TLS. This may seem odd. In fact, it is. The L{OpenSSL.SSL.Connection} is not actually the "system handle" here, nor even an object the reactor knows about directly. However, L{twisted.internet.ssl.Certificate}'s C{peerFromTransport} and C{hostFromTransport} methods depend on being able to get an L{OpenSSL.SSL.Connection} object in order to work properly. Implementing L{ISystemHandle.getHandle} like this is the easiest way for those APIs to be made to work. If they are changed, then it may make sense to get rid of this implementation of L{ISystemHandle} and return the underlying socket instead. """ factory = ClientFactory() contextFactory = ClientTLSContext() wrapperFactory = TLSMemoryBIOFactory(contextFactory, True, factory) proto = TLSMemoryBIOProtocol(wrapperFactory, Protocol()) transport = StringTransport() proto.makeConnection(transport) self.assertIsInstance(proto.getHandle(), Connection) def test_makeConnection(self): """ When L{TLSMemoryBIOProtocol} is connected to a transport, it connects the protocol it wraps to a transport. """ clientProtocol = Protocol() clientFactory = ClientFactory() clientFactory.protocol = lambda: clientProtocol contextFactory = ClientTLSContext() wrapperFactory = TLSMemoryBIOFactory(contextFactory, True, clientFactory) sslProtocol = wrapperFactory.buildProtocol(None) transport = StringTransport() sslProtocol.makeConnection(transport) self.assertIsNotNone(clientProtocol.transport) self.assertIsNot(clientProtocol.transport, transport) self.assertIs(clientProtocol.transport, sslProtocol) def handshakeProtocols(self): """ Start handshake between TLS client and server. """ clientFactory = ClientFactory() clientFactory.protocol = Protocol ( clientContextFactory, handshakeDeferred, ) = HandshakeCallbackContextFactory.factoryAndDeferred() wrapperFactory = TLSMemoryBIOFactory(clientContextFactory, True, clientFactory) sslClientProtocol = wrapperFactory.buildProtocol(None) serverFactory = ServerFactory() serverFactory.protocol = Protocol serverContextFactory = ServerTLSContext() wrapperFactory = TLSMemoryBIOFactory(serverContextFactory, False, serverFactory) sslServerProtocol = wrapperFactory.buildProtocol(None) connectionDeferred = loopbackAsync(sslServerProtocol, sslClientProtocol) return ( sslClientProtocol, sslServerProtocol, handshakeDeferred, connectionDeferred, ) def test_handshake(self): """ The TLS handshake is performed when L{TLSMemoryBIOProtocol} is connected to a transport. """ tlsClient, tlsServer, handshakeDeferred, _ = self.handshakeProtocols() # Only wait for the handshake to complete. Anything after that isn't # important here. return handshakeDeferred def test_handshakeFailure(self): """ L{TLSMemoryBIOProtocol} reports errors in the handshake process to the application-level protocol object using its C{connectionLost} method and disconnects the underlying transport. """ clientConnectionLost = Deferred() clientFactory = ClientFactory() clientFactory.protocol = lambda: ConnectionLostNotifyingProtocol( clientConnectionLost ) clientContextFactory = HandshakeCallbackContextFactory() wrapperFactory = TLSMemoryBIOFactory(clientContextFactory, True, clientFactory) sslClientProtocol = wrapperFactory.buildProtocol(None) serverConnectionLost = Deferred() serverFactory = ServerFactory() serverFactory.protocol = lambda: ConnectionLostNotifyingProtocol( serverConnectionLost ) # This context factory rejects any clients which do not present a # certificate. certificateData = FilePath(certPath).getContent() certificate = PrivateCertificate.loadPEM(certificateData) serverContextFactory = certificate.options(certificate) wrapperFactory = TLSMemoryBIOFactory(serverContextFactory, False, serverFactory) sslServerProtocol = wrapperFactory.buildProtocol(None) connectionDeferred = loopbackAsync(sslServerProtocol, sslClientProtocol) def cbConnectionLost(protocol): # The connection should close on its own in response to the error # induced by the client not supplying the required certificate. # After that, check to make sure the protocol's connectionLost was # called with the right thing. protocol.lostConnectionReason.trap(Error) clientConnectionLost.addCallback(cbConnectionLost) serverConnectionLost.addCallback(cbConnectionLost) # Additionally, the underlying transport should have been told to # go away. return gatherResults( [clientConnectionLost, serverConnectionLost, connectionDeferred] ) def test_getPeerCertificate(self): """ L{TLSMemoryBIOProtocol.getPeerCertificate} returns the L{OpenSSL.crypto.X509} instance representing the peer's certificate. """ # Set up a client and server so there's a certificate to grab. clientFactory = ClientFactory() clientFactory.protocol = Protocol ( clientContextFactory, handshakeDeferred, ) = HandshakeCallbackContextFactory.factoryAndDeferred() wrapperFactory = TLSMemoryBIOFactory(clientContextFactory, True, clientFactory) sslClientProtocol = wrapperFactory.buildProtocol(None) serverFactory = ServerFactory() serverFactory.protocol = Protocol serverContextFactory = ServerTLSContext() wrapperFactory = TLSMemoryBIOFactory(serverContextFactory, False, serverFactory) sslServerProtocol = wrapperFactory.buildProtocol(None) loopbackAsync(sslServerProtocol, sslClientProtocol) # Wait for the handshake def cbHandshook(ignored): # Grab the server's certificate and check it out cert = sslClientProtocol.getPeerCertificate() self.assertIsInstance(cert, crypto.X509) self.assertEqual( cert.digest("sha1"), # openssl x509 -noout -sha1 -fingerprint -in server.pem b"23:4B:72:99:2E:5D:5E:2B:02:C3:BC:1B:7C:50:67:05:4F:60:FF:C9", ) handshakeDeferred.addCallback(cbHandshook) return handshakeDeferred def test_writeAfterHandshake(self): """ Bytes written to L{TLSMemoryBIOProtocol} before the handshake is complete are received by the protocol on the other side of the connection once the handshake succeeds. """ data = b"some bytes" clientProtocol = Protocol() clientFactory = ClientFactory() clientFactory.protocol = lambda: clientProtocol ( clientContextFactory, handshakeDeferred, ) = HandshakeCallbackContextFactory.factoryAndDeferred() wrapperFactory = TLSMemoryBIOFactory(clientContextFactory, True, clientFactory) sslClientProtocol = wrapperFactory.buildProtocol(None) serverProtocol = AccumulatingProtocol(len(data)) serverFactory = ServerFactory() serverFactory.protocol = lambda: serverProtocol serverContextFactory = ServerTLSContext() wrapperFactory = TLSMemoryBIOFactory(serverContextFactory, False, serverFactory) sslServerProtocol = wrapperFactory.buildProtocol(None) connectionDeferred = loopbackAsync(sslServerProtocol, sslClientProtocol) # Wait for the handshake to finish before writing anything. def cbHandshook(ignored): clientProtocol.transport.write(data) # The server will drop the connection once it gets the bytes. return connectionDeferred handshakeDeferred.addCallback(cbHandshook) # Once the connection is lost, make sure the server received the # expected bytes. def cbDisconnected(ignored): self.assertEqual(b"".join(serverProtocol.received), data) handshakeDeferred.addCallback(cbDisconnected) return handshakeDeferred def writeBeforeHandshakeTest(self, sendingProtocol, data): """ Run test where client sends data before handshake, given the sending protocol and expected bytes. """ clientFactory = ClientFactory() clientFactory.protocol = sendingProtocol ( clientContextFactory, handshakeDeferred, ) = HandshakeCallbackContextFactory.factoryAndDeferred() wrapperFactory = TLSMemoryBIOFactory(clientContextFactory, True, clientFactory) sslClientProtocol = wrapperFactory.buildProtocol(None) serverProtocol = AccumulatingProtocol(len(data)) serverFactory = ServerFactory() serverFactory.protocol = lambda: serverProtocol serverContextFactory = ServerTLSContext() wrapperFactory = TLSMemoryBIOFactory(serverContextFactory, False, serverFactory) sslServerProtocol = wrapperFactory.buildProtocol(None) connectionDeferred = loopbackAsync(sslServerProtocol, sslClientProtocol) # Wait for the connection to end, then make sure the server received # the bytes sent by the client. def cbConnectionDone(ignored): self.assertEqual(b"".join(serverProtocol.received), data) connectionDeferred.addCallback(cbConnectionDone) return connectionDeferred def test_writeBeforeHandshake(self): """ Bytes written to L{TLSMemoryBIOProtocol} before the handshake is complete are received by the protocol on the other side of the connection once the handshake succeeds. """ data = b"some bytes" class SimpleSendingProtocol(Protocol): def connectionMade(self): self.transport.write(data) return self.writeBeforeHandshakeTest(SimpleSendingProtocol, data) def test_writeSequence(self): """ Bytes written to L{TLSMemoryBIOProtocol} with C{writeSequence} are received by the protocol on the other side of the connection. """ data = b"some bytes" class SimpleSendingProtocol(Protocol): def connectionMade(self): self.transport.writeSequence(list(iterbytes(data))) return self.writeBeforeHandshakeTest(SimpleSendingProtocol, data) def test_writeAfterLoseConnection(self): """ Bytes written to L{TLSMemoryBIOProtocol} after C{loseConnection} is called are not transmitted (unless there is a registered producer, which will be tested elsewhere). """ data = b"some bytes" class SimpleSendingProtocol(Protocol): def connectionMade(self): self.transport.write(data) self.transport.loseConnection() self.transport.write(b"hello") self.transport.writeSequence([b"world"]) return self.writeBeforeHandshakeTest(SimpleSendingProtocol, data) def test_writeUnicodeRaisesTypeError(self): """ Writing C{unicode} to L{TLSMemoryBIOProtocol} throws a C{TypeError}. """ notBytes = "hello" result = [] class SimpleSendingProtocol(Protocol): def connectionMade(self): try: self.transport.write(notBytes) except TypeError: result.append(True) self.transport.write(b"bytes") self.transport.loseConnection() d = self.writeBeforeHandshakeTest(SimpleSendingProtocol, b"bytes") return d.addCallback(lambda ign: self.assertEqual(result, [True])) def test_multipleWrites(self): """ If multiple separate TLS messages are received in a single chunk from the underlying transport, all of the application bytes from each message are delivered to the application-level protocol. """ data = [b"a", b"b", b"c", b"d", b"e", b"f", b"g", b"h", b"i"] class SimpleSendingProtocol(Protocol): def connectionMade(self): for b in data: self.transport.write(b) clientFactory = ClientFactory() clientFactory.protocol = SimpleSendingProtocol clientContextFactory = HandshakeCallbackContextFactory() wrapperFactory = TLSMemoryBIOFactory(clientContextFactory, True, clientFactory) sslClientProtocol = wrapperFactory.buildProtocol(None) serverProtocol = AccumulatingProtocol(sum(map(len, data))) serverFactory = ServerFactory() serverFactory.protocol = lambda: serverProtocol serverContextFactory = ServerTLSContext() wrapperFactory = TLSMemoryBIOFactory(serverContextFactory, False, serverFactory) sslServerProtocol = wrapperFactory.buildProtocol(None) connectionDeferred = loopbackAsync( sslServerProtocol, sslClientProtocol, collapsingPumpPolicy ) # Wait for the connection to end, then make sure the server received # the bytes sent by the client. def cbConnectionDone(ignored): self.assertEqual(b"".join(serverProtocol.received), b"".join(data)) connectionDeferred.addCallback(cbConnectionDone) return connectionDeferred def hugeWrite(self, method=TLSv1_METHOD): """ If a very long string is passed to L{TLSMemoryBIOProtocol.write}, any trailing part of it which cannot be send immediately is buffered and sent later. """ data = b"some bytes" factor = 2 ** 20 class SimpleSendingProtocol(Protocol): def connectionMade(self): self.transport.write(data * factor) clientFactory = ClientFactory() clientFactory.protocol = SimpleSendingProtocol clientContextFactory = HandshakeCallbackContextFactory(method=method) wrapperFactory = TLSMemoryBIOFactory(clientContextFactory, True, clientFactory) sslClientProtocol = wrapperFactory.buildProtocol(None) serverProtocol = AccumulatingProtocol(len(data) * factor) serverFactory = ServerFactory() serverFactory.protocol = lambda: serverProtocol serverContextFactory = ServerTLSContext(method=method) wrapperFactory = TLSMemoryBIOFactory(serverContextFactory, False, serverFactory) sslServerProtocol = wrapperFactory.buildProtocol(None) connectionDeferred = loopbackAsync(sslServerProtocol, sslClientProtocol) # Wait for the connection to end, then make sure the server received # the bytes sent by the client. def cbConnectionDone(ignored): self.assertEqual(b"".join(serverProtocol.received), data * factor) connectionDeferred.addCallback(cbConnectionDone) return connectionDeferred def test_hugeWrite_TLSv1(self): return self.hugeWrite() def test_hugeWrite_TLSv1_1(self): return self.hugeWrite(method=TLSv1_1_METHOD) def test_hugeWrite_TLSv1_2(self): return self.hugeWrite(method=TLSv1_2_METHOD) def test_disorderlyShutdown(self): """ If a L{TLSMemoryBIOProtocol} loses its connection unexpectedly, this is reported to the application. """ clientConnectionLost = Deferred() clientFactory = ClientFactory() clientFactory.protocol = lambda: ConnectionLostNotifyingProtocol( clientConnectionLost ) clientContextFactory = HandshakeCallbackContextFactory() wrapperFactory = TLSMemoryBIOFactory(clientContextFactory, True, clientFactory) sslClientProtocol = wrapperFactory.buildProtocol(None) # Client speaks first, so the server can be dumb. serverProtocol = Protocol() loopbackAsync(serverProtocol, sslClientProtocol) # Now destroy the connection. serverProtocol.transport.loseConnection() # And when the connection completely dies, check the reason. def cbDisconnected(clientProtocol): clientProtocol.lostConnectionReason.trap(Error, ConnectionLost) clientConnectionLost.addCallback(cbDisconnected) return clientConnectionLost def test_loseConnectionAfterHandshake(self): """ L{TLSMemoryBIOProtocol.loseConnection} sends a TLS close alert and shuts down the underlying connection cleanly on both sides, after transmitting all buffered data. """ class NotifyingProtocol(ConnectionLostNotifyingProtocol): def __init__(self, onConnectionLost): ConnectionLostNotifyingProtocol.__init__(self, onConnectionLost) self.data = [] def dataReceived(self, data): self.data.append(data) clientConnectionLost = Deferred() clientFactory = ClientFactory() clientProtocol = NotifyingProtocol(clientConnectionLost) clientFactory.protocol = lambda: clientProtocol ( clientContextFactory, handshakeDeferred, ) = HandshakeCallbackContextFactory.factoryAndDeferred() wrapperFactory = TLSMemoryBIOFactory(clientContextFactory, True, clientFactory) sslClientProtocol = wrapperFactory.buildProtocol(None) serverConnectionLost = Deferred() serverProtocol = NotifyingProtocol(serverConnectionLost) serverFactory = ServerFactory() serverFactory.protocol = lambda: serverProtocol serverContextFactory = ServerTLSContext() wrapperFactory = TLSMemoryBIOFactory(serverContextFactory, False, serverFactory) sslServerProtocol = wrapperFactory.buildProtocol(None) loopbackAsync(sslServerProtocol, sslClientProtocol) chunkOfBytes = b"123456890" * 100000 # Wait for the handshake before dropping the connection. def cbHandshake(ignored): # Write more than a single bio_read, to ensure client will still # have some data it needs to write when it receives the TLS close # alert, and that simply doing a single bio_read won't be # sufficient. Thus we will verify that any amount of buffered data # will be written out before the connection is closed, rather than # just small amounts that can be returned in a single bio_read: clientProtocol.transport.write(chunkOfBytes) serverProtocol.transport.write(b"x") serverProtocol.transport.loseConnection() # Now wait for the client and server to notice. return gatherResults([clientConnectionLost, serverConnectionLost]) handshakeDeferred.addCallback(cbHandshake) # Wait for the connection to end, then make sure the client and server # weren't notified of a handshake failure that would cause the test to # fail. def cbConnectionDone(result): (clientProtocol, serverProtocol) = result clientProtocol.lostConnectionReason.trap(ConnectionDone) serverProtocol.lostConnectionReason.trap(ConnectionDone) # The server should have received all bytes sent by the client: self.assertEqual(b"".join(serverProtocol.data), chunkOfBytes) # The server should have closed its underlying transport, in # addition to whatever it did to shut down the TLS layer. self.assertTrue(serverProtocol.transport.q.disconnect) # The client should also have closed its underlying transport once # it saw the server shut down the TLS layer, so as to avoid relying # on the server to close the underlying connection. self.assertTrue(clientProtocol.transport.q.disconnect) handshakeDeferred.addCallback(cbConnectionDone) return handshakeDeferred def test_connectionLostOnlyAfterUnderlyingCloses(self): """ The user protocol's connectionLost is only called when transport underlying TLS is disconnected. """ class LostProtocol(Protocol): disconnected = None def connectionLost(self, reason): self.disconnected = reason wrapperFactory = TLSMemoryBIOFactory(ClientTLSContext(), True, ClientFactory()) protocol = LostProtocol() tlsProtocol = TLSMemoryBIOProtocol(wrapperFactory, protocol) transport = StringTransport() tlsProtocol.makeConnection(transport) # Pretend TLS shutdown finished cleanly; the underlying transport # should be told to close, but the user protocol should not yet be # notified: tlsProtocol._tlsShutdownFinished(None) self.assertTrue(transport.disconnecting) self.assertIsNone(protocol.disconnected) # Now close the underlying connection; the user protocol should be # notified with the given reason (since TLS closed cleanly): tlsProtocol.connectionLost(Failure(ConnectionLost("ono"))) self.assertTrue(protocol.disconnected.check(ConnectionLost)) self.assertEqual(protocol.disconnected.value.args, ("ono",)) def test_loseConnectionTwice(self): """ If TLSMemoryBIOProtocol.loseConnection is called multiple times, all but the first call have no effect. """ ( tlsClient, tlsServer, handshakeDeferred, disconnectDeferred, ) = self.handshakeProtocols() self.successResultOf(handshakeDeferred) # Make sure loseConnection calls _shutdownTLS the first time (mostly # to make sure we've overriding it correctly): calls = [] def _shutdownTLS(shutdown=tlsClient._shutdownTLS): calls.append(1) return shutdown() tlsClient._shutdownTLS = _shutdownTLS tlsClient.write(b"x") tlsClient.loseConnection() self.assertTrue(tlsClient.disconnecting) self.assertEqual(calls, [1]) # Make sure _shutdownTLS isn't called a second time: tlsClient.loseConnection() self.assertEqual(calls, [1]) # We do successfully disconnect at some point: return disconnectDeferred def test_loseConnectionAfterConnectionLost(self): """ If TLSMemoryBIOProtocol.loseConnection is called after connectionLost, it does nothing. """ ( tlsClient, tlsServer, handshakeDeferred, disconnectDeferred, ) = self.handshakeProtocols() # Make sure connectionLost calls _shutdownTLS, but loseConnection # doesnt call it for the second time. calls = [] def _shutdownTLS(shutdown=tlsClient._shutdownTLS): calls.append(1) return shutdown() tlsServer._shutdownTLS = _shutdownTLS tlsServer.write(b"x") tlsClient.loseConnection() def disconnected(_): # At this point tlsServer.connectionLost is already called self.assertEqual(calls, [1]) # This call should do nothing tlsServer.loseConnection() self.assertEqual(calls, [1]) disconnectDeferred.addCallback(disconnected) return disconnectDeferred def test_unexpectedEOF(self): """ Unexpected disconnects get converted to ConnectionLost errors. """ ( tlsClient, tlsServer, handshakeDeferred, disconnectDeferred, ) = self.handshakeProtocols() serverProtocol = tlsServer.wrappedProtocol data = [] reason = [] serverProtocol.dataReceived = data.append serverProtocol.connectionLost = reason.append # Write data, then disconnect *underlying* transport, resulting in an # unexpected TLS disconnect: def handshakeDone(ign): tlsClient.write(b"hello") tlsClient.transport.loseConnection() handshakeDeferred.addCallback(handshakeDone) # Receiver should be disconnected, with ConnectionLost notification # (masking the Unexpected EOF SSL error): def disconnected(ign): self.assertTrue(reason[0].check(ConnectionLost), reason[0]) disconnectDeferred.addCallback(disconnected) return disconnectDeferred def test_errorWriting(self): """ Errors while writing cause the protocols to be disconnected. """ ( tlsClient, tlsServer, handshakeDeferred, disconnectDeferred, ) = self.handshakeProtocols() reason = [] tlsClient.wrappedProtocol.connectionLost = reason.append # Pretend TLS connection is unhappy sending: class Wrapper: def __init__(self, wrapped): self._wrapped = wrapped def __getattr__(self, attr): return getattr(self._wrapped, attr) def send(self, *args): raise Error("ONO!") tlsClient._tlsConnection = Wrapper(tlsClient._tlsConnection) # Write some data: def handshakeDone(ign): tlsClient.write(b"hello") handshakeDeferred.addCallback(handshakeDone) # Failed writer should be disconnected with SSL error: def disconnected(ign): self.assertTrue(reason[0].check(Error), reason[0]) disconnectDeferred.addCallback(disconnected) return disconnectDeferred def test_noCircularReferences(self): """ TLSMemoryBIOProtocol doesn't leave circular references that keep it in memory after connection is closed. """ def nObjectsOfType(type): """ Return the number of instances of a given type in memory. @param type: Type whose instances to find. @return: The number of instances found. """ return sum(1 for x in gc.get_objects() if isinstance(x, type)) self.addCleanup(gc.enable) gc.disable() class CloserProtocol(Protocol): def dataReceived(self, data): self.transport.loseConnection() class GreeterProtocol(Protocol): def connectionMade(self): self.transport.write(b"hello") origTLSProtos = nObjectsOfType(TLSMemoryBIOProtocol) origServerProtos = nObjectsOfType(CloserProtocol) authCert, serverCert = certificatesForAuthorityAndServer() serverFactory = TLSMemoryBIOFactory( serverCert.options(), False, Factory.forProtocol(CloserProtocol) ) clientFactory = TLSMemoryBIOFactory( optionsForClientTLS("example.com", trustRoot=authCert), True, Factory.forProtocol(GreeterProtocol), ) loopbackAsync( TLSMemoryBIOProtocol(serverFactory, CloserProtocol()), TLSMemoryBIOProtocol(clientFactory, GreeterProtocol()), ) newTLSProtos = nObjectsOfType(TLSMemoryBIOProtocol) newServerProtos = nObjectsOfType(CloserProtocol) self.assertEqual(newTLSProtos, origTLSProtos) self.assertEqual(newServerProtos, origServerProtos) class TLSProducerTests(TestCase): """ The TLS transport must support the IConsumer interface. """ def drain(self, transport, allowEmpty=False): """ Drain the bytes currently pending write from a L{StringTransport}, then clear it, since those bytes have been consumed. @param transport: The L{StringTransport} to get the bytes from. @type transport: L{StringTransport} @param allowEmpty: Allow the test to pass even if the transport has no outgoing bytes in it. @type allowEmpty: L{bool} @return: the outgoing bytes from the given transport @rtype: L{bytes} """ value = transport.value() transport.clear() self.assertEqual(bool(allowEmpty or value), True) return value def setupStreamingProducer( self, transport=None, fakeConnection=None, server=False, serverMethod=None ): """ Create a new client-side protocol that is connected to a remote TLS server. @param serverMethod: The TLS method accepted by the server-side. Set to to C{None} to use the default method used by your OpenSSL library. @return: A tuple with high level client protocol, the low-level client-side TLS protocol, and a producer that is used to send data to the client. """ class HistoryStringTransport(StringTransport): def __init__(self): StringTransport.__init__(self) self.producerHistory = [] def pauseProducing(self): self.producerHistory.append("pause") StringTransport.pauseProducing(self) def resumeProducing(self): self.producerHistory.append("resume") StringTransport.resumeProducing(self) def stopProducing(self): self.producerHistory.append("stop") StringTransport.stopProducing(self) applicationProtocol, tlsProtocol = buildTLSProtocol( transport=transport, fakeConnection=fakeConnection, server=server, serverMethod=serverMethod, ) producer = HistoryStringTransport() applicationProtocol.transport.registerProducer(producer, True) self.assertTrue(tlsProtocol.transport.streaming) return applicationProtocol, tlsProtocol, producer def flushTwoTLSProtocols(self, tlsProtocol, serverTLSProtocol): """ Transfer bytes back and forth between two TLS protocols. """ # We want to make sure all bytes are passed back and forth; JP # estimated that 3 rounds should be enough: for i in range(3): clientData = self.drain(tlsProtocol.transport, True) if clientData: serverTLSProtocol.dataReceived(clientData) serverData = self.drain(serverTLSProtocol.transport, True) if serverData: tlsProtocol.dataReceived(serverData) if not serverData and not clientData: break self.assertEqual(tlsProtocol.transport.value(), b"") self.assertEqual(serverTLSProtocol.transport.value(), b"") def test_producerDuringRenegotiation(self): """ If we write some data to a TLS connection that is blocked waiting for a renegotiation with its peer, it will pause and resume its registered producer exactly once. Renegotiation only works on TLSv1.2 or less. """ clientProtocol, clientTransport, _ = self.setupStreamingProducer() serverProtocol, serverTransport, serverProducer = self.setupStreamingProducer( server=True, serverMethod=TLSv1_2_METHOD ) # Do the initial handshake. self.flushTwoTLSProtocols(clientTransport, serverTransport) # Check the connection is working by exchanging data between client and server. clientProtocol.transport.write(b"data from client") serverProtocol.transport.write(b"data from server") self.flushTwoTLSProtocols(clientTransport, serverTransport) self.assertEqual([b"data from server"], clientProtocol.received) self.assertEqual([b"data from client"], serverProtocol.received) # no public API for this yet because it's (mostly) unnecessary, but we # have to be prepared for a peer to do it to us tlsc = clientTransport._tlsConnection # Make sure we are on TLSv1.2 as otherwise renegociation is not supported self.assertEqual("TLSv1.2", tlsc.get_cipher_version()) tlsc.renegotiate() self.assertRaises(WantReadError, tlsc.do_handshake) clientTransport._flushSendBIO() serverTransport.dataReceived(self.drain(clientTransport.transport)) payload = b"payload" serverProtocol.transport.write(payload) serverProtocol.transport.loseConnection() # give the client the server the client's response... clientTransport.dataReceived(self.drain(serverTransport.transport)) messageThatUnblocksTheServer = self.drain(clientTransport.transport) # split it into just enough chunks that it would provoke the producer # with an incorrect implementation... for fragment in ( messageThatUnblocksTheServer[0:1], messageThatUnblocksTheServer[1:2], messageThatUnblocksTheServer[2:], ): serverTransport.dataReceived(fragment) self.assertEqual(serverTransport.transport.disconnecting, False) serverProtocol.transport.unregisterProducer() self.flushTwoTLSProtocols(clientTransport, serverTransport) self.assertEqual(serverTransport.transport.disconnecting, True) self.assertEqual([b"data from server", b"payload"], clientProtocol.received) self.assertEqual(serverProducer.producerHistory, ["pause", "resume"]) def test_streamingProducerPausedInNormalMode(self): """ When the TLS transport is not blocked on reads, it correctly calls pauseProducing on the registered producer. """ _, tlsProtocol, producer = self.setupStreamingProducer() # The TLS protocol's transport pretends to be full, pausing its # producer: tlsProtocol.transport.producer.pauseProducing() self.assertEqual(producer.producerState, "paused") self.assertEqual(producer.producerHistory, ["pause"]) self.assertTrue(tlsProtocol._producer._producerPaused) def test_streamingProducerResumedInNormalMode(self): """ When the TLS transport is not blocked on reads, it correctly calls resumeProducing on the registered producer. """ _, tlsProtocol, producer = self.setupStreamingProducer() tlsProtocol.transport.producer.pauseProducing() self.assertEqual(producer.producerHistory, ["pause"]) # The TLS protocol's transport pretends to have written everything # out, so it resumes its producer: tlsProtocol.transport.producer.resumeProducing() self.assertEqual(producer.producerState, "producing") self.assertEqual(producer.producerHistory, ["pause", "resume"]) self.assertFalse(tlsProtocol._producer._producerPaused) def test_streamingProducerPausedInWriteBlockedOnReadMode(self): """ When the TLS transport is blocked on reads, it correctly calls pauseProducing on the registered producer. """ clientProtocol, tlsProtocol, producer = self.setupStreamingProducer() # Write to TLS transport. Because we do this before the initial TLS # handshake is finished, writing bytes triggers a WantReadError, # indicating that until bytes are read for the handshake, more bytes # cannot be written. Thus writing bytes before the handshake should # cause the producer to be paused: clientProtocol.transport.write(b"hello") self.assertEqual(producer.producerState, "paused") self.assertEqual(producer.producerHistory, ["pause"]) self.assertTrue(tlsProtocol._producer._producerPaused) def test_streamingProducerResumedInWriteBlockedOnReadMode(self): """ When the TLS transport is blocked on reads, it correctly calls resumeProducing on the registered producer. """ clientProtocol, tlsProtocol, producer = self.setupStreamingProducer() # Write to TLS transport, triggering WantReadError; this should cause # the producer to be paused. We use a large chunk of data to make sure # large writes don't trigger multiple pauses: clientProtocol.transport.write(b"hello world" * 320000) self.assertEqual(producer.producerHistory, ["pause"]) # Now deliver bytes that will fix the WantRead condition; this should # unpause the producer: serverProtocol, serverTLSProtocol = buildTLSProtocol(server=True) self.flushTwoTLSProtocols(tlsProtocol, serverTLSProtocol) self.assertEqual(producer.producerHistory, ["pause", "resume"]) self.assertFalse(tlsProtocol._producer._producerPaused) # Make sure we haven't disconnected for some reason: self.assertFalse(tlsProtocol.transport.disconnecting) self.assertEqual(producer.producerState, "producing") def test_streamingProducerTwice(self): """ Registering a streaming producer twice throws an exception. """ clientProtocol, tlsProtocol, producer = self.setupStreamingProducer() originalProducer = tlsProtocol._producer producer2 = object() self.assertRaises( RuntimeError, clientProtocol.transport.registerProducer, producer2, True ) self.assertIs(tlsProtocol._producer, originalProducer) def test_streamingProducerUnregister(self): """ Unregistering a streaming producer removes it, reverting to initial state. """ clientProtocol, tlsProtocol, producer = self.setupStreamingProducer() clientProtocol.transport.unregisterProducer() self.assertIsNone(tlsProtocol._producer) self.assertIsNone(tlsProtocol.transport.producer) def test_streamingProducerUnregisterTwice(self): """ Unregistering a streaming producer when no producer is registered is safe. """ clientProtocol, tlsProtocol, producer = self.setupStreamingProducer() clientProtocol.transport.unregisterProducer() clientProtocol.transport.unregisterProducer() self.assertIsNone(tlsProtocol._producer) self.assertIsNone(tlsProtocol.transport.producer) def loseConnectionWithProducer(self, writeBlockedOnRead): """ Common code for tests involving writes by producer after loseConnection is called. """ clientProtocol, tlsProtocol, producer = self.setupStreamingProducer() serverProtocol, serverTLSProtocol = buildTLSProtocol(server=True) if not writeBlockedOnRead: # Do the initial handshake before write: self.flushTwoTLSProtocols(tlsProtocol, serverTLSProtocol) else: # In this case the write below will trigger write-blocked-on-read # condition... pass # Now write, then lose connection: clientProtocol.transport.write(b"x ") clientProtocol.transport.loseConnection() self.flushTwoTLSProtocols(tlsProtocol, serverTLSProtocol) # Underlying transport should not have loseConnection called yet, nor # should producer be stopped: self.assertFalse(tlsProtocol.transport.disconnecting) self.assertFalse("stop" in producer.producerHistory) # Writes from client to server should continue to go through, since we # haven't unregistered producer yet: clientProtocol.transport.write(b"hello") clientProtocol.transport.writeSequence([b" ", b"world"]) # Unregister producer; this should trigger TLS shutdown: clientProtocol.transport.unregisterProducer() self.assertNotEqual(tlsProtocol.transport.value(), b"") self.assertFalse(tlsProtocol.transport.disconnecting) # Additional writes should not go through: clientProtocol.transport.write(b"won't") clientProtocol.transport.writeSequence([b"won't!"]) # Finish TLS close handshake: self.flushTwoTLSProtocols(tlsProtocol, serverTLSProtocol) self.assertTrue(tlsProtocol.transport.disconnecting) # Bytes made it through, as long as they were written before producer # was unregistered: self.assertEqual(b"".join(serverProtocol.received), b"x hello world") def test_streamingProducerLoseConnectionWithProducer(self): """ loseConnection() waits for the producer to unregister itself, then does a clean TLS close alert, then closes the underlying connection. """ return self.loseConnectionWithProducer(False) def test_streamingProducerLoseConnectionWithProducerWBOR(self): """ Even when writes are blocked on reading, loseConnection() waits for the producer to unregister itself, then does a clean TLS close alert, then closes the underlying connection. """ return self.loseConnectionWithProducer(True) def test_streamingProducerBothTransportsDecideToPause(self): """ pauseProducing() events can come from both the TLS transport layer and the underlying transport. In this case, both decide to pause, underlying first. """ class PausingStringTransport(StringTransport): _didPause = False def write(self, data): if not self._didPause and self.producer is not None: self._didPause = True self.producer.pauseProducing() StringTransport.write(self, data) class TLSConnection: def __init__(self): self.l = [] def send(self, data): # on first write, don't send all bytes: if not self.l: data = data[:-1] # pause on second write: if len(self.l) == 1: self.l.append("paused") raise WantReadError() # otherwise just take in data: self.l.append(data) return len(data) def set_connect_state(self): pass def do_handshake(self): pass def bio_write(self, data): pass def bio_read(self, size): return b"X" def recv(self, size): raise WantReadError() transport = PausingStringTransport() clientProtocol, tlsProtocol, producer = self.setupStreamingProducer( transport, fakeConnection=TLSConnection() ) self.assertEqual(producer.producerState, "producing") # Shove in fake TLSConnection that will raise WantReadError the second # time send() is called. This will allow us to have bytes written to # to the PausingStringTransport, so it will pause the producer. Then, # WantReadError will be thrown, triggering the TLS transport's # producer code path. clientProtocol.transport.write(b"hello") self.assertEqual(producer.producerState, "paused") self.assertEqual(producer.producerHistory, ["pause"]) # Now, underlying transport resumes, and then we deliver some data to # TLS transport so that it will resume: tlsProtocol.transport.producer.resumeProducing() self.assertEqual(producer.producerState, "producing") self.assertEqual(producer.producerHistory, ["pause", "resume"]) tlsProtocol.dataReceived(b"hello") self.assertEqual(producer.producerState, "producing") self.assertEqual(producer.producerHistory, ["pause", "resume"]) def test_streamingProducerStopProducing(self): """ If the underlying transport tells its producer to stopProducing(), this is passed on to the high-level producer. """ _, tlsProtocol, producer = self.setupStreamingProducer() tlsProtocol.transport.producer.stopProducing() self.assertEqual(producer.producerState, "stopped") def test_nonStreamingProducer(self): """ Non-streaming producers get wrapped as streaming producers. """ clientProtocol, tlsProtocol = buildTLSProtocol() producer = NonStreamingProducer(clientProtocol.transport) # Register non-streaming producer: clientProtocol.transport.registerProducer(producer, False) streamingProducer = tlsProtocol.transport.producer._producer # Verify it was wrapped into streaming producer: self.assertIsInstance(streamingProducer, _PullToPush) self.assertEqual(streamingProducer._producer, producer) self.assertEqual(streamingProducer._consumer, clientProtocol.transport) self.assertTrue(tlsProtocol.transport.streaming) # Verify the streaming producer was started, and ran until the end: def done(ignore): # Our own producer is done: self.assertIsNone(producer.consumer) # The producer has been unregistered: self.assertIsNone(tlsProtocol.transport.producer) # The streaming producer wrapper knows it's done: self.assertTrue(streamingProducer._finished) producer.result.addCallback(done) serverProtocol, serverTLSProtocol = buildTLSProtocol(server=True) self.flushTwoTLSProtocols(tlsProtocol, serverTLSProtocol) return producer.result def test_interface(self): """ L{_ProducerMembrane} implements L{IPushProducer}. """ producer = StringTransport() membrane = _ProducerMembrane(producer) self.assertTrue(verifyObject(IPushProducer, membrane)) def registerProducerAfterConnectionLost(self, streaming): """ If a producer is registered after the transport has disconnected, the producer is not used, and its stopProducing method is called. """ clientProtocol, tlsProtocol = buildTLSProtocol() clientProtocol.connectionLost = lambda reason: reason.trap( Error, ConnectionLost ) class Producer: stopped = False def resumeProducing(self): return 1 / 0 # this should never be called def stopProducing(self): self.stopped = True # Disconnect the transport: tlsProtocol.connectionLost(Failure(ConnectionDone())) # Register the producer; startProducing should not be called, but # stopProducing will: producer = Producer() tlsProtocol.registerProducer(producer, False) self.assertIsNone(tlsProtocol.transport.producer) self.assertTrue(producer.stopped) def test_streamingProducerAfterConnectionLost(self): """ If a streaming producer is registered after the transport has disconnected, the producer is not used, and its stopProducing method is called. """ self.registerProducerAfterConnectionLost(True) def test_nonStreamingProducerAfterConnectionLost(self): """ If a non-streaming producer is registered after the transport has disconnected, the producer is not used, and its stopProducing method is called. """ self.registerProducerAfterConnectionLost(False) class NonStreamingProducerTests(TestCase): """ Non-streaming producers can be adapted into being streaming producers. """ def streamUntilEnd(self, consumer): """ Verify the consumer writes out all its data, but is not called after that. """ nsProducer = NonStreamingProducer(consumer) streamingProducer = _PullToPush(nsProducer, consumer) consumer.registerProducer(streamingProducer, True) # The producer will call unregisterProducer(), and we need to hook # that up so the streaming wrapper is notified; the # TLSMemoryBIOProtocol will have to do this itself, which is tested # elsewhere: def unregister(orig=consumer.unregisterProducer): orig() streamingProducer.stopStreaming() consumer.unregisterProducer = unregister done = nsProducer.result def doneStreaming(_): # All data was streamed, and the producer unregistered itself: self.assertEqual(consumer.value(), b"0123456789") self.assertIsNone(consumer.producer) # And the streaming wrapper stopped: self.assertTrue(streamingProducer._finished) done.addCallback(doneStreaming) # Now, start streaming: streamingProducer.startStreaming() return done def test_writeUntilDone(self): """ When converted to a streaming producer, the non-streaming producer writes out all its data, but is not called after that. """ consumer = StringTransport() return self.streamUntilEnd(consumer) def test_pause(self): """ When the streaming producer is paused, the underlying producer stops getting resumeProducing calls. """ class PausingStringTransport(StringTransport): writes = 0 def __init__(self): StringTransport.__init__(self) self.paused = Deferred() def write(self, data): self.writes += 1 StringTransport.write(self, data) if self.writes == 3: self.producer.pauseProducing() d = self.paused del self.paused d.callback(None) consumer = PausingStringTransport() nsProducer = NonStreamingProducer(consumer) streamingProducer = _PullToPush(nsProducer, consumer) consumer.registerProducer(streamingProducer, True) # Make sure the consumer does not continue: def shouldNotBeCalled(ignore): self.fail("BUG: The producer should not finish!") nsProducer.result.addCallback(shouldNotBeCalled) done = consumer.paused def paused(ignore): # The CooperatorTask driving the producer was paused: self.assertEqual(streamingProducer._coopTask._pauseCount, 1) done.addCallback(paused) # Now, start streaming: streamingProducer.startStreaming() return done def test_resume(self): """ When the streaming producer is paused and then resumed, the underlying producer starts getting resumeProducing calls again after the resume. The test will never finish (or rather, time out) if the resume producing call is not working. """ class PausingStringTransport(StringTransport): writes = 0 def write(self, data): self.writes += 1 StringTransport.write(self, data) if self.writes == 3: self.producer.pauseProducing() self.producer.resumeProducing() consumer = PausingStringTransport() return self.streamUntilEnd(consumer) def test_stopProducing(self): """ When the streaming producer is stopped by the consumer, the underlying producer is stopped, and streaming is stopped. """ class StoppingStringTransport(StringTransport): writes = 0 def write(self, data): self.writes += 1 StringTransport.write(self, data) if self.writes == 3: self.producer.stopProducing() consumer = StoppingStringTransport() nsProducer = NonStreamingProducer(consumer) streamingProducer = _PullToPush(nsProducer, consumer) consumer.registerProducer(streamingProducer, True) done = nsProducer.result def doneStreaming(_): # Not all data was streamed, and the producer was stopped: self.assertEqual(consumer.value(), b"012") self.assertTrue(nsProducer.stopped) # And the streaming wrapper stopped: self.assertTrue(streamingProducer._finished) done.addCallback(doneStreaming) # Now, start streaming: streamingProducer.startStreaming() return done def resumeProducingRaises(self, consumer, expectedExceptions): """ Common implementation for tests where the underlying producer throws an exception when its resumeProducing is called. """ class ThrowingProducer(NonStreamingProducer): def resumeProducing(self): if self.counter == 2: return 1 / 0 else: NonStreamingProducer.resumeProducing(self) nsProducer = ThrowingProducer(consumer) streamingProducer = _PullToPush(nsProducer, consumer) consumer.registerProducer(streamingProducer, True) # Register log observer: loggedMsgs = [] log.addObserver(loggedMsgs.append) self.addCleanup(log.removeObserver, loggedMsgs.append) # Make consumer unregister do what TLSMemoryBIOProtocol would do: def unregister(orig=consumer.unregisterProducer): orig() streamingProducer.stopStreaming() consumer.unregisterProducer = unregister # Start streaming: streamingProducer.startStreaming() done = streamingProducer._coopTask.whenDone() done.addErrback(lambda reason: reason.trap(TaskStopped)) def stopped(ign): self.assertEqual(consumer.value(), b"01") # Any errors from resumeProducing were logged: errors = self.flushLoggedErrors() self.assertEqual(len(errors), len(expectedExceptions)) for f, (expected, msg), logMsg in zip( errors, expectedExceptions, loggedMsgs ): self.assertTrue(f.check(expected)) self.assertIn(msg, logMsg["why"]) # And the streaming wrapper stopped: self.assertTrue(streamingProducer._finished) done.addCallback(stopped) return done def test_resumeProducingRaises(self): """ If the underlying producer raises an exception when resumeProducing is called, the streaming wrapper should log the error, unregister from the consumer and stop streaming. """ consumer = StringTransport() done = self.resumeProducingRaises( consumer, [(ZeroDivisionError, "failed, producing will be stopped")] ) def cleanShutdown(ignore): # Producer was unregistered from consumer: self.assertIsNone(consumer.producer) done.addCallback(cleanShutdown) return done def test_resumeProducingRaiseAndUnregisterProducerRaises(self): """ If the underlying producer raises an exception when resumeProducing is called, the streaming wrapper should log the error, unregister from the consumer and stop streaming even if the unregisterProducer call also raise. """ consumer = StringTransport() def raiser(): raise RuntimeError() consumer.unregisterProducer = raiser return self.resumeProducingRaises( consumer, [ (ZeroDivisionError, "failed, producing will be stopped"), (RuntimeError, "failed to unregister producer"), ], ) def test_stopStreamingTwice(self): """ stopStreaming() can be called more than once without blowing up. This is useful for error-handling paths. """ consumer = StringTransport() nsProducer = NonStreamingProducer(consumer) streamingProducer = _PullToPush(nsProducer, consumer) streamingProducer.startStreaming() streamingProducer.stopStreaming() streamingProducer.stopStreaming() self.assertTrue(streamingProducer._finished) def test_interface(self): """ L{_PullToPush} implements L{IPushProducer}. """ consumer = StringTransport() nsProducer = NonStreamingProducer(consumer) streamingProducer = _PullToPush(nsProducer, consumer) self.assertTrue(verifyObject(IPushProducer, streamingProducer)) @implementer(IProtocolNegotiationFactory) class ClientNegotiationFactory(ClientFactory): """ A L{ClientFactory} that has a set of acceptable protocols for NPN/ALPN negotiation. """ def __init__(self, acceptableProtocols): """ Create a L{ClientNegotiationFactory}. @param acceptableProtocols: The protocols the client will accept speaking after the TLS handshake is complete. @type acceptableProtocols: L{list} of L{bytes} """ self._acceptableProtocols = acceptableProtocols def acceptableProtocols(self): """ Returns a list of protocols that can be spoken by the connection factory in the form of ALPN tokens, as laid out in the IANA registry for ALPN tokens. @return: a list of ALPN tokens in order of preference. @rtype: L{list} of L{bytes} """ return self._acceptableProtocols @implementer(IProtocolNegotiationFactory) class ServerNegotiationFactory(ServerFactory): """ A L{ServerFactory} that has a set of acceptable protocols for NPN/ALPN negotiation. """ def __init__(self, acceptableProtocols): """ Create a L{ServerNegotiationFactory}. @param acceptableProtocols: The protocols the server will accept speaking after the TLS handshake is complete. @type acceptableProtocols: L{list} of L{bytes} """ self._acceptableProtocols = acceptableProtocols def acceptableProtocols(self): """ Returns a list of protocols that can be spoken by the connection factory in the form of ALPN tokens, as laid out in the IANA registry for ALPN tokens. @return: a list of ALPN tokens in order of preference. @rtype: L{list} of L{bytes} """ return self._acceptableProtocols PK Mb�Z���Nv v protocols/test/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Unit tests for L{twisted.protocols}. """ PK Mb�Z��@�� � protocols/ftp.pynu �[��� # -*- test-case-name: twisted.test.test_ftp -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ An FTP protocol implementation """ import errno import fnmatch # System Imports import os import re import stat import time try: import grp import pwd except ImportError: pwd = grp = None # type: ignore[assignment] from zope.interface import Interface, implementer # Twisted Imports from twisted import copyright from twisted.cred import checkers, credentials, error as cred_error, portal from twisted.internet import defer, error, interfaces, protocol, reactor from twisted.protocols import basic, policies from twisted.python import failure, filepath, log # constants # response codes RESTART_MARKER_REPLY = "100" SERVICE_READY_IN_N_MINUTES = "120" DATA_CNX_ALREADY_OPEN_START_XFR = "125" FILE_STATUS_OK_OPEN_DATA_CNX = "150" CMD_OK = "200.1" TYPE_SET_OK = "200.2" ENTERING_PORT_MODE = "200.3" CMD_NOT_IMPLMNTD_SUPERFLUOUS = "202" SYS_STATUS_OR_HELP_REPLY = "211.1" FEAT_OK = "211.2" DIR_STATUS = "212" FILE_STATUS = "213" HELP_MSG = "214" NAME_SYS_TYPE = "215" SVC_READY_FOR_NEW_USER = "220.1" WELCOME_MSG = "220.2" SVC_CLOSING_CTRL_CNX = "221.1" GOODBYE_MSG = "221.2" DATA_CNX_OPEN_NO_XFR_IN_PROGRESS = "225" CLOSING_DATA_CNX = "226.1" TXFR_COMPLETE_OK = "226.2" ENTERING_PASV_MODE = "227" ENTERING_EPSV_MODE = "229" USR_LOGGED_IN_PROCEED = "230.1" # v1 of code 230 GUEST_LOGGED_IN_PROCEED = "230.2" # v2 of code 230 REQ_FILE_ACTN_COMPLETED_OK = "250" PWD_REPLY = "257.1" MKD_REPLY = "257.2" USR_NAME_OK_NEED_PASS = "331.1" # v1 of Code 331 GUEST_NAME_OK_NEED_EMAIL = "331.2" # v2 of code 331 NEED_ACCT_FOR_LOGIN = "332" REQ_FILE_ACTN_PENDING_FURTHER_INFO = "350" SVC_NOT_AVAIL_CLOSING_CTRL_CNX = "421.1" TOO_MANY_CONNECTIONS = "421.2" CANT_OPEN_DATA_CNX = "425" CNX_CLOSED_TXFR_ABORTED = "426" REQ_ACTN_ABRTD_FILE_UNAVAIL = "450" REQ_ACTN_ABRTD_LOCAL_ERR = "451" REQ_ACTN_ABRTD_INSUFF_STORAGE = "452" SYNTAX_ERR = "500" SYNTAX_ERR_IN_ARGS = "501" CMD_NOT_IMPLMNTD = "502.1" OPTS_NOT_IMPLEMENTED = "502.2" BAD_CMD_SEQ = "503" CMD_NOT_IMPLMNTD_FOR_PARAM = "504" NOT_LOGGED_IN = "530.1" # v1 of code 530 - please log in AUTH_FAILURE = "530.2" # v2 of code 530 - authorization failure NEED_ACCT_FOR_STOR = "532" FILE_NOT_FOUND = "550.1" # no such file or directory PERMISSION_DENIED = "550.2" # permission denied ANON_USER_DENIED = "550.3" # anonymous users can't alter filesystem IS_NOT_A_DIR = "550.4" # rmd called on a path that is not a directory REQ_ACTN_NOT_TAKEN = "550.5" FILE_EXISTS = "550.6" IS_A_DIR = "550.7" PAGE_TYPE_UNK = "551" EXCEEDED_STORAGE_ALLOC = "552" FILENAME_NOT_ALLOWED = "553" RESPONSE = { # -- 100's -- # TODO: this must be fixed RESTART_MARKER_REPLY: "110 MARK yyyy-mmmm", SERVICE_READY_IN_N_MINUTES: "120 service ready in %s minutes", DATA_CNX_ALREADY_OPEN_START_XFR: "125 Data connection already open, " "starting transfer", FILE_STATUS_OK_OPEN_DATA_CNX: "150 File status okay; about to open " "data connection.", # -- 200's -- CMD_OK: "200 Command OK", TYPE_SET_OK: "200 Type set to %s.", ENTERING_PORT_MODE: "200 PORT OK", CMD_NOT_IMPLMNTD_SUPERFLUOUS: "202 Command not implemented, " "superfluous at this site", SYS_STATUS_OR_HELP_REPLY: "211 System status reply", FEAT_OK: ["211-Features:", "211 End"], DIR_STATUS: "212 %s", FILE_STATUS: "213 %s", HELP_MSG: "214 help: %s", NAME_SYS_TYPE: "215 UNIX Type: L8", WELCOME_MSG: "220 %s", SVC_READY_FOR_NEW_USER: "220 Service ready", SVC_CLOSING_CTRL_CNX: "221 Service closing control " "connection", GOODBYE_MSG: "221 Goodbye.", DATA_CNX_OPEN_NO_XFR_IN_PROGRESS: "225 data connection open, no " "transfer in progress", CLOSING_DATA_CNX: "226 Abort successful", TXFR_COMPLETE_OK: "226 Transfer Complete.", ENTERING_PASV_MODE: "227 Entering Passive Mode (%s).", # Where is EPSV defined in the RFCs? ENTERING_EPSV_MODE: "229 Entering Extended Passive Mode " "(|||%s|).", USR_LOGGED_IN_PROCEED: "230 User logged in, proceed", GUEST_LOGGED_IN_PROCEED: "230 Anonymous login ok, access " "restrictions apply.", # i.e. CWD completed OK REQ_FILE_ACTN_COMPLETED_OK: "250 Requested File Action Completed " "OK", PWD_REPLY: '257 "%s"', MKD_REPLY: '257 "%s" created', # -- 300's -- USR_NAME_OK_NEED_PASS: "331 Password required for %s.", GUEST_NAME_OK_NEED_EMAIL: "331 Guest login ok, type your email " "address as password.", NEED_ACCT_FOR_LOGIN: "332 Need account for login.", REQ_FILE_ACTN_PENDING_FURTHER_INFO: "350 Requested file action pending " "further information.", # -- 400's -- SVC_NOT_AVAIL_CLOSING_CTRL_CNX: "421 Service not available, closing " "control connection.", TOO_MANY_CONNECTIONS: "421 Too many users right now, try " "again in a few minutes.", CANT_OPEN_DATA_CNX: "425 Can't open data connection.", CNX_CLOSED_TXFR_ABORTED: "426 Transfer aborted. Data " "connection closed.", REQ_ACTN_ABRTD_FILE_UNAVAIL: "450 Requested action aborted. " "File unavailable.", REQ_ACTN_ABRTD_LOCAL_ERR: "451 Requested action aborted. " "Local error in processing.", REQ_ACTN_ABRTD_INSUFF_STORAGE: "452 Requested action aborted. " "Insufficient storage.", # -- 500's -- SYNTAX_ERR: "500 Syntax error: %s", SYNTAX_ERR_IN_ARGS: "501 syntax error in argument(s) %s.", CMD_NOT_IMPLMNTD: "502 Command '%s' not implemented", OPTS_NOT_IMPLEMENTED: "502 Option '%s' not implemented.", BAD_CMD_SEQ: "503 Incorrect sequence of commands: " "%s", CMD_NOT_IMPLMNTD_FOR_PARAM: "504 Not implemented for parameter " "'%s'.", NOT_LOGGED_IN: "530 Please login with USER and PASS.", AUTH_FAILURE: "530 Sorry, Authentication failed.", NEED_ACCT_FOR_STOR: "532 Need an account for storing " "files", FILE_NOT_FOUND: "550 %s: No such file or directory.", PERMISSION_DENIED: "550 %s: Permission denied.", ANON_USER_DENIED: "550 Anonymous users are forbidden to " "change the filesystem", IS_NOT_A_DIR: "550 Cannot rmd, %s is not a " "directory", FILE_EXISTS: "550 %s: File exists", IS_A_DIR: "550 %s: is a directory", REQ_ACTN_NOT_TAKEN: "550 Requested action not taken: %s", PAGE_TYPE_UNK: "551 Page type unknown", EXCEEDED_STORAGE_ALLOC: "552 Requested file action aborted, " "exceeded file storage allocation", FILENAME_NOT_ALLOWED: "553 Requested action not taken, file " "name not allowed", } class InvalidPath(Exception): """ Internal exception used to signify an error during parsing a path. """ def toSegments(cwd, path): """ Normalize a path, as represented by a list of strings each representing one segment of the path. """ if path.startswith("/"): segs = [] else: segs = cwd[:] for s in path.split("/"): if s == "." or s == "": continue elif s == "..": if segs: segs.pop() else: raise InvalidPath(cwd, path) elif "\0" in s or "/" in s: raise InvalidPath(cwd, path) else: segs.append(s) return segs def errnoToFailure(e, path): """ Map C{OSError} and C{IOError} to standard FTP errors. """ if e == errno.ENOENT: return defer.fail(FileNotFoundError(path)) elif e == errno.EACCES or e == errno.EPERM: return defer.fail(PermissionDeniedError(path)) elif e == errno.ENOTDIR: return defer.fail(IsNotADirectoryError(path)) elif e == errno.EEXIST: return defer.fail(FileExistsError(path)) elif e == errno.EISDIR: return defer.fail(IsADirectoryError(path)) else: return defer.fail() _testTranslation = fnmatch.translate("TEST") def _isGlobbingExpression(segments=None): """ Helper for checking if a FTPShell `segments` contains a wildcard Unix expression. Only filename globbing is supported. This means that wildcards can only be presents in the last element of `segments`. @type segments: C{list} @param segments: List of path elements as used by the FTP server protocol. @rtype: Boolean @return: True if `segments` contains a globbing expression. """ if not segments: return False # To check that something is a glob expression, we convert it to # Regular Expression. # We compare it to the translation of a known non-glob expression. # If the result is the same as the original expression then it contains no # globbing expression. globCandidate = segments[-1] globTranslations = fnmatch.translate(globCandidate) nonGlobTranslations = _testTranslation.replace("TEST", globCandidate, 1) if nonGlobTranslations == globTranslations: return False else: return True class FTPCmdError(Exception): """ Generic exception for FTP commands. """ def __init__(self, *msg): Exception.__init__(self, *msg) self.errorMessage = msg def response(self): """ Generate a FTP response message for this error. """ return RESPONSE[self.errorCode] % self.errorMessage class FileNotFoundError(FTPCmdError): """ Raised when trying to access a non existent file or directory. """ errorCode = FILE_NOT_FOUND class AnonUserDeniedError(FTPCmdError): """ Raised when an anonymous user issues a command that will alter the filesystem """ errorCode = ANON_USER_DENIED class PermissionDeniedError(FTPCmdError): """ Raised when access is attempted to a resource to which access is not allowed. """ errorCode = PERMISSION_DENIED class IsNotADirectoryError(FTPCmdError): """ Raised when RMD is called on a path that isn't a directory. """ errorCode = IS_NOT_A_DIR class FileExistsError(FTPCmdError): """ Raised when attempted to override an existing resource. """ errorCode = FILE_EXISTS class IsADirectoryError(FTPCmdError): """ Raised when DELE is called on a path that is a directory. """ errorCode = IS_A_DIR class CmdSyntaxError(FTPCmdError): """ Raised when a command syntax is wrong. """ errorCode = SYNTAX_ERR class CmdArgSyntaxError(FTPCmdError): """ Raised when a command is called with wrong value or a wrong number of arguments. """ errorCode = SYNTAX_ERR_IN_ARGS class CmdNotImplementedError(FTPCmdError): """ Raised when an unimplemented command is given to the server. """ errorCode = CMD_NOT_IMPLMNTD class CmdNotImplementedForArgError(FTPCmdError): """ Raised when the handling of a parameter for a command is not implemented by the server. """ errorCode = CMD_NOT_IMPLMNTD_FOR_PARAM class FTPError(Exception): pass class PortConnectionError(Exception): pass class BadCmdSequenceError(FTPCmdError): """ Raised when a client sends a series of commands in an illogical sequence. """ errorCode = BAD_CMD_SEQ class AuthorizationError(FTPCmdError): """ Raised when client authentication fails. """ errorCode = AUTH_FAILURE def debugDeferred(self, *_): log.msg("debugDeferred(): %s" % str(_), debug=True) # -- DTP Protocol -- _months = [ None, "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", ] @implementer(interfaces.IConsumer) class DTP(protocol.Protocol): isConnected = False _cons = None _onConnLost = None _buffer = None _encoding = "latin-1" def connectionMade(self): self.isConnected = True self.factory.deferred.callback(None) self._buffer = [] def connectionLost(self, reason): self.isConnected = False if self._onConnLost is not None: self._onConnLost.callback(None) def sendLine(self, line): """ Send a line to data channel. @param line: The line to be sent. @type line: L{bytes} """ self.transport.write(line + b"\r\n") def _formatOneListResponse( self, name, size, directory, permissions, hardlinks, modified, owner, group ): """ Helper method to format one entry's info into a text entry like: 'drwxrwxrwx 0 user group 0 Jan 01 1970 filename.txt' @param name: C{bytes} name of the entry (file or directory or link) @param size: C{int} size of the entry @param directory: evals to C{bool} - whether the entry is a directory @param permissions: L{twisted.python.filepath.Permissions} object representing that entry's permissions @param hardlinks: C{int} number of hardlinks @param modified: C{float} - entry's last modified time in seconds since the epoch @param owner: C{str} username of the owner @param group: C{str} group name of the owner @return: C{str} in the requisite format """ def formatDate(mtime): now = time.gmtime() info = { "month": _months[mtime.tm_mon], "day": mtime.tm_mday, "year": mtime.tm_year, "hour": mtime.tm_hour, "minute": mtime.tm_min, } if now.tm_year != mtime.tm_year: return "%(month)s %(day)02d %(year)5d" % info else: return "%(month)s %(day)02d %(hour)02d:%(minute)02d" % info format = ( "%(directory)s%(permissions)s%(hardlinks)4d " "%(owner)-9s %(group)-9s %(size)15d %(date)12s " ) msg = ( format % { "directory": directory and "d" or "-", "permissions": permissions.shorthand(), "hardlinks": hardlinks, "owner": owner[:8], "group": group[:8], "size": size, "date": formatDate(time.gmtime(modified)), } ).encode(self._encoding) return msg + name def sendListResponse(self, name, response): self.sendLine(self._formatOneListResponse(name, *response)) # Proxy IConsumer to our transport def registerProducer(self, producer, streaming): return self.transport.registerProducer(producer, streaming) def unregisterProducer(self): self.transport.unregisterProducer() self.transport.loseConnection() def write(self, data): if self.isConnected: return self.transport.write(data) raise Exception("Crap damn crap damn crap damn") # Pretend to be a producer, too. def _conswrite(self, bytes): try: self._cons.write(bytes) except BaseException: self._onConnLost.errback() def dataReceived(self, bytes): if self._cons is not None: self._conswrite(bytes) else: self._buffer.append(bytes) def _unregConsumer(self, ignored): self._cons.unregisterProducer() self._cons = None del self._onConnLost return ignored def registerConsumer(self, cons): assert self._cons is None self._cons = cons self._cons.registerProducer(self, True) for chunk in self._buffer: self._conswrite(chunk) self._buffer = None if self.isConnected: self._onConnLost = d = defer.Deferred() d.addBoth(self._unregConsumer) return d else: self._cons.unregisterProducer() self._cons = None return defer.succeed(None) def resumeProducing(self): self.transport.resumeProducing() def pauseProducing(self): self.transport.pauseProducing() def stopProducing(self): self.transport.stopProducing() class DTPFactory(protocol.ClientFactory): """ Client factory for I{data transfer process} protocols. @ivar peerCheck: perform checks to make sure the ftp-pi's peer is the same as the dtp's @ivar pi: a reference to this factory's protocol interpreter @ivar _state: Indicates the current state of the DTPFactory. Initially, this is L{_IN_PROGRESS}. If the connection fails or times out, it is L{_FAILED}. If the connection succeeds before the timeout, it is L{_FINISHED}. @cvar _IN_PROGRESS: Token to signal that connection is active. @type _IN_PROGRESS: L{object}. @cvar _FAILED: Token to signal that connection has failed. @type _FAILED: L{object}. @cvar _FINISHED: Token to signal that connection was successfully closed. @type _FINISHED: L{object}. """ _IN_PROGRESS = object() _FAILED = object() _FINISHED = object() _state = _IN_PROGRESS # -- configuration variables -- peerCheck = False # -- class variables -- def __init__(self, pi, peerHost=None, reactor=None): """ Constructor @param pi: this factory's protocol interpreter @param peerHost: if peerCheck is True, this is the tuple that the generated instance will use to perform security checks """ self.pi = pi self.peerHost = peerHost # from FTP.transport.peerHost() # deferred will fire when instance is connected self.deferred = defer.Deferred() self.delayedCall = None if reactor is None: from twisted.internet import reactor self._reactor = reactor def buildProtocol(self, addr): log.msg("DTPFactory.buildProtocol", debug=True) if self._state is not self._IN_PROGRESS: return None self._state = self._FINISHED self.cancelTimeout() p = DTP() p.factory = self p.pi = self.pi self.pi.dtpInstance = p return p def stopFactory(self): log.msg("dtpFactory.stopFactory", debug=True) self.cancelTimeout() def timeoutFactory(self): log.msg("timed out waiting for DTP connection") if self._state is not self._IN_PROGRESS: return self._state = self._FAILED d = self.deferred self.deferred = None d.errback(PortConnectionError(defer.TimeoutError("DTPFactory timeout"))) def cancelTimeout(self): if self.delayedCall is not None and self.delayedCall.active(): log.msg("cancelling DTP timeout", debug=True) self.delayedCall.cancel() def setTimeout(self, seconds): log.msg("DTPFactory.setTimeout set to %s seconds" % seconds) self.delayedCall = self._reactor.callLater(seconds, self.timeoutFactory) def clientConnectionFailed(self, connector, reason): if self._state is not self._IN_PROGRESS: return self._state = self._FAILED d = self.deferred self.deferred = None d.errback(PortConnectionError(reason)) # -- FTP-PI (Protocol Interpreter) -- class ASCIIConsumerWrapper: def __init__(self, cons): self.cons = cons self.registerProducer = cons.registerProducer self.unregisterProducer = cons.unregisterProducer assert ( os.linesep == "\r\n" or len(os.linesep) == 1 ), "Unsupported platform (yea right like this even exists)" if os.linesep == "\r\n": self.write = cons.write def write(self, bytes): return self.cons.write(bytes.replace(os.linesep, "\r\n")) @implementer(interfaces.IConsumer) class FileConsumer: """ A consumer for FTP input that writes data to a file. @ivar fObj: a file object opened for writing, used to write data received. @type fObj: C{file} """ def __init__(self, fObj): self.fObj = fObj def registerProducer(self, producer, streaming): self.producer = producer assert streaming def unregisterProducer(self): self.producer = None self.fObj.close() def write(self, bytes): self.fObj.write(bytes) class FTPOverflowProtocol(basic.LineReceiver): """FTP mini-protocol for when there are too many connections.""" _encoding = "latin-1" def connectionMade(self): self.sendLine(RESPONSE[TOO_MANY_CONNECTIONS].encode(self._encoding)) self.transport.loseConnection() class FTP(basic.LineReceiver, policies.TimeoutMixin): """ Protocol Interpreter for the File Transfer Protocol @ivar state: The current server state. One of L{UNAUTH}, L{INAUTH}, L{AUTHED}, L{RENAMING}. @ivar shell: The connected avatar @ivar binary: The transfer mode. If false, ASCII. @ivar dtpFactory: Generates a single DTP for this session @ivar dtpPort: Port returned from listenTCP @ivar listenFactory: A callable with the signature of L{twisted.internet.interfaces.IReactorTCP.listenTCP} which will be used to create Ports for passive connections (mainly for testing). @ivar passivePortRange: iterator used as source of passive port numbers. @type passivePortRange: C{iterator} @cvar UNAUTH: Command channel is not yet authenticated. @type UNAUTH: L{int} @cvar INAUTH: Command channel is in the process of being authenticated. @type INAUTH: L{int} @cvar AUTHED: Command channel was successfully authenticated. @type AUTHED: L{int} @cvar RENAMING: Command channel is between the renaming command sequence. @type RENAMING: L{int} """ disconnected = False # States an FTP can be in UNAUTH, INAUTH, AUTHED, RENAMING = range(4) # how long the DTP waits for a connection dtpTimeout = 10 portal = None shell = None dtpFactory = None dtpPort = None dtpInstance = None binary = True PUBLIC_COMMANDS = ["FEAT", "QUIT"] FEATURES = ["FEAT", "MDTM", "PASV", "SIZE", "TYPE A;I"] passivePortRange = range(0, 1) listenFactory = reactor.listenTCP # type: ignore[attr-defined] _encoding = "latin-1" def reply(self, key, *args): msg = RESPONSE[key] % args self.sendLine(msg) def sendLine(self, line): """ (Private) Encodes and sends a line @param line: L{bytes} or L{unicode} """ if isinstance(line, str): line = line.encode(self._encoding) super().sendLine(line) def connectionMade(self): self.state = self.UNAUTH self.setTimeout(self.timeOut) self.reply(WELCOME_MSG, self.factory.welcomeMessage) def connectionLost(self, reason): # if we have a DTP protocol instance running and # we lose connection to the client's PI, kill the # DTP connection and close the port if self.dtpFactory: self.cleanupDTP() self.setTimeout(None) if hasattr(self.shell, "logout") and self.shell.logout is not None: self.shell.logout() self.shell = None self.transport = None def timeoutConnection(self): self.transport.loseConnection() def lineReceived(self, line): self.resetTimeout() self.pauseProducing() if bytes != str: line = line.decode(self._encoding) def processFailed(err): if err.check(FTPCmdError): self.sendLine(err.value.response()) elif err.check(TypeError) and any( msg in err.value.args[0] for msg in ("takes exactly", "required positional argument") ): self.reply(SYNTAX_ERR, f"{cmd} requires an argument.") else: log.msg("Unexpected FTP error") log.err(err) self.reply(REQ_ACTN_NOT_TAKEN, "internal server error") def processSucceeded(result): if isinstance(result, tuple): self.reply(*result) elif result is not None: self.reply(result) def allDone(ignored): if not self.disconnected: self.resumeProducing() spaceIndex = line.find(" ") if spaceIndex != -1: cmd = line[:spaceIndex] args = (line[spaceIndex + 1 :],) else: cmd = line args = () d = defer.maybeDeferred(self.processCommand, cmd, *args) d.addCallbacks(processSucceeded, processFailed) d.addErrback(log.err) # XXX It burnsss # LineReceiver doesn't let you resumeProducing inside # lineReceived atm from twisted.internet import reactor reactor.callLater(0, d.addBoth, allDone) def processCommand(self, cmd, *params): def call_ftp_command(command): method = getattr(self, "ftp_" + command, None) if method is not None: return method(*params) return defer.fail(CmdNotImplementedError(command)) cmd = cmd.upper() if cmd in self.PUBLIC_COMMANDS: return call_ftp_command(cmd) elif self.state == self.UNAUTH: if cmd == "USER": return self.ftp_USER(*params) elif cmd == "PASS": return BAD_CMD_SEQ, "USER required before PASS" else: return NOT_LOGGED_IN elif self.state == self.INAUTH: if cmd == "PASS": return self.ftp_PASS(*params) else: return BAD_CMD_SEQ, "PASS required after USER" elif self.state == self.AUTHED: return call_ftp_command(cmd) elif self.state == self.RENAMING: if cmd == "RNTO": return self.ftp_RNTO(*params) else: return BAD_CMD_SEQ, "RNTO required after RNFR" def getDTPPort(self, factory): """ Return a port for passive access, using C{self.passivePortRange} attribute. """ for portn in self.passivePortRange: try: dtpPort = self.listenFactory(portn, factory) except error.CannotListenError: continue else: return dtpPort raise error.CannotListenError( "", portn, f"No port available in range {self.passivePortRange}" ) def ftp_USER(self, username): """ First part of login. Get the username the peer wants to authenticate as. """ if not username: return defer.fail(CmdSyntaxError("USER requires an argument")) self._user = username self.state = self.INAUTH if self.factory.allowAnonymous and self._user == self.factory.userAnonymous: return GUEST_NAME_OK_NEED_EMAIL else: return (USR_NAME_OK_NEED_PASS, username) # TODO: add max auth try before timeout from ip... # TODO: need to implement minimal ABOR command def ftp_PASS(self, password): """ Second part of login. Get the password the peer wants to authenticate with. """ if self.factory.allowAnonymous and self._user == self.factory.userAnonymous: # anonymous login creds = credentials.Anonymous() reply = GUEST_LOGGED_IN_PROCEED else: # user login creds = credentials.UsernamePassword(self._user, password) reply = USR_LOGGED_IN_PROCEED del self._user def _cbLogin(result): (interface, avatar, logout) = result assert interface is IFTPShell, "The realm is busted, jerk." self.shell = avatar self.logout = logout self.workingDirectory = [] self.state = self.AUTHED return reply def _ebLogin(failure): failure.trap(cred_error.UnauthorizedLogin, cred_error.UnhandledCredentials) self.state = self.UNAUTH raise AuthorizationError d = self.portal.login(creds, None, IFTPShell) d.addCallbacks(_cbLogin, _ebLogin) return d def ftp_PASV(self): """ Request for a passive connection from the rfc:: This command requests the server-DTP to \"listen\" on a data port (which is not its default data port) and to wait for a connection rather than initiate one upon receipt of a transfer command. The response to this command includes the host and port address this server is listening on. """ # if we have a DTP port set up, lose it. if self.dtpFactory is not None: # cleanupDTP sets dtpFactory to none. Later we'll do # cleanup here or something. self.cleanupDTP() self.dtpFactory = DTPFactory(pi=self) self.dtpFactory.setTimeout(self.dtpTimeout) self.dtpPort = self.getDTPPort(self.dtpFactory) host = self.transport.getHost().host port = self.dtpPort.getHost().port self.reply(ENTERING_PASV_MODE, encodeHostPort(host, port)) return self.dtpFactory.deferred.addCallback(lambda ign: None) def ftp_PORT(self, address): addr = tuple(map(int, address.split(","))) ip = "%d.%d.%d.%d" % tuple(addr[:4]) port = addr[4] << 8 | addr[5] # if we have a DTP port set up, lose it. if self.dtpFactory is not None: self.cleanupDTP() self.dtpFactory = DTPFactory(pi=self, peerHost=self.transport.getPeer().host) self.dtpFactory.setTimeout(self.dtpTimeout) self.dtpPort = reactor.connectTCP(ip, port, self.dtpFactory) def connected(ignored): return ENTERING_PORT_MODE def connFailed(err): err.trap(PortConnectionError) return CANT_OPEN_DATA_CNX return self.dtpFactory.deferred.addCallbacks(connected, connFailed) def _encodeName(self, name): """ Encode C{name} to be sent over the wire. This encodes L{unicode} objects as UTF-8 and leaves L{bytes} as-is. As described by U{RFC 3659 section 2.2<https://tools.ietf.org/html/rfc3659#section-2.2>}:: Various FTP commands take pathnames as arguments, or return pathnames in responses. When the MLST command is supported, as indicated in the response to the FEAT command, pathnames are to be transferred in one of the following two formats. pathname = utf-8-name / raw utf-8-name = <a UTF-8 encoded Unicode string> raw = <any string that is not a valid UTF-8 encoding> Which format is used is at the option of the user-PI or server-PI sending the pathname. @param name: Name to be encoded. @type name: L{bytes} or L{unicode} @return: Wire format of C{name}. @rtype: L{bytes} """ if isinstance(name, str): return name.encode("utf-8") return name def ftp_LIST(self, path=""): """This command causes a list to be sent from the server to the passive DTP. If the pathname specifies a directory or other group of files, the server should transfer a list of files in the specified directory. If the pathname specifies a file then the server should send current information on the file. A null argument implies the user's current working or default directory. """ # XXX: why is this check different from ftp_RETR/ftp_STOR? See #4180 if self.dtpInstance is None or not self.dtpInstance.isConnected: return defer.fail(BadCmdSequenceError("must send PORT or PASV before RETR")) # Various clients send flags like -L or -al etc. We just ignore them. if path.lower() in ["-a", "-l", "-la", "-al"]: path = "" def gotListing(results): self.reply(DATA_CNX_ALREADY_OPEN_START_XFR) for (name, attrs) in results: name = self._encodeName(name) self.dtpInstance.sendListResponse(name, attrs) self.dtpInstance.transport.loseConnection() return (TXFR_COMPLETE_OK,) try: segments = toSegments(self.workingDirectory, path) except InvalidPath: return defer.fail(FileNotFoundError(path)) d = self.shell.list( segments, ( "size", "directory", "permissions", "hardlinks", "modified", "owner", "group", ), ) d.addCallback(gotListing) return d def ftp_NLST(self, path): """ This command causes a directory listing to be sent from the server to the client. The pathname should specify a directory or other system-specific file group descriptor. An empty path implies the current working directory. If the path is non-existent, send nothing. If the path is to a file, send only the file name. @type path: C{str} @param path: The path for which a directory listing should be returned. @rtype: L{Deferred} @return: a L{Deferred} which will be fired when the listing request is finished. """ # XXX: why is this check different from ftp_RETR/ftp_STOR? See #4180 if self.dtpInstance is None or not self.dtpInstance.isConnected: return defer.fail(BadCmdSequenceError("must send PORT or PASV before RETR")) try: segments = toSegments(self.workingDirectory, path) except InvalidPath: return defer.fail(FileNotFoundError(path)) def cbList(results, glob): """ Send, line by line, each matching file in the directory listing, and then close the connection. @type results: A C{list} of C{tuple}. The first element of each C{tuple} is a C{str} and the second element is a C{list}. @param results: The names of the files in the directory. @param glob: A shell-style glob through which to filter results (see U{http://docs.python.org/2/library/fnmatch.html}), or L{None} for no filtering. @type glob: L{str} or L{None} @return: A C{tuple} containing the status code for a successful transfer. @rtype: C{tuple} """ self.reply(DATA_CNX_ALREADY_OPEN_START_XFR) for (name, ignored) in results: if not glob or (glob and fnmatch.fnmatch(name, glob)): name = self._encodeName(name) self.dtpInstance.sendLine(name) self.dtpInstance.transport.loseConnection() return (TXFR_COMPLETE_OK,) def listErr(results): """ RFC 959 specifies that an NLST request may only return directory listings. Thus, send nothing and just close the connection. @type results: L{Failure} @param results: The L{Failure} wrapping a L{FileNotFoundError} that occurred while trying to list the contents of a nonexistent directory. @returns: A C{tuple} containing the status code for a successful transfer. @rtype: C{tuple} """ self.dtpInstance.transport.loseConnection() return (TXFR_COMPLETE_OK,) if _isGlobbingExpression(segments): # Remove globbing expression from path # and keep to be used for filtering. glob = segments.pop() else: glob = None d = self.shell.list(segments) d.addCallback(cbList, glob) # self.shell.list will generate an error if the path is invalid d.addErrback(listErr) return d def ftp_CWD(self, path): try: segments = toSegments(self.workingDirectory, path) except InvalidPath: # XXX Eh, what to fail with here? return defer.fail(FileNotFoundError(path)) def accessGranted(result): self.workingDirectory = segments return (REQ_FILE_ACTN_COMPLETED_OK,) return self.shell.access(segments).addCallback(accessGranted) def ftp_CDUP(self): return self.ftp_CWD("..") def ftp_PWD(self): return (PWD_REPLY, "/" + "/".join(self.workingDirectory)) def ftp_RETR(self, path): """ This command causes the content of a file to be sent over the data transfer channel. If the path is to a folder, an error will be raised. @type path: C{str} @param path: The path to the file which should be transferred over the data transfer channel. @rtype: L{Deferred} @return: a L{Deferred} which will be fired when the transfer is done. """ if self.dtpInstance is None: raise BadCmdSequenceError("PORT or PASV required before RETR") try: newsegs = toSegments(self.workingDirectory, path) except InvalidPath: return defer.fail(FileNotFoundError(path)) # XXX For now, just disable the timeout. Later we'll want to # leave it active and have the DTP connection reset it # periodically. self.setTimeout(None) # Put it back later def enableTimeout(result): self.setTimeout(self.factory.timeOut) return result # And away she goes if not self.binary: cons = ASCIIConsumerWrapper(self.dtpInstance) else: cons = self.dtpInstance def cbSent(result): return (TXFR_COMPLETE_OK,) def ebSent(err): log.msg("Unexpected error attempting to transmit file to client:") log.err(err) if err.check(FTPCmdError): return err return (CNX_CLOSED_TXFR_ABORTED,) def cbOpened(file): # Tell them what to doooo if self.dtpInstance.isConnected: self.reply(DATA_CNX_ALREADY_OPEN_START_XFR) else: self.reply(FILE_STATUS_OK_OPEN_DATA_CNX) d = file.send(cons) d.addCallbacks(cbSent, ebSent) return d def ebOpened(err): if not err.check( PermissionDeniedError, FileNotFoundError, IsADirectoryError ): log.msg("Unexpected error attempting to open file for " "transmission:") log.err(err) if err.check(FTPCmdError): return (err.value.errorCode, "/".join(newsegs)) return (FILE_NOT_FOUND, "/".join(newsegs)) d = self.shell.openForReading(newsegs) d.addCallbacks(cbOpened, ebOpened) d.addBoth(enableTimeout) # Pass back Deferred that fires when the transfer is done return d def ftp_STOR(self, path): """ STORE (STOR) This command causes the server-DTP to accept the data transferred via the data connection and to store the data as a file at the server site. If the file specified in the pathname exists at the server site, then its contents shall be replaced by the data being transferred. A new file is created at the server site if the file specified in the pathname does not already exist. """ if self.dtpInstance is None: raise BadCmdSequenceError("PORT or PASV required before STOR") try: newsegs = toSegments(self.workingDirectory, path) except InvalidPath: return defer.fail(FileNotFoundError(path)) # XXX For now, just disable the timeout. Later we'll want to # leave it active and have the DTP connection reset it # periodically. self.setTimeout(None) # Put it back later def enableTimeout(result): self.setTimeout(self.factory.timeOut) return result def cbOpened(file): """ File was open for reading. Launch the data transfer channel via the file consumer. """ d = file.receive() d.addCallback(cbConsumer) d.addCallback(lambda ignored: file.close()) d.addCallbacks(cbSent, ebSent) return d def ebOpened(err): """ Called when failed to open the file for reading. For known errors, return the FTP error code. For all other, return a file not found error. """ if isinstance(err.value, FTPCmdError): return (err.value.errorCode, "/".join(newsegs)) log.err(err, "Unexpected error received while opening file:") return (FILE_NOT_FOUND, "/".join(newsegs)) def cbConsumer(cons): """ Called after the file was opended for reading. Prepare the data transfer channel and send the response to the command channel. """ if not self.binary: cons = ASCIIConsumerWrapper(cons) d = self.dtpInstance.registerConsumer(cons) # Tell them what to doooo if self.dtpInstance.isConnected: self.reply(DATA_CNX_ALREADY_OPEN_START_XFR) else: self.reply(FILE_STATUS_OK_OPEN_DATA_CNX) return d def cbSent(result): """ Called from data transport when transfer is done. """ return (TXFR_COMPLETE_OK,) def ebSent(err): """ Called from data transport when there are errors during the transfer. """ log.err(err, "Unexpected error received during transfer:") if err.check(FTPCmdError): return err return (CNX_CLOSED_TXFR_ABORTED,) d = self.shell.openForWriting(newsegs) d.addCallbacks(cbOpened, ebOpened) d.addBoth(enableTimeout) # Pass back Deferred that fires when the transfer is done return d def ftp_SIZE(self, path): """ File SIZE The FTP command, SIZE OF FILE (SIZE), is used to obtain the transfer size of a file from the server-FTP process. This is the exact number of octets (8 bit bytes) that would be transmitted over the data connection should that file be transmitted. This value will change depending on the current STRUcture, MODE, and TYPE of the data connection or of a data connection that would be created were one created now. Thus, the result of the SIZE command is dependent on the currently established STRU, MODE, and TYPE parameters. The SIZE command returns how many octets would be transferred if the file were to be transferred using the current transfer structure, mode, and type. This command is normally used in conjunction with the RESTART (REST) command when STORing a file to a remote server in STREAM mode, to determine the restart point. The server-PI might need to read the partially transferred file, do any appropriate conversion, and count the number of octets that would be generated when sending the file in order to correctly respond to this command. Estimates of the file transfer size MUST NOT be returned; only precise information is acceptable. http://tools.ietf.org/html/rfc3659 """ try: newsegs = toSegments(self.workingDirectory, path) except InvalidPath: return defer.fail(FileNotFoundError(path)) def cbStat(result): (size,) = result return (FILE_STATUS, str(size)) return self.shell.stat(newsegs, ("size",)).addCallback(cbStat) def ftp_MDTM(self, path): """ File Modification Time (MDTM) The FTP command, MODIFICATION TIME (MDTM), can be used to determine when a file in the server NVFS was last modified. This command has existed in many FTP servers for many years, as an adjunct to the REST command for STREAM mode, thus is widely available. However, where supported, the "modify" fact that can be provided in the result from the new MLST command is recommended as a superior alternative. http://tools.ietf.org/html/rfc3659 """ try: newsegs = toSegments(self.workingDirectory, path) except InvalidPath: return defer.fail(FileNotFoundError(path)) def cbStat(result): (modified,) = result return (FILE_STATUS, time.strftime("%Y%m%d%H%M%S", time.gmtime(modified))) return self.shell.stat(newsegs, ("modified",)).addCallback(cbStat) def ftp_TYPE(self, type): """ REPRESENTATION TYPE (TYPE) The argument specifies the representation type as described in the Section on Data Representation and Storage. Several types take a second parameter. The first parameter is denoted by a single Telnet character, as is the second Format parameter for ASCII and EBCDIC; the second parameter for local byte is a decimal integer to indicate Bytesize. The parameters are separated by a <SP> (Space, ASCII code 32). """ p = type.upper() if p: f = getattr(self, "type_" + p[0], None) if f is not None: return f(p[1:]) return self.type_UNKNOWN(p) return (SYNTAX_ERR,) def type_A(self, code): if code == "" or code == "N": self.binary = False return (TYPE_SET_OK, "A" + code) else: return defer.fail(CmdArgSyntaxError(code)) def type_I(self, code): if code == "": self.binary = True return (TYPE_SET_OK, "I") else: return defer.fail(CmdArgSyntaxError(code)) def type_UNKNOWN(self, code): return defer.fail(CmdNotImplementedForArgError(code)) def ftp_SYST(self): return NAME_SYS_TYPE def ftp_STRU(self, structure): p = structure.upper() if p == "F": return (CMD_OK,) return defer.fail(CmdNotImplementedForArgError(structure)) def ftp_MODE(self, mode): p = mode.upper() if p == "S": return (CMD_OK,) return defer.fail(CmdNotImplementedForArgError(mode)) def ftp_MKD(self, path): try: newsegs = toSegments(self.workingDirectory, path) except InvalidPath: return defer.fail(FileNotFoundError(path)) return self.shell.makeDirectory(newsegs).addCallback( lambda ign: (MKD_REPLY, path) ) def ftp_RMD(self, path): try: newsegs = toSegments(self.workingDirectory, path) except InvalidPath: return defer.fail(FileNotFoundError(path)) return self.shell.removeDirectory(newsegs).addCallback( lambda ign: (REQ_FILE_ACTN_COMPLETED_OK,) ) def ftp_DELE(self, path): try: newsegs = toSegments(self.workingDirectory, path) except InvalidPath: return defer.fail(FileNotFoundError(path)) return self.shell.removeFile(newsegs).addCallback( lambda ign: (REQ_FILE_ACTN_COMPLETED_OK,) ) def ftp_NOOP(self): return (CMD_OK,) def ftp_RNFR(self, fromName): self._fromName = fromName self.state = self.RENAMING return (REQ_FILE_ACTN_PENDING_FURTHER_INFO,) def ftp_RNTO(self, toName): fromName = self._fromName del self._fromName self.state = self.AUTHED try: fromsegs = toSegments(self.workingDirectory, fromName) tosegs = toSegments(self.workingDirectory, toName) except InvalidPath: return defer.fail(FileNotFoundError(fromName)) return self.shell.rename(fromsegs, tosegs).addCallback( lambda ign: (REQ_FILE_ACTN_COMPLETED_OK,) ) def ftp_FEAT(self): """ Advertise the features supported by the server. http://tools.ietf.org/html/rfc2389 """ self.sendLine(RESPONSE[FEAT_OK][0]) for feature in self.FEATURES: self.sendLine(" " + feature) self.sendLine(RESPONSE[FEAT_OK][1]) def ftp_OPTS(self, option): """ Handle OPTS command. http://tools.ietf.org/html/draft-ietf-ftpext-utf-8-option-00 """ return self.reply(OPTS_NOT_IMPLEMENTED, option) def ftp_QUIT(self): self.reply(GOODBYE_MSG) self.transport.loseConnection() self.disconnected = True def cleanupDTP(self): """ Call when DTP connection exits """ log.msg("cleanupDTP", debug=True) log.msg(self.dtpPort) dtpPort, self.dtpPort = self.dtpPort, None if interfaces.IListeningPort.providedBy(dtpPort): dtpPort.stopListening() elif interfaces.IConnector.providedBy(dtpPort): dtpPort.disconnect() else: assert False, ( "dtpPort should be an IListeningPort or IConnector, " "instead is %r" % (dtpPort,) ) self.dtpFactory.stopFactory() self.dtpFactory = None if self.dtpInstance is not None: self.dtpInstance = None class FTPFactory(policies.LimitTotalConnectionsFactory): """ A factory for producing ftp protocol instances @ivar timeOut: the protocol interpreter's idle timeout time in seconds, default is 600 seconds. @ivar passivePortRange: value forwarded to C{protocol.passivePortRange}. @type passivePortRange: C{iterator} """ protocol = FTP overflowProtocol = FTPOverflowProtocol allowAnonymous = True userAnonymous = "anonymous" timeOut = 600 welcomeMessage = f"Twisted {copyright.version} FTP Server" passivePortRange = range(0, 1) def __init__(self, portal=None, userAnonymous="anonymous"): self.portal = portal self.userAnonymous = userAnonymous self.instances = [] def buildProtocol(self, addr): p = policies.LimitTotalConnectionsFactory.buildProtocol(self, addr) if p is not None: p.wrappedProtocol.portal = self.portal p.wrappedProtocol.timeOut = self.timeOut p.wrappedProtocol.passivePortRange = self.passivePortRange return p def stopFactory(self): # make sure ftp instance's timeouts are set to None # to avoid reactor complaints [p.setTimeout(None) for p in self.instances if p.timeOut is not None] policies.LimitTotalConnectionsFactory.stopFactory(self) # -- Cred Objects -- class IFTPShell(Interface): """ An abstraction of the shell commands used by the FTP protocol for a given user account. All path names must be absolute. """ def makeDirectory(path): """ Create a directory. @param path: The path, as a list of segments, to create @type path: C{list} of C{unicode} @return: A Deferred which fires when the directory has been created, or which fails if the directory cannot be created. """ def removeDirectory(path): """ Remove a directory. @param path: The path, as a list of segments, to remove @type path: C{list} of C{unicode} @return: A Deferred which fires when the directory has been removed, or which fails if the directory cannot be removed. """ def removeFile(path): """ Remove a file. @param path: The path, as a list of segments, to remove @type path: C{list} of C{unicode} @return: A Deferred which fires when the file has been removed, or which fails if the file cannot be removed. """ def rename(fromPath, toPath): """ Rename a file or directory. @param fromPath: The current name of the path. @type fromPath: C{list} of C{unicode} @param toPath: The desired new name of the path. @type toPath: C{list} of C{unicode} @return: A Deferred which fires when the path has been renamed, or which fails if the path cannot be renamed. """ def access(path): """ Determine whether access to the given path is allowed. @param path: The path, as a list of segments @return: A Deferred which fires with None if access is allowed or which fails with a specific exception type if access is denied. """ def stat(path, keys=()): """ Retrieve information about the given path. This is like list, except it will never return results about child paths. """ def list(path, keys=()): """ Retrieve information about the given path. If the path represents a non-directory, the result list should have only one entry with information about that non-directory. Otherwise, the result list should have an element for each child of the directory. @param path: The path, as a list of segments, to list @type path: C{list} of C{unicode} or C{bytes} @param keys: A tuple of keys desired in the resulting dictionaries. @return: A Deferred which fires with a list of (name, list), where the name is the name of the entry as a unicode string or bytes and each list contains values corresponding to the requested keys. The following are possible elements of keys, and the values which should be returned for them: - C{'size'}: size in bytes, as an integer (this is kinda required) - C{'directory'}: boolean indicating the type of this entry - C{'permissions'}: a bitvector (see os.stat(foo).st_mode) - C{'hardlinks'}: Number of hard links to this entry - C{'modified'}: number of seconds since the epoch since entry was modified - C{'owner'}: string indicating the user owner of this entry - C{'group'}: string indicating the group owner of this entry """ def openForReading(path): """ @param path: The path, as a list of segments, to open @type path: C{list} of C{unicode} @rtype: C{Deferred} which will fire with L{IReadFile} """ def openForWriting(path): """ @param path: The path, as a list of segments, to open @type path: C{list} of C{unicode} @rtype: C{Deferred} which will fire with L{IWriteFile} """ class IReadFile(Interface): """ A file out of which bytes may be read. """ def send(consumer): """ Produce the contents of the given path to the given consumer. This method may only be invoked once on each provider. @type consumer: C{IConsumer} @return: A Deferred which fires when the file has been consumed completely. """ class IWriteFile(Interface): """ A file into which bytes may be written. """ def receive(): """ Create a consumer which will write to this file. This method may only be invoked once on each provider. @rtype: C{Deferred} of C{IConsumer} """ def close(): """ Perform any post-write work that needs to be done. This method may only be invoked once on each provider, and will always be invoked after receive(). @rtype: C{Deferred} of anything: the value is ignored. The FTP client will not see their upload request complete until this Deferred has been fired. """ def _getgroups(uid): """ Return the primary and supplementary groups for the given UID. @type uid: C{int} """ result = [] pwent = pwd.getpwuid(uid) result.append(pwent.pw_gid) for grent in grp.getgrall(): if pwent.pw_name in grent.gr_mem: result.append(grent.gr_gid) return result def _testPermissions(uid, gid, spath, mode="r"): """ checks to see if uid has proper permissions to access path with mode @type uid: C{int} @param uid: numeric user id @type gid: C{int} @param gid: numeric group id @type spath: C{str} @param spath: the path on the server to test @type mode: C{str} @param mode: 'r' or 'w' (read or write) @rtype: C{bool} @return: True if the given credentials have the specified form of access to the given path """ if mode == "r": usr = stat.S_IRUSR grp = stat.S_IRGRP oth = stat.S_IROTH amode = os.R_OK elif mode == "w": usr = stat.S_IWUSR grp = stat.S_IWGRP oth = stat.S_IWOTH amode = os.W_OK else: raise ValueError(f"Invalid mode {mode!r}: must specify 'r' or 'w'") access = False if os.path.exists(spath): if uid == 0: access = True else: s = os.stat(spath) if usr & s.st_mode and uid == s.st_uid: access = True elif grp & s.st_mode and gid in _getgroups(uid): access = True elif oth & s.st_mode: access = True if access: if not os.access(spath, amode): access = False log.msg( "Filesystem grants permission to UID %d but it is " "inaccessible to me running as UID %d" % (uid, os.getuid()) ) return access @implementer(IFTPShell) class FTPAnonymousShell: """ An anonymous implementation of IFTPShell @type filesystemRoot: L{twisted.python.filepath.FilePath} @ivar filesystemRoot: The path which is considered the root of this shell. """ def __init__(self, filesystemRoot): self.filesystemRoot = filesystemRoot def _path(self, path): return self.filesystemRoot.descendant(path) def makeDirectory(self, path): return defer.fail(AnonUserDeniedError()) def removeDirectory(self, path): return defer.fail(AnonUserDeniedError()) def removeFile(self, path): return defer.fail(AnonUserDeniedError()) def rename(self, fromPath, toPath): return defer.fail(AnonUserDeniedError()) def receive(self, path): path = self._path(path) return defer.fail(AnonUserDeniedError()) def openForReading(self, path): """ Open C{path} for reading. @param path: The path, as a list of segments, to open. @type path: C{list} of C{unicode} @return: A L{Deferred} is returned that will fire with an object implementing L{IReadFile} if the file is successfully opened. If C{path} is a directory, or if an exception is raised while trying to open the file, the L{Deferred} will fire with an error. """ p = self._path(path) if p.isdir(): # Normally, we would only check for EISDIR in open, but win32 # returns EACCES in this case, so we check before return defer.fail(IsADirectoryError(path)) try: f = p.open("r") except OSError as e: return errnoToFailure(e.errno, path) except BaseException: return defer.fail() else: return defer.succeed(_FileReader(f)) def openForWriting(self, path): """ Reject write attempts by anonymous users with L{PermissionDeniedError}. """ return defer.fail(PermissionDeniedError("STOR not allowed")) def access(self, path): p = self._path(path) if not p.exists(): # Again, win32 doesn't report a sane error after, so let's fail # early if we can return defer.fail(FileNotFoundError(path)) # For now, just see if we can os.listdir() it try: p.listdir() except OSError as e: return errnoToFailure(e.errno, path) except BaseException: return defer.fail() else: return defer.succeed(None) def stat(self, path, keys=()): p = self._path(path) if p.isdir(): try: statResult = self._statNode(p, keys) except OSError as e: return errnoToFailure(e.errno, path) except BaseException: return defer.fail() else: return defer.succeed(statResult) else: return self.list(path, keys).addCallback(lambda res: res[0][1]) def list(self, path, keys=()): """ Return the list of files at given C{path}, adding C{keys} stat informations if specified. @param path: the directory or file to check. @type path: C{str} @param keys: the list of desired metadata @type keys: C{list} of C{str} """ filePath = self._path(path) if filePath.isdir(): entries = filePath.listdir() fileEntries = [filePath.child(p) for p in entries] elif filePath.isfile(): entries = [os.path.join(*filePath.segmentsFrom(self.filesystemRoot))] fileEntries = [filePath] else: return defer.fail(FileNotFoundError(path)) results = [] for fileName, filePath in zip(entries, fileEntries): ent = [] results.append((fileName, ent)) if keys: try: ent.extend(self._statNode(filePath, keys)) except OSError as e: return errnoToFailure(e.errno, fileName) except BaseException: return defer.fail() return defer.succeed(results) def _statNode(self, filePath, keys): """ Shortcut method to get stat info on a node. @param filePath: the node to stat. @type filePath: C{filepath.FilePath} @param keys: the stat keys to get. @type keys: C{iterable} """ filePath.restat() return [getattr(self, "_stat_" + k)(filePath) for k in keys] def _stat_size(self, fp): """ Get the filepath's size as an int @param fp: L{twisted.python.filepath.FilePath} @return: C{int} representing the size """ return fp.getsize() def _stat_permissions(self, fp): """ Get the filepath's permissions object @param fp: L{twisted.python.filepath.FilePath} @return: L{twisted.python.filepath.Permissions} of C{fp} """ return fp.getPermissions() def _stat_hardlinks(self, fp): """ Get the number of hardlinks for the filepath - if the number of hardlinks is not yet implemented (say in Windows), just return 0 since stat-ing a file in Windows seems to return C{st_nlink=0}. (Reference: U{http://stackoverflow.com/questions/5275731/os-stat-on-windows}) @param fp: L{twisted.python.filepath.FilePath} @return: C{int} representing the number of hardlinks """ try: return fp.getNumberOfHardLinks() except NotImplementedError: return 0 def _stat_modified(self, fp): """ Get the filepath's last modified date @param fp: L{twisted.python.filepath.FilePath} @return: C{int} as seconds since the epoch """ return fp.getModificationTime() def _stat_owner(self, fp): """ Get the filepath's owner's username. If this is not implemented (say in Windows) return the string "0" since stat-ing a file in Windows seems to return C{st_uid=0}. (Reference: U{http://stackoverflow.com/questions/5275731/os-stat-on-windows}) @param fp: L{twisted.python.filepath.FilePath} @return: C{str} representing the owner's username """ try: userID = fp.getUserID() except NotImplementedError: return "0" else: if pwd is not None: try: return pwd.getpwuid(userID)[0] except KeyError: pass return str(userID) def _stat_group(self, fp): """ Get the filepath's owner's group. If this is not implemented (say in Windows) return the string "0" since stat-ing a file in Windows seems to return C{st_gid=0}. (Reference: U{http://stackoverflow.com/questions/5275731/os-stat-on-windows}) @param fp: L{twisted.python.filepath.FilePath} @return: C{str} representing the owner's group """ try: groupID = fp.getGroupID() except NotImplementedError: return "0" else: if grp is not None: try: return grp.getgrgid(groupID)[0] except KeyError: pass return str(groupID) def _stat_directory(self, fp): """ Get whether the filepath is a directory @param fp: L{twisted.python.filepath.FilePath} @return: C{bool} """ return fp.isdir() @implementer(IReadFile) class _FileReader: def __init__(self, fObj): self.fObj = fObj self._send = False def _close(self, passthrough): self._send = True self.fObj.close() return passthrough def send(self, consumer): assert not self._send, "Can only call IReadFile.send *once* per instance" self._send = True d = basic.FileSender().beginFileTransfer(self.fObj, consumer) d.addBoth(self._close) return d class FTPShell(FTPAnonymousShell): """ An authenticated implementation of L{IFTPShell}. """ def makeDirectory(self, path): p = self._path(path) try: p.makedirs() except OSError as e: return errnoToFailure(e.errno, path) except BaseException: return defer.fail() else: return defer.succeed(None) def removeDirectory(self, path): p = self._path(path) if p.isfile(): # Win32 returns the wrong errno when rmdir is called on a file # instead of a directory, so as we have the info here, let's fail # early with a pertinent error return defer.fail(IsNotADirectoryError(path)) try: os.rmdir(p.path) except OSError as e: return errnoToFailure(e.errno, path) except BaseException: return defer.fail() else: return defer.succeed(None) def removeFile(self, path): p = self._path(path) if p.isdir(): # Win32 returns the wrong errno when remove is called on a # directory instead of a file, so as we have the info here, # let's fail early with a pertinent error return defer.fail(IsADirectoryError(path)) try: p.remove() except OSError as e: return errnoToFailure(e.errno, path) except BaseException: return defer.fail() else: return defer.succeed(None) def rename(self, fromPath, toPath): fp = self._path(fromPath) tp = self._path(toPath) try: os.rename(fp.path, tp.path) except OSError as e: return errnoToFailure(e.errno, fromPath) except BaseException: return defer.fail() else: return defer.succeed(None) def openForWriting(self, path): """ Open C{path} for writing. @param path: The path, as a list of segments, to open. @type path: C{list} of C{unicode} @return: A L{Deferred} is returned that will fire with an object implementing L{IWriteFile} if the file is successfully opened. If C{path} is a directory, or if an exception is raised while trying to open the file, the L{Deferred} will fire with an error. """ p = self._path(path) if p.isdir(): # Normally, we would only check for EISDIR in open, but win32 # returns EACCES in this case, so we check before return defer.fail(IsADirectoryError(path)) try: fObj = p.open("w") except OSError as e: return errnoToFailure(e.errno, path) except BaseException: return defer.fail() return defer.succeed(_FileWriter(fObj)) @implementer(IWriteFile) class _FileWriter: def __init__(self, fObj): self.fObj = fObj self._receive = False def receive(self): assert not self._receive, "Can only call IWriteFile.receive *once* per instance" self._receive = True # FileConsumer will close the file object return defer.succeed(FileConsumer(self.fObj)) def close(self): return defer.succeed(None) @implementer(portal.IRealm) class BaseFTPRealm: """ Base class for simple FTP realms which provides an easy hook for specifying the home directory for each user. """ def __init__(self, anonymousRoot): self.anonymousRoot = filepath.FilePath(anonymousRoot) def getHomeDirectory(self, avatarId): """ Return a L{FilePath} representing the home directory of the given avatar. Override this in a subclass. @param avatarId: A user identifier returned from a credentials checker. @type avatarId: C{str} @rtype: L{FilePath} """ raise NotImplementedError( f"{self.__class__!r} did not override getHomeDirectory" ) def requestAvatar(self, avatarId, mind, *interfaces): for iface in interfaces: if iface is IFTPShell: if avatarId is checkers.ANONYMOUS: avatar = FTPAnonymousShell(self.anonymousRoot) else: avatar = FTPShell(self.getHomeDirectory(avatarId)) return (IFTPShell, avatar, getattr(avatar, "logout", lambda: None)) raise NotImplementedError("Only IFTPShell interface is supported by this realm") class FTPRealm(BaseFTPRealm): """ @type anonymousRoot: L{twisted.python.filepath.FilePath} @ivar anonymousRoot: Root of the filesystem to which anonymous users will be granted access. @type userHome: L{filepath.FilePath} @ivar userHome: Root of the filesystem containing user home directories. """ def __init__(self, anonymousRoot, userHome="/home"): BaseFTPRealm.__init__(self, anonymousRoot) self.userHome = filepath.FilePath(userHome) def getHomeDirectory(self, avatarId): """ Use C{avatarId} as a single path segment to construct a child of C{self.userHome} and return that child. """ return self.userHome.child(avatarId) class SystemFTPRealm(BaseFTPRealm): """ L{SystemFTPRealm} uses system user account information to decide what the home directory for a particular avatarId is. This works on POSIX but probably is not reliable on Windows. """ def getHomeDirectory(self, avatarId): """ Return the system-defined home directory of the system user account with the name C{avatarId}. """ path = os.path.expanduser("~" + avatarId) if path.startswith("~"): raise cred_error.UnauthorizedLogin() return filepath.FilePath(path) # --- FTP CLIENT ------------------------------------------------------------- #### # And now for the client... # Notes: # * Reference: http://cr.yp.to/ftp.html # * FIXME: Does not support pipelining (which is not supported by all # servers anyway). This isn't a functionality limitation, just a # small performance issue. # * Only has a rudimentary understanding of FTP response codes (although # the full response is passed to the caller if they so choose). # * Assumes that USER and PASS should always be sent # * Always sets TYPE I (binary mode) # * Doesn't understand any of the weird, obscure TELNET stuff (\377...) # * FIXME: Doesn't share any code with the FTPServer class ConnectionLost(FTPError): pass class CommandFailed(FTPError): pass class BadResponse(FTPError): pass class UnexpectedResponse(FTPError): pass class UnexpectedData(FTPError): pass class FTPCommand: def __init__(self, text=None, public=0): self.text = text self.deferred = defer.Deferred() self.ready = 1 self.public = public self.transferDeferred = None def fail(self, failure): if self.public: self.deferred.errback(failure) class ProtocolWrapper(protocol.Protocol): def __init__(self, original, deferred): self.original = original self.deferred = deferred def makeConnection(self, transport): self.original.makeConnection(transport) def dataReceived(self, data): self.original.dataReceived(data) def connectionLost(self, reason): self.original.connectionLost(reason) # Signal that transfer has completed self.deferred.callback(None) class IFinishableConsumer(interfaces.IConsumer): """ A Consumer for producers that finish. @since: 11.0 """ def finish(): """ The producer has finished producing. """ @implementer(IFinishableConsumer) class SenderProtocol(protocol.Protocol): def __init__(self): # Fired upon connection self.connectedDeferred = defer.Deferred() # Fired upon disconnection self.deferred = defer.Deferred() # Protocol stuff def dataReceived(self, data): raise UnexpectedData( "Received data from the server on a " "send-only data-connection" ) def makeConnection(self, transport): protocol.Protocol.makeConnection(self, transport) self.connectedDeferred.callback(self) def connectionLost(self, reason): if reason.check(error.ConnectionDone): self.deferred.callback("connection done") else: self.deferred.errback(reason) # IFinishableConsumer stuff def write(self, data): self.transport.write(data) def registerProducer(self, producer, streaming): """ Register the given producer with our transport. """ self.transport.registerProducer(producer, streaming) def unregisterProducer(self): """ Unregister the previously registered producer. """ self.transport.unregisterProducer() def finish(self): self.transport.loseConnection() def decodeHostPort(line): """ Decode an FTP response specifying a host and port. @return: a 2-tuple of (host, port). """ abcdef = re.sub("[^0-9, ]", "", line) parsed = [int(p.strip()) for p in abcdef.split(",")] for x in parsed: if x < 0 or x > 255: raise ValueError("Out of range", line, x) a, b, c, d, e, f = parsed host = f"{a}.{b}.{c}.{d}" port = (int(e) << 8) + int(f) return host, port def encodeHostPort(host, port): numbers = host.split(".") + [str(port >> 8), str(port % 256)] return ",".join(numbers) def _unwrapFirstError(failure): failure.trap(defer.FirstError) return failure.value.subFailure class FTPDataPortFactory(protocol.ServerFactory): """ Factory for data connections that use the PORT command (i.e. "active" transfers) """ noisy = False def buildProtocol(self, addr): # This is a bit hackish -- we already have a Protocol instance, # so just return it instead of making a new one # FIXME: Reject connections from the wrong address/port # (potential security problem) self.protocol.factory = self self.port.loseConnection() return self.protocol class FTPClientBasic(basic.LineReceiver): """ Foundations of an FTP client. """ debug = False _encoding = "latin-1" def __init__(self): self.actionQueue = [] self.greeting = None self.nextDeferred = defer.Deferred().addCallback(self._cb_greeting) self.nextDeferred.addErrback(self.fail) self.response = [] self._failed = 0 def fail(self, error): """ Give an error to any queued deferreds. """ self._fail(error) def _fail(self, error): """ Errback all queued deferreds. """ if self._failed: # We're recursing; bail out here for simplicity return error self._failed = 1 if self.nextDeferred: try: self.nextDeferred.errback( failure.Failure(ConnectionLost("FTP connection lost", error)) ) except defer.AlreadyCalledError: pass for ftpCommand in self.actionQueue: ftpCommand.fail( failure.Failure(ConnectionLost("FTP connection lost", error)) ) return error def _cb_greeting(self, greeting): self.greeting = greeting def sendLine(self, line): """ Sends a line, unless line is None. @param line: Line to send @type line: L{bytes} or L{unicode} """ if line is None: return elif isinstance(line, str): line = line.encode(self._encoding) basic.LineReceiver.sendLine(self, line) def sendNextCommand(self): """ (Private) Processes the next command in the queue. """ ftpCommand = self.popCommandQueue() if ftpCommand is None: self.nextDeferred = None return if not ftpCommand.ready: self.actionQueue.insert(0, ftpCommand) reactor.callLater(1.0, self.sendNextCommand) self.nextDeferred = None return # FIXME: this if block doesn't belong in FTPClientBasic, it belongs in # FTPClient. if ftpCommand.text == "PORT": self.generatePortCommand(ftpCommand) if self.debug: log.msg("<-- %s" % ftpCommand.text) self.nextDeferred = ftpCommand.deferred self.sendLine(ftpCommand.text) def queueCommand(self, ftpCommand): """ Add an FTPCommand object to the queue. If it's the only thing in the queue, and we are connected and we aren't waiting for a response of an earlier command, the command will be sent immediately. @param ftpCommand: an L{FTPCommand} """ self.actionQueue.append(ftpCommand) if ( len(self.actionQueue) == 1 and self.transport is not None and self.nextDeferred is None ): self.sendNextCommand() def queueStringCommand(self, command, public=1): """ Queues a string to be issued as an FTP command @param command: string of an FTP command to queue @param public: a flag intended for internal use by FTPClient. Don't change it unless you know what you're doing. @return: a L{Deferred} that will be called when the response to the command has been received. """ ftpCommand = FTPCommand(command, public) self.queueCommand(ftpCommand) return ftpCommand.deferred def popCommandQueue(self): """ Return the front element of the command queue, or None if empty. """ if self.actionQueue: return self.actionQueue.pop(0) else: return None def queueLogin(self, username, password): """ Login: send the username, send the password. If the password is L{None}, the PASS command won't be sent. Also, if the response to the USER command has a response code of 230 (User logged in), then PASS won't be sent either. """ # Prepare the USER command deferreds = [] userDeferred = self.queueStringCommand("USER " + username, public=0) deferreds.append(userDeferred) # Prepare the PASS command (if a password is given) if password is not None: passwordCmd = FTPCommand("PASS " + password, public=0) self.queueCommand(passwordCmd) deferreds.append(passwordCmd.deferred) # Avoid sending PASS if the response to USER is 230. # (ref: http://cr.yp.to/ftp/user.html#user) def cancelPasswordIfNotNeeded(response): if response[0].startswith("230"): # No password needed! self.actionQueue.remove(passwordCmd) return response userDeferred.addCallback(cancelPasswordIfNotNeeded) # Error handling. for deferred in deferreds: # If something goes wrong, call fail deferred.addErrback(self.fail) # But also swallow the error, so we don't cause spurious errors deferred.addErrback(lambda x: None) def lineReceived(self, line): """ (Private) Parses the response messages from the FTP server. """ # Add this line to the current response if bytes != str: line = line.decode(self._encoding) if self.debug: log.msg("--> %s" % line) self.response.append(line) # Bail out if this isn't the last line of a response # The last line of response starts with 3 digits followed by a space codeIsValid = re.match(r"\d{3} ", line) if not codeIsValid: return code = line[0:3] # Ignore marks if code[0] == "1": return # Check that we were expecting a response if self.nextDeferred is None: self.fail(UnexpectedResponse(self.response)) return # Reset the response response = self.response self.response = [] # Look for a success or error code, and call the appropriate callback if code[0] in ("2", "3"): # Success self.nextDeferred.callback(response) elif code[0] in ("4", "5"): # Failure self.nextDeferred.errback(failure.Failure(CommandFailed(response))) else: # This shouldn't happen unless something screwed up. log.msg(f"Server sent invalid response code {code}") self.nextDeferred.errback(failure.Failure(BadResponse(response))) # Run the next command self.sendNextCommand() def connectionLost(self, reason): self._fail(reason) class _PassiveConnectionFactory(protocol.ClientFactory): noisy = False def __init__(self, protoInstance): self.protoInstance = protoInstance def buildProtocol(self, ignored): self.protoInstance.factory = self return self.protoInstance def clientConnectionFailed(self, connector, reason): e = FTPError("Connection Failed", reason) self.protoInstance.deferred.errback(e) class FTPClient(FTPClientBasic): """ L{FTPClient} is a client implementation of the FTP protocol which exposes FTP commands as methods which return L{Deferred}s. Each command method returns a L{Deferred} which is called back when a successful response code (2xx or 3xx) is received from the server or which is error backed if an error response code (4xx or 5xx) is received from the server or if a protocol violation occurs. If an error response code is received, the L{Deferred} fires with a L{Failure} wrapping a L{CommandFailed} instance. The L{CommandFailed} instance is created with a list of the response lines received from the server. See U{RFC 959<http://www.ietf.org/rfc/rfc959.txt>} for error code definitions. Both active and passive transfers are supported. @ivar passive: See description in __init__. """ connectFactory = reactor.connectTCP # type: ignore[attr-defined] def __init__( self, username="anonymous", password="twisted@twistedmatrix.com", passive=1 ): """ Constructor. I will login as soon as I receive the welcome message from the server. @param username: FTP username @param password: FTP password @param passive: flag that controls if I use active or passive data connections. You can also change this after construction by assigning to C{self.passive}. """ FTPClientBasic.__init__(self) self.queueLogin(username, password) self.passive = passive def fail(self, error): """ Disconnect, and also give an error to any queued deferreds. """ self.transport.loseConnection() self._fail(error) def receiveFromConnection(self, commands, protocol): """ Retrieves a file or listing generated by the given command, feeding it to the given protocol. @param commands: list of strings of FTP commands to execute then receive the results of (e.g. C{LIST}, C{RETR}) @param protocol: A L{Protocol} B{instance} e.g. an L{FTPFileListProtocol}, or something that can be adapted to one. Typically this will be an L{IConsumer} implementation. @return: L{Deferred}. """ protocol = interfaces.IProtocol(protocol) wrapper = ProtocolWrapper(protocol, defer.Deferred()) return self._openDataConnection(commands, wrapper) def queueLogin(self, username, password): """ Login: send the username, send the password, and set retrieval mode to binary """ FTPClientBasic.queueLogin(self, username, password) d = self.queueStringCommand("TYPE I", public=0) # If something goes wrong, call fail d.addErrback(self.fail) # But also swallow the error, so we don't cause spurious errors d.addErrback(lambda x: None) def sendToConnection(self, commands): """ XXX @return: A tuple of two L{Deferred}s: - L{Deferred} L{IFinishableConsumer}. You must call the C{finish} method on the IFinishableConsumer when the file is completely transferred. - L{Deferred} list of control-connection responses. """ s = SenderProtocol() r = self._openDataConnection(commands, s) return (s.connectedDeferred, r) def _openDataConnection(self, commands, protocol): """ This method returns a DeferredList. """ cmds = [FTPCommand(command, public=1) for command in commands] cmdsDeferred = defer.DeferredList( [cmd.deferred for cmd in cmds], fireOnOneErrback=True, consumeErrors=True ) cmdsDeferred.addErrback(_unwrapFirstError) if self.passive: # Hack: use a mutable object to sneak a variable out of the # scope of doPassive _mutable = [None] def doPassive(response): """Connect to the port specified in the response to PASV""" host, port = decodeHostPort(response[-1][4:]) f = _PassiveConnectionFactory(protocol) _mutable[0] = self.connectFactory(host, port, f) pasvCmd = FTPCommand("PASV") self.queueCommand(pasvCmd) pasvCmd.deferred.addCallback(doPassive).addErrback(self.fail) results = [cmdsDeferred, pasvCmd.deferred, protocol.deferred] d = defer.DeferredList(results, fireOnOneErrback=True, consumeErrors=True) d.addErrback(_unwrapFirstError) # Ensure the connection is always closed def close(x, m=_mutable): m[0] and m[0].disconnect() return x d.addBoth(close) else: # We just place a marker command in the queue, and will fill in # the host and port numbers later (see generatePortCommand) portCmd = FTPCommand("PORT") # Ok, now we jump through a few hoops here. # This is the problem: a transfer is not to be trusted as complete # until we get both the "226 Transfer complete" message on the # control connection, and the data socket is closed. Thus, we use # a DeferredList to make sure we only fire the callback at the # right time. portCmd.transferDeferred = protocol.deferred portCmd.protocol = protocol portCmd.deferred.addErrback(portCmd.transferDeferred.errback) self.queueCommand(portCmd) # Create dummy functions for the next callback to call. # These will also be replaced with real functions in # generatePortCommand. portCmd.loseConnection = lambda result: result portCmd.fail = lambda error: error # Ensure that the connection always gets closed cmdsDeferred.addErrback(lambda e, pc=portCmd: pc.fail(e) or e) results = [cmdsDeferred, portCmd.deferred, portCmd.transferDeferred] d = defer.DeferredList(results, fireOnOneErrback=True, consumeErrors=True) d.addErrback(_unwrapFirstError) for cmd in cmds: self.queueCommand(cmd) return d def generatePortCommand(self, portCmd): """ (Private) Generates the text of a given PORT command. """ # The problem is that we don't create the listening port until we need # it for various reasons, and so we have to muck about to figure out # what interface and port it's listening on, and then finally we can # create the text of the PORT command to send to the FTP server. # FIXME: This method is far too ugly. # FIXME: The best solution is probably to only create the data port # once per FTPClient, and just recycle it for each new download. # This should be ok, because we don't pipeline commands. # Start listening on a port factory = FTPDataPortFactory() factory.protocol = portCmd.protocol listener = reactor.listenTCP(0, factory) factory.port = listener # Ensure we close the listening port if something goes wrong def listenerFail(error, listener=listener): if listener.connected: listener.loseConnection() return error portCmd.fail = listenerFail # Construct crufty FTP magic numbers that represent host & port host = self.transport.getHost().host port = listener.getHost().port portCmd.text = "PORT " + encodeHostPort(host, port) def escapePath(self, path): """ Returns a FTP escaped path (replace newlines with nulls). """ # Escape newline characters return path.replace("\n", "\0") def retrieveFile(self, path, protocol, offset=0): """ Retrieve a file from the given path This method issues the 'RETR' FTP command. The file is fed into the given Protocol instance. The data connection will be passive if self.passive is set. @param path: path to file that you wish to receive. @param protocol: a L{Protocol} instance. @param offset: offset to start downloading from @return: L{Deferred} """ cmds = ["RETR " + self.escapePath(path)] if offset: cmds.insert(0, ("REST " + str(offset))) return self.receiveFromConnection(cmds, protocol) retr = retrieveFile def storeFile(self, path, offset=0): """ Store a file at the given path. This method issues the 'STOR' FTP command. @return: A tuple of two L{Deferred}s: - L{Deferred} L{IFinishableConsumer}. You must call the C{finish} method on the IFinishableConsumer when the file is completely transferred. - L{Deferred} list of control-connection responses. """ cmds = ["STOR " + self.escapePath(path)] if offset: cmds.insert(0, ("REST " + str(offset))) return self.sendToConnection(cmds) stor = storeFile def rename(self, pathFrom, pathTo): """ Rename a file. This method issues the I{RNFR}/I{RNTO} command sequence to rename C{pathFrom} to C{pathTo}. @param pathFrom: the absolute path to the file to be renamed @type pathFrom: C{str} @param pathTo: the absolute path to rename the file to. @type pathTo: C{str} @return: A L{Deferred} which fires when the rename operation has succeeded or failed. If it succeeds, the L{Deferred} is called back with a two-tuple of lists. The first list contains the responses to the I{RNFR} command. The second list contains the responses to the I{RNTO} command. If either I{RNFR} or I{RNTO} fails, the L{Deferred} is errbacked with L{CommandFailed} or L{BadResponse}. @rtype: L{Deferred} @since: 8.2 """ renameFrom = self.queueStringCommand("RNFR " + self.escapePath(pathFrom)) renameTo = self.queueStringCommand("RNTO " + self.escapePath(pathTo)) fromResponse = [] # Use a separate Deferred for the ultimate result so that Deferred # chaining can't interfere with its result. result = defer.Deferred() # Bundle up all the responses result.addCallback(lambda toResponse: (fromResponse, toResponse)) def ebFrom(failure): # Make sure the RNTO doesn't run if the RNFR failed. self.popCommandQueue() result.errback(failure) # Save the RNFR response to pass to the result Deferred later renameFrom.addCallbacks(fromResponse.extend, ebFrom) # Hook up the RNTO to the result Deferred as well renameTo.chainDeferred(result) return result def list(self, path, protocol): """ Retrieve a file listing into the given protocol instance. This method issues the 'LIST' FTP command. @param path: path to get a file listing for. @param protocol: a L{Protocol} instance, probably a L{FTPFileListProtocol} instance. It can cope with most common file listing formats. @return: L{Deferred} """ if path is None: path = "" return self.receiveFromConnection(["LIST " + self.escapePath(path)], protocol) def nlst(self, path, protocol): """ Retrieve a short file listing into the given protocol instance. This method issues the 'NLST' FTP command. NLST (should) return a list of filenames, one per line. @param path: path to get short file listing for. @param protocol: a L{Protocol} instance. """ if path is None: path = "" return self.receiveFromConnection(["NLST " + self.escapePath(path)], protocol) def cwd(self, path): """ Issues the CWD (Change Working Directory) command. @return: a L{Deferred} that will be called when done. """ return self.queueStringCommand("CWD " + self.escapePath(path)) def makeDirectory(self, path): """ Make a directory This method issues the MKD command. @param path: The path to the directory to create. @type path: C{str} @return: A L{Deferred} which fires when the server responds. If the directory is created, the L{Deferred} is called back with the server response. If the server response indicates the directory was not created, the L{Deferred} is errbacked with a L{Failure} wrapping L{CommandFailed} or L{BadResponse}. @rtype: L{Deferred} @since: 8.2 """ return self.queueStringCommand("MKD " + self.escapePath(path)) def removeFile(self, path): """ Delete a file on the server. L{removeFile} issues a I{DELE} command to the server to remove the indicated file. Note that this command cannot remove a directory. @param path: The path to the file to delete. May be relative to the current dir. @type path: C{str} @return: A L{Deferred} which fires when the server responds. On error, it is errbacked with either L{CommandFailed} or L{BadResponse}. On success, it is called back with a list of response lines. @rtype: L{Deferred} @since: 8.2 """ return self.queueStringCommand("DELE " + self.escapePath(path)) def removeDirectory(self, path): """ Delete a directory on the server. L{removeDirectory} issues a I{RMD} command to the server to remove the indicated directory. Described in RFC959. @param path: The path to the directory to delete. May be relative to the current working directory. @type path: C{str} @return: A L{Deferred} which fires when the server responds. On error, it is errbacked with either L{CommandFailed} or L{BadResponse}. On success, it is called back with a list of response lines. @rtype: L{Deferred} @since: 11.1 """ return self.queueStringCommand("RMD " + self.escapePath(path)) def cdup(self): """ Issues the CDUP (Change Directory UP) command. @return: a L{Deferred} that will be called when done. """ return self.queueStringCommand("CDUP") def pwd(self): """ Issues the PWD (Print Working Directory) command. The L{getDirectory} does the same job but automatically parses the result. @return: a L{Deferred} that will be called when done. It is up to the caller to interpret the response, but the L{parsePWDResponse} method in this module should work. """ return self.queueStringCommand("PWD") def getDirectory(self): """ Returns the current remote directory. @return: a L{Deferred} that will be called back with a C{str} giving the remote directory or which will errback with L{CommandFailed} if an error response is returned. """ def cbParse(result): try: # The only valid code is 257 if int(result[0].split(" ", 1)[0]) != 257: raise ValueError except (IndexError, ValueError): return failure.Failure(CommandFailed(result)) path = parsePWDResponse(result[0]) if path is None: return failure.Failure(CommandFailed(result)) return path return self.pwd().addCallback(cbParse) def quit(self): """ Issues the I{QUIT} command. @return: A L{Deferred} that fires when the server acknowledges the I{QUIT} command. The transport should not be disconnected until this L{Deferred} fires. """ return self.queueStringCommand("QUIT") class FTPFileListProtocol(basic.LineReceiver): """ Parser for standard FTP file listings This is the evil required to match:: -rw-r--r-- 1 root other 531 Jan 29 03:26 README If you need different evil for a wacky FTP server, you can override either C{fileLinePattern} or C{parseDirectoryLine()}. It populates the instance attribute self.files, which is a list containing dicts with the following keys (examples from the above line): - filetype: e.g. 'd' for directories, or '-' for an ordinary file - perms: e.g. 'rw-r--r--' - nlinks: e.g. 1 - owner: e.g. 'root' - group: e.g. 'other' - size: e.g. 531 - date: e.g. 'Jan 29 03:26' - filename: e.g. 'README' - linktarget: e.g. 'some/file' Note that the 'date' value will be formatted differently depending on the date. Check U{http://cr.yp.to/ftp.html} if you really want to try to parse it. It also matches the following:: -rw-r--r-- 1 root other 531 Jan 29 03:26 I HAVE\\ SPACE - filename: e.g. 'I HAVE SPACE' -rw-r--r-- 1 root other 531 Jan 29 03:26 LINK -> TARGET - filename: e.g. 'LINK' - linktarget: e.g. 'TARGET' -rw-r--r-- 1 root other 531 Jan 29 03:26 N S -> L S - filename: e.g. 'N S' - linktarget: e.g. 'L S' @ivar files: list of dicts describing the files in this listing """ fileLinePattern = re.compile( r"^(?P<filetype>.)(?P<perms>.{9})\s+(?P<nlinks>\d*)\s*" r"(?P<owner>\S+)\s+(?P<group>\S+)\s+(?P<size>\d+)\s+" r"(?P<date>...\s+\d+\s+[\d:]+)\s+(?P<filename>.{1,}?)" r"( -> (?P<linktarget>[^\r]*))?\r?$" ) delimiter = b"\n" _encoding = "latin-1" def __init__(self): self.files = [] def lineReceived(self, line): if bytes != str: line = line.decode(self._encoding) d = self.parseDirectoryLine(line) if d is None: self.unknownLine(line) else: self.addFile(d) def parseDirectoryLine(self, line): """ Return a dictionary of fields, or None if line cannot be parsed. @param line: line of text expected to contain a directory entry @type line: str @return: dict """ match = self.fileLinePattern.match(line) if match is None: return None else: d = match.groupdict() d["filename"] = d["filename"].replace(r"\ ", " ") d["nlinks"] = int(d["nlinks"]) d["size"] = int(d["size"]) if d["linktarget"]: d["linktarget"] = d["linktarget"].replace(r"\ ", " ") return d def addFile(self, info): """ Append file information dictionary to the list of known files. Subclasses can override or extend this method to handle file information differently without affecting the parsing of data from the server. @param info: dictionary containing the parsed representation of the file information @type info: dict """ self.files.append(info) def unknownLine(self, line): """ Deal with received lines which could not be parsed as file information. Subclasses can override this to perform any special processing needed. @param line: unparsable line as received @type line: str """ pass def parsePWDResponse(response): """ Returns the path from a response to a PWD command. Responses typically look like:: 257 "/home/andrew" is current directory. For this example, I will return C{'/home/andrew'}. If I can't find the path, I return L{None}. """ match = re.search('"(.*)"', response) if match: return match.groups()[0] else: return None PK Mb�Z�� * �* protocols/dict.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Dict client protocol implementation. @author: Pavel Pergamenshchik """ from io import BytesIO from twisted.internet import defer, protocol from twisted.protocols import basic from twisted.python import log def parseParam(line): """Chew one dqstring or atom from beginning of line and return (param, remaningline)""" if line == b"": return (None, b"") elif line[0:1] != b'"': # atom mode = 1 else: # dqstring mode = 2 res = b"" io = BytesIO(line) if mode == 2: # skip the opening quote io.read(1) while 1: a = io.read(1) if a == b'"': if mode == 2: io.read(1) # skip the separating space return (res, io.read()) elif a == b"\\": a = io.read(1) if a == b"": return (None, line) # unexpected end of string elif a == b"": if mode == 1: return (res, io.read()) else: return (None, line) # unexpected end of string elif a == b" ": if mode == 1: return (res, io.read()) res += a def makeAtom(line): """Munch a string into an 'atom'""" # FIXME: proper quoting return filter(lambda x: not (x in map(chr, range(33) + [34, 39, 92])), line) def makeWord(s): mustquote = range(33) + [34, 39, 92] result = [] for c in s: if ord(c) in mustquote: result.append(b"\\") result.append(c) s = b"".join(result) return s def parseText(line): if len(line) == 1 and line == b".": return None else: if len(line) > 1 and line[0:2] == b"..": line = line[1:] return line class Definition: """A word definition""" def __init__(self, name, db, dbdesc, text): self.name = name self.db = db self.dbdesc = dbdesc self.text = text # list of strings not terminated by newline class DictClient(basic.LineReceiver): """dict (RFC2229) client""" data = None # multiline data MAX_LENGTH = 1024 state = None mode = None result = None factory = None def __init__(self): self.data = None self.result = None def connectionMade(self): self.state = "conn" self.mode = "command" def sendLine(self, line): """Throw up if the line is longer than 1022 characters""" if len(line) > self.MAX_LENGTH - 2: raise ValueError("DictClient tried to send a too long line") basic.LineReceiver.sendLine(self, line) def lineReceived(self, line): try: line = line.decode("utf-8") except UnicodeError: # garbage received, skip return if self.mode == "text": # we are receiving textual data code = "text" else: if len(line) < 4: log.msg("DictClient got invalid line from server -- %s" % line) self.protocolError("Invalid line from server") self.transport.LoseConnection() return code = int(line[:3]) line = line[4:] method = getattr(self, f"dictCode_{code}_{self.state}", self.dictCode_default) method(line) def dictCode_default(self, line): """Unknown message""" log.msg("DictClient got unexpected message from server -- %s" % line) self.protocolError("Unexpected server message") self.transport.loseConnection() def dictCode_221_ready(self, line): """We are about to get kicked off, do nothing""" pass def dictCode_220_conn(self, line): """Greeting message""" self.state = "ready" self.dictConnected() def dictCode_530_conn(self): self.protocolError("Access denied") self.transport.loseConnection() def dictCode_420_conn(self): self.protocolError("Server temporarily unavailable") self.transport.loseConnection() def dictCode_421_conn(self): self.protocolError("Server shutting down at operator request") self.transport.loseConnection() def sendDefine(self, database, word): """Send a dict DEFINE command""" assert ( self.state == "ready" ), "DictClient.sendDefine called when not in ready state" self.result = ( None # these two are just in case. In "ready" state, result and data ) self.data = None # should be None self.state = "define" command = "DEFINE {} {}".format( makeAtom(database.encode("UTF-8")), makeWord(word.encode("UTF-8")), ) self.sendLine(command) def sendMatch(self, database, strategy, word): """Send a dict MATCH command""" assert ( self.state == "ready" ), "DictClient.sendMatch called when not in ready state" self.result = None self.data = None self.state = "match" command = "MATCH {} {} {}".format( makeAtom(database), makeAtom(strategy), makeAtom(word), ) self.sendLine(command.encode("UTF-8")) def dictCode_550_define(self, line): """Invalid database""" self.mode = "ready" self.defineFailed("Invalid database") def dictCode_550_match(self, line): """Invalid database""" self.mode = "ready" self.matchFailed("Invalid database") def dictCode_551_match(self, line): """Invalid strategy""" self.mode = "ready" self.matchFailed("Invalid strategy") def dictCode_552_define(self, line): """No match""" self.mode = "ready" self.defineFailed("No match") def dictCode_552_match(self, line): """No match""" self.mode = "ready" self.matchFailed("No match") def dictCode_150_define(self, line): """n definitions retrieved""" self.result = [] def dictCode_151_define(self, line): """Definition text follows""" self.mode = "text" (word, line) = parseParam(line) (db, line) = parseParam(line) (dbdesc, line) = parseParam(line) if not (word and db and dbdesc): self.protocolError("Invalid server response") self.transport.loseConnection() else: self.result.append(Definition(word, db, dbdesc, [])) self.data = [] def dictCode_152_match(self, line): """n matches found, text follows""" self.mode = "text" self.result = [] self.data = [] def dictCode_text_define(self, line): """A line of definition text received""" res = parseText(line) if res == None: self.mode = "command" self.result[-1].text = self.data self.data = None else: self.data.append(line) def dictCode_text_match(self, line): """One line of match text received""" def l(s): p1, t = parseParam(s) p2, t = parseParam(t) return (p1, p2) res = parseText(line) if res == None: self.mode = "command" self.result = map(l, self.data) self.data = None else: self.data.append(line) def dictCode_250_define(self, line): """ok""" t = self.result self.result = None self.state = "ready" self.defineDone(t) def dictCode_250_match(self, line): """ok""" t = self.result self.result = None self.state = "ready" self.matchDone(t) def protocolError(self, reason): """override to catch unexpected dict protocol conditions""" pass def dictConnected(self): """override to be notified when the server is ready to accept commands""" pass def defineFailed(self, reason): """override to catch reasonable failure responses to DEFINE""" pass def defineDone(self, result): """override to catch successful DEFINE""" pass def matchFailed(self, reason): """override to catch reasonable failure responses to MATCH""" pass def matchDone(self, result): """override to catch successful MATCH""" pass class InvalidResponse(Exception): pass class DictLookup(DictClient): """Utility class for a single dict transaction. To be used with DictLookupFactory""" def protocolError(self, reason): if not self.factory.done: self.factory.d.errback(InvalidResponse(reason)) self.factory.clientDone() def dictConnected(self): if self.factory.queryType == "define": self.sendDefine(*self.factory.param) elif self.factory.queryType == "match": self.sendMatch(*self.factory.param) def defineFailed(self, reason): self.factory.d.callback([]) self.factory.clientDone() self.transport.loseConnection() def defineDone(self, result): self.factory.d.callback(result) self.factory.clientDone() self.transport.loseConnection() def matchFailed(self, reason): self.factory.d.callback([]) self.factory.clientDone() self.transport.loseConnection() def matchDone(self, result): self.factory.d.callback(result) self.factory.clientDone() self.transport.loseConnection() class DictLookupFactory(protocol.ClientFactory): """Utility factory for a single dict transaction""" protocol = DictLookup done = None def __init__(self, queryType, param, d): self.queryType = queryType self.param = param self.d = d self.done = 0 def clientDone(self): """Called by client when done.""" self.done = 1 del self.d def clientConnectionFailed(self, connector, error): self.d.errback(error) def clientConnectionLost(self, connector, error): if not self.done: self.d.errback(error) def buildProtocol(self, addr): p = self.protocol() p.factory = self return p def define(host, port, database, word): """Look up a word using a dict server""" d = defer.Deferred() factory = DictLookupFactory("define", (database, word), d) from twisted.internet import reactor reactor.connectTCP(host, port, factory) return d def match(host, port, database, strategy, word): """Match a word using a dict server""" d = defer.Deferred() factory = DictLookupFactory("match", (database, strategy, word), d) from twisted.internet import reactor reactor.connectTCP(host, port, factory) return d PK Mb�Z J'��x �x protocols/amp.pynu �[��� # -*- test-case-name: twisted.test.test_amp -*- # Copyright (c) 2005 Divmod, Inc. # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module implements AMP, the Asynchronous Messaging Protocol. AMP is a protocol for sending multiple asynchronous request/response pairs over the same connection. Requests and responses are both collections of key/value pairs. AMP is a very simple protocol which is not an application. This module is a "protocol construction kit" of sorts; it attempts to be the simplest wire-level implementation of Deferreds. AMP provides the following base-level features: - Asynchronous request/response handling (hence the name) - Requests and responses are both key/value pairs - Binary transfer of all data: all data is length-prefixed. Your application will never need to worry about quoting. - Command dispatching (like HTTP Verbs): the protocol is extensible, and multiple AMP sub-protocols can be grouped together easily. The protocol implementation also provides a few additional features which are not part of the core wire protocol, but are nevertheless very useful: - Tight TLS integration, with an included StartTLS command. - Handshaking to other protocols: because AMP has well-defined message boundaries and maintains all incoming and outgoing requests for you, you can start a connection over AMP and then switch to another protocol. This makes it ideal for firewall-traversal applications where you may have only one forwarded port but multiple applications that want to use it. Using AMP with Twisted is simple. Each message is a command, with a response. You begin by defining a command type. Commands specify their input and output in terms of the types that they expect to see in the request and response key-value pairs. Here's an example of a command that adds two integers, 'a' and 'b':: class Sum(amp.Command): arguments = [('a', amp.Integer()), ('b', amp.Integer())] response = [('total', amp.Integer())] Once you have specified a command, you need to make it part of a protocol, and define a responder for it. Here's a 'JustSum' protocol that includes a responder for our 'Sum' command:: class JustSum(amp.AMP): def sum(self, a, b): total = a + b print 'Did a sum: %d + %d = %d' % (a, b, total) return {'total': total} Sum.responder(sum) Later, when you want to actually do a sum, the following expression will return a L{Deferred} which will fire with the result:: ClientCreator(reactor, amp.AMP).connectTCP(...).addCallback( lambda p: p.callRemote(Sum, a=13, b=81)).addCallback( lambda result: result['total']) Command responders may also return Deferreds, causing the response to be sent only once the Deferred fires:: class DelayedSum(amp.AMP): def slowSum(self, a, b): total = a + b result = defer.Deferred() reactor.callLater(3, result.callback, {'total': total}) return result Sum.responder(slowSum) This is transparent to the caller. You can also define the propagation of specific errors in AMP. For example, for the slightly more complicated case of division, we might have to deal with division by zero:: class Divide(amp.Command): arguments = [('numerator', amp.Integer()), ('denominator', amp.Integer())] response = [('result', amp.Float())] errors = {ZeroDivisionError: 'ZERO_DIVISION'} The 'errors' mapping here tells AMP that if a responder to Divide emits a L{ZeroDivisionError}, then the other side should be informed that an error of the type 'ZERO_DIVISION' has occurred. Writing a responder which takes advantage of this is very simple - just raise your exception normally:: class JustDivide(amp.AMP): def divide(self, numerator, denominator): result = numerator / denominator print 'Divided: %d / %d = %d' % (numerator, denominator, total) return {'result': result} Divide.responder(divide) On the client side, the errors mapping will be used to determine what the 'ZERO_DIVISION' error means, and translated into an asynchronous exception, which can be handled normally as any L{Deferred} would be:: def trapZero(result): result.trap(ZeroDivisionError) print "Divided by zero: returning INF" return 1e1000 ClientCreator(reactor, amp.AMP).connectTCP(...).addCallback( lambda p: p.callRemote(Divide, numerator=1234, denominator=0) ).addErrback(trapZero) For a complete, runnable example of both of these commands, see the files in the Twisted repository:: doc/core/examples/ampserver.py doc/core/examples/ampclient.py On the wire, AMP is a protocol which uses 2-byte lengths to prefix keys and values, and empty keys to separate messages:: <2-byte length><key><2-byte length><value> <2-byte length><key><2-byte length><value> ... <2-byte length><key><2-byte length><value> <NUL><NUL> # Empty Key == End of Message And so on. Because it's tedious to refer to lengths and NULs constantly, the documentation will refer to packets as if they were newline delimited, like so:: C: _command: sum C: _ask: ef639e5c892ccb54 C: a: 13 C: b: 81 S: _answer: ef639e5c892ccb54 S: total: 94 Notes: In general, the order of keys is arbitrary. Specific uses of AMP may impose an ordering requirement, but unless this is specified explicitly, any ordering may be generated and any ordering must be accepted. This applies to the command-related keys I{_command} and I{_ask} as well as any other keys. Values are limited to the maximum encodable size in a 16-bit length, 65535 bytes. Keys are limited to the maximum encodable size in a 8-bit length, 255 bytes. Note that we still use 2-byte lengths to encode keys. This small redundancy has several features: - If an implementation becomes confused and starts emitting corrupt data, or gets keys confused with values, many common errors will be signalled immediately instead of delivering obviously corrupt packets. - A single NUL will separate every key, and a double NUL separates messages. This provides some redundancy when debugging traffic dumps. - NULs will be present at regular intervals along the protocol, providing some padding for otherwise braindead C implementations of the protocol, so that <stdio.h> string functions will see the NUL and stop. - This makes it possible to run an AMP server on a port also used by a plain-text protocol, and easily distinguish between non-AMP clients (like web browsers) which issue non-NUL as the first byte, and AMP clients, which always issue NUL as the first byte. @var MAX_VALUE_LENGTH: The maximum length of a message. @type MAX_VALUE_LENGTH: L{int} @var ASK: Marker for an Ask packet. @type ASK: L{bytes} @var ANSWER: Marker for an Answer packet. @type ANSWER: L{bytes} @var COMMAND: Marker for a Command packet. @type COMMAND: L{bytes} @var ERROR: Marker for an AMP box of error type. @type ERROR: L{bytes} @var ERROR_CODE: Marker for an AMP box containing the code of an error. @type ERROR_CODE: L{bytes} @var ERROR_DESCRIPTION: Marker for an AMP box containing the description of the error. @type ERROR_DESCRIPTION: L{bytes} """ import datetime import decimal import warnings from functools import partial from io import BytesIO from itertools import count from struct import pack from types import MethodType from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union from zope.interface import Interface, implementer from twisted.internet.defer import Deferred, fail, maybeDeferred from twisted.internet.error import ConnectionClosed, ConnectionLost, PeerVerifyError from twisted.internet.interfaces import IFileDescriptorReceiver from twisted.internet.main import CONNECTION_LOST from twisted.internet.protocol import Protocol from twisted.protocols.basic import Int16StringReceiver, StatefulStringProtocol from twisted.python import filepath, log from twisted.python._tzhelper import ( UTC as utc, FixedOffsetTimeZone as _FixedOffsetTZInfo, ) from twisted.python.compat import nativeString from twisted.python.failure import Failure from twisted.python.reflect import accumulateClassDict try: from twisted.internet import ssl as _ssl if _ssl.supported: from twisted.internet.ssl import DN, Certificate, CertificateOptions, KeyPair else: ssl = None except ImportError: ssl = None else: ssl = _ssl __all__ = [ "AMP", "ANSWER", "ASK", "AmpBox", "AmpError", "AmpList", "Argument", "BadLocalReturn", "BinaryBoxProtocol", "Boolean", "Box", "BoxDispatcher", "COMMAND", "Command", "CommandLocator", "Decimal", "Descriptor", "ERROR", "ERROR_CODE", "ERROR_DESCRIPTION", "Float", "IArgumentType", "IBoxReceiver", "IBoxSender", "IResponderLocator", "IncompatibleVersions", "Integer", "InvalidSignature", "ListOf", "MAX_KEY_LENGTH", "MAX_VALUE_LENGTH", "MalformedAmpBox", "NoEmptyBoxes", "OnlyOneTLS", "PROTOCOL_ERRORS", "PYTHON_KEYWORDS", "Path", "ProtocolSwitchCommand", "ProtocolSwitched", "QuitBox", "RemoteAmpError", "SimpleStringLocator", "StartTLS", "String", "TooLong", "UNHANDLED_ERROR_CODE", "UNKNOWN_ERROR_CODE", "UnhandledCommand", "utc", "Unicode", "UnknownRemoteError", "parse", "parseString", ] ASK = b"_ask" ANSWER = b"_answer" COMMAND = b"_command" ERROR = b"_error" ERROR_CODE = b"_error_code" ERROR_DESCRIPTION = b"_error_description" UNKNOWN_ERROR_CODE = b"UNKNOWN" UNHANDLED_ERROR_CODE = b"UNHANDLED" MAX_KEY_LENGTH = 0xFF MAX_VALUE_LENGTH = 0xFFFF class IArgumentType(Interface): """ An L{IArgumentType} can serialize a Python object into an AMP box and deserialize information from an AMP box back into a Python object. @since: 9.0 """ def fromBox(name, strings, objects, proto): """ Given an argument name and an AMP box containing serialized values, extract one or more Python objects and add them to the C{objects} dictionary. @param name: The name associated with this argument. Most commonly this is the key which can be used to find a serialized value in C{strings}. @type name: C{bytes} @param strings: The AMP box from which to extract one or more values. @type strings: C{dict} @param objects: The output dictionary to populate with the value for this argument. The key used will be derived from C{name}. It may differ; in Python 3, for example, the key will be a Unicode/native string. See L{_wireNameToPythonIdentifier}. @type objects: C{dict} @param proto: The protocol instance which received the AMP box being interpreted. Most likely this is an instance of L{AMP}, but this is not guaranteed. @return: L{None} """ def toBox(name, strings, objects, proto): """ Given an argument name and a dictionary containing structured Python objects, serialize values into one or more strings and add them to the C{strings} dictionary. @param name: The name associated with this argument. Most commonly this is the key in C{strings} to associate with a C{bytes} giving the serialized form of that object. @type name: C{bytes} @param strings: The AMP box into which to insert one or more strings. @type strings: C{dict} @param objects: The input dictionary from which to extract Python objects to serialize. The key used will be derived from C{name}. It may differ; in Python 3, for example, the key will be a Unicode/native string. See L{_wireNameToPythonIdentifier}. @type objects: C{dict} @param proto: The protocol instance which will send the AMP box once it is fully populated. Most likely this is an instance of L{AMP}, but this is not guaranteed. @return: L{None} """ class IBoxSender(Interface): """ A transport which can send L{AmpBox} objects. """ def sendBox(box): """ Send an L{AmpBox}. @raise ProtocolSwitched: if the underlying protocol has been switched. @raise ConnectionLost: if the underlying connection has already been lost. """ def unhandledError(failure): """ An unhandled error occurred in response to a box. Log it appropriately. @param failure: a L{Failure} describing the error that occurred. """ class IBoxReceiver(Interface): """ An application object which can receive L{AmpBox} objects and dispatch them appropriately. """ def startReceivingBoxes(boxSender): """ The L{IBoxReceiver.ampBoxReceived} method will start being called; boxes may be responded to by responding to the given L{IBoxSender}. @param boxSender: an L{IBoxSender} provider. """ def ampBoxReceived(box): """ A box was received from the transport; dispatch it appropriately. """ def stopReceivingBoxes(reason): """ No further boxes will be received on this connection. @type reason: L{Failure} """ class IResponderLocator(Interface): """ An application object which can look up appropriate responder methods for AMP commands. """ def locateResponder(name): """ Locate a responder method appropriate for the named command. @param name: the wire-level name (commandName) of the AMP command to be responded to. @type name: C{bytes} @return: a 1-argument callable that takes an L{AmpBox} with argument values for the given command, and returns an L{AmpBox} containing argument values for the named command, or a L{Deferred} that fires the same. """ class AmpError(Exception): """ Base class of all Amp-related exceptions. """ class ProtocolSwitched(Exception): """ Connections which have been switched to other protocols can no longer accept traffic at the AMP level. This is raised when you try to send it. """ class OnlyOneTLS(AmpError): """ This is an implementation limitation; TLS may only be started once per connection. """ class NoEmptyBoxes(AmpError): """ You can't have empty boxes on the connection. This is raised when you receive or attempt to send one. """ class InvalidSignature(AmpError): """ You didn't pass all the required arguments. """ class TooLong(AmpError): """ One of the protocol's length limitations was violated. @ivar isKey: true if the string being encoded in a key position, false if it was in a value position. @ivar isLocal: Was the string encoded locally, or received too long from the network? (It's only physically possible to encode "too long" values on the network for keys.) @ivar value: The string that was too long. @ivar keyName: If the string being encoded was in a value position, what key was it being encoded for? """ def __init__(self, isKey, isLocal, value, keyName=None): AmpError.__init__(self) self.isKey = isKey self.isLocal = isLocal self.value = value self.keyName = keyName def __repr__(self) -> str: hdr = self.isKey and "key" or "value" if not self.isKey: hdr += " " + repr(self.keyName) lcl = self.isLocal and "local" or "remote" return "%s %s too long: %d" % (lcl, hdr, len(self.value)) class BadLocalReturn(AmpError): """ A bad value was returned from a local command; we were unable to coerce it. """ def __init__(self, message: str, enclosed: Failure) -> None: AmpError.__init__(self) self.message = message self.enclosed = enclosed def __repr__(self) -> str: return self.message + " " + self.enclosed.getBriefTraceback() __str__ = __repr__ class RemoteAmpError(AmpError): """ This error indicates that something went wrong on the remote end of the connection, and the error was serialized and transmitted to you. """ def __init__(self, errorCode, description, fatal=False, local=None): """Create a remote error with an error code and description. @param errorCode: the AMP error code of this error. @type errorCode: C{bytes} @param description: some text to show to the user. @type description: C{str} @param fatal: a boolean, true if this error should terminate the connection. @param local: a local Failure, if one exists. """ if local: localwhat = " (local)" othertb = local.getBriefTraceback() else: localwhat = "" othertb = "" # Backslash-escape errorCode. Python 3.5 can do this natively # ("backslashescape") but Python 2.7 and Python 3.4 can't. errorCodeForMessage = "".join( f"\\x{c:2x}" if c >= 0x80 else chr(c) for c in errorCode ) if othertb: message = "Code<{}>{}: {}\n{}".format( errorCodeForMessage, localwhat, description, othertb, ) else: message = "Code<{}>{}: {}".format( errorCodeForMessage, localwhat, description ) super().__init__(message) self.local = local self.errorCode = errorCode self.description = description self.fatal = fatal class UnknownRemoteError(RemoteAmpError): """ This means that an error whose type we can't identify was raised from the other side. """ def __init__(self, description): errorCode = UNKNOWN_ERROR_CODE RemoteAmpError.__init__(self, errorCode, description) class MalformedAmpBox(AmpError): """ This error indicates that the wire-level protocol was malformed. """ class UnhandledCommand(AmpError): """ A command received via amp could not be dispatched. """ class IncompatibleVersions(AmpError): """ It was impossible to negotiate a compatible version of the protocol with the other end of the connection. """ PROTOCOL_ERRORS = {UNHANDLED_ERROR_CODE: UnhandledCommand} class AmpBox(dict): """ I am a packet in the AMP protocol, much like a regular bytes:bytes dictionary. """ # be like a regular dictionary don't magically # acquire a __dict__... __slots__: List[str] = [] def __init__(self, *args, **kw): """ Initialize a new L{AmpBox}. In Python 3, keyword arguments MUST be Unicode/native strings whereas in Python 2 they could be either byte strings or Unicode strings. However, all keys of an L{AmpBox} MUST be byte strings, or possible to transparently coerce into byte strings (i.e. Python 2). In Python 3, therefore, native string keys are coerced to byte strings by encoding as ASCII. This can result in C{UnicodeEncodeError} being raised. @param args: See C{dict}, but all keys and values should be C{bytes}. On Python 3, native strings may be used as keys provided they contain only ASCII characters. @param kw: See C{dict}, but all keys and values should be C{bytes}. On Python 3, native strings may be used as keys provided they contain only ASCII characters. @raise UnicodeEncodeError: When a native string key cannot be coerced to an ASCII byte string (Python 3 only). """ super().__init__(*args, **kw) nonByteNames = [n for n in self if not isinstance(n, bytes)] for nonByteName in nonByteNames: byteName = nonByteName.encode("ascii") self[byteName] = self.pop(nonByteName) def copy(self): """ Return another AmpBox just like me. """ newBox = self.__class__() newBox.update(self) return newBox def serialize(self): """ Convert me into a wire-encoded string. @return: a C{bytes} encoded according to the rules described in the module docstring. """ i = sorted(self.items()) L = [] w = L.append for k, v in i: if type(k) == str: raise TypeError("Unicode key not allowed: %r" % k) if type(v) == str: raise TypeError(f"Unicode value for key {k!r} not allowed: {v!r}") if len(k) > MAX_KEY_LENGTH: raise TooLong(True, True, k, None) if len(v) > MAX_VALUE_LENGTH: raise TooLong(False, True, v, k) for kv in k, v: w(pack("!H", len(kv))) w(kv) w(pack("!H", 0)) return b"".join(L) def _sendTo(self, proto): """ Serialize and send this box to an Amp instance. By the time it is being sent, several keys are required. I must have exactly ONE of:: _ask _answer _error If the '_ask' key is set, then the '_command' key must also be set. @param proto: an AMP instance. """ proto.sendBox(self) def __repr__(self) -> str: return f"AmpBox({dict.__repr__(self)})" # amp.Box => AmpBox Box = AmpBox class QuitBox(AmpBox): """ I am an AmpBox that, upon being sent, terminates the connection. """ __slots__: List[str] = [] def __repr__(self) -> str: return f"QuitBox(**{super().__repr__()})" def _sendTo(self, proto): """ Immediately call loseConnection after sending. """ super()._sendTo(proto) proto.transport.loseConnection() class _SwitchBox(AmpBox): """ Implementation detail of ProtocolSwitchCommand: I am an AmpBox which sets up state for the protocol to switch. """ # DON'T set __slots__ here; we do have an attribute. def __init__(self, innerProto, **kw): """ Create a _SwitchBox with the protocol to switch to after being sent. @param innerProto: the protocol instance to switch to. @type innerProto: an IProtocol provider. """ super().__init__(**kw) self.innerProto = innerProto def __repr__(self) -> str: return "_SwitchBox({!r}, **{})".format( self.innerProto, dict.__repr__(self), ) def _sendTo(self, proto): """ Send me; I am the last box on the connection. All further traffic will be over the new protocol. """ super()._sendTo(proto) proto._lockForSwitch() proto._switchTo(self.innerProto) @implementer(IBoxReceiver) class BoxDispatcher: """ A L{BoxDispatcher} dispatches '_ask', '_answer', and '_error' L{AmpBox}es, both incoming and outgoing, to their appropriate destinations. Outgoing commands are converted into L{Deferred}s and outgoing boxes, and associated tracking state to fire those L{Deferred} when '_answer' boxes come back. Incoming '_answer' and '_error' boxes are converted into callbacks and errbacks on those L{Deferred}s, respectively. Incoming '_ask' boxes are converted into method calls on a supplied method locator. @ivar _outstandingRequests: a dictionary mapping request IDs to L{Deferred}s which were returned for those requests. @ivar locator: an object with a L{CommandLocator.locateResponder} method that locates a responder function that takes a Box and returns a result (either a Box or a Deferred which fires one). @ivar boxSender: an object which can send boxes, via the L{_sendBoxCommand} method, such as an L{AMP} instance. @type boxSender: L{IBoxSender} """ _failAllReason = None _outstandingRequests = None _counter = 0 boxSender = None def __init__(self, locator): self._outstandingRequests = {} self.locator = locator def startReceivingBoxes(self, boxSender): """ The given boxSender is going to start calling boxReceived on this L{BoxDispatcher}. @param boxSender: The L{IBoxSender} to send command responses to. """ self.boxSender = boxSender def stopReceivingBoxes(self, reason): """ No further boxes will be received here. Terminate all currently outstanding command deferreds with the given reason. """ self.failAllOutgoing(reason) def failAllOutgoing(self, reason): """ Call the errback on all outstanding requests awaiting responses. @param reason: the Failure instance to pass to those errbacks. """ self._failAllReason = reason OR = self._outstandingRequests.items() self._outstandingRequests = None # we can never send another request for key, value in OR: value.errback(reason) def _nextTag(self): """ Generate protocol-local serial numbers for _ask keys. @return: a string that has not yet been used on this connection. """ self._counter += 1 return b"%x" % (self._counter,) def _sendBoxCommand(self, command, box, requiresAnswer=True): """ Send a command across the wire with the given C{amp.Box}. Mutate the given box to give it any additional keys (_command, _ask) required for the command and request/response machinery, then send it. If requiresAnswer is True, returns a C{Deferred} which fires when a response is received. The C{Deferred} is fired with an C{amp.Box} on success, or with an C{amp.RemoteAmpError} if an error is received. If the Deferred fails and the error is not handled by the caller of this method, the failure will be logged and the connection dropped. @param command: a C{bytes}, the name of the command to issue. @param box: an AmpBox with the arguments for the command. @param requiresAnswer: a boolean. Defaults to True. If True, return a Deferred which will fire when the other side responds to this command. If False, return None and do not ask the other side for acknowledgement. @return: a Deferred which fires the AmpBox that holds the response to this command, or None, as specified by requiresAnswer. @raise ProtocolSwitched: if the protocol has been switched. """ if self._failAllReason is not None: if requiresAnswer: return fail(self._failAllReason) else: return None box[COMMAND] = command tag = self._nextTag() if requiresAnswer: box[ASK] = tag box._sendTo(self.boxSender) if requiresAnswer: result = self._outstandingRequests[tag] = Deferred() else: result = None return result def callRemoteString(self, command, requiresAnswer=True, **kw): """ This is a low-level API, designed only for optimizing simple messages for which the overhead of parsing is too great. @param command: a C{bytes} naming the command. @param kw: arguments to the amp box. @param requiresAnswer: a boolean. Defaults to True. If True, return a Deferred which will fire when the other side responds to this command. If False, return None and do not ask the other side for acknowledgement. @return: a Deferred which fires the AmpBox that holds the response to this command, or None, as specified by requiresAnswer. """ box = Box(kw) return self._sendBoxCommand(command, box, requiresAnswer) def callRemote(self, commandType, *a, **kw): """ This is the primary high-level API for sending messages via AMP. Invoke it with a command and appropriate arguments to send a message to this connection's peer. @param commandType: a subclass of Command. @type commandType: L{type} @param a: Positional (special) parameters taken by the command. Positional parameters will typically not be sent over the wire. The only command included with AMP which uses positional parameters is L{ProtocolSwitchCommand}, which takes the protocol that will be switched to as its first argument. @param kw: Keyword arguments taken by the command. These are the arguments declared in the command's 'arguments' attribute. They will be encoded and sent to the peer as arguments for the L{commandType}. @return: If L{commandType} has a C{requiresAnswer} attribute set to L{False}, then return L{None}. Otherwise, return a L{Deferred} which fires with a dictionary of objects representing the result of this call. Additionally, this L{Deferred} may fail with an exception representing a connection failure, with L{UnknownRemoteError} if the other end of the connection fails for an unknown reason, or with any error specified as a key in L{commandType}'s C{errors} dictionary. """ # XXX this takes command subclasses and not command objects on purpose. # There's really no reason to have all this back-and-forth between # command objects and the protocol, and the extra object being created # (the Command instance) is pointless. Command is kind of like # Interface, and should be more like it. # In other words, the fact that commandType is instantiated here is an # implementation detail. Don't rely on it. try: co = commandType(*a, **kw) except BaseException: return fail() return co._doCommand(self) def unhandledError(self, failure): """ This is a terminal callback called after application code has had a chance to quash any errors. """ return self.boxSender.unhandledError(failure) def _answerReceived(self, box): """ An AMP box was received that answered a command previously sent with L{callRemote}. @param box: an AmpBox with a value for its L{ANSWER} key. """ question = self._outstandingRequests.pop(box[ANSWER]) question.addErrback(self.unhandledError) question.callback(box) def _errorReceived(self, box): """ An AMP box was received that answered a command previously sent with L{callRemote}, with an error. @param box: an L{AmpBox} with a value for its L{ERROR}, L{ERROR_CODE}, and L{ERROR_DESCRIPTION} keys. """ question = self._outstandingRequests.pop(box[ERROR]) question.addErrback(self.unhandledError) errorCode = box[ERROR_CODE] description = box[ERROR_DESCRIPTION] if isinstance(description, bytes): description = description.decode("utf-8", "replace") if errorCode in PROTOCOL_ERRORS: exc = PROTOCOL_ERRORS[errorCode](errorCode, description) else: exc = RemoteAmpError(errorCode, description) question.errback(Failure(exc)) def _commandReceived(self, box): """ @param box: an L{AmpBox} with a value for its L{COMMAND} and L{ASK} keys. """ def formatAnswer(answerBox): answerBox[ANSWER] = box[ASK] return answerBox def formatError(error): if error.check(RemoteAmpError): code = error.value.errorCode desc = error.value.description if isinstance(desc, str): desc = desc.encode("utf-8", "replace") if error.value.fatal: errorBox = QuitBox() else: errorBox = AmpBox() else: errorBox = QuitBox() log.err(error) # here is where server-side logging happens # if the error isn't handled code = UNKNOWN_ERROR_CODE desc = b"Unknown Error" errorBox[ERROR] = box[ASK] errorBox[ERROR_DESCRIPTION] = desc errorBox[ERROR_CODE] = code return errorBox deferred = self.dispatchCommand(box) if ASK in box: deferred.addCallbacks(formatAnswer, formatError) deferred.addCallback(self._safeEmit) deferred.addErrback(self.unhandledError) def ampBoxReceived(self, box): """ An AmpBox was received, representing a command, or an answer to a previously issued command (either successful or erroneous). Respond to it according to its contents. @param box: an AmpBox @raise NoEmptyBoxes: when a box is received that does not contain an '_answer', '_command' / '_ask', or '_error' key; i.e. one which does not fit into the command / response protocol defined by AMP. """ if ANSWER in box: self._answerReceived(box) elif ERROR in box: self._errorReceived(box) elif COMMAND in box: self._commandReceived(box) else: raise NoEmptyBoxes(box) def _safeEmit(self, aBox): """ Emit a box, ignoring L{ProtocolSwitched} and L{ConnectionLost} errors which cannot be usefully handled. """ try: aBox._sendTo(self.boxSender) except (ProtocolSwitched, ConnectionLost): pass def dispatchCommand(self, box): """ A box with a _command key was received. Dispatch it to a local handler call it. @param box: an AmpBox to be dispatched. """ cmd = box[COMMAND] responder = self.locator.locateResponder(cmd) if responder is None: description = f"Unhandled Command: {cmd!r}" return fail( RemoteAmpError( UNHANDLED_ERROR_CODE, description, False, local=Failure(UnhandledCommand()), ) ) return maybeDeferred(responder, box) class _CommandLocatorMeta(type): """ This metaclass keeps track of all of the Command.responder-decorated methods defined since the last CommandLocator subclass was defined. It assumes (usually correctly, but unfortunately not necessarily so) that those commands responders were all declared as methods of the class being defined. Note that this list can be incorrect if users use the Command.responder decorator outside the context of a CommandLocator class declaration. Command responders defined on subclasses are given precedence over those inherited from a base class. The Command.responder decorator explicitly cooperates with this metaclass. """ _currentClassCommands: "List[Tuple[Command, Callable]]" = [] def __new__(cls, name, bases, attrs): commands = cls._currentClassCommands[:] cls._currentClassCommands[:] = [] cd = attrs["_commandDispatch"] = {} subcls = type.__new__(cls, name, bases, attrs) ancestors = list(subcls.__mro__[1:]) ancestors.reverse() for ancestor in ancestors: cd.update(getattr(ancestor, "_commandDispatch", {})) for commandClass, responderFunc in commands: cd[commandClass.commandName] = (commandClass, responderFunc) if bases and (subcls.lookupFunction != CommandLocator.lookupFunction): def locateResponder(self, name): warnings.warn( "Override locateResponder, not lookupFunction.", category=PendingDeprecationWarning, stacklevel=2, ) return self.lookupFunction(name) subcls.locateResponder = locateResponder return subcls @implementer(IResponderLocator) class CommandLocator(metaclass=_CommandLocatorMeta): """ A L{CommandLocator} is a collection of responders to AMP L{Command}s, with the help of the L{Command.responder} decorator. """ def _wrapWithSerialization(self, aCallable, command): """ Wrap aCallable with its command's argument de-serialization and result serialization logic. @param aCallable: a callable with a 'command' attribute, designed to be called with keyword arguments. @param command: the command class whose serialization to use. @return: a 1-arg callable which, when invoked with an AmpBox, will deserialize the argument list and invoke appropriate user code for the callable's command, returning a Deferred which fires with the result or fails with an error. """ def doit(box): kw = command.parseArguments(box, self) def checkKnownErrors(error): key = error.trap(*command.allErrors) code = command.allErrors[key] desc = str(error.value) return Failure( RemoteAmpError(code, desc, key in command.fatalErrors, local=error) ) def makeResponseFor(objects): try: return command.makeResponse(objects, self) except BaseException: # let's helpfully log this. originalFailure = Failure() raise BadLocalReturn( "%r returned %r and %r could not serialize it" % (aCallable, objects, command), originalFailure, ) return ( maybeDeferred(aCallable, **kw) .addCallback(makeResponseFor) .addErrback(checkKnownErrors) ) return doit def lookupFunction(self, name): """ Deprecated synonym for L{CommandLocator.locateResponder} """ if self.__class__.lookupFunction != CommandLocator.lookupFunction: return CommandLocator.locateResponder(self, name) else: warnings.warn( "Call locateResponder, not lookupFunction.", category=PendingDeprecationWarning, stacklevel=2, ) return self.locateResponder(name) def locateResponder(self, name): """ Locate a callable to invoke when executing the named command. @param name: the normalized name (from the wire) of the command. @type name: C{bytes} @return: a 1-argument function that takes a Box and returns a box or a Deferred which fires a Box, for handling the command identified by the given name, or None, if no appropriate responder can be found. """ # Try to find a high-level method to invoke, and if we can't find one, # fall back to a low-level one. cd = self._commandDispatch if name in cd: commandClass, responderFunc = cd[name] responderMethod = MethodType(responderFunc, self) return self._wrapWithSerialization(responderMethod, commandClass) @implementer(IResponderLocator) class SimpleStringLocator: """ Implement the L{AMP.locateResponder} method to do simple, string-based dispatch. """ baseDispatchPrefix = b"amp_" def locateResponder(self, name): """ Locate a callable to invoke when executing the named command. @return: a function with the name C{"amp_" + name} on the same instance, or None if no such function exists. This function will then be called with the L{AmpBox} itself as an argument. @param name: the normalized name (from the wire) of the command. @type name: C{bytes} """ fName = nativeString(self.baseDispatchPrefix + name.upper()) return getattr(self, fName, None) PYTHON_KEYWORDS = [ "and", "del", "for", "is", "raise", "assert", "elif", "from", "lambda", "return", "break", "else", "global", "not", "try", "class", "except", "if", "or", "while", "continue", "exec", "import", "pass", "yield", "def", "finally", "in", "print", ] def _wireNameToPythonIdentifier(key): """ (Private) Normalize an argument name from the wire for use with Python code. If the return value is going to be a python keyword it will be capitalized. If it contains any dashes they will be replaced with underscores. The rationale behind this method is that AMP should be an inherently multi-language protocol, so message keys may contain all manner of bizarre bytes. This is not a complete solution; there are still forms of arguments that this implementation will be unable to parse. However, Python identifiers share a huge raft of properties with identifiers from many other languages, so this is a 'good enough' effort for now. We deal explicitly with dashes because that is the most likely departure: Lisps commonly use dashes to separate method names, so protocols initially implemented in a lisp amp dialect may use dashes in argument or command names. @param key: a C{bytes}, looking something like 'foo-bar-baz' or 'from' @type key: C{bytes} @return: a native string which is a valid python identifier, looking something like 'foo_bar_baz' or 'From'. """ lkey = nativeString(key.replace(b"-", b"_")) if lkey in PYTHON_KEYWORDS: return lkey.title() return lkey @implementer(IArgumentType) class Argument: """ Base-class of all objects that take values from Amp packets and convert them into objects for Python functions. This implementation of L{IArgumentType} provides several higher-level hooks for subclasses to override. See L{toString} and L{fromString} which will be used to define the behavior of L{IArgumentType.toBox} and L{IArgumentType.fromBox}, respectively. """ optional = False def __init__(self, optional=False): """ Create an Argument. @param optional: a boolean indicating whether this argument can be omitted in the protocol. """ self.optional = optional def retrieve(self, d, name, proto): """ Retrieve the given key from the given dictionary, removing it if found. @param d: a dictionary. @param name: a key in I{d}. @param proto: an instance of an AMP. @raise KeyError: if I am not optional and no value was found. @return: d[name]. """ if self.optional: value = d.get(name) if value is not None: del d[name] else: value = d.pop(name) return value def fromBox(self, name, strings, objects, proto): """ Populate an 'out' dictionary with mapping names to Python values decoded from an 'in' AmpBox mapping strings to string values. @param name: the argument name to retrieve @type name: C{bytes} @param strings: The AmpBox to read string(s) from, a mapping of argument names to string values. @type strings: AmpBox @param objects: The dictionary to write object(s) to, a mapping of names to Python objects. Keys will be native strings. @type objects: dict @param proto: an AMP instance. """ st = self.retrieve(strings, name, proto) nk = _wireNameToPythonIdentifier(name) if self.optional and st is None: objects[nk] = None else: objects[nk] = self.fromStringProto(st, proto) def toBox(self, name, strings, objects, proto): """ Populate an 'out' AmpBox with strings encoded from an 'in' dictionary mapping names to Python values. @param name: the argument name to retrieve @type name: C{bytes} @param strings: The AmpBox to write string(s) to, a mapping of argument names to string values. @type strings: AmpBox @param objects: The dictionary to read object(s) from, a mapping of names to Python objects. Keys should be native strings. @type objects: dict @param proto: the protocol we are converting for. @type proto: AMP """ obj = self.retrieve(objects, _wireNameToPythonIdentifier(name), proto) if self.optional and obj is None: # strings[name] = None pass else: strings[name] = self.toStringProto(obj, proto) def fromStringProto(self, inString, proto): """ Convert a string to a Python value. @param inString: the string to convert. @type inString: C{bytes} @param proto: the protocol we are converting for. @type proto: AMP @return: a Python object. """ return self.fromString(inString) def toStringProto(self, inObject, proto): """ Convert a Python object to a string. @param inObject: the object to convert. @param proto: the protocol we are converting for. @type proto: AMP """ return self.toString(inObject) def fromString(self, inString): """ Convert a string to a Python object. Subclasses must implement this. @param inString: the string to convert. @type inString: C{bytes} @return: the decoded value from C{inString} """ def toString(self, inObject): """ Convert a Python object into a string for passing over the network. @param inObject: an object of the type that this Argument is intended to deal with. @return: the wire encoding of inObject @rtype: C{bytes} """ class Integer(Argument): """ Encode any integer values of any size on the wire as the string representation. Example: C{123} becomes C{"123"} """ fromString = int def toString(self, inObject): return b"%d" % (inObject,) class String(Argument): """ Don't do any conversion at all; just pass through 'str'. """ def toString(self, inObject): return inObject def fromString(self, inString): return inString class Float(Argument): """ Encode floating-point values on the wire as their repr. """ fromString = float def toString(self, inString): if not isinstance(inString, float): raise ValueError(f"Bad float value {inString!r}") return str(inString).encode("ascii") class Boolean(Argument): """ Encode True or False as "True" or "False" on the wire. """ def fromString(self, inString): if inString == b"True": return True elif inString == b"False": return False else: raise TypeError(f"Bad boolean value: {inString!r}") def toString(self, inObject): if inObject: return b"True" else: return b"False" class Unicode(String): """ Encode a unicode string on the wire as UTF-8. """ def toString(self, inObject): return String.toString(self, inObject.encode("utf-8")) def fromString(self, inString): return String.fromString(self, inString).decode("utf-8") class Path(Unicode): """ Encode and decode L{filepath.FilePath} instances as paths on the wire. This is really intended for use with subprocess communication tools: exchanging pathnames on different machines over a network is not generally meaningful, but neither is it disallowed; you can use this to communicate about NFS paths, for example. """ def fromString(self, inString): return filepath.FilePath(Unicode.fromString(self, inString)) def toString(self, inObject): return Unicode.toString(self, inObject.asTextMode().path) class ListOf(Argument): """ Encode and decode lists of instances of a single other argument type. For example, if you want to pass:: [3, 7, 9, 15] You can create an argument like this:: ListOf(Integer()) The serialized form of the entire list is subject to the limit imposed by L{MAX_VALUE_LENGTH}. List elements are represented as 16-bit length prefixed strings. The argument type passed to the L{ListOf} initializer is responsible for producing the serialized form of each element. @ivar elementType: The L{Argument} instance used to encode and decode list elements (note, not an arbitrary L{IArgumentType} implementation: arguments must be implemented using only the C{fromString} and C{toString} methods, not the C{fromBox} and C{toBox} methods). @param optional: a boolean indicating whether this argument can be omitted in the protocol. @since: 10.0 """ def __init__(self, elementType, optional=False): self.elementType = elementType Argument.__init__(self, optional) def fromString(self, inString): """ Convert the serialized form of a list of instances of some type back into that list. """ strings = [] parser = Int16StringReceiver() parser.stringReceived = strings.append parser.dataReceived(inString) elementFromString = self.elementType.fromString return [elementFromString(string) for string in strings] def toString(self, inObject): """ Serialize the given list of objects to a single string. """ strings = [] for obj in inObject: serialized = self.elementType.toString(obj) strings.append(pack("!H", len(serialized))) strings.append(serialized) return b"".join(strings) class AmpList(Argument): """ Convert a list of dictionaries into a list of AMP boxes on the wire. For example, if you want to pass:: [{'a': 7, 'b': u'hello'}, {'a': 9, 'b': u'goodbye'}] You might use an AmpList like this in your arguments or response list:: AmpList([('a', Integer()), ('b', Unicode())]) """ def __init__(self, subargs, optional=False): """ Create an AmpList. @param subargs: a list of 2-tuples of ('name', argument) describing the schema of the dictionaries in the sequence of amp boxes. @type subargs: A C{list} of (C{bytes}, L{Argument}) tuples. @param optional: a boolean indicating whether this argument can be omitted in the protocol. """ assert all(isinstance(name, bytes) for name, _ in subargs), ( "AmpList should be defined with a list of (name, argument) " "tuples where `name' is a byte string, got: %r" % (subargs,) ) self.subargs = subargs Argument.__init__(self, optional) def fromStringProto(self, inString, proto): boxes = parseString(inString) values = [_stringsToObjects(box, self.subargs, proto) for box in boxes] return values def toStringProto(self, inObject, proto): return b"".join( [ _objectsToStrings(objects, self.subargs, Box(), proto).serialize() for objects in inObject ] ) class Descriptor(Integer): """ Encode and decode file descriptors for exchange over a UNIX domain socket. This argument type requires an AMP connection set up over an L{IUNIXTransport<twisted.internet.interfaces.IUNIXTransport>} provider (for example, the kind of connection created by L{IReactorUNIX.connectUNIX<twisted.internet.interfaces.IReactorUNIX.connectUNIX>} and L{UNIXClientEndpoint<twisted.internet.endpoints.UNIXClientEndpoint>}). There is no correspondence between the integer value of the file descriptor on the sending and receiving sides, therefore an alternate approach is taken to matching up received descriptors with particular L{Descriptor} parameters. The argument is encoded to an ordinal (unique per connection) for inclusion in the AMP command or response box. The descriptor itself is sent using L{IUNIXTransport.sendFileDescriptor<twisted.internet.interfaces.IUNIXTransport.sendFileDescriptor>}. The receiver uses the order in which file descriptors are received and the ordinal value to come up with the received copy of the descriptor. """ def fromStringProto(self, inString, proto): """ Take a unique identifier associated with a file descriptor which must have been received by now and use it to look up that descriptor in a dictionary where they are kept. @param inString: The base representation (as a byte string) of an ordinal indicating which file descriptor corresponds to this usage of this argument. @type inString: C{str} @param proto: The protocol used to receive this descriptor. This protocol must be connected via a transport providing L{IUNIXTransport<twisted.internet.interfaces.IUNIXTransport>}. @type proto: L{BinaryBoxProtocol} @return: The file descriptor represented by C{inString}. @rtype: C{int} """ return proto._getDescriptor(int(inString)) def toStringProto(self, inObject, proto): """ Send C{inObject}, an integer file descriptor, over C{proto}'s connection and return a unique identifier which will allow the receiver to associate the file descriptor with this argument. @param inObject: A file descriptor to duplicate over an AMP connection as the value for this argument. @type inObject: C{int} @param proto: The protocol which will be used to send this descriptor. This protocol must be connected via a transport providing L{IUNIXTransport<twisted.internet.interfaces.IUNIXTransport>}. @return: A byte string which can be used by the receiver to reconstruct the file descriptor. @rtype: C{bytes} """ identifier = proto._sendFileDescriptor(inObject) outString = Integer.toStringProto(self, identifier, proto) return outString class _CommandMeta(type): """ Metaclass hack to establish reverse-mappings for 'errors' and 'fatalErrors' as class vars. """ def __new__(cls, name, bases, attrs): reverseErrors = attrs["reverseErrors"] = {} er = attrs["allErrors"] = {} if "commandName" not in attrs: attrs["commandName"] = name.encode("ascii") newtype = type.__new__(cls, name, bases, attrs) if not isinstance(newtype.commandName, bytes): raise TypeError( "Command names must be byte strings, got: {!r}".format( newtype.commandName ) ) for name, _ in newtype.arguments: if not isinstance(name, bytes): raise TypeError(f"Argument names must be byte strings, got: {name!r}") for name, _ in newtype.response: if not isinstance(name, bytes): raise TypeError(f"Response names must be byte strings, got: {name!r}") errors: Dict[Type[Exception], bytes] = {} fatalErrors: Dict[Type[Exception], bytes] = {} accumulateClassDict(newtype, "errors", errors) accumulateClassDict(newtype, "fatalErrors", fatalErrors) if not isinstance(newtype.errors, dict): newtype.errors = dict(newtype.errors) if not isinstance(newtype.fatalErrors, dict): newtype.fatalErrors = dict(newtype.fatalErrors) for v, k in errors.items(): reverseErrors[k] = v er[v] = k for v, k in fatalErrors.items(): reverseErrors[k] = v er[v] = k for _, name in newtype.errors.items(): if not isinstance(name, bytes): raise TypeError(f"Error names must be byte strings, got: {name!r}") for _, name in newtype.fatalErrors.items(): if not isinstance(name, bytes): raise TypeError( f"Fatal error names must be byte strings, got: {name!r}" ) return newtype class Command(metaclass=_CommandMeta): """ Subclass me to specify an AMP Command. @cvar arguments: A list of 2-tuples of (name, Argument-subclass-instance), specifying the names and values of the parameters which are required for this command. @cvar response: A list like L{arguments}, but instead used for the return value. @cvar errors: A mapping of subclasses of L{Exception} to wire-protocol tags for errors represented as L{str}s. Responders which raise keys from this dictionary will have the error translated to the corresponding tag on the wire. Invokers which receive Deferreds from invoking this command with L{BoxDispatcher.callRemote} will potentially receive Failures with keys from this mapping as their value. This mapping is inherited; if you declare a command which handles C{FooError} as 'FOO_ERROR', then subclass it and specify C{BarError} as 'BAR_ERROR', responders to the subclass may raise either C{FooError} or C{BarError}, and invokers must be able to deal with either of those exceptions. @cvar fatalErrors: like 'errors', but errors in this list will always terminate the connection, despite being of a recognizable error type. @cvar commandType: The type of Box used to issue commands; useful only for protocol-modifying behavior like startTLS or protocol switching. Defaults to a plain vanilla L{Box}. @cvar responseType: The type of Box used to respond to this command; only useful for protocol-modifying behavior like startTLS or protocol switching. Defaults to a plain vanilla L{Box}. @ivar requiresAnswer: a boolean; defaults to True. Set it to False on your subclass if you want callRemote to return None. Note: this is a hint only to the client side of the protocol. The return-type of a command responder method must always be a dictionary adhering to the contract specified by L{response}, because clients are always free to request a response if they want one. """ arguments: List[Tuple[bytes, Argument]] = [] response: List[Tuple[bytes, Argument]] = [] extra: List[Any] = [] errors: Dict[Type[Exception], bytes] = {} fatalErrors: Dict[Type[Exception], bytes] = {} commandType: "Union[Type[Command], Type[Box]]" = Box responseType: Type[AmpBox] = Box requiresAnswer = True def __init__(self, **kw): """ Create an instance of this command with specified values for its parameters. In Python 3, keyword arguments MUST be Unicode/native strings whereas in Python 2 they could be either byte strings or Unicode strings. A L{Command}'s arguments are defined in its schema using C{bytes} names. The values for those arguments are plucked from the keyword arguments using the name returned from L{_wireNameToPythonIdentifier}. In other words, keyword arguments should be named using the Python-side equivalent of the on-wire (C{bytes}) name. @param kw: a dict containing an appropriate value for each name specified in the L{arguments} attribute of my class. @raise InvalidSignature: if you forgot any required arguments. """ self.structured = kw forgotten = [] for name, arg in self.arguments: pythonName = _wireNameToPythonIdentifier(name) if pythonName not in self.structured and not arg.optional: forgotten.append(pythonName) if forgotten: raise InvalidSignature( "forgot {} for {}".format(", ".join(forgotten), self.commandName) ) forgotten = [] @classmethod def makeResponse(cls, objects, proto): """ Serialize a mapping of arguments using this L{Command}'s response schema. @param objects: a dict with keys matching the names specified in self.response, having values of the types that the Argument objects in self.response can format. @param proto: an L{AMP}. @return: an L{AmpBox}. """ try: responseType = cls.responseType() except BaseException: return fail() return _objectsToStrings(objects, cls.response, responseType, proto) @classmethod def makeArguments(cls, objects, proto): """ Serialize a mapping of arguments using this L{Command}'s argument schema. @param objects: a dict with keys similar to the names specified in self.arguments, having values of the types that the Argument objects in self.arguments can parse. @param proto: an L{AMP}. @return: An instance of this L{Command}'s C{commandType}. """ allowedNames = set() for (argName, ignored) in cls.arguments: allowedNames.add(_wireNameToPythonIdentifier(argName)) for intendedArg in objects: if intendedArg not in allowedNames: raise InvalidSignature(f"{intendedArg} is not a valid argument") return _objectsToStrings(objects, cls.arguments, cls.commandType(), proto) @classmethod def parseResponse(cls, box, protocol): """ Parse a mapping of serialized arguments using this L{Command}'s response schema. @param box: A mapping of response-argument names to the serialized forms of those arguments. @param protocol: The L{AMP} protocol. @return: A mapping of response-argument names to the parsed forms. """ return _stringsToObjects(box, cls.response, protocol) @classmethod def parseArguments(cls, box, protocol): """ Parse a mapping of serialized arguments using this L{Command}'s argument schema. @param box: A mapping of argument names to the seralized forms of those arguments. @param protocol: The L{AMP} protocol. @return: A mapping of argument names to the parsed forms. """ return _stringsToObjects(box, cls.arguments, protocol) @classmethod def responder(cls, methodfunc): """ Declare a method to be a responder for a particular command. This is a decorator. Use like so:: class MyCommand(Command): arguments = [('a', ...), ('b', ...)] class MyProto(AMP): def myFunMethod(self, a, b): ... MyCommand.responder(myFunMethod) Notes: Although decorator syntax is not used within Twisted, this function returns its argument and is therefore safe to use with decorator syntax. This is not thread safe. Don't declare AMP subclasses in other threads. Don't declare responders outside the scope of AMP subclasses; the behavior is undefined. @param methodfunc: A function which will later become a method, which has a keyword signature compatible with this command's L{arguments} list and returns a dictionary with a set of keys compatible with this command's L{response} list. @return: the methodfunc parameter. """ CommandLocator._currentClassCommands.append((cls, methodfunc)) return methodfunc # Our only instance method def _doCommand(self, proto): """ Encode and send this Command to the given protocol. @param proto: an AMP, representing the connection to send to. @return: a Deferred which will fire or error appropriately when the other side responds to the command (or error if the connection is lost before it is responded to). """ def _massageError(error): error.trap(RemoteAmpError) rje = error.value errorType = self.reverseErrors.get(rje.errorCode, UnknownRemoteError) return Failure(errorType(rje.description)) d = proto._sendBoxCommand( self.commandName, self.makeArguments(self.structured, proto), self.requiresAnswer, ) if self.requiresAnswer: d.addCallback(self.parseResponse, proto) d.addErrback(_massageError) return d class _NoCertificate: """ This is for peers which don't want to use a local certificate. Used by AMP because AMP's internal language is all about certificates and this duck-types in the appropriate place; this API isn't really stable though, so it's not exposed anywhere public. For clients, it will use ephemeral DH keys, or whatever the default is for certificate-less clients in OpenSSL. For servers, it will generate a temporary self-signed certificate with garbage values in the DN and use that. """ def __init__(self, client): """ Create a _NoCertificate which either is or isn't for the client side of the connection. @param client: True if we are a client and should truly have no certificate and be anonymous, False if we are a server and actually have to generate a temporary certificate. @type client: bool """ self.client = client def options(self, *authorities): """ Behaves like L{twisted.internet.ssl.PrivateCertificate.options}(). """ if not self.client: # do some crud with sslverify to generate a temporary self-signed # certificate. This is SLOOOWWWWW so it is only in the absolute # worst, most naive case. # We have to do this because OpenSSL will not let both the server # and client be anonymous. sharedDN = DN(CN="TEMPORARY CERTIFICATE") key = KeyPair.generate() cr = key.certificateRequest(sharedDN) sscrd = key.signCertificateRequest(sharedDN, cr, lambda dn: True, 1) cert = key.newCertificate(sscrd) return cert.options(*authorities) options = dict() if authorities: options.update( dict( verify=True, requireCertificate=True, caCerts=[auth.original for auth in authorities], ) ) occo = CertificateOptions(**options) return occo class _TLSBox(AmpBox): """ I am an AmpBox that, upon being sent, initiates a TLS connection. """ __slots__: List[str] = [] def __init__(self): if ssl is None: raise RemoteAmpError(b"TLS_ERROR", "TLS not available") AmpBox.__init__(self) @property def certificate(self): return self.get(b"tls_localCertificate", _NoCertificate(False)) @property def verify(self): return self.get(b"tls_verifyAuthorities", None) def _sendTo(self, proto): """ Send my encoded value to the protocol, then initiate TLS. """ ab = AmpBox(self) for k in [b"tls_localCertificate", b"tls_verifyAuthorities"]: ab.pop(k, None) ab._sendTo(proto) proto._startTLS(self.certificate, self.verify) class _LocalArgument(String): """ Local arguments are never actually relayed across the wire. This is just a shim so that StartTLS can pretend to have some arguments: if arguments acquire documentation properties, replace this with something nicer later. """ def fromBox(self, name, strings, objects, proto): pass class StartTLS(Command): """ Use, or subclass, me to implement a command that starts TLS. Callers of StartTLS may pass several special arguments, which affect the TLS negotiation: - tls_localCertificate: This is a twisted.internet.ssl.PrivateCertificate which will be used to secure the side of the connection it is returned on. - tls_verifyAuthorities: This is a list of twisted.internet.ssl.Certificate objects that will be used as the certificate authorities to verify our peer's certificate. Each of those special parameters may also be present as a key in the response dictionary. """ arguments = [ (b"tls_localCertificate", _LocalArgument(optional=True)), (b"tls_verifyAuthorities", _LocalArgument(optional=True)), ] response = [ (b"tls_localCertificate", _LocalArgument(optional=True)), (b"tls_verifyAuthorities", _LocalArgument(optional=True)), ] responseType = _TLSBox def __init__(self, *, tls_localCertificate=None, tls_verifyAuthorities=None, **kw): """ Create a StartTLS command. (This is private. Use AMP.callRemote.) @param tls_localCertificate: the PrivateCertificate object to use to secure the connection. If it's L{None}, or unspecified, an ephemeral DH key is used instead. @param tls_verifyAuthorities: a list of Certificate objects which represent root certificates to verify our peer with. """ if ssl is None: raise RuntimeError("TLS not available.") self.certificate = ( _NoCertificate(True) if tls_localCertificate is None else tls_localCertificate ) self.authorities = tls_verifyAuthorities Command.__init__(self, **kw) def _doCommand(self, proto): """ When a StartTLS command is sent, prepare to start TLS, but don't actually do it; wait for the acknowledgement, then initiate the TLS handshake. """ d = Command._doCommand(self, proto) proto._prepareTLS(self.certificate, self.authorities) # XXX before we get back to user code we are going to start TLS... def actuallystart(response): proto._startTLS(self.certificate, self.authorities) return response d.addCallback(actuallystart) return d class ProtocolSwitchCommand(Command): """ Use this command to switch from something Amp-derived to a different protocol mid-connection. This can be useful to use amp as the connection-startup negotiation phase. Since TLS is a different layer entirely, you can use Amp to negotiate the security parameters of your connection, then switch to a different protocol, and the connection will remain secured. """ def __init__(self, _protoToSwitchToFactory, **kw): """ Create a ProtocolSwitchCommand. @param _protoToSwitchToFactory: a ProtocolFactory which will generate the Protocol to switch to. @param kw: Keyword arguments, encoded and handled normally as L{Command} would. """ self.protoToSwitchToFactory = _protoToSwitchToFactory super().__init__(**kw) @classmethod def makeResponse(cls, innerProto, proto): return _SwitchBox(innerProto) def _doCommand(self, proto): """ When we emit a ProtocolSwitchCommand, lock the protocol, but don't actually switch to the new protocol unless an acknowledgement is received. If an error is received, switch back. """ d = super()._doCommand(proto) proto._lockForSwitch() def switchNow(ign): innerProto = self.protoToSwitchToFactory.buildProtocol( proto.transport.getPeer() ) proto._switchTo(innerProto, self.protoToSwitchToFactory) return ign def handle(ign): proto._unlockFromSwitch() self.protoToSwitchToFactory.clientConnectionFailed( None, Failure(CONNECTION_LOST) ) return ign return d.addCallbacks(switchNow, handle) @implementer(IFileDescriptorReceiver) class _DescriptorExchanger: """ L{_DescriptorExchanger} is a mixin for L{BinaryBoxProtocol} which adds support for receiving file descriptors, a feature offered by L{IUNIXTransport<twisted.internet.interfaces.IUNIXTransport>}. @ivar _descriptors: Temporary storage for all file descriptors received. Values in this dictionary are the file descriptors (as integers). Keys in this dictionary are ordinals giving the order in which each descriptor was received. The ordering information is used to allow L{Descriptor} to determine which is the correct descriptor for any particular usage of that argument type. @type _descriptors: C{dict} @ivar _sendingDescriptorCounter: A no-argument callable which returns the ordinals, starting from 0. This is used to construct values for C{_sendFileDescriptor}. @ivar _receivingDescriptorCounter: A no-argument callable which returns the ordinals, starting from 0. This is used to construct values for C{fileDescriptorReceived}. """ def __init__(self): self._descriptors = {} self._getDescriptor = self._descriptors.pop self._sendingDescriptorCounter = partial(next, count()) self._receivingDescriptorCounter = partial(next, count()) def _sendFileDescriptor(self, descriptor): """ Assign and return the next ordinal to the given descriptor after sending the descriptor over this protocol's transport. """ self.transport.sendFileDescriptor(descriptor) return self._sendingDescriptorCounter() def fileDescriptorReceived(self, descriptor): """ Collect received file descriptors to be claimed later by L{Descriptor}. @param descriptor: The received file descriptor. @type descriptor: C{int} """ self._descriptors[self._receivingDescriptorCounter()] = descriptor @implementer(IBoxSender) class BinaryBoxProtocol( StatefulStringProtocol, Int16StringReceiver, _DescriptorExchanger ): """ A protocol for receiving L{AmpBox}es - key/value pairs - via length-prefixed strings. A box is composed of: - any number of key-value pairs, described by: - a 2-byte network-endian packed key length (of which the first byte must be null, and the second must be non-null: i.e. the value of the length must be 1-255) - a key, comprised of that many bytes - a 2-byte network-endian unsigned value length (up to the maximum of 65535) - a value, comprised of that many bytes - 2 null bytes In other words, an even number of strings prefixed with packed unsigned 16-bit integers, and then a 0-length string to indicate the end of the box. This protocol also implements 2 extra private bits of functionality related to the byte boundaries between messages; it can start TLS between two given boxes or switch to an entirely different protocol. However, due to some tricky elements of the implementation, the public interface to this functionality is L{ProtocolSwitchCommand} and L{StartTLS}. @ivar _keyLengthLimitExceeded: A flag which is only true when the connection is being closed because a key length prefix which was longer than allowed by the protocol was received. @ivar boxReceiver: an L{IBoxReceiver} provider, whose L{IBoxReceiver.ampBoxReceived} method will be invoked for each L{AmpBox} that is received. """ _justStartedTLS = False _startingTLSBuffer = None _locked = False _currentKey = None _currentBox = None _keyLengthLimitExceeded = False hostCertificate = None noPeerCertificate = False # for tests innerProtocol: Optional[Protocol] = None innerProtocolClientFactory = None def __init__(self, boxReceiver): _DescriptorExchanger.__init__(self) self.boxReceiver = boxReceiver def _switchTo(self, newProto, clientFactory=None): """ Switch this BinaryBoxProtocol's transport to a new protocol. You need to do this 'simultaneously' on both ends of a connection; the easiest way to do this is to use a subclass of ProtocolSwitchCommand. @param newProto: the new protocol instance to switch to. @param clientFactory: the ClientFactory to send the L{twisted.internet.protocol.ClientFactory.clientConnectionLost} notification to. """ # All the data that Int16Receiver has not yet dealt with belongs to our # new protocol: luckily it's keeping that in a handy (although # ostensibly internal) variable for us: newProtoData = self.recvd # We're quite possibly in the middle of a 'dataReceived' loop in # Int16StringReceiver: let's make sure that the next iteration, the # loop will break and not attempt to look at something that isn't a # length prefix. self.recvd = "" # Finally, do the actual work of setting up the protocol and delivering # its first chunk of data, if one is available. self.innerProtocol = newProto self.innerProtocolClientFactory = clientFactory newProto.makeConnection(self.transport) if newProtoData: newProto.dataReceived(newProtoData) def sendBox(self, box): """ Send a amp.Box to my peer. Note: transport.write is never called outside of this method. @param box: an AmpBox. @raise ProtocolSwitched: if the protocol has previously been switched. @raise ConnectionLost: if the connection has previously been lost. """ if self._locked: raise ProtocolSwitched( "This connection has switched: no AMP traffic allowed." ) if self.transport is None: raise ConnectionLost() if self._startingTLSBuffer is not None: self._startingTLSBuffer.append(box) else: self.transport.write(box.serialize()) def makeConnection(self, transport): """ Notify L{boxReceiver} that it is about to receive boxes from this protocol by invoking L{IBoxReceiver.startReceivingBoxes}. """ self.transport = transport self.boxReceiver.startReceivingBoxes(self) self.connectionMade() def dataReceived(self, data): """ Either parse incoming data as L{AmpBox}es or relay it to our nested protocol. """ if self._justStartedTLS: self._justStartedTLS = False # If we already have an inner protocol, then we don't deliver data to # the protocol parser any more; we just hand it off. if self.innerProtocol is not None: self.innerProtocol.dataReceived(data) return return Int16StringReceiver.dataReceived(self, data) def connectionLost(self, reason): """ The connection was lost; notify any nested protocol. """ if self.innerProtocol is not None: self.innerProtocol.connectionLost(reason) if self.innerProtocolClientFactory is not None: self.innerProtocolClientFactory.clientConnectionLost(None, reason) if self._keyLengthLimitExceeded: failReason = Failure(TooLong(True, False, None, None)) elif reason.check(ConnectionClosed) and self._justStartedTLS: # We just started TLS and haven't received any data. This means # the other connection didn't like our cert (although they may not # have told us why - later Twisted should make 'reason' into a TLS # error.) failReason = PeerVerifyError( "Peer rejected our certificate for an unknown reason." ) else: failReason = reason self.boxReceiver.stopReceivingBoxes(failReason) # The longest key allowed _MAX_KEY_LENGTH = 255 # The longest value allowed (this is somewhat redundant, as longer values # cannot be encoded - ah well). _MAX_VALUE_LENGTH = 65535 # The first thing received is a key. MAX_LENGTH = _MAX_KEY_LENGTH def proto_init(self, string): """ String received in the 'init' state. """ self._currentBox = AmpBox() return self.proto_key(string) def proto_key(self, string): """ String received in the 'key' state. If the key is empty, a complete box has been received. """ if string: self._currentKey = string self.MAX_LENGTH = self._MAX_VALUE_LENGTH return "value" else: self.boxReceiver.ampBoxReceived(self._currentBox) self._currentBox = None return "init" def proto_value(self, string): """ String received in the 'value' state. """ self._currentBox[self._currentKey] = string self._currentKey = None self.MAX_LENGTH = self._MAX_KEY_LENGTH return "key" def lengthLimitExceeded(self, length): """ The key length limit was exceeded. Disconnect the transport and make sure a meaningful exception is reported. """ self._keyLengthLimitExceeded = True self.transport.loseConnection() def _lockForSwitch(self): """ Lock this binary protocol so that no further boxes may be sent. This is used when sending a request to switch underlying protocols. You probably want to subclass ProtocolSwitchCommand rather than calling this directly. """ self._locked = True def _unlockFromSwitch(self): """ Unlock this locked binary protocol so that further boxes may be sent again. This is used after an attempt to switch protocols has failed for some reason. """ if self.innerProtocol is not None: raise ProtocolSwitched("Protocol already switched. Cannot unlock.") self._locked = False def _prepareTLS(self, certificate, verifyAuthorities): """ Used by StartTLSCommand to put us into the state where we don't actually send things that get sent, instead we buffer them. see L{_sendBoxCommand}. """ self._startingTLSBuffer = [] if self.hostCertificate is not None: raise OnlyOneTLS( "Previously authenticated connection between %s and %s " "is trying to re-establish as %s" % ( self.hostCertificate, self.peerCertificate, (certificate, verifyAuthorities), ) ) def _startTLS(self, certificate, verifyAuthorities): """ Used by TLSBox to initiate the SSL handshake. @param certificate: a L{twisted.internet.ssl.PrivateCertificate} for use locally. @param verifyAuthorities: L{twisted.internet.ssl.Certificate} instances representing certificate authorities which will verify our peer. """ self.hostCertificate = certificate self._justStartedTLS = True if verifyAuthorities is None: verifyAuthorities = () self.transport.startTLS(certificate.options(*verifyAuthorities)) stlsb = self._startingTLSBuffer if stlsb is not None: self._startingTLSBuffer = None for box in stlsb: self.sendBox(box) @property def peerCertificate(self): if self.noPeerCertificate: return None return Certificate.peerFromTransport(self.transport) def unhandledError(self, failure): """ The buck stops here. This error was completely unhandled, time to terminate the connection. """ log.err( failure, "Amp server or network failure unhandled by client application. " "Dropping connection! To avoid, add errbacks to ALL remote " "commands!", ) if self.transport is not None: self.transport.loseConnection() def _defaultStartTLSResponder(self): """ The default TLS responder doesn't specify any certificate or anything. From a security perspective, it's little better than a plain-text connection - but it is still a *bit* better, so it's included for convenience. You probably want to override this by providing your own StartTLS.responder. """ return {} StartTLS.responder(_defaultStartTLSResponder) class AMP(BinaryBoxProtocol, BoxDispatcher, CommandLocator, SimpleStringLocator): """ This protocol is an AMP connection. See the module docstring for protocol details. """ _ampInitialized = False def __init__(self, boxReceiver=None, locator=None): # For backwards compatibility. When AMP did not separate parsing logic # (L{BinaryBoxProtocol}), request-response logic (L{BoxDispatcher}) and # command routing (L{CommandLocator}), it did not have a constructor. # Now it does, so old subclasses might have defined their own that did # not upcall. If this flag isn't set, we'll call the constructor in # makeConnection before anything actually happens. self._ampInitialized = True if boxReceiver is None: boxReceiver = self if locator is None: locator = self BoxDispatcher.__init__(self, locator) BinaryBoxProtocol.__init__(self, boxReceiver) def locateResponder(self, name): """ Unify the implementations of L{CommandLocator} and L{SimpleStringLocator} to perform both kinds of dispatch, preferring L{CommandLocator}. @type name: C{bytes} """ firstResponder = CommandLocator.locateResponder(self, name) if firstResponder is not None: return firstResponder secondResponder = SimpleStringLocator.locateResponder(self, name) return secondResponder def __repr__(self) -> str: """ A verbose string representation which gives us information about this AMP connection. """ if self.innerProtocol is not None: innerRepr = f" inner {self.innerProtocol!r}" else: innerRepr = "" return f"<{self.__class__.__name__}{innerRepr} at 0x{id(self):x}>" def makeConnection(self, transport): """ Emit a helpful log message when the connection is made. """ if not self._ampInitialized: # See comment in the constructor re: backward compatibility. I # should probably emit a deprecation warning here. AMP.__init__(self) # Save these so we can emit a similar log message in L{connectionLost}. self._transportPeer = transport.getPeer() self._transportHost = transport.getHost() log.msg( "%s connection established (HOST:%s PEER:%s)" % (self.__class__.__name__, self._transportHost, self._transportPeer) ) BinaryBoxProtocol.makeConnection(self, transport) def connectionLost(self, reason): """ Emit a helpful log message when the connection is lost. """ log.msg( "%s connection lost (HOST:%s PEER:%s)" % (self.__class__.__name__, self._transportHost, self._transportPeer) ) BinaryBoxProtocol.connectionLost(self, reason) self.transport = None class _ParserHelper: """ A box receiver which records all boxes received. """ def __init__(self): self.boxes = [] def getPeer(self): return "string" def getHost(self): return "string" disconnecting = False def startReceivingBoxes(self, sender): """ No initialization is required. """ def ampBoxReceived(self, box): self.boxes.append(box) # Synchronous helpers @classmethod def parse(cls, fileObj): """ Parse some amp data stored in a file. @param fileObj: a file-like object. @return: a list of AmpBoxes encoded in the given file. """ parserHelper = cls() bbp = BinaryBoxProtocol(boxReceiver=parserHelper) bbp.makeConnection(parserHelper) bbp.dataReceived(fileObj.read()) return parserHelper.boxes @classmethod def parseString(cls, data): """ Parse some amp data stored in a string. @param data: a str holding some amp-encoded data. @return: a list of AmpBoxes encoded in the given string. """ return cls.parse(BytesIO(data)) parse = _ParserHelper.parse parseString = _ParserHelper.parseString def _stringsToObjects(strings, arglist, proto): """ Convert an AmpBox to a dictionary of python objects, converting through a given arglist. @param strings: an AmpBox (or dict of strings) @param arglist: a list of 2-tuples of strings and Argument objects, as described in L{Command.arguments}. @param proto: an L{AMP} instance. @return: the converted dictionary mapping names to argument objects. """ objects = {} myStrings = strings.copy() for argname, argparser in arglist: argparser.fromBox(argname, myStrings, objects, proto) return objects def _objectsToStrings(objects, arglist, strings, proto): """ Convert a dictionary of python objects to an AmpBox, converting through a given arglist. @param objects: a dict mapping names to python objects @param arglist: a list of 2-tuples of strings and Argument objects, as described in L{Command.arguments}. @param strings: [OUT PARAMETER] An object providing the L{dict} interface which will be populated with serialized data. @param proto: an L{AMP} instance. @return: The converted dictionary mapping names to encoded argument strings (identical to C{strings}). """ myObjects = objects.copy() for argname, argparser in arglist: argparser.toBox(argname, strings, myObjects, proto) return strings class Decimal(Argument): """ Encodes C{decimal.Decimal} instances. There are several ways in which a decimal value might be encoded. Special values are encoded as special strings:: - Positive infinity is encoded as C{"Infinity"} - Negative infinity is encoded as C{"-Infinity"} - Quiet not-a-number is encoded as either C{"NaN"} or C{"-NaN"} - Signalling not-a-number is encoded as either C{"sNaN"} or C{"-sNaN"} Normal values are encoded using the base ten string representation, using engineering notation to indicate magnitude without precision, and "normal" digits to indicate precision. For example:: - C{"1"} represents the value I{1} with precision to one place. - C{"-1"} represents the value I{-1} with precision to one place. - C{"1.0"} represents the value I{1} with precision to two places. - C{"10"} represents the value I{10} with precision to two places. - C{"1E+2"} represents the value I{10} with precision to one place. - C{"1E-1"} represents the value I{0.1} with precision to one place. - C{"1.5E+2"} represents the value I{15} with precision to two places. U{http://speleotrove.com/decimal/} should be considered the authoritative specification for the format. """ def fromString(self, inString): inString = nativeString(inString) return decimal.Decimal(inString) def toString(self, inObject): """ Serialize a C{decimal.Decimal} instance to the specified wire format. """ if isinstance(inObject, decimal.Decimal): # Hopefully decimal.Decimal.__str__ actually does what we want. return str(inObject).encode("ascii") raise ValueError("amp.Decimal can only encode instances of decimal.Decimal") class DateTime(Argument): """ Encodes C{datetime.datetime} instances. Wire format: '%04i-%02i-%02iT%02i:%02i:%02i.%06i%s%02i:%02i'. Fields in order are: year, month, day, hour, minute, second, microsecond, timezone direction (+ or -), timezone hour, timezone minute. Encoded string is always exactly 32 characters long. This format is compatible with ISO 8601, but that does not mean all ISO 8601 dates can be accepted. Also, note that the datetime module's notion of a "timezone" can be complex, but the wire format includes only a fixed offset, so the conversion is not lossless. A lossless transmission of a C{datetime} instance is not feasible since the receiving end would require a Python interpreter. @ivar _positions: A sequence of slices giving the positions of various interesting parts of the wire format. """ _positions = [ slice(0, 4), slice(5, 7), slice(8, 10), # year, month, day slice(11, 13), slice(14, 16), slice(17, 19), # hour, minute, second slice(20, 26), # microsecond # intentionally skip timezone direction, as it is not an integer slice(27, 29), slice(30, 32), # timezone hour, timezone minute ] def fromString(self, s): """ Parse a string containing a date and time in the wire format into a C{datetime.datetime} instance. """ s = nativeString(s) if len(s) != 32: raise ValueError(f"invalid date format {s!r}") values = [int(s[p]) for p in self._positions] sign = s[26] timezone = _FixedOffsetTZInfo.fromSignHoursMinutes(sign, *values[7:]) values[7:] = [timezone] return datetime.datetime(*values) def toString(self, i): """ Serialize a C{datetime.datetime} instance to a string in the specified wire format. """ offset = i.utcoffset() if offset is None: raise ValueError( "amp.DateTime cannot serialize naive datetime instances. " "You may find amp.utc useful." ) minutesOffset = (offset.days * 86400 + offset.seconds) // 60 if minutesOffset > 0: sign = "+" else: sign = "-" # strftime has no way to format the microseconds, or put a ':' in the # timezone. Surprise! # Python 3.4 cannot do % interpolation on byte strings so we pack into # an explicitly Unicode string then encode as ASCII. packed = "%04i-%02i-%02iT%02i:%02i:%02i.%06i%s%02i:%02i" % ( i.year, i.month, i.day, i.hour, i.minute, i.second, i.microsecond, sign, abs(minutesOffset) // 60, abs(minutesOffset) % 60, ) return packed.encode("ascii") PK Mb�Z6^�@� � protocols/wire.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """Implement standard (and unused) TCP protocols. These protocols are either provided by inetd, or are not provided at all. """ import struct import time from zope.interface import implementer from twisted.internet import interfaces, protocol class Echo(protocol.Protocol): """ As soon as any data is received, write it back (RFC 862). """ def dataReceived(self, data): self.transport.write(data) class Discard(protocol.Protocol): """ Discard any received data (RFC 863). """ def dataReceived(self, data): # I'm ignoring you, nyah-nyah pass @implementer(interfaces.IProducer) class Chargen(protocol.Protocol): """ Generate repeating noise (RFC 864). """ noise = br'@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&?' def connectionMade(self): self.transport.registerProducer(self, 0) def resumeProducing(self): self.transport.write(self.noise) def pauseProducing(self): pass def stopProducing(self): pass class QOTD(protocol.Protocol): """ Return a quote of the day (RFC 865). """ def connectionMade(self): self.transport.write(self.getQuote()) self.transport.loseConnection() def getQuote(self): """ Return a quote. May be overrriden in subclasses. """ return b"An apple a day keeps the doctor away.\r\n" class Who(protocol.Protocol): """ Return list of active users (RFC 866) """ def connectionMade(self): self.transport.write(self.getUsers()) self.transport.loseConnection() def getUsers(self): """ Return active users. Override in subclasses. """ return b"root\r\n" class Daytime(protocol.Protocol): """ Send back the daytime in ASCII form (RFC 867). """ def connectionMade(self): self.transport.write(time.asctime(time.gmtime(time.time())) + b"\r\n") self.transport.loseConnection() class Time(protocol.Protocol): """ Send back the time in machine readable form (RFC 868). """ def connectionMade(self): # is this correct only for 32-bit machines? result = struct.pack("!i", int(time.time())) self.transport.write(result) self.transport.loseConnection() __all__ = ["Echo", "Discard", "Chargen", "QOTD", "Who", "Daytime", "Time"] PK Mb�Z%DE�C C protocols/portforward.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ A simple port forwarder. """ # Twisted imports from twisted.internet import protocol from twisted.python import log class Proxy(protocol.Protocol): noisy = True peer = None def setPeer(self, peer): self.peer = peer def connectionLost(self, reason): if self.peer is not None: self.peer.transport.loseConnection() self.peer = None elif self.noisy: log.msg(f"Unable to connect to peer: {reason}") def dataReceived(self, data): self.peer.transport.write(data) class ProxyClient(Proxy): def connectionMade(self): self.peer.setPeer(self) # Wire this and the peer transport together to enable # flow control (this stops connections from filling # this proxy memory when one side produces data at a # higher rate than the other can consume). self.transport.registerProducer(self.peer.transport, True) self.peer.transport.registerProducer(self.transport, True) # We're connected, everybody can read to their hearts content. self.peer.transport.resumeProducing() class ProxyClientFactory(protocol.ClientFactory): protocol = ProxyClient def setServer(self, server): self.server = server def buildProtocol(self, *args, **kw): prot = protocol.ClientFactory.buildProtocol(self, *args, **kw) prot.setPeer(self.server) return prot def clientConnectionFailed(self, connector, reason): self.server.transport.loseConnection() class ProxyServer(Proxy): clientProtocolFactory = ProxyClientFactory reactor = None def connectionMade(self): # Don't read anything from the connecting client until we have # somewhere to send it to. self.transport.pauseProducing() client = self.clientProtocolFactory() client.setServer(self) if self.reactor is None: from twisted.internet import reactor self.reactor = reactor self.reactor.connectTCP(self.factory.host, self.factory.port, client) class ProxyFactory(protocol.Factory): """ Factory for port forwarder. """ protocol = ProxyServer def __init__(self, host, port): self.host = host self.port = port PK Mb�Z.�� � protocols/socks.pynu �[��� # -*- test-case-name: twisted.test.test_socks -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Implementation of the SOCKSv4 protocol. """ import socket import string # python imports import struct import time # twisted imports from twisted.internet import defer, protocol, reactor from twisted.python import log class SOCKSv4Outgoing(protocol.Protocol): def __init__(self, socks): self.socks = socks def connectionMade(self): peer = self.transport.getPeer() self.socks.makeReply(90, 0, port=peer.port, ip=peer.host) self.socks.otherConn = self def connectionLost(self, reason): self.socks.transport.loseConnection() def dataReceived(self, data): self.socks.write(data) def write(self, data): self.socks.log(self, data) self.transport.write(data) class SOCKSv4Incoming(protocol.Protocol): def __init__(self, socks): self.socks = socks self.socks.otherConn = self def connectionLost(self, reason): self.socks.transport.loseConnection() def dataReceived(self, data): self.socks.write(data) def write(self, data): self.socks.log(self, data) self.transport.write(data) class SOCKSv4(protocol.Protocol): """ An implementation of the SOCKSv4 protocol. @type logging: L{str} or L{None} @ivar logging: If not L{None}, the name of the logfile to which connection information will be written. @type reactor: object providing L{twisted.internet.interfaces.IReactorTCP} @ivar reactor: The reactor used to create connections. @type buf: L{str} @ivar buf: Part of a SOCKSv4 connection request. @type otherConn: C{SOCKSv4Incoming}, C{SOCKSv4Outgoing} or L{None} @ivar otherConn: Until the connection has been established, C{otherConn} is L{None}. After that, it is the proxy-to-destination protocol instance along which the client's connection is being forwarded. """ def __init__(self, logging=None, reactor=reactor): self.logging = logging self.reactor = reactor def connectionMade(self): self.buf = b"" self.otherConn = None def dataReceived(self, data): """ Called whenever data is received. @type data: L{bytes} @param data: Part or all of a SOCKSv4 packet. """ if self.otherConn: self.otherConn.write(data) return self.buf = self.buf + data completeBuffer = self.buf if b"\000" in self.buf[8:]: head, self.buf = self.buf[:8], self.buf[8:] version, code, port = struct.unpack("!BBH", head[:4]) user, self.buf = self.buf.split(b"\000", 1) if head[4:7] == b"\000\000\000" and head[7:8] != b"\000": # An IP address of the form 0.0.0.X, where X is non-zero, # signifies that this is a SOCKSv4a packet. # If the complete packet hasn't been received, restore the # buffer and wait for it. if b"\000" not in self.buf: self.buf = completeBuffer return server, self.buf = self.buf.split(b"\000", 1) d = self.reactor.resolve(server) d.addCallback(self._dataReceived2, user, version, code, port) d.addErrback(lambda result, self=self: self.makeReply(91)) return else: server = socket.inet_ntoa(head[4:8]) self._dataReceived2(server, user, version, code, port) def _dataReceived2(self, server, user, version, code, port): """ The second half of the SOCKS connection setup. For a SOCKSv4 packet this is after the server address has been extracted from the header. For a SOCKSv4a packet this is after the host name has been resolved. @type server: L{str} @param server: The IP address of the destination, represented as a dotted quad. @type user: L{str} @param user: The username associated with the connection. @type version: L{int} @param version: The SOCKS protocol version number. @type code: L{int} @param code: The command code. 1 means establish a TCP/IP stream connection, and 2 means establish a TCP/IP port binding. @type port: L{int} @param port: The port number associated with the connection. """ assert version == 4, "Bad version code: %s" % version if not self.authorize(code, server, port, user): self.makeReply(91) return if code == 1: # CONNECT d = self.connectClass(server, port, SOCKSv4Outgoing, self) d.addErrback(lambda result, self=self: self.makeReply(91)) elif code == 2: # BIND d = self.listenClass(0, SOCKSv4IncomingFactory, self, server) d.addCallback(lambda x, self=self: self.makeReply(90, 0, x[1], x[0])) else: raise RuntimeError(f"Bad Connect Code: {code}") assert self.buf == b"", "hmm, still stuff in buffer... %s" % repr(self.buf) def connectionLost(self, reason): if self.otherConn: self.otherConn.transport.loseConnection() def authorize(self, code, server, port, user): log.msg( "code %s connection to %s:%s (user %s) authorized" % (code, server, port, user) ) return 1 def connectClass(self, host, port, klass, *args): return protocol.ClientCreator(reactor, klass, *args).connectTCP(host, port) def listenClass(self, port, klass, *args): serv = reactor.listenTCP(port, klass(*args)) return defer.succeed(serv.getHost()[1:]) def makeReply(self, reply, version=0, port=0, ip="0.0.0.0"): self.transport.write( struct.pack("!BBH", version, reply, port) + socket.inet_aton(ip) ) if reply != 90: self.transport.loseConnection() def write(self, data): self.log(self, data) self.transport.write(data) def log(self, proto, data): if not self.logging: return peer = self.transport.getPeer() their_peer = self.otherConn.transport.getPeer() f = open(self.logging, "a") f.write( "%s\t%s:%d %s %s:%d\n" % ( time.ctime(), peer.host, peer.port, ((proto == self and "<") or ">"), their_peer.host, their_peer.port, ) ) while data: p, data = data[:16], data[16:] f.write(string.join(map(lambda x: "%02X" % ord(x), p), " ") + " ") f.write((16 - len(p)) * 3 * " ") for c in p: if len(repr(c)) > 3: f.write(".") else: f.write(c) f.write("\n") f.write("\n") f.close() class SOCKSv4Factory(protocol.Factory): """ A factory for a SOCKSv4 proxy. Constructor accepts one argument, a log file name. """ def __init__(self, log): self.logging = log def buildProtocol(self, addr): return SOCKSv4(self.logging, reactor) class SOCKSv4IncomingFactory(protocol.Factory): """ A utility class for building protocols for incoming connections. """ def __init__(self, socks, ip): self.socks = socks self.ip = ip def buildProtocol(self, addr): if addr[0] == self.ip: self.ip = "" self.socks.makeReply(90, 0) return SOCKSv4Incoming(self.socks) elif self.ip == "": return None else: self.socks.makeReply(91, 0) self.ip = "" return None PK Mb�Z���{S {S protocols/policies.pynu �[��� # -*- test-case-name: twisted.test.test_policies -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Resource limiting policies. @seealso: See also L{twisted.protocols.htb} for rate limiting. """ # system imports import sys from typing import Optional, Type from zope.interface import directlyProvides, providedBy from twisted.internet import error, interfaces from twisted.internet.interfaces import ILoggingContext # twisted imports from twisted.internet.protocol import ClientFactory, Protocol, ServerFactory from twisted.python import log def _wrappedLogPrefix(wrapper, wrapped): """ Compute a log prefix for a wrapper and the object it wraps. @rtype: C{str} """ if ILoggingContext.providedBy(wrapped): logPrefix = wrapped.logPrefix() else: logPrefix = wrapped.__class__.__name__ return f"{logPrefix} ({wrapper.__class__.__name__})" class ProtocolWrapper(Protocol): """ Wraps protocol instances and acts as their transport as well. @ivar wrappedProtocol: An L{IProtocol<twisted.internet.interfaces.IProtocol>} provider to which L{IProtocol<twisted.internet.interfaces.IProtocol>} method calls onto this L{ProtocolWrapper} will be proxied. @ivar factory: The L{WrappingFactory} which created this L{ProtocolWrapper}. """ disconnecting = 0 def __init__( self, factory: "WrappingFactory", wrappedProtocol: interfaces.IProtocol ): self.wrappedProtocol = wrappedProtocol self.factory = factory def logPrefix(self): """ Use a customized log prefix mentioning both the wrapped protocol and the current one. """ return _wrappedLogPrefix(self, self.wrappedProtocol) def makeConnection(self, transport): """ When a connection is made, register this wrapper with its factory, save the real transport, and connect the wrapped protocol to this L{ProtocolWrapper} to intercept any transport calls it makes. """ directlyProvides(self, providedBy(transport)) Protocol.makeConnection(self, transport) self.factory.registerProtocol(self) self.wrappedProtocol.makeConnection(self) # Transport relaying def write(self, data): self.transport.write(data) def writeSequence(self, data): self.transport.writeSequence(data) def loseConnection(self): self.disconnecting = 1 self.transport.loseConnection() def getPeer(self): return self.transport.getPeer() def getHost(self): return self.transport.getHost() def registerProducer(self, producer, streaming): self.transport.registerProducer(producer, streaming) def unregisterProducer(self): self.transport.unregisterProducer() def stopConsuming(self): self.transport.stopConsuming() def __getattr__(self, name): return getattr(self.transport, name) # Protocol relaying def dataReceived(self, data): self.wrappedProtocol.dataReceived(data) def connectionLost(self, reason): self.factory.unregisterProtocol(self) self.wrappedProtocol.connectionLost(reason) # Breaking reference cycle between self and wrappedProtocol. self.wrappedProtocol = None class WrappingFactory(ClientFactory): """ Wraps a factory and its protocols, and keeps track of them. """ protocol: Type[Protocol] = ProtocolWrapper def __init__(self, wrappedFactory): self.wrappedFactory = wrappedFactory self.protocols = {} def logPrefix(self): """ Generate a log prefix mentioning both the wrapped factory and this one. """ return _wrappedLogPrefix(self, self.wrappedFactory) def doStart(self): self.wrappedFactory.doStart() ClientFactory.doStart(self) def doStop(self): self.wrappedFactory.doStop() ClientFactory.doStop(self) def startedConnecting(self, connector): self.wrappedFactory.startedConnecting(connector) def clientConnectionFailed(self, connector, reason): self.wrappedFactory.clientConnectionFailed(connector, reason) def clientConnectionLost(self, connector, reason): self.wrappedFactory.clientConnectionLost(connector, reason) def buildProtocol(self, addr): return self.protocol(self, self.wrappedFactory.buildProtocol(addr)) def registerProtocol(self, p): """ Called by protocol to register itself. """ self.protocols[p] = 1 def unregisterProtocol(self, p): """ Called by protocols when they go away. """ del self.protocols[p] class ThrottlingProtocol(ProtocolWrapper): """ Protocol for L{ThrottlingFactory}. """ # wrap API for tracking bandwidth def write(self, data): self.factory.registerWritten(len(data)) ProtocolWrapper.write(self, data) def writeSequence(self, seq): self.factory.registerWritten(sum(map(len, seq))) ProtocolWrapper.writeSequence(self, seq) def dataReceived(self, data): self.factory.registerRead(len(data)) ProtocolWrapper.dataReceived(self, data) def registerProducer(self, producer, streaming): self.producer = producer ProtocolWrapper.registerProducer(self, producer, streaming) def unregisterProducer(self): del self.producer ProtocolWrapper.unregisterProducer(self) def throttleReads(self): self.transport.pauseProducing() def unthrottleReads(self): self.transport.resumeProducing() def throttleWrites(self): if hasattr(self, "producer"): self.producer.pauseProducing() def unthrottleWrites(self): if hasattr(self, "producer"): self.producer.resumeProducing() class ThrottlingFactory(WrappingFactory): """ Throttles bandwidth and number of connections. Write bandwidth will only be throttled if there is a producer registered. """ protocol = ThrottlingProtocol def __init__( self, wrappedFactory, maxConnectionCount=sys.maxsize, readLimit=None, writeLimit=None, ): WrappingFactory.__init__(self, wrappedFactory) self.connectionCount = 0 self.maxConnectionCount = maxConnectionCount self.readLimit = readLimit # max bytes we should read per second self.writeLimit = writeLimit # max bytes we should write per second self.readThisSecond = 0 self.writtenThisSecond = 0 self.unthrottleReadsID = None self.checkReadBandwidthID = None self.unthrottleWritesID = None self.checkWriteBandwidthID = None def callLater(self, period, func): """ Wrapper around L{reactor.callLater<twisted.internet.interfaces.IReactorTime.callLater>} for test purpose. """ from twisted.internet import reactor return reactor.callLater(period, func) def registerWritten(self, length): """ Called by protocol to tell us more bytes were written. """ self.writtenThisSecond += length def registerRead(self, length): """ Called by protocol to tell us more bytes were read. """ self.readThisSecond += length def checkReadBandwidth(self): """ Checks if we've passed bandwidth limits. """ if self.readThisSecond > self.readLimit: self.throttleReads() throttleTime = (float(self.readThisSecond) / self.readLimit) - 1.0 self.unthrottleReadsID = self.callLater(throttleTime, self.unthrottleReads) self.readThisSecond = 0 self.checkReadBandwidthID = self.callLater(1, self.checkReadBandwidth) def checkWriteBandwidth(self): if self.writtenThisSecond > self.writeLimit: self.throttleWrites() throttleTime = (float(self.writtenThisSecond) / self.writeLimit) - 1.0 self.unthrottleWritesID = self.callLater( throttleTime, self.unthrottleWrites ) # reset for next round self.writtenThisSecond = 0 self.checkWriteBandwidthID = self.callLater(1, self.checkWriteBandwidth) def throttleReads(self): """ Throttle reads on all protocols. """ log.msg("Throttling reads on %s" % self) for p in self.protocols.keys(): p.throttleReads() def unthrottleReads(self): """ Stop throttling reads on all protocols. """ self.unthrottleReadsID = None log.msg("Stopped throttling reads on %s" % self) for p in self.protocols.keys(): p.unthrottleReads() def throttleWrites(self): """ Throttle writes on all protocols. """ log.msg("Throttling writes on %s" % self) for p in self.protocols.keys(): p.throttleWrites() def unthrottleWrites(self): """ Stop throttling writes on all protocols. """ self.unthrottleWritesID = None log.msg("Stopped throttling writes on %s" % self) for p in self.protocols.keys(): p.unthrottleWrites() def buildProtocol(self, addr): if self.connectionCount == 0: if self.readLimit is not None: self.checkReadBandwidth() if self.writeLimit is not None: self.checkWriteBandwidth() if self.connectionCount < self.maxConnectionCount: self.connectionCount += 1 return WrappingFactory.buildProtocol(self, addr) else: log.msg("Max connection count reached!") return None def unregisterProtocol(self, p): WrappingFactory.unregisterProtocol(self, p) self.connectionCount -= 1 if self.connectionCount == 0: if self.unthrottleReadsID is not None: self.unthrottleReadsID.cancel() if self.checkReadBandwidthID is not None: self.checkReadBandwidthID.cancel() if self.unthrottleWritesID is not None: self.unthrottleWritesID.cancel() if self.checkWriteBandwidthID is not None: self.checkWriteBandwidthID.cancel() class SpewingProtocol(ProtocolWrapper): def dataReceived(self, data): log.msg("Received: %r" % data) ProtocolWrapper.dataReceived(self, data) def write(self, data): log.msg("Sending: %r" % data) ProtocolWrapper.write(self, data) class SpewingFactory(WrappingFactory): protocol = SpewingProtocol class LimitConnectionsByPeer(WrappingFactory): maxConnectionsPerPeer = 5 def startFactory(self): self.peerConnections = {} def buildProtocol(self, addr): peerHost = addr[0] connectionCount = self.peerConnections.get(peerHost, 0) if connectionCount >= self.maxConnectionsPerPeer: return None self.peerConnections[peerHost] = connectionCount + 1 return WrappingFactory.buildProtocol(self, addr) def unregisterProtocol(self, p): peerHost = p.getPeer()[1] self.peerConnections[peerHost] -= 1 if self.peerConnections[peerHost] == 0: del self.peerConnections[peerHost] class LimitTotalConnectionsFactory(ServerFactory): """ Factory that limits the number of simultaneous connections. @type connectionCount: C{int} @ivar connectionCount: number of current connections. @type connectionLimit: C{int} or L{None} @cvar connectionLimit: maximum number of connections. @type overflowProtocol: L{Protocol} or L{None} @cvar overflowProtocol: Protocol to use for new connections when connectionLimit is exceeded. If L{None} (the default value), excess connections will be closed immediately. """ connectionCount = 0 connectionLimit = None overflowProtocol: Optional[Type[Protocol]] = None def buildProtocol(self, addr): if self.connectionLimit is None or self.connectionCount < self.connectionLimit: # Build the normal protocol wrappedProtocol = self.protocol() elif self.overflowProtocol is None: # Just drop the connection return None else: # Too many connections, so build the overflow protocol wrappedProtocol = self.overflowProtocol() wrappedProtocol.factory = self protocol = ProtocolWrapper(self, wrappedProtocol) self.connectionCount += 1 return protocol def registerProtocol(self, p): pass def unregisterProtocol(self, p): self.connectionCount -= 1 class TimeoutProtocol(ProtocolWrapper): """ Protocol that automatically disconnects when the connection is idle. """ def __init__(self, factory, wrappedProtocol, timeoutPeriod): """ Constructor. @param factory: An L{TimeoutFactory}. @param wrappedProtocol: A L{Protocol} to wrapp. @param timeoutPeriod: Number of seconds to wait for activity before timing out. """ ProtocolWrapper.__init__(self, factory, wrappedProtocol) self.timeoutCall = None self.timeoutPeriod = None self.setTimeout(timeoutPeriod) def setTimeout(self, timeoutPeriod=None): """ Set a timeout. This will cancel any existing timeouts. @param timeoutPeriod: If not L{None}, change the timeout period. Otherwise, use the existing value. """ self.cancelTimeout() self.timeoutPeriod = timeoutPeriod if timeoutPeriod is not None: self.timeoutCall = self.factory.callLater( self.timeoutPeriod, self.timeoutFunc ) def cancelTimeout(self): """ Cancel the timeout. If the timeout was already cancelled, this does nothing. """ self.timeoutPeriod = None if self.timeoutCall: try: self.timeoutCall.cancel() except (error.AlreadyCalled, error.AlreadyCancelled): pass self.timeoutCall = None def resetTimeout(self): """ Reset the timeout, usually because some activity just happened. """ if self.timeoutCall: self.timeoutCall.reset(self.timeoutPeriod) def write(self, data): self.resetTimeout() ProtocolWrapper.write(self, data) def writeSequence(self, seq): self.resetTimeout() ProtocolWrapper.writeSequence(self, seq) def dataReceived(self, data): self.resetTimeout() ProtocolWrapper.dataReceived(self, data) def connectionLost(self, reason): self.cancelTimeout() ProtocolWrapper.connectionLost(self, reason) def timeoutFunc(self): """ This method is called when the timeout is triggered. By default it calls I{loseConnection}. Override this if you want something else to happen. """ self.loseConnection() class TimeoutFactory(WrappingFactory): """ Factory for TimeoutWrapper. """ protocol = TimeoutProtocol def __init__(self, wrappedFactory, timeoutPeriod=30 * 60): self.timeoutPeriod = timeoutPeriod WrappingFactory.__init__(self, wrappedFactory) def buildProtocol(self, addr): return self.protocol( self, self.wrappedFactory.buildProtocol(addr), timeoutPeriod=self.timeoutPeriod, ) def callLater(self, period, func): """ Wrapper around L{reactor.callLater<twisted.internet.interfaces.IReactorTime.callLater>} for test purpose. """ from twisted.internet import reactor return reactor.callLater(period, func) class TrafficLoggingProtocol(ProtocolWrapper): def __init__(self, factory, wrappedProtocol, logfile, lengthLimit=None, number=0): """ @param factory: factory which created this protocol. @type factory: L{protocol.Factory}. @param wrappedProtocol: the underlying protocol. @type wrappedProtocol: C{protocol.Protocol}. @param logfile: file opened for writing used to write log messages. @type logfile: C{file} @param lengthLimit: maximum size of the datareceived logged. @type lengthLimit: C{int} @param number: identifier of the connection. @type number: C{int}. """ ProtocolWrapper.__init__(self, factory, wrappedProtocol) self.logfile = logfile self.lengthLimit = lengthLimit self._number = number def _log(self, line): self.logfile.write(line + "\n") self.logfile.flush() def _mungeData(self, data): if self.lengthLimit and len(data) > self.lengthLimit: data = data[: self.lengthLimit - 12] + "<... elided>" return data # IProtocol def connectionMade(self): self._log("*") return ProtocolWrapper.connectionMade(self) def dataReceived(self, data): self._log("C %d: %r" % (self._number, self._mungeData(data))) return ProtocolWrapper.dataReceived(self, data) def connectionLost(self, reason): self._log("C %d: %r" % (self._number, reason)) return ProtocolWrapper.connectionLost(self, reason) # ITransport def write(self, data): self._log("S %d: %r" % (self._number, self._mungeData(data))) return ProtocolWrapper.write(self, data) def writeSequence(self, iovec): self._log("SV %d: %r" % (self._number, [self._mungeData(d) for d in iovec])) return ProtocolWrapper.writeSequence(self, iovec) def loseConnection(self): self._log("S %d: *" % (self._number,)) return ProtocolWrapper.loseConnection(self) class TrafficLoggingFactory(WrappingFactory): protocol = TrafficLoggingProtocol _counter = 0 def __init__(self, wrappedFactory, logfilePrefix, lengthLimit=None): self.logfilePrefix = logfilePrefix self.lengthLimit = lengthLimit WrappingFactory.__init__(self, wrappedFactory) def open(self, name): return open(name, "w") def buildProtocol(self, addr): self._counter += 1 logfile = self.open(self.logfilePrefix + "-" + str(self._counter)) return self.protocol( self, self.wrappedFactory.buildProtocol(addr), logfile, self.lengthLimit, self._counter, ) def resetCounter(self): """ Reset the value of the counter used to identify connections. """ self._counter = 0 class TimeoutMixin: """ Mixin for protocols which wish to timeout connections. Protocols that mix this in have a single timeout, set using L{setTimeout}. When the timeout is hit, L{timeoutConnection} is called, which, by default, closes the connection. @cvar timeOut: The number of seconds after which to timeout the connection. """ timeOut: Optional[int] = None __timeoutCall = None def callLater(self, period, func): """ Wrapper around L{reactor.callLater<twisted.internet.interfaces.IReactorTime.callLater>} for test purpose. """ from twisted.internet import reactor return reactor.callLater(period, func) def resetTimeout(self): """ Reset the timeout count down. If the connection has already timed out, then do nothing. If the timeout has been cancelled (probably using C{setTimeout(None)}), also do nothing. It's often a good idea to call this when the protocol has received some meaningful input from the other end of the connection. "I've got some data, they're still there, reset the timeout". """ if self.__timeoutCall is not None and self.timeOut is not None: self.__timeoutCall.reset(self.timeOut) def setTimeout(self, period): """ Change the timeout period @type period: C{int} or L{None} @param period: The period, in seconds, to change the timeout to, or L{None} to disable the timeout. """ prev = self.timeOut self.timeOut = period if self.__timeoutCall is not None: if period is None: try: self.__timeoutCall.cancel() except (error.AlreadyCancelled, error.AlreadyCalled): # Do nothing if the call was already consumed. pass self.__timeoutCall = None else: self.__timeoutCall.reset(period) elif period is not None: self.__timeoutCall = self.callLater(period, self.__timedOut) return prev def __timedOut(self): self.__timeoutCall = None self.timeoutConnection() def timeoutConnection(self): """ Called when the connection times out. Override to define behavior other than dropping the connection. """ self.transport.loseConnection() PK Mb�Z�"�r1 1 protocols/postfix.pynu �[��� # -*- test-case-name: twisted.test.test_postfix -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Postfix mail transport agent related protocols. """ import sys from collections import UserDict from urllib.parse import quote as _quote, unquote as _unquote from twisted.internet import defer, protocol from twisted.protocols import basic, policies from twisted.python import log # urllib's quote functions just happen to match # the postfix semantics. def quote(s): quoted = _quote(s) if isinstance(quoted, str): quoted = quoted.encode("ascii") return quoted def unquote(s): if isinstance(s, bytes): s = s.decode("ascii") quoted = _unquote(s) return quoted.encode("ascii") class PostfixTCPMapServer(basic.LineReceiver, policies.TimeoutMixin): """ Postfix mail transport agent TCP map protocol implementation. Receive requests for data matching given key via lineReceived, asks it's factory for the data with self.factory.get(key), and returns the data to the requester. None means no entry found. You can use postfix's postmap to test the map service:: /usr/sbin/postmap -q KEY tcp:localhost:4242 """ timeout = 600 delimiter = b"\n" def connectionMade(self): self.setTimeout(self.timeout) def sendCode(self, code, message=b""): """ Send an SMTP-like code with a message. """ self.sendLine(str(code).encode("ascii") + b" " + message) def lineReceived(self, line): self.resetTimeout() try: request, params = line.split(None, 1) except ValueError: request = line params = None try: f = getattr(self, "do_" + request.decode("ascii")) except AttributeError: self.sendCode(400, b"unknown command") else: try: f(params) except BaseException: excInfo = str(sys.exc_info()[1]).encode("ascii") self.sendCode(400, b"Command " + request + b" failed: " + excInfo) def do_get(self, key): if key is None: self.sendCode(400, b"Command 'get' takes 1 parameters.") else: d = defer.maybeDeferred(self.factory.get, key) d.addCallbacks(self._cbGot, self._cbNot) d.addErrback(log.err) def _cbNot(self, fail): msg = fail.getErrorMessage().encode("ascii") self.sendCode(400, msg) def _cbGot(self, value): if value is None: self.sendCode(500) else: self.sendCode(200, quote(value)) def do_put(self, keyAndValue): if keyAndValue is None: self.sendCode(400, b"Command 'put' takes 2 parameters.") else: try: key, value = keyAndValue.split(None, 1) except ValueError: self.sendCode(400, b"Command 'put' takes 2 parameters.") else: self.sendCode(500, b"put is not implemented yet.") class PostfixTCPMapDictServerFactory(UserDict, protocol.ServerFactory): """ An in-memory dictionary factory for PostfixTCPMapServer. """ protocol = PostfixTCPMapServer class PostfixTCPMapDeferringDictServerFactory(protocol.ServerFactory): """ An in-memory dictionary factory for PostfixTCPMapServer. """ protocol = PostfixTCPMapServer def __init__(self, data=None): self.data = {} if data is not None: self.data.update(data) def get(self, key): return defer.succeed(self.data.get(key)) PK Mb�Z��zi i protocols/haproxy/_parser.pynu �[��� # -*- test-case-name: twisted.protocols.haproxy.test.test_parser -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Parser for 'haproxy:' string endpoint. """ from typing import Mapping, Tuple from zope.interface import implementer from twisted.internet import interfaces from twisted.internet.endpoints import ( IStreamServerEndpointStringParser, _WrapperServerEndpoint, quoteStringArgument, serverFromString, ) from twisted.plugin import IPlugin from . import proxyEndpoint def unparseEndpoint(args: Tuple[object, ...], kwargs: Mapping[str, object]) -> str: """ Un-parse the already-parsed args and kwargs back into endpoint syntax. @param args: C{:}-separated arguments @param kwargs: C{:} and then C{=}-separated keyword arguments @return: a string equivalent to the original format which this was parsed as. """ description = ":".join( [quoteStringArgument(str(arg)) for arg in args] + sorted( "{}={}".format( quoteStringArgument(str(key)), quoteStringArgument(str(value)) ) for key, value in kwargs.items() ) ) return description @implementer(IPlugin, IStreamServerEndpointStringParser) class HAProxyServerParser: """ Stream server endpoint string parser for the HAProxyServerEndpoint type. @ivar prefix: See L{IStreamServerEndpointStringParser.prefix}. """ prefix = "haproxy" def parseStreamServer( self, reactor: interfaces.IReactorCore, *args: object, **kwargs: object ) -> _WrapperServerEndpoint: """ Parse a stream server endpoint from a reactor and string-only arguments and keyword arguments. @param reactor: The reactor. @param args: The parsed string arguments. @param kwargs: The parsed keyword arguments. @return: a stream server endpoint @rtype: L{IStreamServerEndpoint} """ subdescription = unparseEndpoint(args, kwargs) wrappedEndpoint = serverFromString(reactor, subdescription) return proxyEndpoint(wrappedEndpoint) PK Mb�Z�̼+ + 5 protocols/haproxy/__pycache__/_parser.cpython-310.pycnu �[��� o �bi � @ s� d Z ddlmZmZ ddlmZ ddlmZ ddlm Z m Z m Z m Z ddl mZ ddlmZ d eed f d eeef d efd d�Zeee �G dd� d��ZdS )z( Parser for 'haproxy:' string endpoint. � )�Mapping�Tuple)� implementer)� interfaces)�!IStreamServerEndpointStringParser�_WrapperServerEndpoint�quoteStringArgument�serverFromString)�IPlugin� )� proxyEndpoint�args.�kwargs�returnc C s. d� dd� | D �tdd� |�� D �� �}|S )a Un-parse the already-parsed args and kwargs back into endpoint syntax. @param args: C{:}-separated arguments @param kwargs: C{:} and then C{=}-separated keyword arguments @return: a string equivalent to the original format which this was parsed as. �:c S s g | ]}t t|���qS � )r �str)�.0�argr r �C/usr/lib/python3/dist-packages/twisted/protocols/haproxy/_parser.py� <listcomp>$ s z#unparseEndpoint.<locals>.<listcomp>c s s0 � | ]\}}d � tt|��tt|���V qdS )z{}={}N)�formatr r )r �key�valuer r r � <genexpr>% s � �� �z"unparseEndpoint.<locals>.<genexpr>)�join�sorted�items)r r � descriptionr r r �unparseEndpoint s ��� r c @ s0 e Zd ZdZdZdejdededefdd�Z d S ) �HAProxyServerParserz� Stream server endpoint string parser for the HAProxyServerEndpoint type. @ivar prefix: See L{IStreamServerEndpointStringParser.prefix}. �haproxy�reactorr r r c O s t ||�}t||�}t|�S )a[ Parse a stream server endpoint from a reactor and string-only arguments and keyword arguments. @param reactor: The reactor. @param args: The parsed string arguments. @param kwargs: The parsed keyword arguments. @return: a stream server endpoint @rtype: L{IStreamServerEndpoint} )r r r )�selfr" r r �subdescription�wrappedEndpointr r r �parseStreamServer9 s z%HAProxyServerParser.parseStreamServerN) �__name__� __module__� __qualname__�__doc__�prefixr � IReactorCore�objectr r& r r r r r / s ����r N)r* �typingr r �zope.interfacer �twisted.internetr �twisted.internet.endpointsr r r r �twisted.pluginr � r r- r r r r r r r �<module> s &PK Mb�Z��Gt� � 9 protocols/haproxy/__pycache__/_interfaces.cpython-310.pycnu �[��� o �bf � @ sH d Z ddlmZmZ ddlZG dd� dejj�ZG dd� dejj�Z dS )z0 Interfaces used by the PROXY protocol modules. � )�Tuple�UnionNc @ s4 e Zd ZdZej�d�Zej�d�Zej�d�Z dS )� IProxyInfoz8 Data container for PROXY protocol header data. z<The raw byestring that represents the PROXY protocol header.zNAn L{twisted.internet.interfaces.IAddress} representing the connection source.zSAn L{twisted.internet.interfaces.IAddress} representing the connection destination.N) �__name__� __module__� __qualname__�__doc__�zope� interface� Attribute�header�source� destination� r r �G/usr/lib/python3/dist-packages/twisted/protocols/haproxy/_interfaces.pyr s ���r c @ sH e Zd ZdZdedeeeef ed f fdd�Zdedefdd �Z d S ) � IProxyParserz? Streaming parser that handles PROXY protocol headers. �data�return)NNc C � dS )a� Consume a chunk of data and attempt to parse it. @param data: A bytestring. @type data: bytes @return: A two-tuple containing, in order, an L{IProxyInfo} and any bytes fed to the parser that followed the end of the header. Both of these values are None until a complete header is parsed. @raises InvalidProxyHeader: If the bytes fed to the parser create an invalid PROXY header. Nr )r r r r �feed$ � zIProxyParser.feed�linec C r )az Parse a bytestring as a full PROXY protocol header line. @param line: A bytestring that represents a valid HAProxy PROXY protocol header line. @type line: bytes @return: An L{IProxyInfo} containing the parsed data. @raises InvalidProxyHeader: If the bytestring does not represent a valid PROXY header. Nr )r r r r �parse3 r zIProxyParser.parseN) r r r r �bytesr r r r r r r r r r s &r ) r �typingr r �zope.interfacer r � Interfacer r r r r r �<module> s PK Mb�Z4�hP/ / 7 protocols/haproxy/__pycache__/_v2parser.cpython-310.pycnu �[��� o 5�@g� � @ s� d Z ddlZddlZddlmZmZmZmZmZ ddl m Z ddl m Z m Z ddlmZ ddlmZ dd lmZmZ dd lmZmZmZmZ G d d � d e �ZG d d� de �ZdZ dZ dZ dZ e ej �G dd� d��Z!dS )zD IProxyParser implementation for version two of the PROXY protocol. � N)�Callable�Literal�Tuple�Type�Union)� implementer)� ValueConstant�Values)�address)�compat� )�_info� _interfaces)�InvalidNetworkProtocol�InvalidProxyHeader�MissingAddressData� convertErrorc @ s0 e Zd ZdZed�Zed�Zed�Zed�ZdS )� NetFamilyz( Values for the 'family' field. r � � �0 N) �__name__� __module__� __qualname__�__doc__r �UNSPEC�INET�INET6�UNIX� r r �E/usr/lib/python3/dist-packages/twisted/protocols/haproxy/_v2parser.pyr s r c @ s( e Zd ZdZed�Zed�Zed�ZdS )� NetProtocolz& Values for 'protocol' field. r r � N)r r r r r r �STREAM�DGRAMr r r r r! ( s r! �� � �LOCAL�PROXYc @ s� e Zd ZdZdZdgZeed�Zddddddd�Z dd d �Z d e d e e eje f e d f fdd�Zede d e fdd��Zede d e fdd��Zede d ejfdd��Zd S )�V2Parserzn PROXY protocol version two header parser. Version two of the PROXY protocol is a binary format. s QUIT r )r r z!4s4s2Hz !16s16s2Hz !108s108s)� � �! �" �1 �2 �returnNc C s d| _ d S )N� )�buffer)�selfr r r �__init__O s zV2Parser.__init__�data�NNc C s� | j |7 _ t| j �dk rt� �t�d| j dd� �d d }t| j �|k r)dS | j d|� | j |d� }}d| _ | �|�}||fS )a� Consume a chunk of data and attempt to parse it. @param data: A bytestring. @type data: bytes @return: A two-tuple containing, in order, a L{_interfaces.IProxyInfo} and any bytes fed to the parser that followed the end of the header. Both of these values are None until a complete header is parsed. @raises InvalidProxyHeader: If the bytes fed to the parser create an invalid PROXY header. r z!H� r r6 Nr1 )r2 �lenr �struct�unpack�parse)r3 r5 �size�header� remaining�infor r r �feedR s z V2Parser.feed� bytestringc C s d� dd� t�| �D ��S )a7 Convert packed 32-bit IPv4 address bytes into a dotted-quad ASCII bytes representation of that address. @param bytestring: 4 octets representing an IPv4 address. @type bytestring: L{bytes} @return: a dotted-quad notation IPv4 address. @rtype: L{bytes} � .c s s$ � | ] }d t |�f �d�V qdS )z%i�asciiN)�ord�encode��.0�br r r � <genexpr>| s � �z(V2Parser._bytesToIPv4.<locals>.<genexpr>)�joinr � iterbytes�rA r r r � _bytesToIPv4p s �zV2Parser._bytesToIPv4c s* t �| �� d�� fdd�tddd�D ��S )a= Convert packed 128-bit IPv6 address bytes into a colon-separated ASCII bytes representation of that address. @param bytestring: 16 octets representing an IPv6 address. @type bytestring: L{bytes} @return: a dotted-quad notation IPv6 address. @rtype: L{bytes} � :c 3 s0 � | ]}t � ||d � d�d��d�V qdS )� r �xrC N)�intrE rF �� hexStringr r rI � s � � �z(V2Parser._bytesToIPv6.<locals>.<genexpr>r r rO )�binascii�b2a_hexrJ �rangerL r rR r � _bytesToIPv6� s �zV2Parser._bytesToIPv6�linec C sX |dd� }d}t tt�� t|dd� �}t|dd� �}W d � n1 s(w Y || jkr5t� �|t@ |t@ }}|| jvsH|| jvrKt� �| j| t krYt � |dd�S |t@ |t@ }} t t t �� t�|�}t�| �} W d � n1 s|w Y |tju s�| tju r�t � |dd�S | j| } |ddt�| � � }|tju r�t tjt�� t�| |�\} } W d � n1 s�w Y t � |t�| �d��t�| �d���S d} | tj u r�d} tj }| j }|tj u r�tj }| j!}t tjt�� t�| |�}|\} } }}W d � n 1 �sw Y t � ||| || ��"� |�|| || ��"� |��S ) a� Parse a bytestring as a full PROXY protocol header. @param line: A bytestring that represents a valid HAProxy PROXY protocol version 2 header. @type line: bytes @return: A L{_interfaces.IProxyInfo} containing the parsed data. @raises InvalidProxyHeader: If the bytestring does not represent a valid PROXY header. N� � r7 r � �TCP�UDP)#r � IndexErrorr rD �PREFIX�_HIGH�_LOW�VERSIONS�COMMANDS� _LOCALCOMMANDr � ProxyInfo� ValueErrorr r � lookupByValuer! r �ADDRESSFORMATSr9 �calcsizer �errorr r: r � UNIXAddress�rstripr$ � IPv4AddressrM r � IPv6AddressrW �decode)�clsrX �prefix�addrInfo�versionCommand� familyProto�version�command�family�netproto� addressFormat�source�dest�addrType�addrCls� addrParserr? �sPort�dPortr r r r; � sb � � �� � ��zV2Parser.parse)r0 N)r r r r r_ rb rd � _PROXYCOMMANDrc rh r4 �bytesr r r re r@ � staticmethodrM rW � classmethodr; r r r r r) 8 s0 � � � r) )"r rT r9 �typingr r r r r �zope.interfacer � constantlyr r �twisted.internetr �twisted.pythonr � r r � _exceptionsr r r r r r! r` ra rd r� � IProxyParserr) r r r r �<module> s$ PK Mb�ZJ[��} } 3 protocols/haproxy/__pycache__/_info.cpython-310.pycnu �[��� o �b� � @ sf d Z ddlmZ ddlmZ ddlZddlmZ ddlm Z ee �ej dddd �G d d � d ���Z dS ) z IProxyInfo implementation. � )�Optional)� implementerN)�IAddress� )� IProxyInfoT)�frozen�slots� auto_attribsc @ s2 e Zd ZU dZeed< ee ed< ee ed< dS )� ProxyInfoa� A data container for parsed PROXY protocol information. @ivar header: The raw header bytes extracted from the connection. @type header: C{bytes} @ivar source: The connection source address. @type source: L{twisted.internet.interfaces.IAddress} @ivar destination: The connection destination address. @type destination: L{twisted.internet.interfaces.IAddress} �header�source� destinationN)�__name__� __module__� __qualname__�__doc__�bytes�__annotations__r r � r r �A/usr/lib/python3/dist-packages/twisted/protocols/haproxy/_info.pyr s r ) r �typingr �zope.interfacer �attr�twisted.internet.interfacesr � _interfacesr �sr r r r r �<module> s PK Mb�Z[�k 6 protocols/haproxy/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dgZddlmZ dS )z) HAProxy PROXY protocol implementations. � proxyEndpoint� )r N)�__doc__�__all__�_wrapperr � r r �D/usr/lib/python3/dist-packages/twisted/protocols/haproxy/__init__.py�<module> s PK Mb�Z���} } 6 protocols/haproxy/__pycache__/_wrapper.cpython-310.pycnu �[��� o �b] � @ s� d Z ddlmZmZ ddlmZ ddlmZ ddlm Z ddl m Z ddl m Z dd lmZ dd lmZ G d d � d e j�ZG d d� de j�Zdejdefdd�ZdS )z@ Protocol wrapper that provides HAProxy PROXY protocol support. � )�Optional�Union)� interfaces)�_WrapperServerEndpoint)�policies� )�_info)�InvalidProxyHeader)�V1Parser)�V2Parserc s` e Zd ZdZdejdejf� fdd� Zde ddfd d �Z dej fd d �Z dej fd d�Z � ZS )�HAProxyProtocolWrappera A Protocol wrapper that provides HAProxy support. This protocol reads the PROXY stream header, v1 or v2, parses the provided connection data, and modifies the behavior of getPeer and getHost to return the data provided by the PROXY header. �factory�wrappedProtocolc s t � �||� d | _d | _d S �N)�super�__init__� _proxyInfo�_parser)�selfr r �� __class__� �D/usr/lib/python3/dist-packages/twisted/protocols/haproxy/_wrapper.pyr s z HAProxyProtocolWrapper.__init__�data�returnNc C s� | j d ur | j�|�S | j}|d u rPt|�dkr4|d d� tjkr4t|dd� �d@ dkr4t� | _}n t|�dkrJ|d d� tj krJt� | _}n| � � d S z|� |�\| _ }|rd| j�|� W d S W d S t yt | � � Y d S w )N� � � �� � � � ) r r � dataReceivedr �lenr �PREFIX�ordr �PROXYSTR�loseConnection�feedr )r r �parser� remainingr r r r" $ s( � �z#HAProxyProtocolWrapper.dataReceivedc C �* | j r | j jr | j jS | jsJ �| j�� S r )r �source� transport�getPeer�r r r r r. = � z HAProxyProtocolWrapper.getPeerc C r+ r )r � destinationr- �getHostr/ r r r r2 C r0 z HAProxyProtocolWrapper.getHost)�__name__� __module__� __qualname__�__doc__r �WrappingFactoryr � IProtocolr �bytesr" �IAddressr. r2 � __classcell__r r r r r s ��r c @ s" e Zd ZdZeZdefdd�ZdS )�HAProxyWrappingFactoryzL A Factory wrapper that adds PROXY protocol support to connections. r c C s. t j�| j�r | j�� }n| jjj}|� d�S )z� Annotate the wrapped factory's log prefix with some text indicating the PROXY protocol is in use. @rtype: C{str} z (PROXY))r �ILoggingContext� providedBy�wrappedFactory� logPrefixr r3 )r r@ r r r r@ Q s z HAProxyWrappingFactory.logPrefixN)r3 r4 r5 r6 r �protocol�strr@ r r r r r< J s r< �wrappedEndpointr c C s t | t�S )a� Wrap an endpoint with PROXY protocol support, so that the transport's C{getHost} and C{getPeer} methods reflect the attributes of the proxied connection rather than the underlying connection. @param wrappedEndpoint: The underlying listening endpoint. @type wrappedEndpoint: L{IStreamServerEndpoint} @return: a new listening endpoint that speaks the PROXY protocol. @rtype: L{IStreamServerEndpoint} )r r< )rC r r r � proxyEndpoint_ s rD N)r6 �typingr r �twisted.internetr �twisted.internet.endpointsr �twisted.protocolsr � r � _exceptionsr � _v1parserr � _v2parserr �ProtocolWrapperr r7 r< �IStreamServerEndpointrD r r r r �<module> s 6��PK Mb�ZN�)�T T 7 protocols/haproxy/__pycache__/_v1parser.cpython-310.pycnu �[��� o �b� � @ sp d Z ddlmZmZ ddlmZ ddlmZ ddlm Z m Z ddl m Z m Z mZmZ ee j�G dd � d ��Zd S ) zD IProxyParser implementation for version one of the PROXY protocol. � )�Tuple�Union)� implementer)�address� )�_info� _interfaces)�InvalidNetworkProtocol�InvalidProxyHeader�MissingAddressData� convertErrorc @ sx e Zd ZdZdZdZdZdZeeefZdZ dd d �Z d e de e eje f e d f fd d�Zede dejfdd��ZdS )�V1Parserz� PROXY protocol version one header parser. Version one of the PROXY protocol is a human readable format represented by a single, newline delimited binary string that contains all of the relevant source and destination data. s PROXYs UNKNOWNs TCP4s TCP6s �returnNc C s d| _ d S )N� )�buffer)�self� r �E/usr/lib/python3/dist-packages/twisted/protocols/haproxy/_v1parser.py�__init__, s zV1Parser.__init__�data�NNc C sv | j |7 _ t| j �dkr| j| j vrt� �| j �| jd�}t|�dks'dS d| _ |�� }|�� }| �|�}||fS )a� Consume a chunk of data and attempt to parse it. @param data: A bytestring. @type data: L{bytes} @return: A two-tuple containing, in order, a L{_interfaces.IProxyInfo} and any bytes fed to the parser that followed the end of the header. Both of these values are None until a complete header is parsed. @raises InvalidProxyHeader: If the bytes fed to the parser create an invalid PROXY header. �k r r r )r �len�NEWLINEr �split�pop�parse)r r �lines� remaining�header�infor r r �feed/ s z V1Parser.feed�linec C s |}d}d}d}d}d}d}t tt�� |�dd�\}}W d � n1 s&w Y || jkr3t� �t tt�� |�dd�\}}W d � n1 sKw Y || jvrXt� �|| jkrdt� |dd�S t tt �� |�dd�\}}W d � n1 s|w Y t tt �� |�dd�\}}W d � n1 s�w Y t tt �� |�dd�\}}W d � n1 s�w Y t tt �� |�d�d }W d � n1 s�w Y || j kr�t� |t � d|�� t|��t � d|�� t|���S t� |t �d|�� t|��t �d|�� t|���S )a� Parse a bytestring as a full PROXY protocol header line. @param line: A bytestring that represents a valid HAProxy PROXY protocol header line. @type line: bytes @return: A L{_interfaces.IProxyInfo} containing the parsed data. @raises InvalidProxyHeader: If the bytestring does not represent a valid PROXY header. @raises InvalidNetworkProtocol: When no protocol can be parsed or is not one of the allowed values. @raises MissingAddressData: When the protocol is TCP* but the header does not contain a complete set of addresses and ports. N� r r �TCP)r � ValueErrorr r �PROXYSTRr �ALLOWED_NET_PROTOS� UNKNOWN_PROTOr � ProxyInfor � TCP4_PROTOr � IPv4Address�decode�int� IPv6Address) �clsr" � originalLine�proxyStr�networkProtocol� sourceAddr� sourcePort�destAddr�destPortr r r r L sT � � � � � � ��zV1Parser.parse)r N)�__name__� __module__� __qualname__�__doc__r& r( r* � TCP6_PROTOr' r r �bytesr r r r) r! � classmethodr r r r r r s& � � � r N)r: �typingr r �zope.interfacer �twisted.internetr � r r � _exceptionsr r r r � IProxyParserr r r r r �<module> s PK Mb�Z ,�$ $ 9 protocols/haproxy/__pycache__/_exceptions.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlmZmZmZ G dd� de�ZG dd� de�ZG dd � d e�Z ej d ee d eg e f d ed fdd��Z dS )z HAProxy specific exceptions. � N)�Callable� Generator�Typec @ � e Zd ZdZdS )�InvalidProxyHeaderz8 The provided PROXY protocol header is invalid. N��__name__� __module__� __qualname__�__doc__� r r �G/usr/lib/python3/dist-packages/twisted/protocols/haproxy/_exceptions.pyr � r c @ r )�InvalidNetworkProtocolzC The network protocol was not one of TCP4 TCP6 or UNKNOWN. Nr r r r r r r r c @ r )�MissingAddressDataz4 The address data is missing or incomplete. Nr r r r r r r r � sourceType� targetType�return)NNNc c s6 � zdV W dS | y } z|� � |j��d}~ww )aA Convert an error into a different error type. @param sourceType: The type of exception that should be caught and converted. @type sourceType: L{BaseException} @param targetType: The type of exception to which the original should be converted. @type targetType: L{BaseException} N)�with_traceback� __traceback__)r r �er r r � convertError s � ��r ) r � contextlib�typingr r r � Exceptionr r r �contextmanager� BaseExceptionr r r r r �<module> s � ��PK Mb�ZnȷA� � ; protocols/haproxy/test/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z. Unit tests for L{twisted.protocols.haproxy}. N)�__doc__� r r �I/usr/lib/python3/dist-packages/twisted/protocols/haproxy/test/__init__.py�<module> s PK Mb�Zq��MS$ S$ ? protocols/haproxy/test/__pycache__/test_wrapper.cpython-310.pycnu �[��� o �b�6 � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZm Z ddl m Z ddl mZ dd l mZ G d d � d e �ZG d d � d ej�ZG dd� dej�ZdS )z> Test cases for L{twisted.protocols.haproxy.HAProxyProtocol}. � )�Optional)�mock)�address)�Factory�Protocol)� StringTransportWithDisconnection)�unittest� )�HAProxyWrappingFactoryc @ s, e Zd ZdZd dd�Zdeddfdd�ZdS ) �StaticProtocolz6 Protocol stand-in that maintains test state. �returnNc C s d | _ d | _d| _d| _d S )N� F)�source� destination�data� disconnected)�self� r �M/usr/lib/python3/dist-packages/twisted/protocols/haproxy/test/test_wrapper.py�__init__ s zStaticProtocol.__init__r c C s4 | j sJ �| j �� | _| j �� | _| j|7 _d S )N)� transport�getPeerr �getHostr r )r r r r r � dataReceived s zStaticProtocol.dataReceived�r N)�__name__� __module__� __qualname__�__doc__r �bytesr r r r r r s r c @ s` e Zd ZdZddd�Zddd�Zddd �Zdd d �Zdd d �Zddd�Z ddd�Z ddd�Z dS )� HAProxyWrappingFactoryV1Testsz] Test L{twisted.protocols.haproxy.HAProxyWrappingFactory} with v1 PROXY headers. r Nc C sR t t�t��}|�t�ddd��}t� }||_|� |� |� d� | � |j � dS )�J Test if invalid headers result in connectionLost events. �TCP� 127.1.1.1� s NOTPROXY anything can go here N� r r � forProtocolr � buildProtocolr � IPv4Addressr �protocol�makeConnectionr � assertFalse� connected�r �factory�protor r r r � test_invalidHeaderDisconnects) s � z;HAProxyWrappingFactoryV1Tests.test_invalidHeaderDisconnectsc C s\ t t�t��}|�t�ddd��}t� }||_|� |� |� d� |� d� | � |j � dS )r! r" r# r$ s PROXY TCP4 1.1.1.1 s 2.2.2.2 8080 Nr% r- r r r �$test_invalidPartialHeaderDisconnects7 s � zBHAProxyWrappingFactoryV1Tests.test_invalidPartialHeaderDisconnectsc C sl t t�t��}|�t�ddd��}ttj j tj j d�}|� |� | � |�� tj j � | � |�� tj j � dS )z� Before any data is received the HAProxy protocol will return the same peer and host as the IP connection. r" � 127.0.0.1r$ )� hostAddress� peerAddressN)r r r& r r' r r( r r �sentinel� host_address� peer_addressr* � assertEqualr r r- r r r � test_preDataReceived_getPeerHostF s �� z>HAProxyWrappingFactoryV1Tests.test_preDataReceived_getPeerHostc C s� t t�t��}|�t�ddd��}t� }|�|� |� d� | � |� � j d� | � |� � j d� | � |jj� � j d� | � |jj� � j d� | � |�� j d� | � |�� j d� | � |jj�� j d� | � |jj�� j d� dS ) �P Test if IPv4 headers result in the correct host and peer data. r" r2 r$ s& PROXY TCP4 1.1.1.1 2.2.2.2 8080 8888 z1.1.1.1z2.2.2.2�" N)r r r& r r' r r( r r* r r8 r �host�port�wrappedProtocolr r r- r r r �(test_validIPv4HeaderResolves_getPeerHostW �6 � � � � �zFHAProxyWrappingFactoryV1Tests.test_validIPv4HeaderResolves_getPeerHostc C s� t t�t��}|�t�ddd��}t� }|�|� |� d� | � |� � j d� | � |� � j d� | � |jj� � j d� | � |jj� � j d� | � |�� j d� | � |�� j d� | � |jj�� j d� | � |jj�� j d� dS )�P Test if IPv6 headers result in the correct host and peer data. r" �::1r$ s PROXY TCP6 ::1 ::2 8080 8888 z::2r; N)r r r& r r' r � IPv6Addressr r* r r8 r r< r= r> r r r- r r r �(test_validIPv6HeaderResolves_getPeerHostw r@ zFHAProxyWrappingFactoryV1Tests.test_validIPv6HeaderResolves_getPeerHostc C sP t t�t��}|�t�ddd��}t� }|�|� |� d� | � |j j d� dS )�N Test if non-header bytes are passed to the wrapped protocol. r" rB r$ s, PROXY TCP6 ::1 ::2 8080 8888 HTTP/1.1 / GET� HTTP/1.1 / GETN� r r r& r r' r rC r r* r r8 r> r r- r r r �'test_overflowBytesSentToWrappedProtocol� s � zEHAProxyWrappingFactoryV1Tests.test_overflowBytesSentToWrappedProtocolc C sZ t t�t��}|�t�ddd��}t� }|�|� |� d� |� d� | � |j j d� dS )�K Test if header streaming passes extra data appropriately. r" rB r$ � PROXY TCP6 ::1 ::2 � 8080 8888 HTTP/1.1 / GETrF NrG r- r r r �-test_overflowBytesSentToWrappedProtocolChunks� s � zKHAProxyWrappingFactoryV1Tests.test_overflowBytesSentToWrappedProtocolChunksc C sd t t�t��}|�t�ddd��}t� }|�|� |� d� |� d� |� d� | � |j j d� dS ) zT Test if wrapper writes all data to wrapped protocol after parsing. r" rB r$ rJ rK s s HTTP/1.1 / GET NrG r- r r r �,test_overflowBytesSentToWrappedProtocolAfter� s � zJHAProxyWrappingFactoryV1Tests.test_overflowBytesSentToWrappedProtocolAfterr ) r r r r r0 r1 r9 r? rD rH rL rM r r r r r # s r c @ sd e Zd ZdZdZdZdZde e Zddd �Zdd d �Z dd d �Z ddd�Z ddd�Z ddd�Z dS )� HAProxyWrappingFactoryV2Testsz] Test L{twisted.protocols.haproxy.HAProxyWrappingFactory} with v2 PROXY headers. s QUIT ! �"�s4 QUIT !! $ �"�sl /home/tests/mysockets/sock s QUIT !1 �r Nc C s` t t�t��}|�t�ddd��}t� }||_|� |� |� d| j dd� � | � |j � dS )r! r" rB r$ � � N)r r r& r r' r rC r r) r* r � IPV4HEADERr+ r, r- r r r r0 � s � z;HAProxyWrappingFactoryV2Tests.test_invalidHeaderDisconnectsc C s� t t�t��}|�t�ddd��}t� }|�|� |� | j � | � |� � j d� | � |� � jd� | � |jj� � j d� | � |jj� � jd� | � |�� j d� | � |�� jd� | � |jj�� j d� | � |jj�� jd� dS )r: r" r2 r$ r; N)r r r& r r' r r( r r* r rQ r8 r r< r= r> r r r- r r r r? �6 � � � � �zFHAProxyWrappingFactoryV2Tests.test_validIPv4HeaderResolves_getPeerHostc C s� t t�t��}|�t�ddd��}t� }|�|� |� | j � | � |� � j d� | � |� � jd� | � |jj� � j d� | � |jj� � jd� | � |�� j d� | � |�� jd� | � |jj�� j d� | � |jj�� jd� dS )rA r" rB r$ z0:0:0:0:0:0:0:1r; N)r r r& r r' r r( r r* r � IPV6HEADERr8 r r< r= r> r r r- r r r rD ( rR zFHAProxyWrappingFactoryV2Tests.test_validIPv6HeaderResolves_getPeerHostc C s� t t�t��}|�t�d��}t� }|�|� |� | j � | � |� � j d� | � |jj� � j d� | � |�� j d� | � |jj�� j d� dS )zP Test if UNIX headers result in the correct host and peer data. s /home/test/sockets/server.socks /home/tests/mysockets/sockN)r r r& r r' r � UNIXAddressr r* r � UNIXHEADERr8 r �namer> r r r- r r r �(test_validUNIXHeaderResolves_getPeerHostH s" � � �zFHAProxyWrappingFactoryV2Tests.test_validUNIXHeaderResolves_getPeerHostc C sV t t�t��}|�t�ddd��}t� }|�|� |� | j d � | � |j j d� dS )rE r" rB r$ rF N�r r r& r r' r rC r r* r rS r8 r> r r- r r r rH ^ s � zEHAProxyWrappingFactoryV2Tests.test_overflowBytesSentToWrappedProtocolc C sr t t�t��}|�t�ddd��}t� }|�|� |� | j dd� � |� | j dd� d � | � |j j d� dS )rI r" rB r$ N� rF rX r- r r r rL k s � zKHAProxyWrappingFactoryV2Tests.test_overflowBytesSentToWrappedProtocolChunksr )r r r r rQ rS � _SOCK_PATHrU r0 r? rD rW rH rL r r r r rN � s( ��� � �� rN N)r �typingr r r �twisted.internetr �twisted.internet.protocolr r �twisted.test.proto_helpersr � twisted.trial�_wrapperr r �TestCaser rN r r r r �<module> s PK Mb�Z�E� � > protocols/haproxy/test/__pycache__/test_parser.cpython-310.pycnu �[��� o �b � @ s� d Z ddlmZmZ ddlmZmZmZmZ m Z m Z ddl m Z ddlmZ ddlmZ ddlmZ G d d � d e�ZG d d � d e�Zd S )z1 Tests for L{twisted.protocols.haproxy._parser}. � )�Type�Union)�TCP4ServerEndpoint�TCP6ServerEndpoint�UNIXServerEndpoint�_parse�_WrapperServerEndpoint�serverFromString)� MemoryReactor)�SynchronousTestCase� )�unparseEndpoint)�HAProxyWrappingFactoryc @ s^ e Zd ZdZdeddfdd�Zddd�Zdd d �Zdd d �Zdd d�Z ddd�Z ddd�Z dS )�UnparseEndpointTestszg Tests to ensure that un-parsing an endpoint string round trips through escaping properly. �input�returnNc C s | � tt|�� |� dS )aA Check that the input unparses into the output, raising an assertion error if it doesn't. @param input: an input in endpoint-string-description format. (To ensure determinism, keyword arguments should be in alphabetical order.) @type input: native L{str} N)� assertEqualr � parseEndpoint)�selfr � r �L/usr/lib/python3/dist-packages/twisted/protocols/haproxy/test/test_parser.py�check s zUnparseEndpointTests.checkc C � | � d� dS )z% An individual word. �wordN�r �r r r r �test_basicUnparse) � z&UnparseEndpointTests.test_basicUnparsec C r )z% Multiple arguments. zone:twoNr r r r r �test_multipleArguments/ r z+UnparseEndpointTests.test_multipleArgumentsc C r )z$ Keyword arguments. zaleph=one:bet=twoNr r r r r � test_keywords5 r z"UnparseEndpointTests.test_keywordsc C r )z Escaped ":". zhello\:colon\:worldNr r r r r �test_colonInArgument; r z)UnparseEndpointTests.test_colonInArgumentc C r )z/ Escaped ":" in keyword value. zhello=\:Nr r r r r �test_colonInKeywordValueA r z-UnparseEndpointTests.test_colonInKeywordValuec C r )z. Escaped ":" in keyword name. z\:=helloNr r r r r �test_colonInKeywordNameG r z,UnparseEndpointTests.test_colonInKeywordName�r N) �__name__� __module__� __qualname__�__doc__�strr r r r r r! r" r r r r r s r c @ sZ e Zd ZdZdedeee ee ee f de fdd�Z ddd �Z dd d �Z dd d �ZdS )�HAProxyServerParserTestsz@ Tests that the parser generates the correct endpoints. � description� expectedClassr c C sJ t � }t||�}| �|t� t|t�sJ �| �|j|� | �|jt� |S )a% Test the C{haproxy} enpdoint prefix against one sub-endpoint type. @param description: A string endpoint description beginning with C{haproxy}. @type description: native L{str} @param expectedClass: the expected sub-endpoint class given the description. @type expectedClass: L{type} @return: the parsed endpoint @rtype: L{IStreamServerEndpoint} @raise twisted.trial.unittest.Failtest: if the parsed endpoint doesn't match expectations. ) r r �assertIsInstancer � isinstance�_wrappedEndpoint�assertIs�_wrapperFactoryr )r r* r+ �reactor�endpointr r r � onePrefixS s z"HAProxyServerParserTests.onePrefixNc C � | � dt� dS )zG Test if the parser generates a wrapped TCP4 endpoint. zhaproxy:tcp:8080N)r3 r r r r r � test_tcp4u � z"HAProxyServerParserTests.test_tcp4c C r4 )zG Test if the parser generates a wrapped TCP6 endpoint. zhaproxy:tcp6:8080N)r3 r r r r r � test_tcp6{ r6 z"HAProxyServerParserTests.test_tcp6c C r4 )zG Test if the parser generates a wrapped UNIX endpoint. z haproxy:unix:address=/tmp/socketN)r3 r r r r r � test_unix� r6 z"HAProxyServerParserTests.test_unixr# )r$ r% r& r' r( r r r r r r r3 r5 r7 r8 r r r r r) N s" ���� � " r) N)r' �typingr r �twisted.internet.endpointsr r r r r r r �twisted.test.proto_helpersr �twisted.trial.unittestr �TestCase�_parserr �_wrapperr r r) r r r r �<module> s 7PK Mb�Z� >�$) $) @ protocols/haproxy/test/__pycache__/test_v2parser.cpython-310.pycnu �[��� o �b�. � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ dZ e ddd d d fd e d e de de de de de fdd�Z e ddddd fd e d e de de de de de fdd�Z e dddd fd e d e de de de de f d d �Z G d d � d ej�Zd!S )"z7 Test cases for L{twisted.protocols.haproxy.V2Parser}. � )�address)�unittest� )� _v2parser)�InvalidProxyHeaders QUIT � !s $s s �"��sig�verCom�famProto� addrLength�addrs�ports�returnc C � | | | | | | S )aV Construct a version 2 IPv6 header with custom bytes. @param sig: The protocol signature; defaults to valid L{V2_SIGNATURE}. @type sig: L{bytes} @param verCom: Protocol version and command. Defaults to V2 PROXY. @type verCom: L{bytes} @param famProto: Address family and protocol. Defaults to AF_INET6/STREAM. @type famProto: L{bytes} @param addrLength: Network-endian byte length of payload. Defaults to description of default addrs/ports. @type addrLength: L{bytes} @param addrs: Address payload. Defaults to C{::1} for source and destination. @type addrs: L{bytes} @param ports: Source and destination ports. Defaults to 8080 for source 8888 for destination. @type ports: L{bytes} @return: A packet with header, addresses, and ports. @rtype: L{bytes} � �r r r r r r r r �N/usr/lib/python3/dist-packages/twisted/protocols/haproxy/test/test_v2parser.py�_makeHeaderIPv6 � #r � s s c C r )aX Construct a version 2 IPv4 header with custom bytes. @param sig: The protocol signature; defaults to valid L{V2_SIGNATURE}. @type sig: L{bytes} @param verCom: Protocol version and command. Defaults to V2 PROXY. @type verCom: L{bytes} @param famProto: Address family and protocol. Defaults to AF_INET/STREAM. @type famProto: L{bytes} @param addrLength: Network-endian byte length of payload. Defaults to description of default addrs/ports. @type addrLength: L{bytes} @param addrs: Address payload. Defaults to 127.0.0.1 for source and destination. @type addrs: L{bytes} @param ports: Source and destination ports. Defaults to 8080 for source 8888 for destination. @type ports: L{bytes} @return: A packet with header, addresses, and ports. @rtype: L{bytes} r r r r r �_makeHeaderIPv46 r r � 1s �s� /home/tests/mysockets/sock /home/tests/mysockets/sock c C s | | | | | S )a� Construct a version 2 IPv4 header with custom bytes. @param sig: The protocol signature; defaults to valid L{V2_SIGNATURE}. @type sig: L{bytes} @param verCom: Protocol version and command. Defaults to V2 PROXY. @type verCom: L{bytes} @param famProto: Address family and protocol. Defaults to AF_UNIX/STREAM. @type famProto: L{bytes} @param addrLength: Network-endian byte length of payload. Defaults to 108 bytes for 2 null terminated paths. @type addrLength: L{bytes} @param addrs: Address payload. Defaults to C{/home/tests/mysockets/sock} for source and destination paths. @type addrs: L{bytes} @return: A packet with header, addresses, and8 ports. @rtype: L{bytes} r )r r r r r r r r �_makeHeaderUnix\ s #r c @ s e Zd ZdZd4dd�Zd4dd�Zd4dd �Zd4d d �Zd4d d �Zd4dd�Z d4dd�Z d4dd�Z d4dd�Z d4dd�Z d4dd�Zd4dd�Zd4d d �Zd4d d �Zd4d d!�Zd4d"d#�Zd4d$d%�Zd4d&d'�Zd4d(d)�Zd4d*d+�Zd4d,d-�Zd4d.d/�Zd4d0d1�Zd4d2d3�ZdS )5� V2ParserTestsz? Test L{twisted.protocols.haproxy.V2Parser} behaviour. r Nc C � t � }| �tj�|�� dS )zL Test if a well formed IPv4 header is parsed without error. N)r � assertTruer �V2Parser�parse��self�headerr r r �test_happyPathIPv4� � z V2ParserTests.test_happyPathIPv4c C r )zL Test if a well formed IPv6 header is parsed without error. N)r r r r r r r r r �test_happyPathIPv6� r" z V2ParserTests.test_happyPathIPv6c C r )zL Test if a well formed UNIX header is parsed without error. N)r r r r r r r r r �test_happyPathUnix� r" z V2ParserTests.test_happyPathUnixc C � t dd�}| �ttjj|� dS )zN Test if an invalid signature block raises InvalidProxyError. s )r N�r � assertRaisesr r r r r r r r �test_invalidSignature� � �z#V2ParserTests.test_invalidSignaturec C r% )zF Test if an invalid version raises InvalidProxyError. r �r Nr& r r r r �test_invalidVersion� r) z!V2ParserTests.test_invalidVersionc C r% )zF Test if an invalid command raises InvalidProxyError. � #r* Nr& r r r r �test_invalidCommand� r) z!V2ParserTests.test_invalidCommandc C r% )zE Test if an invalid family raises InvalidProxyError. � @�r Nr& r r r r �test_invalidFamily� r) z V2ParserTests.test_invalidFamilyc C r% )zG Test if an invalid protocol raises InvalidProxyError. � $r/ Nr& r r r r �test_invalidProto� r) z V2ParserTests.test_invalidProtoc C �2 t dd�}tj�|�}| �|j� | �|j� dS )zU Test that local does not return endpoint data for IPv4 connections. � r* N�r r r r � assertFalse�source� destination�r r �infor r r �test_localCommandIpv4� � z#V2ParserTests.test_localCommandIpv4c C r3 )zU Test that local does not return endpoint data for IPv6 connections. r4 r* N�r r r r r6 r7 r8 r9 r r r �test_localCommandIpv6� r< z#V2ParserTests.test_localCommandIpv6c C r3 )zU Test that local does not return endpoint data for UNIX connections. r4 r* N�r r r r r6 r7 r8 r9 r r r �test_localCommandUnix� r< z#V2ParserTests.test_localCommandUnixc C �R t dd�}tj�|�}| �|j� | �|jtj� | �|j � | �|j tj� dS )zM Test that proxy returns endpoint data for IPv4 connections. r r* N) r r r r r r7 �assertIsInstancer � IPv4Addressr8 r9 r r r �test_proxyCommandIpv4� � z#V2ParserTests.test_proxyCommandIpv4c C rA )zM Test that proxy returns endpoint data for IPv6 connections. r r* N) r r r r r r7 rB r � IPv6Addressr8 r9 r r r �test_proxyCommandIpv6� rE z#V2ParserTests.test_proxyCommandIpv6c C rA )zM Test that proxy returns endpoint data for UNIX connections. r r* N) r r r r r r7 rB r � UNIXAddressr8 r9 r r r �test_proxyCommandUnix rE z#V2ParserTests.test_proxyCommandUnixc C r3 )�V Test that UNSPEC does not return endpoint data for IPv4 connections. � r/ Nr5 r9 r r r �test_unspecFamilyIpv4 r< z#V2ParserTests.test_unspecFamilyIpv4c C r3 )�V Test that UNSPEC does not return endpoint data for IPv6 connections. rK r/ Nr= r9 r r r �test_unspecFamilyIpv6 r< z#V2ParserTests.test_unspecFamilyIpv6c C r3 )�V Test that UNSPEC does not return endpoint data for UNIX connections. rK r/ Nr? r9 r r r �test_unspecFamilyUnix! r< z#V2ParserTests.test_unspecFamilyUnixc C r3 )rJ � r/ Nr5 r9 r r r �test_unspecProtoIpv4* r< z"V2ParserTests.test_unspecProtoIpv4c C r3 )rM r4 r/ Nr= r9 r r r �test_unspecProtoIpv63 r< z"V2ParserTests.test_unspecProtoIpv6c C r3 )rO � 0r/ Nr? r9 r r r �test_unspecProtoUnix< r< z"V2ParserTests.test_unspecProtoUnixc C �> d}t � | }t�� }|�|�\}}| �|� | �||� dS )zU Test that overflow bits are preserved during feed parsing for IPv4. � TEST DATA TEST DATAN)r r r �feedr � assertEqual�r � testValuer �parserr: �overflowr r r �test_overflowIpv4E � z V2ParserTests.test_overflowIpv4c C rV )zU Test that overflow bits are preserved during feed parsing for IPv6. rW N)r r r rX r rY rZ r r r �test_overflowIpv6P r_ z V2ParserTests.test_overflowIpv6c C rV )zU Test that overflow bits are preserved during feed parsing for Unix. rW N)r r r rX r rY rZ r r r �test_overflowUnix[ r_ z V2ParserTests.test_overflowUnixc C s d}t �� }| �t|j|� dS )zK Test that an initial payload of less than 16 bytes fails. s NEEDMOREDATAN)r r r' r rX )r r[ r\ r r r �test_segmentTooSmallf s �z"V2ParserTests.test_segmentTooSmall)r N) �__name__� __module__� __qualname__�__doc__r! r# r$ r( r+ r- r0 r2 r; r> r@ rD rG rI rL rN rP rR rS rU r^ r` ra rb r r r r r � s4 r N)rf �twisted.internetr � twisted.trialr � r � _exceptionsr � V2_SIGNATURE�bytesr r r �TestCaser r r r r �<module> s� ������� �'������� �'������ �&PK Mb�ZQ��^� � @ protocols/haproxy/test/__pycache__/test_v1parser.cpython-310.pycnu �[��� o �bJ � @ sR d Z ddlmZ ddlmZ ddlmZ ddlmZm Z m Z G dd� dej �Z d S ) z7 Test cases for L{twisted.protocols.haproxy.V1Parser}. � )�address)�unittest� )� _v1parser)�InvalidNetworkProtocol�InvalidProxyHeader�MissingAddressDatac @ st e Zd ZdZddd�Zddd�Zddd �Zdd d �Zdd d �Zddd�Z ddd�Z ddd�Z ddd�Z ddd�Z dS )� V1ParserTestsz? Test L{twisted.protocols.haproxy.V1Parser} behaviour. �returnNc C � | � ttjjd� dS )zT Test that an exception is raised when the PROXY header is missing. s NOTPROXY N)� assertRaisesr r �V1Parser�parse��self� r �N/usr/lib/python3/dist-packages/twisted/protocols/haproxy/test/test_v1parser.py� test_missingPROXYHeaderValue � �z*V1ParserTests.test_missingPROXYHeaderValuec C r )zX Test that an exception is raised when the proto is not TCP or UNKNOWN. s PROXY WUTPROTO N)r r r r r r r r r �test_invalidNetworkProtocol r z)V1ParserTests.test_invalidNetworkProtocolc C r )zU Test that an exception is raised when the proto has no source data. s PROXY TCP4 N�r r r r r r r r r �test_missingSourceData' r z$V1ParserTests.test_missingSourceDatac C r )zU Test that an exception is raised when the proto has no destination. s PROXY TCP4 127.0.0.1 8080 8888Nr r r r r �test_missingDestData1 r z"V1ParserTests.test_missingDestDatac C � t j�d�}| �|jtj� t|jtj�sJ �t|jtj�s J �| � |jj d� | � |jj d� | � |jj d� | � |jj d� dS )zE Test that parsing is successful for a PROXY header. s( PROXY TCP4 127.0.0.1 127.0.0.1 8080 8888� 127.0.0.1� �" N) r r r �assertIsInstance�sourcer � IPv4Address� isinstance� destination� assertEqual�host�port�r �infor r r �test_fullParsingSuccess; � �z%V1ParserTests.test_fullParsingSuccessc C r )zK Test that parsing is successful for an IPv6 PROXY header. s PROXY TCP6 ::1 ::1 8080 8888z::1r r N) r r r r r r � IPv6Addressr r! r" r# r$ r% r r r � test_fullParsingSuccess_IPv6J r( z*V1ParserTests.test_fullParsingSuccess_IPv6c C s( t j�d�}| �|j� | �|j� dS )zM Test that parsing is successful for a UNKNOWN PROXY header. s$ PROXY UNKNOWN anything could go hereN)r r r � assertIsNoner r! r% r r r � test_fullParsingSuccess_UNKNOWNY s � z-V1ParserTests.test_fullParsingSuccess_UNKNOWNc C s� t �� }|�d�\}}| �|� | �|� |�d�\}}| �|� | �|� |�d�\}}| �|� |dus8J �|dus>J �| �|jtj� t|jtj�sOJ �t|j tj�sXJ �| � |jj d� | � |jj d� | � |j j d� | � |j j d� dS )zE Test that parsing happens when fed a complete line. � PROXY TCP4 127.0.0.1 127.0.0.1 � 8080 8888s Nr r r ) r r �feed� assertFalser r r r r r! r" r# r$ �r �parserr& � remainingr r r �test_feedParsingc s$ z V1ParserTests.test_feedParsingc C s` t �� }|�d�\}}| �|� | �|� |�d�\}}| �|� | �|� | �t|jd� dS )zN Test that parsing fails if no newline is found in 108 bytes. r- r. sd N)r r r/ r0 r r r1 r r r �test_feedParsingTooLongz s �z%V1ParserTests.test_feedParsingTooLongc C s< t �� }|�d�\}}| �|� | �|d� | �|j� dS )zH Test that parsing leaves overflow bytes in the buffer. s: PROXY TCP4 127.0.0.1 127.0.0.1 8080 8888 HTTP/1.1 GET / s HTTP/1.1 GET / N)r r r/ � assertTruer" r0 �bufferr1 r r r �test_feedParsingOverflow� s � z&V1ParserTests.test_feedParsingOverflow)r N)�__name__� __module__� __qualname__�__doc__r r r r r' r* r, r4 r5 r8 r r r r r s r N) r< �twisted.internetr � twisted.trialr � r � _exceptionsr r r �TestCaser r r r r �<module> s PK Mb�Zgm��. �. ' protocols/haproxy/test/test_v2parser.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.protocols.haproxy.V2Parser}. """ from twisted.internet import address from twisted.trial import unittest from .. import _v2parser from .._exceptions import InvalidProxyHeader V2_SIGNATURE = b"\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A" def _makeHeaderIPv6( sig: bytes = V2_SIGNATURE, verCom: bytes = b"\x21", famProto: bytes = b"\x21", addrLength: bytes = b"\x00\x24", addrs: bytes = ((b"\x00" * 15) + b"\x01") * 2, ports: bytes = b"\x1F\x90\x22\xB8", ) -> bytes: """ Construct a version 2 IPv6 header with custom bytes. @param sig: The protocol signature; defaults to valid L{V2_SIGNATURE}. @type sig: L{bytes} @param verCom: Protocol version and command. Defaults to V2 PROXY. @type verCom: L{bytes} @param famProto: Address family and protocol. Defaults to AF_INET6/STREAM. @type famProto: L{bytes} @param addrLength: Network-endian byte length of payload. Defaults to description of default addrs/ports. @type addrLength: L{bytes} @param addrs: Address payload. Defaults to C{::1} for source and destination. @type addrs: L{bytes} @param ports: Source and destination ports. Defaults to 8080 for source 8888 for destination. @type ports: L{bytes} @return: A packet with header, addresses, and ports. @rtype: L{bytes} """ return sig + verCom + famProto + addrLength + addrs + ports def _makeHeaderIPv4( sig: bytes = V2_SIGNATURE, verCom: bytes = b"\x21", famProto: bytes = b"\x11", addrLength: bytes = b"\x00\x0C", addrs: bytes = b"\x7F\x00\x00\x01\x7F\x00\x00\x01", ports: bytes = b"\x1F\x90\x22\xB8", ) -> bytes: """ Construct a version 2 IPv4 header with custom bytes. @param sig: The protocol signature; defaults to valid L{V2_SIGNATURE}. @type sig: L{bytes} @param verCom: Protocol version and command. Defaults to V2 PROXY. @type verCom: L{bytes} @param famProto: Address family and protocol. Defaults to AF_INET/STREAM. @type famProto: L{bytes} @param addrLength: Network-endian byte length of payload. Defaults to description of default addrs/ports. @type addrLength: L{bytes} @param addrs: Address payload. Defaults to 127.0.0.1 for source and destination. @type addrs: L{bytes} @param ports: Source and destination ports. Defaults to 8080 for source 8888 for destination. @type ports: L{bytes} @return: A packet with header, addresses, and ports. @rtype: L{bytes} """ return sig + verCom + famProto + addrLength + addrs + ports def _makeHeaderUnix( sig: bytes = V2_SIGNATURE, verCom: bytes = b"\x21", famProto: bytes = b"\x31", addrLength: bytes = b"\x00\xD8", addrs: bytes = ( b"\x2F\x68\x6F\x6D\x65\x2F\x74\x65\x73\x74\x73\x2F" b"\x6D\x79\x73\x6F\x63\x6B\x65\x74\x73\x2F\x73\x6F" b"\x63\x6B" + (b"\x00" * 82) ) * 2, ) -> bytes: """ Construct a version 2 IPv4 header with custom bytes. @param sig: The protocol signature; defaults to valid L{V2_SIGNATURE}. @type sig: L{bytes} @param verCom: Protocol version and command. Defaults to V2 PROXY. @type verCom: L{bytes} @param famProto: Address family and protocol. Defaults to AF_UNIX/STREAM. @type famProto: L{bytes} @param addrLength: Network-endian byte length of payload. Defaults to 108 bytes for 2 null terminated paths. @type addrLength: L{bytes} @param addrs: Address payload. Defaults to C{/home/tests/mysockets/sock} for source and destination paths. @type addrs: L{bytes} @return: A packet with header, addresses, and8 ports. @rtype: L{bytes} """ return sig + verCom + famProto + addrLength + addrs class V2ParserTests(unittest.TestCase): """ Test L{twisted.protocols.haproxy.V2Parser} behaviour. """ def test_happyPathIPv4(self) -> None: """ Test if a well formed IPv4 header is parsed without error. """ header = _makeHeaderIPv4() self.assertTrue(_v2parser.V2Parser.parse(header)) def test_happyPathIPv6(self) -> None: """ Test if a well formed IPv6 header is parsed without error. """ header = _makeHeaderIPv6() self.assertTrue(_v2parser.V2Parser.parse(header)) def test_happyPathUnix(self) -> None: """ Test if a well formed UNIX header is parsed without error. """ header = _makeHeaderUnix() self.assertTrue(_v2parser.V2Parser.parse(header)) def test_invalidSignature(self) -> None: """ Test if an invalid signature block raises InvalidProxyError. """ header = _makeHeaderIPv4(sig=b"\x00" * 12) self.assertRaises( InvalidProxyHeader, _v2parser.V2Parser.parse, header, ) def test_invalidVersion(self) -> None: """ Test if an invalid version raises InvalidProxyError. """ header = _makeHeaderIPv4(verCom=b"\x11") self.assertRaises( InvalidProxyHeader, _v2parser.V2Parser.parse, header, ) def test_invalidCommand(self) -> None: """ Test if an invalid command raises InvalidProxyError. """ header = _makeHeaderIPv4(verCom=b"\x23") self.assertRaises( InvalidProxyHeader, _v2parser.V2Parser.parse, header, ) def test_invalidFamily(self) -> None: """ Test if an invalid family raises InvalidProxyError. """ header = _makeHeaderIPv4(famProto=b"\x40") self.assertRaises( InvalidProxyHeader, _v2parser.V2Parser.parse, header, ) def test_invalidProto(self) -> None: """ Test if an invalid protocol raises InvalidProxyError. """ header = _makeHeaderIPv4(famProto=b"\x24") self.assertRaises( InvalidProxyHeader, _v2parser.V2Parser.parse, header, ) def test_localCommandIpv4(self) -> None: """ Test that local does not return endpoint data for IPv4 connections. """ header = _makeHeaderIPv4(verCom=b"\x20") info = _v2parser.V2Parser.parse(header) self.assertFalse(info.source) self.assertFalse(info.destination) def test_localCommandIpv6(self) -> None: """ Test that local does not return endpoint data for IPv6 connections. """ header = _makeHeaderIPv6(verCom=b"\x20") info = _v2parser.V2Parser.parse(header) self.assertFalse(info.source) self.assertFalse(info.destination) def test_localCommandUnix(self) -> None: """ Test that local does not return endpoint data for UNIX connections. """ header = _makeHeaderUnix(verCom=b"\x20") info = _v2parser.V2Parser.parse(header) self.assertFalse(info.source) self.assertFalse(info.destination) def test_proxyCommandIpv4(self) -> None: """ Test that proxy returns endpoint data for IPv4 connections. """ header = _makeHeaderIPv4(verCom=b"\x21") info = _v2parser.V2Parser.parse(header) self.assertTrue(info.source) self.assertIsInstance(info.source, address.IPv4Address) self.assertTrue(info.destination) self.assertIsInstance(info.destination, address.IPv4Address) def test_proxyCommandIpv6(self) -> None: """ Test that proxy returns endpoint data for IPv6 connections. """ header = _makeHeaderIPv6(verCom=b"\x21") info = _v2parser.V2Parser.parse(header) self.assertTrue(info.source) self.assertIsInstance(info.source, address.IPv6Address) self.assertTrue(info.destination) self.assertIsInstance(info.destination, address.IPv6Address) def test_proxyCommandUnix(self) -> None: """ Test that proxy returns endpoint data for UNIX connections. """ header = _makeHeaderUnix(verCom=b"\x21") info = _v2parser.V2Parser.parse(header) self.assertTrue(info.source) self.assertIsInstance(info.source, address.UNIXAddress) self.assertTrue(info.destination) self.assertIsInstance(info.destination, address.UNIXAddress) def test_unspecFamilyIpv4(self) -> None: """ Test that UNSPEC does not return endpoint data for IPv4 connections. """ header = _makeHeaderIPv4(famProto=b"\x01") info = _v2parser.V2Parser.parse(header) self.assertFalse(info.source) self.assertFalse(info.destination) def test_unspecFamilyIpv6(self) -> None: """ Test that UNSPEC does not return endpoint data for IPv6 connections. """ header = _makeHeaderIPv6(famProto=b"\x01") info = _v2parser.V2Parser.parse(header) self.assertFalse(info.source) self.assertFalse(info.destination) def test_unspecFamilyUnix(self) -> None: """ Test that UNSPEC does not return endpoint data for UNIX connections. """ header = _makeHeaderUnix(famProto=b"\x01") info = _v2parser.V2Parser.parse(header) self.assertFalse(info.source) self.assertFalse(info.destination) def test_unspecProtoIpv4(self) -> None: """ Test that UNSPEC does not return endpoint data for IPv4 connections. """ header = _makeHeaderIPv4(famProto=b"\x10") info = _v2parser.V2Parser.parse(header) self.assertFalse(info.source) self.assertFalse(info.destination) def test_unspecProtoIpv6(self) -> None: """ Test that UNSPEC does not return endpoint data for IPv6 connections. """ header = _makeHeaderIPv6(famProto=b"\x20") info = _v2parser.V2Parser.parse(header) self.assertFalse(info.source) self.assertFalse(info.destination) def test_unspecProtoUnix(self) -> None: """ Test that UNSPEC does not return endpoint data for UNIX connections. """ header = _makeHeaderUnix(famProto=b"\x30") info = _v2parser.V2Parser.parse(header) self.assertFalse(info.source) self.assertFalse(info.destination) def test_overflowIpv4(self) -> None: """ Test that overflow bits are preserved during feed parsing for IPv4. """ testValue = b"TEST DATA\r\n\r\nTEST DATA" header = _makeHeaderIPv4() + testValue parser = _v2parser.V2Parser() info, overflow = parser.feed(header) self.assertTrue(info) self.assertEqual(overflow, testValue) def test_overflowIpv6(self) -> None: """ Test that overflow bits are preserved during feed parsing for IPv6. """ testValue = b"TEST DATA\r\n\r\nTEST DATA" header = _makeHeaderIPv6() + testValue parser = _v2parser.V2Parser() info, overflow = parser.feed(header) self.assertTrue(info) self.assertEqual(overflow, testValue) def test_overflowUnix(self) -> None: """ Test that overflow bits are preserved during feed parsing for Unix. """ testValue = b"TEST DATA\r\n\r\nTEST DATA" header = _makeHeaderUnix() + testValue parser = _v2parser.V2Parser() info, overflow = parser.feed(header) self.assertTrue(info) self.assertEqual(overflow, testValue) def test_segmentTooSmall(self) -> None: """ Test that an initial payload of less than 16 bytes fails. """ testValue = b"NEEDMOREDATA" parser = _v2parser.V2Parser() self.assertRaises( InvalidProxyHeader, parser.feed, testValue, ) PK Mb�Z��k % protocols/haproxy/test/test_parser.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.protocols.haproxy._parser}. """ from typing import Type, Union from twisted.internet.endpoints import ( TCP4ServerEndpoint, TCP6ServerEndpoint, UNIXServerEndpoint, _parse as parseEndpoint, _WrapperServerEndpoint, serverFromString, ) from twisted.test.proto_helpers import MemoryReactor from twisted.trial.unittest import SynchronousTestCase as TestCase from .._parser import unparseEndpoint from .._wrapper import HAProxyWrappingFactory class UnparseEndpointTests(TestCase): """ Tests to ensure that un-parsing an endpoint string round trips through escaping properly. """ def check(self, input: str) -> None: """ Check that the input unparses into the output, raising an assertion error if it doesn't. @param input: an input in endpoint-string-description format. (To ensure determinism, keyword arguments should be in alphabetical order.) @type input: native L{str} """ self.assertEqual(unparseEndpoint(*parseEndpoint(input)), input) def test_basicUnparse(self) -> None: """ An individual word. """ self.check("word") def test_multipleArguments(self) -> None: """ Multiple arguments. """ self.check("one:two") def test_keywords(self) -> None: """ Keyword arguments. """ self.check("aleph=one:bet=two") def test_colonInArgument(self) -> None: """ Escaped ":". """ self.check("hello\\:colon\\:world") def test_colonInKeywordValue(self) -> None: """ Escaped ":" in keyword value. """ self.check("hello=\\:") def test_colonInKeywordName(self) -> None: """ Escaped ":" in keyword name. """ self.check("\\:=hello") class HAProxyServerParserTests(TestCase): """ Tests that the parser generates the correct endpoints. """ def onePrefix( self, description: str, expectedClass: Union[ Type[TCP4ServerEndpoint], Type[TCP6ServerEndpoint], Type[UNIXServerEndpoint], ], ) -> _WrapperServerEndpoint: """ Test the C{haproxy} enpdoint prefix against one sub-endpoint type. @param description: A string endpoint description beginning with C{haproxy}. @type description: native L{str} @param expectedClass: the expected sub-endpoint class given the description. @type expectedClass: L{type} @return: the parsed endpoint @rtype: L{IStreamServerEndpoint} @raise twisted.trial.unittest.Failtest: if the parsed endpoint doesn't match expectations. """ reactor = MemoryReactor() endpoint = serverFromString(reactor, description) self.assertIsInstance(endpoint, _WrapperServerEndpoint) assert isinstance(endpoint, _WrapperServerEndpoint) self.assertIsInstance(endpoint._wrappedEndpoint, expectedClass) self.assertIs(endpoint._wrapperFactory, HAProxyWrappingFactory) return endpoint def test_tcp4(self) -> None: """ Test if the parser generates a wrapped TCP4 endpoint. """ self.onePrefix("haproxy:tcp:8080", TCP4ServerEndpoint) def test_tcp6(self) -> None: """ Test if the parser generates a wrapped TCP6 endpoint. """ self.onePrefix("haproxy:tcp6:8080", TCP6ServerEndpoint) def test_unix(self) -> None: """ Test if the parser generates a wrapped UNIX endpoint. """ self.onePrefix("haproxy:unix:address=/tmp/socket", UNIXServerEndpoint) PK Mb�Zصr�6 �6 & protocols/haproxy/test/test_wrapper.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.protocols.haproxy.HAProxyProtocol}. """ from typing import Optional from unittest import mock from twisted.internet import address from twisted.internet.protocol import Factory, Protocol from twisted.test.proto_helpers import StringTransportWithDisconnection from twisted.trial import unittest from .._wrapper import HAProxyWrappingFactory class StaticProtocol(Protocol): """ Protocol stand-in that maintains test state. """ def __init__(self) -> None: self.source: Optional[address.IAddress] = None self.destination: Optional[address.IAddress] = None self.data = b"" self.disconnected = False def dataReceived(self, data: bytes) -> None: assert self.transport self.source = self.transport.getPeer() self.destination = self.transport.getHost() self.data += data class HAProxyWrappingFactoryV1Tests(unittest.TestCase): """ Test L{twisted.protocols.haproxy.HAProxyWrappingFactory} with v1 PROXY headers. """ def test_invalidHeaderDisconnects(self) -> None: """ Test if invalid headers result in connectionLost events. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv4Address("TCP", "127.1.1.1", 8080), ) transport = StringTransportWithDisconnection() transport.protocol = proto proto.makeConnection(transport) proto.dataReceived(b"NOTPROXY anything can go here\r\n") self.assertFalse(transport.connected) def test_invalidPartialHeaderDisconnects(self) -> None: """ Test if invalid headers result in connectionLost events. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv4Address("TCP", "127.1.1.1", 8080), ) transport = StringTransportWithDisconnection() transport.protocol = proto proto.makeConnection(transport) proto.dataReceived(b"PROXY TCP4 1.1.1.1\r\n") proto.dataReceived(b"2.2.2.2 8080\r\n") self.assertFalse(transport.connected) def test_preDataReceived_getPeerHost(self) -> None: """ Before any data is received the HAProxy protocol will return the same peer and host as the IP connection. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv4Address("TCP", "127.0.0.1", 8080), ) transport = StringTransportWithDisconnection( hostAddress=mock.sentinel.host_address, peerAddress=mock.sentinel.peer_address, ) proto.makeConnection(transport) self.assertEqual(proto.getHost(), mock.sentinel.host_address) self.assertEqual(proto.getPeer(), mock.sentinel.peer_address) def test_validIPv4HeaderResolves_getPeerHost(self) -> None: """ Test if IPv4 headers result in the correct host and peer data. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv4Address("TCP", "127.0.0.1", 8080), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(b"PROXY TCP4 1.1.1.1 2.2.2.2 8080 8888\r\n") self.assertEqual(proto.getPeer().host, "1.1.1.1") self.assertEqual(proto.getPeer().port, 8080) self.assertEqual( proto.wrappedProtocol.transport.getPeer().host, "1.1.1.1", ) self.assertEqual( proto.wrappedProtocol.transport.getPeer().port, 8080, ) self.assertEqual(proto.getHost().host, "2.2.2.2") self.assertEqual(proto.getHost().port, 8888) self.assertEqual( proto.wrappedProtocol.transport.getHost().host, "2.2.2.2", ) self.assertEqual( proto.wrappedProtocol.transport.getHost().port, 8888, ) def test_validIPv6HeaderResolves_getPeerHost(self) -> None: """ Test if IPv6 headers result in the correct host and peer data. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv6Address("TCP", "::1", 8080), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(b"PROXY TCP6 ::1 ::2 8080 8888\r\n") self.assertEqual(proto.getPeer().host, "::1") self.assertEqual(proto.getPeer().port, 8080) self.assertEqual( proto.wrappedProtocol.transport.getPeer().host, "::1", ) self.assertEqual( proto.wrappedProtocol.transport.getPeer().port, 8080, ) self.assertEqual(proto.getHost().host, "::2") self.assertEqual(proto.getHost().port, 8888) self.assertEqual( proto.wrappedProtocol.transport.getHost().host, "::2", ) self.assertEqual( proto.wrappedProtocol.transport.getHost().port, 8888, ) def test_overflowBytesSentToWrappedProtocol(self) -> None: """ Test if non-header bytes are passed to the wrapped protocol. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv6Address("TCP", "::1", 8080), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(b"PROXY TCP6 ::1 ::2 8080 8888\r\nHTTP/1.1 / GET") self.assertEqual(proto.wrappedProtocol.data, b"HTTP/1.1 / GET") def test_overflowBytesSentToWrappedProtocolChunks(self) -> None: """ Test if header streaming passes extra data appropriately. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv6Address("TCP", "::1", 8080), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(b"PROXY TCP6 ::1 ::2 ") proto.dataReceived(b"8080 8888\r\nHTTP/1.1 / GET") self.assertEqual(proto.wrappedProtocol.data, b"HTTP/1.1 / GET") def test_overflowBytesSentToWrappedProtocolAfter(self) -> None: """ Test if wrapper writes all data to wrapped protocol after parsing. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv6Address("TCP", "::1", 8080), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(b"PROXY TCP6 ::1 ::2 ") proto.dataReceived(b"8080 8888\r\nHTTP/1.1 / GET") proto.dataReceived(b"\r\n\r\n") self.assertEqual(proto.wrappedProtocol.data, b"HTTP/1.1 / GET\r\n\r\n") class HAProxyWrappingFactoryV2Tests(unittest.TestCase): """ Test L{twisted.protocols.haproxy.HAProxyWrappingFactory} with v2 PROXY headers. """ IPV4HEADER = ( # V2 Signature b"\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A" # V2 PROXY command b"\x21" # AF_INET/STREAM b"\x11" # 12 bytes for 2 IPv4 addresses and two ports b"\x00\x0C" # 127.0.0.1 for source and destination b"\x7F\x00\x00\x01\x7F\x00\x00\x01" # 8080 for source 8888 for destination b"\x1F\x90\x22\xB8" ) IPV6HEADER = ( # V2 Signature b"\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A" # V2 PROXY command b"\x21" # AF_INET6/STREAM b"\x21" # 16 bytes for 2 IPv6 addresses and two ports b"\x00\x24" # ::1 for source and destination b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" # 8080 for source 8888 for destination b"\x1F\x90\x22\xB8" ) _SOCK_PATH = ( b"\x2F\x68\x6F\x6D\x65\x2F\x74\x65\x73\x74\x73\x2F\x6D\x79\x73\x6F" b"\x63\x6B\x65\x74\x73\x2F\x73\x6F\x63\x6B" + (b"\x00" * 82) ) UNIXHEADER = ( ( # V2 Signature b"\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A" # V2 PROXY command b"\x21" # AF_UNIX/STREAM b"\x31" # 108 bytes for 2 null terminated paths b"\x00\xD8" # /home/tests/mysockets/sock for source and destination paths ) + _SOCK_PATH + _SOCK_PATH ) def test_invalidHeaderDisconnects(self) -> None: """ Test if invalid headers result in connectionLost events. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv6Address("TCP", "::1", 8080), ) transport = StringTransportWithDisconnection() transport.protocol = proto proto.makeConnection(transport) proto.dataReceived(b"\x00" + self.IPV4HEADER[1:]) self.assertFalse(transport.connected) def test_validIPv4HeaderResolves_getPeerHost(self) -> None: """ Test if IPv4 headers result in the correct host and peer data. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv4Address("TCP", "127.0.0.1", 8080), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(self.IPV4HEADER) self.assertEqual(proto.getPeer().host, "127.0.0.1") self.assertEqual(proto.getPeer().port, 8080) self.assertEqual( proto.wrappedProtocol.transport.getPeer().host, "127.0.0.1", ) self.assertEqual( proto.wrappedProtocol.transport.getPeer().port, 8080, ) self.assertEqual(proto.getHost().host, "127.0.0.1") self.assertEqual(proto.getHost().port, 8888) self.assertEqual( proto.wrappedProtocol.transport.getHost().host, "127.0.0.1", ) self.assertEqual( proto.wrappedProtocol.transport.getHost().port, 8888, ) def test_validIPv6HeaderResolves_getPeerHost(self) -> None: """ Test if IPv6 headers result in the correct host and peer data. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv4Address("TCP", "::1", 8080), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(self.IPV6HEADER) self.assertEqual(proto.getPeer().host, "0:0:0:0:0:0:0:1") self.assertEqual(proto.getPeer().port, 8080) self.assertEqual( proto.wrappedProtocol.transport.getPeer().host, "0:0:0:0:0:0:0:1", ) self.assertEqual( proto.wrappedProtocol.transport.getPeer().port, 8080, ) self.assertEqual(proto.getHost().host, "0:0:0:0:0:0:0:1") self.assertEqual(proto.getHost().port, 8888) self.assertEqual( proto.wrappedProtocol.transport.getHost().host, "0:0:0:0:0:0:0:1", ) self.assertEqual( proto.wrappedProtocol.transport.getHost().port, 8888, ) def test_validUNIXHeaderResolves_getPeerHost(self) -> None: """ Test if UNIX headers result in the correct host and peer data. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.UNIXAddress(b"/home/test/sockets/server.sock"), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(self.UNIXHEADER) self.assertEqual(proto.getPeer().name, b"/home/tests/mysockets/sock") self.assertEqual( proto.wrappedProtocol.transport.getPeer().name, b"/home/tests/mysockets/sock", ) self.assertEqual(proto.getHost().name, b"/home/tests/mysockets/sock") self.assertEqual( proto.wrappedProtocol.transport.getHost().name, b"/home/tests/mysockets/sock", ) def test_overflowBytesSentToWrappedProtocol(self) -> None: """ Test if non-header bytes are passed to the wrapped protocol. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv6Address("TCP", "::1", 8080), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(self.IPV6HEADER + b"HTTP/1.1 / GET") self.assertEqual(proto.wrappedProtocol.data, b"HTTP/1.1 / GET") def test_overflowBytesSentToWrappedProtocolChunks(self) -> None: """ Test if header streaming passes extra data appropriately. """ factory = HAProxyWrappingFactory(Factory.forProtocol(StaticProtocol)) proto = factory.buildProtocol( address.IPv6Address("TCP", "::1", 8080), ) transport = StringTransportWithDisconnection() proto.makeConnection(transport) proto.dataReceived(self.IPV6HEADER[:18]) proto.dataReceived(self.IPV6HEADER[18:] + b"HTTP/1.1 / GET") self.assertEqual(proto.wrappedProtocol.data, b"HTTP/1.1 / GET") PK Mb�Z��ñJ J ' protocols/haproxy/test/test_v1parser.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.protocols.haproxy.V1Parser}. """ from twisted.internet import address from twisted.trial import unittest from .. import _v1parser from .._exceptions import InvalidNetworkProtocol, InvalidProxyHeader, MissingAddressData class V1ParserTests(unittest.TestCase): """ Test L{twisted.protocols.haproxy.V1Parser} behaviour. """ def test_missingPROXYHeaderValue(self) -> None: """ Test that an exception is raised when the PROXY header is missing. """ self.assertRaises( InvalidProxyHeader, _v1parser.V1Parser.parse, b"NOTPROXY ", ) def test_invalidNetworkProtocol(self) -> None: """ Test that an exception is raised when the proto is not TCP or UNKNOWN. """ self.assertRaises( InvalidNetworkProtocol, _v1parser.V1Parser.parse, b"PROXY WUTPROTO ", ) def test_missingSourceData(self) -> None: """ Test that an exception is raised when the proto has no source data. """ self.assertRaises( MissingAddressData, _v1parser.V1Parser.parse, b"PROXY TCP4 ", ) def test_missingDestData(self) -> None: """ Test that an exception is raised when the proto has no destination. """ self.assertRaises( MissingAddressData, _v1parser.V1Parser.parse, b"PROXY TCP4 127.0.0.1 8080 8888", ) def test_fullParsingSuccess(self) -> None: """ Test that parsing is successful for a PROXY header. """ info = _v1parser.V1Parser.parse( b"PROXY TCP4 127.0.0.1 127.0.0.1 8080 8888", ) self.assertIsInstance(info.source, address.IPv4Address) assert isinstance(info.source, address.IPv4Address) assert isinstance(info.destination, address.IPv4Address) self.assertEqual(info.source.host, "127.0.0.1") self.assertEqual(info.source.port, 8080) self.assertEqual(info.destination.host, "127.0.0.1") self.assertEqual(info.destination.port, 8888) def test_fullParsingSuccess_IPv6(self) -> None: """ Test that parsing is successful for an IPv6 PROXY header. """ info = _v1parser.V1Parser.parse( b"PROXY TCP6 ::1 ::1 8080 8888", ) self.assertIsInstance(info.source, address.IPv6Address) assert isinstance(info.source, address.IPv6Address) assert isinstance(info.destination, address.IPv6Address) self.assertEqual(info.source.host, "::1") self.assertEqual(info.source.port, 8080) self.assertEqual(info.destination.host, "::1") self.assertEqual(info.destination.port, 8888) def test_fullParsingSuccess_UNKNOWN(self) -> None: """ Test that parsing is successful for a UNKNOWN PROXY header. """ info = _v1parser.V1Parser.parse( b"PROXY UNKNOWN anything could go here", ) self.assertIsNone(info.source) self.assertIsNone(info.destination) def test_feedParsing(self) -> None: """ Test that parsing happens when fed a complete line. """ parser = _v1parser.V1Parser() info, remaining = parser.feed(b"PROXY TCP4 127.0.0.1 127.0.0.1 ") self.assertFalse(info) self.assertFalse(remaining) info, remaining = parser.feed(b"8080 8888") self.assertFalse(info) self.assertFalse(remaining) info, remaining = parser.feed(b"\r\n") self.assertFalse(remaining) assert remaining is not None assert info is not None self.assertIsInstance(info.source, address.IPv4Address) assert isinstance(info.source, address.IPv4Address) assert isinstance(info.destination, address.IPv4Address) self.assertEqual(info.source.host, "127.0.0.1") self.assertEqual(info.source.port, 8080) self.assertEqual(info.destination.host, "127.0.0.1") self.assertEqual(info.destination.port, 8888) def test_feedParsingTooLong(self) -> None: """ Test that parsing fails if no newline is found in 108 bytes. """ parser = _v1parser.V1Parser() info, remaining = parser.feed(b"PROXY TCP4 127.0.0.1 127.0.0.1 ") self.assertFalse(info) self.assertFalse(remaining) info, remaining = parser.feed(b"8080 8888") self.assertFalse(info) self.assertFalse(remaining) self.assertRaises( InvalidProxyHeader, parser.feed, b" " * 100, ) def test_feedParsingOverflow(self) -> None: """ Test that parsing leaves overflow bytes in the buffer. """ parser = _v1parser.V1Parser() info, remaining = parser.feed( b"PROXY TCP4 127.0.0.1 127.0.0.1 8080 8888\r\nHTTP/1.1 GET /\r\n", ) self.assertTrue(info) self.assertEqual(remaining, b"HTTP/1.1 GET /\r\n") self.assertFalse(parser.buffer) PK Mb�Z��逷 � " protocols/haproxy/test/__init__.pynu �[��� # -*- test-case-name: twisted.protocols.haproxy.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Unit tests for L{twisted.protocols.haproxy}. """ PK Mb�Z��D] ] protocols/haproxy/_wrapper.pynu �[��� # -*- test-case-name: twisted.protocols.haproxy.test.test_wrapper -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Protocol wrapper that provides HAProxy PROXY protocol support. """ from typing import Optional, Union from twisted.internet import interfaces from twisted.internet.endpoints import _WrapperServerEndpoint from twisted.protocols import policies from . import _info from ._exceptions import InvalidProxyHeader from ._v1parser import V1Parser from ._v2parser import V2Parser class HAProxyProtocolWrapper(policies.ProtocolWrapper): """ A Protocol wrapper that provides HAProxy support. This protocol reads the PROXY stream header, v1 or v2, parses the provided connection data, and modifies the behavior of getPeer and getHost to return the data provided by the PROXY header. """ def __init__( self, factory: policies.WrappingFactory, wrappedProtocol: interfaces.IProtocol ): super().__init__(factory, wrappedProtocol) self._proxyInfo: Optional[_info.ProxyInfo] = None self._parser: Union[V2Parser, V1Parser, None] = None def dataReceived(self, data: bytes) -> None: if self._proxyInfo is not None: return self.wrappedProtocol.dataReceived(data) parser = self._parser if parser is None: if ( len(data) >= 16 and data[:12] == V2Parser.PREFIX and ord(data[12:13]) & 0b11110000 == 0x20 ): self._parser = parser = V2Parser() elif len(data) >= 8 and data[:5] == V1Parser.PROXYSTR: self._parser = parser = V1Parser() else: self.loseConnection() return None try: self._proxyInfo, remaining = parser.feed(data) if remaining: self.wrappedProtocol.dataReceived(remaining) except InvalidProxyHeader: self.loseConnection() def getPeer(self) -> interfaces.IAddress: if self._proxyInfo and self._proxyInfo.source: return self._proxyInfo.source assert self.transport return self.transport.getPeer() def getHost(self) -> interfaces.IAddress: if self._proxyInfo and self._proxyInfo.destination: return self._proxyInfo.destination assert self.transport return self.transport.getHost() class HAProxyWrappingFactory(policies.WrappingFactory): """ A Factory wrapper that adds PROXY protocol support to connections. """ protocol = HAProxyProtocolWrapper def logPrefix(self) -> str: """ Annotate the wrapped factory's log prefix with some text indicating the PROXY protocol is in use. @rtype: C{str} """ if interfaces.ILoggingContext.providedBy(self.wrappedFactory): logPrefix = self.wrappedFactory.logPrefix() else: logPrefix = self.wrappedFactory.__class__.__name__ return f"{logPrefix} (PROXY)" def proxyEndpoint( wrappedEndpoint: interfaces.IStreamServerEndpoint, ) -> _WrapperServerEndpoint: """ Wrap an endpoint with PROXY protocol support, so that the transport's C{getHost} and C{getPeer} methods reflect the attributes of the proxied connection rather than the underlying connection. @param wrappedEndpoint: The underlying listening endpoint. @type wrappedEndpoint: L{IStreamServerEndpoint} @return: a new listening endpoint that speaks the PROXY protocol. @rtype: L{IStreamServerEndpoint} """ return _WrapperServerEndpoint(wrappedEndpoint, HAProxyWrappingFactory) PK Mb�Z �t+� � protocols/haproxy/_exceptions.pynu �[��� # -*- test-case-name: twisted.protocols.haproxy.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ HAProxy specific exceptions. """ import contextlib from typing import Callable, Generator, Type class InvalidProxyHeader(Exception): """ The provided PROXY protocol header is invalid. """ class InvalidNetworkProtocol(InvalidProxyHeader): """ The network protocol was not one of TCP4 TCP6 or UNKNOWN. """ class MissingAddressData(InvalidProxyHeader): """ The address data is missing or incomplete. """ @contextlib.contextmanager def convertError( sourceType: Type[BaseException], targetType: Callable[[], BaseException] ) -> Generator[None, None, None]: """ Convert an error into a different error type. @param sourceType: The type of exception that should be caught and converted. @type sourceType: L{BaseException} @param targetType: The type of exception to which the original should be converted. @type targetType: L{BaseException} """ try: yield except sourceType as e: raise targetType().with_traceback(e.__traceback__) PK Mb�Z�ջ � � protocols/haproxy/_info.pynu �[��� # -*- test-case-name: twisted.protocols.haproxy.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ IProxyInfo implementation. """ from typing import Optional from zope.interface import implementer import attr from twisted.internet.interfaces import IAddress from ._interfaces import IProxyInfo @implementer(IProxyInfo) @attr.s(frozen=True, slots=True, auto_attribs=True) class ProxyInfo: """ A data container for parsed PROXY protocol information. @ivar header: The raw header bytes extracted from the connection. @type header: C{bytes} @ivar source: The connection source address. @type source: L{twisted.internet.interfaces.IAddress} @ivar destination: The connection destination address. @type destination: L{twisted.internet.interfaces.IAddress} """ header: bytes source: Optional[IAddress] destination: Optional[IAddress] PK Mb�ZZԭL� � protocols/haproxy/_v1parser.pynu �[��� # -*- test-case-name: twisted.protocols.haproxy.test.test_v1parser -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ IProxyParser implementation for version one of the PROXY protocol. """ from typing import Tuple, Union from zope.interface import implementer from twisted.internet import address from . import _info, _interfaces from ._exceptions import ( InvalidNetworkProtocol, InvalidProxyHeader, MissingAddressData, convertError, ) @implementer(_interfaces.IProxyParser) class V1Parser: """ PROXY protocol version one header parser. Version one of the PROXY protocol is a human readable format represented by a single, newline delimited binary string that contains all of the relevant source and destination data. """ PROXYSTR = b"PROXY" UNKNOWN_PROTO = b"UNKNOWN" TCP4_PROTO = b"TCP4" TCP6_PROTO = b"TCP6" ALLOWED_NET_PROTOS = ( TCP4_PROTO, TCP6_PROTO, UNKNOWN_PROTO, ) NEWLINE = b"\r\n" def __init__(self) -> None: self.buffer = b"" def feed( self, data: bytes ) -> Union[Tuple[_info.ProxyInfo, bytes], Tuple[None, None]]: """ Consume a chunk of data and attempt to parse it. @param data: A bytestring. @type data: L{bytes} @return: A two-tuple containing, in order, a L{_interfaces.IProxyInfo} and any bytes fed to the parser that followed the end of the header. Both of these values are None until a complete header is parsed. @raises InvalidProxyHeader: If the bytes fed to the parser create an invalid PROXY header. """ self.buffer += data if len(self.buffer) > 107 and self.NEWLINE not in self.buffer: raise InvalidProxyHeader() lines = (self.buffer).split(self.NEWLINE, 1) if not len(lines) > 1: return (None, None) self.buffer = b"" remaining = lines.pop() header = lines.pop() info = self.parse(header) return (info, remaining) @classmethod def parse(cls, line: bytes) -> _info.ProxyInfo: """ Parse a bytestring as a full PROXY protocol header line. @param line: A bytestring that represents a valid HAProxy PROXY protocol header line. @type line: bytes @return: A L{_interfaces.IProxyInfo} containing the parsed data. @raises InvalidProxyHeader: If the bytestring does not represent a valid PROXY header. @raises InvalidNetworkProtocol: When no protocol can be parsed or is not one of the allowed values. @raises MissingAddressData: When the protocol is TCP* but the header does not contain a complete set of addresses and ports. """ originalLine = line proxyStr = None networkProtocol = None sourceAddr = None sourcePort = None destAddr = None destPort = None with convertError(ValueError, InvalidProxyHeader): proxyStr, line = line.split(b" ", 1) if proxyStr != cls.PROXYSTR: raise InvalidProxyHeader() with convertError(ValueError, InvalidNetworkProtocol): networkProtocol, line = line.split(b" ", 1) if networkProtocol not in cls.ALLOWED_NET_PROTOS: raise InvalidNetworkProtocol() if networkProtocol == cls.UNKNOWN_PROTO: return _info.ProxyInfo(originalLine, None, None) with convertError(ValueError, MissingAddressData): sourceAddr, line = line.split(b" ", 1) with convertError(ValueError, MissingAddressData): destAddr, line = line.split(b" ", 1) with convertError(ValueError, MissingAddressData): sourcePort, line = line.split(b" ", 1) with convertError(ValueError, MissingAddressData): destPort = line.split(b" ")[0] if networkProtocol == cls.TCP4_PROTO: return _info.ProxyInfo( originalLine, address.IPv4Address("TCP", sourceAddr.decode(), int(sourcePort)), address.IPv4Address("TCP", destAddr.decode(), int(destPort)), ) return _info.ProxyInfo( originalLine, address.IPv6Address("TCP", sourceAddr.decode(), int(sourcePort)), address.IPv6Address("TCP", destAddr.decode(), int(destPort)), ) PK Mb�ZBO�f f protocols/haproxy/_interfaces.pynu �[��� # -*- test-case-name: twisted.protocols.haproxy.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Interfaces used by the PROXY protocol modules. """ from typing import Tuple, Union import zope.interface class IProxyInfo(zope.interface.Interface): """ Data container for PROXY protocol header data. """ header = zope.interface.Attribute( "The raw byestring that represents the PROXY protocol header.", ) source = zope.interface.Attribute( "An L{twisted.internet.interfaces.IAddress} representing the " "connection source." ) destination = zope.interface.Attribute( "An L{twisted.internet.interfaces.IAddress} representing the " "connection destination." ) class IProxyParser(zope.interface.Interface): """ Streaming parser that handles PROXY protocol headers. """ def feed(data: bytes) -> Union[Tuple[IProxyInfo, bytes], Tuple[None, None]]: """ Consume a chunk of data and attempt to parse it. @param data: A bytestring. @type data: bytes @return: A two-tuple containing, in order, an L{IProxyInfo} and any bytes fed to the parser that followed the end of the header. Both of these values are None until a complete header is parsed. @raises InvalidProxyHeader: If the bytes fed to the parser create an invalid PROXY header. """ def parse(line: bytes) -> IProxyInfo: """ Parse a bytestring as a full PROXY protocol header line. @param line: A bytestring that represents a valid HAProxy PROXY protocol header line. @type line: bytes @return: An L{IProxyInfo} containing the parsed data. @raises InvalidProxyHeader: If the bytestring does not represent a valid PROXY header. """ PK Mb�Z�v�_� � protocols/haproxy/_v2parser.pynu �[��� # -*- test-case-name: twisted.protocols.haproxy.test.test_v2parser -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ IProxyParser implementation for version two of the PROXY protocol. """ import binascii import struct from typing import Callable, Literal, Tuple, Type, Union from zope.interface import implementer from constantly import ValueConstant, Values # type: ignore[import] from twisted.internet import address from twisted.python import compat from . import _info, _interfaces from ._exceptions import ( InvalidNetworkProtocol, InvalidProxyHeader, MissingAddressData, convertError, ) class NetFamily(Values): """ Values for the 'family' field. """ UNSPEC = ValueConstant(0x00) INET = ValueConstant(0x10) INET6 = ValueConstant(0x20) UNIX = ValueConstant(0x30) class NetProtocol(Values): """ Values for 'protocol' field. """ UNSPEC = ValueConstant(0) STREAM = ValueConstant(1) DGRAM = ValueConstant(2) _HIGH = 0b11110000 _LOW = 0b00001111 _LOCALCOMMAND = "LOCAL" _PROXYCOMMAND = "PROXY" @implementer(_interfaces.IProxyParser) class V2Parser: """ PROXY protocol version two header parser. Version two of the PROXY protocol is a binary format. """ PREFIX = b"\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A" VERSIONS = [32] COMMANDS = {0: _LOCALCOMMAND, 1: _PROXYCOMMAND} ADDRESSFORMATS = { # TCP4 17: "!4s4s2H", 18: "!4s4s2H", # TCP6 33: "!16s16s2H", 34: "!16s16s2H", # UNIX 49: "!108s108s", 50: "!108s108s", } def __init__(self) -> None: self.buffer = b"" def feed( self, data: bytes ) -> Union[Tuple[_info.ProxyInfo, bytes], Tuple[None, None]]: """ Consume a chunk of data and attempt to parse it. @param data: A bytestring. @type data: bytes @return: A two-tuple containing, in order, a L{_interfaces.IProxyInfo} and any bytes fed to the parser that followed the end of the header. Both of these values are None until a complete header is parsed. @raises InvalidProxyHeader: If the bytes fed to the parser create an invalid PROXY header. """ self.buffer += data if len(self.buffer) < 16: raise InvalidProxyHeader() size = struct.unpack("!H", self.buffer[14:16])[0] + 16 if len(self.buffer) < size: return (None, None) header, remaining = self.buffer[:size], self.buffer[size:] self.buffer = b"" info = self.parse(header) return (info, remaining) @staticmethod def _bytesToIPv4(bytestring: bytes) -> bytes: """ Convert packed 32-bit IPv4 address bytes into a dotted-quad ASCII bytes representation of that address. @param bytestring: 4 octets representing an IPv4 address. @type bytestring: L{bytes} @return: a dotted-quad notation IPv4 address. @rtype: L{bytes} """ return b".".join( ("%i" % (ord(b),)).encode("ascii") for b in compat.iterbytes(bytestring) ) @staticmethod def _bytesToIPv6(bytestring: bytes) -> bytes: """ Convert packed 128-bit IPv6 address bytes into a colon-separated ASCII bytes representation of that address. @param bytestring: 16 octets representing an IPv6 address. @type bytestring: L{bytes} @return: a dotted-quad notation IPv6 address. @rtype: L{bytes} """ hexString = binascii.b2a_hex(bytestring) return b":".join( (f"{int(hexString[b : b + 4], 16):x}").encode("ascii") for b in range(0, 32, 4) ) @classmethod def parse(cls, line: bytes) -> _info.ProxyInfo: """ Parse a bytestring as a full PROXY protocol header. @param line: A bytestring that represents a valid HAProxy PROXY protocol version 2 header. @type line: bytes @return: A L{_interfaces.IProxyInfo} containing the parsed data. @raises InvalidProxyHeader: If the bytestring does not represent a valid PROXY header. """ prefix = line[:12] addrInfo = None with convertError(IndexError, InvalidProxyHeader): # Use single value slices to ensure bytestring values are returned # instead of int in PY3. versionCommand = ord(line[12:13]) familyProto = ord(line[13:14]) if prefix != cls.PREFIX: raise InvalidProxyHeader() version, command = versionCommand & _HIGH, versionCommand & _LOW if version not in cls.VERSIONS or command not in cls.COMMANDS: raise InvalidProxyHeader() if cls.COMMANDS[command] == _LOCALCOMMAND: return _info.ProxyInfo(line, None, None) family, netproto = familyProto & _HIGH, familyProto & _LOW with convertError(ValueError, InvalidNetworkProtocol): family = NetFamily.lookupByValue(family) netproto = NetProtocol.lookupByValue(netproto) if family is NetFamily.UNSPEC or netproto is NetProtocol.UNSPEC: return _info.ProxyInfo(line, None, None) addressFormat = cls.ADDRESSFORMATS[familyProto] addrInfo = line[16 : 16 + struct.calcsize(addressFormat)] if family is NetFamily.UNIX: with convertError(struct.error, MissingAddressData): source, dest = struct.unpack(addressFormat, addrInfo) return _info.ProxyInfo( line, address.UNIXAddress(source.rstrip(b"\x00")), address.UNIXAddress(dest.rstrip(b"\x00")), ) addrType: Union[Literal["TCP"], Literal["UDP"]] = "TCP" if netproto is NetProtocol.DGRAM: addrType = "UDP" addrCls: Union[ Type[address.IPv4Address], Type[address.IPv6Address] ] = address.IPv4Address addrParser: Callable[[bytes], bytes] = cls._bytesToIPv4 if family is NetFamily.INET6: addrCls = address.IPv6Address addrParser = cls._bytesToIPv6 with convertError(struct.error, MissingAddressData): info = struct.unpack(addressFormat, addrInfo) source, dest, sPort, dPort = info return _info.ProxyInfo( line, addrCls(addrType, addrParser(source).decode(), sPort), addrCls(addrType, addrParser(dest).decode(), dPort), ) PK Mb�Zi�� � protocols/haproxy/__init__.pynu �[��� # -*- test-case-name: twisted.protocols.haproxy.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ HAProxy PROXY protocol implementations. """ __all__ = ["proxyEndpoint"] from ._wrapper import proxyEndpoint PK Mb�Z�_t�{ �{ protocols/basic.pynu �[��� # -*- test-case-name: twisted.protocols.test.test_basic -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Basic protocols, such as line-oriented, netstring, and int prefixed strings. """ import math # System imports import re from io import BytesIO from struct import calcsize, pack, unpack from zope.interface import implementer # Twisted imports from twisted.internet import defer, interfaces, protocol from twisted.python import log # Unfortunately we cannot use regular string formatting on Python 3; see # http://bugs.python.org/issue3982 for details. def _formatNetstring(data): return b"".join([str(len(data)).encode("ascii"), b":", data, b","]) _formatNetstring.__doc__ = """ Convert some C{bytes} into netstring format. @param data: C{bytes} that will be reformatted. """ DEBUG = 0 class NetstringParseError(ValueError): """ The incoming data is not in valid Netstring format. """ class IncompleteNetstring(Exception): """ Not enough data to complete a netstring. """ class NetstringReceiver(protocol.Protocol): """ A protocol that sends and receives netstrings. See U{http://cr.yp.to/proto/netstrings.txt} for the specification of netstrings. Every netstring starts with digits that specify the length of the data. This length specification is separated from the data by a colon. The data is terminated with a comma. Override L{stringReceived} to handle received netstrings. This method is called with the netstring payload as a single argument whenever a complete netstring is received. Security features: 1. Messages are limited in size, useful if you don't want someone sending you a 500MB netstring (change C{self.MAX_LENGTH} to the maximum length you wish to accept). 2. The connection is lost if an illegal message is received. @ivar MAX_LENGTH: Defines the maximum length of netstrings that can be received. @type MAX_LENGTH: C{int} @ivar _LENGTH: A pattern describing all strings that contain a netstring length specification. Examples for length specifications are C{b'0:'}, C{b'12:'}, and C{b'179:'}. C{b'007:'} is not a valid length specification, since leading zeros are not allowed. @type _LENGTH: C{re.Match} @ivar _LENGTH_PREFIX: A pattern describing all strings that contain the first part of a netstring length specification (without the trailing comma). Examples are '0', '12', and '179'. '007' does not start a netstring length specification, since leading zeros are not allowed. @type _LENGTH_PREFIX: C{re.Match} @ivar _PARSING_LENGTH: Indicates that the C{NetstringReceiver} is in the state of parsing the length portion of a netstring. @type _PARSING_LENGTH: C{int} @ivar _PARSING_PAYLOAD: Indicates that the C{NetstringReceiver} is in the state of parsing the payload portion (data and trailing comma) of a netstring. @type _PARSING_PAYLOAD: C{int} @ivar brokenPeer: Indicates if the connection is still functional @type brokenPeer: C{int} @ivar _state: Indicates if the protocol is consuming the length portion (C{PARSING_LENGTH}) or the payload (C{PARSING_PAYLOAD}) of a netstring @type _state: C{int} @ivar _remainingData: Holds the chunk of data that has not yet been consumed @type _remainingData: C{string} @ivar _payload: Holds the payload portion of a netstring including the trailing comma @type _payload: C{BytesIO} @ivar _expectedPayloadSize: Holds the payload size plus one for the trailing comma. @type _expectedPayloadSize: C{int} """ MAX_LENGTH = 99999 _LENGTH = re.compile(br"(0|[1-9]\d*)(:)") _LENGTH_PREFIX = re.compile(br"(0|[1-9]\d*)$") # Some error information for NetstringParseError instances. _MISSING_LENGTH = ( "The received netstring does not start with a " "length specification." ) _OVERFLOW = ( "The length specification of the received netstring " "cannot be represented in Python - it causes an " "OverflowError!" ) _TOO_LONG = ( "The received netstring is longer than the maximum %s " "specified by self.MAX_LENGTH" ) _MISSING_COMMA = "The received netstring is not terminated by a comma." # The following constants are used for determining if the NetstringReceiver # is parsing the length portion of a netstring, or the payload. _PARSING_LENGTH, _PARSING_PAYLOAD = range(2) def makeConnection(self, transport): """ Initializes the protocol. """ protocol.Protocol.makeConnection(self, transport) self._remainingData = b"" self._currentPayloadSize = 0 self._payload = BytesIO() self._state = self._PARSING_LENGTH self._expectedPayloadSize = 0 self.brokenPeer = 0 def sendString(self, string): """ Sends a netstring. Wraps up C{string} by adding length information and a trailing comma; writes the result to the transport. @param string: The string to send. The necessary framing (length prefix, etc) will be added. @type string: C{bytes} """ self.transport.write(_formatNetstring(string)) def dataReceived(self, data): """ Receives some characters of a netstring. Whenever a complete netstring is received, this method extracts its payload and calls L{stringReceived} to process it. @param data: A chunk of data representing a (possibly partial) netstring @type data: C{bytes} """ self._remainingData += data while self._remainingData: try: self._consumeData() except IncompleteNetstring: break except NetstringParseError: self._handleParseError() break def stringReceived(self, string): """ Override this for notification when each complete string is received. @param string: The complete string which was received with all framing (length prefix, etc) removed. @type string: C{bytes} @raise NotImplementedError: because the method has to be implemented by the child class. """ raise NotImplementedError() def _maxLengthSize(self): """ Calculate and return the string size of C{self.MAX_LENGTH}. @return: The size of the string representation for C{self.MAX_LENGTH} @rtype: C{float} """ return math.ceil(math.log10(self.MAX_LENGTH)) + 1 def _consumeData(self): """ Consumes the content of C{self._remainingData}. @raise IncompleteNetstring: if C{self._remainingData} does not contain enough data to complete the current netstring. @raise NetstringParseError: if the received data do not form a valid netstring. """ if self._state == self._PARSING_LENGTH: self._consumeLength() self._prepareForPayloadConsumption() if self._state == self._PARSING_PAYLOAD: self._consumePayload() def _consumeLength(self): """ Consumes the length portion of C{self._remainingData}. @raise IncompleteNetstring: if C{self._remainingData} contains a partial length specification (digits without trailing comma). @raise NetstringParseError: if the received data do not form a valid netstring. """ lengthMatch = self._LENGTH.match(self._remainingData) if not lengthMatch: self._checkPartialLengthSpecification() raise IncompleteNetstring() self._processLength(lengthMatch) def _checkPartialLengthSpecification(self): """ Makes sure that the received data represents a valid number. Checks if C{self._remainingData} represents a number smaller or equal to C{self.MAX_LENGTH}. @raise NetstringParseError: if C{self._remainingData} is no number or is too big (checked by L{_extractLength}). """ partialLengthMatch = self._LENGTH_PREFIX.match(self._remainingData) if not partialLengthMatch: raise NetstringParseError(self._MISSING_LENGTH) lengthSpecification = partialLengthMatch.group(1) self._extractLength(lengthSpecification) def _processLength(self, lengthMatch): """ Processes the length definition of a netstring. Extracts and stores in C{self._expectedPayloadSize} the number representing the netstring size. Removes the prefix representing the length specification from C{self._remainingData}. @raise NetstringParseError: if the received netstring does not start with a number or the number is bigger than C{self.MAX_LENGTH}. @param lengthMatch: A regular expression match object matching a netstring length specification @type lengthMatch: C{re.Match} """ endOfNumber = lengthMatch.end(1) startOfData = lengthMatch.end(2) lengthString = self._remainingData[:endOfNumber] # Expect payload plus trailing comma: self._expectedPayloadSize = self._extractLength(lengthString) + 1 self._remainingData = self._remainingData[startOfData:] def _extractLength(self, lengthAsString): """ Attempts to extract the length information of a netstring. @raise NetstringParseError: if the number is bigger than C{self.MAX_LENGTH}. @param lengthAsString: A chunk of data starting with a length specification @type lengthAsString: C{bytes} @return: The length of the netstring @rtype: C{int} """ self._checkStringSize(lengthAsString) length = int(lengthAsString) if length > self.MAX_LENGTH: raise NetstringParseError(self._TOO_LONG % (self.MAX_LENGTH,)) return length def _checkStringSize(self, lengthAsString): """ Checks the sanity of lengthAsString. Checks if the size of the length specification exceeds the size of the string representing self.MAX_LENGTH. If this is not the case, the number represented by lengthAsString is certainly bigger than self.MAX_LENGTH, and a NetstringParseError can be raised. This method should make sure that netstrings with extremely long length specifications are refused before even attempting to convert them to an integer (which might trigger a MemoryError). """ if len(lengthAsString) > self._maxLengthSize(): raise NetstringParseError(self._TOO_LONG % (self.MAX_LENGTH,)) def _prepareForPayloadConsumption(self): """ Sets up variables necessary for consuming the payload of a netstring. """ self._state = self._PARSING_PAYLOAD self._currentPayloadSize = 0 self._payload.seek(0) self._payload.truncate() def _consumePayload(self): """ Consumes the payload portion of C{self._remainingData}. If the payload is complete, checks for the trailing comma and processes the payload. If not, raises an L{IncompleteNetstring} exception. @raise IncompleteNetstring: if the payload received so far contains fewer characters than expected. @raise NetstringParseError: if the payload does not end with a comma. """ self._extractPayload() if self._currentPayloadSize < self._expectedPayloadSize: raise IncompleteNetstring() self._checkForTrailingComma() self._state = self._PARSING_LENGTH self._processPayload() def _extractPayload(self): """ Extracts payload information from C{self._remainingData}. Splits C{self._remainingData} at the end of the netstring. The first part becomes C{self._payload}, the second part is stored in C{self._remainingData}. If the netstring is not yet complete, the whole content of C{self._remainingData} is moved to C{self._payload}. """ if self._payloadComplete(): remainingPayloadSize = self._expectedPayloadSize - self._currentPayloadSize self._payload.write(self._remainingData[:remainingPayloadSize]) self._remainingData = self._remainingData[remainingPayloadSize:] self._currentPayloadSize = self._expectedPayloadSize else: self._payload.write(self._remainingData) self._currentPayloadSize += len(self._remainingData) self._remainingData = b"" def _payloadComplete(self): """ Checks if enough data have been received to complete the netstring. @return: C{True} iff the received data contain at least as many characters as specified in the length section of the netstring @rtype: C{bool} """ return ( len(self._remainingData) + self._currentPayloadSize >= self._expectedPayloadSize ) def _processPayload(self): """ Processes the actual payload with L{stringReceived}. Strips C{self._payload} of the trailing comma and calls L{stringReceived} with the result. """ self.stringReceived(self._payload.getvalue()[:-1]) def _checkForTrailingComma(self): """ Checks if the netstring has a trailing comma at the expected position. @raise NetstringParseError: if the last payload character is anything but a comma. """ if self._payload.getvalue()[-1:] != b",": raise NetstringParseError(self._MISSING_COMMA) def _handleParseError(self): """ Terminates the connection and sets the flag C{self.brokenPeer}. """ self.transport.loseConnection() self.brokenPeer = 1 class LineOnlyReceiver(protocol.Protocol): """ A protocol that receives only lines. This is purely a speed optimisation over LineReceiver, for the cases that raw mode is known to be unnecessary. @cvar delimiter: The line-ending delimiter to use. By default this is C{b'\\r\\n'}. @cvar MAX_LENGTH: The maximum length of a line to allow (If a sent line is longer than this, the connection is dropped). Default is 16384. """ _buffer = b"" delimiter = b"\r\n" MAX_LENGTH = 16384 def dataReceived(self, data): """ Translates bytes into lines, and calls lineReceived. """ lines = (self._buffer + data).split(self.delimiter) self._buffer = lines.pop(-1) for line in lines: if self.transport.disconnecting: # this is necessary because the transport may be told to lose # the connection by a line within a larger packet, and it is # important to disregard all the lines in that packet following # the one that told it to close. return if len(line) > self.MAX_LENGTH: return self.lineLengthExceeded(line) else: self.lineReceived(line) if len(self._buffer) > self.MAX_LENGTH: return self.lineLengthExceeded(self._buffer) def lineReceived(self, line): """ Override this for when each line is received. @param line: The line which was received with the delimiter removed. @type line: C{bytes} """ raise NotImplementedError def sendLine(self, line): """ Sends a line to the other end of the connection. @param line: The line to send, not including the delimiter. @type line: C{bytes} """ return self.transport.writeSequence((line, self.delimiter)) def lineLengthExceeded(self, line): """ Called when the maximum line length has been reached. Override if it needs to be dealt with in some special way. """ return self.transport.loseConnection() class _PauseableMixin: paused = False def pauseProducing(self): self.paused = True self.transport.pauseProducing() def resumeProducing(self): self.paused = False self.transport.resumeProducing() self.dataReceived(b"") def stopProducing(self): self.paused = True self.transport.stopProducing() class LineReceiver(protocol.Protocol, _PauseableMixin): """ A protocol that receives lines and/or raw data, depending on mode. In line mode, each line that's received becomes a callback to L{lineReceived}. In raw data mode, each chunk of raw data becomes a callback to L{LineReceiver.rawDataReceived}. The L{setLineMode} and L{setRawMode} methods switch between the two modes. This is useful for line-oriented protocols such as IRC, HTTP, POP, etc. @cvar delimiter: The line-ending delimiter to use. By default this is C{b'\\r\\n'}. @cvar MAX_LENGTH: The maximum length of a line to allow (If a sent line is longer than this, the connection is dropped). Default is 16384. """ line_mode = 1 _buffer = b"" _busyReceiving = False delimiter = b"\r\n" MAX_LENGTH = 16384 def clearLineBuffer(self): """ Clear buffered data. @return: All of the cleared buffered data. @rtype: C{bytes} """ b, self._buffer = self._buffer, b"" return b def dataReceived(self, data): """ Protocol.dataReceived. Translates bytes into lines, and calls lineReceived (or rawDataReceived, depending on mode.) """ if self._busyReceiving: self._buffer += data return try: self._busyReceiving = True self._buffer += data while self._buffer and not self.paused: if self.line_mode: try: line, self._buffer = self._buffer.split(self.delimiter, 1) except ValueError: if len(self._buffer) >= (self.MAX_LENGTH + len(self.delimiter)): line, self._buffer = self._buffer, b"" return self.lineLengthExceeded(line) return else: lineLength = len(line) if lineLength > self.MAX_LENGTH: exceeded = line + self.delimiter + self._buffer self._buffer = b"" return self.lineLengthExceeded(exceeded) why = self.lineReceived(line) if why or self.transport and self.transport.disconnecting: return why else: data = self._buffer self._buffer = b"" why = self.rawDataReceived(data) if why: return why finally: self._busyReceiving = False def setLineMode(self, extra=b""): """ Sets the line-mode of this receiver. If you are calling this from a rawDataReceived callback, you can pass in extra unhandled data, and that data will be parsed for lines. Further data received will be sent to lineReceived rather than rawDataReceived. Do not pass extra data if calling this function from within a lineReceived callback. """ self.line_mode = 1 if extra: return self.dataReceived(extra) def setRawMode(self): """ Sets the raw mode of this receiver. Further data received will be sent to rawDataReceived rather than lineReceived. """ self.line_mode = 0 def rawDataReceived(self, data): """ Override this for when raw data is received. """ raise NotImplementedError def lineReceived(self, line): """ Override this for when each line is received. @param line: The line which was received with the delimiter removed. @type line: C{bytes} """ raise NotImplementedError def sendLine(self, line): """ Sends a line to the other end of the connection. @param line: The line to send, not including the delimiter. @type line: C{bytes} """ return self.transport.write(line + self.delimiter) def lineLengthExceeded(self, line): """ Called when the maximum line length has been reached. Override if it needs to be dealt with in some special way. The argument 'line' contains the remainder of the buffer, starting with (at least some part) of the line which is too long. This may be more than one line, or may be only the initial portion of the line. """ return self.transport.loseConnection() class StringTooLongError(AssertionError): """ Raised when trying to send a string too long for a length prefixed protocol. """ class _RecvdCompatHack: """ Emulates the to-be-deprecated C{IntNStringReceiver.recvd} attribute. The C{recvd} attribute was where the working buffer for buffering and parsing netstrings was kept. It was updated each time new data arrived and each time some of that data was parsed and delivered to application code. The piecemeal updates to its string value were expensive and have been removed from C{IntNStringReceiver} in the normal case. However, for applications directly reading this attribute, this descriptor restores that behavior. It only copies the working buffer when necessary (ie, when accessed). This avoids the cost for applications not using the data. This is a custom descriptor rather than a property, because we still need the default __set__ behavior in both new-style and old-style subclasses. """ def __get__(self, oself, type=None): return oself._unprocessed[oself._compatibilityOffset :] class IntNStringReceiver(protocol.Protocol, _PauseableMixin): """ Generic class for length prefixed protocols. @ivar _unprocessed: bytes received, but not yet broken up into messages / sent to stringReceived. _compatibilityOffset must be updated when this value is updated so that the C{recvd} attribute can be generated correctly. @type _unprocessed: C{bytes} @ivar structFormat: format used for struct packing/unpacking. Define it in subclass. @type structFormat: C{str} @ivar prefixLength: length of the prefix, in bytes. Define it in subclass, using C{struct.calcsize(structFormat)} @type prefixLength: C{int} @ivar _compatibilityOffset: the offset within C{_unprocessed} to the next message to be parsed. (used to generate the recvd attribute) @type _compatibilityOffset: C{int} """ MAX_LENGTH = 99999 _unprocessed = b"" _compatibilityOffset = 0 # Backwards compatibility support for applications which directly touch the # "internal" parse buffer. recvd = _RecvdCompatHack() def stringReceived(self, string): """ Override this for notification when each complete string is received. @param string: The complete string which was received with all framing (length prefix, etc) removed. @type string: C{bytes} """ raise NotImplementedError def lengthLimitExceeded(self, length): """ Callback invoked when a length prefix greater than C{MAX_LENGTH} is received. The default implementation disconnects the transport. Override this. @param length: The length prefix which was received. @type length: C{int} """ self.transport.loseConnection() def dataReceived(self, data): """ Convert int prefixed strings into calls to stringReceived. """ # Try to minimize string copying (via slices) by keeping one buffer # containing all the data we have so far and a separate offset into that # buffer. alldata = self._unprocessed + data currentOffset = 0 prefixLength = self.prefixLength fmt = self.structFormat self._unprocessed = alldata while len(alldata) >= (currentOffset + prefixLength) and not self.paused: messageStart = currentOffset + prefixLength (length,) = unpack(fmt, alldata[currentOffset:messageStart]) if length > self.MAX_LENGTH: self._unprocessed = alldata self._compatibilityOffset = currentOffset self.lengthLimitExceeded(length) return messageEnd = messageStart + length if len(alldata) < messageEnd: break # Here we have to slice the working buffer so we can send just the # netstring into the stringReceived callback. packet = alldata[messageStart:messageEnd] currentOffset = messageEnd self._compatibilityOffset = currentOffset self.stringReceived(packet) # Check to see if the backwards compat "recvd" attribute got written # to by application code. If so, drop the current data buffer and # switch to the new buffer given by that attribute's value. if "recvd" in self.__dict__: alldata = self.__dict__.pop("recvd") self._unprocessed = alldata self._compatibilityOffset = currentOffset = 0 if alldata: continue return # Slice off all the data that has been processed, avoiding holding onto # memory to store it, and update the compatibility attributes to reflect # that change. self._unprocessed = alldata[currentOffset:] self._compatibilityOffset = 0 def sendString(self, string): """ Send a prefixed string to the other end of the connection. @param string: The string to send. The necessary framing (length prefix, etc) will be added. @type string: C{bytes} """ if len(string) >= 2 ** (8 * self.prefixLength): raise StringTooLongError( "Try to send %s bytes whereas maximum is %s" % (len(string), 2 ** (8 * self.prefixLength)) ) self.transport.write(pack(self.structFormat, len(string)) + string) class Int32StringReceiver(IntNStringReceiver): """ A receiver for int32-prefixed strings. An int32 string is a string prefixed by 4 bytes, the 32-bit length of the string encoded in network byte order. This class publishes the same interface as NetstringReceiver. """ structFormat = "!I" prefixLength = calcsize(structFormat) class Int16StringReceiver(IntNStringReceiver): """ A receiver for int16-prefixed strings. An int16 string is a string prefixed by 2 bytes, the 16-bit length of the string encoded in network byte order. This class publishes the same interface as NetstringReceiver. """ structFormat = "!H" prefixLength = calcsize(structFormat) class Int8StringReceiver(IntNStringReceiver): """ A receiver for int8-prefixed strings. An int8 string is a string prefixed by 1 byte, the 8-bit length of the string. This class publishes the same interface as NetstringReceiver. """ structFormat = "!B" prefixLength = calcsize(structFormat) class StatefulStringProtocol: """ A stateful string protocol. This is a mixin for string protocols (L{Int32StringReceiver}, L{NetstringReceiver}) which translates L{stringReceived} into a callback (prefixed with C{'proto_'}) depending on state. The state C{'done'} is special; if a C{proto_*} method returns it, the connection will be closed immediately. @ivar state: Current state of the protocol. Defaults to C{'init'}. @type state: C{str} """ state = "init" def stringReceived(self, string): """ Choose a protocol phase function and call it. Call back to the appropriate protocol phase; this begins with the function C{proto_init} and moves on to C{proto_*} depending on what each C{proto_*} function returns. (For example, if C{self.proto_init} returns 'foo', then C{self.proto_foo} will be the next function called when a protocol message is received. """ try: pto = "proto_" + self.state statehandler = getattr(self, pto) except AttributeError: log.msg("callback", self.state, "not found") else: self.state = statehandler(string) if self.state == "done": self.transport.loseConnection() @implementer(interfaces.IProducer) class FileSender: """ A producer that sends the contents of a file to a consumer. This is a helper for protocols that, at some point, will take a file-like object, read its contents, and write them out to the network, optionally performing some transformation on the bytes in between. """ CHUNK_SIZE = 2 ** 14 lastSent = "" deferred = None def beginFileTransfer(self, file, consumer, transform=None): """ Begin transferring a file @type file: Any file-like object @param file: The file object to read data from @type consumer: Any implementor of IConsumer @param consumer: The object to write data to @param transform: A callable taking one string argument and returning the same. All bytes read from the file are passed through this before being written to the consumer. @rtype: C{Deferred} @return: A deferred whose callback will be invoked when the file has been completely written to the consumer. The last byte written to the consumer is passed to the callback. """ self.file = file self.consumer = consumer self.transform = transform self.deferred = deferred = defer.Deferred() self.consumer.registerProducer(self, False) return deferred def resumeProducing(self): chunk = "" if self.file: chunk = self.file.read(self.CHUNK_SIZE) if not chunk: self.file = None self.consumer.unregisterProducer() if self.deferred: self.deferred.callback(self.lastSent) self.deferred = None return if self.transform: chunk = self.transform(chunk) self.consumer.write(chunk) self.lastSent = chunk[-1:] def pauseProducing(self): pass def stopProducing(self): if self.deferred: self.deferred.errback(Exception("Consumer asked us to stop producing")) self.deferred = None PK Mb�Z B��� � protocols/shoutcast.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Chop up shoutcast stream into MP3s and metadata, if available. """ from twisted import copyright from twisted.web import http class ShoutcastClient(http.HTTPClient): """ Shoutcast HTTP stream. Modes can be 'length', 'meta' and 'mp3'. See U{http://www.smackfu.com/stuff/programming/shoutcast.html} for details on the protocol. """ userAgent = "Twisted Shoutcast client " + copyright.version def __init__(self, path="/"): self.path = path self.got_metadata = False self.metaint = None self.metamode = "mp3" self.databuffer = "" def connectionMade(self): self.sendCommand("GET", self.path) self.sendHeader("User-Agent", self.userAgent) self.sendHeader("Icy-MetaData", "1") self.endHeaders() def lineReceived(self, line): # fix shoutcast crappiness if not self.firstLine and line: if len(line.split(": ", 1)) == 1: line = line.replace(":", ": ", 1) http.HTTPClient.lineReceived(self, line) def handleHeader(self, key, value): if key.lower() == "icy-metaint": self.metaint = int(value) self.got_metadata = True def handleEndHeaders(self): # Lets check if we got metadata, and set the # appropriate handleResponsePart method. if self.got_metadata: # if we have metadata, then it has to be parsed out of the data stream self.handleResponsePart = self.handleResponsePart_with_metadata else: # otherwise, all the data is MP3 data self.handleResponsePart = self.gotMP3Data def handleResponsePart_with_metadata(self, data): self.databuffer += data while self.databuffer: stop = getattr(self, "handle_%s" % self.metamode)() if stop: return def handle_length(self): self.remaining = ord(self.databuffer[0]) * 16 self.databuffer = self.databuffer[1:] self.metamode = "meta" def handle_mp3(self): if len(self.databuffer) > self.metaint: self.gotMP3Data(self.databuffer[: self.metaint]) self.databuffer = self.databuffer[self.metaint :] self.metamode = "length" else: return 1 def handle_meta(self): if len(self.databuffer) >= self.remaining: if self.remaining: data = self.databuffer[: self.remaining] self.gotMetaData(self.parseMetadata(data)) self.databuffer = self.databuffer[self.remaining :] self.metamode = "mp3" else: return 1 def parseMetadata(self, data): meta = [] for chunk in data.split(";"): chunk = chunk.strip().replace("\x00", "") if not chunk: continue key, value = chunk.split("=", 1) if value.startswith("'") and value.endswith("'"): value = value[1:-1] meta.append((key, value)) return meta def gotMetaData(self, metadata): """Called with a list of (key, value) pairs of metadata, if metadata is available on the server. Will only be called on non-empty metadata. """ raise NotImplementedError("implement in subclass") def gotMP3Data(self, data): """Called with chunk of MP3 data.""" raise NotImplementedError("implement in subclass") PK Mb�Z�� �$ �$ protocols/htb.pynu �[��� # -*- test-case-name: twisted.test.test_htb -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Hierarchical Token Bucket traffic shaping. Patterned after U{Martin Devera's Hierarchical Token Bucket traffic shaper for the Linux kernel<http://luxik.cdi.cz/~devik/qos/htb/>}. @seealso: U{HTB Linux queuing discipline manual - user guide <http://luxik.cdi.cz/~devik/qos/htb/manual/userg.htm>} @seealso: U{Token Bucket Filter in Linux Advanced Routing & Traffic Control HOWTO<http://lartc.org/howto/lartc.qdisc.classless.html#AEN682>} """ # TODO: Investigate whether we should be using os.times()[-1] instead of # time.time. time.time, it has been pointed out, can go backwards. Is # the same true of os.times? from time import time from typing import Optional from zope.interface import Interface, implementer from twisted.protocols import pcp class Bucket: """ Implementation of a Token bucket. A bucket can hold a certain number of tokens and it drains over time. @cvar maxburst: The maximum number of tokens that the bucket can hold at any given time. If this is L{None}, the bucket has an infinite size. @type maxburst: C{int} @cvar rate: The rate at which the bucket drains, in number of tokens per second. If the rate is L{None}, the bucket drains instantaneously. @type rate: C{int} """ maxburst: Optional[int] = None rate: Optional[int] = None _refcount = 0 def __init__(self, parentBucket=None): """ Create a L{Bucket} that may have a parent L{Bucket}. @param parentBucket: If a parent Bucket is specified, all L{add} and L{drip} operations on this L{Bucket} will be applied on the parent L{Bucket} as well. @type parentBucket: L{Bucket} """ self.content = 0 self.parentBucket = parentBucket self.lastDrip = time() def add(self, amount): """ Adds tokens to the L{Bucket} and its C{parentBucket}. This will add as many of the C{amount} tokens as will fit into both this L{Bucket} and its C{parentBucket}. @param amount: The number of tokens to try to add. @type amount: C{int} @returns: The number of tokens that actually fit. @returntype: C{int} """ self.drip() if self.maxburst is None: allowable = amount else: allowable = min(amount, self.maxburst - self.content) if self.parentBucket is not None: allowable = self.parentBucket.add(allowable) self.content += allowable return allowable def drip(self): """ Let some of the bucket drain. The L{Bucket} drains at the rate specified by the class variable C{rate}. @returns: C{True} if the bucket is empty after this drip. @returntype: C{bool} """ if self.parentBucket is not None: self.parentBucket.drip() if self.rate is None: self.content = 0 else: now = time() deltaTime = now - self.lastDrip deltaTokens = deltaTime * self.rate self.content = max(0, self.content - deltaTokens) self.lastDrip = now return self.content == 0 class IBucketFilter(Interface): def getBucketFor(*somethings, **some_kw): """ Return a L{Bucket} corresponding to the provided parameters. @returntype: L{Bucket} """ @implementer(IBucketFilter) class HierarchicalBucketFilter: """ Filter things into buckets that can be nested. @cvar bucketFactory: Class of buckets to make. @type bucketFactory: L{Bucket} @cvar sweepInterval: Seconds between sweeping out the bucket cache. @type sweepInterval: C{int} """ bucketFactory = Bucket sweepInterval: Optional[int] = None def __init__(self, parentFilter=None): self.buckets = {} self.parentFilter = parentFilter self.lastSweep = time() def getBucketFor(self, *a, **kw): """ Find or create a L{Bucket} corresponding to the provided parameters. Any parameters are passed on to L{getBucketKey}, from them it decides which bucket you get. @returntype: L{Bucket} """ if (self.sweepInterval is not None) and ( (time() - self.lastSweep) > self.sweepInterval ): self.sweep() if self.parentFilter: parentBucket = self.parentFilter.getBucketFor(self, *a, **kw) else: parentBucket = None key = self.getBucketKey(*a, **kw) bucket = self.buckets.get(key) if bucket is None: bucket = self.bucketFactory(parentBucket) self.buckets[key] = bucket return bucket def getBucketKey(self, *a, **kw): """ Construct a key based on the input parameters to choose a L{Bucket}. The default implementation returns the same key for all arguments. Override this method to provide L{Bucket} selection. @returns: Something to be used as a key in the bucket cache. """ return None def sweep(self): """ Remove empty buckets. """ for key, bucket in self.buckets.items(): bucket_is_empty = bucket.drip() if (bucket._refcount == 0) and bucket_is_empty: del self.buckets[key] self.lastSweep = time() class FilterByHost(HierarchicalBucketFilter): """ A Hierarchical Bucket filter with a L{Bucket} for each host. """ sweepInterval = 60 * 20 def getBucketKey(self, transport): return transport.getPeer()[1] class FilterByServer(HierarchicalBucketFilter): """ A Hierarchical Bucket filter with a L{Bucket} for each service. """ sweepInterval = None def getBucketKey(self, transport): return transport.getHost()[2] class ShapedConsumer(pcp.ProducerConsumerProxy): """ Wraps a C{Consumer} and shapes the rate at which it receives data. """ # Providing a Pull interface means I don't have to try to schedule # traffic with callLaters. iAmStreaming = False def __init__(self, consumer, bucket): pcp.ProducerConsumerProxy.__init__(self, consumer) self.bucket = bucket self.bucket._refcount += 1 def _writeSomeData(self, data): # In practice, this actually results in obscene amounts of # overhead, as a result of generating lots and lots of packets # with twelve-byte payloads. We may need to do a version of # this with scheduled writes after all. amount = self.bucket.add(len(data)) return pcp.ProducerConsumerProxy._writeSomeData(self, data[:amount]) def stopProducing(self): pcp.ProducerConsumerProxy.stopProducing(self) self.bucket._refcount -= 1 class ShapedTransport(ShapedConsumer): """ Wraps a C{Transport} and shapes the rate at which it receives data. This is a L{ShapedConsumer} with a little bit of magic to provide for the case where the consumer it wraps is also a C{Transport} and people will be attempting to access attributes this does not proxy as a C{Consumer} (e.g. C{loseConnection}). """ # Ugh. We only wanted to filter IConsumer, not ITransport. iAmStreaming = False def __getattr__(self, name): # Because people will be doing things like .getPeer and # .loseConnection on me. return getattr(self.consumer, name) class ShapedProtocolFactory: """ Dispense C{Protocols} with traffic shaping on their transports. Usage:: myserver = SomeFactory() myserver.protocol = ShapedProtocolFactory(myserver.protocol, bucketFilter) Where C{SomeServerFactory} is a L{twisted.internet.protocol.Factory}, and C{bucketFilter} is an instance of L{HierarchicalBucketFilter}. """ def __init__(self, protoClass, bucketFilter): """ Tell me what to wrap and where to get buckets. @param protoClass: The class of C{Protocol} this will generate wrapped instances of. @type protoClass: L{Protocol<twisted.internet.interfaces.IProtocol>} class @param bucketFilter: The filter which will determine how traffic is shaped. @type bucketFilter: L{HierarchicalBucketFilter}. """ # More precisely, protoClass can be any callable that will return # instances of something that implements IProtocol. self.protocol = protoClass self.bucketFilter = bucketFilter def __call__(self, *a, **kw): """ Make a C{Protocol} instance with a shaped transport. Any parameters will be passed on to the protocol's initializer. @returns: A C{Protocol} instance with a L{ShapedTransport}. """ proto = self.protocol(*a, **kw) origMakeConnection = proto.makeConnection def makeConnection(transport): bucket = self.bucketFilter.getBucketFor(transport) shapedTransport = ShapedTransport(transport, bucket) return origMakeConnection(shapedTransport) proto.makeConnection = makeConnection return proto PK Mb�Z��}�� � protocols/finger.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """The Finger User Information Protocol (RFC 1288)""" from twisted.protocols import basic class Finger(basic.LineReceiver): def lineReceived(self, line): parts = line.split() if not parts: parts = [b""] if len(parts) == 1: slash_w = 0 else: slash_w = 1 user = parts[-1] if b"@" in user: hostPlace = user.rfind(b"@") user = user[:hostPlace] host = user[hostPlace + 1 :] return self.forwardQuery(slash_w, user, host) if user: return self.getUser(slash_w, user) else: return self.getDomain(slash_w) def _refuseMessage(self, message): self.transport.write(message + b"\n") self.transport.loseConnection() def forwardQuery(self, slash_w, user, host): self._refuseMessage(b"Finger forwarding service denied") def getDomain(self, slash_w): self._refuseMessage(b"Finger online list denied") def getUser(self, slash_w, user): self.transport.write(b"Login: " + user + b"\n") self._refuseMessage(b"No such user") PK Mb�Zr뛯� � protocols/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted Protocols: A collection of internet protocol implementations. """ from incremental import Version from twisted.python.deprecate import deprecatedModuleAttribute deprecatedModuleAttribute( Version("Twisted", 17, 9, 0), "There is no replacement for this module.", "twisted.protocols", "dict", ) PK Mb�ZJ��I+ I+ cred/checkers.pynu �[��� # -*- test-case-name: twisted.cred.test.test_cred -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Basic credential checkers @var ANONYMOUS: An empty tuple used to represent the anonymous avatar ID. """ import os from zope.interface import Attribute, Interface, implementer from twisted.cred import credentials, error from twisted.internet import defer from twisted.logger import Logger from twisted.python import failure class ICredentialsChecker(Interface): """ An object that can check sub-interfaces of L{ICredentials}. """ credentialInterfaces = Attribute( "A list of sub-interfaces of L{ICredentials} which specifies which I " "may check." ) def requestAvatarId(credentials): """ Validate credentials and produce an avatar ID. @param credentials: something which implements one of the interfaces in C{credentialInterfaces}. @return: a L{Deferred} which will fire with a L{bytes} that identifies an avatar, an empty tuple to specify an authenticated anonymous user (provided as L{twisted.cred.checkers.ANONYMOUS}) or fail with L{UnauthorizedLogin}. Alternatively, return the result itself. @see: L{twisted.cred.credentials} """ # A note on anonymity - We do not want None as the value for anonymous # because it is too easy to accidentally return it. We do not want the # empty string, because it is too easy to mistype a password file. For # example, an .htpasswd file may contain the lines: ['hello:asdf', # 'world:asdf', 'goodbye', ':world']. This misconfiguration will have an # ill effect in any case, but accidentally granting anonymous access is a # worse failure mode than simply granting access to an untypeable # username. We do not want an instance of 'object', because that would # create potential problems with persistence. ANONYMOUS = () @implementer(ICredentialsChecker) class AllowAnonymousAccess: """ A credentials checker that unconditionally grants anonymous access. @cvar credentialInterfaces: Tuple containing L{IAnonymous}. """ credentialInterfaces = (credentials.IAnonymous,) def requestAvatarId(self, credentials): """ Succeed with the L{ANONYMOUS} avatar ID. @return: L{Deferred} that fires with L{twisted.cred.checkers.ANONYMOUS} """ return defer.succeed(ANONYMOUS) @implementer(ICredentialsChecker) class InMemoryUsernamePasswordDatabaseDontUse: """ An extremely simple credentials checker. This is only of use in one-off test programs or examples which don't want to focus too much on how credentials are verified. You really don't want to use this for anything else. It is, at best, a toy. If you need a simple credentials checker for a real application, see L{FilePasswordDB}. @cvar credentialInterfaces: Tuple of L{IUsernamePassword} and L{IUsernameHashedPassword}. @ivar users: Mapping of usernames to passwords. @type users: L{dict} mapping L{bytes} to L{bytes} """ credentialInterfaces = ( credentials.IUsernamePassword, credentials.IUsernameHashedPassword, ) def __init__(self, **users): """ Initialize the in-memory database. For example:: db = InMemoryUsernamePasswordDatabaseDontUse( user1=b'sesame', user2=b'hunter2', ) @param users: Usernames and passwords to seed the database with. Each username given as a keyword is encoded to L{bytes} as ASCII. Passwords must be given as L{bytes}. @type users: L{dict} of L{str} to L{bytes} """ self.users = {x.encode("ascii"): y for x, y in users.items()} def addUser(self, username, password): """ Set a user's password. @param username: Name of the user. @type username: L{bytes} @param password: Password to associate with the username. @type password: L{bytes} """ self.users[username] = password def _cbPasswordMatch(self, matched, username): if matched: return username else: return failure.Failure(error.UnauthorizedLogin()) def requestAvatarId(self, credentials): if credentials.username in self.users: return defer.maybeDeferred( credentials.checkPassword, self.users[credentials.username] ).addCallback(self._cbPasswordMatch, credentials.username) else: return defer.fail(error.UnauthorizedLogin()) @implementer(ICredentialsChecker) class FilePasswordDB: """ A file-based, text-based username/password database. Records in the datafile for this class are delimited by a particular string. The username appears in a fixed field of the columns delimited by this string, as does the password. Both fields are specifiable. If the passwords are not stored plaintext, a hash function must be supplied to convert plaintext passwords to the form stored on disk and this CredentialsChecker will only be able to check L{IUsernamePassword} credentials. If the passwords are stored plaintext, L{IUsernameHashedPassword} credentials will be checkable as well. """ cache = False _credCache = None _cacheTimestamp = 0 _log = Logger() def __init__( self, filename, delim=b":", usernameField=0, passwordField=1, caseSensitive=True, hash=None, cache=False, ): """ @type filename: L{str} @param filename: The name of the file from which to read username and password information. @type delim: L{bytes} @param delim: The field delimiter used in the file. @type usernameField: L{int} @param usernameField: The index of the username after splitting a line on the delimiter. @type passwordField: L{int} @param passwordField: The index of the password after splitting a line on the delimiter. @type caseSensitive: L{bool} @param caseSensitive: If true, consider the case of the username when performing a lookup. Ignore it otherwise. @type hash: Three-argument callable or L{None} @param hash: A function used to transform the plaintext password received over the network to a format suitable for comparison against the version stored on disk. The arguments to the callable are the username, the network-supplied password, and the in-file version of the password. If the return value compares equal to the version stored on disk, the credentials are accepted. @type cache: L{bool} @param cache: If true, maintain an in-memory cache of the contents of the password file. On lookups, the mtime of the file will be checked, and the file will only be re-parsed if the mtime is newer than when the cache was generated. """ self.filename = filename self.delim = delim self.ufield = usernameField self.pfield = passwordField self.caseSensitive = caseSensitive self.hash = hash self.cache = cache if self.hash is None: # The passwords are stored plaintext. We can support both # plaintext and hashed passwords received over the network. self.credentialInterfaces = ( credentials.IUsernamePassword, credentials.IUsernameHashedPassword, ) else: # The passwords are hashed on disk. We can support only # plaintext passwords received over the network. self.credentialInterfaces = (credentials.IUsernamePassword,) def __getstate__(self): d = dict(vars(self)) for k in "_credCache", "_cacheTimestamp": try: del d[k] except KeyError: pass return d def _cbPasswordMatch(self, matched, username): if matched: return username else: return failure.Failure(error.UnauthorizedLogin()) def _loadCredentials(self): """ Loads the credentials from the configured file. @return: An iterable of C{username, password} couples. @rtype: C{iterable} @raise UnauthorizedLogin: when failing to read the credentials from the file. """ try: with open(self.filename, "rb") as f: for line in f: line = line.rstrip() parts = line.split(self.delim) if self.ufield >= len(parts) or self.pfield >= len(parts): continue if self.caseSensitive: yield parts[self.ufield], parts[self.pfield] else: yield parts[self.ufield].lower(), parts[self.pfield] except OSError as e: self._log.error("Unable to load credentials db: {e!r}", e=e) raise error.UnauthorizedLogin() def getUser(self, username): """ Look up the credentials for a username. @param username: The username to look up. @type username: L{bytes} @returns: Two-tuple of the canonicalicalized username (i.e. lowercase if the database is not case sensitive) and the associated password value, both L{bytes}. @rtype: L{tuple} @raises KeyError: When lookup of the username fails. """ if not self.caseSensitive: username = username.lower() if self.cache: if ( self._credCache is None or os.path.getmtime(self.filename) > self._cacheTimestamp ): self._cacheTimestamp = os.path.getmtime(self.filename) self._credCache = dict(self._loadCredentials()) return username, self._credCache[username] else: for u, p in self._loadCredentials(): if u == username: return u, p raise KeyError(username) def requestAvatarId(self, c): try: u, p = self.getUser(c.username) except KeyError: return defer.fail(error.UnauthorizedLogin()) else: up = credentials.IUsernamePassword(c, None) if self.hash: if up is not None: h = self.hash(up.username, up.password, p) if h == p: return defer.succeed(u) return defer.fail(error.UnauthorizedLogin()) else: return defer.maybeDeferred(c.checkPassword, p).addCallback( self._cbPasswordMatch, u ) # For backwards compatibility # Allow access as the old name. OnDiskUsernamePasswordDatabase = FilePasswordDB PK Mb�Z�~� ) cred/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )zm Twisted Cred: Support for verifying credentials, and providing services to user based on those credentials. N)�__doc__� r r �7/usr/lib/python3/dist-packages/twisted/cred/__init__.py�<module> s PK Mb�ZԼ &� � ' cred/__pycache__/portal.cpython-310.pycnu �[��� o �b. � @ sj d Z ddlmZmZ ddlmZ ddlmZ ddlm Z ddl m Z m Z G dd� de�Z G d d � d �Zd S ) z= The point of integration of application and authentication. � )� Interface� providedBy)�error)�defer)� maybeDeferred)�failure�reflectc @ s e Zd ZdZdd� ZdS )�IRealmz[ The realm connects application-specific objects to the authentication system. c G s dS )a� Return avatar which provides one of the given interfaces. @param avatarId: a string that identifies an avatar, as returned by L{ICredentialsChecker.requestAvatarId<twisted.cred.checkers.ICredentialsChecker.requestAvatarId>} (via a Deferred). Alternatively, it may be C{twisted.cred.checkers.ANONYMOUS}. @param mind: usually None. See the description of mind in L{Portal.login}. @param interfaces: the interface(s) the returned avatar should implement, e.g. C{IMailAccount}. See the description of L{Portal.login}. @returns: a deferred which will fire a tuple of (interface, avatarAspect, logout), or the tuple itself. The interface will be one of the interfaces passed in the 'interfaces' argument. The 'avatarAspect' will implement that interface. The 'logout' object is a callable which will detach the mind from the avatar. N� )�avatarId�mind� interfacesr r �5/usr/lib/python3/dist-packages/twisted/cred/portal.py� requestAvatar s zIRealm.requestAvatarN)�__name__� __module__� __qualname__�__doc__r r r r r r s r c @ s2 e Zd ZdZd dd�Zdd� Zdd� Zd d � Zd S ) �Portala� A mediator between clients and a realm. A portal is associated with one Realm and zero or more credentials checkers. When a login is attempted, the portal finds the appropriate credentials checker for the credentials given, invokes it, and if the credentials are valid, retrieves the appropriate avatar from the Realm. This class is not intended to be subclassed. Customization should be done in the realm object and in the credentials checker objects. r c C s$ || _ i | _|D ]}| �|� qdS )z1 Create a Portal to a L{IRealm}. N)�realm�checkers�registerChecker)�selfr r �checkerr r r �__init__< s �zPortal.__init__c C s t | j�� �S )zR Return list of credentials interfaces that can be used to login. )�listr �keys)r r r r �listCredentialsInterfacesE s z Portal.listCredentialsInterfacesc G s" |s|j }|D ]}|| j|< qd S )N)�credentialInterfacesr )r r r �credentialInterfacer r r r K s �zPortal.registerCheckerc G sp | j D ] }|�|�r t| j | j|�j| jj|g|�R � S qt|�}t�t � t � dd� ttj|�� ���S )a� @param credentials: an implementor of L{twisted.cred.credentials.ICredentials} @param mind: an object which implements a client-side interface for your particular realm. In many cases, this may be None, so if the word 'mind' confuses you, just ignore it. @param interfaces: list of interfaces for the perspective that the mind wishes to attach to. Usually, this will be only one interface, for example IMailAccount. For highly dynamic protocols, however, this may be a list like (IMailAccount, IUserChooser, IServiceInfo). To expand: if we are speaking to the system over IMAP, any information that will be relayed to the user MUST be returned as an IMailAccount implementor; IMAP clients would not be able to understand anything else. Any information about unusual status would have to be relayed as a single mail message in an otherwise-empty mailbox. However, in a web-based mail system, or a PB-based client, the ``mind'' object inside the web server (implemented with a dynamic page-viewing mechanism such as a Twisted Web Resource) or on the user's client program may be intelligent enough to respond to several ``server''-side interfaces. @return: A deferred which will fire a tuple of (interface, avatarAspect, logout). The interface will be one of the interfaces passed in the 'interfaces' argument. The 'avatarAspect' will implement that interface. The 'logout' object is a callable which will detach the mind from the avatar. It must be called when the user has conceptually disconnected from the service. Although in some cases this will not be in connectionLost (such as in a web-based session), it will always be at the end of a user's interactive session. zNo checker for %sz, )r r r �requestAvatarId� addCallbackr r r �failr �Failurer �UnhandledCredentials�join�mapr �qual)r � credentialsr r �i�ifacr r r �loginQ s$ # � � �����z Portal.loginN)r )r r r r r r r r+ r r r r r / s r N)r �zope.interfacer r � twisted.credr �twisted.internetr �twisted.internet.deferr �twisted.pythonr r r r r r r r �<module> s PK Mb�Z �>�� � ( cred/__pycache__/strcred.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlmZmZmZ ddlmZmZ ddl m Z ddl m Z G dd� de�Z G d d � d e�ZG d d � d e�ZG d d� de�ZG dd� de�ZdZdd� Zdd� Zdd� ZG dd� d�ZdS )z� Support for resolving command-line strings that represent different checkers available to cred. Examples: - passwd:/etc/passwd - memory:admin:asdf:user:lkj - unix � N)�Optional�Sequence�Type)� Attribute� Interface)� getPlugins)�usagec @ s8 e Zd ZdZed�Zed�Zed�Zed�Zdd� Z dS ) �ICheckerFactoryz� A factory for objects which provide L{twisted.cred.checkers.ICredentialsChecker}. It's implemented by twistd plugins creating checkers. z0A tag that identifies the authentication method.zmA detailed (potentially multi-line) description of precisely what functionality this CheckerFactory provides.z=A short (one-line) description of the argument string format.z@A list of credentials interfaces that this factory will support.c C s dS )z} Return an L{twisted.cred.checkers.ICredentialsChecker} provider using the supplied argument string. N� )� argstringr r �6/usr/lib/python3/dist-packages/twisted/cred/strcred.py�generateChecker2 s z ICheckerFactory.generateCheckerN) �__name__� __module__� __qualname__�__doc__r �authType�authHelp�argStringFormat�credentialInterfacesr r r r r r s ��� r c @ � e Zd ZdZdS )�StrcredExceptionz+ Base exception class for strcred. N�r r r r r r r r r 9 � r c @ r )�InvalidAuthTypezv Raised when a user provides an invalid identifier for the authentication plugin (known as the authType). Nr r r r r r ? r r c @ r )�InvalidAuthArgumentStringzl Raised by an authentication plugin when the argument string provided is formatted incorrectly. Nr r r r r r F r r c @ r )�UnsupportedInterfacesz� Raised when an application is given a checker to use that does not provide any of the application's supported credentials interfaces. Nr r r r r r M r r z<WARNING: This authType is not supported by this application.c C s t t�S )z= Find all objects that implement L{ICheckerFactory}. )r r r r r r �findCheckerFactoriesY s r c C s& t � D ] }|j| kr| S qt| ��)zJ Find the first checker factory that supports the given authType. )r r r )r �factoryr r r �findCheckerFactory` s �r c C s0 d| v r | � dd�\}}n| }d}t|��|�S )z� Returns an L{twisted.cred.checkers.ICredentialsChecker} based on the contents of a descriptive string. Similar to L{twisted.application.strports}. �:� � )�splitr r )� descriptionr r r r r � makeCheckerj s r% c @ sh e Zd ZU dZdZeeee e d< e j Z dd� Z dd� Zdd � Zd d � Zd d � Zdd� Zdd� ZdS )�AuthOptionMixinak Defines helper methods that can be added on to any L{usage.Options} subclass that needs authentication. This mixin implements three new options methods: The opt_auth method (--auth) will write two new values to the 'self' dictionary: C{credInterfaces} (a dict of lists) and C{credCheckers} (a list). The opt_help_auth method (--help-auth) will search for all available checker plugins and list them for the user; it will exit when finished. The opt_help_auth_type method (--help-auth-type) will display detailed help for a particular checker plugin. @cvar supportedInterfaces: An iterable object that returns credential interfaces which this application is able to support. @cvar authOutput: A writeable object to which this options class will send all help-related output. Default: L{sys.stdout} N�supportedInterfacesc C s | j du p || j v S )zR Returns whether a particular credentials interface is supported. N)r' )�self� interfacer r r �supportsInterface� s z!AuthOptionMixin.supportsInterfacec C s |j D ] }| �|�r dS qdS )z� Returns whether a checker factory will provide at least one of the credentials interfaces that we care about. TF)r r* �r( r r) r r r �supportsCheckerFactory� s �z&AuthOptionMixin.supportsCheckerFactoryc C s� g }| j du r |j}n|jD ] }| �|�r|�|� q|s"t|j��d| vr*i | d< d| vr2g | d< | d �|� |D ] }| d �|g ��|� q;dS )zM Supply a supplied credentials checker to the Options class. N�credInterfaces� credCheckers)r' r r* �appendr � setdefault)r( �checker� supportedr) r r r � addChecker� s" � �zAuthOptionMixin.addCheckerc C s� z | � t|�� W dS ty } z t�d|jd ��d}~w ty5 } z t�d|jd ��d}~w tyG } zt�d| ��d}~ww )zB Specify an authentication method for the server. z Auth plugin not supported: %sr Nz Auth plugin not recognized: %szUnexpected error: %s)r3 r% r r � UsageError�argsr � Exception)r( r$ �er r r �opt_auth� s ����zAuthOptionMixin.opt_authc c s2 � t � D ]}|jD ] }| �|�r|V nq qdS )z� Return a list of which authTypes will be displayed by --help-auth. This makes it a lot easier to test this module. N)r r r* r+ r r r � _checkerFactoriesForOptHelpAuth� s � ���z/AuthOptionMixin._checkerFactoriesForOptHelpAuthc C s� | j �d� | j �d� | j �d� d}| �� D ]}t|j�|kr&t|j�}qd| }| j �|d � | j �|d � | �� D ]}| j �||j|jf � q?| j �d� td��)z< Show all authentication methods available. z#Usage: --auth AuthType[:ArgString] z-For detailed help: --help-auth-type AuthType � r z %%-%is %%s )�AuthTypezArgString format)z========z================)� authOutput�writer9 �lenr r � SystemExit)r( � firstLengthr � formatStringr r r � opt_help_auth� s" � � z AuthOptionMixin.opt_help_authc C s� zt |�}W n ty t�d| ��w | j�d| � | j�d|j � | j�d� |j�� � � D ] }| j�d|� � � q3| j�d� | � |�sY| j�dt � | j�d� t d��)zA Show help for a particular authentication type. zInvalid auth type: %sz Usage: --auth %s[:ArgString] zArgString format: %s r: z %s r )r r r r4 r< r= r r �strip� splitlines�rstripr, �notSupportedWarningr? )r( r �cf�liner r r �opt_help_auth_type� s � z"AuthOptionMixin.opt_help_auth_type)r r r r r' r r r r �__annotations__�sys�stdoutr< r* r, r3 r8 r9 rB rI r r r r r& x s r& )r rK �typingr r r �zope.interfacer r �twisted.pluginr �twisted.pythonr r r6 r r r r rF r r r% r& r r r r �<module> s PK Mb�Z]��-' -' ) cred/__pycache__/checkers.cpython-310.pycnu �[��� o �bI+ � @ s� d Z ddlZddlmZmZmZ ddlmZmZ ddl m Z ddl m Z ddl mZ G dd � d e�Zd Zee�G d d � d ��Zee�G d d� d��Zee�G dd� d��ZeZdS )zf Basic credential checkers @var ANONYMOUS: An empty tuple used to represent the anonymous avatar ID. � N)� Attribute� Interface� implementer)� credentials�error)�defer)�Logger)�failurec @ s e Zd ZdZed�Zdd� ZdS )�ICredentialsCheckerzE An object that can check sub-interfaces of L{ICredentials}. zNA list of sub-interfaces of L{ICredentials} which specifies which I may check.c C s dS )a Validate credentials and produce an avatar ID. @param credentials: something which implements one of the interfaces in C{credentialInterfaces}. @return: a L{Deferred} which will fire with a L{bytes} that identifies an avatar, an empty tuple to specify an authenticated anonymous user (provided as L{twisted.cred.checkers.ANONYMOUS}) or fail with L{UnauthorizedLogin}. Alternatively, return the result itself. @see: L{twisted.cred.credentials} N� )r r r �7/usr/lib/python3/dist-packages/twisted/cred/checkers.py�requestAvatarId s z#ICredentialsChecker.requestAvatarIdN)�__name__� __module__� __qualname__�__doc__r �credentialInterfacesr r r r r r s � r r c @ s e Zd ZdZejfZdd� ZdS )�AllowAnonymousAccessz� A credentials checker that unconditionally grants anonymous access. @cvar credentialInterfaces: Tuple containing L{IAnonymous}. c C s t �t�S )z� Succeed with the L{ANONYMOUS} avatar ID. @return: L{Deferred} that fires with L{twisted.cred.checkers.ANONYMOUS} )r �succeed� ANONYMOUS��selfr r r r r G s z$AllowAnonymousAccess.requestAvatarIdN)r r r r r � IAnonymousr r r r r r r = s r c @ s< e Zd ZdZejejfZdd� Zdd� Z dd� Z dd � Z d S ) �'InMemoryUsernamePasswordDatabaseDontUsea9 An extremely simple credentials checker. This is only of use in one-off test programs or examples which don't want to focus too much on how credentials are verified. You really don't want to use this for anything else. It is, at best, a toy. If you need a simple credentials checker for a real application, see L{FilePasswordDB}. @cvar credentialInterfaces: Tuple of L{IUsernamePassword} and L{IUsernameHashedPassword}. @ivar users: Mapping of usernames to passwords. @type users: L{dict} mapping L{bytes} to L{bytes} c K s dd� |� � D �| _dS )a� Initialize the in-memory database. For example:: db = InMemoryUsernamePasswordDatabaseDontUse( user1=b'sesame', user2=b'hunter2', ) @param users: Usernames and passwords to seed the database with. Each username given as a keyword is encoded to L{bytes} as ASCII. Passwords must be given as L{bytes}. @type users: L{dict} of L{str} to L{bytes} c S s i | ] \}}|� d �|�qS )�ascii)�encode)�.0�x�yr r r � <dictcomp>x s zDInMemoryUsernamePasswordDatabaseDontUse.__init__.<locals>.<dictcomp>N)�items�users)r r! r r r �__init__h s z0InMemoryUsernamePasswordDatabaseDontUse.__init__c C s || j |< dS )z� Set a user's password. @param username: Name of the user. @type username: L{bytes} @param password: Password to associate with the username. @type password: L{bytes} N)r! )r �username�passwordr r r �addUserz s z/InMemoryUsernamePasswordDatabaseDontUse.addUserc C � |r|S t �t�� �S �N�r �Failurer �UnauthorizedLogin�r �matchedr# r r r �_cbPasswordMatch� � z8InMemoryUsernamePasswordDatabaseDontUse._cbPasswordMatchc C s< |j | jv rt�|j| j|j ��| j|j �S t�t� � �S r' ) r# r! r � maybeDeferred� checkPassword� addCallbackr- �failr r* r r r r r � s � �z7InMemoryUsernamePasswordDatabaseDontUse.requestAvatarIdN) r r r r r �IUsernamePassword�IUsernameHashedPasswordr r" r% r- r r r r r r P s � r c @ s` e Zd ZdZdZdZdZe� Z ddd �Z d d � Z d d � Z dd� Z dd� Z dd� ZdS )�FilePasswordDBaz A file-based, text-based username/password database. Records in the datafile for this class are delimited by a particular string. The username appears in a fixed field of the columns delimited by this string, as does the password. Both fields are specifiable. If the passwords are not stored plaintext, a hash function must be supplied to convert plaintext passwords to the form stored on disk and this CredentialsChecker will only be able to check L{IUsernamePassword} credentials. If the passwords are stored plaintext, L{IUsernameHashedPassword} credentials will be checkable as well. FNr � :� Tc C sT || _ || _|| _|| _|| _|| _|| _| jdu r#tjtj f| _ dS tjf| _ dS )a� @type filename: L{str} @param filename: The name of the file from which to read username and password information. @type delim: L{bytes} @param delim: The field delimiter used in the file. @type usernameField: L{int} @param usernameField: The index of the username after splitting a line on the delimiter. @type passwordField: L{int} @param passwordField: The index of the password after splitting a line on the delimiter. @type caseSensitive: L{bool} @param caseSensitive: If true, consider the case of the username when performing a lookup. Ignore it otherwise. @type hash: Three-argument callable or L{None} @param hash: A function used to transform the plaintext password received over the network to a format suitable for comparison against the version stored on disk. The arguments to the callable are the username, the network-supplied password, and the in-file version of the password. If the return value compares equal to the version stored on disk, the credentials are accepted. @type cache: L{bool} @param cache: If true, maintain an in-memory cache of the contents of the password file. On lookups, the mtime of the file will be checked, and the file will only be re-parsed if the mtime is newer than when the cache was generated. N) �filename�delim�ufield�pfield� caseSensitive�hash�cacher r3 r4 r )r r8 r9 � usernameField� passwordFieldr< r= r> r r r r" � s , �zFilePasswordDB.__init__c C s6 t t| ��}dD ]}z||= W q ty Y qw |S )N)� _credCache�_cacheTimestamp)�dict�vars�KeyError)r �d�kr r r � __getstate__� s �zFilePasswordDB.__getstate__c C r& r' r( r+ r r r r- � r. z FilePasswordDB._cbPasswordMatchc c s� � zUt | jd��D}|D ]7}|�� }|�| j�}| jt|�ks%| jt|�kr&q | jr5|| j || j fV q || j � � || j fV q W d � W dS 1 sOw Y W dS t yn } z | j j d|d� t � � �d}~ww )a Loads the credentials from the configured file. @return: An iterable of C{username, password} couples. @rtype: C{iterable} @raise UnauthorizedLogin: when failing to read the credentials from the file. �rbNz$Unable to load credentials db: {e!r})�e)�openr8 �rstrip�splitr9 r: �lenr; r< �lower�OSError�_logr r* )r �f�line�partsrJ r r r �_loadCredentials� s$ � �&� ��z FilePasswordDB._loadCredentialsc C s� | j s|�� }| jr/| jdu stj�| j�| jkr(tj�| j�| _t | � � �| _|| j| fS | � � D ]\}}||krA||f S q3t |��)a� Look up the credentials for a username. @param username: The username to look up. @type username: L{bytes} @returns: Two-tuple of the canonicalicalized username (i.e. lowercase if the database is not case sensitive) and the associated password value, both L{bytes}. @rtype: L{tuple} @raises KeyError: When lookup of the username fails. N) r< rO r> rA �os�path�getmtimer8 rB rC rU rE )r r# �u�pr r r �getUser s �zFilePasswordDB.getUserc C s� z | � |j�\}}W n ty t�t�� � Y S w t�|d �}| j rA|d ur:| � |j|j |�}||kr:t� |�S t�t�� �S t� |j |��| j|�S r' )r[ r# rE r r2 r r* r r3 r= r$ r r/ r0 r1 r- )r �crY rZ �up�hr r r r 1 s � �z FilePasswordDB.requestAvatarId)r6 r r7 TNF)r r r r r> rA rB r rQ r" rH r- rU r[ r r r r r r5 � s$ �@ r5 )r rV �zope.interfacer r r � twisted.credr r �twisted.internetr �twisted.loggerr �twisted.pythonr r r r r r5 � OnDiskUsernamePasswordDatabaser r r r �<module> s" $D 1PK Mb�Z�f� � & cred/__pycache__/error.cpython-310.pycnu �[��� o �b� � @ sZ d Z G dd� de�ZG dd� de�ZG dd� dee�ZG dd� de�ZG d d � d e�Zd S ) z Cred errors. c @ � e Zd ZdZdS )� Unauthorizedz Standard unauthorized error.N��__name__� __module__� __qualname__�__doc__� r r �4/usr/lib/python3/dist-packages/twisted/cred/error.pyr � r c @ r )� LoginFailedz> The user's request to log in failed for some reason. Nr r r r r r r r c @ r )�UnauthorizedLoginz&The user was not authorized to log in.Nr r r r r r r r c @ r )�UnhandledCredentialsa A type of credentials were passed in with no knowledge of how to check them. This is a server configuration error - it means that a protocol was connected to a Portal without a CredentialChecker that can check all of its potential authentication strategies. Nr r r r r r r r c @ r )� LoginDeniedz� The realm rejected this login for some reason. Examples of reasons this might be raised include an avatar logging in too frequently, a quota having been fully used, or the overall server load being too high. Nr r r r r r r r N)r � Exceptionr r r r r r r r r �<module> s PK Mb�Z�ݜ�= �= , cred/__pycache__/credentials.cpython-310.pycnu �[��� o �bC@ � @ s� d Z ddlZddlZddlZddlZddlZddlmZ ddlm Z ddl m Z m Z ddl mZ ddlmZmZmZ ddlmZmZ dd lmZ dd lmZ dd lmZ G d d � d e �Z G dd� de �Z G dd� de �Z G dd� de �Z G dd� de �Z e e e �G dd� d��Z!G dd� d�Z"e e �G dd� d��Z#e e �G d d � d ��Z$e e �G d d � d ��Z%e e �G d d!� d!��Z&G d"d#� d#e �Z'e e'�G d$d%� d%��Z(dS )&z� This module defines L{ICredentials}, an interface for objects that represent authentication credentials to provide, and also includes a number of useful implementations of that interface. � N)�hexlify)�md5)� Interface� implementer)�error)�calcHA1�calcHA2� calcResponse)� nativeString� networkString)�deprecatedModuleAttribute)� secureRandom)�Versionc @ � e Zd ZdZdS )� ICredentialsz� I check credentials. Implementors I{must} specify the sub-interfaces of ICredentials to which it conforms, using L{zope.interface.implementer}. N��__name__� __module__� __qualname__�__doc__� r r �:/usr/lib/python3/dist-packages/twisted/cred/credentials.pyr � r c @ � e Zd ZdZdd� ZdS )�IUsernameDigestHashz� This credential is used when a CredentialChecker has access to the hash of the username:realm:password as in an Apache .htdigest file. c C � dS )a- @param digestHash: The hashed username:realm:password to check against. @return: C{True} if the credentials represented by this object match the given hash, C{False} if they do not, or a L{Deferred} which will be called back with one of these values. Nr )� digestHashr r r � checkHash- � z IUsernameDigestHash.checkHashN)r r r r r r r r r r ' s r c @ r )�IUsernameHashedPassworda� I encapsulate a username and a hashed password. This credential is used when a hashed password is received from the party requesting authentication. CredentialCheckers which check this kind of credential must store the passwords in plaintext (or as password-equivalent hashes) form so that they can be hashed in a manner appropriate for the particular credentials class. @type username: L{bytes} @ivar username: The username associated with these credentials. c C r �a� Validate these credentials against the correct password. @type password: L{bytes} @param password: The correct, plaintext password against which to check. @rtype: C{bool} or L{Deferred} @return: C{True} if the credentials represented by this object match the given password, C{False} if they do not, or a L{Deferred} which will be called back with one of these values. Nr ��passwordr r r � checkPasswordE r z%IUsernameHashedPassword.checkPasswordN�r r r r r# r r r r r 7 s r c @ r )�IUsernamePasswordaK I encapsulate a username and a plaintext password. This encapsulates the case where the password received over the network has been hashed with the identity function (That is, not at all). The CredentialsChecker may store the password in whatever format it desires, it need only transform the stored password in a similar way before performing the comparison. @type username: L{bytes} @ivar username: The username associated with these credentials. @type password: L{bytes} @ivar password: The password associated with these credentials. c C r r r r! r r r r# e r z IUsernamePassword.checkPasswordNr$ r r r r r% T s r% c @ r )� IAnonymouszs I am an explicitly anonymous request for access. @see: L{twisted.cred.checkers.AllowAnonymousAccess} Nr r r r r r& t r r& c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �DigestedCredentialsz? Yet Another Simple HTTP Digest authentication scheme. c C s || _ || _|| _|| _d S �N)�username�method�realm�fields)�selfr) r* r+ r, r r r �__init__� s z DigestedCredentials.__init__c C s� | j �d�}| j �d�}| j �d�}| j �d�}| j �d�}| j �dd��� }| j �dd �}tt|| j| j|||�t|| j||d �|||||�} | |kS ) a Verify that the credentials represented by this object agree with the given plaintext C{password} by hashing C{password} in the same way the response hash represented by this object was generated and comparing the results. �response�uri�nonce�cnonce�nc� algorithm� md5�qop� authN) r, �get�lowerr r r) r+ r r* ) r- r" r/ r0 r1 r2 r3 �algor6 �expectedr r r r# � s" � z!DigestedCredentials.checkPasswordc C s� | j �d�}| j �d�}| j �d�}| j �d�}| j �d�}| j �dd��� }| j �dd �}tt|d d d |||d �t|| j||d �|||||�} | |kS ) a4 Verify that the credentials represented by this object agree with the credentials represented by the I{H(A1)} given in C{digestHash}. @param digestHash: A precomputed H(A1) value based on the username, realm, and password associate with this credentials object. r/ r0 r1 r2 r3 r4 r5 r6 r7 N)�preHA1)r, r8 r9 r r r r* ) r- r r/ r0 r1 r2 r3 r: r6 r; r r r r � s" � z DigestedCredentials.checkHashN)r r r r r. r# r r r r r r' | s r' c @ sZ e Zd ZdZe�d�ZdZdZdd� Z dd� Z d d � Z d d � Z d d� Z dd� Zdd� ZdS )�DigestCredentialFactoryar Support for RFC2617 HTTP Digest Authentication @cvar CHALLENGE_LIFETIME_SECS: The number of seconds for which an opaque should be valid. @type privateKey: L{bytes} @ivar privateKey: A random string used for generating the secure opaque. @type algorithm: L{bytes} @param algorithm: Case insensitive string specifying the hash algorithm to use. Must be either C{'md5'} or C{'sha'}. C{'md5-sess'} is B{not} supported. @type authenticationRealm: L{bytes} @param authenticationRealm: case sensitive string that specifies the realm portion of the challenge s ([^= ]+)=(?:"([^"]*)"|([^,]+)),?i� s digestc C s || _ || _td�| _d S )N� )r4 �authenticationRealmr � privateKey)r- r4 r? r r r r. � s z DigestCredentialFactory.__init__c C s( | � � }| �||�}||d| j| jd�S )a Generate the challenge for use in the WWW-Authenticate header. @param address: The client address to which this challenge is being sent. @return: The L{dict} that can be used to generate a WWW-Authenticate header. r7 )r1 �opaquer6 r4 r+ )�_generateNonce�_generateOpaquer4 r? )r- �address�c�or r r � getChallenge� s �z$DigestCredentialFactory.getChallengec C s t td��S )z� Create a random value suitable for use as the nonce parameter of a WWW-Authenticate challenge. @rtype: L{bytes} r> )r r �r- r r r rB � s z&DigestCredentialFactory._generateNoncec C s t � � S )z� Parameterize the time based seed used in C{_generateOpaque} so we can deterministically unittest it's behavior. )�timerH r r r �_getTime s z DigestCredentialFactory._getTimec C sv dt | �� �f }|sd}n t|t�r|�d�}d�|||f�}tt|| j �� � �}t � |�}d�||� dd�f�S )z� Generate an opaque to be returned to the client. This is a unique string that can be returned to us and verified. s %d� �ascii� ,� -� ) �intrJ � isinstance�str�encode�joinr r r@ �digest�base64� b64encode�replace)r- r1 �clientip�now�keyrU �ekeyr r r rC s z'DigestCredentialFactory._generateOpaquec C s |� d�}t|�dkrt�d��|sd}n t|t�r |�d�}t�|d �}|� d�}t|�dkr6t�d��|d |krAt�d ��|d |krLt�d ��zt |d �}W n t y` t�d ��w t | � � �| t j krqt�d ��tt|| j ��� �}||d kr�t�d��dS )a� Given the opaque and nonce from the request, as well as the client IP that made the request, verify that the opaque was generated by us. And that it's not too old. @param opaque: The opaque value from the Digest response @param nonce: The nonce value from the Digest response @param clientip: The remote IP address of the client making the request or L{None} if the request was submitted over a channel where this does not make sense. @return: C{True} if the opaque was successfully verified. @raise error.LoginFailed: if C{opaque} could not be parsed or contained the wrong values. rN � z&Invalid response, invalid opaque valuerK rL � rM � r z2Invalid response, incompatible opaque/nonce valuesz3Invalid response, incompatible opaque/client valuesz,Invalid response, invalid opaque/time valuesz3Invalid response, incompatible opaque/nonce too oldT)�split�lenr � LoginFailedrQ rR rS rV � b64decoderP � ValueErrorrJ r= �CHALLENGE_LIFETIME_SECSr r r@ rU ) r- rA r1 rY � opaquePartsr[ �keyParts�whenrU r r r � _verifyOpaque sD � � ��� z%DigestCredentialFactory._verifyOpaquec C s� d� |�� �}| j�|�}i }|D ]\}}}|p|�� } | |t|�� �< q|�d�} | s1t�d��d|vr:t�d��d|vrCt�d��| � |�d�|�d�|�rXt | || j |�S dS ) a� Decode the given response and attempt to generate a L{DigestedCredentials} from it. @type response: L{bytes} @param response: A string of comma separated key=value pairs @type method: L{bytes} @param method: The action requested to which this response is addressed (GET, POST, INVITE, OPTIONS, etc). @type host: L{bytes} @param host: The address the request was sent from. @raise error.LoginFailed: If the response does not contain a username, a nonce, an opaque, or if the opaque is invalid. @return: L{DigestedCredentials} � r) z$Invalid response, no username given.rA z"Invalid response, no opaque given.r1 z!Invalid response, no nonce given.N) rT � splitlines� _parseparts�findall�stripr r8 r rb ri r' r? ) r- r/ r* �host�parts�authr[ �bare�quoted�valuer) r r r �decodea s �z DigestCredentialFactory.decodeN)r r r r �re�compilerl re �schemer. rG rB rJ rC ri ru r r r r r= � s � Ar= c @ sF e Zd ZdZdZdZdZddd�Zdd� Zdd � Z d d � Z d d � Z dS )�CramMD5Credentialsas An encapsulation of some CramMD5 hashed credentials. @ivar challenge: The challenge to be sent to the client. @type challenge: L{bytes} @ivar response: The hashed response from the client. @type response: L{bytes} @ivar username: The username from the response from the client. @type username: L{bytes} or L{None} if not yet provided. NrK c C s || _ d S r( )ro )r- ro r r r r. � � zCramMD5Credentials.__init__c C sH | j r| j S t�d�}t�� }td||| jrt| j�nd f �| _ | j S )Ni���z <%d.%d@%s>)� challenge�random� randrangerI r ro r )r- �r�tr r r rG � s �z CramMD5Credentials.getChallengec C s |� d d�\| _| _d S )Nr^ )r` r) r/ )r- r/ r r r � setResponse� s z CramMD5Credentials.setResponsec C r )NFr rH r r r �moreChallenges� s z!CramMD5Credentials.moreChallengesc C s$ t tj|| jtd��� �}|| jkS )N)� digestmod)r �hmac�HMACr{ r rU r/ )r- r" �verifyr r r r# � s z CramMD5Credentials.checkPasswordr( ) r r r r r) r{ r/ r. rG r� r� r# r r r r ry � s ry c @ s4 e Zd Zeedddd�ddd � dd� Zd d � Zd S ) �UsernameHashedPassword�Twisted� r] r z6Use twisted.cred.credentials.UsernamePassword instead.ztwisted.cred.credentialsc C � || _ || _d S r( )r) �hashed)r- r) r� r r r r. � � z UsernameHashedPassword.__init__c C � | j |kS r( )r� �r- r" r r r r# � rz z$UsernameHashedPassword.checkPasswordN)r r r r r r. r# r r r r r� � s � r� c @ s e Zd Zdd� Zdd� ZdS )�UsernamePasswordc C r� r( )r) r" )r- r) r" r r r r. � r� zUsernamePassword.__init__c C r� r( r! r� r r r r# � rz z UsernamePassword.checkPasswordN)r r r r. r# r r r r r� � s r� c @ s e Zd ZdS )� AnonymousN)r r r r r r r r� � s r� c @ r )�ISSHPrivateKeyaj L{ISSHPrivateKey} credentials encapsulate an SSH public key to be checked against a user's private key. @ivar username: The username associated with these credentials. @type username: L{bytes} @ivar algName: The algorithm name for the blob. @type algName: L{bytes} @ivar blob: The public key blob as sent by the client. @type blob: L{bytes} @ivar sigData: The data the signature was made from. @type sigData: L{bytes} @ivar signature: The signed data. This is checked to verify that the user owns the private key. @type signature: L{bytes} or L{None} Nr r r r r r� � r r� c @ s e Zd Zdd� ZdS )� SSHPrivateKeyc C s" || _ || _|| _|| _|| _d S r( )r) �algName�blob�sigData� signature)r- r) r� r� r� r� r r r r. � s zSSHPrivateKey.__init__N)r r r r. r r r r r� � s r� ))r rV r� r| rv rI �binasciir �hashlibr �zope.interfacer r � twisted.credr �twisted.cred._digestr r r �twisted.python.compatr r �twisted.python.deprecater �twisted.python.randbytesr �twisted.python.versionsr r r r r% r& r' r= ry r� r� r� r� r� r r r r �<module> sF C L0 PK Mb�Zа1� � ( cred/__pycache__/_digest.cpython-310.pycnu �[��� o �b� � @ sL d Z ddlmZ ddlmZmZ eeed�Z d dd�Zdd � Zd d � Z dS ) z^ Calculations for HTTP Digest authentication. @see: U{http://www.faqs.org/rfcs/rfc2617.html} � )�hexlify)�md5�sha1)s md5� md5-sesss shaNc C s� |r |s|s|r t d��|du r5t| � }|�|� |�d� |�|� |�d� |�|� t|�� �}n|}| dkr_t| � }|�|� |�d� |�|� |�d� |�|� t|�� �}|S )a: Compute H(A1) from RFC 2617. @param pszAlg: The name of the algorithm to use to calculate the digest. Currently supported are md5, md5-sess, and sha. @param pszUserName: The username @param pszRealm: The realm @param pszPassword: The password @param pszNonce: The nonce @param pszCNonce: The cnonce @param preHA1: If available this is a str containing a previously calculated H(A1) as a hex string. If this is given then the values for pszUserName, pszRealm, and pszPassword must be L{None} and are ignored. zPpreHA1 is incompatible with the pszUserName, pszRealm, and pszPassword argumentsN� :r )� TypeError� algorithms�updater �digest) �pszAlg� pszUserName�pszRealm� pszPassword�pszNonce� pszCNonce�preHA1�m�HA1� r �6/usr/lib/python3/dist-packages/twisted/cred/_digest.py�calcHA1! s, � r c C sP t | � }|�|� |�d� |�|� |dkr"|�d� |�|� t|�� �S )a� Compute H(A2) from RFC 2617. @param algo: The name of the algorithm to use to calculate the digest. Currently supported are md5, md5-sess, and sha. @param pszMethod: The request method. @param pszDigestUri: The request URI. @param pszQop: The Quality-of-Protection value. @param pszHEntity: The hash of the entity body or L{None} if C{pszQop} is not C{'auth-int'}. @return: The hash of the A2 value for the calculation of the response digest. r s auth-int�r r r r )�algo� pszMethod� pszDigestUri�pszQop� pszHEntityr r r r �calcHA2S s r c C s� t | � }|�| � |�d� |�|� |�d� |r;|r;|�|� |�d� |�|� |�d� |�|� |�d� |�|� t|�� �}|S )a� Compute the digest for the given parameters. @param HA1: The H(A1) value, as computed by L{calcHA1}. @param HA2: The H(A2) value, as computed by L{calcHA2}. @param pszNonce: The challenge nonce. @param pszNonceCount: The (client) nonce count value for this response. @param pszCNonce: The client nonce. @param pszQop: The Quality-of-Protection value. r r ) r �HA2r r � pszNonceCountr r r �respHashr r r � calcResponsek s r! )N) �__doc__�binasciir �hashlibr r r r r r! r r r r �<module> s � �2 PK Mb�ZE ͒ � cred/strcred.pynu �[��� # -*- test-case-name: twisted.cred.test.test_strcred -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # """ Support for resolving command-line strings that represent different checkers available to cred. Examples: - passwd:/etc/passwd - memory:admin:asdf:user:lkj - unix """ import sys from typing import Optional, Sequence, Type from zope.interface import Attribute, Interface from twisted.plugin import getPlugins from twisted.python import usage class ICheckerFactory(Interface): """ A factory for objects which provide L{twisted.cred.checkers.ICredentialsChecker}. It's implemented by twistd plugins creating checkers. """ authType = Attribute("A tag that identifies the authentication method.") authHelp = Attribute( "A detailed (potentially multi-line) description of precisely " "what functionality this CheckerFactory provides." ) argStringFormat = Attribute( "A short (one-line) description of the argument string format." ) credentialInterfaces = Attribute( "A list of credentials interfaces that this factory will support." ) def generateChecker(argstring): """ Return an L{twisted.cred.checkers.ICredentialsChecker} provider using the supplied argument string. """ class StrcredException(Exception): """ Base exception class for strcred. """ class InvalidAuthType(StrcredException): """ Raised when a user provides an invalid identifier for the authentication plugin (known as the authType). """ class InvalidAuthArgumentString(StrcredException): """ Raised by an authentication plugin when the argument string provided is formatted incorrectly. """ class UnsupportedInterfaces(StrcredException): """ Raised when an application is given a checker to use that does not provide any of the application's supported credentials interfaces. """ # This will be used to warn the users whenever they view help for an # authType that is not supported by the application. notSupportedWarning = "WARNING: This authType is not supported by " "this application." def findCheckerFactories(): """ Find all objects that implement L{ICheckerFactory}. """ return getPlugins(ICheckerFactory) def findCheckerFactory(authType): """ Find the first checker factory that supports the given authType. """ for factory in findCheckerFactories(): if factory.authType == authType: return factory raise InvalidAuthType(authType) def makeChecker(description): """ Returns an L{twisted.cred.checkers.ICredentialsChecker} based on the contents of a descriptive string. Similar to L{twisted.application.strports}. """ if ":" in description: authType, argstring = description.split(":", 1) else: authType = description argstring = "" return findCheckerFactory(authType).generateChecker(argstring) class AuthOptionMixin: """ Defines helper methods that can be added on to any L{usage.Options} subclass that needs authentication. This mixin implements three new options methods: The opt_auth method (--auth) will write two new values to the 'self' dictionary: C{credInterfaces} (a dict of lists) and C{credCheckers} (a list). The opt_help_auth method (--help-auth) will search for all available checker plugins and list them for the user; it will exit when finished. The opt_help_auth_type method (--help-auth-type) will display detailed help for a particular checker plugin. @cvar supportedInterfaces: An iterable object that returns credential interfaces which this application is able to support. @cvar authOutput: A writeable object to which this options class will send all help-related output. Default: L{sys.stdout} """ supportedInterfaces: Optional[Sequence[Type[Interface]]] = None authOutput = sys.stdout def supportsInterface(self, interface): """ Returns whether a particular credentials interface is supported. """ return self.supportedInterfaces is None or interface in self.supportedInterfaces def supportsCheckerFactory(self, factory): """ Returns whether a checker factory will provide at least one of the credentials interfaces that we care about. """ for interface in factory.credentialInterfaces: if self.supportsInterface(interface): return True return False def addChecker(self, checker): """ Supply a supplied credentials checker to the Options class. """ # First figure out which interfaces we're willing to support. supported = [] if self.supportedInterfaces is None: supported = checker.credentialInterfaces else: for interface in checker.credentialInterfaces: if self.supportsInterface(interface): supported.append(interface) if not supported: raise UnsupportedInterfaces(checker.credentialInterfaces) # If we get this far, then we know we can use this checker. if "credInterfaces" not in self: self["credInterfaces"] = {} if "credCheckers" not in self: self["credCheckers"] = [] self["credCheckers"].append(checker) for interface in supported: self["credInterfaces"].setdefault(interface, []).append(checker) def opt_auth(self, description): """ Specify an authentication method for the server. """ try: self.addChecker(makeChecker(description)) except UnsupportedInterfaces as e: raise usage.UsageError("Auth plugin not supported: %s" % e.args[0]) except InvalidAuthType as e: raise usage.UsageError("Auth plugin not recognized: %s" % e.args[0]) except Exception as e: raise usage.UsageError("Unexpected error: %s" % e) def _checkerFactoriesForOptHelpAuth(self): """ Return a list of which authTypes will be displayed by --help-auth. This makes it a lot easier to test this module. """ for factory in findCheckerFactories(): for interface in factory.credentialInterfaces: if self.supportsInterface(interface): yield factory break def opt_help_auth(self): """ Show all authentication methods available. """ self.authOutput.write("Usage: --auth AuthType[:ArgString]\n") self.authOutput.write("For detailed help: --help-auth-type AuthType\n") self.authOutput.write("\n") # Figure out the right width for our columns firstLength = 0 for factory in self._checkerFactoriesForOptHelpAuth(): if len(factory.authType) > firstLength: firstLength = len(factory.authType) formatString = " %%-%is\t%%s\n" % firstLength self.authOutput.write(formatString % ("AuthType", "ArgString format")) self.authOutput.write(formatString % ("========", "================")) for factory in self._checkerFactoriesForOptHelpAuth(): self.authOutput.write( formatString % (factory.authType, factory.argStringFormat) ) self.authOutput.write("\n") raise SystemExit(0) def opt_help_auth_type(self, authType): """ Show help for a particular authentication type. """ try: cf = findCheckerFactory(authType) except InvalidAuthType: raise usage.UsageError("Invalid auth type: %s" % authType) self.authOutput.write("Usage: --auth %s[:ArgString]\n" % authType) self.authOutput.write("ArgString format: %s\n" % cf.argStringFormat) self.authOutput.write("\n") for line in cf.authHelp.strip().splitlines(): self.authOutput.write(" %s\n" % line.rstrip()) self.authOutput.write("\n") if not self.supportsCheckerFactory(cf): self.authOutput.write(" %s\n" % notSupportedWarning) self.authOutput.write("\n") raise SystemExit(0) PK Mb�ZCP�Y� � cred/test/test_simpleauth.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for basic constructs of L{twisted.cred.credentials}. """ from twisted.cred.credentials import ( IUsernameHashedPassword, IUsernamePassword, UsernamePassword, ) from twisted.cred.test.test_cred import _uhpVersion from twisted.trial.unittest import TestCase class UsernamePasswordTests(TestCase): """ Tests for L{UsernamePassword}. """ def test_initialisation(self): """ The initialisation of L{UsernamePassword} will set C{username} and C{password} on it. """ creds = UsernamePassword(b"foo", b"bar") self.assertEqual(creds.username, b"foo") self.assertEqual(creds.password, b"bar") def test_correctPassword(self): """ Calling C{checkPassword} on a L{UsernamePassword} will return L{True} when the password given is the password on the object. """ creds = UsernamePassword(b"user", b"pass") self.assertTrue(creds.checkPassword(b"pass")) def test_wrongPassword(self): """ Calling C{checkPassword} on a L{UsernamePassword} will return L{False} when the password given is NOT the password on the object. """ creds = UsernamePassword(b"user", b"pass") self.assertFalse(creds.checkPassword(b"someotherpass")) def test_interface(self): """ L{UsernamePassword} implements L{IUsernamePassword}. """ self.assertTrue(IUsernamePassword.implementedBy(UsernamePassword)) class UsernameHashedPasswordTests(TestCase): """ Tests for L{UsernameHashedPassword}. """ def test_initialisation(self): """ The initialisation of L{UsernameHashedPassword} will set C{username} and C{hashed} on it. """ UsernameHashedPassword = self.getDeprecatedModuleAttribute( "twisted.cred.credentials", "UsernameHashedPassword", _uhpVersion ) creds = UsernameHashedPassword(b"foo", b"bar") self.assertEqual(creds.username, b"foo") self.assertEqual(creds.hashed, b"bar") def test_correctPassword(self): """ Calling C{checkPassword} on a L{UsernameHashedPassword} will return L{True} when the password given is the password on the object. """ UsernameHashedPassword = self.getDeprecatedModuleAttribute( "twisted.cred.credentials", "UsernameHashedPassword", _uhpVersion ) creds = UsernameHashedPassword(b"user", b"pass") self.assertTrue(creds.checkPassword(b"pass")) def test_wrongPassword(self): """ Calling C{checkPassword} on a L{UsernameHashedPassword} will return L{False} when the password given is NOT the password on the object. """ UsernameHashedPassword = self.getDeprecatedModuleAttribute( "twisted.cred.credentials", "UsernameHashedPassword", _uhpVersion ) creds = UsernameHashedPassword(b"user", b"pass") self.assertFalse(creds.checkPassword(b"someotherpass")) def test_interface(self): """ L{UsernameHashedPassword} implements L{IUsernameHashedPassword}. """ UsernameHashedPassword = self.getDeprecatedModuleAttribute( "twisted.cred.credentials", "UsernameHashedPassword", _uhpVersion ) self.assertTrue(IUsernameHashedPassword.implementedBy(UsernameHashedPassword)) PK Mb�Z8�`�� � . cred/test/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z! Unit tests for C{twisted.cred}. N)�__doc__� r r �</usr/lib/python3/dist-packages/twisted/cred/test/__init__.py�<module> s PK Mb�Z;�} } 3 cred/test/__pycache__/test_cramauth.cpython-310.pycnu �[��� o �b� � @ sT d Z ddlZddlmZ ddlmZ ddlmZmZ ddl m Z G dd� de �Z dS ) z9 Tests for L{twisted.cred}'s implementation of CRAM-MD5. � N)�hexlify)�HMAC)�CramMD5Credentials�IUsernameHashedPassword)�TestCasec @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�CramMD5CredentialsTestsz* Tests for L{CramMD5Credentials}. c C s" t � }|�� }| �||�� � dS )z� The same L{CramMD5Credentials} will always provide the same challenge, no matter how many times it is called. N)r � getChallenge� assertEqual��self�c�chal� r �A/usr/lib/python3/dist-packages/twisted/cred/test/test_cramauth.py�test_idempotentChallenge s z0CramMD5CredentialsTests.test_idempotentChallengec C s< t � }|�� }ttd|tjd��� �|_| �|� d�� dS )a2 When a valid response (which is a hex digest of the challenge that has been encrypted by the user's shared secret) is set on the L{CramMD5Credentials} that created the challenge, and C{checkPassword} is called with the user's shared secret, it will return L{True}. � secret�� digestmodN) r r r r �hashlib�md5�digest�response� assertTrue� checkPasswordr r r r �test_checkPassword s z*CramMD5CredentialsTests.test_checkPasswordc C s t � }| �|�d�� dS )zg When there is no response set, calling C{checkPassword} will return L{False}. r N)r � assertFalser )r r r r r �test_noResponse+ s z'CramMD5CredentialsTests.test_noResponsec C s< t � }|�� }ttd|tjd��� �|_| �|� d�� dS )a When an invalid response is set on the L{CramMD5Credentials} (one that is not the hex digest of the challenge, encrypted with the user's shared secret) and C{checkPassword} is called with the user's correct shared secret, it will return L{False}. s thewrongsecretr r N) r r r r r r r r r r r r r r �test_wrongPassword3 s �z*CramMD5CredentialsTests.test_wrongPasswordc C sX t � }|�� }|�d�dttd|tjd��� �f�� | � |� d�� | � |j d� dS )z� When C{setResponse} is called with a string that is the username and the hashed challenge separated with a space, they will be set on the L{CramMD5Credentials}. � s squirrels supersecretr N) r r � setResponse�joinr r r r r r r r �usernamer r r r �test_setResponseA s ���z(CramMD5CredentialsTests.test_setResponsec C s | � t�t�� dS )zd L{CramMD5Credentials} implements the L{IUsernameHashedPassword} interface. N)r r � implementedByr )r r r r �test_interfaceT s z&CramMD5CredentialsTests.test_interfaceN) �__name__� __module__� __qualname__�__doc__r r r r r" r$ r r r r r s r ) r( r �binasciir �hmacr �twisted.cred.credentialsr r �twisted.trial.unittestr r r r r r �<module> s PK Mb�Zy�^��G �G / cred/test/__pycache__/test_cred.cpython-310.pycnu �[��� o �b9 � @ s� d Z ddlmZmZ ddlmZmZ ddlmZm Z m Z m Z ddl m Z ddlmZ ddlmZ ddlmZ zdd lmZ W n eyI d ZY nw eZed d d d�ZG dd� de�ZG dd� d�Zee�G dd� dej��Ze� eee� G dd� de j �Z ee e�G dd� d��Z ee j �G dd� d��Z!G dd� dej"�Z#G d d � d ej"�Z$G d d � d ej"�Z%G d d!� d!�Z&G d"d#� d#�Z'G d$d%� d%e'�Z(G d&d'� d'e'�Z)G d(d)� d)e'e&ej"�Z*G d*d+� d+e(e&ej"�Z+G d,d-� d-e)e&ej"�Z,G d.d/� d/ej"�Z-d S )0z6 Tests for L{twisted.cred}, now with 30% more starch. � )�hexlify� unhexlify)� Interface� implementer)�checkers� credentials�error�portal)�defer)� components)�Version)�unittest)�cryptN�Twisted� � c @ � e Zd ZdZdS )� ITestablez2 An interface for a theoretical protocol. N��__name__� __module__� __qualname__�__doc__� r r �=/usr/lib/python3/dist-packages/twisted/cred/test/test_cred.pyr s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � TestAvatarz A test avatar. c C s || _ d| _d| _d S )NF)�name�loggedIn� loggedOut)�selfr r r r �__init__, s zTestAvatar.__init__c C s | j rJ �d| _ d S �NT)r �r r r r �login1 s zTestAvatar.loginc C s d| _ d S r! )r r" r r r �logout5 � zTestAvatar.logoutN)r r r r r r# r$ r r r r r ' s r c @ r )�Testablez- A theoretical protocol for testing. Nr r r r r r& 9 s r& c @ � e Zd ZdS )�IDerivedCredentialsN�r r r r r r r r( E s r( c @ s e Zd Zdd� Zdd� ZdS )�DerivedCredentialsc C s || _ || _d S �N)�username�password)r r, r- r r r r K s zDerivedCredentials.__init__c C s || j kS r+ )r- �r r- r r r � checkPasswordO r% z DerivedCredentials.checkPasswordN)r r r r r/ r r r r r* I s r* c @ s e Zd ZdZdd� Zdd� ZdS )� TestRealmz A basic test realm. c C s i | _ d S r+ )�avatarsr" r r r r Y r% zTestRealm.__init__c G sH || j v r | j | }n t|�}|| j |< |�� |d |d |�|jfS )Nr )r1 r r# r$ )r �avatarId�mind� interfaces�avatarr r r � requestAvatar\ s zTestRealm.requestAvatarN)r r r r r r6 r r r r r0 S s r0 c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� CredTestsz^ Tests for the meat of L{twisted.cred} -- realms, portals, avatars, and checkers. c C s@ t � | _t�| j�| _t�� | _| j�dd� | j�| j� d S )N� bob� hello) r0 �realmr �Portalr �'InMemoryUsernamePasswordDatabaseDontUse�checker�addUser�registerCheckerr" r r r �setUpl s zCredTests.setUpc C s. t jt jg}| j�� }| �t|�t|�� dS )z� The checkers in a portal can check only certain types of credentials. Since this portal has L{checkers.InMemoryUsernamePasswordDatabaseDontUse} registered, it N)r �IUsernamePassword�IUsernameHashedPasswordr �listCredentialsInterfaces� assertEqual�sorted)r �expected�gotr r r �test_listCheckerss s zCredTests.test_listCheckersc C s� | � | j�t�dd�| t��}|\}}}| �|t� | �|�|�|� d|� �� | �|j j � | �|j j � |� | �|j j � dS )z� Calling C{login} on a portal with correct credentials and an interface that the portal's realm supports works. r8 r9 � does not implement N) �successResultOfr r# r �UsernamePasswordr rD � assertTrue� providedBy�originalr r �r r# �iface�implr$ r r r �test_basicLogin} s �� zCredTests.test_basicLoginc C s� | � | j�tdd�| t��}|\}}}| �|t� | �|�|�|� d|� �� | �|jj � | �|jj � |� | �|jj � dS )z~ Logging in with correct derived credentials and an interface that the portal's realm supports works. r8 r9 rI N) rJ r r# r* r rD rL rM rN r r rO r r r �test_derivedInterface� s � z CredTests.test_derivedInterfacec C �< | � | j�t�dd�| t��}| �|� | �tj |j � dS )z� Calling C{login} with incorrect credentials (in this case a wrong password) causes L{error.UnauthorizedLogin} to be raised. r8 s h3lloN� �failureResultOfr r# r rK r rL rD r �UnauthorizedLogin�type�r r# r r r �test_failedLoginPassword� � �� z"CredTests.test_failedLoginPasswordc C rT )z� Calling C{login} with incorrect credentials (in this case no known user) causes L{error.UnauthorizedLogin} to be raised. s jayr9 NrU rY r r r �test_failedLoginName� r[ z CredTests.test_failedLoginNameN) r r r r r@ rH rR rS rZ r\ r r r r r7 f s r7 c @ sD e Zd Zg d�Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�OnDiskDatabaseTests�)� user1s pass1)� user2s pass2)� user3s pass3c C sb | � � | _t| jd�� }| jD ]\}}|�|d | d � qW d � d S 1 s*w Y d S )N�wb� :� )�mktemp�dbfile�open�users�write)r �f�u�pr r r r@ � s �"�zOnDiskDatabaseTests.setUpc C s$ t �d�| _| �tj| jjd� dS )zg A missing db file will cause a permanent rejection of authorization attempts. z test_thisbetternoteverexist.db�userN)r �FilePasswordDB�db� assertRaisesr rW �getUserr" r r r � test_getUserNonexistentDatabase� s z3OnDiskDatabaseTests.test_getUserNonexistentDatabasec C sP t �| j�| _| jD ]\}}| �t| jj|�� � | � | j�|�||f� q d S r+ ) r rn rf ro rh rp �KeyErrorrq �upperrD �r rk rl r r r �testUserLookup� s �z"OnDiskDatabaseTests.testUserLookupc C sB t j| jdd�| _| jD ]\}}| �| j�|�� �||f� q d S )NF)� caseSensitive)r rn rf ro rh rD rq rt ru r r r �testCaseInSensitivity� s �z)OnDiskDatabaseTests.testCaseInSensitivityc sT t �� j�� _dd� � jD �}t�� fdd�|D ��}|�� jdd� � jD �� |S )Nc S � g | ] \}}t �||��qS r �r rK ��.0rk rl r r r � <listcomp>� � z;OnDiskDatabaseTests.testRequestAvatarId.<locals>.<listcomp>c � g | ] }t �� jj|��qS r �r � maybeDeferredro �requestAvatarId�r| �cr" r r r} � r~ c S � g | ]\}}|�qS r r r{ r r r r} � � ) r rn rf ro rh r � gatherResults� addCallbackrD �r �creds�dr r" r �testRequestAvatarId� s �z'OnDiskDatabaseTests.testRequestAvatarIdc sf t ��j��_��ddt�� � fdd��jD �}t��fdd�|D ��}|� �j dd� �jD �� |S )N�twisted.cred.credentials�UsernameHashedPasswordc s g | ] \}}� ||��qS r r r{ )r� r r r} � � zBOnDiskDatabaseTests.testRequestAvatarId_hashed.<locals>.<listcomp>c r r r� r� r" r r r} � r~ c S r� r r r{ r r r r} � r� ) r rn rf ro � getDeprecatedModuleAttribute� _uhpVersionrh r r� r� rD r� r �r� r r �testRequestAvatarId_hashed� s ��z.OnDiskDatabaseTests.testRequestAvatarId_hashedN) r r r rh r@ rr rv rx r� r� r r r r r] � s r] c @ sn e Zd Zg d�Zdd� Zdedededefdd �Zd d � Zd d � Zdd� Z dd� Z dd� Z e du r5dZ dS dS )�!HashedPasswordOnDiskDatabaseTestsr^ c C s� | � � }tj|| jd�| _t|d��$}| jD ]\}}|�|d | �|||d d� � d � qW d � n1 s9w Y t� }t � |�| _ | j � | j� d S )N��hashrb rc r rd ) re r rn r� ro rg rh ri r0 r r; �portr? )r rf rj rk rl �rr r r r@ s *� � z'HashedPasswordOnDiskDatabaseTests.setUprk rl �s�returnc C s. t |�d�|�d��}t|t�r|S |�d�S )N�ascii)r �decode� isinstance�bytes�encode)r rk rl r� �hashed_passwordr r r r� s z&HashedPasswordOnDiskDatabaseTests.hashc sF dd� � j D �}t�� fdd�|D ��}|�� jdd� � j D �� |S )Nc S ry r rz r{ r r r r} r~ zIHashedPasswordOnDiskDatabaseTests.testGoodCredentials.<locals>.<listcomp>c s g | ]}� j �|��qS r )ro r� r� r" r r r} s c S r� r r r{ r r r r} r� �rh r r� r� rD �r � goodCredsr� r r" r �testGoodCredentials s z5HashedPasswordOnDiskDatabaseTests.testGoodCredentialsc sT dd� � j D �}t�� fdd�|D ��}|�dd� � |�� jdd� � j D �� |S )Nc S ry r rz r{ r r r r} r~ zOHashedPasswordOnDiskDatabaseTests.testGoodCredentials_login.<locals>.<listcomp>c � g | ] }� j �|d t��qS r+ �r� r# r r� r" r r r} r~ c S s dd� | D �S )Nc S s g | ] \}}}|j j�qS r )rN r )r| �i�a�lr r r r} r� zaHashedPasswordOnDiskDatabaseTests.testGoodCredentials_login.<locals>.<lambda>.<locals>.<listcomp>r ��xr r r �<lambda> s zMHashedPasswordOnDiskDatabaseTests.testGoodCredentials_login.<locals>.<lambda>c S r� r r r{ r r r r} r� r� r� r r" r �testGoodCredentials_login s �z;HashedPasswordOnDiskDatabaseTests.testGoodCredentials_loginc s@ dd� � j D �}tj� fdd�|D �dd�}|�� jtj� |S )Nc S s g | ] \}}t �|d ��qS )s wrong passwordrz r{ r r r r} $ s �zHHashedPasswordOnDiskDatabaseTests.testBadCredentials.<locals>.<listcomp>c r� r+ r� r� r" r r r} ( r~ T�� consumeErrors)rh r � DeferredListr� �_assertFailuresr rW )r �badCredsr� r r" r �testBadCredentials# s ��z4HashedPasswordOnDiskDatabaseTests.testBadCredentialsc sT �� ddt�� � �fdd��jD �}tj�fdd�|D �dd�}|��jtj� |S )Nr� r� c s, g | ]\}}� |�� d ||d d� ���qS )Nr r� r{ r� r r r} 1 s �zKHashedPasswordOnDiskDatabaseTests.testHashedCredentials.<locals>.<listcomp>c r� r+ r� r� r" r r r} 5 r~ Tr� ) r� r� rh r r� r� r� r �UnhandledCredentials)r � hashedCredsr� r r� r �testHashedCredentials- s � ��z7HashedPasswordOnDiskDatabaseTests.testHashedCredentialsc G s* |D ]\}}| � |tj� |j|� qd S r+ )rD r �FAILURE�trap)r �failures�expectedFailures�flag�failurer r r r� ; s z1HashedPasswordOnDiskDatabaseTests._assertFailuresNzcrypt module not available)r r r rh r@ r� r� r� r� r� r� r� r �skipr r r r r� � s �r� c @ s, e Zd ZdZejdd� �Zejdd� �ZdS )� CheckersMixina� L{unittest.TestCase} mixin for testing that some checkers accept and deny specified credentials. Subclasses must provide - C{getCheckers} which returns a sequence of L{checkers.ICredentialChecker} - C{getGoodCredentials} which returns a list of 2-tuples of credential to check and avaterId to expect. - C{getBadCredentials} which returns a list of credentials which are expected to be unauthorized. c c s> � | � � D ]}| �� D ]\}}|�|�V }| �||� q qdS )zt The given credentials are accepted by all the checkers, and give the expected C{avatarID}s N)� getCheckers�getGoodCredentialsr� rD )r �chk�credr2 r� r r r � test_positiveS s � ��zCheckersMixin.test_positivec c s< � | � � D ]}| �� D ]}|�|�}| �|tj�V q qdS )zI The given credentials are rejected by all the checkers. N)r� �getBadCredentialsr� � assertFailurer rW )r r� r� r� r r r � test_negative^ s � ��zCheckersMixin.test_negativeN)r r r r r �inlineCallbacksr� r� r r r r r� E s r� c @ sL e Zd ZejZdZededefdd��Z g d�Z dd� Z d d � Z d d � Z dS ) �HashlessFilePasswordDBMixinNr� r� c C � | S r+ r r� r r r � networkHashm s z'HashlessFilePasswordDBMixin.networkHash))r_ � password1)r` s password2)ra � password3c c s. � | j D ]\}}| �|| �|��|fV qd S r+ )�_validCredentials� credClassr� ru r r r r� w s ��z.HashlessFilePasswordDBMixin.getGoodCredentialsc c s( � dD ]\}}| � || �|��V qd S )N))r_ r� )r` r� )s bloofs blarf)r� r� ru r r r r� { s � �z-HashlessFilePasswordDBMixin.getBadCredentialsc # s� � � j pdd� }� j o� fdd�}dD ]�}� �� }t|d�� }� jD ]\}}|�|d ||� d � q"W d � n1 s>w Y tj|||d�V � �� }t|d�� }� jD ]\}}|�||�d | d � qYW d � n1 suw Y tj|d d d ||d�V � �� }t|d��!}� jD ]\}}|�d |�� d ||� d � q�W d � n1 s�w Y tj|dddd||d�V qd S )Nc S r� r+ r r� r r r r� � s z9HashlessFilePasswordDBMixin.getCheckers.<locals>.<lambda>c s � � |�S r+ )�diskHash)r, r- �storedr" r r r� � s )TFrb rc rd )�cacher� s dingle dongle � � r s zip,zap,s ,zup,� ,r � F)r� re rg r� ri r rn �title)r r� � hashCheckr� �fn�fObjrk rl r r" r r� � s@ � � � � � � �� � ��z'HashlessFilePasswordDBMixin.getCheckers)r r r r rK r� r� � staticmethodr� r� r� r� r� r� r r r r r� i s r� c @ s e Zd Zedd� �ZdS )� LocallyHashedFilePasswordDBMixinc C � t | �S r+ �r r� r r r r� � � z)LocallyHashedFilePasswordDBMixin.diskHashN)r r r r� r� r r r r r� � s r� c @ s4 e Zd Zededefdd��ZG dd� dej�ZdS )� NetworkHashedFilePasswordDBMixinr� r� c C r� r+ r� r� r r r r� � r� z,NetworkHashedFilePasswordDBMixin.networkHashc @ s e Zd Zdd� ZdS )z*NetworkHashedFilePasswordDBMixin.credClassc C s t | j�|kS r+ )r r- r. r r r r/ � s z8NetworkHashedFilePasswordDBMixin.credClass.checkPasswordN)r r r r/ r r r r r� � s r� N) r r r r� r� r� r rK r� r r r r r� � s r� c @ r' )�"HashlessFilePasswordDBCheckerTestsNr) r r r r r� � � r� c @ r' )�'LocallyHashedFilePasswordDBCheckerTestsNr) r r r r r� � r� r� c @ r' )�'NetworkHashedFilePasswordDBCheckerTestsNr) r r r r r� � r� r� c @ s e Zd ZdZdd� ZdS )�UsernameHashedPasswordTestszo UsernameHashedPassword is a deprecated class that is functionally equivalent to UsernamePassword. c C s | � ddtd� dS )zB Tests that UsernameHashedPassword is deprecated. r� r� z6Use twisted.cred.credentials.UsernamePassword instead.N)r� r� r" r r r �test_deprecation� s �z,UsernameHashedPasswordTests.test_deprecationN)r r r r r� r r r r r� � s r� ).r �binasciir r �zope.interfacer r � twisted.credr r r r �twisted.internetr �twisted.pythonr �twisted.python.versionsr � twisted.trialr r �_crypt� ImportErrorr� r r �Adapterr& �registerAdapterrA r( r* �IRealmr0 �TestCaser7 r] r� r� r� r� r� r� r� r� r� r r r r �<module> sT � \7L$8 � � �PK Mb�Z� ܗQ �Q 5 cred/test/__pycache__/test_digestauth.cpython-310.pycnu �[��� o �b�] � @ s� d Z ddlZddlmZ ddlmZmZ ddlmZ ddl m Z m Z m Z m Z mZ ddlmZ ddlmZ dd lmZ dd lmZ d d � ZG d d� de �ZG dd� de�ZdS )z[ Tests for L{twisted.cred._digest} and the associated bits in L{twisted.cred.credentials}. � N)�hexlify)�md5�sha1)� verifyObject)�DigestCredentialFactory�IUsernameDigestHash�calcHA1�calcHA2� calcResponse)� LoginFailed)� IPv4Address)� networkString)�TestCasec C s t �| ��� S )N)�base64� b64encode�strip)�s� r �C/usr/lib/python3/dist-packages/twisted/cred/test/test_digestauth.pyr s r c s0 e Zd ZdZ� fdd�Zdd� Zdd� Z� ZS )�FakeDigestCredentialFactoryz\ A Fake Digest Credential Factory that generates a predictable nonce and opaque c s t � j|i |�� d| _d S )N� 0)�super�__init__� privateKey)�self�args�kwargs�� __class__r r r ' s z$FakeDigestCredentialFactory.__init__c C � dS )z) Generate a static nonce s 178288758716122392881254770685r �r r r r �_generateNonce+ � z*FakeDigestCredentialFactory._generateNoncec C r )z& Return a stable time r r r r r r �_getTime1 r" z$FakeDigestCredentialFactory._getTime)�__name__� __module__� __qualname__�__doc__r r! r# � __classcell__r r r r r ! s r c @ sZ e Zd ZdZdd� Zdefdd�Zdd� Zd d � Zdefd d �Z defd d�Z dd� Z dd� Z dd� Z dd� Zdefdd�Zdd� Zdd � Zdefd d �Zd d � Zd!d"� ZdOd$d%�Zd&d'� ZdOd(d)�Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@dA� Z#dBdC� Z$dDdE� Z%dFdG� Z&dHdI� Z'dJdK� Z(dLdM� Z)dNS )P�DigestAuthTestsz� L{TestCase} mixin class which defines a number of tests for L{DigestCredentialFactory}. Because this mixin defines C{setUp}, it must be inherited before L{TestCase}. c C sR d| _ d| _d| _d| _d| _d| _d| _tdd d �| _d | _ t | j| j�| _ d S ) z> Create a DigestCredentialFactory for testing � foobars bazquuxs test realm� md5s 29fc54aa1641c6fa0e151419361c8f23� auths /write/�TCPz10.2.3.4iu� � GETN) �username�password�realm� algorithm�cnonce�qop�urir � clientAddress�methodr �credentialFactoryr r r r �setUp? s zDigestAuthTests.setUpr+ c C sT d}t || j| j| j|| j�}d�| j| j| jf�}t||��� �}| �||� dS )z� L{calcHA1} accepts the C{'md5'} algorithm and returns an MD5 hash of its parameters, excluding the nonce and cnonce. s abc123xyz� :N) r r/ r1 r0 r3 �joinr �digest� assertEqual)r � _algorithm�_hash�nonce�hashA1�a1�expectedr r r �test_MD5HashA1N s �z DigestAuthTests.test_MD5HashA1c C s~ d}t d| j| j| j|| j�}| jd | j d | j }tt|��� �}|d | d | j }tt|��� �}| �||� dS )z� L{calcHA1} accepts the C{'md5-sess'} algorithm and returns an MD5 hash of its parameters, including the nonce and cnonce. s xyz321abc� md5-sessr: N) r r/ r1 r0 r3 r r r< r= )r r@ rA rB �ha1rC r r r �test_MD5SessionHashA1[ s �z%DigestAuthTests.test_MD5SessionHashA1c C � | � dt� dS )z� L{calcHA1} accepts the C{'sha'} algorithm and returns a SHA hash of its parameters, excluding the nonce and cnonce. � shaN)rD r r r r r �test_SHAHashA1j � z DigestAuthTests.test_SHAHashA1c C sD d}t ||| jdd�}|d | j }t||��� �}| �||� dS )z� L{calcHA2} accepts the C{'md5'} algorithm and returns an MD5 hash of its arguments, excluding the entity hash for QOP other than C{'auth-int'}. r. r, Nr: �r r5 r r< r= )r r> r? r7 �hashA2�a2rC r r r �test_MD5HashA2Authq s z"DigestAuthTests.test_MD5HashA2Authc C sP d}d}t ||| jd|�}|d | j d | }t||��� �}| �||� dS )z� L{calcHA2} accepts the C{'md5'} algorithm and returns an MD5 hash of its arguments, including the entity hash for QOP of C{'auth-int'}. r. s foobarbazs auth-intr: NrL )r r> r? r7 �hentityrM rN rC r r r �test_MD5HashA2AuthInt} s z%DigestAuthTests.test_MD5HashA2AuthIntc C � | � d� dS )z� L{calcHA2} accepts the C{'md5-sess'} algorithm and QOP of C{'auth'} and returns the same value as it does for the C{'md5'} algorithm. rE N)rO r r r r �test_MD5SessHashA2Auth� � z&DigestAuthTests.test_MD5SessHashA2Authc C rR )z� L{calcHA2} accepts the C{'md5-sess'} algorithm and QOP of C{'auth-int'} and returns the same value as it does for the C{'md5'} algorithm. rE N)rQ r r r r �test_MD5SessHashA2AuthInt� rT z)DigestAuthTests.test_MD5SessHashA2AuthIntc C rH )z� L{calcHA2} accepts the C{'sha'} algorithm and returns a SHA hash of its arguments, excluding the entity hash for QOP other than C{'auth-int'}. rI N)rO r r r r r �test_SHAHashA2Auth� � z"DigestAuthTests.test_SHAHashA2Authc C rH )z� L{calcHA2} accepts the C{'sha'} algorithm and returns a SHA hash of its arguments, including the entity hash for QOP of C{'auth-int'}. rI N)rQ r r r r r �test_SHAHashA2AuthInt� rK z%DigestAuthTests.test_SHAHashA2AuthIntc C sT d}d}d}|d | d | }t ||��� �}t||||ddd�}| �||� dS )z� L{calcResponse} accepts the C{'md5'} algorithm and returns an MD5 hash of its parameters, excluding the nonce count, client nonce, and QoP value if the nonce count and client nonce are L{None} � abc123� 789xyz� lmnopqr: N�r r< r r= ) r r> r? rA rM r@ �responserC r< r r r �test_MD5HashResponse� s z$DigestAuthTests.test_MD5HashResponsec C rR )z� L{calcResponse} accepts the C{'md5-sess'} algorithm and returns an MD5 hash of its parameters, excluding the nonce count, client nonce, and QoP value if the nonce count and client nonce are L{None} rE N)r^ r r r r �test_MD5SessionHashResponse� � z+DigestAuthTests.test_MD5SessionHashResponsec C rH )z� L{calcResponse} accepts the C{'sha'} algorithm and returns a SHA hash of its parameters, excluding the nonce count, client nonce, and QoP value if the nonce count and client nonce are L{None} rI N)r^ r r r r r �test_SHAHashResponse� rW z$DigestAuthTests.test_SHAHashResponsec C sx d}d}d}d}d}d}|d | d | d | d | d | } t || ��� �} t|||||||�} | �| | � dS ) z� L{calcResponse} accepts the C{'md5'} algorithm and returns an MD5 hash of its parameters, including the nonce count, client nonce, and QoP value if they are specified. rY rZ r[ s 00000004s abcxyz123r, r: Nr\ ) r r> r? rA rM r@ � nonceCount� clientNoncer4 r] rC r< r r r �test_MD5HashResponseExtra� sB �������� � �� �z)DigestAuthTests.test_MD5HashResponseExtrac C rR )z� L{calcResponse} accepts the C{'md5-sess'} algorithm and returns an MD5 hash of its parameters, including the nonce count, client nonce, and QoP value if they are specified. rE N)rd r r r r � test_MD5SessionHashResponseExtra� r` z0DigestAuthTests.test_MD5SessionHashResponseExtrac C rH )z� L{calcResponse} accepts the C{'sha'} algorithm and returns a SHA hash of its parameters, including the nonce count, client nonce, and QoP value if they are specified. rI N)rd r r r r r �test_SHAHashResponseExtra� rW z)DigestAuthTests.test_SHAHashResponseExtraTc s� d|vr | j |d< d|vr| j|d< d|vr| j|d< d|vr$| j|d< d|vr-| j|d< d|vr6| j|d< |r;d� nd� d �� fd d �|�� D ��S ) a� Format all given keyword arguments and their values suitably for use as the value of an HTTP header. @types quotes: C{bool} @param quotes: A flag indicating whether to quote the values of each field in the response. @param **kw: Keywords and C{bytes} values which will be treated as field name/value pairs to include in the result. @rtype: C{bytes} @return: The given fields formatted for use as an HTTP header value. r/ r1 r2 r4 r3 r5 � "� s , c s0 g | ]\}}|d urd� t|�d� |� f��qS )Nrh � =)r; r )�.0�k�v��quoter r � <listcomp> s �z2DigestAuthTests.formatResponse.<locals>.<listcomp>)r/ r1 r2 r4 r3 r5 r; �items)r �quotes�kwr rm r �formatResponse� s( ��z DigestAuthTests.formatResponsec C sh |� d�}|� d��� }|� d�}t|| j| j| j|| j�}t|d| j|d�}t |||||| j|�}|S )z@ Calculate the response for the given challenge r@ r2 r4 r. N) �get�lowerr r/ r1 r0 r3 r r5 r ) r � challenge�ncountr@ �algor4 rF �ha2rC r r r �getDigestResponse s �z!DigestAuthTests.getDigestResponsec C sz | j �| jj�}d}| j||d | �||�||d d�}| j �|| j| jj�}| �|� | j �� | � |� | j d �� dS )z� L{DigestCredentialFactory.decode} accepts a digest challenge response and parses it into an L{IUsernameHashedPassword} provider. � 00000001r@ �opaque)rq r@ r] �ncr| � wrongN� r8 � getChallenger6 �hostrs rz �decoder7 � assertTrue� checkPasswordr0 � assertFalse)r rq rv r} �clientResponse�credsr r r � test_response. s � �z DigestAuthTests.test_responsec C rR )a L{DigestCredentialFactory.decode} accepts a digest challenge response which does not quote the values of its fields and parses it into an L{IUsernameHashedPassword} provider in the same way it would a response which included quoted field values. FN)r� r r r r �test_responseWithoutQuotesC s z*DigestAuthTests.test_responseWithoutQuotesc C s d| _ | �d� dS )z� L{DigestCredentialFactory.decode} accepts a digest challenge response which quotes the values of its fields and includes a C{b","} in the URI field. s /some,path/TN)r5 r� r r r r �test_responseWithCommaURIL s z)DigestAuthTests.test_responseWithCommaURIc C s d| _ | �� dS )zs The case of the algorithm value in the response is ignored when checking the credentials. s MD5N�r2 r� r r r r � test_caseInsensitiveAlgorithmU s z-DigestAuthTests.test_caseInsensitiveAlgorithmc C s d| _ | �� dS )zV The algorithm defaults to MD5 if it is not supplied in the response. Nr� r r r r �test_md5DefaultAlgorithm] s z(DigestAuthTests.test_md5DefaultAlgorithmc C sp | j �d�}d}| j|d | �||�||d d�}| j �|| jd�}| �|�| j�� | � |�| jd �� dS )z� L{DigestCredentialFactory.decode} accepts a digest challenge response even if the client address it is passed is L{None}. Nr{ r@ r| �r@ r] r} r| r~ ) r8 r� rs rz r� r7 r� r� r0 r� �r rv r} r� r� r r r � test_responseWithoutClientIPd s �z,DigestAuthTests.test_responseWithoutClientIPc C s� | j �| jj�}d}| j|d | �||�||d d�}| j �|| j| jj�}| �|� | j �� | � |� | j d �� d}| j|d | �||�||d d�}| j �|| j| jj�}| �|� | j �� | � |� | j d �� dS )zm L{DigestCredentialFactory.decode} handles multiple responses to a single challenge. r{ r@ r| r� r~ s 00000002Nr r� r r r �test_multiResponsev s2 � � � �z"DigestAuthTests.test_multiResponsec C sv | j �| jj�}d}| j|d | �||�||d d�}| j �|d| jj�}| �|�| j �� | �|�| j d �� dS )a& L{DigestCredentialFactory.decode} returns an L{IUsernameHashedPassword} provider which rejects a correct password for the given user if the challenge response request is made using a different HTTP method than was used to request the initial challenge. r{ r@ r| r� s POSTr~ N) r8 r� r6 r� rs rz r� r� r� r0 r� r r r � test_failsWithDifferentMethod� s � �z-DigestAuthTests.test_failsWithDifferentMethodc C sl | � t| jj| jdd�| j| jj�}| �t |�d� | � t| jj| jdd�| j| jj�}| �t |�d� dS )z� L{DigestCredentialFactory.decode} raises L{LoginFailed} if the response has no username field or if the username field is empty. N)r/ z$Invalid response, no username given.rh � � assertRaisesr r8 r� rs r7 r6 r� r= �str�r �er r r �test_noUsername� s � �z DigestAuthTests.test_noUsernamec C s8 | � t| jj| jdd�| j| jj�}| �t |�d� dS )zo L{DigestCredentialFactory.decode} raises L{LoginFailed} if the response has no nonce. rY )r| z!Invalid response, no nonce given.Nr� r� r r r � test_noNonce� s �z DigestAuthTests.test_noNoncec C s4 | � t| jj| �� | j| jj�}| �t |�d� dS )zp L{DigestCredentialFactory.decode} raises L{LoginFailed} if the response has no opaque. z"Invalid response, no opaque given.Nr� r� r r r � test_noOpaque� s �z DigestAuthTests.test_noOpaquec C s� | j �| jj�}d}| j|d | �||�||d d�}| j �|| j| jj�}| �t t |�� | j d | j d | j }t|�}| �|�t|�� ��� |�d� | �|�t|�� ��� dS )z� L{DigestCredentialFactory.decode} returns an L{IUsernameDigestHash} provider which can verify a hash of the form 'username:realm:password'. r{ r@ r| r� r: r~ N)r8 r� r6 r� rs rz r� r7 r� r r r/ r1 r0 r � checkHashr r< �updater� )r rv r} r� r� � cleartext�hashr r r �test_checkHash� s" � � z DigestAuthTests.test_checkHashc C s t | j| j�}|�| jj�}| �t|jd|d | jj�}| � t |�d� dt d� }| �t|j||d | jj�}| � t |�d� | �t|jd|d | jj�}| � t |�d� dt d� |d t | jj�df�� }| �t|j||d | jj�}| � t |�d � d S ) z� L{DigestCredentialFactory.decode} raises L{LoginFailed} when the opaque value does not contain all the required parts. s badOpaquer@ z&Invalid response, invalid opaque values foo-s nonce,clientiprh � ,r* z,Invalid response, invalid opaque/time valuesN)r r2 r1 r� r6 r� r� r � _verifyOpaquer= r� r r; r )r r8 rv �exc� badOpaquer r r �test_invalidOpaque� sP � �����z"DigestAuthTests.test_invalidOpaquec C s� t | j| j�}|�| jj�}|�d| jj�}| �t|j ||d | jj�}| � t |�d� | �t|j |d| jj�}| � t |�d� dS )z� L{DigestCredentialFactory.decode} raises L{LoginFailed} when the given nonce from the response does not match the nonce encoded in the opaque. s 1234567890r@ z2Invalid response, incompatible opaque/nonce valuesrh N) r r2 r1 r� r6 r� �_generateOpaquer� r r� r= r� )r r8 rv �badNonceOpaquer� r r r �test_incompatibleNonce1 s* ���z&DigestAuthTests.test_incompatibleNoncec C s` t | j| j�}|�| jj�}d}| �| jj|� |�|d |�}| �t |j ||d | jj� dS )z� L{DigestCredentialFactory.decode} raises L{LoginFailed} when the request comes from a client IP other than what is encoded in the opaque. z10.0.0.1r@ N) r r2 r1 r� r6 r� �assertNotEqualr� r� r r� )r r8 rv � badAddressr� r r r �test_incompatibleClientIPO s ��z)DigestAuthTests.test_incompatibleClientIPc C s� t | j| j�}|�| jj�}d�|d t| jj�df�}tt ||j �� � �}t |�}d�||� d�f�}| �t|j||d | jj� dS )z� L{DigestCredentialFactory.decode} raises L{LoginFailed} when the given opaque is older than C{DigestCredentialFactory.CHALLENGE_LIFETIME_SECS} r� r@ s -137876876� -� N)r r2 r1 r� r6 r� r; r r r r r< r r r� r r� )r r8 rv �keyr< �ekey�oldNonceOpaquer r r � test_oldNonceh s ��z DigestAuthTests.test_oldNoncec C s~ t | j| j�}|�| jj�}d�|d t| jj�df�}tt |d �� � �}d�|t |�f�}| � t |j||d | jj� dS )z~ L{DigestCredentialFactory.decode} raises L{LoginFailed} when the opaque checksum fails verification. r� r@ r s this is not the right pkeyr� N)r r2 r1 r� r6 r� r; r r r r< r r� r r� )r r8 rv r� r< � badChecksumr r r � test_mismatchedOpaqueChecksum� s ��z-DigestAuthTests.test_mismatchedOpaqueChecksumc C s6 d}|D ]\}}}}| j ttd|||dd|d� qdS )z� L{calcHA1} raises L{TypeError} when any of the pszUsername, pszRealm, or pszPassword arguments are specified with the preHA1 keyword argument. ))s user� realm� password� preHA1)Nr� Nr� )NNr� r� r+ s nonces cnonce)�preHA1N)r� � TypeErrorr )r � arguments� pszUsername�pszRealm� pszPasswordr� r r r � test_incompatibleCalcHA1Options� s ��z/DigestAuthTests.test_incompatibleCalcHA1Optionsc C s | j �dd�}| �d|� dS )z� L{DigestCredentialFactory._generateOpaque} returns a value without newlines, regardless of the length of the nonce. sn long nonce long nonce long nonce long nonce long nonce long nonce long nonce long nonce long nonce long nonce Nr� )r8 r� � assertNotIn)r r| r r r �test_noNewlineOpaque� s z$DigestAuthTests.test_noNewlineOpaqueN)T)*r$ r% r& r' r9 r rD rG rJ rO rQ rS rU rV rX r^ r_ ra rd re rf rs rz r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r) 8 sN ! ( #3 r) )r' r �binasciir �hashlibr r �zope.interface.verifyr �twisted.cred.credentialsr r r r r �twisted.cred.errorr �twisted.internet.addressr �twisted.python.compatr �twisted.trial.unittestr r r r) r r r r �<module> s PK Mb�Z��8�_ �_ 2 cred/test/__pycache__/test_strcred.cpython-310.pycnu �[��� o �be � @ s6 d Z ddlZddlmZ ddlmZmZ ddlmZ ddl m Z ddl m Z ddl mZmZmZmZ dd lmZmZmZ dd lmZ dd lmZ dd lmZ dd l m Z ddl m Z e d�Z e d�Z!e d�Z"dd� Z#G dd� de �Z$G dd� de �Z%G dd� de �Z&G dd� de �Z'ee! d �ee d �ee" d �G d d � d e ����Z(ee d!�G d"d#� d#e ��Z)G d$d%� d%e �Z*ee d&� d'�ee d(� d)�G d*d+� d+e ���Z+G d,d-� d-ej,ej-�Z.G d.d/� d/e �Z/G d0d1� d1ej,ej-�Z0G d2d3� d3ej,ej-�Z1G d4d5� d5ej,ej-�Z2G d6d7� d7ej,ej-�Z3G d8d9� d9e �Z4dS ):z L{twisted.cred.strcred}. � N)�StringIO)�Sequence�Type)�skipIf)� Interface)�plugin)�checkers� credentials�error�strcred)�cred_anonymous� cred_file� cred_unix)�usage)� UserDatabase)�FilePath)� requireModule)�TestCase�crypt�pwd�spwdc C s< d} | dd� t �� D �v r | d7 } | dd� t �� D �v s | S )zC Helper method to produce an auth type that doesn't exist. �ThisPluginDoesNotExistc S s g | ]}|j �qS � )�authType)�.0�factoryr r �@/usr/lib/python3/dist-packages/twisted/cred/test/test_strcred.py� <listcomp># s �z&getInvalidAuthType.<locals>.<listcomp>�_)r �findCheckerFactories)�invalidAuthTyper r r �getInvalidAuthType s ���r! c @ � e Zd Zdd� Zdd� ZdS )�PublicAPITestsc C �. t � }| �tjtj|� | �tjtj|� dS )z9 The description string cannot be empty. N�r! � assertRaisesr �InvalidAuthType� makeChecker�findCheckerFactory��self�iatr r r �test_emptyDescription+ � z$PublicAPITests.test_emptyDescriptionc C r$ )z@ An unrecognized auth type raises an exception. Nr% r* r r r �test_invalidAuthType3 r. z#PublicAPITests.test_invalidAuthTypeN)�__name__� __module__� __qualname__r- r/ r r r r r# * � r# c @ r" )�StrcredFunctionsTestsc C s. t t�� �}t�tj�D ]}| �||� q dS )zP L{strcred.findCheckerFactories} returns all available plugins. N)�listr r r � getPlugins�ICheckerFactory�assertIn)r+ �availablePlugins�plgr r r �test_findCheckerFactories= s �z/StrcredFunctionsTests.test_findCheckerFactoriesc C s | � t�d�tj� dS )z{ L{strcred.findCheckerFactory} returns the first plugin available for a given authentication type. �fileN)�assertIdenticalr r) r �theFileCheckerFactory�r+ r r r �test_findCheckerFactoryE s �z-StrcredFunctionsTests.test_findCheckerFactoryN)r0 r1 r2 r; r@ r r r r r4 < r3 r4 c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd S )�MemoryCheckerTestsc C sH t �dd�| _t �dd�| _t �dd�| _t �dd�| _t�d�| _d S ) N�admin�asdf�alice�foo�foobar�x�yzzmemory:admin:asdf:alice:foo) r �UsernamePasswordrB rD �badPass�badUserr r( �checkerr? r r r �setUpP s zMemoryCheckerTests.setUpc C �* | � tj�| j�� | �tj| jj� dS �z� Verifies that strcred.makeChecker('memory') returns an object that implements the L{ICredentialsChecker} interface. N� � assertTruer �ICredentialsChecker� providedByrL r8 r �IUsernamePassword�credentialInterfacesr? r r r �test_isCheckerW � z!MemoryCheckerTests.test_isCheckerc C s | � tjtjd� dS )z� An argument string which does not contain user:pass pairs (i.e., an odd number of ':' characters) raises an exception. z memory:a:b:cN)r& r �InvalidAuthArgumentStringr( r? r r r �test_badFormatArgString_ s �z*MemoryCheckerTests.test_badFormatArgStringc � � fdd�}� j �� j��|�S )�; The checker works with valid credentials. c � � � | � jj� d S �N�� assertEqualrB �username�r` r? r r � _gotAvatarm � zAMemoryCheckerTests.test_memoryCheckerSucceeds.<locals>._gotAvatar�rL �requestAvatarIdrB � addCallback�r+ rb r r? r �test_memoryCheckerSucceedsh � z-MemoryCheckerTests.test_memoryCheckerSucceedsc C � | � | j�| j�tj�S �z= The checker fails with an invalid username. �� assertFailurerL re rK r �UnauthorizedLoginr? r r r � test_memoryCheckerFailsUsernamer � �z2MemoryCheckerTests.test_memoryCheckerFailsUsernamec C rj �z= The checker fails with an invalid password. �rm rL re rJ r rn r? r r r � test_memoryCheckerFailsPasswordz rp z2MemoryCheckerTests.test_memoryCheckerFailsPasswordN) r0 r1 r2 rM rV rY rh ro rs r r r r rA O s rA c @ r" )�AnonymousCheckerTestsc C �0 t �d�}| �tj�|�� | �tj|j � dS )z� Verifies that strcred.makeChecker('anonymous') returns an object that implements the L{ICredentialsChecker} interface. � anonymousN) r r( rQ r rR rS r8 r � IAnonymousrU )r+ rL r r r rV � � z$AnonymousCheckerTests.test_isCheckerc s. t �d�}|�t�� �}� fdd�}|�|�S )z? We can log in anonymously using this checker. rv c s � � tj| � d S r] )r= r � ANONYMOUS)�avatarr? r r rb � s zEAnonymousCheckerTests.testAnonymousAccessSucceeds.<locals>._gotAvatar)r r( re r � Anonymousrf )r+ rL �requestrb r r? r �testAnonymousAccessSucceeds� s z1AnonymousCheckerTests.testAnonymousAccessSucceedsN)r0 r1 r2 rV r} r r r r rt � s rt z"Required module not available: pwdz$Required module not available: cryptz#Required module not available: spwdc @ s^ e Zd Zddd�Zdd� Zdd� Zdd � Zd d � Zd d � Zdd� Z dd� Z dd� Z dd� Z dS )�UnixCheckerTestsrC rE )rB rD c C s* t �|t�| j| d�dddddddf �S )N�F/r i�� � ���)r � struct_spwdr �users)r+ r` r r r �_spwd_getspnam� s ��z UnixCheckerTests._spwd_getspnamc C s� t �dd�| _t �dd�| _t �dd�| _t �dd�| _t�d�| _t �d d �| _ t �d d �| _ t �d d �| _ t �dd�| _ t�d�| _ trlt� }| j�� D ]\}}|�|t�|d�dd|d| d� qN| �td|j� trx| �td| j� d S d S )NrB rC rD rE rF rG rH �unix� admin� asdf� alice� foo� foobar� x� yzr i� z/home/z/bin/sh�getpwnam�getspnam)r rI rB rD rJ rK r r( rL � adminBytes� aliceBytes� badPassBytes� badUserBytes� checkerBytesr r r� �items�addUserr �patchr� r r� )r+ �databaser` �passwordr r r rM � s4 � �zUnixCheckerTests.setUpc C sP | � tj�| j�� | �tj| jj� | � tj�| j �� | �tj| j j� dS )z� Verifies that strcred.makeChecker('unix') returns an object that implements the L{ICredentialsChecker} interface. N) rQ r rR rS rL r8 r rT rU r� r? r r r rV � s �z UnixCheckerTests.test_isCheckerc rZ )r[ c r\ r] r^ ra r? r r rb � rc z=UnixCheckerTests.test_unixCheckerSucceeds.<locals>._gotAvatarrd rg r r? r �test_unixCheckerSucceeds� ri z)UnixCheckerTests.test_unixCheckerSucceedsc rZ )zD The checker works with valid L{bytes} credentials. c s � � | � jj�d�� d S )N�utf-8)r_ r� r` �decodera r? r r rb � s zBUnixCheckerTests.test_unixCheckerSucceedsBytes.<locals>._gotAvatar)r� re r� rf rg r r? r � test_unixCheckerSucceedsBytes� s �z.UnixCheckerTests.test_unixCheckerSucceedsBytesc C rj rk rl r? r r r � test_unixCheckerFailsUsername� rp z.UnixCheckerTests.test_unixCheckerFailsUsernamec C rj )zF The checker fails with an invalid L{bytes} username. )rm r� re r� r rn r? r r r �"test_unixCheckerFailsUsernameBytes� � �z3UnixCheckerTests.test_unixCheckerFailsUsernameBytesc C rj rq rr r? r r r � test_unixCheckerFailsPassword rp z.UnixCheckerTests.test_unixCheckerFailsPasswordc C rj )zF The checker fails with an invalid L{bytes} password. )rm r� re r� r rn r? r r r �"test_unixCheckerFailsPasswordBytes r� z3UnixCheckerTests.test_unixCheckerFailsPasswordBytesN) r0 r1 r2 r� r� rM rV r� r� r� r� r� r� r r r r r~ � s � r~ z%Required module is unavailable: cryptc @ s e Zd ZdZdd� Zdd� ZdS )� CryptTestsz9 L{crypt} has functions for encrypting password. c C s* d}dD ]2}zt � ||�}t|t�r|�d�}W n ty! Y qw d}| �t�||�� | �t�||�� qdD ]Y}t t |d�}|sDq9d}t � ||�}t|t�rV|�d�}|d }t�||�} | �| � t�|� d�|� d��} | �| � t�||�} | �| � t�|� d�|� d��} | �| � q9dS ) z4 L{cred_unix.verifyCryptedPassword} �sample password ^%$)N�abr� z$1x1234)� METHOD_SHA512� METHOD_SHA256� METHOD_MD5� METHOD_CRYPTNzinteresting password xyz�blahfooincorrect) r � isinstance�bytesr� � TypeErrorrQ r �verifyCryptedPassword� assertFalse�getattr�encode) r+ r� �salt�cryptedCorrect�cryptedIncorrect�method� cryptMethod�crypted�incorrectCrypted�resultr r r �test_verifyCryptedPassword sJ � � � � � �z%CryptTests.test_verifyCryptedPasswordc C s< dd� }d}t � |d�}| �t d|� | �t�||�� dS )zK L{cred_unix.verifyCryptedPassword} when OSError is raised c S s t d��)N� )�OSError)r� r� r r r � mockCryptQ s z?CryptTests.test_verifyCryptedPasswordOSError.<locals>.mockCryptr� r� r N)r r� r� r r� )r+ r� r� r� r r r �!test_verifyCryptedPasswordOSErrorL s z,CryptTests.test_verifyCryptedPasswordOSErrorN)r0 r1 r2 �__doc__r� r� r r r r r� s 0r� c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )�FileDBCheckerTestsz* C{--auth=file:...} file checker. c C sh t �dd�| _t �dd�| _t �dd�| _t �dd�| _| �� | _t| j�� d� t � d | j �| _ d S ) Nr� r� r� r� r� r� r� � admin:asdf alice:foo �file:) r rI rB rD rJ rK �mktemp�filenamer � setContentr r( rL r? r r r rM _ s zFileDBCheckerTests.setUpc C s( d}t j�|�r|d7 }t j�|�s|S )Nz /DoesNotExistr )�os�path�exists)r+ r� r r r � _fakeFilenameh s �z FileDBCheckerTests._fakeFilenamec C rN rO rP r? r r r rV n rW z!FileDBCheckerTests.test_isCheckerc rZ )r[ c r\ r] r^ ra r? r r rb { rc z?FileDBCheckerTests.test_fileCheckerSucceeds.<locals>._gotAvatarrd rg r r? r �test_fileCheckerSucceedsv ri z+FileDBCheckerTests.test_fileCheckerSucceedsc C rj rk rl r? r r r � test_fileCheckerFailsUsername� rp z0FileDBCheckerTests.test_fileCheckerFailsUsernamec C rj rq rr r? r r r � test_fileCheckerFailsPassword� rp z0FileDBCheckerTests.test_fileCheckerFailsPasswordc C s$ | � ttjd� | � ttjd� dS )z4 An empty filename raises an error. r< r� N)r& � ValueErrorr r( r? r r r �test_failsWithEmptyFilename� s z.FileDBCheckerTests.test_failsWithEmptyFilenamec C sF t jj}t� }|t j_t�d| �� � |t j_| �t j|� � � dS )zt When the file auth plugin is given a file that doesn't exist, it should produce a warning. r� N) r r> � errorOutputr r r( r� r8 �invalidFileWarning�getvalue)r+ � oldOutput� newOutputr r r �test_warnWithBadFilename� s z+FileDBCheckerTests.test_warnWithBadFilenameN) r0 r1 r2 r� rM r� rV r� r� r� r� r� r r r r r� Z s r� � cryptographyz cryptography is not available�pyasn1zpyasn1 is not availablec @ s e Zd ZdZdd� ZdS )�SSHCheckerTestsz� Tests for the C{--auth=sshkey:...} checker. The majority of the tests for the ssh public key database checker are in L{twisted.conch.test.test_checkers.SSHPublicKeyCheckerTestCase}. c C ru )z� Verifies that strcred.makeChecker('sshkey') returns an object that implements the L{ICredentialsChecker} interface. �sshkeyN) r r( rQ r rR rS r8 r �ISSHPrivateKeyrU )r+ � sshCheckerr r r rV � rx z SSHCheckerTests.test_isCheckerN)r0 r1 r2 r� rV r r r r r� � s r� c @ s e Zd ZdZdS )� DummyOptionsz@ Simple options for testing L{strcred.AuthOptionMixin}. N)r0 r1 r2 r� r r r r r� � � r� c @ sL e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dS )�CheckerOptionsTestsc C sT t � }|�ddg� | �t|d �d� t � }|�g d�� | �t|d �d� dS )zu The C{--auth} command line creates a list in the Options instance and appends values to it. �--auth�memory� credCheckers� )r� r� r� r� � N)r� � parseOptionsr_ �len�r+ �optionsr r r �test_createsList� s z$CheckerOptionsTests.test_createsListc C s< t � }t� }| �tj|jd|g� | �tj|jd|g� dS )zx The C{--auth} command line raises an exception when it gets a parameter it doesn't understand. r� �--help-auth-typeN)r� r! r& r � UsageErrorr� )r+ r� �invalidParameterr r r �test_invalidAuthError� s ��z)CheckerOptionsTests.test_invalidAuthErrorc C s� t � }|�g d�� |d }| �t|tj �d� | �t|tj �d� |tj d }|tj d }| �tj � |�� | �tj � |�� | � tj|j � | � tj|j � dS )z� The C{--auth} command line creates a dictionary mapping supported interfaces to the list of credentials checkers that support it. )r� r� r� rv �credInterfacesr� r N) r� r� r_ r� r rw rT rQ r rR rS r8 rU )r+ r� �chd� chdAnonymous� chdUserPassr r r �test_createsDictionary� s z*CheckerOptionsTests.test_createsDictionaryc C s2 t � }|�g d�� | �|d |d tj � dS )z� When two C{--auth} arguments are passed along which support the same interface, a list with both is created. )r� r� r� r� r� r� N)r� r� r_ r rT r� r r r � test_credInterfacesProvidesLists� s �z4CheckerOptionsTests.test_credInterfacesProvidesListsc C s6 g }t � }|�� D ]}| �|j|� |�|j� q dS )zG The list for C{--help-auth} does not duplicate items. N)r� � _checkerFactoriesForOptHelpAuth� assertNotInr �append)r+ � authTypesr� �cfr r r �!test_listDoesNotDisplayDuplicates� s �z5CheckerOptionsTests.test_listDoesNotDisplayDuplicatesc C sH t � }t� }||_| �t|jdg� t�� D ] }| �|j |� � � qdS )zz The C{--help-auth} argument correctly displays all available authentication plugins, then exits. z --help-authN) r r� � authOutputr& � SystemExitr� r r r8 r r� )r+ � newStdoutr� �checkerFactoryr r r �test_displaysListCorrectly s �z.CheckerOptionsTests.test_displaysListCorrectlyc C sT t � }t� }||_| �t|jddg� tjjD ]}|� � r'| � |� � |� � � qdS )z� The C{--help-auth-for} argument will correctly display the help file for a particular authentication plugin. r� r< N) r r� r� r& r� r� r r> �authHelp�stripr8 r� )r+ r� r� �liner r r �test_displaysHelpCorrectly s � ��z.CheckerOptionsTests.test_displaysHelpCorrectlyc C s0 t � }| �tj|jddg�}| �t|�d� dS )z� When the checker specified by C{--auth} raises an unexpected error, it should be caught and re-raised within a L{usage.UsageError}. r� r< z,Unexpected error: 'file' requires a filenameN)r� r& r r� r� r_ �str)r+ r� �errr r r �test_unexpectedException s �z,CheckerOptionsTests.test_unexpectedExceptionN) r0 r1 r2 r� r� r� r� r� r� r� r r r r r r� � s r� c @ � e Zd ZejfZdS )�OptionsForUsernamePasswordN)r0 r1 r2 r rT �supportedInterfacesr r r r r * � r c @ r )� OptionsForUsernameHashedPasswordN)r0 r1 r2 r �IUsernameHashedPasswordr r r r r r . r r c @ s e Zd ZdZdS )� OptionsSupportsAllInterfacesN)r0 r1 r2 r r r r r r 2 r� r c @ s" e Zd ZU g Zeee ed< dS )�OptionsSupportsNoInterfacesr N)r0 r1 r2 r r r r �__annotations__r r r r r 6 s r c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )�LimitingInterfacesTestsa� Tests functionality that allows an application to limit the credential interfaces it can support. For the purposes of this test, we use IUsernameHashedPassword, although this will never really be used by the command line. (I have, to date, not thought of a half-decent way for a user to specify a hash algorithm via the command-line. Nor do I think it's very useful.) I should note that, at first, this test is counter-intuitive, because we're using the checker with a pre-defined hash function as the 'bad' checker. See the documentation for L{twisted.cred.checkers.FilePasswordDB.hash} for more details. c C sp | � � | _t| jd�� }|�d� W d � n1 sw Y t�| j�| _tj| j| jd�| _t� � | _ d S )N�wbr� )�hash) r� r� �open�writer �FilePasswordDB� goodChecker�_hash� badChecker�AllowAnonymousAccess� anonChecker)r+ �fr r r rM K s �z LimitingInterfacesTests.setUpc C s |S )z> A dumb hash that doesn't really do anything. r )r+ �networkUsername�networkPassword�storedPasswordr r r r S s z LimitingInterfacesTests._hashc C sB t � }| �|�tj�� | �|�tj�� | �tj |j | j � dS )zE The supportsInterface method behaves appropriately. N) r rQ �supportsInterfacer rT r� rw r& r �UnsupportedInterfaces� addCheckerr r� r r r �test_supportsInterfaceY s �z.LimitingInterfacesTests.test_supportsInterfacec C s. t � }| �|�tj�� | �|�tj�� dS )z| The supportsInterface method behaves appropriately when the supportedInterfaces attribute is None. N)r rQ r r rT rw r� r r r �test_supportsAllInterfacesd s z2LimitingInterfacesTests.test_supportsAllInterfacesc C s6 t � }tj}tj}| �|�|�� | �|�|�� dS )zJ The supportsCheckerFactory method behaves appropriately. N)r r r> r �theAnonymousCheckerFactoryrQ �supportsCheckerFactoryr� )r+ r� �fileCF�anonCFr r r �test_supportsCheckerFactorym s z3LimitingInterfacesTests.test_supportsCheckerFactoryc C s| t � }|�| j� |jd }| �|d | d | j� | �|d d | j� | �t|d | �d� | �t|d �d� dS )z� When addChecker is called with a checker that implements at least one of the interfaces our application supports, it is successful. r r� r� r� N)r r r r r= r_ r� )r+ r� �ifacer r r �test_canAddSupportedCheckerw s z3LimitingInterfacesTests.test_canAddSupportedCheckerc C s t � }| �tj|j| j� dS )z~ When addChecker is called with a checker that does not implement any supported interfaces, it fails. N)r r& r r r r r� r r r �#test_failOnAddingUnsupportedChecker� s �z;LimitingInterfacesTests.test_failOnAddingUnsupportedCheckerc C s( t � }tjj}| �tj|jd|g� dS )zq The C{--auth} command line raises an exception when it gets a checker we don't support. r� N)r r r r r& r r� r� )r+ r� r r r r � test_unsupportedInterfaceError� s z6LimitingInterfacesTests.test_unsupportedInterfaceErrorc C sB t � }|�� D ]}d}|jD ] }|�|�rd}q|r t�� �qdS )z� C{--help-auth} will only list checkers that purport to supply at least one of the credential interfaces our application can use. TFN)r r� rU r r r )r+ r� r �invalid� interfacer r r �test_helpAuthLimitsOutput� s ���z1LimitingInterfacesTests.test_helpAuthLimitsOutputc C sl t � }d}t�� D ] }|�|�s|} nq | �|d� t� }||_| �t|j ddg� | � tj |� � � dS )z� C{--help-auth-type} will display a warning if you get help for an authType that does not supply at least one of the credential interfaces our application can use. Nr� rv ) r r r r! �assertNotIdenticalr r� r& r� r� r8 �notSupportedWarningr� )r+ r� �invalidFactoryr r� r r r � test_helpAuthTypeLimitsOutput� s � �z5LimitingInterfacesTests.test_helpAuthTypeLimitsOutputN)r0 r1 r2 r� rM r r r r$ r& r' r( r+ r/ r r r r r : s r )5r� r� �ior �typingr r �unittestr �zope.interfacer �twistedr � twisted.credr r r r �twisted.pluginsr r r �twisted.pythonr �twisted.python.fakepwdr �twisted.python.filepathr �twisted.python.reflectr �twisted.trial.unittestr r r r r! r# r4 rA rt r~ r� r� r� �Options�AuthOptionMixinr� r� r r r r r r r r r �<module> sN 4 yCJmPK Mb�Z�-.� � 5 cred/test/__pycache__/test_simpleauth.cpython-310.pycnu �[��� o �b� � @ sT d Z ddlmZmZmZ ddlmZ ddlmZ G dd� de�Z G dd� de�Z d S ) z< Tests for basic constructs of L{twisted.cred.credentials}. � )�IUsernameHashedPassword�IUsernamePassword�UsernamePassword)� _uhpVersion)�TestCasec @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �UsernamePasswordTestsz( Tests for L{UsernamePassword}. c C s* t dd�}| �|jd� | �|jd� dS )zo The initialisation of L{UsernamePassword} will set C{username} and C{password} on it. � foo� barN)r � assertEqual�username�password��self�creds� r �C/usr/lib/python3/dist-packages/twisted/cred/test/test_simpleauth.py�test_initialisation s z)UsernamePasswordTests.test_initialisationc C s t dd�}| �|�d�� dS )z� Calling C{checkPassword} on a L{UsernamePassword} will return L{True} when the password given is the password on the object. � user� passN)r � assertTrue� checkPasswordr r r r �test_correctPassword � z*UsernamePasswordTests.test_correctPasswordc C s t dd�}| �|�d�� dS )z� Calling C{checkPassword} on a L{UsernamePassword} will return L{False} when the password given is NOT the password on the object. r r � someotherpassN)r � assertFalser r r r r �test_wrongPassword( r z(UsernamePasswordTests.test_wrongPasswordc C s | � t�t�� dS )zF L{UsernamePassword} implements L{IUsernamePassword}. N)r r � implementedByr )r r r r �test_interface0 s z$UsernamePasswordTests.test_interfaceN��__name__� __module__� __qualname__�__doc__r r r r r r r r r s r c @ r ) �UsernameHashedPasswordTestsz. Tests for L{UsernameHashedPassword}. c C s8 | � ddt�}|dd�}| �|jd� | �|jd� dS )zs The initialisation of L{UsernameHashedPassword} will set C{username} and C{hashed} on it. �twisted.cred.credentials�UsernameHashedPasswordr r N)� getDeprecatedModuleAttributer r r �hashed�r r& r r r r r < s � z/UsernameHashedPasswordTests.test_initialisationc C s, | � ddt�}|dd�}| �|�d�� dS )z� Calling C{checkPassword} on a L{UsernameHashedPassword} will return L{True} when the password given is the password on the object. r% r& r r N)r' r r r r) r r r r H � � z0UsernameHashedPasswordTests.test_correctPasswordc C s, | � ddt�}|dd�}| �|�d�� dS )z� Calling C{checkPassword} on a L{UsernameHashedPassword} will return L{False} when the password given is NOT the password on the object. r% r& r r r N)r' r r r r) r r r r S r* z.UsernameHashedPasswordTests.test_wrongPasswordc C s" | � ddt�}| �t�|�� dS )zR L{UsernameHashedPassword} implements L{IUsernameHashedPassword}. r% r& N)r' r r r r )r r& r r r r ^ s �z*UsernameHashedPasswordTests.test_interfaceNr r r r r r$ 7 s r$ N) r# �twisted.cred.credentialsr r r �twisted.cred.test.test_credr �twisted.trial.unittestr r r$ r r r r �<module> s %PK Mb�Z�]{9 9 cred/test/test_cred.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.cred}, now with 30% more starch. """ from binascii import hexlify, unhexlify from zope.interface import Interface, implementer from twisted.cred import checkers, credentials, error, portal from twisted.internet import defer from twisted.python import components from twisted.python.versions import Version from twisted.trial import unittest try: from crypt import crypt as _crypt except ImportError: crypt = None else: crypt = _crypt # The Twisted version in which UsernameHashedPassword is first deprecated. _uhpVersion = Version("Twisted", 21, 2, 0) class ITestable(Interface): """ An interface for a theoretical protocol. """ pass class TestAvatar: """ A test avatar. """ def __init__(self, name): self.name = name self.loggedIn = False self.loggedOut = False def login(self): assert not self.loggedIn self.loggedIn = True def logout(self): self.loggedOut = True @implementer(ITestable) class Testable(components.Adapter): """ A theoretical protocol for testing. """ pass components.registerAdapter(Testable, TestAvatar, ITestable) class IDerivedCredentials(credentials.IUsernamePassword): pass @implementer(IDerivedCredentials, ITestable) class DerivedCredentials: def __init__(self, username, password): self.username = username self.password = password def checkPassword(self, password): return password == self.password @implementer(portal.IRealm) class TestRealm: """ A basic test realm. """ def __init__(self): self.avatars = {} def requestAvatar(self, avatarId, mind, *interfaces): if avatarId in self.avatars: avatar = self.avatars[avatarId] else: avatar = TestAvatar(avatarId) self.avatars[avatarId] = avatar avatar.login() return (interfaces[0], interfaces[0](avatar), avatar.logout) class CredTests(unittest.TestCase): """ Tests for the meat of L{twisted.cred} -- realms, portals, avatars, and checkers. """ def setUp(self): self.realm = TestRealm() self.portal = portal.Portal(self.realm) self.checker = checkers.InMemoryUsernamePasswordDatabaseDontUse() self.checker.addUser(b"bob", b"hello") self.portal.registerChecker(self.checker) def test_listCheckers(self): """ The checkers in a portal can check only certain types of credentials. Since this portal has L{checkers.InMemoryUsernamePasswordDatabaseDontUse} registered, it """ expected = [credentials.IUsernamePassword, credentials.IUsernameHashedPassword] got = self.portal.listCredentialsInterfaces() self.assertEqual(sorted(got), sorted(expected)) def test_basicLogin(self): """ Calling C{login} on a portal with correct credentials and an interface that the portal's realm supports works. """ login = self.successResultOf( self.portal.login( credentials.UsernamePassword(b"bob", b"hello"), self, ITestable ) ) iface, impl, logout = login # whitebox self.assertEqual(iface, ITestable) self.assertTrue(iface.providedBy(impl), f"{impl} does not implement {iface}") # greybox self.assertTrue(impl.original.loggedIn) self.assertTrue(not impl.original.loggedOut) logout() self.assertTrue(impl.original.loggedOut) def test_derivedInterface(self): """ Logging in with correct derived credentials and an interface that the portal's realm supports works. """ login = self.successResultOf( self.portal.login(DerivedCredentials(b"bob", b"hello"), self, ITestable) ) iface, impl, logout = login # whitebox self.assertEqual(iface, ITestable) self.assertTrue(iface.providedBy(impl), f"{impl} does not implement {iface}") # greybox self.assertTrue(impl.original.loggedIn) self.assertTrue(not impl.original.loggedOut) logout() self.assertTrue(impl.original.loggedOut) def test_failedLoginPassword(self): """ Calling C{login} with incorrect credentials (in this case a wrong password) causes L{error.UnauthorizedLogin} to be raised. """ login = self.failureResultOf( self.portal.login( credentials.UsernamePassword(b"bob", b"h3llo"), self, ITestable ) ) self.assertTrue(login) self.assertEqual(error.UnauthorizedLogin, login.type) def test_failedLoginName(self): """ Calling C{login} with incorrect credentials (in this case no known user) causes L{error.UnauthorizedLogin} to be raised. """ login = self.failureResultOf( self.portal.login( credentials.UsernamePassword(b"jay", b"hello"), self, ITestable ) ) self.assertTrue(login) self.assertEqual(error.UnauthorizedLogin, login.type) class OnDiskDatabaseTests(unittest.TestCase): users = [ (b"user1", b"pass1"), (b"user2", b"pass2"), (b"user3", b"pass3"), ] def setUp(self): self.dbfile = self.mktemp() with open(self.dbfile, "wb") as f: for (u, p) in self.users: f.write(u + b":" + p + b"\n") def test_getUserNonexistentDatabase(self): """ A missing db file will cause a permanent rejection of authorization attempts. """ self.db = checkers.FilePasswordDB("test_thisbetternoteverexist.db") self.assertRaises(error.UnauthorizedLogin, self.db.getUser, "user") def testUserLookup(self): self.db = checkers.FilePasswordDB(self.dbfile) for (u, p) in self.users: self.assertRaises(KeyError, self.db.getUser, u.upper()) self.assertEqual(self.db.getUser(u), (u, p)) def testCaseInSensitivity(self): self.db = checkers.FilePasswordDB(self.dbfile, caseSensitive=False) for (u, p) in self.users: self.assertEqual(self.db.getUser(u.upper()), (u, p)) def testRequestAvatarId(self): self.db = checkers.FilePasswordDB(self.dbfile) creds = [credentials.UsernamePassword(u, p) for u, p in self.users] d = defer.gatherResults( [defer.maybeDeferred(self.db.requestAvatarId, c) for c in creds] ) d.addCallback(self.assertEqual, [u for u, p in self.users]) return d def testRequestAvatarId_hashed(self): self.db = checkers.FilePasswordDB(self.dbfile) UsernameHashedPassword = self.getDeprecatedModuleAttribute( "twisted.cred.credentials", "UsernameHashedPassword", _uhpVersion ) creds = [UsernameHashedPassword(u, p) for u, p in self.users] d = defer.gatherResults( [defer.maybeDeferred(self.db.requestAvatarId, c) for c in creds] ) d.addCallback(self.assertEqual, [u for u, p in self.users]) return d class HashedPasswordOnDiskDatabaseTests(unittest.TestCase): users = [ (b"user1", b"pass1"), (b"user2", b"pass2"), (b"user3", b"pass3"), ] def setUp(self): dbfile = self.mktemp() self.db = checkers.FilePasswordDB(dbfile, hash=self.hash) with open(dbfile, "wb") as f: for (u, p) in self.users: f.write(u + b":" + self.hash(u, p, u[:2]) + b"\n") r = TestRealm() self.port = portal.Portal(r) self.port.registerChecker(self.db) def hash(self, u: bytes, p: bytes, s: bytes) -> bytes: hashed_password = crypt(p.decode("ascii"), s.decode("ascii")) # type: ignore[misc] # workaround for pypy3 3.6.9 and above which returns bytes from crypt.crypt() # This is fixed in pypy3 7.3.5. # See L{https://foss.heptapod.net/pypy/pypy/-/issues/3395} if isinstance(hashed_password, bytes): return hashed_password return hashed_password.encode("ascii") def testGoodCredentials(self): goodCreds = [credentials.UsernamePassword(u, p) for u, p in self.users] d = defer.gatherResults([self.db.requestAvatarId(c) for c in goodCreds]) d.addCallback(self.assertEqual, [u for u, p in self.users]) return d def testGoodCredentials_login(self): goodCreds = [credentials.UsernamePassword(u, p) for u, p in self.users] d = defer.gatherResults( [self.port.login(c, None, ITestable) for c in goodCreds] ) d.addCallback(lambda x: [a.original.name for i, a, l in x]) d.addCallback(self.assertEqual, [u for u, p in self.users]) return d def testBadCredentials(self): badCreds = [ credentials.UsernamePassword(u, b"wrong password") for u, p in self.users ] d = defer.DeferredList( [self.port.login(c, None, ITestable) for c in badCreds], consumeErrors=True ) d.addCallback(self._assertFailures, error.UnauthorizedLogin) return d def testHashedCredentials(self): UsernameHashedPassword = self.getDeprecatedModuleAttribute( "twisted.cred.credentials", "UsernameHashedPassword", _uhpVersion ) hashedCreds = [ UsernameHashedPassword(u, self.hash(None, p, u[:2])) for u, p in self.users ] d = defer.DeferredList( [self.port.login(c, None, ITestable) for c in hashedCreds], consumeErrors=True, ) d.addCallback(self._assertFailures, error.UnhandledCredentials) return d def _assertFailures(self, failures, *expectedFailures): for flag, failure in failures: self.assertEqual(flag, defer.FAILURE) failure.trap(*expectedFailures) return None if crypt is None: skip = "crypt module not available" class CheckersMixin: """ L{unittest.TestCase} mixin for testing that some checkers accept and deny specified credentials. Subclasses must provide - C{getCheckers} which returns a sequence of L{checkers.ICredentialChecker} - C{getGoodCredentials} which returns a list of 2-tuples of credential to check and avaterId to expect. - C{getBadCredentials} which returns a list of credentials which are expected to be unauthorized. """ @defer.inlineCallbacks def test_positive(self): """ The given credentials are accepted by all the checkers, and give the expected C{avatarID}s """ for chk in self.getCheckers(): for (cred, avatarId) in self.getGoodCredentials(): r = yield chk.requestAvatarId(cred) self.assertEqual(r, avatarId) @defer.inlineCallbacks def test_negative(self): """ The given credentials are rejected by all the checkers. """ for chk in self.getCheckers(): for cred in self.getBadCredentials(): d = chk.requestAvatarId(cred) yield self.assertFailure(d, error.UnauthorizedLogin) class HashlessFilePasswordDBMixin: credClass = credentials.UsernamePassword diskHash = None @staticmethod def networkHash(x: bytes) -> bytes: return x _validCredentials = [ (b"user1", b"password1"), (b"user2", b"password2"), (b"user3", b"password3"), ] def getGoodCredentials(self): for u, p in self._validCredentials: yield self.credClass(u, self.networkHash(p)), u def getBadCredentials(self): for u, p in [ (b"user1", b"password3"), (b"user2", b"password1"), (b"bloof", b"blarf"), ]: yield self.credClass(u, self.networkHash(p)) def getCheckers(self): diskHash = self.diskHash or (lambda x: x) hashCheck = self.diskHash and ( lambda username, password, stored: self.diskHash(password) ) for cache in True, False: fn = self.mktemp() with open(fn, "wb") as fObj: for u, p in self._validCredentials: fObj.write(u + b":" + diskHash(p) + b"\n") yield checkers.FilePasswordDB(fn, cache=cache, hash=hashCheck) fn = self.mktemp() with open(fn, "wb") as fObj: for u, p in self._validCredentials: fObj.write(diskHash(p) + b" dingle dongle " + u + b"\n") yield checkers.FilePasswordDB(fn, b" ", 3, 0, cache=cache, hash=hashCheck) fn = self.mktemp() with open(fn, "wb") as fObj: for u, p in self._validCredentials: fObj.write( b"zip,zap," + u.title() + b",zup," + diskHash(p) + b"\n", ) yield checkers.FilePasswordDB( fn, b",", 2, 4, False, cache=cache, hash=hashCheck ) class LocallyHashedFilePasswordDBMixin(HashlessFilePasswordDBMixin): @staticmethod def diskHash(x): return hexlify(x) class NetworkHashedFilePasswordDBMixin(HashlessFilePasswordDBMixin): @staticmethod def networkHash(x: bytes) -> bytes: return hexlify(x) class credClass(credentials.UsernamePassword): def checkPassword(self, password): return unhexlify(self.password) == password class HashlessFilePasswordDBCheckerTests( HashlessFilePasswordDBMixin, CheckersMixin, unittest.TestCase ): pass class LocallyHashedFilePasswordDBCheckerTests( LocallyHashedFilePasswordDBMixin, CheckersMixin, unittest.TestCase ): pass class NetworkHashedFilePasswordDBCheckerTests( NetworkHashedFilePasswordDBMixin, CheckersMixin, unittest.TestCase ): pass class UsernameHashedPasswordTests(unittest.TestCase): """ UsernameHashedPassword is a deprecated class that is functionally equivalent to UsernamePassword. """ def test_deprecation(self): """ Tests that UsernameHashedPassword is deprecated. """ self.getDeprecatedModuleAttribute( "twisted.cred.credentials", "UsernameHashedPassword", _uhpVersion, "Use twisted.cred.credentials.UsernamePassword instead.", ) PK Mb�Z��1�] �] cred/test/test_digestauth.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.cred._digest} and the associated bits in L{twisted.cred.credentials}. """ import base64 from binascii import hexlify from hashlib import md5, sha1 from zope.interface.verify import verifyObject from twisted.cred.credentials import ( DigestCredentialFactory, IUsernameDigestHash, calcHA1, calcHA2, calcResponse, ) from twisted.cred.error import LoginFailed from twisted.internet.address import IPv4Address from twisted.python.compat import networkString from twisted.trial.unittest import TestCase def b64encode(s): return base64.b64encode(s).strip() class FakeDigestCredentialFactory(DigestCredentialFactory): """ A Fake Digest Credential Factory that generates a predictable nonce and opaque """ def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.privateKey = b"0" def _generateNonce(self): """ Generate a static nonce """ return b"178288758716122392881254770685" def _getTime(self): """ Return a stable time """ return 0 class DigestAuthTests(TestCase): """ L{TestCase} mixin class which defines a number of tests for L{DigestCredentialFactory}. Because this mixin defines C{setUp}, it must be inherited before L{TestCase}. """ def setUp(self): """ Create a DigestCredentialFactory for testing """ self.username = b"foobar" self.password = b"bazquux" self.realm = b"test realm" self.algorithm = b"md5" self.cnonce = b"29fc54aa1641c6fa0e151419361c8f23" self.qop = b"auth" self.uri = b"/write/" self.clientAddress = IPv4Address("TCP", "10.2.3.4", 43125) self.method = b"GET" self.credentialFactory = DigestCredentialFactory(self.algorithm, self.realm) def test_MD5HashA1(self, _algorithm=b"md5", _hash=md5): """ L{calcHA1} accepts the C{'md5'} algorithm and returns an MD5 hash of its parameters, excluding the nonce and cnonce. """ nonce = b"abc123xyz" hashA1 = calcHA1( _algorithm, self.username, self.realm, self.password, nonce, self.cnonce ) a1 = b":".join((self.username, self.realm, self.password)) expected = hexlify(_hash(a1).digest()) self.assertEqual(hashA1, expected) def test_MD5SessionHashA1(self): """ L{calcHA1} accepts the C{'md5-sess'} algorithm and returns an MD5 hash of its parameters, including the nonce and cnonce. """ nonce = b"xyz321abc" hashA1 = calcHA1( b"md5-sess", self.username, self.realm, self.password, nonce, self.cnonce ) a1 = self.username + b":" + self.realm + b":" + self.password ha1 = hexlify(md5(a1).digest()) a1 = ha1 + b":" + nonce + b":" + self.cnonce expected = hexlify(md5(a1).digest()) self.assertEqual(hashA1, expected) def test_SHAHashA1(self): """ L{calcHA1} accepts the C{'sha'} algorithm and returns a SHA hash of its parameters, excluding the nonce and cnonce. """ self.test_MD5HashA1(b"sha", sha1) def test_MD5HashA2Auth(self, _algorithm=b"md5", _hash=md5): """ L{calcHA2} accepts the C{'md5'} algorithm and returns an MD5 hash of its arguments, excluding the entity hash for QOP other than C{'auth-int'}. """ method = b"GET" hashA2 = calcHA2(_algorithm, method, self.uri, b"auth", None) a2 = method + b":" + self.uri expected = hexlify(_hash(a2).digest()) self.assertEqual(hashA2, expected) def test_MD5HashA2AuthInt(self, _algorithm=b"md5", _hash=md5): """ L{calcHA2} accepts the C{'md5'} algorithm and returns an MD5 hash of its arguments, including the entity hash for QOP of C{'auth-int'}. """ method = b"GET" hentity = b"foobarbaz" hashA2 = calcHA2(_algorithm, method, self.uri, b"auth-int", hentity) a2 = method + b":" + self.uri + b":" + hentity expected = hexlify(_hash(a2).digest()) self.assertEqual(hashA2, expected) def test_MD5SessHashA2Auth(self): """ L{calcHA2} accepts the C{'md5-sess'} algorithm and QOP of C{'auth'} and returns the same value as it does for the C{'md5'} algorithm. """ self.test_MD5HashA2Auth(b"md5-sess") def test_MD5SessHashA2AuthInt(self): """ L{calcHA2} accepts the C{'md5-sess'} algorithm and QOP of C{'auth-int'} and returns the same value as it does for the C{'md5'} algorithm. """ self.test_MD5HashA2AuthInt(b"md5-sess") def test_SHAHashA2Auth(self): """ L{calcHA2} accepts the C{'sha'} algorithm and returns a SHA hash of its arguments, excluding the entity hash for QOP other than C{'auth-int'}. """ self.test_MD5HashA2Auth(b"sha", sha1) def test_SHAHashA2AuthInt(self): """ L{calcHA2} accepts the C{'sha'} algorithm and returns a SHA hash of its arguments, including the entity hash for QOP of C{'auth-int'}. """ self.test_MD5HashA2AuthInt(b"sha", sha1) def test_MD5HashResponse(self, _algorithm=b"md5", _hash=md5): """ L{calcResponse} accepts the C{'md5'} algorithm and returns an MD5 hash of its parameters, excluding the nonce count, client nonce, and QoP value if the nonce count and client nonce are L{None} """ hashA1 = b"abc123" hashA2 = b"789xyz" nonce = b"lmnopq" response = hashA1 + b":" + nonce + b":" + hashA2 expected = hexlify(_hash(response).digest()) digest = calcResponse(hashA1, hashA2, _algorithm, nonce, None, None, None) self.assertEqual(expected, digest) def test_MD5SessionHashResponse(self): """ L{calcResponse} accepts the C{'md5-sess'} algorithm and returns an MD5 hash of its parameters, excluding the nonce count, client nonce, and QoP value if the nonce count and client nonce are L{None} """ self.test_MD5HashResponse(b"md5-sess") def test_SHAHashResponse(self): """ L{calcResponse} accepts the C{'sha'} algorithm and returns a SHA hash of its parameters, excluding the nonce count, client nonce, and QoP value if the nonce count and client nonce are L{None} """ self.test_MD5HashResponse(b"sha", sha1) def test_MD5HashResponseExtra(self, _algorithm=b"md5", _hash=md5): """ L{calcResponse} accepts the C{'md5'} algorithm and returns an MD5 hash of its parameters, including the nonce count, client nonce, and QoP value if they are specified. """ hashA1 = b"abc123" hashA2 = b"789xyz" nonce = b"lmnopq" nonceCount = b"00000004" clientNonce = b"abcxyz123" qop = b"auth" response = ( hashA1 + b":" + nonce + b":" + nonceCount + b":" + clientNonce + b":" + qop + b":" + hashA2 ) expected = hexlify(_hash(response).digest()) digest = calcResponse( hashA1, hashA2, _algorithm, nonce, nonceCount, clientNonce, qop ) self.assertEqual(expected, digest) def test_MD5SessionHashResponseExtra(self): """ L{calcResponse} accepts the C{'md5-sess'} algorithm and returns an MD5 hash of its parameters, including the nonce count, client nonce, and QoP value if they are specified. """ self.test_MD5HashResponseExtra(b"md5-sess") def test_SHAHashResponseExtra(self): """ L{calcResponse} accepts the C{'sha'} algorithm and returns a SHA hash of its parameters, including the nonce count, client nonce, and QoP value if they are specified. """ self.test_MD5HashResponseExtra(b"sha", sha1) def formatResponse(self, quotes=True, **kw): """ Format all given keyword arguments and their values suitably for use as the value of an HTTP header. @types quotes: C{bool} @param quotes: A flag indicating whether to quote the values of each field in the response. @param **kw: Keywords and C{bytes} values which will be treated as field name/value pairs to include in the result. @rtype: C{bytes} @return: The given fields formatted for use as an HTTP header value. """ if "username" not in kw: kw["username"] = self.username if "realm" not in kw: kw["realm"] = self.realm if "algorithm" not in kw: kw["algorithm"] = self.algorithm if "qop" not in kw: kw["qop"] = self.qop if "cnonce" not in kw: kw["cnonce"] = self.cnonce if "uri" not in kw: kw["uri"] = self.uri if quotes: quote = b'"' else: quote = b"" return b", ".join( [ b"".join((networkString(k), b"=", quote, v, quote)) for (k, v) in kw.items() if v is not None ] ) def getDigestResponse(self, challenge, ncount): """ Calculate the response for the given challenge """ nonce = challenge.get("nonce") algo = challenge.get("algorithm").lower() qop = challenge.get("qop") ha1 = calcHA1( algo, self.username, self.realm, self.password, nonce, self.cnonce ) ha2 = calcHA2(algo, b"GET", self.uri, qop, None) expected = calcResponse(ha1, ha2, algo, nonce, ncount, self.cnonce, qop) return expected def test_response(self, quotes=True): """ L{DigestCredentialFactory.decode} accepts a digest challenge response and parses it into an L{IUsernameHashedPassword} provider. """ challenge = self.credentialFactory.getChallenge(self.clientAddress.host) nc = b"00000001" clientResponse = self.formatResponse( quotes=quotes, nonce=challenge["nonce"], response=self.getDigestResponse(challenge, nc), nc=nc, opaque=challenge["opaque"], ) creds = self.credentialFactory.decode( clientResponse, self.method, self.clientAddress.host ) self.assertTrue(creds.checkPassword(self.password)) self.assertFalse(creds.checkPassword(self.password + b"wrong")) def test_responseWithoutQuotes(self): """ L{DigestCredentialFactory.decode} accepts a digest challenge response which does not quote the values of its fields and parses it into an L{IUsernameHashedPassword} provider in the same way it would a response which included quoted field values. """ self.test_response(False) def test_responseWithCommaURI(self): """ L{DigestCredentialFactory.decode} accepts a digest challenge response which quotes the values of its fields and includes a C{b","} in the URI field. """ self.uri = b"/some,path/" self.test_response(True) def test_caseInsensitiveAlgorithm(self): """ The case of the algorithm value in the response is ignored when checking the credentials. """ self.algorithm = b"MD5" self.test_response() def test_md5DefaultAlgorithm(self): """ The algorithm defaults to MD5 if it is not supplied in the response. """ self.algorithm = None self.test_response() def test_responseWithoutClientIP(self): """ L{DigestCredentialFactory.decode} accepts a digest challenge response even if the client address it is passed is L{None}. """ challenge = self.credentialFactory.getChallenge(None) nc = b"00000001" clientResponse = self.formatResponse( nonce=challenge["nonce"], response=self.getDigestResponse(challenge, nc), nc=nc, opaque=challenge["opaque"], ) creds = self.credentialFactory.decode(clientResponse, self.method, None) self.assertTrue(creds.checkPassword(self.password)) self.assertFalse(creds.checkPassword(self.password + b"wrong")) def test_multiResponse(self): """ L{DigestCredentialFactory.decode} handles multiple responses to a single challenge. """ challenge = self.credentialFactory.getChallenge(self.clientAddress.host) nc = b"00000001" clientResponse = self.formatResponse( nonce=challenge["nonce"], response=self.getDigestResponse(challenge, nc), nc=nc, opaque=challenge["opaque"], ) creds = self.credentialFactory.decode( clientResponse, self.method, self.clientAddress.host ) self.assertTrue(creds.checkPassword(self.password)) self.assertFalse(creds.checkPassword(self.password + b"wrong")) nc = b"00000002" clientResponse = self.formatResponse( nonce=challenge["nonce"], response=self.getDigestResponse(challenge, nc), nc=nc, opaque=challenge["opaque"], ) creds = self.credentialFactory.decode( clientResponse, self.method, self.clientAddress.host ) self.assertTrue(creds.checkPassword(self.password)) self.assertFalse(creds.checkPassword(self.password + b"wrong")) def test_failsWithDifferentMethod(self): """ L{DigestCredentialFactory.decode} returns an L{IUsernameHashedPassword} provider which rejects a correct password for the given user if the challenge response request is made using a different HTTP method than was used to request the initial challenge. """ challenge = self.credentialFactory.getChallenge(self.clientAddress.host) nc = b"00000001" clientResponse = self.formatResponse( nonce=challenge["nonce"], response=self.getDigestResponse(challenge, nc), nc=nc, opaque=challenge["opaque"], ) creds = self.credentialFactory.decode( clientResponse, b"POST", self.clientAddress.host ) self.assertFalse(creds.checkPassword(self.password)) self.assertFalse(creds.checkPassword(self.password + b"wrong")) def test_noUsername(self): """ L{DigestCredentialFactory.decode} raises L{LoginFailed} if the response has no username field or if the username field is empty. """ # Check for no username e = self.assertRaises( LoginFailed, self.credentialFactory.decode, self.formatResponse(username=None), self.method, self.clientAddress.host, ) self.assertEqual(str(e), "Invalid response, no username given.") # Check for an empty username e = self.assertRaises( LoginFailed, self.credentialFactory.decode, self.formatResponse(username=b""), self.method, self.clientAddress.host, ) self.assertEqual(str(e), "Invalid response, no username given.") def test_noNonce(self): """ L{DigestCredentialFactory.decode} raises L{LoginFailed} if the response has no nonce. """ e = self.assertRaises( LoginFailed, self.credentialFactory.decode, self.formatResponse(opaque=b"abc123"), self.method, self.clientAddress.host, ) self.assertEqual(str(e), "Invalid response, no nonce given.") def test_noOpaque(self): """ L{DigestCredentialFactory.decode} raises L{LoginFailed} if the response has no opaque. """ e = self.assertRaises( LoginFailed, self.credentialFactory.decode, self.formatResponse(), self.method, self.clientAddress.host, ) self.assertEqual(str(e), "Invalid response, no opaque given.") def test_checkHash(self): """ L{DigestCredentialFactory.decode} returns an L{IUsernameDigestHash} provider which can verify a hash of the form 'username:realm:password'. """ challenge = self.credentialFactory.getChallenge(self.clientAddress.host) nc = b"00000001" clientResponse = self.formatResponse( nonce=challenge["nonce"], response=self.getDigestResponse(challenge, nc), nc=nc, opaque=challenge["opaque"], ) creds = self.credentialFactory.decode( clientResponse, self.method, self.clientAddress.host ) self.assertTrue(verifyObject(IUsernameDigestHash, creds)) cleartext = self.username + b":" + self.realm + b":" + self.password hash = md5(cleartext) self.assertTrue(creds.checkHash(hexlify(hash.digest()))) hash.update(b"wrong") self.assertFalse(creds.checkHash(hexlify(hash.digest()))) def test_invalidOpaque(self): """ L{DigestCredentialFactory.decode} raises L{LoginFailed} when the opaque value does not contain all the required parts. """ credentialFactory = FakeDigestCredentialFactory(self.algorithm, self.realm) challenge = credentialFactory.getChallenge(self.clientAddress.host) exc = self.assertRaises( LoginFailed, credentialFactory._verifyOpaque, b"badOpaque", challenge["nonce"], self.clientAddress.host, ) self.assertEqual(str(exc), "Invalid response, invalid opaque value") badOpaque = b"foo-" + b64encode(b"nonce,clientip") exc = self.assertRaises( LoginFailed, credentialFactory._verifyOpaque, badOpaque, challenge["nonce"], self.clientAddress.host, ) self.assertEqual(str(exc), "Invalid response, invalid opaque value") exc = self.assertRaises( LoginFailed, credentialFactory._verifyOpaque, b"", challenge["nonce"], self.clientAddress.host, ) self.assertEqual(str(exc), "Invalid response, invalid opaque value") badOpaque = b"foo-" + b64encode( b",".join( (challenge["nonce"], networkString(self.clientAddress.host), b"foobar") ) ) exc = self.assertRaises( LoginFailed, credentialFactory._verifyOpaque, badOpaque, challenge["nonce"], self.clientAddress.host, ) self.assertEqual(str(exc), "Invalid response, invalid opaque/time values") def test_incompatibleNonce(self): """ L{DigestCredentialFactory.decode} raises L{LoginFailed} when the given nonce from the response does not match the nonce encoded in the opaque. """ credentialFactory = FakeDigestCredentialFactory(self.algorithm, self.realm) challenge = credentialFactory.getChallenge(self.clientAddress.host) badNonceOpaque = credentialFactory._generateOpaque( b"1234567890", self.clientAddress.host ) exc = self.assertRaises( LoginFailed, credentialFactory._verifyOpaque, badNonceOpaque, challenge["nonce"], self.clientAddress.host, ) self.assertEqual(str(exc), "Invalid response, incompatible opaque/nonce values") exc = self.assertRaises( LoginFailed, credentialFactory._verifyOpaque, badNonceOpaque, b"", self.clientAddress.host, ) self.assertEqual(str(exc), "Invalid response, incompatible opaque/nonce values") def test_incompatibleClientIP(self): """ L{DigestCredentialFactory.decode} raises L{LoginFailed} when the request comes from a client IP other than what is encoded in the opaque. """ credentialFactory = FakeDigestCredentialFactory(self.algorithm, self.realm) challenge = credentialFactory.getChallenge(self.clientAddress.host) badAddress = "10.0.0.1" # Sanity check self.assertNotEqual(self.clientAddress.host, badAddress) badNonceOpaque = credentialFactory._generateOpaque( challenge["nonce"], badAddress ) self.assertRaises( LoginFailed, credentialFactory._verifyOpaque, badNonceOpaque, challenge["nonce"], self.clientAddress.host, ) def test_oldNonce(self): """ L{DigestCredentialFactory.decode} raises L{LoginFailed} when the given opaque is older than C{DigestCredentialFactory.CHALLENGE_LIFETIME_SECS} """ credentialFactory = FakeDigestCredentialFactory(self.algorithm, self.realm) challenge = credentialFactory.getChallenge(self.clientAddress.host) key = b",".join( (challenge["nonce"], networkString(self.clientAddress.host), b"-137876876") ) digest = hexlify(md5(key + credentialFactory.privateKey).digest()) ekey = b64encode(key) oldNonceOpaque = b"-".join((digest, ekey.strip(b"\n"))) self.assertRaises( LoginFailed, credentialFactory._verifyOpaque, oldNonceOpaque, challenge["nonce"], self.clientAddress.host, ) def test_mismatchedOpaqueChecksum(self): """ L{DigestCredentialFactory.decode} raises L{LoginFailed} when the opaque checksum fails verification. """ credentialFactory = FakeDigestCredentialFactory(self.algorithm, self.realm) challenge = credentialFactory.getChallenge(self.clientAddress.host) key = b",".join( (challenge["nonce"], networkString(self.clientAddress.host), b"0") ) digest = hexlify(md5(key + b"this is not the right pkey").digest()) badChecksum = b"-".join((digest, b64encode(key))) self.assertRaises( LoginFailed, credentialFactory._verifyOpaque, badChecksum, challenge["nonce"], self.clientAddress.host, ) def test_incompatibleCalcHA1Options(self): """ L{calcHA1} raises L{TypeError} when any of the pszUsername, pszRealm, or pszPassword arguments are specified with the preHA1 keyword argument. """ arguments = ( (b"user", b"realm", b"password", b"preHA1"), (None, b"realm", None, b"preHA1"), (None, None, b"password", b"preHA1"), ) for pszUsername, pszRealm, pszPassword, preHA1 in arguments: self.assertRaises( TypeError, calcHA1, b"md5", pszUsername, pszRealm, pszPassword, b"nonce", b"cnonce", preHA1=preHA1, ) def test_noNewlineOpaque(self): """ L{DigestCredentialFactory._generateOpaque} returns a value without newlines, regardless of the length of the nonce. """ opaque = self.credentialFactory._generateOpaque(b"long nonce " * 10, None) self.assertNotIn(b"\n", opaque) PK Mb�Z���Me e cred/test/test_strcred.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ L{twisted.cred.strcred}. """ import os from io import StringIO from typing import Sequence, Type from unittest import skipIf from zope.interface import Interface from twisted import plugin from twisted.cred import checkers, credentials, error, strcred from twisted.plugins import cred_anonymous, cred_file, cred_unix from twisted.python import usage from twisted.python.fakepwd import UserDatabase from twisted.python.filepath import FilePath from twisted.python.reflect import requireModule from twisted.trial.unittest import TestCase crypt = requireModule("crypt") pwd = requireModule("pwd") spwd = requireModule("spwd") def getInvalidAuthType(): """ Helper method to produce an auth type that doesn't exist. """ invalidAuthType = "ThisPluginDoesNotExist" while invalidAuthType in [ factory.authType for factory in strcred.findCheckerFactories() ]: invalidAuthType += "_" return invalidAuthType class PublicAPITests(TestCase): def test_emptyDescription(self): """ The description string cannot be empty. """ iat = getInvalidAuthType() self.assertRaises(strcred.InvalidAuthType, strcred.makeChecker, iat) self.assertRaises(strcred.InvalidAuthType, strcred.findCheckerFactory, iat) def test_invalidAuthType(self): """ An unrecognized auth type raises an exception. """ iat = getInvalidAuthType() self.assertRaises(strcred.InvalidAuthType, strcred.makeChecker, iat) self.assertRaises(strcred.InvalidAuthType, strcred.findCheckerFactory, iat) class StrcredFunctionsTests(TestCase): def test_findCheckerFactories(self): """ L{strcred.findCheckerFactories} returns all available plugins. """ availablePlugins = list(strcred.findCheckerFactories()) for plg in plugin.getPlugins(strcred.ICheckerFactory): self.assertIn(plg, availablePlugins) def test_findCheckerFactory(self): """ L{strcred.findCheckerFactory} returns the first plugin available for a given authentication type. """ self.assertIdentical( strcred.findCheckerFactory("file"), cred_file.theFileCheckerFactory ) class MemoryCheckerTests(TestCase): def setUp(self): self.admin = credentials.UsernamePassword("admin", "asdf") self.alice = credentials.UsernamePassword("alice", "foo") self.badPass = credentials.UsernamePassword("alice", "foobar") self.badUser = credentials.UsernamePassword("x", "yz") self.checker = strcred.makeChecker("memory:admin:asdf:alice:foo") def test_isChecker(self): """ Verifies that strcred.makeChecker('memory') returns an object that implements the L{ICredentialsChecker} interface. """ self.assertTrue(checkers.ICredentialsChecker.providedBy(self.checker)) self.assertIn(credentials.IUsernamePassword, self.checker.credentialInterfaces) def test_badFormatArgString(self): """ An argument string which does not contain user:pass pairs (i.e., an odd number of ':' characters) raises an exception. """ self.assertRaises( strcred.InvalidAuthArgumentString, strcred.makeChecker, "memory:a:b:c" ) def test_memoryCheckerSucceeds(self): """ The checker works with valid credentials. """ def _gotAvatar(username): self.assertEqual(username, self.admin.username) return self.checker.requestAvatarId(self.admin).addCallback(_gotAvatar) def test_memoryCheckerFailsUsername(self): """ The checker fails with an invalid username. """ return self.assertFailure( self.checker.requestAvatarId(self.badUser), error.UnauthorizedLogin ) def test_memoryCheckerFailsPassword(self): """ The checker fails with an invalid password. """ return self.assertFailure( self.checker.requestAvatarId(self.badPass), error.UnauthorizedLogin ) class AnonymousCheckerTests(TestCase): def test_isChecker(self): """ Verifies that strcred.makeChecker('anonymous') returns an object that implements the L{ICredentialsChecker} interface. """ checker = strcred.makeChecker("anonymous") self.assertTrue(checkers.ICredentialsChecker.providedBy(checker)) self.assertIn(credentials.IAnonymous, checker.credentialInterfaces) def testAnonymousAccessSucceeds(self): """ We can log in anonymously using this checker. """ checker = strcred.makeChecker("anonymous") request = checker.requestAvatarId(credentials.Anonymous()) def _gotAvatar(avatar): self.assertIdentical(checkers.ANONYMOUS, avatar) return request.addCallback(_gotAvatar) @skipIf(not pwd, "Required module not available: pwd") @skipIf(not crypt, "Required module not available: crypt") @skipIf(not spwd, "Required module not available: spwd") class UnixCheckerTests(TestCase): users = { "admin": "asdf", "alice": "foo", } def _spwd_getspnam(self, username): return spwd.struct_spwd( ( username, crypt.crypt(self.users[username], "F/"), 0, 0, 99999, 7, -1, -1, -1, ) ) def setUp(self): self.admin = credentials.UsernamePassword("admin", "asdf") self.alice = credentials.UsernamePassword("alice", "foo") self.badPass = credentials.UsernamePassword("alice", "foobar") self.badUser = credentials.UsernamePassword("x", "yz") self.checker = strcred.makeChecker("unix") self.adminBytes = credentials.UsernamePassword(b"admin", b"asdf") self.aliceBytes = credentials.UsernamePassword(b"alice", b"foo") self.badPassBytes = credentials.UsernamePassword(b"alice", b"foobar") self.badUserBytes = credentials.UsernamePassword(b"x", b"yz") self.checkerBytes = strcred.makeChecker("unix") # Hack around the pwd and spwd modules, since we can't really # go about reading your /etc/passwd or /etc/shadow files if pwd: database = UserDatabase() for username, password in self.users.items(): database.addUser( username, crypt.crypt(password, "F/"), 1000, 1000, username, "/home/" + username, "/bin/sh", ) self.patch(pwd, "getpwnam", database.getpwnam) if spwd: self.patch(spwd, "getspnam", self._spwd_getspnam) def test_isChecker(self): """ Verifies that strcred.makeChecker('unix') returns an object that implements the L{ICredentialsChecker} interface. """ self.assertTrue(checkers.ICredentialsChecker.providedBy(self.checker)) self.assertIn(credentials.IUsernamePassword, self.checker.credentialInterfaces) self.assertTrue(checkers.ICredentialsChecker.providedBy(self.checkerBytes)) self.assertIn( credentials.IUsernamePassword, self.checkerBytes.credentialInterfaces ) def test_unixCheckerSucceeds(self): """ The checker works with valid credentials. """ def _gotAvatar(username): self.assertEqual(username, self.admin.username) return self.checker.requestAvatarId(self.admin).addCallback(_gotAvatar) def test_unixCheckerSucceedsBytes(self): """ The checker works with valid L{bytes} credentials. """ def _gotAvatar(username): self.assertEqual(username, self.adminBytes.username.decode("utf-8")) return self.checkerBytes.requestAvatarId(self.adminBytes).addCallback( _gotAvatar ) def test_unixCheckerFailsUsername(self): """ The checker fails with an invalid username. """ return self.assertFailure( self.checker.requestAvatarId(self.badUser), error.UnauthorizedLogin ) def test_unixCheckerFailsUsernameBytes(self): """ The checker fails with an invalid L{bytes} username. """ return self.assertFailure( self.checkerBytes.requestAvatarId(self.badUserBytes), error.UnauthorizedLogin, ) def test_unixCheckerFailsPassword(self): """ The checker fails with an invalid password. """ return self.assertFailure( self.checker.requestAvatarId(self.badPass), error.UnauthorizedLogin ) def test_unixCheckerFailsPasswordBytes(self): """ The checker fails with an invalid L{bytes} password. """ return self.assertFailure( self.checkerBytes.requestAvatarId(self.badPassBytes), error.UnauthorizedLogin, ) @skipIf(not crypt, "Required module is unavailable: crypt") class CryptTests(TestCase): """ L{crypt} has functions for encrypting password. """ def test_verifyCryptedPassword(self): """ L{cred_unix.verifyCryptedPassword} """ password = "sample password ^%$" for salt in (None, "ab"): try: cryptedCorrect = crypt.crypt(password, salt) if isinstance(cryptedCorrect, bytes): cryptedCorrect = cryptedCorrect.decode("utf-8") except TypeError: # Older Python versions would throw a TypeError if # a value of None was is used for the salt. # Newer Python versions allow it. continue cryptedIncorrect = "$1x1234" self.assertTrue(cred_unix.verifyCryptedPassword(cryptedCorrect, password)) self.assertFalse( cred_unix.verifyCryptedPassword(cryptedIncorrect, password) ) # Python 3.3+ has crypt.METHOD_*, but not all # platforms implement all methods. for method in ("METHOD_SHA512", "METHOD_SHA256", "METHOD_MD5", "METHOD_CRYPT"): cryptMethod = getattr(crypt, method, None) if not cryptMethod: continue password = "interesting password xyz" crypted = crypt.crypt(password, cryptMethod) if isinstance(crypted, bytes): crypted = crypted.decode("utf-8") incorrectCrypted = crypted + "blahfooincorrect" result = cred_unix.verifyCryptedPassword(crypted, password) self.assertTrue(result) # Try to pass in bytes result = cred_unix.verifyCryptedPassword( crypted.encode("utf-8"), password.encode("utf-8") ) self.assertTrue(result) result = cred_unix.verifyCryptedPassword(incorrectCrypted, password) self.assertFalse(result) # Try to pass in bytes result = cred_unix.verifyCryptedPassword( incorrectCrypted.encode("utf-8"), password.encode("utf-8") ) self.assertFalse(result) def test_verifyCryptedPasswordOSError(self): """ L{cred_unix.verifyCryptedPassword} when OSError is raised """ def mockCrypt(password, salt): raise OSError("") password = "sample password ^%$" cryptedCorrect = crypt.crypt(password, "ab") self.patch(crypt, "crypt", mockCrypt) self.assertFalse(cred_unix.verifyCryptedPassword(cryptedCorrect, password)) class FileDBCheckerTests(TestCase): """ C{--auth=file:...} file checker. """ def setUp(self): self.admin = credentials.UsernamePassword(b"admin", b"asdf") self.alice = credentials.UsernamePassword(b"alice", b"foo") self.badPass = credentials.UsernamePassword(b"alice", b"foobar") self.badUser = credentials.UsernamePassword(b"x", b"yz") self.filename = self.mktemp() FilePath(self.filename).setContent(b"admin:asdf\nalice:foo\n") self.checker = strcred.makeChecker("file:" + self.filename) def _fakeFilename(self): filename = "/DoesNotExist" while os.path.exists(filename): filename += "_" return filename def test_isChecker(self): """ Verifies that strcred.makeChecker('memory') returns an object that implements the L{ICredentialsChecker} interface. """ self.assertTrue(checkers.ICredentialsChecker.providedBy(self.checker)) self.assertIn(credentials.IUsernamePassword, self.checker.credentialInterfaces) def test_fileCheckerSucceeds(self): """ The checker works with valid credentials. """ def _gotAvatar(username): self.assertEqual(username, self.admin.username) return self.checker.requestAvatarId(self.admin).addCallback(_gotAvatar) def test_fileCheckerFailsUsername(self): """ The checker fails with an invalid username. """ return self.assertFailure( self.checker.requestAvatarId(self.badUser), error.UnauthorizedLogin ) def test_fileCheckerFailsPassword(self): """ The checker fails with an invalid password. """ return self.assertFailure( self.checker.requestAvatarId(self.badPass), error.UnauthorizedLogin ) def test_failsWithEmptyFilename(self): """ An empty filename raises an error. """ self.assertRaises(ValueError, strcred.makeChecker, "file") self.assertRaises(ValueError, strcred.makeChecker, "file:") def test_warnWithBadFilename(self): """ When the file auth plugin is given a file that doesn't exist, it should produce a warning. """ oldOutput = cred_file.theFileCheckerFactory.errorOutput newOutput = StringIO() cred_file.theFileCheckerFactory.errorOutput = newOutput strcred.makeChecker("file:" + self._fakeFilename()) cred_file.theFileCheckerFactory.errorOutput = oldOutput self.assertIn(cred_file.invalidFileWarning, newOutput.getvalue()) @skipIf(not requireModule("cryptography"), "cryptography is not available") @skipIf(not requireModule("pyasn1"), "pyasn1 is not available") class SSHCheckerTests(TestCase): """ Tests for the C{--auth=sshkey:...} checker. The majority of the tests for the ssh public key database checker are in L{twisted.conch.test.test_checkers.SSHPublicKeyCheckerTestCase}. """ def test_isChecker(self): """ Verifies that strcred.makeChecker('sshkey') returns an object that implements the L{ICredentialsChecker} interface. """ sshChecker = strcred.makeChecker("sshkey") self.assertTrue(checkers.ICredentialsChecker.providedBy(sshChecker)) self.assertIn(credentials.ISSHPrivateKey, sshChecker.credentialInterfaces) class DummyOptions(usage.Options, strcred.AuthOptionMixin): """ Simple options for testing L{strcred.AuthOptionMixin}. """ class CheckerOptionsTests(TestCase): def test_createsList(self): """ The C{--auth} command line creates a list in the Options instance and appends values to it. """ options = DummyOptions() options.parseOptions(["--auth", "memory"]) self.assertEqual(len(options["credCheckers"]), 1) options = DummyOptions() options.parseOptions(["--auth", "memory", "--auth", "memory"]) self.assertEqual(len(options["credCheckers"]), 2) def test_invalidAuthError(self): """ The C{--auth} command line raises an exception when it gets a parameter it doesn't understand. """ options = DummyOptions() # If someone adds a 'ThisPluginDoesNotExist' then this unit # test should still run. invalidParameter = getInvalidAuthType() self.assertRaises( usage.UsageError, options.parseOptions, ["--auth", invalidParameter] ) self.assertRaises( usage.UsageError, options.parseOptions, ["--help-auth-type", invalidParameter], ) def test_createsDictionary(self): """ The C{--auth} command line creates a dictionary mapping supported interfaces to the list of credentials checkers that support it. """ options = DummyOptions() options.parseOptions(["--auth", "memory", "--auth", "anonymous"]) chd = options["credInterfaces"] self.assertEqual(len(chd[credentials.IAnonymous]), 1) self.assertEqual(len(chd[credentials.IUsernamePassword]), 1) chdAnonymous = chd[credentials.IAnonymous][0] chdUserPass = chd[credentials.IUsernamePassword][0] self.assertTrue(checkers.ICredentialsChecker.providedBy(chdAnonymous)) self.assertTrue(checkers.ICredentialsChecker.providedBy(chdUserPass)) self.assertIn(credentials.IAnonymous, chdAnonymous.credentialInterfaces) self.assertIn(credentials.IUsernamePassword, chdUserPass.credentialInterfaces) def test_credInterfacesProvidesLists(self): """ When two C{--auth} arguments are passed along which support the same interface, a list with both is created. """ options = DummyOptions() options.parseOptions(["--auth", "memory", "--auth", "unix"]) self.assertEqual( options["credCheckers"], options["credInterfaces"][credentials.IUsernamePassword], ) def test_listDoesNotDisplayDuplicates(self): """ The list for C{--help-auth} does not duplicate items. """ authTypes = [] options = DummyOptions() for cf in options._checkerFactoriesForOptHelpAuth(): self.assertNotIn(cf.authType, authTypes) authTypes.append(cf.authType) def test_displaysListCorrectly(self): """ The C{--help-auth} argument correctly displays all available authentication plugins, then exits. """ newStdout = StringIO() options = DummyOptions() options.authOutput = newStdout self.assertRaises(SystemExit, options.parseOptions, ["--help-auth"]) for checkerFactory in strcred.findCheckerFactories(): self.assertIn(checkerFactory.authType, newStdout.getvalue()) def test_displaysHelpCorrectly(self): """ The C{--help-auth-for} argument will correctly display the help file for a particular authentication plugin. """ newStdout = StringIO() options = DummyOptions() options.authOutput = newStdout self.assertRaises( SystemExit, options.parseOptions, ["--help-auth-type", "file"] ) for line in cred_file.theFileCheckerFactory.authHelp: if line.strip(): self.assertIn(line.strip(), newStdout.getvalue()) def test_unexpectedException(self): """ When the checker specified by C{--auth} raises an unexpected error, it should be caught and re-raised within a L{usage.UsageError}. """ options = DummyOptions() err = self.assertRaises( usage.UsageError, options.parseOptions, ["--auth", "file"] ) self.assertEqual(str(err), "Unexpected error: 'file' requires a filename") class OptionsForUsernamePassword(usage.Options, strcred.AuthOptionMixin): supportedInterfaces = (credentials.IUsernamePassword,) class OptionsForUsernameHashedPassword(usage.Options, strcred.AuthOptionMixin): supportedInterfaces = (credentials.IUsernameHashedPassword,) class OptionsSupportsAllInterfaces(usage.Options, strcred.AuthOptionMixin): supportedInterfaces = None class OptionsSupportsNoInterfaces(usage.Options, strcred.AuthOptionMixin): supportedInterfaces: Sequence[Type[Interface]] = [] class LimitingInterfacesTests(TestCase): """ Tests functionality that allows an application to limit the credential interfaces it can support. For the purposes of this test, we use IUsernameHashedPassword, although this will never really be used by the command line. (I have, to date, not thought of a half-decent way for a user to specify a hash algorithm via the command-line. Nor do I think it's very useful.) I should note that, at first, this test is counter-intuitive, because we're using the checker with a pre-defined hash function as the 'bad' checker. See the documentation for L{twisted.cred.checkers.FilePasswordDB.hash} for more details. """ def setUp(self): self.filename = self.mktemp() with open(self.filename, "wb") as f: f.write(b"admin:asdf\nalice:foo\n") self.goodChecker = checkers.FilePasswordDB(self.filename) self.badChecker = checkers.FilePasswordDB(self.filename, hash=self._hash) self.anonChecker = checkers.AllowAnonymousAccess() def _hash(self, networkUsername, networkPassword, storedPassword): """ A dumb hash that doesn't really do anything. """ return networkPassword def test_supportsInterface(self): """ The supportsInterface method behaves appropriately. """ options = OptionsForUsernamePassword() self.assertTrue(options.supportsInterface(credentials.IUsernamePassword)) self.assertFalse(options.supportsInterface(credentials.IAnonymous)) self.assertRaises( strcred.UnsupportedInterfaces, options.addChecker, self.anonChecker ) def test_supportsAllInterfaces(self): """ The supportsInterface method behaves appropriately when the supportedInterfaces attribute is None. """ options = OptionsSupportsAllInterfaces() self.assertTrue(options.supportsInterface(credentials.IUsernamePassword)) self.assertTrue(options.supportsInterface(credentials.IAnonymous)) def test_supportsCheckerFactory(self): """ The supportsCheckerFactory method behaves appropriately. """ options = OptionsForUsernamePassword() fileCF = cred_file.theFileCheckerFactory anonCF = cred_anonymous.theAnonymousCheckerFactory self.assertTrue(options.supportsCheckerFactory(fileCF)) self.assertFalse(options.supportsCheckerFactory(anonCF)) def test_canAddSupportedChecker(self): """ When addChecker is called with a checker that implements at least one of the interfaces our application supports, it is successful. """ options = OptionsForUsernamePassword() options.addChecker(self.goodChecker) iface = options.supportedInterfaces[0] # Test that we did get IUsernamePassword self.assertIdentical(options["credInterfaces"][iface][0], self.goodChecker) self.assertIdentical(options["credCheckers"][0], self.goodChecker) # Test that we didn't get IUsernameHashedPassword self.assertEqual(len(options["credInterfaces"][iface]), 1) self.assertEqual(len(options["credCheckers"]), 1) def test_failOnAddingUnsupportedChecker(self): """ When addChecker is called with a checker that does not implement any supported interfaces, it fails. """ options = OptionsForUsernameHashedPassword() self.assertRaises( strcred.UnsupportedInterfaces, options.addChecker, self.badChecker ) def test_unsupportedInterfaceError(self): """ The C{--auth} command line raises an exception when it gets a checker we don't support. """ options = OptionsSupportsNoInterfaces() authType = cred_anonymous.theAnonymousCheckerFactory.authType self.assertRaises(usage.UsageError, options.parseOptions, ["--auth", authType]) def test_helpAuthLimitsOutput(self): """ C{--help-auth} will only list checkers that purport to supply at least one of the credential interfaces our application can use. """ options = OptionsForUsernamePassword() for factory in options._checkerFactoriesForOptHelpAuth(): invalid = True for interface in factory.credentialInterfaces: if options.supportsInterface(interface): invalid = False if invalid: raise strcred.UnsupportedInterfaces() def test_helpAuthTypeLimitsOutput(self): """ C{--help-auth-type} will display a warning if you get help for an authType that does not supply at least one of the credential interfaces our application can use. """ options = OptionsForUsernamePassword() # Find an interface that we can use for our test invalidFactory = None for factory in strcred.findCheckerFactories(): if not options.supportsCheckerFactory(factory): invalidFactory = factory break self.assertNotIdentical(invalidFactory, None) # Capture output and make sure the warning is there newStdout = StringIO() options.authOutput = newStdout self.assertRaises( SystemExit, options.parseOptions, ["--help-auth-type", "anonymous"] ) self.assertIn(strcred.notSupportedWarning, newStdout.getvalue()) PK Mb�Z[YLe� � cred/test/test_cramauth.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.cred}'s implementation of CRAM-MD5. """ import hashlib from binascii import hexlify from hmac import HMAC from twisted.cred.credentials import CramMD5Credentials, IUsernameHashedPassword from twisted.trial.unittest import TestCase class CramMD5CredentialsTests(TestCase): """ Tests for L{CramMD5Credentials}. """ def test_idempotentChallenge(self): """ The same L{CramMD5Credentials} will always provide the same challenge, no matter how many times it is called. """ c = CramMD5Credentials() chal = c.getChallenge() self.assertEqual(chal, c.getChallenge()) def test_checkPassword(self): """ When a valid response (which is a hex digest of the challenge that has been encrypted by the user's shared secret) is set on the L{CramMD5Credentials} that created the challenge, and C{checkPassword} is called with the user's shared secret, it will return L{True}. """ c = CramMD5Credentials() chal = c.getChallenge() c.response = hexlify(HMAC(b"secret", chal, digestmod=hashlib.md5).digest()) self.assertTrue(c.checkPassword(b"secret")) def test_noResponse(self): """ When there is no response set, calling C{checkPassword} will return L{False}. """ c = CramMD5Credentials() self.assertFalse(c.checkPassword(b"secret")) def test_wrongPassword(self): """ When an invalid response is set on the L{CramMD5Credentials} (one that is not the hex digest of the challenge, encrypted with the user's shared secret) and C{checkPassword} is called with the user's correct shared secret, it will return L{False}. """ c = CramMD5Credentials() chal = c.getChallenge() c.response = hexlify( HMAC(b"thewrongsecret", chal, digestmod=hashlib.md5).digest() ) self.assertFalse(c.checkPassword(b"secret")) def test_setResponse(self): """ When C{setResponse} is called with a string that is the username and the hashed challenge separated with a space, they will be set on the L{CramMD5Credentials}. """ c = CramMD5Credentials() chal = c.getChallenge() c.setResponse( b" ".join( ( b"squirrel", hexlify(HMAC(b"supersecret", chal, digestmod=hashlib.md5).digest()), ) ) ) self.assertTrue(c.checkPassword(b"supersecret")) self.assertEqual(c.username, b"squirrel") def test_interface(self): """ L{CramMD5Credentials} implements the L{IUsernameHashedPassword} interface. """ self.assertTrue(IUsernameHashedPassword.implementedBy(CramMD5Credentials)) PK Mb�Z(G��� � cred/test/__init__.pynu �[��� # -*- test-case-name: twisted.cred.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Unit tests for C{twisted.cred}. """ PK Mb�Z�(1�� � cred/error.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Cred errors. """ class Unauthorized(Exception): """Standard unauthorized error.""" class LoginFailed(Exception): """ The user's request to log in failed for some reason. """ class UnauthorizedLogin(LoginFailed, Unauthorized): """The user was not authorized to log in.""" class UnhandledCredentials(LoginFailed): """A type of credentials were passed in with no knowledge of how to check them. This is a server configuration error - it means that a protocol was connected to a Portal without a CredentialChecker that can check all of its potential authentication strategies. """ class LoginDenied(LoginFailed): """ The realm rejected this login for some reason. Examples of reasons this might be raised include an avatar logging in too frequently, a quota having been fully used, or the overall server load being too high. """ PK Mb�Zh�C�. . cred/portal.pynu �[��� # -*- test-case-name: twisted.cred.test.test_cred -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ The point of integration of application and authentication. """ from zope.interface import Interface, providedBy from twisted.cred import error from twisted.internet import defer from twisted.internet.defer import maybeDeferred from twisted.python import failure, reflect class IRealm(Interface): """ The realm connects application-specific objects to the authentication system. """ def requestAvatar(avatarId, mind, *interfaces): """ Return avatar which provides one of the given interfaces. @param avatarId: a string that identifies an avatar, as returned by L{ICredentialsChecker.requestAvatarId<twisted.cred.checkers.ICredentialsChecker.requestAvatarId>} (via a Deferred). Alternatively, it may be C{twisted.cred.checkers.ANONYMOUS}. @param mind: usually None. See the description of mind in L{Portal.login}. @param interfaces: the interface(s) the returned avatar should implement, e.g. C{IMailAccount}. See the description of L{Portal.login}. @returns: a deferred which will fire a tuple of (interface, avatarAspect, logout), or the tuple itself. The interface will be one of the interfaces passed in the 'interfaces' argument. The 'avatarAspect' will implement that interface. The 'logout' object is a callable which will detach the mind from the avatar. """ class Portal: """ A mediator between clients and a realm. A portal is associated with one Realm and zero or more credentials checkers. When a login is attempted, the portal finds the appropriate credentials checker for the credentials given, invokes it, and if the credentials are valid, retrieves the appropriate avatar from the Realm. This class is not intended to be subclassed. Customization should be done in the realm object and in the credentials checker objects. """ def __init__(self, realm, checkers=()): """ Create a Portal to a L{IRealm}. """ self.realm = realm self.checkers = {} for checker in checkers: self.registerChecker(checker) def listCredentialsInterfaces(self): """ Return list of credentials interfaces that can be used to login. """ return list(self.checkers.keys()) def registerChecker(self, checker, *credentialInterfaces): if not credentialInterfaces: credentialInterfaces = checker.credentialInterfaces for credentialInterface in credentialInterfaces: self.checkers[credentialInterface] = checker def login(self, credentials, mind, *interfaces): """ @param credentials: an implementor of L{twisted.cred.credentials.ICredentials} @param mind: an object which implements a client-side interface for your particular realm. In many cases, this may be None, so if the word 'mind' confuses you, just ignore it. @param interfaces: list of interfaces for the perspective that the mind wishes to attach to. Usually, this will be only one interface, for example IMailAccount. For highly dynamic protocols, however, this may be a list like (IMailAccount, IUserChooser, IServiceInfo). To expand: if we are speaking to the system over IMAP, any information that will be relayed to the user MUST be returned as an IMailAccount implementor; IMAP clients would not be able to understand anything else. Any information about unusual status would have to be relayed as a single mail message in an otherwise-empty mailbox. However, in a web-based mail system, or a PB-based client, the ``mind'' object inside the web server (implemented with a dynamic page-viewing mechanism such as a Twisted Web Resource) or on the user's client program may be intelligent enough to respond to several ``server''-side interfaces. @return: A deferred which will fire a tuple of (interface, avatarAspect, logout). The interface will be one of the interfaces passed in the 'interfaces' argument. The 'avatarAspect' will implement that interface. The 'logout' object is a callable which will detach the mind from the avatar. It must be called when the user has conceptually disconnected from the service. Although in some cases this will not be in connectionLost (such as in a web-based session), it will always be at the end of a user's interactive session. """ for i in self.checkers: if i.providedBy(credentials): return maybeDeferred( self.checkers[i].requestAvatarId, credentials ).addCallback(self.realm.requestAvatar, mind, *interfaces) ifac = providedBy(credentials) return defer.fail( failure.Failure( error.UnhandledCredentials( "No checker for %s" % ", ".join(map(reflect.qual, ifac)) ) ) ) PK Mb�Z|��� � cred/_digest.pynu �[��� # -*- test-case-name: twisted.cred.test.test_digestauth -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Calculations for HTTP Digest authentication. @see: U{http://www.faqs.org/rfcs/rfc2617.html} """ from binascii import hexlify from hashlib import md5, sha1 # The digest math algorithms = { b"md5": md5, # md5-sess is more complicated than just another algorithm. It requires # H(A1) state to be remembered from the first WWW-Authenticate challenge # issued and re-used to process any Authorization header in response to # that WWW-Authenticate challenge. It is *not* correct to simply # recalculate H(A1) each time an Authorization header is received. Read # RFC 2617, section 3.2.2.2 and do not try to make DigestCredentialFactory # support this unless you completely understand it. -exarkun b"md5-sess": md5, b"sha": sha1, } # DigestCalcHA1 def calcHA1( pszAlg, pszUserName, pszRealm, pszPassword, pszNonce, pszCNonce, preHA1=None ): """ Compute H(A1) from RFC 2617. @param pszAlg: The name of the algorithm to use to calculate the digest. Currently supported are md5, md5-sess, and sha. @param pszUserName: The username @param pszRealm: The realm @param pszPassword: The password @param pszNonce: The nonce @param pszCNonce: The cnonce @param preHA1: If available this is a str containing a previously calculated H(A1) as a hex string. If this is given then the values for pszUserName, pszRealm, and pszPassword must be L{None} and are ignored. """ if preHA1 and (pszUserName or pszRealm or pszPassword): raise TypeError( "preHA1 is incompatible with the pszUserName, " "pszRealm, and pszPassword arguments" ) if preHA1 is None: # We need to calculate the HA1 from the username:realm:password m = algorithms[pszAlg]() m.update(pszUserName) m.update(b":") m.update(pszRealm) m.update(b":") m.update(pszPassword) HA1 = hexlify(m.digest()) else: # We were given a username:realm:password HA1 = preHA1 if pszAlg == b"md5-sess": m = algorithms[pszAlg]() m.update(HA1) m.update(b":") m.update(pszNonce) m.update(b":") m.update(pszCNonce) HA1 = hexlify(m.digest()) return HA1 def calcHA2(algo, pszMethod, pszDigestUri, pszQop, pszHEntity): """ Compute H(A2) from RFC 2617. @param algo: The name of the algorithm to use to calculate the digest. Currently supported are md5, md5-sess, and sha. @param pszMethod: The request method. @param pszDigestUri: The request URI. @param pszQop: The Quality-of-Protection value. @param pszHEntity: The hash of the entity body or L{None} if C{pszQop} is not C{'auth-int'}. @return: The hash of the A2 value for the calculation of the response digest. """ m = algorithms[algo]() m.update(pszMethod) m.update(b":") m.update(pszDigestUri) if pszQop == b"auth-int": m.update(b":") m.update(pszHEntity) return hexlify(m.digest()) def calcResponse(HA1, HA2, algo, pszNonce, pszNonceCount, pszCNonce, pszQop): """ Compute the digest for the given parameters. @param HA1: The H(A1) value, as computed by L{calcHA1}. @param HA2: The H(A2) value, as computed by L{calcHA2}. @param pszNonce: The challenge nonce. @param pszNonceCount: The (client) nonce count value for this response. @param pszCNonce: The client nonce. @param pszQop: The Quality-of-Protection value. """ m = algorithms[algo]() m.update(HA1) m.update(b":") m.update(pszNonce) m.update(b":") if pszNonceCount and pszCNonce: m.update(pszNonceCount) m.update(b":") m.update(pszCNonce) m.update(b":") m.update(pszQop) m.update(b":") m.update(HA2) respHash = hexlify(m.digest()) return respHash PK Mb�Zt%��C@ C@ cred/credentials.pynu �[��� # -*- test-case-name: twisted.cred.test.test_cred-*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module defines L{ICredentials}, an interface for objects that represent authentication credentials to provide, and also includes a number of useful implementations of that interface. """ import base64 import hmac import random import re import time from binascii import hexlify from hashlib import md5 from zope.interface import Interface, implementer from twisted.cred import error from twisted.cred._digest import calcHA1, calcHA2, calcResponse from twisted.python.compat import nativeString, networkString from twisted.python.deprecate import deprecatedModuleAttribute from twisted.python.randbytes import secureRandom from twisted.python.versions import Version class ICredentials(Interface): """ I check credentials. Implementors I{must} specify the sub-interfaces of ICredentials to which it conforms, using L{zope.interface.implementer}. """ class IUsernameDigestHash(ICredentials): """ This credential is used when a CredentialChecker has access to the hash of the username:realm:password as in an Apache .htdigest file. """ def checkHash(digestHash): """ @param digestHash: The hashed username:realm:password to check against. @return: C{True} if the credentials represented by this object match the given hash, C{False} if they do not, or a L{Deferred} which will be called back with one of these values. """ class IUsernameHashedPassword(ICredentials): """ I encapsulate a username and a hashed password. This credential is used when a hashed password is received from the party requesting authentication. CredentialCheckers which check this kind of credential must store the passwords in plaintext (or as password-equivalent hashes) form so that they can be hashed in a manner appropriate for the particular credentials class. @type username: L{bytes} @ivar username: The username associated with these credentials. """ def checkPassword(password): """ Validate these credentials against the correct password. @type password: L{bytes} @param password: The correct, plaintext password against which to check. @rtype: C{bool} or L{Deferred} @return: C{True} if the credentials represented by this object match the given password, C{False} if they do not, or a L{Deferred} which will be called back with one of these values. """ class IUsernamePassword(ICredentials): """ I encapsulate a username and a plaintext password. This encapsulates the case where the password received over the network has been hashed with the identity function (That is, not at all). The CredentialsChecker may store the password in whatever format it desires, it need only transform the stored password in a similar way before performing the comparison. @type username: L{bytes} @ivar username: The username associated with these credentials. @type password: L{bytes} @ivar password: The password associated with these credentials. """ def checkPassword(password): """ Validate these credentials against the correct password. @type password: L{bytes} @param password: The correct, plaintext password against which to check. @rtype: C{bool} or L{Deferred} @return: C{True} if the credentials represented by this object match the given password, C{False} if they do not, or a L{Deferred} which will be called back with one of these values. """ class IAnonymous(ICredentials): """ I am an explicitly anonymous request for access. @see: L{twisted.cred.checkers.AllowAnonymousAccess} """ @implementer(IUsernameHashedPassword, IUsernameDigestHash) class DigestedCredentials: """ Yet Another Simple HTTP Digest authentication scheme. """ def __init__(self, username, method, realm, fields): self.username = username self.method = method self.realm = realm self.fields = fields def checkPassword(self, password): """ Verify that the credentials represented by this object agree with the given plaintext C{password} by hashing C{password} in the same way the response hash represented by this object was generated and comparing the results. """ response = self.fields.get("response") uri = self.fields.get("uri") nonce = self.fields.get("nonce") cnonce = self.fields.get("cnonce") nc = self.fields.get("nc") algo = self.fields.get("algorithm", b"md5").lower() qop = self.fields.get("qop", b"auth") expected = calcResponse( calcHA1(algo, self.username, self.realm, password, nonce, cnonce), calcHA2(algo, self.method, uri, qop, None), algo, nonce, nc, cnonce, qop, ) return expected == response def checkHash(self, digestHash): """ Verify that the credentials represented by this object agree with the credentials represented by the I{H(A1)} given in C{digestHash}. @param digestHash: A precomputed H(A1) value based on the username, realm, and password associate with this credentials object. """ response = self.fields.get("response") uri = self.fields.get("uri") nonce = self.fields.get("nonce") cnonce = self.fields.get("cnonce") nc = self.fields.get("nc") algo = self.fields.get("algorithm", b"md5").lower() qop = self.fields.get("qop", b"auth") expected = calcResponse( calcHA1(algo, None, None, None, nonce, cnonce, preHA1=digestHash), calcHA2(algo, self.method, uri, qop, None), algo, nonce, nc, cnonce, qop, ) return expected == response class DigestCredentialFactory: """ Support for RFC2617 HTTP Digest Authentication @cvar CHALLENGE_LIFETIME_SECS: The number of seconds for which an opaque should be valid. @type privateKey: L{bytes} @ivar privateKey: A random string used for generating the secure opaque. @type algorithm: L{bytes} @param algorithm: Case insensitive string specifying the hash algorithm to use. Must be either C{'md5'} or C{'sha'}. C{'md5-sess'} is B{not} supported. @type authenticationRealm: L{bytes} @param authenticationRealm: case sensitive string that specifies the realm portion of the challenge """ _parseparts = re.compile( b"([^= ]+)" # The key b"=" # Conventional key/value separator (literal) b"(?:" # Group together a couple options b'"([^"]*)"' # A quoted string of length 0 or more b"|" # The other option in the group is coming b"([^,]+)" # An unquoted string of length 1 or more, up to a comma b")" # That non-matching group ends b",?" ) # There might be a comma at the end (none on last pair) CHALLENGE_LIFETIME_SECS = 15 * 60 # 15 minutes scheme = b"digest" def __init__(self, algorithm, authenticationRealm): self.algorithm = algorithm self.authenticationRealm = authenticationRealm self.privateKey = secureRandom(12) def getChallenge(self, address): """ Generate the challenge for use in the WWW-Authenticate header. @param address: The client address to which this challenge is being sent. @return: The L{dict} that can be used to generate a WWW-Authenticate header. """ c = self._generateNonce() o = self._generateOpaque(c, address) return { "nonce": c, "opaque": o, "qop": b"auth", "algorithm": self.algorithm, "realm": self.authenticationRealm, } def _generateNonce(self): """ Create a random value suitable for use as the nonce parameter of a WWW-Authenticate challenge. @rtype: L{bytes} """ return hexlify(secureRandom(12)) def _getTime(self): """ Parameterize the time based seed used in C{_generateOpaque} so we can deterministically unittest it's behavior. """ return time.time() def _generateOpaque(self, nonce, clientip): """ Generate an opaque to be returned to the client. This is a unique string that can be returned to us and verified. """ # Now, what we do is encode the nonce, client ip and a timestamp in the # opaque value with a suitable digest. now = b"%d" % (int(self._getTime()),) if not clientip: clientip = b"" elif isinstance(clientip, str): clientip = clientip.encode("ascii") key = b",".join((nonce, clientip, now)) digest = hexlify(md5(key + self.privateKey).digest()) ekey = base64.b64encode(key) return b"-".join((digest, ekey.replace(b"\n", b""))) def _verifyOpaque(self, opaque, nonce, clientip): """ Given the opaque and nonce from the request, as well as the client IP that made the request, verify that the opaque was generated by us. And that it's not too old. @param opaque: The opaque value from the Digest response @param nonce: The nonce value from the Digest response @param clientip: The remote IP address of the client making the request or L{None} if the request was submitted over a channel where this does not make sense. @return: C{True} if the opaque was successfully verified. @raise error.LoginFailed: if C{opaque} could not be parsed or contained the wrong values. """ # First split the digest from the key opaqueParts = opaque.split(b"-") if len(opaqueParts) != 2: raise error.LoginFailed("Invalid response, invalid opaque value") if not clientip: clientip = b"" elif isinstance(clientip, str): clientip = clientip.encode("ascii") # Verify the key key = base64.b64decode(opaqueParts[1]) keyParts = key.split(b",") if len(keyParts) != 3: raise error.LoginFailed("Invalid response, invalid opaque value") if keyParts[0] != nonce: raise error.LoginFailed( "Invalid response, incompatible opaque/nonce values" ) if keyParts[1] != clientip: raise error.LoginFailed( "Invalid response, incompatible opaque/client values" ) try: when = int(keyParts[2]) except ValueError: raise error.LoginFailed("Invalid response, invalid opaque/time values") if ( int(self._getTime()) - when > DigestCredentialFactory.CHALLENGE_LIFETIME_SECS ): raise error.LoginFailed( "Invalid response, incompatible opaque/nonce too old" ) # Verify the digest digest = hexlify(md5(key + self.privateKey).digest()) if digest != opaqueParts[0]: raise error.LoginFailed("Invalid response, invalid opaque value") return True def decode(self, response, method, host): """ Decode the given response and attempt to generate a L{DigestedCredentials} from it. @type response: L{bytes} @param response: A string of comma separated key=value pairs @type method: L{bytes} @param method: The action requested to which this response is addressed (GET, POST, INVITE, OPTIONS, etc). @type host: L{bytes} @param host: The address the request was sent from. @raise error.LoginFailed: If the response does not contain a username, a nonce, an opaque, or if the opaque is invalid. @return: L{DigestedCredentials} """ response = b" ".join(response.splitlines()) parts = self._parseparts.findall(response) auth = {} for (key, bare, quoted) in parts: value = (quoted or bare).strip() auth[nativeString(key.strip())] = value username = auth.get("username") if not username: raise error.LoginFailed("Invalid response, no username given.") if "opaque" not in auth: raise error.LoginFailed("Invalid response, no opaque given.") if "nonce" not in auth: raise error.LoginFailed("Invalid response, no nonce given.") # Now verify the nonce/opaque values for this client if self._verifyOpaque(auth.get("opaque"), auth.get("nonce"), host): return DigestedCredentials(username, method, self.authenticationRealm, auth) @implementer(IUsernameHashedPassword) class CramMD5Credentials: """ An encapsulation of some CramMD5 hashed credentials. @ivar challenge: The challenge to be sent to the client. @type challenge: L{bytes} @ivar response: The hashed response from the client. @type response: L{bytes} @ivar username: The username from the response from the client. @type username: L{bytes} or L{None} if not yet provided. """ username = None challenge = b"" response = b"" def __init__(self, host=None): self.host = host def getChallenge(self): if self.challenge: return self.challenge # The data encoded in the first ready response contains an # presumptively arbitrary string of random digits, a timestamp, and # the fully-qualified primary host name of the server. The syntax of # the unencoded form must correspond to that of an RFC 822 'msg-id' # [RFC822] as described in [POP3]. # -- RFC 2195 r = random.randrange(0x7FFFFFFF) t = time.time() self.challenge = networkString( "<%d.%d@%s>" % (r, t, nativeString(self.host) if self.host else None) ) return self.challenge def setResponse(self, response): self.username, self.response = response.split(None, 1) def moreChallenges(self): return False def checkPassword(self, password): verify = hexlify(hmac.HMAC(password, self.challenge, digestmod=md5).digest()) return verify == self.response @implementer(IUsernameHashedPassword) class UsernameHashedPassword: deprecatedModuleAttribute( Version("Twisted", 21, 2, 0), "Use twisted.cred.credentials.UsernamePassword instead.", "twisted.cred.credentials", "UsernameHashedPassword", ) def __init__(self, username, hashed): self.username = username self.hashed = hashed def checkPassword(self, password): return self.hashed == password @implementer(IUsernamePassword) class UsernamePassword: def __init__(self, username, password): self.username = username self.password = password def checkPassword(self, password): return self.password == password @implementer(IAnonymous) class Anonymous: pass class ISSHPrivateKey(ICredentials): """ L{ISSHPrivateKey} credentials encapsulate an SSH public key to be checked against a user's private key. @ivar username: The username associated with these credentials. @type username: L{bytes} @ivar algName: The algorithm name for the blob. @type algName: L{bytes} @ivar blob: The public key blob as sent by the client. @type blob: L{bytes} @ivar sigData: The data the signature was made from. @type sigData: L{bytes} @ivar signature: The signed data. This is checked to verify that the user owns the private key. @type signature: L{bytes} or L{None} """ @implementer(ISSHPrivateKey) class SSHPrivateKey: def __init__(self, username, algName, blob, sigData, signature): self.username = username self.algName = algName self.blob = blob self.sigData = sigData self.signature = signature PK Mb�Z�<[ � � cred/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted Cred: Support for verifying credentials, and providing services to user based on those credentials. """ PK Mb�Z ���~ ~ 4 application/twist/__pycache__/_twist.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlmZ ddlmZ ddlmZmZ ddl m Z m Z ddl m Z mZ dd lmZ dd lmZmZmZ d d lmZ G d d� d�ZdS )z Run a Twisted application. � N)�Sequence)�_exitWithSignal)� IReactorCore� _ISupportsExitSignalCapturing)�Options� UsageError� )� ExitStatus�exit)�Runner)� Application�IService� IServiceMaker� )� TwistOptionsc @ s� e Zd ZdZedee defdd��Zede de de fdd ��Z ed e d e dd fd d��Zededd fdd��Zeejfdee dd fdd��Zd S )�Twistz$ Run a Twisted application. �argv�returnc C s^ t � }z |�| dd� � W |S ty. } zttjd|� d|� �� W Y d}~|S d}~ww )z� Parse command line options. @param argv: Command line arguments. @return: The parsed options. r NzError: z )r � parseOptionsr r r �EX_USAGE)r �options�e� r �B/usr/lib/python3/dist-packages/twisted/application/twist/_twist.pyr s �"��z Twist.options�pluginr c C s& | � |�}t| j�}|�|� t|�S )a Create the application service. @param plugin: The name of the plugin that implements the service application to run. @param options: Options to pass to the application. @return: The created application service. )� makeServicer �tapname�setServiceParentr )r r �service� applicationr r r r + s z Twist.service�reactorr Nc C s |� � | �dd|j� dS )z� Start the application service. @param reactor: The reactor to run the service with. @param service: The application service to run. �before�shutdownN)� startService�addSystemEventTrigger� stopService)r r r r r r# ; s zTwist.startService� twistOptionsc C sZ t | d | d | d | d d�}|�� | d }t�|�r)|jdur+t|j� dS dS dS )z� Run the application service. @param twistOptions: Command line options to convert to runner arguments. r �logLevel�logFile�fileLogObserverFactory)r �defaultLogLevelr( r) N)r �runr � providedBy� _exitSignalr )r& �runnerr r r r r+ H s � �z Twist.runc C sT | � |�}|d }|j}|dusJ �| j|j| |jd�}| �||� | �|� dS )z� Executable entry point for L{Twist}. Processes options and run a twisted reactor with a service. @param argv: Command line arguments. @type argv: L{list} r N)r r )r � subCommandr �plugins� subOptionsr# r+ )�clsr r r r/ r r r r �main\ s � z Twist.main)�__name__� __module__� __qualname__�__doc__� staticmethodr �strr r r r r r r r# r+ � classmethod�sysr r3 r r r r r s "r )r7 r; �typingr �twisted.application.appr �twisted.internet.interfacesr r �twisted.python.usager r � runner._exitr r �runner._runnerr r r r r �_optionsr r r r r r �<module> s PK Mb�Z�V$V� � 6 application/twist/__pycache__/_options.cpython-310.pycnu �[��� o �b� � @ s d Z ddlZddlmZmZ ddlmZ ddlmZmZm Z m Z m Z m Z m Z ddlmZ ddlmZ ddlmZmZmZmZ dd lmZ dd lmZmZ d d l m Z m Z m Z d d l m!Z!m"Z" d dl#m$Z$ e%Z&dede'gdf de'ddfdd�Z(G dd� de�Z)dS )z$ Command line options for C{twist}. � N)�stderr�stdout)�dedent)�Callable�Iterable�Mapping�Optional�Sequence�Tuple�cast)�version)� IReactorCore)�InvalidLogLevelError�LogLevel�jsonFileLogObserver�textFileLogObserver)� getPlugins)�Options� UsageError� )� NoSuchReactor�getReactorTypes�installReactor)� ExitStatus�exit)� IServiceMaker�opt� TwistOptions�kwargs�returnc K s t | jpd�jdi |��| _dS )z� Update the docstring of a method that implements an option. The string is dedented and the given keyword arguments are substituted. � N� )r �__doc__�format)r r r! r! �D/usr/lib/python3/dist-packages/twisted/application/twist/_options.py� _update_doc s r% c @ sV e Zd ZdZdZejZd+dd�Zde fdd�Z d,d d �Z d e ddfd d�Z e e d�dd� e� D ��d� d e defdd�Zde ddfdd�Ze ed�dd� e�� D ��ejd� de ddfdd �Zd e ddfd d �Ze e� d+d d!�Zd-d"eee ddfd#d$�Zede e e f fd%d&��Z ede e e de!e ge"f e f fd'd(��Z#d+d)d*�Z$dS ).r z, Command line options for C{twist}. �defaultr Nc C s0 t �| � | j| d< | j| d< t| d< d| _d S )N� reactorName�logLevel�logFiler )r �__init__�defaultReactorName�defaultLogLevelr �longdesc��selfr! r! r$ r* / s zTwistOptions.__init__c C s t �| �� d�S )Nz plugin [plugin_options])r � getSynopsisr. r! r! r$ r0 : s zTwistOptions.getSynopsis�typing.NoReturnc C s t tjt� � dS )z) Print version and exit. N)r r �EX_OKr r. r! r! r$ � opt_version= s zTwistOptions.opt_version�namec C s< z | � |�| d< W n ty td|� ���w || d< dS )zN The name of the reactor to use. (options: {options}) �reactorzUnknown reactor: r' N)r r r )r/ r4 r! r! r$ � opt_reactorC s � zTwistOptions.opt_reactorz, c c � � | ] }d |j � d �V qdS ��"N)� shortName)�.0�rtr! r! r$ � <genexpr>T s � zTwistOptions.<genexpr>��optionsc C s( || j krddlm} tt|�S t|�S )z& Install the reactor. r )r5 )r+ �twisted.internetr5 r r r )r/ r4 r5 r! r! r$ r W s zTwistOptions.installReactor� levelNamec C s2 z t �|�| d< W dS ty td|� ���w )z[ Set default log level. (options: {options}; default: "{default}") r( zInvalid log level: N)r � levelWithNamer r )r/ rA r! r! r$ � opt_log_levelb s �zTwistOptions.opt_log_levelc c r7 r8 )r4 )r; �constantr! r! r$ r= n s � �)r? r& �fileNamec C s| |dkr t | d< dS |dkrt| d< dS z t|d�| d< W dS ty= } zttjd|�d|� �� W Y d}~dS d}~ww )zM Log to file. ("-" for stdout, "+" for stderr; default: "-") �-r) N�+�azUnable to open log file z: )r r �openFile�OSErrorr r �EX_IOERR)r/ rE �er! r! r$ � opt_log_filet s ���zTwistOptions.opt_log_filer# c C sF |� � }|dkr t| d< n|dkrt| d< ntd|� ���|| d< dS )z� Log file format. (options: "text", "json"; default: "text" if the log file is a tty, otherwise "json") �text�fileLogObserverFactory�jsonzInvalid log format: � logFormatN)�lowerr r r )r/ r# r! r! r$ �opt_log_format� s zTwistOptions.opt_log_formatc C sN d| vr%| d }t |d�r|�� rt| d< d| d< dS t| d< d| d< dS dS )zm Set C{fileLogObserverFactory} to the default appropriate for the chosen C{logFile}. rO r) �isattyrN rQ rP N)�hasattrrT r r )r/ r) r! r! r$ �selectDefaultLogObserver� s �z%TwistOptions.selectDefaultLogObserverr? c C s8 | � � tj| |d� d| vr| �| d �| d< d S d S )Nr> r5 r' )rV r � parseOptionsr )r/ r? r! r! r$ rW � s �zTwistOptions.parseOptionsc C sB d| vri }t t�D ]}|||j< q || d< ttttf | d �S )N�plugins)r r �tapnamer r �str)r/ rX �pluginr! r! r$ rX � s zTwistOptions.pluginsc c sJ � | j }t|�D ]}|| }|fdtdtfdd�}|jd ||jfV qd S )Nr[ r c S s t t| �� �S �N)r r r? )r[ r! r! r$ r? � s z)TwistOptions.subCommands.<locals>.options)rX �sortedr r rY � description)r/ rX r4 r[ r? r! r! r$ � subCommands� s � �zTwistOptions.subCommandsc C s t �| � | jd u rtd��d S )NzNo plugin specified.)r � postOptions� subCommandr r. r! r! r$ r` � s �zTwistOptions.postOptions)r N)r r1 r\ )%�__name__� __module__� __qualname__r" r+ r �infor, r* rZ r0 r3 r6 r% �joinr r r rC � iterconstantsr4 rM rS rV r r rW �propertyr r rX r r r r r_ r` r! r! r! r$ r ' sB � �� �)*r" �typing�sysr r �textwrapr r r r r r r r �twisted.copyrightr �twisted.internet.interfacesr �twisted.loggerr r r r �twisted.pluginr �twisted.python.usager r �reactorsr r r � runner._exitr r �servicer �openrI rZ r% r r! r! r! r$ �<module> s $ "PK Mb�Z��M� � 6 application/twist/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z C{twist} command line tool. N)�__doc__� r r �D/usr/lib/python3/dist-packages/twisted/application/twist/__init__.py�<module> s PK Mb�Z�Y�u� � application/twist/_options.pynu �[��� # -*- test-case-name: twisted.application.twist.test.test_options -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Command line options for C{twist}. """ import typing from sys import stderr, stdout from textwrap import dedent from typing import Callable, Iterable, Mapping, Optional, Sequence, Tuple, cast from twisted.copyright import version from twisted.internet.interfaces import IReactorCore from twisted.logger import ( InvalidLogLevelError, LogLevel, jsonFileLogObserver, textFileLogObserver, ) from twisted.plugin import getPlugins from twisted.python.usage import Options, UsageError from ..reactors import NoSuchReactor, getReactorTypes, installReactor from ..runner._exit import ExitStatus, exit from ..service import IServiceMaker openFile = open def _update_doc(opt: Callable[["TwistOptions", str], None], **kwargs: str) -> None: """ Update the docstring of a method that implements an option. The string is dedented and the given keyword arguments are substituted. """ opt.__doc__ = dedent(opt.__doc__ or "").format(**kwargs) class TwistOptions(Options): """ Command line options for C{twist}. """ defaultReactorName = "default" defaultLogLevel = LogLevel.info def __init__(self) -> None: Options.__init__(self) self["reactorName"] = self.defaultReactorName self["logLevel"] = self.defaultLogLevel self["logFile"] = stdout # An empty long description is explicitly set here as otherwise # when executing from distributed trial twisted.python.usage will # pull the description from `__main__` which is another entry point. self.longdesc = "" def getSynopsis(self) -> str: return f"{Options.getSynopsis(self)} plugin [plugin_options]" def opt_version(self) -> "typing.NoReturn": """ Print version and exit. """ exit(ExitStatus.EX_OK, f"{version}") def opt_reactor(self, name: str) -> None: """ The name of the reactor to use. (options: {options}) """ # Actually actually actually install the reactor right at this very # moment, before any other code (for example, a sub-command plugin) # runs and accidentally imports and installs the default reactor. try: self["reactor"] = self.installReactor(name) except NoSuchReactor: raise UsageError(f"Unknown reactor: {name}") else: self["reactorName"] = name _update_doc( opt_reactor, options=", ".join(f'"{rt.shortName}"' for rt in getReactorTypes()), ) def installReactor(self, name: str) -> IReactorCore: """ Install the reactor. """ if name == self.defaultReactorName: from twisted.internet import reactor return cast(IReactorCore, reactor) else: return installReactor(name) def opt_log_level(self, levelName: str) -> None: """ Set default log level. (options: {options}; default: "{default}") """ try: self["logLevel"] = LogLevel.levelWithName(levelName) except InvalidLogLevelError: raise UsageError(f"Invalid log level: {levelName}") _update_doc( opt_log_level, options=", ".join( f'"{constant.name}"' for constant in LogLevel.iterconstants() ), default=defaultLogLevel.name, ) def opt_log_file(self, fileName: str) -> None: """ Log to file. ("-" for stdout, "+" for stderr; default: "-") """ if fileName == "-": self["logFile"] = stdout return if fileName == "+": self["logFile"] = stderr return try: self["logFile"] = openFile(fileName, "a") except OSError as e: exit( ExitStatus.EX_IOERR, f"Unable to open log file {fileName!r}: {e}", ) def opt_log_format(self, format: str) -> None: """ Log file format. (options: "text", "json"; default: "text" if the log file is a tty, otherwise "json") """ format = format.lower() if format == "text": self["fileLogObserverFactory"] = textFileLogObserver elif format == "json": self["fileLogObserverFactory"] = jsonFileLogObserver else: raise UsageError(f"Invalid log format: {format}") self["logFormat"] = format _update_doc(opt_log_format) def selectDefaultLogObserver(self) -> None: """ Set C{fileLogObserverFactory} to the default appropriate for the chosen C{logFile}. """ if "fileLogObserverFactory" not in self: logFile = self["logFile"] if hasattr(logFile, "isatty") and logFile.isatty(): self["fileLogObserverFactory"] = textFileLogObserver self["logFormat"] = "text" else: self["fileLogObserverFactory"] = jsonFileLogObserver self["logFormat"] = "json" def parseOptions(self, options: Optional[Sequence[str]] = None) -> None: self.selectDefaultLogObserver() Options.parseOptions(self, options=options) if "reactor" not in self: self["reactor"] = self.installReactor(self["reactorName"]) @property def plugins(self) -> Mapping[str, IServiceMaker]: if "plugins" not in self: plugins = {} for plugin in getPlugins(IServiceMaker): plugins[plugin.tapname] = plugin self["plugins"] = plugins return cast(Mapping[str, IServiceMaker], self["plugins"]) @property def subCommands( self, ) -> Iterable[Tuple[str, None, Callable[[IServiceMaker], Options], str]]: plugins = self.plugins for name in sorted(plugins): plugin = plugins[name] # Don't pass plugin.options along in order to avoid resolving the # options attribute right away, in case it's a property with a # non-trivial getter (eg, one which imports modules). def options(plugin: IServiceMaker = plugin) -> Options: return cast(Options, plugin.options()) yield (plugin.tapname, None, options, plugin.description) def postOptions(self) -> None: Options.postOptions(self) if self.subCommand is None: raise UsageError("No plugin specified.") PK Mb�Z� �� � $ application/twist/test/test_twist.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.application.twist._twist}. """ from sys import stdout from typing import Any, Dict, List import twisted.trial.unittest from twisted.internet.interfaces import IReactorCore from twisted.logger import LogLevel, jsonFileLogObserver from twisted.test.proto_helpers import MemoryReactor from twisted.test.test_twistd import SignalCapturingMemoryReactor from ...runner._exit import ExitStatus from ...runner._runner import Runner from ...runner.test.test_runner import DummyExit from ...service import IService, MultiService from ...twist import _twist from .._options import TwistOptions from .._twist import Twist class TwistTests(twisted.trial.unittest.TestCase): """ Tests for L{Twist}. """ def setUp(self) -> None: self.patchInstallReactor() def patchExit(self) -> None: """ Patch L{_twist.exit} so we can capture usage and prevent actual exits. """ self.exit = DummyExit() self.patch(_twist, "exit", self.exit) def patchInstallReactor(self) -> None: """ Patch C{_options.installReactor} so we can capture usage and prevent actual installs. """ self.installedReactors: Dict[str, IReactorCore] = {} def installReactor(_: TwistOptions, name: str) -> IReactorCore: reactor = MemoryReactor() self.installedReactors[name] = reactor return reactor self.patch(TwistOptions, "installReactor", installReactor) def patchStartService(self) -> None: """ Patch L{MultiService.startService} so we can capture usage and prevent actual starts. """ self.serviceStarts: List[IService] = [] def startService(service: IService) -> None: self.serviceStarts.append(service) self.patch(MultiService, "startService", startService) def test_optionsValidArguments(self) -> None: """ L{Twist.options} given valid arguments returns options. """ options = Twist.options(["twist", "web"]) self.assertIsInstance(options, TwistOptions) def test_optionsInvalidArguments(self) -> None: """ L{Twist.options} given invalid arguments exits with L{ExitStatus.EX_USAGE} and an error/usage message. """ self.patchExit() Twist.options(["twist", "--bogus-bagels"]) self.assertIdentical(self.exit.status, ExitStatus.EX_USAGE) self.assertIsNotNone(self.exit.message) self.assertTrue( self.exit.message.startswith("Error: ") # type: ignore[union-attr] ) self.assertTrue( self.exit.message.endswith( # type: ignore[union-attr] f"\n\n{TwistOptions()}" ) ) def test_service(self) -> None: """ L{Twist.service} returns an L{IService}. """ options = Twist.options(["twist", "web"]) # web should exist service = Twist.service(options.plugins["web"], options.subOptions) self.assertTrue(IService.providedBy(service)) def test_startService(self) -> None: """ L{Twist.startService} starts the service and registers a trigger to stop the service when the reactor shuts down. """ options = Twist.options(["twist", "web"]) reactor = options["reactor"] subCommand = options.subCommand assert subCommand is not None service = Twist.service( plugin=options.plugins[subCommand], options=options.subOptions, ) self.patchStartService() Twist.startService(reactor, service) self.assertEqual(self.serviceStarts, [service]) self.assertEqual( reactor.triggers["before"]["shutdown"], [(service.stopService, (), {})] ) def test_run(self) -> None: """ L{Twist.run} runs the runner with arguments corresponding to the given options. """ argsSeen = [] self.patch(Runner, "__init__", lambda self, **args: argsSeen.append(args)) self.patch(Runner, "run", lambda self: None) twistOptions = Twist.options( ["twist", "--reactor=default", "--log-format=json", "web"] ) Twist.run(twistOptions) self.assertEqual(len(argsSeen), 1) self.assertEqual( argsSeen[0], dict( reactor=self.installedReactors["default"], defaultLogLevel=LogLevel.info, logFile=stdout, fileLogObserverFactory=jsonFileLogObserver, ), ) def test_main(self) -> None: """ L{Twist.main} runs the runner with arguments corresponding to the given command line arguments. """ self.patchStartService() runners = [] class Runner: def __init__(self, **kwargs: Any) -> None: self.args = kwargs self.runs = 0 runners.append(self) def run(self) -> None: self.runs += 1 self.patch(_twist, "Runner", Runner) Twist.main(["twist", "--reactor=default", "--log-format=json", "web"]) self.assertEqual(len(self.serviceStarts), 1) self.assertEqual(len(runners), 1) self.assertEqual( runners[0].args, dict( reactor=self.installedReactors["default"], defaultLogLevel=LogLevel.info, logFile=stdout, fileLogObserverFactory=jsonFileLogObserver, ), ) self.assertEqual(runners[0].runs, 1) class TwistExitTests(twisted.trial.unittest.TestCase): """ Tests to verify that the Twist script takes the expected actions related to signals and the reactor. """ def setUp(self) -> None: self.exitWithSignalCalled = False def fakeExitWithSignal(sig: int) -> None: """ Fake to capture whether L{twisted.application._exitWithSignal was called. @param sig: Signal value @type sig: C{int} """ self.exitWithSignalCalled = True self.patch(_twist, "_exitWithSignal", fakeExitWithSignal) def startLogging(_: Runner) -> None: """ Prevent Runner from adding new log observers or other tests outside this module will fail. @param _: Unused self param """ self.patch(Runner, "startLogging", startLogging) def test_twistReactorDoesntExitWithSignal(self) -> None: """ _exitWithSignal is not called if the reactor's _exitSignal attribute is zero. """ reactor = SignalCapturingMemoryReactor() reactor._exitSignal = None options = TwistOptions() options["reactor"] = reactor options["fileLogObserverFactory"] = jsonFileLogObserver Twist.run(options) self.assertFalse(self.exitWithSignalCalled) def test_twistReactorHasNoExitSignalAttr(self) -> None: """ _exitWithSignal is not called if the runner's reactor does not implement L{twisted.internet.interfaces._ISupportsExitSignalCapturing} """ reactor = MemoryReactor() options = TwistOptions() options["reactor"] = reactor options["fileLogObserverFactory"] = jsonFileLogObserver Twist.run(options) self.assertFalse(self.exitWithSignalCalled) def test_twistReactorExitsWithSignal(self) -> None: """ _exitWithSignal is called if the runner's reactor exits due to a signal. """ reactor = SignalCapturingMemoryReactor() reactor._exitSignal = 2 options = TwistOptions() options["reactor"] = reactor options["fileLogObserverFactory"] = jsonFileLogObserver Twist.run(options) self.assertTrue(self.exitWithSignalCalled) PK Mb�Zv�X �/ �/ ? application/twist/test/__pycache__/test_options.cpython-310.pycnu �[��� o �b�, � @ s� d Z ddlmZmZ ddlmZmZmZmZm Z m Z ddl Z ddl mZ ddlmZ ddlmZ ddlmZmZmZmZ dd lmZ dd lmZ d d l m Z d d l m Z d dl m!Z! d dl"m#Z# d dl$m%Z% ddl%m&Z& G dd� de j'j(j)�Z*dS )z2 Tests for L{twisted.application.twist._options}. � )�stderr�stdout)�Callable�Dict�List�Optional�TextIO�TupleN)�version)�reactor)� IReactorCore)�FileLogObserver�LogLevel�jsonFileLogObserver�textFileLogObserver)� UsageError)� MemoryReactor� )� NoSuchReactor)� ExitStatus)� DummyExit)� ServiceMaker)�_options� )� TwistOptionsc @ sJ e Zd ZdZd@dd�Zd@dd�Zd@dd �Zd@d d �Zd@d d �Zd@dd�Z d@dd�Z d@dd�Z d@dd�Z d@dd�Z d@dd�Zdededdfd d �Zd@d d �Zd@d d!�Zd@d"d#�Zd@d$d%�Zd&ed'eegef ddfd(d)�Zd@d*d+�Zd@d,d-�Zd@d.d/�Zd@d0d1�Z d@d2d3�Z d@d4d5�Z d@d6d7�Z d@d8d9�Z d@d:d;�Z!d@d<d=�Z"d@d>d?�Z#dS )A� OptionsTestsz$ Tests for L{TwistOptions}. �returnNc C s t � | _| �td| j� dS )zX Patch L{_twist.exit} so we can capture usage and prevent actual exits. �exitN)r r �patchr ��self� r! �M/usr/lib/python3/dist-packages/twisted/application/twist/test/test_options.py� patchExit$ s zOptionsTests.patchExitc s8 g � _ ddtdtt dtf� fdd� }� �td|� dS ) zZ Patch L{_options.open} so we can capture usage and prevent actual opens. N�name�moder c s( | dkr t d d | ��� j�| |f� tS )N� nocanopen)�OSError�opened�append�NotImplemented)r$ r% r r! r" �fakeOpen1 s z(OptionsTests.patchOpen.<locals>.fakeOpen�openFile)N)r( �strr r r r )r r+ r! r r" � patchOpen+ s zOptionsTests.patchOpenc s. i � _ dtdtf� fdd� }� �td|� dS )zo Patch C{_options.installReactor} so we can capture usage and prevent actual installs. r$ r c s" | dkrt � �t� }|� j| < |S )N�fusion)r r �installedReactors)r$ r r r! r" �installReactorA s z8OptionsTests.patchInstallReactor.<locals>.installReactorr1 N)r0 r- r r r )r r1 r! r r" �patchInstallReactor: s z OptionsTests.patchInstallReactorc C s t � }| �|�� �d�� dS )z@ L{TwistOptions.getSynopsis} appends arguments. z plugin [plugin_options]N)r � assertTrue� getSynopsis�endswith�r �optionsr! r! r" � test_synopsisK s zOptionsTests.test_synopsisc C s< | � � t� }|�� | �| jjtj� | �| jjt � dS )zl L{TwistOptions.opt_version} exits with L{ExitStatus.EX_OK} and prints the version. N) r# r � opt_version� assertEqualsr �statusr �EX_OK�messager r6 r! r! r" � test_versionS s zOptionsTests.test_versionc C s@ | � � t� }|�d� | �t| j�dh� | �|d d� dS )zo L{TwistOptions.installReactor} installs the chosen reactor and sets the reactor name. r/ � reactorNameN)r2 r � opt_reactor� assertEqual�setr0 r: r6 r! r! r" � test_reactor` s zOptionsTests.test_reactorc C s8 | � � t� }d|_|�dg� | �t| j�dh� dS )z� L{TwistOptions.installReactor} installs the chosen reactor after the command line options have been parsed. ztest-subcommandz--reactor=fusionr/ N)r2 r � subCommand� parseOptionsrA rB r0 r6 r! r! r" �test_installCorrectReactorm s z'OptionsTests.test_installCorrectReactorc C s" | � � t� }| �t|jd� dS )zn L{TwistOptions.installReactor} raises UsageError if an unknown reactor is specified. �coalN)r2 r � assertRaisesr r@ r6 r! r! r" �test_installReactorBogusz s z%OptionsTests.test_installReactorBogusc C s t � }| �t|�d�� dS )z� L{TwistOptions.installReactor} returns the currently installed reactor when the default reactor name is specified. �defaultN)r �assertIdenticalr r1 r6 r! r! r" �test_installReactorDefault� s z'OptionsTests.test_installReactorDefaultc C s& t � }|�d� | �|d tj� dS )zQ L{TwistOptions.opt_log_level} sets the corresponding log level. �warn�logLevelN)r � opt_log_levelrK r rM r6 r! r! r" �test_logLevelValid� s z OptionsTests.test_logLevelValidc C � t � }| �t|jd� dS )zi L{TwistOptions.opt_log_level} with an invalid log level name raises UsageError. �cheeseN)r rH r rO r6 r! r! r" �test_logLevelInvalid� � z!OptionsTests.test_logLevelInvalidr$ �expectedStreamc C s$ t � }|�|� | �|d |� dS )z� Set log file name and check the selected output stream. @param name: The name of the file. @param expectedStream: The expected stream. �logFileN)r � opt_log_filerK )r r$ rU r7 r! r! r" � _testLogFile� s zOptionsTests._testLogFilec C � | � dt� dS )zW L{TwistOptions.opt_log_file} given C{"-"} as a file name uses stdout. �-N)rX r r r! r! r" �test_logFileStdout� � z OptionsTests.test_logFileStdoutc C rY )zW L{TwistOptions.opt_log_file} given C{"+"} as a file name uses stderr. �+N)rX r r r! r! r" �test_logFileStderr� r\ z OptionsTests.test_logFileStderrc C s, | � � t� }|�d� | �dg| j� dS )zX L{TwistOptions.opt_log_file} opens the given file name in append mode. �mylog)r_ �aN)r. r rW rA r( r6 r! r! r" �test_logFileNamed� s z OptionsTests.test_logFileNamedc C sX | � � | �� t� }|�d� | �| jjtj� | � | jj � | � | jj � d�� dS )z� L{TwistOptions.opt_log_file} exits with L{ExitStatus.EX_IOERR} if unable to open the log file due to an L{EnvironmentError}. r& z%Unable to open log file 'nocanopen': N) r# r. r rW r: r r; r �EX_IOERR�assertIsNotNoner= r3 � startswithr6 r! r! r" �test_logFileCantOpen� s ��z!OptionsTests.test_logFileCantOpen�format�expectedObserverFactoryc C s4 t � }|�|� | �|d |� | �|d |� dS )z� Set log file format and check the selected observer factory. @param format: The format of the file. @param expectedObserverFactory: The expected observer factory. �fileLogObserverFactory� logFormatN)r �opt_log_formatrK rA )r rf rg r7 r! r! r" �_testLogFormat� s zOptionsTests._testLogFormatc C rY )�g L{TwistOptions.opt_log_format} given C{"text"} uses a L{textFileLogObserver}. �textN)rk r r r! r! r" �test_logFormatText� � z OptionsTests.test_logFormatTextc C rY )rl �jsonN)rk r r r! r! r" �test_logFormatJSON� ro z OptionsTests.test_logFormatJSONc C rQ )zk L{TwistOptions.opt_log_format} given an invalid format name raises L{UsageError}. �frommageN)r rH r rj r6 r! r! r" �test_logFormatInvalid� rT z"OptionsTests.test_logFormatInvalidc C sN | � � t� }|�d� |�d� |�� | �|d t� | �|d d� dS )�r L{TwistOptions.selectDefaultLogObserver} will not override an already selected observer. rm �quesorh ri N)r. r rj rW �selectDefaultLogObserverrK r rA r6 r! r! r" �'test_selectDefaultLogObserverNoOverride� s z4OptionsTests.test_selectDefaultLogObserverNoOverridec C sZ G dd� d�}| � td|� � t� }|�d� |�� | �|d t� | �|d d� dS ) rt c @ s e Zd Zdefdd�ZdS )zIOptionsTests.test_selectDefaultLogObserverDefaultWithTTY.<locals>.TTYFiler c S s dS )NTr! r r! r! r" �isatty s zPOptionsTests.test_selectDefaultLogObserverDefaultWithTTY.<locals>.TTYFile.isattyN)�__name__� __module__� __qualname__�boolrx r! r! r! r" �TTYFile s r} r rZ rh ri rm N)r r r rW rv rK r rA )r r} r7 r! r! r" �+test_selectDefaultLogObserverDefaultWithTTY s z8OptionsTests.test_selectDefaultLogObserverDefaultWithTTYc C sD | � � t� }|�d� |�� | �|d t� | �|d d� dS )rt ru rh ri rp N)r. r rW rv rK r rA r6 r! r! r" �.test_selectDefaultLogObserverDefaultWithoutTTY s z;OptionsTests.test_selectDefaultLogObserverDefaultWithoutTTYc C s6 t � }|j}|D ]}| �|t� | �|| t� qdS )zM L{TwistOptions.plugins} is a mapping of available plug-ins. N)r �plugins�assertIsInstancer- r )r r7 r� r$ r! r! r" �test_pluginsType- s �z OptionsTests.test_pluginsTypec C s t � }| �d|j� dS )z� L{TwistOptions.plugins} includes a C{"web"} plug-in. This is an attempt to verify that something we expect to be in the list is in there without enumerating all of the built-in plug-ins. �webN)r �assertInr� r6 r! r! r" �test_pluginsIncludeWeb8 s z#OptionsTests.test_pluginsIncludeWebc C sP t � }|jD ] \}}}}| �|t� | �|d� | �t|�� | �|t� qdS )z~ L{TwistOptions.subCommands} is an iterable of tuples as expected by L{twisted.python.usage.Options}. N)r � subCommandsr� r- rK r3 �callable)r r7 r$ �shortcut�parser�docr! r! r" �test_subCommandsTypeB s �z!OptionsTests.test_subCommandsTypec C s0 t � }t|j�}dd� |jD �}| �||� dS )zW L{TwistOptions.subCommands} includes a sub-command for every plug-in. c S s h | ]\}}}}|�qS r! r! )�.0r$ r� r� r� r! r! r" � <setcomp>V s z:OptionsTests.test_subCommandsIncludeWeb.<locals>.<setcomp>N)r rB r� r� rA )r r7 r� r� r! r! r" �test_subCommandsIncludeWebO s z'OptionsTests.test_subCommandsIncludeWebc C s | � � t� }| �t|j� dS )zd L{TwistOptions.postOptions} raises L{UsageError} is it has no sub-command. N)r2 r rH r � postOptionsr6 r! r! r" � test_postOptionsNoSubCommandZ s z)OptionsTests.test_postOptionsNoSubCommand)r N)$ry rz r{ �__doc__r# r. r2 r8 r> rC rF rI rL rP rS r- r rX r[ r^ ra re r r rk rn rq rs rw r~ r r� r� r� r� r� r! r! r! r" r sH � � � r )+r� �sysr r �typingr r r r r r �twisted.trial.unittest�twisted�twisted.copyrightr �twisted.internetr �twisted.internet.interfacesr �twisted.loggerr r r r �twisted.python.usager �twisted.test.proto_helpersr �reactorsr � runner._exitr �runner.test.test_runnerr �servicer �twistr r �trial�unittest�TestCaser r! r! r! r" �<module> s" PK Mb�Z 0�� � ; application/twist/test/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z) Tests for L{twisted.application.twist}. N)�__doc__� r r �I/usr/lib/python3/dist-packages/twisted/application/twist/test/__init__.py�<module> s PK Mb�Z|V}��" �" = application/twist/test/__pycache__/test_twist.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZmZmZ ddlZddl m Z ddl m Z m Z ddlmZ ddlmZ d d lmZ d d lmZ d d lmZ d d lmZmZ d dlm Z ddl m Z ddl m Z G dd� dej j!j"�Z#G dd� dej j!j"�Z$dS )z0 Tests for L{twisted.application.twist._twist}. � )�stdout)�Any�Dict�ListN)� IReactorCore)�LogLevel�jsonFileLogObserver)� MemoryReactor)� SignalCapturingMemoryReactor� )� ExitStatus)�Runner)� DummyExit)�IService� MultiService)�_twist� )� TwistOptions)�Twistc @ st e Zd ZdZddd�Zddd�Zddd �Zdd d �Zdd d �Zddd�Z ddd�Z ddd�Z ddd�Z ddd�Z dS )� TwistTestsz Tests for L{Twist}. �returnNc C s | � � d S �N)�patchInstallReactor��self� r �K/usr/lib/python3/dist-packages/twisted/application/twist/test/test_twist.py�setUp s zTwistTests.setUpc C s t � | _| �td| j� dS )zX Patch L{_twist.exit} so we can capture usage and prevent actual exits. �exitN)r r �patchr r r r r � patchExit! s zTwistTests.patchExitc s2 i � _ dtdtdtf� fdd� }� �td|� dS )zo Patch C{_options.installReactor} so we can capture usage and prevent actual installs. �_�namer c s t � }|� j|< |S r )r �installedReactors)r! r" �reactorr r r �installReactor/ s z6TwistTests.patchInstallReactor.<locals>.installReactorr% N)r# r �strr r )r r% r r r r ( s z TwistTests.patchInstallReactorc s. g � _ dtddf� fdd� }� �td|� dS )zo Patch L{MultiService.startService} so we can capture usage and prevent actual starts. �servicer Nc s � j �| � d S r )� serviceStarts�append)r' r r r � startService= s z2TwistTests.patchStartService.<locals>.startServicer* )r( r r r )r r* r r r �patchStartService6 s z TwistTests.patchStartServicec C s t �ddg�}| �|t� dS )zI L{Twist.options} given valid arguments returns options. �twist�webN)r �options�assertIsInstancer )r r. r r r �test_optionsValidArgumentsB s z%TwistTests.test_optionsValidArgumentsc C sj | � � t�ddg� | �| jjtj� | �| jj � | � | jj � d�� | � | jj � dt � � ��� dS )z� L{Twist.options} given invalid arguments exits with L{ExitStatus.EX_USAGE} and an error/usage message. r, z--bogus-bagelszError: z N)r r r. �assertIdenticalr �statusr �EX_USAGE�assertIsNotNone�message� assertTrue� startswith�endswithr r r r r � test_optionsInvalidArgumentsJ s � ��z'TwistTests.test_optionsInvalidArgumentsc C s6 t �ddg�}t �|jd |j�}| �t�|�� dS )z: L{Twist.service} returns an L{IService}. r, r- N)r r. r' �plugins� subOptionsr6 r � providedBy)r r. r' r r r � test_service^ s zTwistTests.test_servicec C s� t �ddg�}|d }|j}|dusJ �t j|j| |jd�}| �� t �||� | �| j |g� | �|j d d |j di fg� dS ) z� L{Twist.startService} starts the service and registers a trigger to stop the service when the reactor shuts down. r, r- r$ N)�pluginr. �before�shutdownr ) r r. � subCommandr' r: r; r+ r* � assertEqualr( �triggers� stopService)r r. r$ rA r' r r r �test_startServicef s � �z TwistTests.test_startServicec s| g � | � td� fdd�� | � tddd� � t�g d��}t�|� | �t� �d� | �� d t| jd t j t t d �� d S ) zi L{Twist.run} runs the runner with arguments corresponding to the given options. �__init__c s � � |�S r )r) )r �args��argsSeenr r �<lambda>� s z%TwistTests.test_run.<locals>.<lambda>�runc S s d S r r r r r r rJ � � �r, z--reactor=defaultz--log-format=jsonr- � r �default�r$ �defaultLogLevel�logFile�fileLogObserverFactoryN) r r r r. rK rB �len�dictr# r �infor r )r � twistOptionsr rH r �test_run~ s" � ��zTwistTests.test_runc s� | � � g � G � fdd�d�}| �td|� t�g d�� | �t| j�d� | �t� �d� | �� d jt | j d t j t td�� | �� d jd� dS ) zy L{Twist.main} runs the runner with arguments corresponding to the given command line arguments. c s, e Zd Zdeddf� fdd� Zddd�ZdS ) z$TwistTests.test_main.<locals>.Runner�kwargsr Nc s || _ d| _� �| � d S )Nr )rG �runsr) )r rY ��runnersr r rF � s z-TwistTests.test_main.<locals>.Runner.__init__c S s | j d7 _ d S )NrN )rZ r r r r rK � s z(TwistTests.test_main.<locals>.Runner.run�r N)�__name__� __module__� __qualname__r rF rK r r[ r r r � s r rM rN r rO rP N)r+ r r r �mainrB rT r( rG rU r# r rV r r rZ )r r r r[ r � test_main� s" �� zTwistTests.test_mainr] )r^ r_ r` �__doc__r r r r+ r0 r9 r= rE rX rb r r r r r s r c @ s8 e Zd ZdZd dd�Zd dd�Zd dd �Zd d d �ZdS ) �TwistExitTestszr Tests to verify that the Twist script takes the expected actions related to signals and the reactor. r Nc sN d� _ dtdd f� fdd� }� �td|� dtdd fdd �}� �td |� d S ) NF�sigr c s d� _ dS )z� Fake to capture whether L{twisted.application._exitWithSignal was called. @param sig: Signal value @type sig: C{int} TN)�exitWithSignalCalled)re r r r �fakeExitWithSignal� s z0TwistExitTests.setUp.<locals>.fakeExitWithSignal�_exitWithSignalr! c S s dS )z� Prevent Runner from adding new log observers or other tests outside this module will fail. @param _: Unused self param Nr )r! r r r � startLogging� rL z*TwistExitTests.setUp.<locals>.startLoggingri )rf �intr r r )r rg ri r r r r � s zTwistExitTests.setUpc C s< t � }d|_t� }||d< t|d< t�|� | �| j� dS )zg _exitWithSignal is not called if the reactor's _exitSignal attribute is zero. Nr$ rS )r � _exitSignalr r r rK � assertFalserf �r r$ r. r r r �%test_twistReactorDoesntExitWithSignal� s z4TwistExitTests.test_twistReactorDoesntExitWithSignalc C s6 t � }t� }||d< t|d< t�|� | �| j� dS )z� _exitWithSignal is not called if the runner's reactor does not implement L{twisted.internet.interfaces._ISupportsExitSignalCapturing} r$ rS N)r r r r rK rl rf rm r r r �$test_twistReactorHasNoExitSignalAttr� s z3TwistExitTests.test_twistReactorHasNoExitSignalAttrc C s< t � }d|_t� }||d< t|d< t�|� | �| j� dS )zb _exitWithSignal is called if the runner's reactor exits due to a signal. r r$ rS N)r rk r r r rK r6 rf rm r r r � test_twistReactorExitsWithSignal� s z/TwistExitTests.test_twistReactorExitsWithSignalr] )r^ r_ r` rc r rn ro rp r r r r rd � s rd )%rc �sysr �typingr r r �twisted.trial.unittest�twisted�twisted.internet.interfacesr �twisted.loggerr r �twisted.test.proto_helpersr �twisted.test.test_twistdr � runner._exitr �runner._runnerr �runner.test.test_runnerr r' r r r, r �_optionsr r �trial�unittest�TestCaser rd r r r r �<module> s$ $PK Mb�Zl�ܪ, �, & application/twist/test/test_options.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.application.twist._options}. """ from sys import stderr, stdout from typing import Callable, Dict, List, Optional, TextIO, Tuple import twisted.trial.unittest from twisted.copyright import version from twisted.internet import reactor from twisted.internet.interfaces import IReactorCore from twisted.logger import ( FileLogObserver, LogLevel, jsonFileLogObserver, textFileLogObserver, ) from twisted.python.usage import UsageError from twisted.test.proto_helpers import MemoryReactor from ...reactors import NoSuchReactor from ...runner._exit import ExitStatus from ...runner.test.test_runner import DummyExit from ...service import ServiceMaker from ...twist import _options from .._options import TwistOptions class OptionsTests(twisted.trial.unittest.TestCase): """ Tests for L{TwistOptions}. """ def patchExit(self) -> None: """ Patch L{_twist.exit} so we can capture usage and prevent actual exits. """ self.exit = DummyExit() self.patch(_options, "exit", self.exit) def patchOpen(self) -> None: """ Patch L{_options.open} so we can capture usage and prevent actual opens. """ self.opened: List[Tuple[str, Optional[str]]] = [] def fakeOpen(name: str, mode: Optional[str] = None) -> TextIO: if name == "nocanopen": raise OSError(None, None, name) self.opened.append((name, mode)) return NotImplemented self.patch(_options, "openFile", fakeOpen) def patchInstallReactor(self) -> None: """ Patch C{_options.installReactor} so we can capture usage and prevent actual installs. """ self.installedReactors: Dict[str, IReactorCore] = {} def installReactor(name: str) -> IReactorCore: if name != "fusion": raise NoSuchReactor() reactor = MemoryReactor() self.installedReactors[name] = reactor return reactor self.patch(_options, "installReactor", installReactor) def test_synopsis(self) -> None: """ L{TwistOptions.getSynopsis} appends arguments. """ options = TwistOptions() self.assertTrue(options.getSynopsis().endswith(" plugin [plugin_options]")) def test_version(self) -> None: """ L{TwistOptions.opt_version} exits with L{ExitStatus.EX_OK} and prints the version. """ self.patchExit() options = TwistOptions() options.opt_version() self.assertEquals(self.exit.status, ExitStatus.EX_OK) # type: ignore[unreachable] self.assertEquals(self.exit.message, version) def test_reactor(self) -> None: """ L{TwistOptions.installReactor} installs the chosen reactor and sets the reactor name. """ self.patchInstallReactor() options = TwistOptions() options.opt_reactor("fusion") self.assertEqual(set(self.installedReactors), {"fusion"}) self.assertEquals(options["reactorName"], "fusion") def test_installCorrectReactor(self) -> None: """ L{TwistOptions.installReactor} installs the chosen reactor after the command line options have been parsed. """ self.patchInstallReactor() options = TwistOptions() options.subCommand = "test-subcommand" options.parseOptions(["--reactor=fusion"]) self.assertEqual(set(self.installedReactors), {"fusion"}) def test_installReactorBogus(self) -> None: """ L{TwistOptions.installReactor} raises UsageError if an unknown reactor is specified. """ self.patchInstallReactor() options = TwistOptions() self.assertRaises(UsageError, options.opt_reactor, "coal") def test_installReactorDefault(self) -> None: """ L{TwistOptions.installReactor} returns the currently installed reactor when the default reactor name is specified. """ options = TwistOptions() self.assertIdentical(reactor, options.installReactor("default")) def test_logLevelValid(self) -> None: """ L{TwistOptions.opt_log_level} sets the corresponding log level. """ options = TwistOptions() options.opt_log_level("warn") self.assertIdentical(options["logLevel"], LogLevel.warn) def test_logLevelInvalid(self) -> None: """ L{TwistOptions.opt_log_level} with an invalid log level name raises UsageError. """ options = TwistOptions() self.assertRaises(UsageError, options.opt_log_level, "cheese") def _testLogFile(self, name: str, expectedStream: TextIO) -> None: """ Set log file name and check the selected output stream. @param name: The name of the file. @param expectedStream: The expected stream. """ options = TwistOptions() options.opt_log_file(name) self.assertIdentical(options["logFile"], expectedStream) def test_logFileStdout(self) -> None: """ L{TwistOptions.opt_log_file} given C{"-"} as a file name uses stdout. """ self._testLogFile("-", stdout) def test_logFileStderr(self) -> None: """ L{TwistOptions.opt_log_file} given C{"+"} as a file name uses stderr. """ self._testLogFile("+", stderr) def test_logFileNamed(self) -> None: """ L{TwistOptions.opt_log_file} opens the given file name in append mode. """ self.patchOpen() options = TwistOptions() options.opt_log_file("mylog") self.assertEqual([("mylog", "a")], self.opened) def test_logFileCantOpen(self) -> None: """ L{TwistOptions.opt_log_file} exits with L{ExitStatus.EX_IOERR} if unable to open the log file due to an L{EnvironmentError}. """ self.patchExit() self.patchOpen() options = TwistOptions() options.opt_log_file("nocanopen") self.assertEquals(self.exit.status, ExitStatus.EX_IOERR) self.assertIsNotNone(self.exit.message) self.assertTrue( self.exit.message.startswith( # type: ignore[union-attr] "Unable to open log file 'nocanopen': " ) ) def _testLogFormat( self, format: str, expectedObserverFactory: Callable[[TextIO], FileLogObserver] ) -> None: """ Set log file format and check the selected observer factory. @param format: The format of the file. @param expectedObserverFactory: The expected observer factory. """ options = TwistOptions() options.opt_log_format(format) self.assertIdentical(options["fileLogObserverFactory"], expectedObserverFactory) self.assertEqual(options["logFormat"], format) def test_logFormatText(self) -> None: """ L{TwistOptions.opt_log_format} given C{"text"} uses a L{textFileLogObserver}. """ self._testLogFormat("text", textFileLogObserver) def test_logFormatJSON(self) -> None: """ L{TwistOptions.opt_log_format} given C{"text"} uses a L{textFileLogObserver}. """ self._testLogFormat("json", jsonFileLogObserver) def test_logFormatInvalid(self) -> None: """ L{TwistOptions.opt_log_format} given an invalid format name raises L{UsageError}. """ options = TwistOptions() self.assertRaises(UsageError, options.opt_log_format, "frommage") def test_selectDefaultLogObserverNoOverride(self) -> None: """ L{TwistOptions.selectDefaultLogObserver} will not override an already selected observer. """ self.patchOpen() options = TwistOptions() options.opt_log_format("text") # Ask for text options.opt_log_file("queso") # File, not a tty options.selectDefaultLogObserver() # Because we didn't select a file that is a tty, the default is JSON, # but since we asked for text, we should get text. self.assertIdentical(options["fileLogObserverFactory"], textFileLogObserver) self.assertEqual(options["logFormat"], "text") def test_selectDefaultLogObserverDefaultWithTTY(self) -> None: """ L{TwistOptions.selectDefaultLogObserver} will not override an already selected observer. """ class TTYFile: def isatty(self) -> bool: return True # stdout may not be a tty, so let's make sure it thinks it is self.patch(_options, "stdout", TTYFile()) options = TwistOptions() options.opt_log_file("-") # stdout, a tty options.selectDefaultLogObserver() self.assertIdentical(options["fileLogObserverFactory"], textFileLogObserver) self.assertEqual(options["logFormat"], "text") def test_selectDefaultLogObserverDefaultWithoutTTY(self) -> None: """ L{TwistOptions.selectDefaultLogObserver} will not override an already selected observer. """ self.patchOpen() options = TwistOptions() options.opt_log_file("queso") # File, not a tty options.selectDefaultLogObserver() self.assertIdentical(options["fileLogObserverFactory"], jsonFileLogObserver) self.assertEqual(options["logFormat"], "json") def test_pluginsType(self) -> None: """ L{TwistOptions.plugins} is a mapping of available plug-ins. """ options = TwistOptions() plugins = options.plugins for name in plugins: self.assertIsInstance(name, str) self.assertIsInstance(plugins[name], ServiceMaker) def test_pluginsIncludeWeb(self) -> None: """ L{TwistOptions.plugins} includes a C{"web"} plug-in. This is an attempt to verify that something we expect to be in the list is in there without enumerating all of the built-in plug-ins. """ options = TwistOptions() self.assertIn("web", options.plugins) def test_subCommandsType(self) -> None: """ L{TwistOptions.subCommands} is an iterable of tuples as expected by L{twisted.python.usage.Options}. """ options = TwistOptions() for name, shortcut, parser, doc in options.subCommands: self.assertIsInstance(name, str) self.assertIdentical(shortcut, None) self.assertTrue(callable(parser)) self.assertIsInstance(doc, str) def test_subCommandsIncludeWeb(self) -> None: """ L{TwistOptions.subCommands} includes a sub-command for every plug-in. """ options = TwistOptions() plugins = set(options.plugins) subCommands = {name for name, shortcut, parser, doc in options.subCommands} self.assertEqual(subCommands, plugins) def test_postOptionsNoSubCommand(self) -> None: """ L{TwistOptions.postOptions} raises L{UsageError} is it has no sub-command. """ self.patchInstallReactor() options = TwistOptions() self.assertRaises(UsageError, options.postOptions) PK Mb�Z�&�9� � " application/twist/test/__init__.pynu �[��� # -*- test-case-name: twisted.application.twist.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.application.twist}. """ PK Mb�Z:�-�� � application/twist/_twist.pynu �[��� # -*- test-case-name: twisted.application.twist.test.test_twist -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Run a Twisted application. """ import sys from typing import Sequence from twisted.application.app import _exitWithSignal from twisted.internet.interfaces import IReactorCore, _ISupportsExitSignalCapturing from twisted.python.usage import Options, UsageError from ..runner._exit import ExitStatus, exit from ..runner._runner import Runner from ..service import Application, IService, IServiceMaker from ._options import TwistOptions class Twist: """ Run a Twisted application. """ @staticmethod def options(argv: Sequence[str]) -> TwistOptions: """ Parse command line options. @param argv: Command line arguments. @return: The parsed options. """ options = TwistOptions() try: options.parseOptions(argv[1:]) except UsageError as e: exit(ExitStatus.EX_USAGE, f"Error: {e}\n\n{options}") return options @staticmethod def service(plugin: IServiceMaker, options: Options) -> IService: """ Create the application service. @param plugin: The name of the plugin that implements the service application to run. @param options: Options to pass to the application. @return: The created application service. """ service = plugin.makeService(options) application = Application(plugin.tapname) service.setServiceParent(application) return IService(application) @staticmethod def startService(reactor: IReactorCore, service: IService) -> None: """ Start the application service. @param reactor: The reactor to run the service with. @param service: The application service to run. """ service.startService() # Ask the reactor to stop the service before shutting down reactor.addSystemEventTrigger("before", "shutdown", service.stopService) @staticmethod def run(twistOptions: TwistOptions) -> None: """ Run the application service. @param twistOptions: Command line options to convert to runner arguments. """ runner = Runner( reactor=twistOptions["reactor"], defaultLogLevel=twistOptions["logLevel"], logFile=twistOptions["logFile"], fileLogObserverFactory=twistOptions["fileLogObserverFactory"], ) runner.run() reactor = twistOptions["reactor"] if _ISupportsExitSignalCapturing.providedBy(reactor): if reactor._exitSignal is not None: _exitWithSignal(reactor._exitSignal) @classmethod def main(cls, argv: Sequence[str] = sys.argv) -> None: """ Executable entry point for L{Twist}. Processes options and run a twisted reactor with a service. @param argv: Command line arguments. @type argv: L{list} """ options = cls.options(argv) reactor = options["reactor"] # If subCommand is None, TwistOptions.parseOptions() raises UsageError # and Twist.options() will exit the runner, so we'll never get here. subCommand = options.subCommand assert subCommand is not None service = cls.service( plugin=options.plugins[subCommand], options=options.subOptions, ) cls.startService(reactor, service) cls.run(options) PK Mb�ZL �.� � application/twist/__init__.pynu �[��� # -*- test-case-name: twisted.application.twist.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ C{twist} command line tool. """ PK Mb�Zz����- �- application/service.pynu �[��� # -*- test-case-name: twisted.application.test.test_service -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Service architecture for Twisted. Services are arranged in a hierarchy. At the leafs of the hierarchy, the services which actually interact with the outside world are started. Services can be named or anonymous -- usually, they will be named if there is need to access them through the hierarchy (from a parent or a sibling). Maintainer: Moshe Zadka """ from zope.interface import Attribute, Interface, implementer from twisted.internet import defer from twisted.persisted import sob from twisted.plugin import IPlugin from twisted.python import components from twisted.python.reflect import namedAny class IServiceMaker(Interface): """ An object which can be used to construct services in a flexible way. This interface should most often be implemented along with L{twisted.plugin.IPlugin}, and will most often be used by the 'twistd' command. """ tapname = Attribute( "A short string naming this Twisted plugin, for example 'web' or " "'pencil'. This name will be used as the subcommand of 'twistd'." ) description = Attribute( "A brief summary of the features provided by this " "Twisted application plugin." ) options = Attribute( "A C{twisted.python.usage.Options} subclass defining the " "configuration options for this application." ) def makeService(options): """ Create and return an object providing L{twisted.application.service.IService}. @param options: A mapping (typically a C{dict} or L{twisted.python.usage.Options} instance) of configuration options to desired configuration values. """ @implementer(IPlugin, IServiceMaker) class ServiceMaker: """ Utility class to simplify the definition of L{IServiceMaker} plugins. """ def __init__(self, name, module, description, tapname): self.name = name self.module = module self.description = description self.tapname = tapname @property def options(self): return namedAny(self.module).Options @property def makeService(self): return namedAny(self.module).makeService class IService(Interface): """ A service. Run start-up and shut-down code at the appropriate times. """ name = Attribute("A C{str} which is the name of the service or C{None}.") running = Attribute("A C{boolean} which indicates whether the service is running.") parent = Attribute("An C{IServiceCollection} which is the parent or C{None}.") def setName(name): """ Set the name of the service. @type name: C{str} @raise RuntimeError: Raised if the service already has a parent. """ def setServiceParent(parent): """ Set the parent of the service. This method is responsible for setting the C{parent} attribute on this service (the child service). @type parent: L{IServiceCollection} @raise RuntimeError: Raised if the service already has a parent or if the service has a name and the parent already has a child by that name. """ def disownServiceParent(): """ Use this API to remove an L{IService} from an L{IServiceCollection}. This method is used symmetrically with L{setServiceParent} in that it sets the C{parent} attribute on the child. @rtype: L{Deferred<defer.Deferred>} @return: a L{Deferred<defer.Deferred>} which is triggered when the service has finished shutting down. If shutting down is immediate, a value can be returned (usually, L{None}). """ def startService(): """ Start the service. """ def stopService(): """ Stop the service. @rtype: L{Deferred<defer.Deferred>} @return: a L{Deferred<defer.Deferred>} which is triggered when the service has finished shutting down. If shutting down is immediate, a value can be returned (usually, L{None}). """ def privilegedStartService(): """ Do preparation work for starting the service. Here things which should be done before changing directory, root or shedding privileges are done. """ @implementer(IService) class Service: """ Base class for services. Most services should inherit from this class. It handles the book-keeping responsibilities of starting and stopping, as well as not serializing this book-keeping information. """ running = 0 name = None parent = None def __getstate__(self): dict = self.__dict__.copy() if "running" in dict: del dict["running"] return dict def setName(self, name): if self.parent is not None: raise RuntimeError("cannot change name when parent exists") self.name = name def setServiceParent(self, parent): if self.parent is not None: self.disownServiceParent() parent = IServiceCollection(parent, parent) self.parent = parent self.parent.addService(self) def disownServiceParent(self): d = self.parent.removeService(self) self.parent = None return d def privilegedStartService(self): pass def startService(self): self.running = 1 def stopService(self): self.running = 0 class IServiceCollection(Interface): """ Collection of services. Contain several services, and manage their start-up/shut-down. Services can be accessed by name if they have a name, and it is always possible to iterate over them. """ def getServiceNamed(name): """ Get the child service with a given name. @type name: C{str} @rtype: L{IService} @raise KeyError: Raised if the service has no child with the given name. """ def __iter__(): """ Get an iterator over all child services. """ def addService(service): """ Add a child service. Only implementations of L{IService.setServiceParent} should use this method. @type service: L{IService} @raise RuntimeError: Raised if the service has a child with the given name. """ def removeService(service): """ Remove a child service. Only implementations of L{IService.disownServiceParent} should use this method. @type service: L{IService} @raise ValueError: Raised if the given service is not a child. @rtype: L{Deferred<defer.Deferred>} @return: a L{Deferred<defer.Deferred>} which is triggered when the service has finished shutting down. If shutting down is immediate, a value can be returned (usually, L{None}). """ @implementer(IServiceCollection) class MultiService(Service): """ Straightforward Service Container. Hold a collection of services, and manage them in a simplistic way. No service will wait for another, but this object itself will not finish shutting down until all of its child services will finish. """ def __init__(self): self.services = [] self.namedServices = {} self.parent = None def privilegedStartService(self): Service.privilegedStartService(self) for service in self: service.privilegedStartService() def startService(self): Service.startService(self) for service in self: service.startService() def stopService(self): Service.stopService(self) l = [] services = list(self) services.reverse() for service in services: l.append(defer.maybeDeferred(service.stopService)) return defer.DeferredList(l) def getServiceNamed(self, name): return self.namedServices[name] def __iter__(self): return iter(self.services) def addService(self, service): if service.name is not None: if service.name in self.namedServices: raise RuntimeError( "cannot have two services with same name" " '%s'" % service.name ) self.namedServices[service.name] = service self.services.append(service) if self.running: # It may be too late for that, but we will do our best service.privilegedStartService() service.startService() def removeService(self, service): if service.name: del self.namedServices[service.name] self.services.remove(service) if self.running: # Returning this so as not to lose information from the # MultiService.stopService deferred. return service.stopService() else: return None class IProcess(Interface): """ Process running parameters. Represents parameters for how processes should be run. """ processName = Attribute( """ A C{str} giving the name the process should have in ps (or L{None} to leave the name alone). """ ) uid = Attribute( """ An C{int} giving the user id as which the process should run (or L{None} to leave the UID alone). """ ) gid = Attribute( """ An C{int} giving the group id as which the process should run (or L{None} to leave the GID alone). """ ) @implementer(IProcess) class Process: """ Process running parameters. Sets up uid/gid in the constructor, and has a default of L{None} as C{processName}. """ processName = None def __init__(self, uid=None, gid=None): """ Set uid and gid. @param uid: The user ID as whom to execute the process. If this is L{None}, no attempt will be made to change the UID. @param gid: The group ID as whom to execute the process. If this is L{None}, no attempt will be made to change the GID. """ self.uid = uid self.gid = gid def Application(name, uid=None, gid=None): """ Return a compound class. Return an object supporting the L{IService}, L{IServiceCollection}, L{IProcess} and L{sob.IPersistable} interfaces, with the given parameters. Always access the return value by explicit casting to one of the interfaces. """ ret = components.Componentized() availableComponents = [MultiService(), Process(uid, gid), sob.Persistent(ret, name)] for comp in availableComponents: ret.addComponent(comp, ignoreClass=1) IService(ret).setName(name) return ret def loadApplication(filename, kind, passphrase=None): """ Load Application from a given file. The serialization format it was saved in should be given as C{kind}, and is one of C{pickle}, C{source}, C{xml} or C{python}. If C{passphrase} is given, the application was encrypted with the given passphrase. @type filename: C{str} @type kind: C{str} @type passphrase: C{str} """ if kind == "python": application = sob.loadValueFromFile(filename, "application") else: application = sob.load(filename, kind) return application __all__ = [ "IServiceMaker", "IService", "Service", "IServiceCollection", "MultiService", "IProcess", "Process", "Application", "loadApplication", ] PK Mb�Z�jjrV� V� 0 application/__pycache__/internet.cpython-310.pycnu �[��� o �b,� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z m Z mZmZmZ ddlmZ dd lmZ dd lmZ d d � ZG d d� dej�ZG dd� de�ZG dd� de�ZdZ dZ G dd� de�Z G dd� de�Z G dd� de�Z G dd � d e�Z!G d d � d e�Z"G d d � d e�Z#G d!d"� d"e�Z$G d#d$� d$e�Z%G d%d&� d&e�Z&G d'd(� d(e�Z'G d)d*� d*e�Z(G d+d,� d,ej�Z)G d-d.� d.ej�Z*G d/d0� d0�Z+G d1d2� d2�Z,d3d4d5efd6d7�Z-e-� Z.d8d9� Z/G d:d;� d;�Z0G d<d=� d=ej�Z1g d>�Z2d?S )@a� Reactor-based Services Here are services to run clients, servers and periodic services using the reactor. If you want to run a server service, L{StreamServerEndpointService} defines a service that can wrap an arbitrary L{IStreamServerEndpoint <twisted.internet.interfaces.IStreamServerEndpoint>} as an L{IService}. See also L{twisted.application.strports.service} for constructing one of these directly from a descriptive string. Additionally, this module (dynamically) defines various Service subclasses that let you represent clients and servers in a Service hierarchy. Endpoints APIs should be preferred for stream server services, but since those APIs do not yet exist for clients or datagram services, many of these are still useful. They are as follows:: TCPServer, TCPClient, UNIXServer, UNIXClient, SSLServer, SSLClient, UDPServer, UNIXDatagramServer, UNIXDatagramClient, MulticastServer These classes take arbitrary arguments in their constructors and pass them straight on to their respective reactor.listenXXX or reactor.connectXXX calls. For example, the following service starts a web server on port 8080: C{TCPServer(8080, server.Site(r))}. See the documentation for the reactor.listen/connect* methods for more information. � )�random)�List)�MethodicalMachine)�service)�task)�CancelledError�Deferred�fail� maybeDeferred�succeed)�Logger)�log)�Failurec C s | du r ddl m} |S | S )zR @return: the argument, or the global reactor if the argument is L{None}. Nr )�reactor)�twisted.internetr )� maybeReactorr � r �>/usr/lib/python3/dist-packages/twisted/application/internet.py�_maybeGlobalReactor< s r c @ s& e Zd ZU g Zee ed< dd� ZdS )�_VolatileDataService�volatilec C s* t j�| �}| jD ] }||v r||= q |S �N)r �Service� __getstate__r )�self�d�attrr r r r L s �z!_VolatileDataService.__getstate__N)�__name__� __module__� __qualname__r r �str�__annotations__r r r r r r H s r c @ sT e Zd ZU dZdgZdZeed< dZdZ dd� Z dd � Z d d � Z d d � Z dd� ZdS )�_AbstractServera @cvar volatile: list of attribute to remove from pickling. @type volatile: C{list} @ivar method: the type of method to call on the reactor, one of B{TCP}, B{UDP}, B{SSL} or B{UNIX}. @type method: C{str} @ivar reactor: the current running reactor. @type reactor: a provider of C{IReactorTCP}, C{IReactorUDP}, C{IReactorSSL} or C{IReactorUnix}. @ivar _port: instance of port set when the service is started. @type _port: a provider of L{twisted.internet.interfaces.IListeningPort}. �_port� �methodNc O �$ || _ d|v r |�d�| _|| _d S �Nr ��args�popr �kwargs�r r) r+ r r r �__init__k � z_AbstractServer.__init__c C � t j�| � | �� | _d S r )r r �privilegedStartService�_getPortr# �r r r r r0 q � z&_AbstractServer.privilegedStartServicec C s( t j�| � | jd u r| �� | _d S d S r )r r � startServicer# r1 r2 r r r r4 u s �z _AbstractServer.startServicec C s, t j�| � | jd ur| j�� }| `|S d S r )r r � stopServicer# � stopListening)r r r r r r5 z s �z_AbstractServer.stopServicec C s& t t| j�d�| j��| ji | j��S )z� Wrapper around the appropriate listen method of the reactor. @return: the port object returned by the listen method. @rtype: an object providing L{twisted.internet.interfaces.IListeningPort}. zlisten{})�getattrr r �formatr% r) r+ r2 r r r r1 � s ����z_AbstractServer._getPort)r r r �__doc__r r% r r! r r# r- r0 r4 r5 r1 r r r r r" T s r" c @ sL e Zd ZU dZdgZdZeed< dZdZ dd� Z dd � Z d d � Z d d � Z dS )�_AbstractClienta& @cvar volatile: list of attribute to remove from pickling. @type volatile: C{list} @ivar method: the type of method to call on the reactor, one of B{TCP}, B{UDP}, B{SSL} or B{UNIX}. @type method: C{str} @ivar reactor: the current running reactor. @type reactor: a provider of C{IReactorTCP}, C{IReactorUDP}, C{IReactorSSL} or C{IReactorUnix}. @ivar _connection: instance of connection set when the service is started. @type _connection: a provider of L{twisted.internet.interfaces.IConnector}. � _connectionr$ r% Nc O r& r' r( r, r r r r- � r. z_AbstractClient.__init__c C r/ r )r r r4 �_getConnectionr; r2 r r r r4 � r3 z _AbstractClient.startServicec C s, t j�| � | jd ur| j�� | `d S d S r )r r r5 r; � disconnectr2 r r r r5 � s �z_AbstractClient.stopServicec C s& t t| j�d| j� ��| ji | j��S )z� Wrapper around the appropriate connect method of the reactor. @return: the port object returned by the connect method. @rtype: an object providing L{twisted.internet.interfaces.IConnector}. �connect)r7 r r r% r) r+ r2 r r r r< � s ��z _AbstractClient._getConnection)r r r r9 r r% r r! r r; r- r4 r5 r< r r r r r: � s r: ztConnect to {tran} Call reactor.connect{tran} when the service starts, with the arguments given to the constructor. z�Serve {tran} clients Call reactor.listen{tran} when the service starts, with the arguments given to the constructor. When the service stops, stop listening. See twisted.internet.interfaces for documentation on arguments to the reactor method. c @ � e Zd Zejdd�ZdZdS )� TCPServer�TCP��tranN�r r r � _serverDocr8 r9 r% r r r r r@ � � r@ c @ r? )� TCPClientrA rB N�r r r � _clientDocr8 r9 r% r r r r rG � rF rG c @ r? )� UNIXServer�UNIXrB NrD r r r r rJ � rF rJ c @ r? )� UNIXClientrK rB NrH r r r r rL � rF rL c @ r? )� SSLServer�SSLrB NrD r r r r rM � rF rM c @ r? )� SSLClientrN rB NrH r r r r rO � rF rO c @ r? )� UDPServer�UDPrB NrD r r r r rP � rF rP c @ r? )�UNIXDatagramServer� UNIXDatagramrB NrD r r r r rR � rF rR c @ r? )�UNIXDatagramClientrS rB NrH r r r r rT � rF rT c @ r? )�MulticastServer� MulticastrB NrD r r r r rU rF rU c @ s8 e Zd ZdZddgZdd� Zdd� Zdd � Zd d � Zd S ) � TimerServicea� Service to periodically call a function Every C{step} seconds call the given function with the given arguments. The service starts the calls when it starts, and cancels them when it stops. @ivar clock: Source of time. This defaults to L{None} which is causes L{twisted.internet.reactor} to be used. Feel free to set this to something else, but it probably ought to be set *before* calling L{startService}. @type clock: L{IReactorTime<twisted.internet.interfaces.IReactorTime>} @ivar call: Function and arguments to call periodically. @type call: L{tuple} of C{(callable, args, kwargs)} �_loop� _loopFinishedc O s || _ |||f| _d| _dS )a+ @param step: The number of seconds between calls. @type step: L{float} @param callable: Function to call @type callable: L{callable} @param args: Positional arguments to pass to function @param kwargs: Keyword arguments to pass to function N)�step�call�clock)r rZ �callabler) r+ r r r r- s zTimerService.__init__c C sf t j�| � | j\}}}tj|g|�R i |��| _t| j�| j_| jj | j dd�| _ | j � | j � d S )NT)�now)r r r4 r[ r � LoopingCallrX r r\ �startrZ rY � addErrback�_failed)r r] r) r+ r r r r4 * s zTimerService.startServicec C s d| j _t�|� d S �NF)rX �runningr �err)r �whyr r r rb 6 s zTimerService._failedc s, � j jr � j �� � j�� fdd�� � jS )z� Stop the service. @rtype: L{Deferred<defer.Deferred>} @return: a L{Deferred<defer.Deferred>} which is fired when the currently running call (if any) is finished. c s t j�� �S r )r r r5 ��_r2 r r �<lambda>G s z*TimerService.stopService.<locals>.<lambda>)rX rd �stoprY � addCallbackr2 r r2 r r5 = s zTimerService.stopServiceN) r r r r9 r r- r4 rb r5 r r r r rW s rW c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �CooperatorServicezb Simple L{service.IService} which starts and stops a L{twisted.internet.task.Cooperator}. c C s t jdd�| _d S )NF)�started)r � Cooperator�coopr2 r r r r- P s zCooperatorService.__init__c C � | j �|�S r )ro � coiterate)r �iteratorr r r rq S � zCooperatorService.coiteratec C � | j �� d S r )ro r` r2 r r r r4 V � z CooperatorService.startServicec C rt r )ro rj r2 r r r r5 Y ru z CooperatorService.stopServiceN)r r r r9 r- rq r4 r5 r r r r rl K s rl c @ s4 e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd S ) �StreamServerEndpointServiceaP A L{StreamServerEndpointService} is an L{IService} which runs a server on a listening port described by an L{IStreamServerEndpoint <twisted.internet.interfaces.IStreamServerEndpoint>}. @ivar factory: A server factory which will be used to listen on the endpoint. @ivar endpoint: An L{IStreamServerEndpoint <twisted.internet.interfaces.IStreamServerEndpoint>} provider which will be used to listen when the service starts. @ivar _waitingForPort: a Deferred, if C{listen} has yet been invoked on the endpoint, otherwise None. @ivar _raiseSynchronously: Defines error-handling behavior for the case where C{listen(...)} raises an exception before C{startService} or C{privilegedStartService} have completed. @type _raiseSynchronously: C{bool} @since: 10.2 Fc C s || _ || _d | _d S r )�endpoint�factory�_waitingForPort)r rw rx r r r r- x s z$StreamServerEndpointService.__init__c sT t j��� �j��j��_g � � �fdd�}�j�|� � r%� d �� d�_ dS )z2 Start listening on the endpoint. c s0 �j r � �| � d S | �t�st�| � d S d S r )�_raiseSynchronously�append�checkr r re )re �� raisedNowr r r �handleIt� s �zDStreamServerEndpointService.privilegedStartService.<locals>.handleItr FN) r r r0 rw �listenrx ry ra �raiseExceptionrz )r r r r} r r0 } s z2StreamServerEndpointService.privilegedStartServicec C s& t j�| � | jdu r| �� dS dS )zu Start listening on the endpoint, unless L{privilegedStartService} got around to it already. N)r r r4 ry r0 r2 r r r r4 � s �z(StreamServerEndpointService.startServicec s8 � j �� dd� }� j �|�}� fdd�}|�|� |S )a Stop listening on the port if it is already listening, otherwise, cancel the attempt to listen. @return: a L{Deferred<twisted.internet.defer.Deferred>} which fires with L{None} when the port has stopped listening. c S s | d ur| � � S d S r )r6 )�portr r r �stopIt� s �z7StreamServerEndpointService.stopService.<locals>.stopItc s d� _ | S rc )rd )� passthroughr2 r r rj � s z5StreamServerEndpointService.stopService.<locals>.stop)ry �cancelrk �addBoth)r r� r rj r r2 r r5 � s z'StreamServerEndpointService.stopServiceN) r r r r9 rz r- r0 r4 r5 r r r r rv ] s rv c @ �6 e Zd ZdZdd� Zdd� Zdd� Zdefd d �Zd S ) �_ReconnectingProtocolProxyz� A proxy for a Protocol to provide connectionLost notification to a client connection service, in support of reconnecting when connections are lost. c C s || _ || _dS )a� Create a L{_ReconnectingProtocolProxy}. @param protocol: the application-provided L{interfaces.IProtocol} provider. @type protocol: provider of L{interfaces.IProtocol} which may additionally provide L{interfaces.IHalfCloseableProtocol} and L{interfaces.IFileDescriptorReceiver}. @param lostNotification: a 1-argument callable to invoke with the C{reason} when the connection is lost. N)� _protocol�_lostNotification)r �protocol�lostNotificationr r r r- � s z#_ReconnectingProtocolProxy.__init__c C s& z | j �|�W | �|� S | �|� w )z� The connection was lost. Relay this information. @param reason: The reason the connection was lost. @return: the underlying protocol's result )r� �connectionLostr� )r �reasonr r r r� � s z)_ReconnectingProtocolProxy.connectionLostc C � t | j|�S r )r7 r� �r �itemr r r � __getattr__� rs z&_ReconnectingProtocolProxy.__getattr__�returnc C s d| j j� d| j�d�S )N�<z wrapping �>)� __class__r r� r2 r r r �__repr__� s z#_ReconnectingProtocolProxy.__repr__N) r r r r9 r- r� r� r r� r r r r r� � s r� c @ r� ) �_DisconnectFactoryz� A L{_DisconnectFactory} is a proxy for L{IProtocolFactory} that catches C{connectionLost} notifications and relays them. c C s || _ || _d S r )�_protocolFactory�_protocolDisconnected)r �protocolFactory�protocolDisconnectedr r r r- � s z_DisconnectFactory.__init__c C s t | j�|�| j�S )a2 Create a L{_ReconnectingProtocolProxy} with the disconnect-notification callback we were called with. @param addr: The address the connection is coming from. @return: a L{_ReconnectingProtocolProxy} for a protocol produced by C{self._protocolFactory} )r� r� � buildProtocolr� )r �addrr r r r� � s �z _DisconnectFactory.buildProtocolc C r� r )r7 r� r� r r r r� � rs z _DisconnectFactory.__getattr__r� c C s d� | jj| j�S )Nz<{} wrapping {!r}>)r8 r� r r� r2 r r r r� � s �z_DisconnectFactory.__repr__N) r r r r9 r- r� r� r r� r r r r r� � s r� g �?g N@g �?c s � ���fdd�}|S )a� A timeout policy for L{ClientService} which computes an exponential backoff interval with configurable parameters. @since: 16.1.0 @param initialDelay: Delay for the first reconnection attempt (default 1.0s). @type initialDelay: L{float} @param maxDelay: Maximum number of seconds between connection attempts (default 60 seconds, or one minute). Note that this value is before jitter is applied, so the actual maximum possible delay is this value plus the maximum possible result of C{jitter()}. @type maxDelay: L{float} @param factor: A multiplicative factor by which the delay grows on each failed reattempt. Default: 1.5. @type factor: L{float} @param jitter: A 0-argument callable that introduces noise into the delay. By default, C{random.random}, i.e. a pseudorandom floating-point value between zero and one. @type jitter: 0-argument callable returning L{float} @return: a 1-argument callable that, given an attempt count, returns a floating point number; the number of seconds to delay. @rtype: see L{ClientService.__init__}'s C{retryPolicy} argument. c s> zt �� t d| � ��}W n ty �}Y nw |�� S )N�d )�min� OverflowError)�attempt�delay��factor� initialDelay�jitter�maxDelayr r �policy s � z backoffPolicy.<locals>.policyr )r� r� r� r� r� r r� r � backoffPolicy� s !r� c C s t | �d S )aO Return the first element of a generator and exhaust it. C{MethodicalMachine.upon}'s C{collector} argument takes a generator of output results. If the generator is exhausted, the later outputs aren't actually run. @param gen: Generator to extract values from @return: The first element of the generator. r )�list)�genr r r � _firstResult* s r� c @ s| e Zd ZdZe� Zdd� Zejdd�dd� �Ze�� dd � �Z e�� d d � �Z e�� d d � �Z e�� dd� �Z e�� dd� �Z e�� dd� �Ze�� dd� �Ze�� dd� �Zdd� Ze�� dd� �Ze�� d d � �Ze�� d d � �Ze�� d d!� �Ze�� d"d#� �Ze�� d$d%� �Ze�� d&d'� �Ze�� d(d)� �Ze�� d*d+� �Z e�� d,d-� �Z e�� d.d/� �Z d0d1� Z e�� d2d3� �Z e�� d4d5� �Z!e�� d6d7� �Z"e�� d8d9� �Z#e�� d:d;� �Z$e�� d<d=� �Z%e�� d>d?� �Z&d@dA� Z'e�� dSdCdD��Z(e�� dSdEdF��Z)e�� dSdGdH��Z*e�� dSdIdJ��Z+e�� dKdL� �Z,dMdN� Z-e�� dOdP� �Z.ej/ee egdQ� ej/eee,ge0dR� e j/ee g dQ� e j/ee eege0dR� e j/ee egdQ� e j/e e e e.gdQ� e j/ee g dQ� e j/eeee#ee%ge0dR� e j/e e egdQ� e j/ee g dQ� e j/ee eege0dR� e j/e!e e"e gdQ� e j/ee egdQ� e j/ee ege0dR� e j/e!ee#e%e"gdQ� e j/e ee$e&gdQ� e j/ee g dQ� e j/ee ege0dR� e j/e!e e%egdQ� ej/ee egdQ� ej/eee,ge0dR� ej/e(ee+ge0dR� e j/e(e e+ge0dR� e j/e(e e+ge0dR� e j/e(e e)ge0dR� e j/e(e e+ge0dR� e j/e(e e+ge0dR� ej/e(ee*ge0dR� dBS )T�_ClientMachinea State machine for maintaining a single outgoing connection to an endpoint. @ivar _awaitingConnected: notifications to make when connection succeeds, fails, or is cancelled @type _awaitingConnected: list of (Deferred, count) tuples @see: L{ClientService} c C sJ || _ d| _d| _|| _|| _|| _|| _td�| _g | _ g | _ || _ dS )z� @see: L{ClientService.__init__} @param log: The logger for the L{ClientService} instance this state machine is associated to. @type log: L{Logger} r FN) � _endpoint�_failedAttempts�_stopped�_factory�_timeoutForAttempt�_clock�_prepareConnectionr �_connectionInProgress�_awaitingConnected� _stopWaiters�_log)r rw rx � retryPolicyr\ �prepareConnectionr r r r r- F s z_ClientMachine.__init__T)�initialc C � dS )z3 The service has not been started. Nr r2 r r r �_init\ � z_ClientMachine._initc C r� )z5 The service has started connecting. Nr r2 r r r � _connectingb r� z_ClientMachine._connectingc C r� )za The service is waiting for the reconnection period before reconnecting. Nr r2 r r r �_waitingh r� z_ClientMachine._waitingc C r� )z+ The service is connected. Nr r2 r r r � _connectedo r� z_ClientMachine._connectedc C r� )zM The service is disconnecting after being asked to shutdown. Nr r2 r r r �_disconnectingu r� z _ClientMachine._disconnectingc C r� )zM The service is disconnecting and has been asked to restart. Nr r2 r r r � _restarting{ r� z_ClientMachine._restartingc C r� )zC The service has been stopped and is disconnected. Nr r2 r r r r� � r� z_ClientMachine._stoppedc C r� )�T Start this L{ClientService}, initiating the connection retry loop. Nr r2 r r r r` � r� z_ClientMachine.startc s> t � j� fdd��}� j�|��� j��� j��� j�� _ dS )z- Start a connection attempt. c s � � � S r )�_clientDisconnectedrg r2 r r ri � s z)_ClientMachine._connect.<locals>.<lambda>N) r� r� r� r> rk �_runPrepareConnection�_connectionMadera �_connectionFailedr� )r � factoryProxyr r2 r �_connect� s � �z_ClientMachine._connectc s$ | j rt| j � ��� fdd��S � S )am Run any C{prepareConnection} callback with the connected protocol, ignoring its return value but propagating any failure. @param protocol: The protocol of the connection. @type protocol: L{IProtocol} @return: Either: - A L{Deferred} that succeeds with the protocol when the C{prepareConnection} callback has executed successfully. - A L{Deferred} that fails when the C{prepareConnection} callback throws or returns a failed L{Deferred}. - The protocol, when no C{prepareConnection} callback is defined. c s � S r r rg �r� r r ri � r� z6_ClientMachine._runPrepareConnection.<locals>.<lambda>)r� r rk �r r� r r� r r� � s �z$_ClientMachine._runPrepareConnectionc C s d| _ dS )z6 Reset the number of failed attempts. r N)r� r2 r r r �_resetFailedAttempts� s z#_ClientMachine._resetFailedAttemptsc C r� )z� Stop trying to connect and disconnect any current connection. @return: a L{Deferred} that fires when all outstanding connections are closed and all in-progress connection attempts halted. Nr r2 r r r rj � r� z_ClientMachine.stopc C s | j �t� � | j d S )z� Return a deferred that will fire when the service has finished disconnecting. @return: L{Deferred} that fires when the service has finished disconnecting. ���)r� r{ r r2 r r r � _waitForStop� s z_ClientMachine._waitForStopc C s | j �� dS )z2 Stop pending connection attempt. N)r� r� r2 r r r �_stopConnecting� s z _ClientMachine._stopConnectingc C s | j �� | ` dS )z4 Stop pending attempt to reconnect. N)� _retryCallr� r2 r r r � _stopRetrying� s z _ClientMachine._stopRetryingc C s | j j�� dS )z4 Disconnect the current connection. N)�_currentConnection� transport�loseConnectionr2 r r r � _disconnect� s z_ClientMachine._disconnectc C r� )z� A connection has been made. @param protocol: The protocol of the connection. @type protocol: L{IProtocol} Nr r� r r r r� � r� z _ClientMachine._connectionMadec C s d| _ |j| _| �| j� dS )z� Notify all pending requests for a connection that a connection has been made. @param protocol: The protocol of the connection. @type protocol: L{IProtocol} r N)r� r� r� �_unawaitr� r r r �_notifyWaiters� s z _ClientMachine._notifyWaitersc C r� )z8 The current connection attempt failed. Nr �r �fr r r r� r� z _ClientMachine._connectionFailedc C � | � � dS )z+ Schedule a retry attempt. N��_doWaitr2 r r r �_wait � z_ClientMachine._waitc C s | � � S )zM Schedule a retry attempt, and ignore the Failure passed in. r� r� r r r �_ignoreAndWait � z _ClientMachine._ignoreAndWaitc C sH | j d7 _ | �| j �}| jjd| j | j|d� | j�|| j�| _d S )N� zDScheduling retry {attempt} to connect {endpoint} in {delay} seconds.)r� rw r� ) r� r� r� �infor� r� � callLater� _reconnectr� )r r� r r r r� s �z_ClientMachine._doWaitc C r� )z? The wait between connection attempts is done. Nr r2 r r r r� r� z_ClientMachine._reconnectc C r� )z? The current connection has been disconnected. Nr r2 r r r r� % r� z"_ClientMachine._clientDisconnectedc C s | ` dS )z0 Forget the current connection. N)r� r2 r r r �_forgetConnection+ r� z _ClientMachine._forgetConnectionc C � | � tt� �� dS )zm Notify all pending requests for a connection that no more connections are expected. N�r� r r r2 r r r �_cancelConnectWaiters2 � z$_ClientMachine._cancelConnectWaitersc C r� )z� Notify all pending requests for a connection that no more connections are expected, after ignoring the Failure passed in. Nr� r� r r r � _ignoreAndCancelConnectWaiters: r� z-_ClientMachine._ignoreAndCancelConnectWaitersc C r� )zG Notify all deferreds waiting on the service stopping. N��_doFinishStoppingr2 r r r �_finishStoppingB r� z _ClientMachine._finishStoppingc C r� )zq Notify all deferreds waiting on the service stopping, and ignore the Failure passed in. Nr� r� r r r �_ignoreAndFinishStoppingI s z'_ClientMachine._ignoreAndFinishStoppingc C s& g | j | _ }|D ]}|�d � q d S r )r� �callback)r �waiting�wr r r r� Q s �z _ClientMachine._doFinishStoppingNc C r� )�i Retrieve the currently-connected L{Protocol}, or the next one to connect. @param failAfterFailures: number of connection failures after which the Deferred will deliver a Failure (None means the Deferred will only fail if/when the service is stopped). Set this to 1 to make the very first connection failure signal an error. Use 2 to allow one failure but signal an error if the subsequent retry then fails. @type failAfterFailures: L{int} or None @return: a Deferred that fires with a protocol produced by the factory passed to C{__init__} @rtype: L{Deferred} that may: - fire with L{IProtocol} - fail with L{CancelledError} when the service is stopped - fail with e.g. L{DNSLookupError<twisted.internet.error.DNSLookupError>} or L{ConnectionRefusedError<twisted.internet.error.ConnectionRefusedError>} when the number of consecutive failed connection attempts equals the value of "failAfterFailures" Nr �r �failAfterFailuresr r r � whenConnectedV r� z _ClientMachine.whenConnectedc C s t | j�S )z� Return the currently connected protocol. @return: L{Deferred} that is fired with currently connected protocol. )r r� r� r r r r� s � z!_ClientMachine._currentConnectionc C s t t� �S )z� Notify the caller that no connection is expected. @return: L{Deferred} that is fired with L{CancelledError}. )r r r� r r r � _noConnection| r� z _ClientMachine._noConnectionc C s t � }| j�||f� |S )z� Return a deferred that will fire with the next connected protocol. @return: L{Deferred} that will fire with the next connected protocol. )r r� r{ )r r� �resultr r r �_awaitingConnection� s z"_ClientMachine._awaitingConnectionc C s t d�S )z� Return a deferred that has already fired with L{None}. @return: A L{Deferred} that has already fired with L{None}. N)r r2 r r r �_deferredSucceededWithNone� s z)_ClientMachine._deferredSucceededWithNonec C s* g | j | _ }|D ] \}}|�|� q dS )z� Fire all outstanding L{ClientService.whenConnected} L{Deferred}s. @param value: the value to fire the L{Deferred}s with. N)r� r� )r �valuer� r� � remainingr r r r� � s �z_ClientMachine._unawaitc C st g }g }| j D ]#\}}|du r|�||f� q|dkr!|�|� q|�||d f� q|| _ |D ]}|�|� q0dS )z� Deliver connection failures to any L{ClientService.whenConnected} L{Deferred}s that have met their failAfterFailures threshold. @param f: the Failure to fire the L{Deferred}s with. Nr� )r� r{ r� )r r� �ready�notReadyr� r� r r r �_deliverConnectionFailure� s �z(_ClientMachine._deliverConnectionFailure)�enter�outputs)r r � collectorr )1r r r r9 r �_machiner- �stater� r� r� r� r� r� r� �inputr` �outputr� r� r� rj r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r �uponr� r r r r r� 9 sf ��� �� � ��� � �������� �r� c sH e Zd ZdZe� Z d dd�Zd dd�Z� fdd�Z� fd d �Z � Z S ) � ClientServicez� A L{ClientService} maintains a single outgoing connection to a client endpoint, reconnecting after a configurable timeout when a connection fails, either before or after connecting. @since: 16.1.0 Nc C s4 t |�}|du r tn|}t|||||| jd�| _dS )aZ @param endpoint: A L{stream client endpoint <interfaces.IStreamClientEndpoint>} provider which will be used to connect when the service starts. @param factory: A L{protocol factory <interfaces.IProtocolFactory>} which will be used to create clients for the endpoint. @param retryPolicy: A policy configuring how long L{ClientService} will wait between attempts to connect to C{endpoint}. @type retryPolicy: callable taking (the number of failed connection attempts made in a row (L{int})) and returning the number of seconds to wait before making another attempt. @param clock: The clock used to schedule reconnection. It's mainly useful to be parametrized in tests. If the factory is serialized, this attribute will not be serialized, and the default value (the reactor) will be restored when deserialized. @type clock: L{IReactorTime} @param prepareConnection: A single argument L{callable} that may return a L{Deferred}. It will be called once with the L{protocol <interfaces.IProtocol>} each time a new connection is made. It may call methods on the protocol to prepare it for use (e.g. authenticate) or validate it (check its health). The C{prepareConnection} callable may raise an exception or return a L{Deferred} which fails to reject the connection. A rejected connection is not used to fire an L{Deferred} returned by L{whenConnected}. Instead, L{ClientService} handles the failure and continues as if the connection attempt were a failure (incrementing the counter passed to C{retryPolicy}). L{Deferred}s returned by L{whenConnected} will not fire until any L{Deferred} returned by the C{prepareConnection} callable fire. Otherwise its successful return value is consumed, but ignored. Present Since Twisted 18.7.0 @type prepareConnection: L{callable} N)r� r )r �_defaultPolicyr� r� r )r rw rx r� r\ r� r r r r- ; s . �zClientService.__init__c C rp )r� )r r� r� r r r r� u s zClientService.whenConnectedc s. | j r | j�d� dS t� �� | j�� dS )r� z1Duplicate ClientService.startService {log_source}N)rd r� �warn�superr4 r r` r2 �r� r r r4 � s zClientService.startServicec s t � �� | j�� S )z� Stop attempting to reconnect and close any existing connections. @return: a L{Deferred} that fires when all outstanding connections are closed and all in-progress connection attempts halted. )r r5 r rj r2 r r r r5 � s zClientService.stopService)NNNr ) r r r r9 r r� r- r� r4 r5 � __classcell__r r r r r 0 s � : r )rW rl rU rv rP r r@ rG rJ rL rM rO rR rT N)3r9 r �_goodEnoughRandom�typingr �automatr �twisted.applicationr r r �twisted.internet.deferr r r r r �twisted.loggerr �twisted.pythonr �twisted.python.failurer r r r r" r: rI rE r@ rG rJ rL rM rO rP rR rT rU rW rl rv r� r� r� r r� r� r �__all__r r r r �<module> sR $ ?3 DT*" �+ z wPK Mb�Z�9�A� � 0 application/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z1 Configuration objects for Twisted Applications. N)�__doc__� r r �>/usr/lib/python3/dist-packages/twisted/application/__init__.py�<module> s PK Mb�Z��!)J J 0 application/__pycache__/strports.cpython-310.pycnu �[��� o �b! � @ s� d Z ddlmZmZ ddlmZ ddlmZmZ dej fdd�Z dd e d ej d eej defd d �Z d e d ej dejfdd�Zd dgZdS )z� Construct listening port services from a simple string description. @see: L{twisted.internet.endpoints.serverFromString} @see: L{twisted.internet.endpoints.clientFromString} � )�Optional�cast)�StreamServerEndpointService)� endpoints� interfaces�returnc C s ddl m} ttj| �S )Nr ��reactor)�twisted.internetr r r � IReactorCorer � r �>/usr/lib/python3/dist-packages/twisted/application/strports.py� _getReactor s r N� description�factoryr c C s* |du rt � }tt�|| �|�}d|_|S )aj Return the service corresponding to a description. @param description: The description of the listening port, in the syntax described by L{twisted.internet.endpoints.serverFromString}. @type description: C{str} @param factory: The protocol factory which will build protocols for connections to this service. @type factory: L{twisted.internet.interfaces.IProtocolFactory} @rtype: C{twisted.application.service.IService} @return: the service corresponding to a description of a reliable stream server. @see: L{twisted.internet.endpoints.serverFromString} NT)r r r �serverFromString�_raiseSynchronously)r r r �svcr r r �service s �r c C s> ddl m} t�| |�\}}}ttjt|d| �|i |���S )ac Listen on a port corresponding to a description. @param description: The description of the connecting port, in the syntax described by L{twisted.internet.endpoints.serverFromString}. @type description: L{str} @param factory: The protocol factory which will build protocols on connection. @type factory: L{twisted.internet.interfaces.IProtocolFactory} @rtype: L{twisted.internet.interfaces.IListeningPort} @return: the port corresponding to a description of a reliable virtual circuit server. @see: L{twisted.internet.endpoints.serverFromString} r r �listen)r r r � _parseServerr r �IListeningPort�getattr)r r r �name�args�kwr r r r 7 s �r )N)�__doc__�typingr r � twisted.application.internetr r r r r r �str�IProtocolFactoryr r r �__all__r r r r �<module> s. ���� � �� � PK Mb�Zd�]�V �V + application/__pycache__/app.cpython-310.pycnu �[��� o �bqZ � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlmZ d dl m Z m Z m Z d dl mZmZ d dlmZmZ d dlmZ d dlmZ d dlmZ d d lmZmZm Z m Z m Z m Z d d l m!Z!m"Z"m#Z# G d d � d �Z$G d d� de$�Z%G dd� de$�Z&G dd� d�Z'G dd� d�Z(dd� Z)d/dd�Z*dd� Z+dd � Z,G d d � d �Z-d d � Z.d!d"� Z/G d#d$� d$�Z0G d%d&� d&e j1e0�Z2d'd(� Z3d)d*� Z4d+d,� Z5d-d.� Z6dS )0� N)� attrgetter)� copyright�logger�plugin)�reactors�service)� NoSuchReactor�installReactor)�defer)� _ISupportsExitSignalCapturing)�sob)�failure�log�logfile�runtime�usage�util)�namedAny� namedModule�qualc @ s e Zd ZdZdd� Zdd� ZdS )�_BasicProfilerz� @ivar saveStats: if C{True}, save the stats information instead of the human readable format @type saveStats: C{bool} @ivar profileOutput: the name of the file use to print profile data. @type profileOutput: C{str} c C s || _ || _d S �N)� profileOutput� saveStats)�selfr r � r �9/usr/lib/python3/dist-packages/twisted/application/app.py�__init__% s z_BasicProfiler.__init__c C s d|� d|� �}|d7 }t |��)z� Helper method to report an import error with a profile module. This has to be explicit because some of these modules are removed by distributions due to them being non-free. zFailed to import module �: z� This is most likely caused by your operating system not including the module due to it being non-free. Either do not use the option --profile, or install the module; your operating system vendor may provide it in a separate package. )� SystemExit)r �module�e�sr r r �_reportImportError) s z!_BasicProfiler._reportImportErrorN)�__name__� __module__� __qualname__�__doc__r r# r r r r r s r c @ � e Zd ZdZdd� ZdS )� ProfileRunnerz1 Runner for the standard profile module. c C s� zddl }W n ty } z | �d|� W Y d}~nd}~ww |�� }|�|j� | jr4|�| j� dS t j t | jd�}t _ z|� � W |t j t _ }|� � dS |t j t _ }|� � w )z: Run reactor under the standard profiler. r N�profile�a)r* � ImportErrorr# �Profile�runcall�runr � dump_statsr �sys�stdout�open� print_stats�close)r �reactorr* r! �p�tmpr r r r/ > s" �� � zProfileRunner.runN�r$ r% r& r' r/ r r r r r) 9 � r) c @ r( )�CProfileRunnerz) Runner for the cProfile module. c C s� z ddl }ddl}W n ty" } z | �d|� W Y d}~nd}~ww |�� }|�|j� | jr8|�| j � dS t | j d�� }|j ||d�}|� � |� d� |�� W d � dS 1 s^w Y dS )z: Run reactor under the cProfile profiler. r N�cProfile�w)�stream���)r< �pstatsr, r# r- r. r/ r r0 r r3 �Stats� strip_dirs� sort_statsr4 )r r6 r< r@ r! r7 r> r" r r r r/ Y s" �� "�zCProfileRunner.runNr9 r r r r r; T r: r; c @ s" e Zd ZdZeed�Zdd� ZdS )� AppProfilerz� Class which selects a specific profile runner based on configuration options. @ivar profiler: the name of the selected profiler. @type profiler: C{str} )r* �cprofilec C sd |� dd�}|� dd �}|� dd��� | _| j| jv r*| j| j ||�}|j| _d S td| j� ���)N� savestatsFr* �profilerrE zUnsupported profiler name: )�get�lowerrG � profilersr/ r )r �optionsr r rG r r r r z s zAppProfiler.__init__N)r$ r% r& r' r) r; rJ r r r r r rD o s rD c @ s< e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z dS ) � AppLoggera] An L{AppLogger} attaches the configured log observer specified on the commandline to a L{ServerOptions} object, a custom L{logger.ILogObserver}, or a legacy custom {log.ILogObserver}. @ivar _logfilename: The name of the file to which to log, if other than the default. @type _logfilename: C{str} @ivar _observerFactory: Callable object that will create a log observer, or None. @ivar _observer: log observer added at C{start} and removed at C{stop}. @type _observer: a callable that implements L{logger.ILogObserver} or L{log.ILogObserver}. Nc C s" |� dd�| _|� d�p d| _dS )zE Initialize an L{AppLogger} with a L{ServerOptions}. r � r N)rH � _logfilename�_observerFactory�r rK r r r r � s zAppLogger.__init__c C s� | j dur | � � }n|�tjd�}|du r |�tjd�}|du r$| �� }|| _tj�| j�r3| jg}n tj�| j�rBt�| j�g}nt j dt dd� t�| j�g}tj � |� | �� dS )a� Initialize the global logging system for the given application. If a custom logger was specified on the command line it will be used. If not, and an L{logger.ILogObserver} or legacy L{log.ILogObserver} component has been set on C{application}, then it will be used as the log observer. Otherwise a log observer will be created based on the command line options for built-in loggers (e.g. C{--logfile}). @param application: The application on which to check for an L{logger.ILogObserver} or legacy L{log.ILogObserver}. @type application: L{twisted.python.components.Componentized} NaZ Passing a logger factory which makes log observers which do not implement twisted.logger.ILogObserver or twisted.python.log.ILogObserver to twisted.application.app.AppLogger was deprecated in Twisted 16.2. Please use a factory that produces twisted.logger.ILogObserver (or the legacy twisted.python.log.ILogObserver) implementing objects instead.� )� stacklevel)rO � getComponentr � ILogObserverr �_getLogObserver� _observer� providedBy�LegacyLogObserverWrapper�warnings�warn�DeprecationWarning�globalLogBeginner�beginLoggingTo� _initialLog)r � application�observer� observersr r r �start� s( � zAppLogger.startc C sJ ddl m} t�| �jdtjtjt � � d� t�| �jdt |j �d� dS )z1 Print twistd start log message. r �r6 z1twistd {version} ({exe} {pyVersion}) starting up.)�version�exe� pyVersionzreactor class: {reactor}.N) �twisted.internetr6 r � _loggerFor�infor rd r1 � executabler �shortPythonVersionr � __class__)r r6 r r r r^ � s � �zAppLogger._initialLogc C s0 | j dks| j s tj}ntj�| j �}t�|�S )zr Create a log observer to be added to the logging system before running this application. �-)rN r1 r2 r �LogFile� fromFullPathr �textFileLogObserver)r �logFiler r r rU � s zAppLogger._getLogObserverc C s6 t �| ��d� | jdurt j�| j� d| _dS dS )zS Remove all log observers previously set up by L{AppLogger.start}. zServer Shut Down.N)r rh ri rV �globalLogPublisher�removeObserver�r r r r �stop� s �zAppLogger.stop) r$ r% r& r' rV r rb r^ rU ru r r r r rL � s 2 rL c C s4 dd� } dd� }dd� }|t j_| t j_|t j_d S )Nc S s. | � � | �� ddlm} |�d|j� dS )Nr rc � )�clear_all_breaks� set_continuerg r6 � callLaterru )r �argr6 r r r �do_stop� s zfixPdb.<locals>.do_stopc S s t d� d S )NzEstop - Continue execution, then cleanly shutdown the twisted reactor.)�printrt r r r � help_stop s �zfixPdb.<locals>.help_stopc S s t �d� d S )Nr )�os�_exitrt r r r �set_quit s zfixPdb.<locals>.set_quit)�pdb�Pdbr� r{ r} )r{ r} r� r r r �fixPdb� s r� c C s |du r ddl m} zG| d r |dur|�|� W dS W dS | d rK|t_|t_tjdkr?t�tj dd� � t�tj d d� � t � t � |j� W dS |�� W dS ty� d }| d ra|}ntd d �}d}ztj|d� |�� W |r}|�� Y dS Y dS |r�|�� w w w )aN Start the reactor, using profiling if specified by the configuration, and log any error happening in the process. @param config: configuration of the twistd application. @type config: L{ServerOptions} @param oldstdout: initial value of C{sys.stdout}. @type oldstdout: C{file} @param oldstderr: initial value of C{sys.stderr}. @type oldstderr: C{file} @param profiler: object used to run the reactor with profiling. @type profiler: L{AppProfiler} @param reactor: The reactor to use. If L{None}, the global reactor will be used. Nr rc r* �debug�posixc W � t �� S r �r� � set_trace��argsr r r �<lambda>+ � z'runReactorWithLogging.<locals>.<lambda>c W r� r r� r� r r r r� , r� F�nodaemonzTWISTD-CRASH.logr+ T��file)rg r6 r/ r1 r2 �stderrr � platformType�signal�SIGUSR2�SIGINTr� r� r. � BaseExceptionr3 � traceback� print_exc�flushr5 )�config� oldstdout� oldstderrrG r6 r5 r� r r r �runReactorWithLogging s> � � ��r� c C s | rt � d�S d S )Nz Passphrase: )�getpass��neededr r r � getPassphrase@ � r� c C s | rt �d�S d S )NzEncryption passphrase: )r � getPasswordr� r r r �getSavePassphraseG r� r� c @ sH e Zd ZdZeZeZdd� Zdd� Z dd� Z dd � Z d d � Z d d � Z dS )�ApplicationRunnera An object which helps running an application based on a config object. Subclass me and implement preApplication and postApplication methods. postApplication generally will want to run the reactor after starting the application. @ivar config: The config object, which provides a dict-like interface. @ivar application: Available in postApplication, but not preApplication. This is the application object. @ivar profilerFactory: Factory for creating a profiler object, able to profile the application if options are set accordingly. @ivar profiler: Instance provided by C{profilerFactory}. @ivar loggerFactory: Factory for creating object responsible for logging. @ivar logger: Instance provided by C{loggerFactory}. c C s" || _ | �|�| _| �|�| _d S r )r� �profilerFactoryrG � loggerFactoryr )r r� r r r r h s zApplicationRunner.__init__c C s6 | � � | �� | _| j�| j� | �� | j�� dS )z& Run the application. N)�preApplication�createOrGetApplicationr_ r rb �postApplicationru rt r r r r/ m s zApplicationRunner.runc C sH |du r ddl m} t| j||| j|� t�|�r |j| _dS d| _dS )z� Run the reactor with the given configuration. Subclasses should probably call this from C{postApplication}. @see: L{runReactorWithLogging} Nr rc )rg r6 r� r� rG r rW � _exitSignal)r r6 r� r� r r r � startReactory s z ApplicationRunner.startReactorc C � t � �)z� Override in subclass. This should set up any state necessary before loading and running the Application. ��NotImplementedErrorrt r r r r� � s z ApplicationRunner.preApplicationc C r� )z� Override in subclass. This will be called after the application has been loaded (so the C{application} attribute will be set). Generally this should start the application and run the reactor. r� rt r r r r� � s z!ApplicationRunner.postApplicationc C s^ | j jr | j j| j j }|�| j j�}t�|j�}|�|� |S t | j d �}t | j |�}|S )a� Create or load an Application based on the parameters found in the given L{ServerOptions} instance. If a subcommand was used, the L{service.IServiceMaker} that it represents will be used to construct a service to be added to a newly-created Application. Otherwise, an application will be loaded based on parameters in the config. � encrypted) r� � subCommand� loadedPlugins� makeService� subOptionsr � Application�tapname�setServiceParentr� �getApplication)r �plg�serr_ � passphraser r r r� � s � z(ApplicationRunner.createOrGetApplicationN)r$ r% r& r' rD r� rL r� r r/ r� r� r� r� r r r r r� N s r� c s� � fdd�dD �d }|d ddi� |d |d �}}zt�d| � t�|||�}t�d � W |S tyr } z4d | }t|t�rN|jd d krN|d 7 }t j tj d � t�|� t� � t �d| d � W Y d }~|S d }~ww )Nc s g | ] }� | r� | |f�qS r r )�.0�t�r� r r � <listcomp>� s z"getApplication.<locals>.<listcomp>)�python�sourcer� r r� �picklerv z Loading %s...zLoaded.z Failed to load application: %sr_ aN Could not find 'application' in the file. To use 'twistd -y', your .tac file must create a suitable object (e.g., by calling service.Application()) and store it in a variable named 'application'. twistd loads your .tac file and scans the global variables for one of this name. Please read the 'Using Application' HOWTO for details. r� � )rH r �msgr �loadApplication� Exception� isinstance�KeyErrorr� r� r� r �deferrr1 �exit)r� r� r" �filename�styler_ r! r r� r r� � s$ " � ��r� c C s t �dd� t�� D ��S )Nc S s g | ]}|j �qS r )� shortName)r� �rr r r r� � s z"_reactorAction.<locals>.<listcomp>)r � CompleteListr �getReactorTypesr r r r �_reactorAction� s r� c @ sD e Zd ZdZejdeid�Zej Z e e j �Zdd� Zdd� ZeZdS ) �ReactorSelectionMixinz� Provides options for selecting a reactor to install. If a reactor is installed, the short name which was used to locate it is saved as the value for the C{"reactor"} key. r6 )� optActionsc C s� t | �� td�d�}d}|D ]9}zt|j� | j�d|jd�d|j� d�� W q t yG } z|d� |j|j|j d �7 }W Y d }~qd }~ww |r\| j�d� | j�d � | j�|� t d ��) zE Display a list of possibly available reactor names. r� ��keyrM z z<4� r� z !{:<4} {} ({}) r Nz. reactors not available on this platform: ) �sorted�_getReactorTypesr r � moduleName� messageOutput�writer� � descriptionr, �formatr� r )r �rcts�notWorkingReactorsr� r! r r r �opt_help_reactors� s* $��� � z'ReactorSelectionMixin.opt_help_reactorsc C sf zt |� W n& ty d|f }t�|�� ty, } z d|f }t�|��d}~ww || d< dS )zX Which reactor to use (see --help-reactors for a list of possibilities) zcThe specified reactor does not exist: '%s'. See the list of available reactors with --help-reactorsztThe specified reactor cannot be used, failed with error: %s. See the list of available reactors with --help-reactorsNr6 )r r r � UsageErrorr� )r r� r� r! r r r � opt_reactor� s" �� �� �� z!ReactorSelectionMixin.opt_reactorN)r$ r% r& r' r � Completionsr� �compDatar1 r2 r� � staticmethodr r� r� r� r� �opt_rr r r r r� � s r� c @ s� e Zd ZdZg d�g d�g d�gZg d�g d�g d�dd d d d �ej� gg d �g d�g d�g d�gZe j dge � d�e � d�e � d�e � � d�d�Z eej�Zdd� Zdd� ZeZdd � Zd#d d �Zd d � Zed!d"� �Zd S )$� ServerOptionszQtwistd reads a twisted.application.service.Application out of a file and runs it.)rF NzBsave the Stats object rather than the text output of the profiler.)�no_save�oz do not save state on shutdown)r� r! z(The specified tap/aos file is encrypted.)r �lNz%log to a specified file, - for stdout)r NNz�A fully-qualified name to a log observer factory to use for the initial log observer. Takes precedence over --logfile and --syslog (when available).)r* r7 Nz7Run in profile mode, dumping results to specified file.rG NrE z!Name of the profiler to use (%s).z, )r� �fz twistd.tapzread the given .tap file)r� �yNz:read an application from within a Python file (implies -o))r� r" Nz2Read an application from a .tas file (AOT format).)�rundir�d�.z-Change to a supplied directory before running)r� r� r� z*.tapz *.(tac|py)z*.tas)r� r� r� r� )�mutuallyExclusiver� c O s4 d| d< d|v r|d | _ ntj | _ tj�| � d S )NFr� r2 )r2 r1 r �Optionsr )r r+ �kwr r r r Y s zServerOptions.__init__c C s t �d� t�� d| d< dS )z� Run the application in the Python Debugger (implies nodaemon), sending SIGUSR2 will drop into debugger Tr� N)r � setDebuggingr �startDebugModert r r r � opt_debuga s zServerOptions.opt_debugc C s> t �tj� zddl}W n ty Y dS w |�tj� dS )z� Print an insanely verbose log of everything that happens. Useful when debugging freezes or locks in complex code. r N)r1 �settracer �spewer� threadingr, )r r� r r r �opt_spewl s �zServerOptions.opt_spewc C s. |d u rt jdd � p dg}tj�| |� d S )Nrv z--help)r1 �argvr r� � parseOptionsrP r r r r� x s zServerOptions.parseOptionsc C sl | j s| d r d| d< | d d ur4z t| d �| d< W d S ty3 } z t�d�| d |���d }~ww d S )Nr� Tr� r z%Logger '{}' could not be imported: {})r� r r� r r� r� )r r! r r r � postOptions} s ����zServerOptions.postOptionsc c sT � | � tj�}i | _t|td�d�D ]}|| j|j< |jd |fdd�|jfV qd S )Nr� r� c S s | � � S r )rK )�plugr r r r� � r� z+ServerOptions.subCommands.<locals>.<lambda>)� _getPluginsr � IServiceMakerr� r� r r� r� )r �pluginsr� r r r � subCommands� s � ��zServerOptions.subCommandsr )r$ r% r& �longdesc�optFlags�joinrD rJ � optParametersr r� � CompleteFiles� CompleteDirsr� r� r � getPluginsr� r r� �opt_br� r� r� �propertyr r r r r r� sJ �� ��!�� r� c C sv |� }z|� � W n+ tjy4 } z d�tjdd� �}t|� t|� d|� �� W Y d }~d S d }~ww | |� d S )N� r rQ r )r� r �errorr r1 r� r| )�runAppr� r� �ue�commstrr r r r/ � s �� r/ c C sF t �| ||�}t�|��|� t|�}|rd }t�|�j||d� d S )N)r� r� )r r� r � IPersistable�setStyler� �save)�filein�typeinr� �fileout�typeout�encryptr_ r r r � convertStyle� s r c C sT ddl m} t�| ��� |r t�| �}|�dd|jd� |�ddt�| �j � d S )Nr rc �after�shutdown�before) rg r6 r �IService� startServicer r �addSystemEventTriggerr � stopService)r_ r r6 r7 r r r �startApplication� s �r c C s" t � | t j� t�t�� | � dS )a Force the application to terminate with the specified signal by replacing the signal handler with the default and sending the signal to ourselves. @param sig: Signal to use to terminate the process with C{os.kill}. @type sig: C{int} N)r� �SIG_DFLr~ �kill�getpid)�sigr r r �_exitWithSignal� s r$ )NN)7r� r~ r� r� r1 r� rY �operatorr �twistedr r r �twisted.applicationr r � twisted.application.reactorsr r rg r �twisted.internet.interfacesr �twisted.persistedr �twisted.pythonr r r r r r �twisted.python.reflectr r r r r) r; rD rL r� r� r� r� r� r� r� r� r� r� r/ r r r$ r r r r �<module> sD r 3kE~ PK Mb�Z 7�P5 P5 / application/__pycache__/service.cpython-310.pycnu �[��� o �b�- � @ s d Z ddlmZmZmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZ G dd � d e�Zee e�G d d � d ��ZG d d � d e�Zee�G dd� d��ZG dd� de�Zee�G dd� de��ZG dd� de�Zee�G dd� d��Zd dd�Zd dd �Zg d �ZdS ) aa Service architecture for Twisted. Services are arranged in a hierarchy. At the leafs of the hierarchy, the services which actually interact with the outside world are started. Services can be named or anonymous -- usually, they will be named if there is need to access them through the hierarchy (from a parent or a sibling). Maintainer: Moshe Zadka � )� Attribute� Interface� implementer)�defer)�sob)�IPlugin)� components)�namedAnyc @ s0 e Zd ZdZed�Zed�Zed�Zdd� ZdS )� IServiceMakerz� An object which can be used to construct services in a flexible way. This interface should most often be implemented along with L{twisted.plugin.IPlugin}, and will most often be used by the 'twistd' command. zA short string naming this Twisted plugin, for example 'web' or 'pencil'. This name will be used as the subcommand of 'twistd'.zLA brief summary of the features provided by this Twisted application plugin.zcA C{twisted.python.usage.Options} subclass defining the configuration options for this application.c C � dS )a Create and return an object providing L{twisted.application.service.IService}. @param options: A mapping (typically a C{dict} or L{twisted.python.usage.Options} instance) of configuration options to desired configuration values. N� )�optionsr r �=/usr/lib/python3/dist-packages/twisted/application/service.py� makeService4 � zIServiceMaker.makeServiceN) �__name__� __module__� __qualname__�__doc__r �tapname� descriptionr r r r r r r s ��� r c @ s0 e Zd ZdZdd� Zedd� �Zedd� �ZdS ) � ServiceMakerzO Utility class to simplify the definition of L{IServiceMaker} plugins. c C s || _ || _|| _|| _d S �N)�name�moduler r )�selfr r r r r r r �__init__E s zServiceMaker.__init__c C � t | j�jS r )r r �Options�r r r r r K � zServiceMaker.optionsc C r r )r r r r r r r r O r zServiceMaker.makeServiceN)r r r r r �propertyr r r r r r r ? s r c @ sX e Zd ZdZed�Zed�Zed�Zdd� Zdd� Z d d � Z d d � Z d d� Z dd� Z dS )�IServicezS A service. Run start-up and shut-down code at the appropriate times. z5A C{str} which is the name of the service or C{None}.z<A C{boolean} which indicates whether the service is running.z8An C{IServiceCollection} which is the parent or C{None}.c C r )z� Set the name of the service. @type name: C{str} @raise RuntimeError: Raised if the service already has a parent. Nr �r r r r �setNamea r zIService.setNamec C r )ax Set the parent of the service. This method is responsible for setting the C{parent} attribute on this service (the child service). @type parent: L{IServiceCollection} @raise RuntimeError: Raised if the service already has a parent or if the service has a name and the parent already has a child by that name. Nr )�parentr r r �setServiceParenti r zIService.setServiceParentc C r )a� Use this API to remove an L{IService} from an L{IServiceCollection}. This method is used symmetrically with L{setServiceParent} in that it sets the C{parent} attribute on the child. @rtype: L{Deferred<defer.Deferred>} @return: a L{Deferred<defer.Deferred>} which is triggered when the service has finished shutting down. If shutting down is immediate, a value can be returned (usually, L{None}). Nr r r r r �disownServiceParentt r z IService.disownServiceParentc C r )z$ Start the service. Nr r r r r � startService� r zIService.startServicec C r )a" Stop the service. @rtype: L{Deferred<defer.Deferred>} @return: a L{Deferred<defer.Deferred>} which is triggered when the service has finished shutting down. If shutting down is immediate, a value can be returned (usually, L{None}). Nr r r r r � stopService� r zIService.stopServicec C r )z� Do preparation work for starting the service. Here things which should be done before changing directory, root or shedding privileges are done. Nr r r r r �privilegedStartService� r z IService.privilegedStartServiceN)r r r r r r �runningr% r$ r& r' r( r) r* r r r r r" T s r" c @ sT e Zd ZdZdZdZdZdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dS )�Servicez� Base class for services. Most services should inherit from this class. It handles the book-keeping responsibilities of starting and stopping, as well as not serializing this book-keeping information. r Nc C s | j �� }d|v r |d= |S )Nr+ )�__dict__�copy)r �dictr r r � __getstate__� s zService.__getstate__c C s | j d ur td��|| _d S )Nz%cannot change name when parent exists)r% � RuntimeErrorr �r r r r r r$ � s zService.setNamec C s2 | j d ur | �� t||�}|| _ | j �| � d S r )r% r' �IServiceCollection� addService)r r% r r r r& � s zService.setServiceParentc C s | j �| �}d | _ |S r )r% � removeService)r �dr r r r' � s zService.disownServiceParentc C s d S r r r r r r r* � s z Service.privilegedStartServicec C � d| _ d S )N� �r+ r r r r r( � � zService.startServicec C r7 )Nr r9 r r r r r) � r: zService.stopService)r r r r r+ r r% r0 r$ r& r' r* r( r) r r r r r, � s r, c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) r3 z� Collection of services. Contain several services, and manage their start-up/shut-down. Services can be accessed by name if they have a name, and it is always possible to iterate over them. c C r )z� Get the child service with a given name. @type name: C{str} @rtype: L{IService} @raise KeyError: Raised if the service has no child with the given name. Nr r# r r r �getServiceNamed� r z"IServiceCollection.getServiceNamedc C r )z: Get an iterator over all child services. Nr r r r r �__iter__� r zIServiceCollection.__iter__c C r )a Add a child service. Only implementations of L{IService.setServiceParent} should use this method. @type service: L{IService} @raise RuntimeError: Raised if the service has a child with the given name. Nr ��servicer r r r4 � r z IServiceCollection.addServicec C r )a� Remove a child service. Only implementations of L{IService.disownServiceParent} should use this method. @type service: L{IService} @raise ValueError: Raised if the given service is not a child. @rtype: L{Deferred<defer.Deferred>} @return: a L{Deferred<defer.Deferred>} which is triggered when the service has finished shutting down. If shutting down is immediate, a value can be returned (usually, L{None}). Nr r= r r r r5 � r z IServiceCollection.removeServiceN)r r r r r; r< r4 r5 r r r r r3 � s r3 c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )� MultiServicea Straightforward Service Container. Hold a collection of services, and manage them in a simplistic way. No service will wait for another, but this object itself will not finish shutting down until all of its child services will finish. c C s g | _ i | _d | _d S r )�services� namedServicesr% r r r r r s zMultiService.__init__c C � t �| � | D ]}|�� qd S r )r, r* �r r> r r r r* � �z#MultiService.privilegedStartServicec C rB r )r, r( rC r r r r( rD zMultiService.startServicec C sD t �| � g }t| �}|�� |D ] }|�t�|j�� qt�|�S r )r, r) �list�reverse�appendr � maybeDeferred� DeferredList)r �lr@ r> r r r r) s zMultiService.stopServicec C s | j | S r )rA r2 r r r r; r: z MultiService.getServiceNamedc C s t | j�S r )�iterr@ r r r r r< " r: zMultiService.__iter__c C sZ |j d ur|j | jv rtd|j ��|| j|j < | j�|� | jr+|�� |�� d S d S )Nz,cannot have two services with same name '%s')r rA r1 r@ rG r+ r* r( rC r r r r4 % s � �zMultiService.addServicec C s. |j r| j|j = | j�|� | jr|�� S d S r )r rA r@ �remover+ r) rC r r r r5 2 s zMultiService.removeServiceN) r r r r r r* r( r) r; r< r4 r5 r r r r r? � s r? c @ s( e Zd ZdZed�Zed�Zed�ZdS )�IProcessza Process running parameters. Represents parameters for how processes should be run. zv A C{str} giving the name the process should have in ps (or L{None} to leave the name alone). z{ An C{int} giving the user id as which the process should run (or L{None} to leave the UID alone). z| An C{int} giving the group id as which the process should run (or L{None} to leave the GID alone). N)r r r r r � processName�uid�gidr r r r rM > s ���rM c @ s e Zd ZdZdZddd�ZdS )�Processz� Process running parameters. Sets up uid/gid in the constructor, and has a default of L{None} as C{processName}. Nc C s || _ || _dS )a= Set uid and gid. @param uid: The user ID as whom to execute the process. If this is L{None}, no attempt will be made to change the UID. @param gid: The group ID as whom to execute the process. If this is L{None}, no attempt will be made to change the GID. N)rO rP )r rO rP r r r r f s zProcess.__init__�NN)r r r r rN r r r r r rQ [ s rQ Nc C sL t �� }t� t||�t�|| �g}|D ] }|j|dd� qt|��| � |S )a Return a compound class. Return an object supporting the L{IService}, L{IServiceCollection}, L{IProcess} and L{sob.IPersistable} interfaces, with the given parameters. Always access the return value by explicit casting to one of the interfaces. r8 )� ignoreClass) r � Componentizedr? rQ r � Persistent� addComponentr" r$ )r rO rP �ret�availableComponents�compr r r � Applicationt s rZ c C s( |dkr t �| d�}|S t �| |�}|S )a` Load Application from a given file. The serialization format it was saved in should be given as C{kind}, and is one of C{pickle}, C{source}, C{xml} or C{python}. If C{passphrase} is given, the application was encrypted with the given passphrase. @type filename: C{str} @type kind: C{str} @type passphrase: C{str} �python� application)r �loadValueFromFile�load)�filename�kind� passphraser\ r r r �loadApplication� s �rb ) r r" r, r3 r? rM rQ rZ rb rR r )r �zope.interfacer r r �twisted.internetr �twisted.persistedr �twisted.pluginr �twisted.pythonr �twisted.python.reflectr r r r" r, r3 r? rM rQ rZ rb �__all__r r r r �<module> s, $E.4A PK Mb�ZW�f� 0 application/__pycache__/reactors.cpython-310.pycnu �[��� o �b! � @ s� d Z ddlmZmZ ddlmZmZmZ ddlm Z ddl m Z m Z ddl mZ G dd� de�ZG d d � d e�Zee e�G d d � d ��Zd ee fdd�Zded e fdd�ZdS )zT Plugin-based system for enumerating available reactors and installing one of them. � )�Iterable�cast)� Attribute� Interface� implementer)� IReactorCore)�IPlugin� getPlugins)�namedAnyc @ s* e Zd ZdZed�Zed�Zddd�ZdS ) �IReactorInstallerzB Definition of a reactor which can probably be installed. zE A brief string giving the user-facing name of this reactor. zK A longer string giving a user-facing description of this reactor. �returnNc C s dS )z' Install this reactor. N� r r r �>/usr/lib/python3/dist-packages/twisted/application/reactors.py�install# s zIReactorInstaller.install�r N)�__name__� __module__� __qualname__�__doc__r � shortName� descriptionr r r r r r s ��r c @ s e Zd ZdZdS )� NoSuchReactorzT Raised when an attempt is made to install a reactor which cannot be found. N)r r r r r r r r r , s r c @ s0 e Zd ZdZdededefdd�Zd d d �ZdS ) �Reactorz| @ivar moduleName: The fully-qualified Python name of the module of which the install callable is an attribute. r � moduleNamer c C s || _ || _|| _d S �N)r r r )�selfr r r r r r �__init__9 s zReactor.__init__r Nc C s t | j��� d S r )r r r )r r r r r > s zReactor.installr )r r r r �strr r r r r r r 2 s r r c C s t t�S )z= Return an iterator of L{IReactorInstaller} plugins. )r r r r r r �getReactorTypesB s r r c C s@ t � D ]}|j| kr|�� ddlm} tt|� S qt| ��)z� Install the reactor with the given C{shortName} attribute. @raise NoSuchReactor: If no reactor is found with a matching C{shortName}. @raise Exception: Anything that the specified reactor can raise when installed. r )�reactor)r r r �twisted.internetr r r r )r � installerr r r r �installReactorI s �r" N)r �typingr r �zope.interfacer r r �twisted.internet.interfacesr �twisted.pluginr r �twisted.python.reflectr r �KeyErrorr r r r r" r r r r �<module> s PK Mb�Z�ϕb� � 5 application/test/__pycache__/__init__.cpython-310.pycnu �[��� o �b| � @ s d Z dS )z, Tests for L{twisted.internet.application}. N)�__doc__� r r �C/usr/lib/python3/dist-packages/twisted/application/test/__init__.py�<module> s PK Mb�Z��E{Q� Q� : application/test/__pycache__/test_internet.cpython-310.pycnu �[��� o �bO� � @ st d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z m Z m Z ddl m Z ddlmZmZ dd lmZmZmZmZmZ dd lmZmZ dd lmZ dd l m Z m Z dd l m Z ddl!m"Z" ddl#m$Z$m%Z% dd� Z&ee�G dd� d��Z'eee'� ee�G dd� d��Z(eee'� G dd� de%�Z)G dd� de%�Z*G dd� d�Z+d$d d �Z,e fd d �Z-d!Z.G d"d#� d#e$�Z/dS )%z� Tests for (new code in) L{twisted.application.internet}. @var AT_LEAST_ONE_ATTEMPT: At least enough seconds for L{ClientService} to make one attempt. � N)� implementer)� verifyClass)�internet)� ClientService�StreamServerEndpointService� TimerService)�task)�CancelledError�Deferred)�IFileDescriptorReceiver�IHalfCloseableProtocol�IListeningPort�IStreamClientEndpoint�IStreamServerEndpoint)�Factory�Protocol)�Clock)� formatEvent�globalLogPublisher)�Failure)�StringTransport)�SynchronousTestCase�TestCasec C s dS )zM A fake target function for testing TimerService which does nothing. N� r r r �H/usr/lib/python3/dist-packages/twisted/application/test/test_internet.py�fakeTargetFunction) s r c @ sF e Zd ZdZdZdZdZe� ZdZ dd� Z dd� Z dd � Z d d � Z dS ) � FakeServeraq In-memory implementation of L{IStreamServerEndpoint}. @ivar result: The L{Deferred} resulting from the call to C{listen}, after C{listen} has been called. @ivar factory: The factory passed to C{listen}. @ivar cancelException: The exception to errback C{self.result} when it is cancelled. @ivar port: The L{IListeningPort} which C{listen}'s L{Deferred} will fire with. @ivar listenAttempts: The number of times C{listen} has been invoked. @ivar failImmediately: If set, the exception to fail the L{Deferred} returned from C{listen} before it is returned. Nr c C s t � | _d S �N)�FakePort�port��selfr r r �__init__L s zFakeServer.__init__c sF � j d7 _ |� _t� fdd�d�� _� jdur � j�� j� � jS )z� Return a Deferred and store it for future use. (Implementation of L{IStreamServerEndpoint}). @param factory: the factory to listen with @return: a L{Deferred} stored in L{FakeServer.result} � c s | � � j�S r )�errback�cancelException)�dr r r �<lambda>Z � z#FakeServer.listen.<locals>.<lambda>)� cancellerN)�listenAttempts�factoryr �result�failImmediatelyr$ )r! r+ r r r �listenO s zFakeServer.listenc C s | j �| j� dS )z� Test code should invoke this method after causing C{listen} to be invoked in order to fire the L{Deferred} previously returned from C{listen}. N)r, �callbackr r r r r �startedListening_ � zFakeServer.startedListeningc C s | j j�d� dS )a Test code should invoke this method after causing C{stopListening} to be invoked on the port fired from the L{Deferred} returned from C{listen} in order to cause the L{Deferred} returned from C{stopListening} to fire. N)r �deferredr/ r r r r �stoppedListeningg s zFakeServer.stoppedListening)�__name__� __module__� __qualname__�__doc__r, r+ r- r r% r* r" r. r0 r3 r r r r r 0 s r c @ s, e Zd ZdZdZdd� Zdd� Zdd� ZdS ) r zs Fake L{IListeningPort} implementation. @ivar deferred: The L{Deferred} returned by C{stopListening}. Nc C s t � | _| jS )z` Stop listening. @return: a L{Deferred} stored in L{FakePort.deferred} )r r2 r r r r � stopListening~ s zFakePort.stopListeningc C � d S r r r r r r �getHost� � zFakePort.getHostc C r9 r r r r r r �startListening� r; zFakePort.startListening)r4 r5 r6 r7 r2 r8 r: r< r r r r r t s r c @ sr e Zd ZdZdd� Zdd� Zddd�Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� ZdS ) �EndpointServiceTestsz4 Tests for L{twisted.application.internet}. c C s$ t � | _t� | _t| j| j�| _dS )zp Construct a stub server, a stub factory, and a L{StreamServerEndpointService} to test. N)r � fakeServerr r+ r �svcr r r r �setUp� s zEndpointServiceTests.setUpc C s | j �� | �| j| jj� dS )z� L{StreamServerEndpointService.privilegedStartService} calls its endpoint's C{listen} method with its factory. N)r? �privilegedStartService�assertIdenticalr+ r> r r r r �test_privilegedStartService� s z0EndpointServiceTests.test_privilegedStartServiceNc C s* t � | j_d| j_| �t |p| jj� dS )a@ L{StreamServerEndpointService.startService} should raise synchronously if the L{Deferred} returned by its wrapped L{IStreamServerEndpoint.listen} has already fired with an errback and the L{StreamServerEndpointService}'s C{_raiseSynchronously} flag has been set. This feature is necessary to preserve compatibility with old behavior of L{twisted.internet.strports.service}, which is to return a service which synchronously raises an exception from C{startService} (so that, among other things, twistd will not start running). However, since L{IStreamServerEndpoint.listen} may fail asynchronously, it is a bad idea to rely on this behavior. @param thunk: If specified, a callable to execute in place of C{startService}. TN)�ZeroDivisionErrorr> r- r? �_raiseSynchronously� assertRaises� startService)r! �thunkr r r �(test_synchronousRaiseRaisesSynchronously� s z=EndpointServiceTests.test_synchronousRaiseRaisesSynchronouslyc C s | � | jj� dS )z� L{StreamServerEndpointService.privilegedStartService} should behave the same as C{startService} with respect to L{EndpointServiceTests.test_synchronousRaiseRaisesSynchronously}. N)rI r? rA r r r r � test_synchronousRaisePrivileged� r1 z4EndpointServiceTests.test_synchronousRaisePrivilegedc C s8 | j �� | jj�t� � | �t�}| �t|�d� dS )a L{StreamServerEndpointService.startService} and L{StreamServerEndpointService.privilegedStartService} should both log an exception when the L{Deferred} returned from their wrapped L{IStreamServerEndpoint.listen} fails. r# N) r? rG r> r, r$ rD �flushLoggedErrors� assertEqual�len�r! �loggedr r r �test_failReportsError� s z*EndpointServiceTests.test_failReportsErrorc C s@ d| j _| j �� | jj�t� � | �t�}| �t |�d� dS )aB L{StreamServerEndpointService.startService} and L{StreamServerEndpointService.privilegedStartService} should both log an exception when the L{Deferred} returned from their wrapped L{IStreamServerEndpoint.listen} fails asynchronously, even if C{_raiseSynchronously} is set. Tr# N) r? rE rG r> r, r$ rD rK rL rM rN r r r �!test_asynchronousFailReportsError� s z6EndpointServiceTests.test_asynchronousFailReportsErrorc C s2 t � | j_| j�� | �t �}| �t|�d� dS )z� Without the C{_raiseSynchronously} compatibility flag, failing immediately has the same behavior as failing later; it logs the error. r# N)rD r> r- r? rG rK rL rM rN r r r � test_synchronousFailReportsError� s z5EndpointServiceTests.test_synchronousFailReportsErrorc C s0 | j �� | �| j| jj� | �| j jd� dS )z� L{StreamServerEndpointService.startService} sets the C{running} flag, and calls its endpoint's C{listen} method with its factory, if it has not yet been started. TN)r? rG rB r+ r> rL �runningr r r r �test_startServiceUnstarted� s z/EndpointServiceTests.test_startServiceUnstartedc C s6 | � � | j�� | �| jjd� | �| jjd� dS )z� L{StreamServerEndpointService.startService} sets the C{running} flag, but nothing else, if the service has already been started. r# TN)rC r? rG rL r> r* rS r r r r �test_startServiceStarted� s z-EndpointServiceTests.test_startServiceStartedc C st | j �� | j�� | j �� | j �� }g }|�|j� | �t |�d� | j� � | �t |�d� | � | j j � dS )z� L{StreamServerEndpointService.stopService} calls C{stopListening} on the L{IListeningPort} returned from its endpoint, returns the C{Deferred} from stopService, and sets C{running} to C{False}. r r# N) r? rA r> r0 rG � stopService� addCallback�appendrL rM r3 � assertFalserS �r! r, �lr r r �test_stopService� s z%EndpointServiceTests.test_stopServicec C sH | j �� | j �� }g }|�|j� | �|dg� | �| �t�g � dS )z� L{StreamServerEndpointService.stopService} cancels the L{Deferred} returned by C{listen} if it has not yet fired. No error will be logged about the cancellation of the listen attempt. N)r? rA rV �addBothrX rL rK r rZ r r r �#test_stopServiceBeforeStartFinished s z8EndpointServiceTests.test_stopServiceBeforeStartFinishedc C sZ t � | j_| j�� | j�� }g }|�|j� | �|dg� | � t �}| �t |�d� dS )z� L{StreamServerEndpointService.stopService} cancels the L{Deferred} returned by C{listen} if it has not fired yet. An error will be logged if the resulting exception is not L{CancelledError}. Nr# ) rD r> r% r? rA rV rW rX rL rK rM )r! r, r[ �stoppingErrorsr r r � test_stopServiceCancelStartError s z5EndpointServiceTests.test_stopServiceCancelStartErrorr )r4 r5 r6 r7 r@ rC rI rJ rP rQ rR rT rU r\ r^ r` r r r r r= � s r= c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )�TimerServiceTestsa) Tests for L{twisted.application.internet.TimerService}. @type timer: L{TimerService} @ivar timer: service to test @type clock: L{task.Clock} @ivar clock: source of time @type deferred: L{Deferred} @ivar deferred: deferred returned by L{TimerServiceTests.call}. c C s, t d| j�| _t�� | _| j_t� | _dS )z1 Set up a timer service to test. � N)r �call�timerr r �clockr r2 r r r r r@ : s zTimerServiceTests.setUpc C s | j S )z� Function called by L{TimerService} being tested. @returns: C{self.deferred} @rtype: L{Deferred} )r2 r r r r rc B s zTimerServiceTests.callc C sV | j �� | �| j jd� | �| j jtj� | �| j | j jj � | �| j jjd� dS )z� When L{TimerService.startService} is called, it marks itself as running, creates a L{task.LoopingCall} and starts it. zService is startedzLoopingCall is startedN) rd rG � assertTruerS �assertIsInstance�_loopr � LoopingCallrB re r r r r �test_startServiceK s z#TimerServiceTests.test_startServicec C s0 g }|j di f| j_| j�� | �dg|� dS )zi When L{TimerService.startService} is called, it calls the function immediately. r N)rX rd rc rG rL )r! r, r r r �$test_startServiceRunsCallImmediatelyV s z6TimerServiceTests.test_startServiceRunsCallImmediatelyc sB t �� � � fdd�}| �td|� | j�� | �� | jjj� dS )z� L{TimerService.startService} uses L{internet._maybeGlobalReactor} to choose the reactor to pass to L{task.LoopingCall} uses the global reactor. c � � S r r )� maybeReactor�� otherClockr r � getOtherClockh � zKTimerServiceTests.test_startServiceUsesGlobalReactor.<locals>.getOtherClock�_maybeGlobalReactorN) r r �patchr rd rG rB rh re )r! rp r rn r �"test_startServiceUsesGlobalReactor` s z4TimerServiceTests.test_startServiceUsesGlobalReactorc C sR | j �� | j �� }| �|� | �d| j j� | j�t� � | � | � |�d� dS )z� When L{TimerService.stopService} is called while a call is in progress. the L{Deferred} returned doesn't fire until after the call finishes. TN) rd rG rV �assertNoResultrL rS r2 r/ �objectrB �successResultOf�r! r& r r r �test_stopServiceWaitso s z'TimerServiceTests.test_stopServiceWaitsc C s8 | j �� | j�t� � | j �� }| �| �|�d� dS )z� When L{TimerService.stopService} is called while a call isn't in progress. the L{Deferred} returned has already been fired. N)rd rG r2 r/ rv rV rB rw rx r r r �test_stopServiceImmediately{ s z-TimerServiceTests.test_stopServiceImmediatelyc C sV | j �� | j�tt� �� | �t�}| �dt|�� | j � � }| � | � |�d� dS )z� When function passed to L{TimerService} returns a deferred that errbacks, the exception is logged, and L{TimerService.stopService} doesn't raise an error. r# N) rd rG r2 r$ r rD rK rL rM rV rB rw )r! �errorsr& r r r �test_failedCallLogsError� s z*TimerServiceTests.test_failedCallLogsErrorc C �P t dt�}|�� t�|�}|�� t�|�}t� }t|d|�}| � ||� dS )zq When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loop}. r# rh N� r r rG �pickle�dumpsrV �loadsrv �getattrrB �r! rd � dumpedTimer� loadedTimer�nothing�valuer r r �$test_pickleTimerServiceNotPickleLoop� � z6TimerServiceTests.test_pickleTimerServiceNotPickleLoopc C r} )zy When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loopFinished}. r# � _loopFinishedNr~ r� r r r �,test_pickleTimerServiceNotPickleLoopFinished� r� z>TimerServiceTests.test_pickleTimerServiceNotPickleLoopFinishedN)r4 r5 r6 r7 r@ rc rj rk rt ry rz r| r� r� r r r r ra , s ra c @ s e Zd ZdZdd� ZdS )�ConnectInformationa� Information about C{endpointForTesting} @ivar connectQueue: a L{list} of L{Deferred} returned from C{connect}. If these are not already fired, you can fire them with no value and they will trigger building a factory. @ivar constructedProtocols: a L{list} of protocols constructed. @ivar passedFactories: a L{list} of L{IProtocolFactory}; the ones actually passed to the underlying endpoint / i.e. the reactor. c C s g | _ g | _g | _d S r )� connectQueue�constructedProtocols�passedFactoriesr r r r r" � s zConnectInformation.__init__N)r4 r5 r6 r7 r" r r r r r� � s r� Fc s, t t�G � �fdd�d��}t� ��|� fS )aD Make a sample endpoint for testing. @param fireImmediately: If true, fire all L{Deferred}s returned from C{connect} immedaitely. @return: a 2-tuple of C{(information, endpoint)}, where C{information} is a L{ConnectInformation} describing the operations in progress on C{endpoint}. c s e Zd Z� �fdd�ZdS )z.endpointForTesting.<locals>.ClientTestEndpointc sD t � }�j�� � |j� �fdd��}�j�|� �r |�d � |S )Nc s* � � d �}�j�|� t� }|�|� |S r )� buildProtocolr� rX r �makeConnection)�ignored�protocol� transport)r+ �infor r �createProtocol� s zNendpointForTesting.<locals>.ClientTestEndpoint.connect.<locals>.createProtocol)r r� rX rW r� r/ )r! r+ r, r� ��fireImmediatelyr� )r+ r �connect� s z6endpointForTesting.<locals>.ClientTestEndpoint.connectN)r4 r5 r6 r� r r� r r �ClientTestEndpoint� s r� )r r r� )r� r� r r� r �endpointForTesting� s r� c s0 g �� � �j� | �� �fdd�� �fdd�S )a6 Catch the global log stream. @param testCase: The test case to add a cleanup to. @param logPublisher: the log publisher to add and remove observers for. @return: a 0-argument callable that returns a list of textual log messages for comparison. @rtype: L{list} of L{unicode} c s � � �j�S r )�removeObserverrX r �� logPublisher�logsr r r' � r( zcatchLogs.<locals>.<lambda>c s dd� � D �S )Nc S s g | ]}t |��qS r )r )�.0�eventr r r � <listcomp>� s z/catchLogs.<locals>.<lambda>.<locals>.<listcomp>r r )r� r r r' � s )� addObserverrX � addCleanup)�testCaser� r r� r � catchLogs� s r� g Y@c @ s e Zd ZdZddefdd�Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Z d3d4� Z d5d6� Z d7d8� Z d9d:� Z d;d<� Z!d=d>� Z"d?d@� Z#dAS )B�ClientServiceTestsz% Tests for L{ClientService}. Tc s� i }|j t� d� |� |� |d �t|d�\}}g � |_G � �fdd�dt�}|� |_} t|| fi |������fdd�} ��| � |rK��� |�fS )aL Create a L{ClientService} along with a L{ConnectInformation} indicating the connections in progress on its endpoint. @param fireImmediately: Should all of the endpoint connection attempts fire synchronously? @type fireImmediately: L{bool} @param startService: Should the L{ClientService} be started before being returned? @type startService: L{bool} @param protocolType: a 0-argument callable returning a new L{IProtocol} provider to be used for application-level protocol connections. @param kw: Arbitrary keyword arguments to be passed on to L{ClientService} @return: a 2-tuple of L{ConnectInformation} (for information about test state) and L{ClientService} (the system under test). The L{ConnectInformation} has 2 additional attributes; C{applicationFactory} and C{applicationProtocols}, which refer to the unwrapped protocol factory and protocol instances passed in to L{ClientService} respectively. �re re �r� c s" e Zd Z�Z� �fdd�Z� ZS )z>ClientServiceTests.makeReconnector.<locals>.RememberingFactoryc s t � �|�}��|� |S r )�superr� rX )r! �addrr, )� __class__�applicationProtocolsr r r� 0 s zLClientServiceTests.makeReconnector.<locals>.RememberingFactory.buildProtocol)r4 r5 r6 r� r� � __classcell__r )r� � protocolType)r� r �RememberingFactory- s r� c s( d �_ �jr ��� ��� �� g � d S r )� _protocolrS rV rL �getDelayedCallsr )re r! �servicer r �stop9 s z0ClientServiceTests.makeReconnector.<locals>.stop) �updater r� r� r �applicationFactoryr r� rG ) r! r� rG r� �kw�nkw�cq�endpointr� r+ r� r )r� re r� r! r� r �makeReconnector s z"ClientServiceTests.makeReconnectorc C s& | j dd�\}}| �t|j�d� dS )zL When the service is started, a connection attempt is made. Fr� r# N)r� rL rM r� )r! r� r� r r r rj F s z$ClientServiceTests.test_startServicec C sD | � � \}}|j}| �|jd� |jd }|�� | �|jd� dS )a! Although somewhat obscure, L{IProtocolFactory} includes both C{doStart} and C{doStop} methods; ensure that when these methods are called on the factory that was passed to the reactor, the factory that was passed from the application receives them. r r# N)r� r� rL �numPortsr� �doStart)r! r� r� �firstAppFactory�firstPassedFactoryr r r �test_startStopFactoryM s z(ClientServiceTests.test_startStopFactoryc C sV | � � \}}|�� }| �|� |jd }| �|jjd� |�tt � �� | � |� dS )z� When the service is stopped, no further connect attempts are made. The returned L{Deferred} fires when all outstanding connections have been stopped. r TN) r� rV ru r� rL r� � disconnecting�connectionLostr � Exceptionrw �r! r� r� r& r� r r r � test_stopServiceWhileConnected[ s z1ClientServiceTests.test_stopServiceWhileConnectedc C s� | � � \}}|�� }| �|� |jd }| �|jjd� |�� | �|� | �t|j�d� |� t t � �� | �t|j�d� dS )z� When L{ClientService} is restarted after having been connected, it waits to start connecting until after having disconnected. r Tr# rb N) r� rV ru r� rL r� r� rG rM r� r r� r� r r r �#test_startServiceWaitsForDisconnecti s z6ClientServiceTests.test_startServiceWaitsForDisconnectc C s� | j dd�\}}|jd �d� |jd }|�� }| �|� |�� }| �|� |�� | �|� | �|� | �|j j d� |� t t � �� | �|� |jd �d� | �t|j�d� | �| �|�|jd � |�� }| �|� dS )a% When L{ClientService} is stopping - that is, L{ClientService.stopService} has been called, but the L{Deferred} it returns has not fired yet - calling L{startService} will cause a new connection to be made, and new calls to L{whenConnected} to succeed. Fr� r NTr# rb )r� r� r/ r� rV ru � whenConnectedrG rL r� r� r� r r� rw rM rB r� )r! r� r� �first�stopped� nextProtocol� secondStoppedr r r � test_startServiceWhileStoppingy s( �z1ClientServiceTests.test_startServiceWhileStoppingc C sj | j dd�\}}|�� }| �|� | �|�� t� |�� |jd �d� | � |j d | �|�� �� dS )a When L{ClientService} is stopped - that is, L{ClientService.stopService} has been called and the L{Deferred} it returns has fired - calling L{startService} will cause a new connection to be made, and new calls to L{whenConnected} to succeed. Fr� ���N) r� rV rw �failureResultOfr� r rG r� r/ rB r� )r! r� r� r� r r r � test_startServiceWhileStopped� s �z0ClientServiceTests.test_startServiceWhileStoppedc C sX t tt�G dd� dt��}| j|d�\}}|jd }| �t�|�� | �t�|�� dS )aC If the protocol objects returned by the factory given to L{ClientService} provide special "marker" interfaces for their transport - L{IHalfCloseableProtocol} or L{IFileDescriptorReceiver} - those interfaces will be provided by the protocol objects passed on to the reactor. c @ s e Zd ZdZdS )zEClientServiceTests.test_interfacesForTransport.<locals>.FancyProtocolz9 Provider of various interfaces. N)r4 r5 r6 r7 r r r r � FancyProtocol� s r� )r� r N)r r r r r� r� rf � providedBy)r! r� r� r� � reactorFacingr r r �test_interfacesForTransport� s z.ClientServiceTests.test_interfacesForTransportc C sn t � }| jd|d�\}}|jd �t� � |�t� | �t|j�d� |� � }|jd �t� � | � |� dS )zU When the service is stopped while retrying, the retry is cancelled. F�r� re r rb r# N) r r� r� r$ r� �advance�AT_LEAST_ONE_ATTEMPTrL rM rV rw �r! re r� r� r& r r r � test_stopServiceWhileRetrying� s z0ClientServiceTests.test_stopServiceWhileRetryingc C sP t � }| jd|d�\}}| �t|j�d� | �|jd � |�� }| �|� dS )zv When the service is stopped while initially connecting, the connection attempt is cancelled. Fr� r# r N)r r� rL rM r� ru rV rw r� r r r � test_stopServiceWhileConnecting� s z2ClientServiceTests.test_stopServiceWhileConnectingc C sJ t � }| j|d�\}}|�� }| �|�� g � | �| �|�|jd � dS )zy When a client connects, the service keeps a reference to the new protocol and resets the delay. r� r N)r r� r� rL r� rB rw r� )r! re r� r� �awaitingProtocolr r r �test_clientConnected� s �z'ClientServiceTests.test_clientConnectedc C s� t � }| jd|d�\}}| �t|j�d� |jd �tt� �� |�� }| � |� |� dd� � |� t � | �t|j�d� dS ) z� When a client connection fails, the service removes its reference to the protocol and tries again after a timeout. Fr� r# r c S s | � t�S r )�trapr )r� r r r r' � s z@ClientServiceTests.test_clientConnectionFailed.<locals>.<lambda>rb N) r r� rL rM r� r$ r r� r� ru � addErrbackr� r� )r! re r� r� r� r r r �test_clientConnectionFailed� s z.ClientServiceTests.test_clientConnectionFailedc C s� t � }| j|dd�\}}| �t|j�d� |jd �d� | �t|j�d� | �| �|�� �|j d � |j d � t t � �� |�t� | �t|j�d� |jd �d� | �| �|�� �|j d � dS )z~ When a client connection is lost, the service removes its reference to the protocol and calls retry. F)re r� r# r Nrb )r r� rL rM r� r/ rB rw r� r� r� r� r r� r� r� )r! re r� r� r r r �test_clientConnectionLost� s � �z,ClientServiceTests.test_clientConnectionLostc C sT t � }| j|d�\}}|�� }|jd �tt� �� | �|�� t � | � |j � dS )z� When a client connection is lost while the service is stopping, the protocol stopping deferred is called and the reference to the protocol is removed. r� r N) r r� rV r� r� r �IndentationErrorr� r� r rf �calledr� r r r �&test_clientConnectionLostWhileStopping s z9ClientServiceTests.test_clientConnectionLostWhileStoppingc C sv | j ddd�\}}| �t|j�d� |�� | �t|j�d� t| �}|�� | �t|j�d� | �d|� d � dS )z� If L{ClientService} is started when it's already started, it will log a complaint and do nothing else (in particular it will not make additional connections). F)r� rG r r# z$Duplicate ClientService.startServiceN)r� rL rM r� rG r� �assertIn)r! r� r� �messagesr r r �test_startTwice s z"ClientServiceTests.test_startTwicec C s� t � }| jd|d�\}}|�� }|�� }|jdd�}| �|� | �|� | �|� |jd �d� | �|�}| �|�}| �|�} | �||� | �|| � | �||jd � dS )z{ L{ClientService.whenConnected} returns a L{Deferred} that fires when a connection is established. Fr� r# ��failAfterFailuresr N) r r� r� ru r� r/ rw rB r� ) r! re r� r� �a�b�c�resultA�resultB�resultCr r r �test_whenConnectedLater" s z*ClientServiceTests.test_whenConnectedLaterc C s� t � }| jd|d�\}}|�� }|jdd�}|jdd�}|jdd�}| �|� | �|� | �|� | �|� tt� �}|jd �|� | �|� | �| � |t�|� | �|� | �|� |� t � | � t |j�d� | �|� | �|� | �|� tt� �} |jd �| � | �|� | �| � |t�| � | �|� t } |� | � | � t |j�d� | �|� | �|� |jd �d� | �|�} | �|�} | �| | � | �| |jd � |jdd�} | �| �}| �| |� dS ) z� L{ClientService.whenConnected} returns a L{Deferred} that fails, if asked, when some number of connections have failed. Fr� r# r� rb � r N)r r� r� ru r r� r� r$ rB r� r� r� rL rM r/ rw r� )r! re r� r� �a0�a1�a2�a3�f1�f2�AT_LEAST_TWO_ATTEMPTS�resultA0�resultA3�a4�resultA4r r r �test_whenConnectedFails7 sN z*ClientServiceTests.test_whenConnectedFailsc C s� t � }| jd|d�\}}|�� }|�� }|jdd�}| �|� | �|� | �|� |�� |�t� | �|t� | �|t� | �|t� dS )z� L{ClientService.whenConnected} returns a L{Deferred} that fails when L{ClientService.stopService} is called. Fr� r# r� N) r r� r� ru rV r� r� r� r )r! re r� r� r� r� r� r r r � test_whenConnectedStopServiceq s z0ClientServiceTests.test_whenConnectedStopServicec C sR t � }| jd|d�\}}|jd �td�� |�� }| �|�� g � | �|� dS )z� When L{ClientService.stopService} is called while waiting between connection attempts, the pending reconnection attempt is cancelled and the service is stopped immediately. Fr� r � no connectionN) r r� r� r$ r� rV rL r� rw r� r r r �test_retryCancelled� s z&ClientServiceTests.test_retryCancelledc C s6 t � }| jdd|d�\}}|�� }| �| �|�� dS )z� Calling L{ClientService.stopService} before L{ClientService.startService} returns a L{Deferred} that has already fired with L{None}. F)r� rG re N�r r� rV � assertIsNonerw )r! re �_r� r& r r r �"test_stopServiceBeforeStartService� s �z5ClientServiceTests.test_stopServiceBeforeStartServicec C sp t � }| jd|d�\}}|�� }|jd �td�� |�� |�� }| �| �|�j t � | �| �|�j t � dS )z� L{ClientService.whenConnected} returns a L{Deferred} that errbacks with L{CancelledError} if L{ClientService.stopService} is called between connection attempts. Fr� r r� N) r r� r� r� r$ r� rV rg r� r� r )r! re r� r� �beforeErrbackAndStop�afterErrbackAndStopr r r �'test_whenConnectedErrbacksOnStopService� s � �z:ClientServiceTests.test_whenConnectedErrbacksOnStopServicec C sf t � }| jd|d�\}}|jd �d� |�� }|�� }|jd �tt� �� | � |� | � |� dS )z� Calling L{ClientService.stopService} twice after it has connected (that is, stopping it while it is disconnecting) returns a L{Deferred} each time that fires when the disconnection has completed. Fr� r N) r r� r� r/ rV r� r� r r� rw �r! re r� r� �firstStopDeferred�secondStopDeferredr r r �"test_stopServiceWhileDisconnecting� s z5ClientServiceTests.test_stopServiceWhileDisconnectingc C sn t � }| jd|d�\}}|jd �d� |�� }|�� |�� }|jd �tt � �� | � |� | � |� dS )z� Calling L{ClientService.stopService} after calling a reconnection attempt returns a L{Deferred} that fires when the disconnection has completed. Fr� r N) r r� r� r/ rV rG r� r� r r� rw r r r r � test_stopServiceWhileRestarting� s z2ClientServiceTests.test_stopServiceWhileRestartingc C sL t � }| jd|d�\}}|�� }|�� }| �| �|�� | �| �|�� dS )z� Calling L{ClientService.stopService} on a stopped service returns a L{Deferred} that has already fired with L{None}. Fr� Nr� )r! re r r� r r r r r � test_stopServiceOnStoppedService� s z3ClientServiceTests.test_stopServiceOnStoppedServicec s8 dg� � fdd�}| j |dd�\}}| �d� d � dS )z� The C{prepareConnection} callable is called after L{ClientService.startService} once the connection is made. r c � � d d7 < d S �Nr r# r ��_proto��preparesr r �prepareConnection� � z[ClientServiceTests.test_prepareConnectionCalledWhenServiceStarts.<locals>.prepareConnectionT)r rG r# N)r� rL �r! r r� r� r r r �-test_prepareConnectionCalledWhenServiceStarts� s �z@ClientServiceTests.test_prepareConnectionCalledWhenServiceStartsc s: g � � fdd�}| j |d�\}}| �|jd � d � dS )zf The C{prepareConnection} callable is passed the connected protocol instance. c s � � | � d S r �rX ��proto�� newProtocolsr r r s zVClientServiceTests.test_prepareConnectionCalledWithProtocol.<locals>.prepareConnection�r r N)r� rB r� r r r r �(test_prepareConnectionCalledWithProtocol s �z;ClientServiceTests.test_prepareConnectionCalledWithProtocolc s~ dg� � fdd�}t � }| j|d|d�\}}|jd �td�� | �d� d � |�t� |jd �d� | �d� d � dS ) zf The C{prepareConnection} callback is invoked only once a connection is made. r c r r r r r r r r r z]ClientServiceTests.test_prepareConnectionCalledAfterConnectionMade.<locals>.prepareConnectionF)r r� re zconnection attempt failedr# N) r r� r� r$ r� rL r� r� r/ �r! r re r� r� r r r �/test_prepareConnectionCalledAfterConnectionMade s � zBClientServiceTests.test_prepareConnectionCalledAfterConnectionMadec sn dg� � fdd�}t � }| j||d�\}}| �d� d � |jd �tt� �� |�t� | �d� d � dS )z� The C{prepareConnection} callback is invoked each time a connection is made, including on reconnection. r c r r r r r r r r / r zUClientServiceTests.test_prepareConnectionCalledOnReconnect.<locals>.prepareConnection�r re r# rb N) r r� rL r� r� r r� r� r� r r r r �'test_prepareConnectionCalledOnReconnect( s � z:ClientServiceTests.test_prepareConnectionCalledOnReconnectc s@ t � � � fdd�}| j|d�\}}| �|�� �}| �� |� dS )a? The C{prepareConnection} return value is ignored when it does not indicate a failure. Even though the callback participates in the internal new-connection L{Deferred} chain for error propagation purposes, any successful result does not affect the ultimate return value. c rl r r r ��sentinelr r r J rq zVClientServiceTests.test_prepareConnectionReturnValueIgnored.<locals>.prepareConnectionr N)rv r� rw r� �assertNotIdentical)r! r r� r� r, r r! r �(test_prepareConnectionReturnValueIgnored? s z;ClientServiceTests.test_prepareConnectionReturnValueIgnoredc s` g �t � � � �fdd�}| j|d�\}}|�� }| �|� � �d� | �|jd | �|�� dS )z� The C{prepareConnection} callable returns a deferred and calls to L{ClientService.whenConnected} wait until it fires. c s �� | � � S r r r ��newProtocolDeferredr r r r Z s zVClientServiceTests.test_prepareConnectionReturningADeferred.<locals>.prepareConnectionr Nr )r r� r� ru r/ rB r� rw )r! r r� r� �whenConnectedDeferredr r% r �(test_prepareConnectionReturningADeferredR s �z;ClientServiceTests.test_prepareConnectionReturningADeferredc C sl t � }dd� }| j||d�\}}|jdd�}| �|� |�t� | �|� |�t� | �t| �|�j � dS )zs The connection attempt counts as a failure when the C{prepareConnection} callable throws. c S s t � �r )r� r r r r r p s zJClientServiceTests.test_prepareConnectionThrows.<locals>.prepareConnectionr rb r� N) r r� r� ru r� r� rB r� r� �type)r! re r r� r� r' r r r � test_prepareConnectionThrowsi s � �z/ClientServiceTests.test_prepareConnectionThrowsN)$r4 r5 r6 r7 r r� rj r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r$ r( r* r r r r r� � sD �C : r� )F)0r7 r �zope.interfacer �zope.interface.verifyr �twisted.applicationr � twisted.application.internetr r r �twisted.internetr �twisted.internet.deferr r �twisted.internet.interfacesr r r r r �twisted.internet.protocolr r �twisted.internet.taskr �twisted.loggerr r �twisted.python.failurer �twisted.test.proto_helpersr �twisted.trial.unittestr r r r r r= ra r� r� r� r� r� r r r r �<module> s> @ #PK Mb�Z�� .� � 9 application/test/__pycache__/test_service.cpython-310.pycnu �[��� o �b/ � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZm Z m Z m Z m Z ddl mZ ddlmZ ee �G dd � d ��ZG d d � d e�ZG d d � d e�ZdS )z+ Tests for L{twisted.application.service}. � )� implementer)�BrokenImplementation)� verifyObject)� Application�IProcess�IService�IServiceCollection�Service)� IPersistable)�TestCasec @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )� AlmostServicea� Implement IService in a way that can fail. In general, classes should maintain invariants that adhere to the interfaces that they claim to implement -- otherwise, it is a bug. This is a buggy class -- the IService implementation is fragile, and several methods will break it. These bugs are intentional, as the tests trigger them -- and then check that the class, indeed, no longer complies with the interface (IService) that it claims to comply with. Since the verification will, by definition, only fail on buggy classes -- in other words, those which do not actually support the interface they claim to support, we have to write a buggy class to properly verify the interface. c C s || _ || _|| _d S )N)�name�parent�running)�selfr r r � r �G/usr/lib/python3/dist-packages/twisted/application/test/test_service.py�__init__- s zAlmostService.__init__c C � | ` dS )z� Probably not a wise method to call. This method removes the :code:`name` attribute, which has to exist in IService classes. N)r �r r r r �makeInvalidByDeletingName2 � z'AlmostService.makeInvalidByDeletingNamec C r )z� Probably not a wise method to call. This method removes the :code:`parent` attribute, which has to exist in IService classes. N)r r r r r �makeInvalidByDeletingParent; r z)AlmostService.makeInvalidByDeletingParentc C r )z� Probably not a wise method to call. This method removes the :code:`running` attribute, which has to exist in IService classes. N)r r r r r � makeInvalidByDeletingRunningD r z*AlmostService.makeInvalidByDeletingRunningc C � dS )z\ See L{twisted.application.service.IService}. @param name: ignored Nr )r r r r r �setNameM � zAlmostService.setNamec C r )z^ See L{twisted.application.service.IService}. @param parent: ignored Nr )r r r r r �setServiceParentT r z AlmostService.setServiceParentc C r �z> See L{twisted.application.service.IService}. Nr r r r r �disownServiceParent[ r z!AlmostService.disownServiceParentc C r r r r r r r �privilegedStartService` r z$AlmostService.privilegedStartServicec C r r r r r r r � startServicee r zAlmostService.startServicec C r r r r r r r � stopServicej r zAlmostService.stopServiceN)�__name__� __module__� __qualname__�__doc__r r r r r r r r r! r" r r r r r s r c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�ServiceInterfaceTestszK Tests for L{twisted.application.service.IService} implementation. c C s t dddd�| _dS )z; Build something that implements IService. NF)r r r )r � almostServicer r r r �setUpu s zServiceInterfaceTests.setUpc C s t � }tt|� dS )z. Service implements IService. N)r r r )r � myServicer r r �test_realService{ s z&ServiceInterfaceTests.test_realServicec C s t t| j� dS )z4 AlmostService implements IService. N)r r r( r r r r � test_hasAll� s z!ServiceInterfaceTests.test_hasAllc C �F | j �� | �t�� tt| j � W d � dS 1 s w Y dS )zI AlmostService with no name does not implement IService. N)r( r � assertRaisesr r r r r r r � test_noName� � "�z!ServiceInterfaceTests.test_noNamec C r- )zK AlmostService with no parent does not implement IService. N)r( r r. r r r r r r r � test_noParent� r0 z#ServiceInterfaceTests.test_noParentc C r- )zL AlmostService with no running does not implement IService. N)r( r r. r r r r r r r �test_noRunning� r0 z$ServiceInterfaceTests.test_noRunningN) r# r$ r% r& r) r+ r, r/ r1 r2 r r r r r' p s r' c @ s e Zd ZdZdd� ZdS )�ApplicationTestsz? Tests for L{twisted.application.service.Application}. c C s\ t d�}| �ttt|��� | �ttt|��� | �ttt|��� | �ttt|��� dS )zQ Check L{twisted.application.service.Application} instantiation. zapp-nameN)r � assertTruer r r r r )r �appr r r �test_applicationComponents� s z+ApplicationTests.test_applicationComponentsN)r# r$ r% r& r6 r r r r r3 � s r3 N)r& �zope.interfacer �zope.interface.exceptionsr �zope.interface.verifyr �twisted.application.servicer r r r r �twisted.persisted.sobr �twisted.trial.unittestr r r' r3 r r r r �<module> s W1PK Mb�Z]���O� O� ! application/test/test_internet.pynu �[��� # -*- test-case-name: twisted.application.test.test_internet -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for (new code in) L{twisted.application.internet}. @var AT_LEAST_ONE_ATTEMPT: At least enough seconds for L{ClientService} to make one attempt. """ import pickle from zope.interface import implementer from zope.interface.verify import verifyClass from twisted.application import internet from twisted.application.internet import ( ClientService, StreamServerEndpointService, TimerService, ) from twisted.internet import task from twisted.internet.defer import CancelledError, Deferred from twisted.internet.interfaces import ( IFileDescriptorReceiver, IHalfCloseableProtocol, IListeningPort, IStreamClientEndpoint, IStreamServerEndpoint, ) from twisted.internet.protocol import Factory, Protocol from twisted.internet.task import Clock from twisted.logger import formatEvent, globalLogPublisher from twisted.python.failure import Failure from twisted.test.proto_helpers import StringTransport from twisted.trial.unittest import SynchronousTestCase, TestCase def fakeTargetFunction(): """ A fake target function for testing TimerService which does nothing. """ pass @implementer(IStreamServerEndpoint) class FakeServer: """ In-memory implementation of L{IStreamServerEndpoint}. @ivar result: The L{Deferred} resulting from the call to C{listen}, after C{listen} has been called. @ivar factory: The factory passed to C{listen}. @ivar cancelException: The exception to errback C{self.result} when it is cancelled. @ivar port: The L{IListeningPort} which C{listen}'s L{Deferred} will fire with. @ivar listenAttempts: The number of times C{listen} has been invoked. @ivar failImmediately: If set, the exception to fail the L{Deferred} returned from C{listen} before it is returned. """ result = None factory = None failImmediately = None cancelException = CancelledError() listenAttempts = 0 def __init__(self): self.port = FakePort() def listen(self, factory): """ Return a Deferred and store it for future use. (Implementation of L{IStreamServerEndpoint}). @param factory: the factory to listen with @return: a L{Deferred} stored in L{FakeServer.result} """ self.listenAttempts += 1 self.factory = factory self.result = Deferred(canceller=lambda d: d.errback(self.cancelException)) if self.failImmediately is not None: self.result.errback(self.failImmediately) return self.result def startedListening(self): """ Test code should invoke this method after causing C{listen} to be invoked in order to fire the L{Deferred} previously returned from C{listen}. """ self.result.callback(self.port) def stoppedListening(self): """ Test code should invoke this method after causing C{stopListening} to be invoked on the port fired from the L{Deferred} returned from C{listen} in order to cause the L{Deferred} returned from C{stopListening} to fire. """ self.port.deferred.callback(None) verifyClass(IStreamServerEndpoint, FakeServer) @implementer(IListeningPort) class FakePort: """ Fake L{IListeningPort} implementation. @ivar deferred: The L{Deferred} returned by C{stopListening}. """ deferred = None def stopListening(self): """ Stop listening. @return: a L{Deferred} stored in L{FakePort.deferred} """ self.deferred = Deferred() return self.deferred def getHost(self): # IListeningPort.getHost pass def startListening(self): # IListeningPort.startListening pass verifyClass(IStreamServerEndpoint, FakeServer) class EndpointServiceTests(TestCase): """ Tests for L{twisted.application.internet}. """ def setUp(self): """ Construct a stub server, a stub factory, and a L{StreamServerEndpointService} to test. """ self.fakeServer = FakeServer() self.factory = Factory() self.svc = StreamServerEndpointService(self.fakeServer, self.factory) def test_privilegedStartService(self): """ L{StreamServerEndpointService.privilegedStartService} calls its endpoint's C{listen} method with its factory. """ self.svc.privilegedStartService() self.assertIdentical(self.factory, self.fakeServer.factory) def test_synchronousRaiseRaisesSynchronously(self, thunk=None): """ L{StreamServerEndpointService.startService} should raise synchronously if the L{Deferred} returned by its wrapped L{IStreamServerEndpoint.listen} has already fired with an errback and the L{StreamServerEndpointService}'s C{_raiseSynchronously} flag has been set. This feature is necessary to preserve compatibility with old behavior of L{twisted.internet.strports.service}, which is to return a service which synchronously raises an exception from C{startService} (so that, among other things, twistd will not start running). However, since L{IStreamServerEndpoint.listen} may fail asynchronously, it is a bad idea to rely on this behavior. @param thunk: If specified, a callable to execute in place of C{startService}. """ self.fakeServer.failImmediately = ZeroDivisionError() self.svc._raiseSynchronously = True self.assertRaises(ZeroDivisionError, thunk or self.svc.startService) def test_synchronousRaisePrivileged(self): """ L{StreamServerEndpointService.privilegedStartService} should behave the same as C{startService} with respect to L{EndpointServiceTests.test_synchronousRaiseRaisesSynchronously}. """ self.test_synchronousRaiseRaisesSynchronously(self.svc.privilegedStartService) def test_failReportsError(self): """ L{StreamServerEndpointService.startService} and L{StreamServerEndpointService.privilegedStartService} should both log an exception when the L{Deferred} returned from their wrapped L{IStreamServerEndpoint.listen} fails. """ self.svc.startService() self.fakeServer.result.errback(ZeroDivisionError()) logged = self.flushLoggedErrors(ZeroDivisionError) self.assertEqual(len(logged), 1) def test_asynchronousFailReportsError(self): """ L{StreamServerEndpointService.startService} and L{StreamServerEndpointService.privilegedStartService} should both log an exception when the L{Deferred} returned from their wrapped L{IStreamServerEndpoint.listen} fails asynchronously, even if C{_raiseSynchronously} is set. """ self.svc._raiseSynchronously = True self.svc.startService() self.fakeServer.result.errback(ZeroDivisionError()) logged = self.flushLoggedErrors(ZeroDivisionError) self.assertEqual(len(logged), 1) def test_synchronousFailReportsError(self): """ Without the C{_raiseSynchronously} compatibility flag, failing immediately has the same behavior as failing later; it logs the error. """ self.fakeServer.failImmediately = ZeroDivisionError() self.svc.startService() logged = self.flushLoggedErrors(ZeroDivisionError) self.assertEqual(len(logged), 1) def test_startServiceUnstarted(self): """ L{StreamServerEndpointService.startService} sets the C{running} flag, and calls its endpoint's C{listen} method with its factory, if it has not yet been started. """ self.svc.startService() self.assertIdentical(self.factory, self.fakeServer.factory) self.assertEqual(self.svc.running, True) def test_startServiceStarted(self): """ L{StreamServerEndpointService.startService} sets the C{running} flag, but nothing else, if the service has already been started. """ self.test_privilegedStartService() self.svc.startService() self.assertEqual(self.fakeServer.listenAttempts, 1) self.assertEqual(self.svc.running, True) def test_stopService(self): """ L{StreamServerEndpointService.stopService} calls C{stopListening} on the L{IListeningPort} returned from its endpoint, returns the C{Deferred} from stopService, and sets C{running} to C{False}. """ self.svc.privilegedStartService() self.fakeServer.startedListening() # Ensure running gets set to true self.svc.startService() result = self.svc.stopService() l = [] result.addCallback(l.append) self.assertEqual(len(l), 0) self.fakeServer.stoppedListening() self.assertEqual(len(l), 1) self.assertFalse(self.svc.running) def test_stopServiceBeforeStartFinished(self): """ L{StreamServerEndpointService.stopService} cancels the L{Deferred} returned by C{listen} if it has not yet fired. No error will be logged about the cancellation of the listen attempt. """ self.svc.privilegedStartService() result = self.svc.stopService() l = [] result.addBoth(l.append) self.assertEqual(l, [None]) self.assertEqual(self.flushLoggedErrors(CancelledError), []) def test_stopServiceCancelStartError(self): """ L{StreamServerEndpointService.stopService} cancels the L{Deferred} returned by C{listen} if it has not fired yet. An error will be logged if the resulting exception is not L{CancelledError}. """ self.fakeServer.cancelException = ZeroDivisionError() self.svc.privilegedStartService() result = self.svc.stopService() l = [] result.addCallback(l.append) self.assertEqual(l, [None]) stoppingErrors = self.flushLoggedErrors(ZeroDivisionError) self.assertEqual(len(stoppingErrors), 1) class TimerServiceTests(TestCase): """ Tests for L{twisted.application.internet.TimerService}. @type timer: L{TimerService} @ivar timer: service to test @type clock: L{task.Clock} @ivar clock: source of time @type deferred: L{Deferred} @ivar deferred: deferred returned by L{TimerServiceTests.call}. """ def setUp(self): """ Set up a timer service to test. """ self.timer = TimerService(2, self.call) self.clock = self.timer.clock = task.Clock() self.deferred = Deferred() def call(self): """ Function called by L{TimerService} being tested. @returns: C{self.deferred} @rtype: L{Deferred} """ return self.deferred def test_startService(self): """ When L{TimerService.startService} is called, it marks itself as running, creates a L{task.LoopingCall} and starts it. """ self.timer.startService() self.assertTrue(self.timer.running, "Service is started") self.assertIsInstance(self.timer._loop, task.LoopingCall) self.assertIdentical(self.clock, self.timer._loop.clock) self.assertTrue(self.timer._loop.running, "LoopingCall is started") def test_startServiceRunsCallImmediately(self): """ When L{TimerService.startService} is called, it calls the function immediately. """ result = [] self.timer.call = (result.append, (None,), {}) self.timer.startService() self.assertEqual([None], result) def test_startServiceUsesGlobalReactor(self): """ L{TimerService.startService} uses L{internet._maybeGlobalReactor} to choose the reactor to pass to L{task.LoopingCall} uses the global reactor. """ otherClock = task.Clock() def getOtherClock(maybeReactor): return otherClock self.patch(internet, "_maybeGlobalReactor", getOtherClock) self.timer.startService() self.assertIdentical(otherClock, self.timer._loop.clock) def test_stopServiceWaits(self): """ When L{TimerService.stopService} is called while a call is in progress. the L{Deferred} returned doesn't fire until after the call finishes. """ self.timer.startService() d = self.timer.stopService() self.assertNoResult(d) self.assertEqual(True, self.timer.running) self.deferred.callback(object()) self.assertIdentical(self.successResultOf(d), None) def test_stopServiceImmediately(self): """ When L{TimerService.stopService} is called while a call isn't in progress. the L{Deferred} returned has already been fired. """ self.timer.startService() self.deferred.callback(object()) d = self.timer.stopService() self.assertIdentical(self.successResultOf(d), None) def test_failedCallLogsError(self): """ When function passed to L{TimerService} returns a deferred that errbacks, the exception is logged, and L{TimerService.stopService} doesn't raise an error. """ self.timer.startService() self.deferred.errback(Failure(ZeroDivisionError())) errors = self.flushLoggedErrors(ZeroDivisionError) self.assertEqual(1, len(errors)) d = self.timer.stopService() self.assertIdentical(self.successResultOf(d), None) def test_pickleTimerServiceNotPickleLoop(self): """ When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loop}. """ # We need a pickleable callable to test pickling TimerService. So we # can't use self.timer timer = TimerService(1, fakeTargetFunction) timer.startService() dumpedTimer = pickle.dumps(timer) timer.stopService() loadedTimer = pickle.loads(dumpedTimer) nothing = object() value = getattr(loadedTimer, "_loop", nothing) self.assertIdentical(nothing, value) def test_pickleTimerServiceNotPickleLoopFinished(self): """ When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loopFinished}. """ # We need a pickleable callable to test pickling TimerService. So we # can't use self.timer timer = TimerService(1, fakeTargetFunction) timer.startService() dumpedTimer = pickle.dumps(timer) timer.stopService() loadedTimer = pickle.loads(dumpedTimer) nothing = object() value = getattr(loadedTimer, "_loopFinished", nothing) self.assertIdentical(nothing, value) class ConnectInformation: """ Information about C{endpointForTesting} @ivar connectQueue: a L{list} of L{Deferred} returned from C{connect}. If these are not already fired, you can fire them with no value and they will trigger building a factory. @ivar constructedProtocols: a L{list} of protocols constructed. @ivar passedFactories: a L{list} of L{IProtocolFactory}; the ones actually passed to the underlying endpoint / i.e. the reactor. """ def __init__(self): self.connectQueue = [] self.constructedProtocols = [] self.passedFactories = [] def endpointForTesting(fireImmediately=False): """ Make a sample endpoint for testing. @param fireImmediately: If true, fire all L{Deferred}s returned from C{connect} immedaitely. @return: a 2-tuple of C{(information, endpoint)}, where C{information} is a L{ConnectInformation} describing the operations in progress on C{endpoint}. """ @implementer(IStreamClientEndpoint) class ClientTestEndpoint: def connect(self, factory): result = Deferred() info.passedFactories.append(factory) @result.addCallback def createProtocol(ignored): protocol = factory.buildProtocol(None) info.constructedProtocols.append(protocol) transport = StringTransport() protocol.makeConnection(transport) return protocol info.connectQueue.append(result) if fireImmediately: result.callback(None) return result info = ConnectInformation() return info, ClientTestEndpoint() def catchLogs(testCase, logPublisher=globalLogPublisher): """ Catch the global log stream. @param testCase: The test case to add a cleanup to. @param logPublisher: the log publisher to add and remove observers for. @return: a 0-argument callable that returns a list of textual log messages for comparison. @rtype: L{list} of L{unicode} """ logs = [] logPublisher.addObserver(logs.append) testCase.addCleanup(lambda: logPublisher.removeObserver(logs.append)) return lambda: [formatEvent(event) for event in logs] AT_LEAST_ONE_ATTEMPT = 100.0 class ClientServiceTests(SynchronousTestCase): """ Tests for L{ClientService}. """ def makeReconnector( self, fireImmediately=True, startService=True, protocolType=Protocol, **kw ): """ Create a L{ClientService} along with a L{ConnectInformation} indicating the connections in progress on its endpoint. @param fireImmediately: Should all of the endpoint connection attempts fire synchronously? @type fireImmediately: L{bool} @param startService: Should the L{ClientService} be started before being returned? @type startService: L{bool} @param protocolType: a 0-argument callable returning a new L{IProtocol} provider to be used for application-level protocol connections. @param kw: Arbitrary keyword arguments to be passed on to L{ClientService} @return: a 2-tuple of L{ConnectInformation} (for information about test state) and L{ClientService} (the system under test). The L{ConnectInformation} has 2 additional attributes; C{applicationFactory} and C{applicationProtocols}, which refer to the unwrapped protocol factory and protocol instances passed in to L{ClientService} respectively. """ nkw = {} nkw.update(clock=Clock()) nkw.update(kw) clock = nkw["clock"] cq, endpoint = endpointForTesting(fireImmediately=fireImmediately) # `endpointForTesting` is totally generic to any LLPI client that uses # endpoints, and maintains all its state internally; however, # applicationProtocols and applicationFactory are bonus attributes that # are only specifically interesitng to tests that use wrapper # protocols. For now, set them here, externally. applicationProtocols = cq.applicationProtocols = [] class RememberingFactory(Factory): protocol = protocolType def buildProtocol(self, addr): result = super().buildProtocol(addr) applicationProtocols.append(result) return result cq.applicationFactory = factory = RememberingFactory() service = ClientService(endpoint, factory, **nkw) def stop(): service._protocol = None if service.running: service.stopService() # Ensure that we don't leave any state in the reactor after # stopService. self.assertEqual(clock.getDelayedCalls(), []) self.addCleanup(stop) if startService: service.startService() return cq, service def test_startService(self): """ When the service is started, a connection attempt is made. """ cq, service = self.makeReconnector(fireImmediately=False) self.assertEqual(len(cq.connectQueue), 1) def test_startStopFactory(self): """ Although somewhat obscure, L{IProtocolFactory} includes both C{doStart} and C{doStop} methods; ensure that when these methods are called on the factory that was passed to the reactor, the factory that was passed from the application receives them. """ cq, service = self.makeReconnector() firstAppFactory = cq.applicationFactory self.assertEqual(firstAppFactory.numPorts, 0) firstPassedFactory = cq.passedFactories[0] firstPassedFactory.doStart() self.assertEqual(firstAppFactory.numPorts, 1) def test_stopServiceWhileConnected(self): """ When the service is stopped, no further connect attempts are made. The returned L{Deferred} fires when all outstanding connections have been stopped. """ cq, service = self.makeReconnector() d = service.stopService() self.assertNoResult(d) protocol = cq.constructedProtocols[0] self.assertEqual(protocol.transport.disconnecting, True) protocol.connectionLost(Failure(Exception())) self.successResultOf(d) def test_startServiceWaitsForDisconnect(self): """ When L{ClientService} is restarted after having been connected, it waits to start connecting until after having disconnected. """ cq, service = self.makeReconnector() d = service.stopService() self.assertNoResult(d) protocol = cq.constructedProtocols[0] self.assertEqual(protocol.transport.disconnecting, True) service.startService() self.assertNoResult(d) self.assertEqual(len(cq.constructedProtocols), 1) protocol.connectionLost(Failure(Exception())) self.assertEqual(len(cq.constructedProtocols), 2) def test_startServiceWhileStopping(self): """ When L{ClientService} is stopping - that is, L{ClientService.stopService} has been called, but the L{Deferred} it returns has not fired yet - calling L{startService} will cause a new connection to be made, and new calls to L{whenConnected} to succeed. """ cq, service = self.makeReconnector(fireImmediately=False) cq.connectQueue[0].callback(None) first = cq.constructedProtocols[0] stopped = service.stopService() self.assertNoResult(stopped) nextProtocol = service.whenConnected() self.assertNoResult(nextProtocol) service.startService() self.assertNoResult(nextProtocol) self.assertNoResult(stopped) self.assertEqual(first.transport.disconnecting, True) first.connectionLost(Failure(Exception())) self.successResultOf(stopped) cq.connectQueue[1].callback(None) self.assertEqual(len(cq.constructedProtocols), 2) self.assertIdentical( self.successResultOf(nextProtocol), cq.applicationProtocols[1] ) secondStopped = service.stopService() self.assertNoResult(secondStopped) def test_startServiceWhileStopped(self): """ When L{ClientService} is stopped - that is, L{ClientService.stopService} has been called and the L{Deferred} it returns has fired - calling L{startService} will cause a new connection to be made, and new calls to L{whenConnected} to succeed. """ cq, service = self.makeReconnector(fireImmediately=False) stopped = service.stopService() self.successResultOf(stopped) self.failureResultOf(service.whenConnected(), CancelledError) service.startService() cq.connectQueue[-1].callback(None) self.assertIdentical( cq.applicationProtocols[-1], self.successResultOf(service.whenConnected()) ) def test_interfacesForTransport(self): """ If the protocol objects returned by the factory given to L{ClientService} provide special "marker" interfaces for their transport - L{IHalfCloseableProtocol} or L{IFileDescriptorReceiver} - those interfaces will be provided by the protocol objects passed on to the reactor. """ @implementer(IHalfCloseableProtocol, IFileDescriptorReceiver) class FancyProtocol(Protocol): """ Provider of various interfaces. """ cq, service = self.makeReconnector(protocolType=FancyProtocol) reactorFacing = cq.constructedProtocols[0] self.assertTrue(IFileDescriptorReceiver.providedBy(reactorFacing)) self.assertTrue(IHalfCloseableProtocol.providedBy(reactorFacing)) def test_stopServiceWhileRetrying(self): """ When the service is stopped while retrying, the retry is cancelled. """ clock = Clock() cq, service = self.makeReconnector(fireImmediately=False, clock=clock) cq.connectQueue[0].errback(Exception()) clock.advance(AT_LEAST_ONE_ATTEMPT) self.assertEqual(len(cq.connectQueue), 2) d = service.stopService() cq.connectQueue[1].errback(Exception()) self.successResultOf(d) def test_stopServiceWhileConnecting(self): """ When the service is stopped while initially connecting, the connection attempt is cancelled. """ clock = Clock() cq, service = self.makeReconnector(fireImmediately=False, clock=clock) self.assertEqual(len(cq.connectQueue), 1) self.assertNoResult(cq.connectQueue[0]) d = service.stopService() self.successResultOf(d) def test_clientConnected(self): """ When a client connects, the service keeps a reference to the new protocol and resets the delay. """ clock = Clock() cq, service = self.makeReconnector(clock=clock) awaitingProtocol = service.whenConnected() self.assertEqual(clock.getDelayedCalls(), []) self.assertIdentical( self.successResultOf(awaitingProtocol), cq.applicationProtocols[0] ) def test_clientConnectionFailed(self): """ When a client connection fails, the service removes its reference to the protocol and tries again after a timeout. """ clock = Clock() cq, service = self.makeReconnector(fireImmediately=False, clock=clock) self.assertEqual(len(cq.connectQueue), 1) cq.connectQueue[0].errback(Failure(Exception())) whenConnected = service.whenConnected() self.assertNoResult(whenConnected) # Don't fail during test tear-down when service shutdown causes all # waiting connections to fail. whenConnected.addErrback(lambda ignored: ignored.trap(CancelledError)) clock.advance(AT_LEAST_ONE_ATTEMPT) self.assertEqual(len(cq.connectQueue), 2) def test_clientConnectionLost(self): """ When a client connection is lost, the service removes its reference to the protocol and calls retry. """ clock = Clock() cq, service = self.makeReconnector(clock=clock, fireImmediately=False) self.assertEqual(len(cq.connectQueue), 1) cq.connectQueue[0].callback(None) self.assertEqual(len(cq.connectQueue), 1) self.assertIdentical( self.successResultOf(service.whenConnected()), cq.applicationProtocols[0] ) cq.constructedProtocols[0].connectionLost(Failure(Exception())) clock.advance(AT_LEAST_ONE_ATTEMPT) self.assertEqual(len(cq.connectQueue), 2) cq.connectQueue[1].callback(None) self.assertIdentical( self.successResultOf(service.whenConnected()), cq.applicationProtocols[1] ) def test_clientConnectionLostWhileStopping(self): """ When a client connection is lost while the service is stopping, the protocol stopping deferred is called and the reference to the protocol is removed. """ clock = Clock() cq, service = self.makeReconnector(clock=clock) d = service.stopService() cq.constructedProtocols[0].connectionLost(Failure(IndentationError())) self.failureResultOf(service.whenConnected(), CancelledError) self.assertTrue(d.called) def test_startTwice(self): """ If L{ClientService} is started when it's already started, it will log a complaint and do nothing else (in particular it will not make additional connections). """ cq, service = self.makeReconnector(fireImmediately=False, startService=False) self.assertEqual(len(cq.connectQueue), 0) service.startService() self.assertEqual(len(cq.connectQueue), 1) messages = catchLogs(self) service.startService() self.assertEqual(len(cq.connectQueue), 1) self.assertIn("Duplicate ClientService.startService", messages()[0]) def test_whenConnectedLater(self): """ L{ClientService.whenConnected} returns a L{Deferred} that fires when a connection is established. """ clock = Clock() cq, service = self.makeReconnector(fireImmediately=False, clock=clock) a = service.whenConnected() b = service.whenConnected() c = service.whenConnected(failAfterFailures=1) self.assertNoResult(a) self.assertNoResult(b) self.assertNoResult(c) cq.connectQueue[0].callback(None) resultA = self.successResultOf(a) resultB = self.successResultOf(b) resultC = self.successResultOf(c) self.assertIdentical(resultA, resultB) self.assertIdentical(resultA, resultC) self.assertIdentical(resultA, cq.applicationProtocols[0]) def test_whenConnectedFails(self): """ L{ClientService.whenConnected} returns a L{Deferred} that fails, if asked, when some number of connections have failed. """ clock = Clock() cq, service = self.makeReconnector(fireImmediately=False, clock=clock) a0 = service.whenConnected() a1 = service.whenConnected(failAfterFailures=1) a2 = service.whenConnected(failAfterFailures=2) a3 = service.whenConnected(failAfterFailures=3) self.assertNoResult(a0) self.assertNoResult(a1) self.assertNoResult(a2) self.assertNoResult(a3) f1 = Failure(Exception()) cq.connectQueue[0].errback(f1) self.assertNoResult(a0) self.assertIdentical(self.failureResultOf(a1, Exception), f1) self.assertNoResult(a2) self.assertNoResult(a3) clock.advance(AT_LEAST_ONE_ATTEMPT) self.assertEqual(len(cq.connectQueue), 2) self.assertNoResult(a0) self.assertNoResult(a2) self.assertNoResult(a3) f2 = Failure(Exception()) cq.connectQueue[1].errback(f2) self.assertNoResult(a0) self.assertIdentical(self.failureResultOf(a2, Exception), f2) self.assertNoResult(a3) AT_LEAST_TWO_ATTEMPTS = AT_LEAST_ONE_ATTEMPT # close enough clock.advance(AT_LEAST_TWO_ATTEMPTS) self.assertEqual(len(cq.connectQueue), 3) self.assertNoResult(a0) self.assertNoResult(a3) cq.connectQueue[2].callback(None) resultA0 = self.successResultOf(a0) resultA3 = self.successResultOf(a3) self.assertIdentical(resultA0, resultA3) self.assertIdentical(resultA0, cq.applicationProtocols[0]) # a new whenConnected Deferred, obtained after we're connected, # should have fired already, even if failAfterFailures is set a4 = service.whenConnected(failAfterFailures=1) resultA4 = self.successResultOf(a4) self.assertIdentical(resultA0, resultA4) def test_whenConnectedStopService(self): """ L{ClientService.whenConnected} returns a L{Deferred} that fails when L{ClientService.stopService} is called. """ clock = Clock() cq, service = self.makeReconnector(fireImmediately=False, clock=clock) a = service.whenConnected() b = service.whenConnected() c = service.whenConnected(failAfterFailures=1) self.assertNoResult(a) self.assertNoResult(b) self.assertNoResult(c) service.stopService() clock.advance(AT_LEAST_ONE_ATTEMPT) self.failureResultOf(a, CancelledError) self.failureResultOf(b, CancelledError) self.failureResultOf(c, CancelledError) def test_retryCancelled(self): """ When L{ClientService.stopService} is called while waiting between connection attempts, the pending reconnection attempt is cancelled and the service is stopped immediately. """ clock = Clock() cq, service = self.makeReconnector(fireImmediately=False, clock=clock) cq.connectQueue[0].errback(Exception("no connection")) d = service.stopService() self.assertEqual(clock.getDelayedCalls(), []) self.successResultOf(d) def test_stopServiceBeforeStartService(self): """ Calling L{ClientService.stopService} before L{ClientService.startService} returns a L{Deferred} that has already fired with L{None}. """ clock = Clock() _, service = self.makeReconnector( fireImmediately=False, startService=False, clock=clock ) d = service.stopService() self.assertIsNone(self.successResultOf(d)) def test_whenConnectedErrbacksOnStopService(self): """ L{ClientService.whenConnected} returns a L{Deferred} that errbacks with L{CancelledError} if L{ClientService.stopService} is called between connection attempts. """ clock = Clock() cq, service = self.makeReconnector(fireImmediately=False, clock=clock) beforeErrbackAndStop = service.whenConnected() # The protocol fails to connect, and the service is waiting to # reconnect. cq.connectQueue[0].errback(Exception("no connection")) service.stopService() afterErrbackAndStop = service.whenConnected() self.assertIsInstance( self.failureResultOf(beforeErrbackAndStop).value, CancelledError ) self.assertIsInstance( self.failureResultOf(afterErrbackAndStop).value, CancelledError ) def test_stopServiceWhileDisconnecting(self): """ Calling L{ClientService.stopService} twice after it has connected (that is, stopping it while it is disconnecting) returns a L{Deferred} each time that fires when the disconnection has completed. """ clock = Clock() cq, service = self.makeReconnector(fireImmediately=False, clock=clock) # The protocol connects cq.connectQueue[0].callback(None) # The protocol begins disconnecting firstStopDeferred = service.stopService() # The protocol continues disconnecting secondStopDeferred = service.stopService() # The protocol is disconnected cq.constructedProtocols[0].connectionLost(Failure(IndentationError())) self.successResultOf(firstStopDeferred) self.successResultOf(secondStopDeferred) def test_stopServiceWhileRestarting(self): """ Calling L{ClientService.stopService} after calling a reconnection attempt returns a L{Deferred} that fires when the disconnection has completed. """ clock = Clock() cq, service = self.makeReconnector(fireImmediately=False, clock=clock) # The protocol connects cq.connectQueue[0].callback(None) # The protocol begins disconnecting firstStopDeferred = service.stopService() # The protocol begins reconnecting service.startService() # The protocol begins disconnecting again secondStopDeferred = service.stopService() # The protocol is disconnected cq.constructedProtocols[0].connectionLost(Failure(IndentationError())) self.successResultOf(firstStopDeferred) self.successResultOf(secondStopDeferred) def test_stopServiceOnStoppedService(self): """ Calling L{ClientService.stopService} on a stopped service returns a L{Deferred} that has already fired with L{None}. """ clock = Clock() _, service = self.makeReconnector(fireImmediately=False, clock=clock) firstStopDeferred = service.stopService() secondStopDeferred = service.stopService() self.assertIsNone(self.successResultOf(firstStopDeferred)) self.assertIsNone(self.successResultOf(secondStopDeferred)) def test_prepareConnectionCalledWhenServiceStarts(self): """ The C{prepareConnection} callable is called after L{ClientService.startService} once the connection is made. """ prepares = [0] def prepareConnection(_proto): prepares[0] += 1 cq, service = self.makeReconnector( prepareConnection=prepareConnection, startService=True ) self.assertEqual(1, prepares[0]) def test_prepareConnectionCalledWithProtocol(self): """ The C{prepareConnection} callable is passed the connected protocol instance. """ newProtocols = [] def prepareConnection(proto): newProtocols.append(proto) cq, service = self.makeReconnector( prepareConnection=prepareConnection, ) self.assertIdentical(cq.constructedProtocols[0], newProtocols[0]) def test_prepareConnectionCalledAfterConnectionMade(self): """ The C{prepareConnection} callback is invoked only once a connection is made. """ prepares = [0] def prepareConnection(_proto): prepares[0] += 1 clock = Clock() cq, service = self.makeReconnector( prepareConnection=prepareConnection, fireImmediately=False, clock=clock ) cq.connectQueue[0].errback(Exception("connection attempt failed")) self.assertEqual(0, prepares[0]) # Not called yet. clock.advance(AT_LEAST_ONE_ATTEMPT) cq.connectQueue[1].callback(None) self.assertEqual(1, prepares[0]) # Was called. def test_prepareConnectionCalledOnReconnect(self): """ The C{prepareConnection} callback is invoked each time a connection is made, including on reconnection. """ prepares = [0] def prepareConnection(_proto): prepares[0] += 1 clock = Clock() cq, service = self.makeReconnector( prepareConnection=prepareConnection, clock=clock ) self.assertEqual(1, prepares[0]) # Called once. # Protocol disconnects. cq.constructedProtocols[0].connectionLost(Failure(IndentationError())) clock.advance(AT_LEAST_ONE_ATTEMPT) self.assertEqual(2, prepares[0]) # Called again. def test_prepareConnectionReturnValueIgnored(self): """ The C{prepareConnection} return value is ignored when it does not indicate a failure. Even though the callback participates in the internal new-connection L{Deferred} chain for error propagation purposes, any successful result does not affect the ultimate return value. """ # Sentinel object returned by prepareConnection. sentinel = object() def prepareConnection(proto): return sentinel cq, service = self.makeReconnector(prepareConnection=prepareConnection) result = self.successResultOf(service.whenConnected()) self.assertNotIdentical(sentinel, result) def test_prepareConnectionReturningADeferred(self): """ The C{prepareConnection} callable returns a deferred and calls to L{ClientService.whenConnected} wait until it fires. """ newProtocols = [] newProtocolDeferred = Deferred() def prepareConnection(proto): newProtocols.append(proto) return newProtocolDeferred cq, service = self.makeReconnector(prepareConnection=prepareConnection) whenConnectedDeferred = service.whenConnected() self.assertNoResult(whenConnectedDeferred) newProtocolDeferred.callback(None) self.assertIdentical( cq.applicationProtocols[0], self.successResultOf(whenConnectedDeferred) ) def test_prepareConnectionThrows(self): """ The connection attempt counts as a failure when the C{prepareConnection} callable throws. """ clock = Clock() def prepareConnection(_proto): raise IndentationError() cq, service = self.makeReconnector( prepareConnection=prepareConnection, clock=clock ) whenConnectedDeferred = service.whenConnected(failAfterFailures=2) self.assertNoResult(whenConnectedDeferred) clock.advance(AT_LEAST_ONE_ATTEMPT) self.assertNoResult(whenConnectedDeferred) clock.advance(AT_LEAST_ONE_ATTEMPT) self.assertIdentical( IndentationError, self.failureResultOf(whenConnectedDeferred).type ) PK Mb�Z�kg�/ / application/test/test_service.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.application.service}. """ from zope.interface import implementer from zope.interface.exceptions import BrokenImplementation from zope.interface.verify import verifyObject from twisted.application.service import ( Application, IProcess, IService, IServiceCollection, Service, ) from twisted.persisted.sob import IPersistable from twisted.trial.unittest import TestCase @implementer(IService) class AlmostService: """ Implement IService in a way that can fail. In general, classes should maintain invariants that adhere to the interfaces that they claim to implement -- otherwise, it is a bug. This is a buggy class -- the IService implementation is fragile, and several methods will break it. These bugs are intentional, as the tests trigger them -- and then check that the class, indeed, no longer complies with the interface (IService) that it claims to comply with. Since the verification will, by definition, only fail on buggy classes -- in other words, those which do not actually support the interface they claim to support, we have to write a buggy class to properly verify the interface. """ def __init__(self, name, parent, running): self.name = name self.parent = parent self.running = running def makeInvalidByDeletingName(self): """ Probably not a wise method to call. This method removes the :code:`name` attribute, which has to exist in IService classes. """ del self.name def makeInvalidByDeletingParent(self): """ Probably not a wise method to call. This method removes the :code:`parent` attribute, which has to exist in IService classes. """ del self.parent def makeInvalidByDeletingRunning(self): """ Probably not a wise method to call. This method removes the :code:`running` attribute, which has to exist in IService classes. """ del self.running def setName(self, name): """ See L{twisted.application.service.IService}. @param name: ignored """ def setServiceParent(self, parent): """ See L{twisted.application.service.IService}. @param parent: ignored """ def disownServiceParent(self): """ See L{twisted.application.service.IService}. """ def privilegedStartService(self): """ See L{twisted.application.service.IService}. """ def startService(self): """ See L{twisted.application.service.IService}. """ def stopService(self): """ See L{twisted.application.service.IService}. """ class ServiceInterfaceTests(TestCase): """ Tests for L{twisted.application.service.IService} implementation. """ def setUp(self): """ Build something that implements IService. """ self.almostService = AlmostService(parent=None, running=False, name=None) def test_realService(self): """ Service implements IService. """ myService = Service() verifyObject(IService, myService) def test_hasAll(self): """ AlmostService implements IService. """ verifyObject(IService, self.almostService) def test_noName(self): """ AlmostService with no name does not implement IService. """ self.almostService.makeInvalidByDeletingName() with self.assertRaises(BrokenImplementation): verifyObject(IService, self.almostService) def test_noParent(self): """ AlmostService with no parent does not implement IService. """ self.almostService.makeInvalidByDeletingParent() with self.assertRaises(BrokenImplementation): verifyObject(IService, self.almostService) def test_noRunning(self): """ AlmostService with no running does not implement IService. """ self.almostService.makeInvalidByDeletingRunning() with self.assertRaises(BrokenImplementation): verifyObject(IService, self.almostService) class ApplicationTests(TestCase): """ Tests for L{twisted.application.service.Application}. """ def test_applicationComponents(self): """ Check L{twisted.application.service.Application} instantiation. """ app = Application("app-name") self.assertTrue(verifyObject(IService, IService(app))) self.assertTrue(verifyObject(IServiceCollection, IServiceCollection(app))) self.assertTrue(verifyObject(IProcess, IProcess(app))) self.assertTrue(verifyObject(IPersistable, IPersistable(app))) PK Mb�Z��| | application/test/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.internet.application}. """ PK Mb�Z��h�! ! application/reactors.pynu �[��� # -*- test-case-name: twisted.test.test_application -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Plugin-based system for enumerating available reactors and installing one of them. """ from typing import Iterable, cast from zope.interface import Attribute, Interface, implementer from twisted.internet.interfaces import IReactorCore from twisted.plugin import IPlugin, getPlugins from twisted.python.reflect import namedAny class IReactorInstaller(Interface): """ Definition of a reactor which can probably be installed. """ shortName = Attribute( """ A brief string giving the user-facing name of this reactor. """ ) description = Attribute( """ A longer string giving a user-facing description of this reactor. """ ) def install() -> None: """ Install this reactor. """ # TODO - A method which provides a best-guess as to whether this reactor # can actually be used in the execution environment. class NoSuchReactor(KeyError): """ Raised when an attempt is made to install a reactor which cannot be found. """ @implementer(IPlugin, IReactorInstaller) class Reactor: """ @ivar moduleName: The fully-qualified Python name of the module of which the install callable is an attribute. """ def __init__(self, shortName: str, moduleName: str, description: str): self.shortName = shortName self.moduleName = moduleName self.description = description def install(self) -> None: namedAny(self.moduleName).install() def getReactorTypes() -> Iterable[IReactorInstaller]: """ Return an iterator of L{IReactorInstaller} plugins. """ return getPlugins(IReactorInstaller) def installReactor(shortName: str) -> IReactorCore: """ Install the reactor with the given C{shortName} attribute. @raise NoSuchReactor: If no reactor is found with a matching C{shortName}. @raise Exception: Anything that the specified reactor can raise when installed. """ for installer in getReactorTypes(): if installer.shortName == shortName: installer.install() from twisted.internet import reactor return cast(IReactorCore, reactor) raise NoSuchReactor(shortName) PK Mb�Z�_�! ! application/strports.pynu �[��� # -*- test-case-name: twisted.test.test_strports -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Construct listening port services from a simple string description. @see: L{twisted.internet.endpoints.serverFromString} @see: L{twisted.internet.endpoints.clientFromString} """ from typing import Optional, cast from twisted.application.internet import StreamServerEndpointService from twisted.internet import endpoints, interfaces def _getReactor() -> interfaces.IReactorCore: from twisted.internet import reactor return cast(interfaces.IReactorCore, reactor) def service( description: str, factory: interfaces.IProtocolFactory, reactor: Optional[interfaces.IReactorCore] = None, ) -> StreamServerEndpointService: """ Return the service corresponding to a description. @param description: The description of the listening port, in the syntax described by L{twisted.internet.endpoints.serverFromString}. @type description: C{str} @param factory: The protocol factory which will build protocols for connections to this service. @type factory: L{twisted.internet.interfaces.IProtocolFactory} @rtype: C{twisted.application.service.IService} @return: the service corresponding to a description of a reliable stream server. @see: L{twisted.internet.endpoints.serverFromString} """ if reactor is None: reactor = _getReactor() svc = StreamServerEndpointService( endpoints.serverFromString(reactor, description), factory ) svc._raiseSynchronously = True return svc def listen( description: str, factory: interfaces.IProtocolFactory ) -> interfaces.IListeningPort: """ Listen on a port corresponding to a description. @param description: The description of the connecting port, in the syntax described by L{twisted.internet.endpoints.serverFromString}. @type description: L{str} @param factory: The protocol factory which will build protocols on connection. @type factory: L{twisted.internet.interfaces.IProtocolFactory} @rtype: L{twisted.internet.interfaces.IListeningPort} @return: the port corresponding to a description of a reliable virtual circuit server. @see: L{twisted.internet.endpoints.serverFromString} """ from twisted.internet import reactor name, args, kw = endpoints._parseServer(description, factory) return cast( interfaces.IListeningPort, getattr(reactor, "listen" + name)(*args, **kw) ) __all__ = ["service", "listen"] PK Mb�Z��*qZ qZ application/app.pynu �[��� # -*- test-case-name: twisted.test.test_application,twisted.test.test_twistd -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import getpass import os import pdb import signal import sys import traceback import warnings from operator import attrgetter from twisted import copyright, logger, plugin from twisted.application import reactors, service # Expose the new implementation of installReactor at the old location. from twisted.application.reactors import NoSuchReactor, installReactor from twisted.internet import defer from twisted.internet.interfaces import _ISupportsExitSignalCapturing from twisted.persisted import sob from twisted.python import failure, log, logfile, runtime, usage, util from twisted.python.reflect import namedAny, namedModule, qual class _BasicProfiler: """ @ivar saveStats: if C{True}, save the stats information instead of the human readable format @type saveStats: C{bool} @ivar profileOutput: the name of the file use to print profile data. @type profileOutput: C{str} """ def __init__(self, profileOutput, saveStats): self.profileOutput = profileOutput self.saveStats = saveStats def _reportImportError(self, module, e): """ Helper method to report an import error with a profile module. This has to be explicit because some of these modules are removed by distributions due to them being non-free. """ s = f"Failed to import module {module}: {e}" s += """ This is most likely caused by your operating system not including the module due to it being non-free. Either do not use the option --profile, or install the module; your operating system vendor may provide it in a separate package. """ raise SystemExit(s) class ProfileRunner(_BasicProfiler): """ Runner for the standard profile module. """ def run(self, reactor): """ Run reactor under the standard profiler. """ try: import profile except ImportError as e: self._reportImportError("profile", e) p = profile.Profile() p.runcall(reactor.run) if self.saveStats: p.dump_stats(self.profileOutput) else: tmp, sys.stdout = sys.stdout, open(self.profileOutput, "a") try: p.print_stats() finally: sys.stdout, tmp = tmp, sys.stdout tmp.close() class CProfileRunner(_BasicProfiler): """ Runner for the cProfile module. """ def run(self, reactor): """ Run reactor under the cProfile profiler. """ try: import cProfile import pstats except ImportError as e: self._reportImportError("cProfile", e) p = cProfile.Profile() p.runcall(reactor.run) if self.saveStats: p.dump_stats(self.profileOutput) else: with open(self.profileOutput, "w") as stream: s = pstats.Stats(p, stream=stream) s.strip_dirs() s.sort_stats(-1) s.print_stats() class AppProfiler: """ Class which selects a specific profile runner based on configuration options. @ivar profiler: the name of the selected profiler. @type profiler: C{str} """ profilers = {"profile": ProfileRunner, "cprofile": CProfileRunner} def __init__(self, options): saveStats = options.get("savestats", False) profileOutput = options.get("profile", None) self.profiler = options.get("profiler", "cprofile").lower() if self.profiler in self.profilers: profiler = self.profilers[self.profiler](profileOutput, saveStats) self.run = profiler.run else: raise SystemExit(f"Unsupported profiler name: {self.profiler}") class AppLogger: """ An L{AppLogger} attaches the configured log observer specified on the commandline to a L{ServerOptions} object, a custom L{logger.ILogObserver}, or a legacy custom {log.ILogObserver}. @ivar _logfilename: The name of the file to which to log, if other than the default. @type _logfilename: C{str} @ivar _observerFactory: Callable object that will create a log observer, or None. @ivar _observer: log observer added at C{start} and removed at C{stop}. @type _observer: a callable that implements L{logger.ILogObserver} or L{log.ILogObserver}. """ _observer = None def __init__(self, options): """ Initialize an L{AppLogger} with a L{ServerOptions}. """ self._logfilename = options.get("logfile", "") self._observerFactory = options.get("logger") or None def start(self, application): """ Initialize the global logging system for the given application. If a custom logger was specified on the command line it will be used. If not, and an L{logger.ILogObserver} or legacy L{log.ILogObserver} component has been set on C{application}, then it will be used as the log observer. Otherwise a log observer will be created based on the command line options for built-in loggers (e.g. C{--logfile}). @param application: The application on which to check for an L{logger.ILogObserver} or legacy L{log.ILogObserver}. @type application: L{twisted.python.components.Componentized} """ if self._observerFactory is not None: observer = self._observerFactory() else: observer = application.getComponent(logger.ILogObserver, None) if observer is None: # If there's no new ILogObserver, try the legacy one observer = application.getComponent(log.ILogObserver, None) if observer is None: observer = self._getLogObserver() self._observer = observer if logger.ILogObserver.providedBy(self._observer): observers = [self._observer] elif log.ILogObserver.providedBy(self._observer): observers = [logger.LegacyLogObserverWrapper(self._observer)] else: warnings.warn( ( "Passing a logger factory which makes log observers which do " "not implement twisted.logger.ILogObserver or " "twisted.python.log.ILogObserver to " "twisted.application.app.AppLogger was deprecated in " "Twisted 16.2. Please use a factory that produces " "twisted.logger.ILogObserver (or the legacy " "twisted.python.log.ILogObserver) implementing objects " "instead." ), DeprecationWarning, stacklevel=2, ) observers = [logger.LegacyLogObserverWrapper(self._observer)] logger.globalLogBeginner.beginLoggingTo(observers) self._initialLog() def _initialLog(self): """ Print twistd start log message. """ from twisted.internet import reactor logger._loggerFor(self).info( "twistd {version} ({exe} {pyVersion}) starting up.", version=copyright.version, exe=sys.executable, pyVersion=runtime.shortPythonVersion(), ) logger._loggerFor(self).info( "reactor class: {reactor}.", reactor=qual(reactor.__class__) ) def _getLogObserver(self): """ Create a log observer to be added to the logging system before running this application. """ if self._logfilename == "-" or not self._logfilename: logFile = sys.stdout else: logFile = logfile.LogFile.fromFullPath(self._logfilename) return logger.textFileLogObserver(logFile) def stop(self): """ Remove all log observers previously set up by L{AppLogger.start}. """ logger._loggerFor(self).info("Server Shut Down.") if self._observer is not None: logger.globalLogPublisher.removeObserver(self._observer) self._observer = None def fixPdb(): def do_stop(self, arg): self.clear_all_breaks() self.set_continue() from twisted.internet import reactor reactor.callLater(0, reactor.stop) return 1 def help_stop(self): print( "stop - Continue execution, then cleanly shutdown the twisted " "reactor." ) def set_quit(self): os._exit(0) pdb.Pdb.set_quit = set_quit pdb.Pdb.do_stop = do_stop pdb.Pdb.help_stop = help_stop def runReactorWithLogging(config, oldstdout, oldstderr, profiler=None, reactor=None): """ Start the reactor, using profiling if specified by the configuration, and log any error happening in the process. @param config: configuration of the twistd application. @type config: L{ServerOptions} @param oldstdout: initial value of C{sys.stdout}. @type oldstdout: C{file} @param oldstderr: initial value of C{sys.stderr}. @type oldstderr: C{file} @param profiler: object used to run the reactor with profiling. @type profiler: L{AppProfiler} @param reactor: The reactor to use. If L{None}, the global reactor will be used. """ if reactor is None: from twisted.internet import reactor try: if config["profile"]: if profiler is not None: profiler.run(reactor) elif config["debug"]: sys.stdout = oldstdout sys.stderr = oldstderr if runtime.platformType == "posix": signal.signal(signal.SIGUSR2, lambda *args: pdb.set_trace()) signal.signal(signal.SIGINT, lambda *args: pdb.set_trace()) fixPdb() pdb.runcall(reactor.run) else: reactor.run() except BaseException: close = False if config["nodaemon"]: file = oldstdout else: file = open("TWISTD-CRASH.log", "a") close = True try: traceback.print_exc(file=file) file.flush() finally: if close: file.close() def getPassphrase(needed): if needed: return getpass.getpass("Passphrase: ") else: return None def getSavePassphrase(needed): if needed: return util.getPassword("Encryption passphrase: ") else: return None class ApplicationRunner: """ An object which helps running an application based on a config object. Subclass me and implement preApplication and postApplication methods. postApplication generally will want to run the reactor after starting the application. @ivar config: The config object, which provides a dict-like interface. @ivar application: Available in postApplication, but not preApplication. This is the application object. @ivar profilerFactory: Factory for creating a profiler object, able to profile the application if options are set accordingly. @ivar profiler: Instance provided by C{profilerFactory}. @ivar loggerFactory: Factory for creating object responsible for logging. @ivar logger: Instance provided by C{loggerFactory}. """ profilerFactory = AppProfiler loggerFactory = AppLogger def __init__(self, config): self.config = config self.profiler = self.profilerFactory(config) self.logger = self.loggerFactory(config) def run(self): """ Run the application. """ self.preApplication() self.application = self.createOrGetApplication() self.logger.start(self.application) self.postApplication() self.logger.stop() def startReactor(self, reactor, oldstdout, oldstderr): """ Run the reactor with the given configuration. Subclasses should probably call this from C{postApplication}. @see: L{runReactorWithLogging} """ if reactor is None: from twisted.internet import reactor runReactorWithLogging(self.config, oldstdout, oldstderr, self.profiler, reactor) if _ISupportsExitSignalCapturing.providedBy(reactor): self._exitSignal = reactor._exitSignal else: self._exitSignal = None def preApplication(self): """ Override in subclass. This should set up any state necessary before loading and running the Application. """ raise NotImplementedError() def postApplication(self): """ Override in subclass. This will be called after the application has been loaded (so the C{application} attribute will be set). Generally this should start the application and run the reactor. """ raise NotImplementedError() def createOrGetApplication(self): """ Create or load an Application based on the parameters found in the given L{ServerOptions} instance. If a subcommand was used, the L{service.IServiceMaker} that it represents will be used to construct a service to be added to a newly-created Application. Otherwise, an application will be loaded based on parameters in the config. """ if self.config.subCommand: # If a subcommand was given, it's our responsibility to create # the application, instead of load it from a file. # loadedPlugins is set up by the ServerOptions.subCommands # property, which is iterated somewhere in the bowels of # usage.Options. plg = self.config.loadedPlugins[self.config.subCommand] ser = plg.makeService(self.config.subOptions) application = service.Application(plg.tapname) ser.setServiceParent(application) else: passphrase = getPassphrase(self.config["encrypted"]) application = getApplication(self.config, passphrase) return application def getApplication(config, passphrase): s = [(config[t], t) for t in ["python", "source", "file"] if config[t]][0] filename, style = s[0], {"file": "pickle"}.get(s[1], s[1]) try: log.msg("Loading %s..." % filename) application = service.loadApplication(filename, style, passphrase) log.msg("Loaded.") except Exception as e: s = "Failed to load application: %s" % e if isinstance(e, KeyError) and e.args[0] == "application": s += """ Could not find 'application' in the file. To use 'twistd -y', your .tac file must create a suitable object (e.g., by calling service.Application()) and store it in a variable named 'application'. twistd loads your .tac file and scans the global variables for one of this name. Please read the 'Using Application' HOWTO for details. """ traceback.print_exc(file=log.logfile) log.msg(s) log.deferr() sys.exit("\n" + s + "\n") return application def _reactorAction(): return usage.CompleteList([r.shortName for r in reactors.getReactorTypes()]) class ReactorSelectionMixin: """ Provides options for selecting a reactor to install. If a reactor is installed, the short name which was used to locate it is saved as the value for the C{"reactor"} key. """ compData = usage.Completions(optActions={"reactor": _reactorAction}) messageOutput = sys.stdout _getReactorTypes = staticmethod(reactors.getReactorTypes) def opt_help_reactors(self): """ Display a list of possibly available reactor names. """ rcts = sorted(self._getReactorTypes(), key=attrgetter("shortName")) notWorkingReactors = "" for r in rcts: try: namedModule(r.moduleName) self.messageOutput.write(f" {r.shortName:<4}\t{r.description}\n") except ImportError as e: notWorkingReactors += " !{:<4}\t{} ({})\n".format( r.shortName, r.description, e.args[0], ) if notWorkingReactors: self.messageOutput.write("\n") self.messageOutput.write( " reactors not available " "on this platform:\n\n" ) self.messageOutput.write(notWorkingReactors) raise SystemExit(0) def opt_reactor(self, shortName): """ Which reactor to use (see --help-reactors for a list of possibilities) """ # Actually actually actually install the reactor right at this very # moment, before any other code (for example, a sub-command plugin) # runs and accidentally imports and installs the default reactor. # # This could probably be improved somehow. try: installReactor(shortName) except NoSuchReactor: msg = ( "The specified reactor does not exist: '%s'.\n" "See the list of available reactors with " "--help-reactors" % (shortName,) ) raise usage.UsageError(msg) except Exception as e: msg = ( "The specified reactor cannot be used, failed with error: " "%s.\nSee the list of available reactors with " "--help-reactors" % (e,) ) raise usage.UsageError(msg) else: self["reactor"] = shortName opt_r = opt_reactor class ServerOptions(usage.Options, ReactorSelectionMixin): longdesc = ( "twistd reads a twisted.application.service.Application out " "of a file and runs it." ) optFlags = [ [ "savestats", None, "save the Stats object rather than the text output of " "the profiler.", ], ["no_save", "o", "do not save state on shutdown"], ["encrypted", "e", "The specified tap/aos file is encrypted."], ] optParameters = [ ["logfile", "l", None, "log to a specified file, - for stdout"], [ "logger", None, None, "A fully-qualified name to a log observer factory to " "use for the initial log observer. Takes precedence " "over --logfile and --syslog (when available).", ], [ "profile", "p", None, "Run in profile mode, dumping results to specified " "file.", ], [ "profiler", None, "cprofile", "Name of the profiler to use (%s)." % ", ".join(AppProfiler.profilers), ], ["file", "f", "twistd.tap", "read the given .tap file"], [ "python", "y", None, "read an application from within a Python file " "(implies -o)", ], ["source", "s", None, "Read an application from a .tas file (AOT format)."], ["rundir", "d", ".", "Change to a supplied directory before running"], ] compData = usage.Completions( mutuallyExclusive=[("file", "python", "source")], optActions={ "file": usage.CompleteFiles("*.tap"), "python": usage.CompleteFiles("*.(tac|py)"), "source": usage.CompleteFiles("*.tas"), "rundir": usage.CompleteDirs(), }, ) _getPlugins = staticmethod(plugin.getPlugins) def __init__(self, *a, **kw): self["debug"] = False if "stdout" in kw: self.stdout = kw["stdout"] else: self.stdout = sys.stdout usage.Options.__init__(self) def opt_debug(self): """ Run the application in the Python Debugger (implies nodaemon), sending SIGUSR2 will drop into debugger """ defer.setDebugging(True) failure.startDebugMode() self["debug"] = True opt_b = opt_debug def opt_spew(self): """ Print an insanely verbose log of everything that happens. Useful when debugging freezes or locks in complex code. """ sys.settrace(util.spewer) try: import threading except ImportError: return threading.settrace(util.spewer) def parseOptions(self, options=None): if options is None: options = sys.argv[1:] or ["--help"] usage.Options.parseOptions(self, options) def postOptions(self): if self.subCommand or self["python"]: self["no_save"] = True if self["logger"] is not None: try: self["logger"] = namedAny(self["logger"]) except Exception as e: raise usage.UsageError( "Logger '{}' could not be imported: {}".format(self["logger"], e) ) @property def subCommands(self): plugins = self._getPlugins(service.IServiceMaker) self.loadedPlugins = {} for plug in sorted(plugins, key=attrgetter("tapname")): self.loadedPlugins[plug.tapname] = plug yield ( plug.tapname, None, # Avoid resolving the options attribute right away, in case # it's a property with a non-trivial getter (eg, one which # imports modules). lambda plug=plug: plug.options(), plug.description, ) def run(runApp, ServerOptions): config = ServerOptions() try: config.parseOptions() except usage.error as ue: commstr = " ".join(sys.argv[0:2]) print(config) print(f"{commstr}: {ue}") else: runApp(config) def convertStyle(filein, typein, passphrase, fileout, typeout, encrypt): application = service.loadApplication(filein, typein, passphrase) sob.IPersistable(application).setStyle(typeout) passphrase = getSavePassphrase(encrypt) if passphrase: fileout = None sob.IPersistable(application).save(filename=fileout, passphrase=passphrase) def startApplication(application, save): from twisted.internet import reactor service.IService(application).startService() if save: p = sob.IPersistable(application) reactor.addSystemEventTrigger("after", "shutdown", p.save, "shutdown") reactor.addSystemEventTrigger( "before", "shutdown", service.IService(application).stopService ) def _exitWithSignal(sig): """ Force the application to terminate with the specified signal by replacing the signal handler with the default and sending the signal to ourselves. @param sig: Signal to use to terminate the process with C{os.kill}. @type sig: C{int} """ signal.signal(sig, signal.SIG_DFL) os.kill(os.getpid(), sig) PK Mb�Z�`��� � 4 application/runner/__pycache__/_exit.cpython-310.pycnu �[��� o �b| � @ s� d Z ddlZddlmZ ddlmZmZmZ ddlm Z zddl Z W n e y2 G dd� d�Z Y nw G dd � d e�Z dd e ee f d ed dfdd�ZdS )z System exit support. � N)�IntEnum)�exit�stderr�stdout)�Unionc @ s� e Zd ZdZdZdZeZed Zed Zed Z ed Z ed Z ed Z ed Z ed Zed Zed Zed Zed Zed Zed ZdS )�StatuszT Object to hang C{EX_*} values off of as a substitute for L{posix}. �@ r � � � � � � � � � � � � � � N)�__name__� __module__� __qualname__�__doc__�EX__BASE�EX_OK�EX_USAGE� EX_DATAERR� EX_NOINPUT� EX_NOUSER� EX_NOHOST�EX_UNAVAILABLE� EX_SOFTWARE�EX_OSERR� EX_OSFILE� EX_CANTCREAT�EX_IOERR� EX_TEMPFAIL� EX_PROTOCOL� EX_NOPERM� EX_CONFIG� r, r, �B/usr/lib/python3/dist-packages/twisted/application/runner/_exit.pyr s& r c @ sp e Zd ZdZejZejZejZejZej Z ej Z ej Z ej Z ej Z ejZejZejZejZejZejZejZdS )� ExitStatusa" Standard exit status codes for system programs. @cvar EX_OK: Successful termination. @cvar EX_USAGE: Command line usage error. @cvar EX_DATAERR: Data format error. @cvar EX_NOINPUT: Cannot open input. @cvar EX_NOUSER: Addressee unknown. @cvar EX_NOHOST: Host name unknown. @cvar EX_UNAVAILABLE: Service unavailable. @cvar EX_SOFTWARE: Internal software error. @cvar EX_OSERR: System error (e.g., can't fork). @cvar EX_OSFILE: Critical OS file missing. @cvar EX_CANTCREAT: Can't create (user) output file. @cvar EX_IOERR: Input/output error. @cvar EX_TEMPFAIL: Temporary failure; the user is invited to retry. @cvar EX_PROTOCOL: Remote error in protocol. @cvar EX_NOPERM: Permission denied. @cvar EX_CONFIG: Configuration error. N)r r r r r r r r r r r! r" r# r$ r% r& r' r( r) r* r+ r, r, r, r- r. + s$ r. � �status�message�returnztyping.NoReturnc C s8 |r| t jkr t}nt}|�|� |�d� t| � dS )z� Exit the python interpreter with the given status and an optional message. @param status: An exit status. An appropriate value from L{ExitStatus} is recommended. @param message: An optional message to print. � N)r. r r r �write�sysexit)r0 r1 �outr, r, r- r S s r )r/ )r �typing�enumr �sysr r5 r r r �posixr � ImportErrorr. �int�strr, r, r, r- �<module> s �$(PK Mb�Z N�K� � 7 application/runner/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z/ Facilities for running a Twisted application. N)�__doc__� r r �E/usr/lib/python3/dist-packages/twisted/application/runner/__init__.py�<module> s PK Mb�Z� �$ $ 7 application/runner/__pycache__/_pidfile.cpython-310.pycnu �[��� o �b� � @ s� U d Z ddlZddlmZmZmZ ddlmZ ddl m Z m Z ddl m Z mZ ddlmZ ddlmZ G d d � d e �Zee�G d d � d ��Zee�G d d� d��Ze� Zeed< G dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Z dS )z PID file. � N)�getpid�kill�name)� TracebackType)�Optional�Type)� Interface� implementer)�Logger)�FilePathc @ sx e Zd ZdZdefdd�Zddd�Zddd �Zdefd d �Z dd d �Z de e e de e de e de e fdd�ZdS )�IPIDFilez5 Manages a file that remembers a process ID. �returnc C � dS )a+ Read the process ID stored in this PID file. @return: The contained process ID. @raise NoPIDFound: If this PID file does not exist. @raise EnvironmentError: If this PID file cannot be read. @raise ValueError: If this PID file's content is invalid. N� r r r �E/usr/lib/python3/dist-packages/twisted/application/runner/_pidfile.py�read � z IPIDFile.readNc C r )z� Store the PID of the current process in this PID file. @raise EnvironmentError: If this PID file cannot be written. Nr r r r r �writeRunningPID$ r zIPIDFile.writeRunningPIDc C r )zm Remove this PID file. @raise EnvironmentError: If this PID file cannot be removed. Nr r r r r �remove+ r zIPIDFile.removec C r )a Determine whether there is a running process corresponding to the PID in this PID file. @return: True if this PID file contains a PID and a process with that PID is currently running; false otherwise. @raise EnvironmentError: If this PID file cannot be read. @raise InvalidPIDFileError: If this PID file's content is invalid. @raise StalePIDFileError: If this PID file's content refers to a PID for which there is no corresponding running process. Nr r r r r � isRunning2 r zIPIDFile.isRunningc C r )z� Enter a context using this PIDFile. Writes the PID file with the PID of the running process. @raise AlreadyRunningError: A process corresponding to the PID in this PID file is already running. Nr r r r r � __enter__@ r zIPIDFile.__enter__�excType�excValue� tracebackc C r )zS Exit a context using this PIDFile. Removes the PID file. Nr )r r r r r r �__exit__J r zIPIDFile.__exit__�r N)r r )�__name__� __module__� __qualname__�__doc__�intr r r �boolr r r r � BaseExceptionr r r r r r r s ����r c @ s� e Zd ZdZe� Zededefdd��Z de ddfdd �Z defd d �Z deddfd d �Z d dd�Zd dd�Zdefdd�Zededefdd��Zd dd�Zdeee dee dee ddfdd �ZdS ) �PIDFilez� Concrete implementation of L{IPIDFile}. This implementation is presently not supported on non-POSIX platforms. Specifically, calling L{PIDFile.isRunning} will raise L{NotImplementedError}. �pidr c C s t | �� d��� S )z� Format a PID file's content. @param pid: A process ID. @return: Formatted PID file contents. � )r �encode�r$ r r r �_formatb s zPIDFile._format�filePathNc C s || _ dS )zD @param filePath: The path to the PID file on disk. N)r) )�selfr) r r r �__init__m s zPIDFile.__init__c C s� d}z | j �� � }|D ]} W d � n1 sw Y W n ty5 } z |jtjkr0td��� d }~ww zt|�W S tyI td|����w )N� �PID file does not existz#non-integer PID value in PID file: ) r) �open�OSError�errno�ENOENT� NoPIDFoundr � ValueError�InvalidPIDFileError)r* � pidString�fh�er r r r s s* � �� �� ��z PIDFile.readc C s | j �| j|d�� dS )z� Store a PID in this PID file. @param pid: A PID to store. @raise EnvironmentError: If this PID file cannot be written. r' N)r) � setContentr( �r* r$ r r r �_write� s zPIDFile._writec C s | � t� � d S �N)r: r �r* r r r r � s zPIDFile.writeRunningPIDc C s | j �� d S r; )r) r r< r r r r � � zPIDFile.removec C sB z| � � }W n ty Y dS w tdkr| �|�S tdt� ���)NF�posixz isRunning is not implemented on )r r2 � SYSTEM_NAME�_pidIsRunningPOSIX�NotImplementedErrorr9 r r r r � s � zPIDFile.isRunningc C sZ zt | d� W dS ty, } z|jtjkrtd��|jtjkr'W Y d}~dS � d}~ww )a1 POSIX implementation for running process check. Determine whether there is a running process corresponding to the given PID. @param pid: The PID to check. @return: True if the given PID is currently running; false otherwise. @raise EnvironmentError: If this PID file cannot be read. @raise InvalidPIDFileError: If this PID file's content is invalid. @raise StalePIDFileError: If this PID file's content refers to a PID for which there is no corresponding running process. r z'PID file refers to non-existing processNT)r r/ r0 �ESRCH�StalePIDFileError�EPERM)r$ r7 r r r r@ � s � ��zPIDFile._pidIsRunningPOSIXc C s> z | � � rt� �W n ty | j�d� Y nw | �� | S )Nz&Replacing stale PID file: {log_source})r �AlreadyRunningErrorrC �_log�infor r< r r r r � s � �zPIDFile.__enter__r r r c C s | � � d S r; )r �r* r r r r r r r � s zPIDFile.__exit__r )r r# )r r r r r rF � staticmethodr �bytesr( r r+ r r: r r r! r r@ r r r r" r r r r r r r# V s. ����r# c @ s� e Zd ZdZddd�Zdefdd�Zdeddfd d �Zdd d �Zdd d�Z de fdd�Z ddd�Z de ee de e de e ddfdd�ZdS )� NonePIDFilez� PID file implementation that does nothing. This is meant to be used as a "active None" object in place of a PID file when no PID file is desired. r Nc C � d S r; r r< r r r r+ � � zNonePIDFile.__init__c C s t d��)Nr- )r2 r< r r r r � s zNonePIDFile.readr$ c C � t tjd��)z� Store a PID in this PID file. @param pid: A PID to store. @raise EnvironmentError: If this PID file cannot be written. @note: This implementation always raises an L{EnvironmentError}. zOperation not permitted)r/ r0 rD r9 r r r r: � s zNonePIDFile._writec C s | � d� d S )Nr )r: r< r r r r � r= zNonePIDFile.writeRunningPIDc C rN )NzNo such file or directory)r/ r0 r1 r< r r r r � s zNonePIDFile.removec C r )NFr r< r r r r � rM zNonePIDFile.isRunningc C s | S r; r r< r r r r � rM zNonePIDFile.__enter__r r r c C rL r; r rH r r r r � s zNonePIDFile.__exit__r )r rK )r r r r r+ r r r: r r r! r r r r r" r r r r r r rK � s$ ����rK � nonePIDFilec @ � e Zd ZdZdS )rE z% Process is already running. N�r r r r r r r r rE � rE c @ rP )r4 z( PID file contents are invalid. NrQ r r r r r4 rR r4 c @ rP )rC z[ PID file contents are valid, but there is no process with the referenced PID. NrQ r r r r rC rR rC c @ rP )r2 z# No PID found in PID file. NrQ r r r r r2 rR r2 ) r r0 �osr r r r? �typesr �typingr r �zope.interfacer r �twisted.loggerr �twisted.python.filepathr r r# rK rO �__annotations__� ExceptionrE r4 rC r2 r r r r �<module> s$ By/PK Mb�Z���� � 6 application/runner/__pycache__/_runner.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZm Z m Z m Z ddl m Z mZmZ ddlmZ ddlmZ dd lmZmZmZmZmZmZmZ d d l m Z m Z d d l m Z m!Z!m"Z"m#Z# ed d�G dd� d��Z$dS )z Twisted application runner. � )�kill)�SIGTERM)�stderr)�Any�Callable�Mapping�TextIO)�Factory�attrib�attrs)� NamedConstant)� IReactorCore)�FileLogObserver�FilteringLogObserver�Logger�LogLevel�LogLevelFilterPredicate�globalLogBeginner�textFileLogObserver� )� ExitStatus�exit)�AlreadyRunningError�InvalidPIDFileError�IPIDFile� nonePIDFileT)�frozenc @ s� e Zd ZdZe� Zeed�Zee e d�Z ee dd�Z eeejd�Zeeed�Zeeegef ed�Zeed dd� d�Zeeee f e e �d�Z eed dd� d�Z eeee f e e �d�Z!dd d �Z"dd d�Z#ddd�Z$ddd�Z%ddd�Z&ddd�Z'd S )�Runnera Twisted application runner. @cvar _log: The logger attached to this class. @ivar _reactor: The reactor to start and run the application in. @ivar _pidFile: The file to store the running process ID in. @ivar _kill: Whether this runner should kill an existing running instance of the application. @ivar _defaultLogLevel: The default log level to start the logging system with. @ivar _logFile: A file stream to write logging output to. @ivar _fileLogObserverFactory: A factory for the file log observer to use when starting the logging system. @ivar _whenRunning: Hook to call after the reactor is running; this is where the application code that relies on the reactor gets called. @ivar _whenRunningArguments: Keyword arguments to pass to C{whenRunning} when it is called. @ivar _reactorExited: Hook to call after the reactor exits. @ivar _reactorExitedArguments: Keyword arguments to pass to C{reactorExited} when it is called. )�type)r �defaultF).Nc K � d S �N� ��_r" r" �D/usr/lib/python3/dist-packages/twisted/application/runner/_runner.py�<lambda>C � zRunner.<lambda>c K r r! r" r# r" r" r% r& E r' �returnNc C sv | j }| �� z#|� | �� | �� | �� W d � W dS 1 s#w Y W dS ty: ttjd� Y dS w )z# Run this command. NzAlready running.) �_pidFile�killIfRequested� startLogging� startReactor� reactorExitedr r r � EX_CONFIG)�self�pidFiler" r" r% �runH s &� �z Runner.runc C s� | j }| jrP|tu rttjd� dS z|�� }W n ty( ttjd� Y dS t y7 ttj d� Y dS w | � � | j j d|d� t|t� ttj� dS dS )zj If C{self._kill} is true, attempt to kill a running instance of the application. zNo PID file specified.NzUnable to read PID file.zInvalid PID file.zTerminating process: {pid})�pid)r) �_killr r r �EX_USAGE�read�OSError�EX_IOERRr � EX_DATAERRr+ �_log�infor r �EX_OK)r/ r0 r2 r" r" r% r* [ s( � �zRunner.killIfRequestedc C s< | j }| j}||�}t| jd�}t||g�}t�|g� dS )z= Start the L{twisted.logger} logging system. )�defaultLogLevelN)�_logFile�_fileLogObserverFactoryr �_defaultLogLevelr r �beginLoggingTo)r/ �logFile�fileLogObserverFactory�fileLogObserver�logLevelPredicate�filteringObserverr" r" r% r+ | s � zRunner.startLoggingc C s( | j �| j� | j�d� | j �� dS )z� Register C{self._whenRunning} with the reactor so that it is called once the reactor is running, then start the reactor. zStarting reactor...N)�_reactor�callWhenRunning� whenRunningr9 r: r1 �r/ r" r" r% r, � s zRunner.startReactorc C � | j di | j�� dS )z� Call C{self._whenRunning} with C{self._whenRunningArguments}. @note: This method is called after the reactor starts running. Nr" )� _whenRunning�_whenRunningArgumentsrI r" r" r% rH � � zRunner.whenRunningc C rJ )z� Call C{self._reactorExited} with C{self._reactorExitedArguments}. @note: This method is called after the reactor exits. Nr" )�_reactorExited�_reactorExitedArgumentsrI r" r" r% r- � rM zRunner.reactorExited)r( N)(�__name__� __module__� __qualname__�__doc__r r9 r r rF r r r) �boolr3 r r r: r? r r r= r r r r> rK r �strr r �dictrL rN rO r1 r* r+ r, rH r- r" r" r" r% r s* � ! r N)%rS �osr �signalr �sysr �typingr r r r �attrr r r � constantlyr �twisted.internet.interfacesr �twisted.loggerr r r r r r r �_exitr r �_pidfiler r r r r r" r" r" r% �<module> s $ PK Mb�Z� � � application/runner/_pidfile.pynu �[��� # -*- test-case-name: twisted.application.runner.test.test_pidfile -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ PID file. """ import errno from os import getpid, kill, name as SYSTEM_NAME from types import TracebackType from typing import Optional, Type from zope.interface import Interface, implementer from twisted.logger import Logger from twisted.python.filepath import FilePath class IPIDFile(Interface): """ Manages a file that remembers a process ID. """ def read() -> int: """ Read the process ID stored in this PID file. @return: The contained process ID. @raise NoPIDFound: If this PID file does not exist. @raise EnvironmentError: If this PID file cannot be read. @raise ValueError: If this PID file's content is invalid. """ def writeRunningPID() -> None: """ Store the PID of the current process in this PID file. @raise EnvironmentError: If this PID file cannot be written. """ def remove() -> None: """ Remove this PID file. @raise EnvironmentError: If this PID file cannot be removed. """ def isRunning() -> bool: """ Determine whether there is a running process corresponding to the PID in this PID file. @return: True if this PID file contains a PID and a process with that PID is currently running; false otherwise. @raise EnvironmentError: If this PID file cannot be read. @raise InvalidPIDFileError: If this PID file's content is invalid. @raise StalePIDFileError: If this PID file's content refers to a PID for which there is no corresponding running process. """ def __enter__() -> "IPIDFile": """ Enter a context using this PIDFile. Writes the PID file with the PID of the running process. @raise AlreadyRunningError: A process corresponding to the PID in this PID file is already running. """ def __exit__( excType: Optional[Type[BaseException]], excValue: Optional[BaseException], traceback: Optional[TracebackType], ) -> Optional[bool]: """ Exit a context using this PIDFile. Removes the PID file. """ @implementer(IPIDFile) class PIDFile: """ Concrete implementation of L{IPIDFile}. This implementation is presently not supported on non-POSIX platforms. Specifically, calling L{PIDFile.isRunning} will raise L{NotImplementedError}. """ _log = Logger() @staticmethod def _format(pid: int) -> bytes: """ Format a PID file's content. @param pid: A process ID. @return: Formatted PID file contents. """ return f"{int(pid)}\n".encode() def __init__(self, filePath: FilePath) -> None: """ @param filePath: The path to the PID file on disk. """ self.filePath = filePath def read(self) -> int: pidString = b"" try: with self.filePath.open() as fh: for pidString in fh: break except OSError as e: if e.errno == errno.ENOENT: # No such file raise NoPIDFound("PID file does not exist") raise try: return int(pidString) except ValueError: raise InvalidPIDFileError( f"non-integer PID value in PID file: {pidString!r}" ) def _write(self, pid: int) -> None: """ Store a PID in this PID file. @param pid: A PID to store. @raise EnvironmentError: If this PID file cannot be written. """ self.filePath.setContent(self._format(pid=pid)) def writeRunningPID(self) -> None: self._write(getpid()) def remove(self) -> None: self.filePath.remove() def isRunning(self) -> bool: try: pid = self.read() except NoPIDFound: return False if SYSTEM_NAME == "posix": return self._pidIsRunningPOSIX(pid) else: raise NotImplementedError(f"isRunning is not implemented on {SYSTEM_NAME}") @staticmethod def _pidIsRunningPOSIX(pid: int) -> bool: """ POSIX implementation for running process check. Determine whether there is a running process corresponding to the given PID. @param pid: The PID to check. @return: True if the given PID is currently running; false otherwise. @raise EnvironmentError: If this PID file cannot be read. @raise InvalidPIDFileError: If this PID file's content is invalid. @raise StalePIDFileError: If this PID file's content refers to a PID for which there is no corresponding running process. """ try: kill(pid, 0) except OSError as e: if e.errno == errno.ESRCH: # No such process raise StalePIDFileError("PID file refers to non-existing process") elif e.errno == errno.EPERM: # Not permitted to kill return True else: raise else: return True def __enter__(self) -> "PIDFile": try: if self.isRunning(): raise AlreadyRunningError() except StalePIDFileError: self._log.info("Replacing stale PID file: {log_source}") self.writeRunningPID() return self def __exit__( self, excType: Optional[Type[BaseException]], excValue: Optional[BaseException], traceback: Optional[TracebackType], ) -> None: self.remove() return None @implementer(IPIDFile) class NonePIDFile: """ PID file implementation that does nothing. This is meant to be used as a "active None" object in place of a PID file when no PID file is desired. """ def __init__(self) -> None: pass def read(self) -> int: raise NoPIDFound("PID file does not exist") def _write(self, pid: int) -> None: """ Store a PID in this PID file. @param pid: A PID to store. @raise EnvironmentError: If this PID file cannot be written. @note: This implementation always raises an L{EnvironmentError}. """ raise OSError(errno.EPERM, "Operation not permitted") def writeRunningPID(self) -> None: self._write(0) def remove(self) -> None: raise OSError(errno.ENOENT, "No such file or directory") def isRunning(self) -> bool: return False def __enter__(self) -> "NonePIDFile": return self def __exit__( self, excType: Optional[Type[BaseException]], excValue: Optional[BaseException], traceback: Optional[TracebackType], ) -> None: return None nonePIDFile: IPIDFile = NonePIDFile() class AlreadyRunningError(Exception): """ Process is already running. """ class InvalidPIDFileError(Exception): """ PID file contents are invalid. """ class StalePIDFileError(Exception): """ PID file contents are valid, but there is no process with the referenced PID. """ class NoPIDFound(Exception): """ No PID found in PID file. """ PK Mb�Z�]r��7 �7 @ application/runner/test/__pycache__/test_pidfile.cpython-310.pycnu �[��� o �b;2 � @ s� d Z ddlZddlmZ ddlmZmZ ddlm Z m Z m Z ddl m Z ddlZddlmZ ddlmZ dd lmZ d d lmZ d d lmZmZmZmZmZm Z m Z de de f de de f fdd�Z G dd� dej j j!�Z"G dd� dej j j!�Z#dS )z3 Tests for L{twisted.application.runner._pidfile}. � N)�wraps)�getpid�name)�Any�Callable�Optional)� verifyObject)�FilePath)�platform)�SkipTest� )�_pidfile� )�AlreadyRunningError�InvalidPIDFileError�IPIDFile� NonePIDFile� NoPIDFound�PIDFile�StalePIDFileError�f.�returnc s* t � �dtdtdtdtf� fdd� �}|S )a= Decorator for tests that are not expected to work on all platforms. Calling L{PIDFile.isRunning} currently raises L{NotImplementedError} on non-POSIX platforms. On an unsupported platform, we expect to see any test that calls L{PIDFile.isRunning} to raise either L{NotImplementedError}, L{SkipTest}, or C{self.failureException}. (C{self.failureException} may occur in a test that checks for a specific exception but it gets NotImplementedError instead.) @param f: The test method to decorate. @return: The wrapped callable. �self�args�kwargsr c sp t �� dk}|r� | g|�R i |��S | jtt| jf� | g|�R i |��}t|t�r6| �t|�� d�� d S d S )N�posixz isRunning is not implemented on ) r �getType� assertRaises�NotImplementedErrorr �failureException� isinstance� assertTrue�str� startswith)r r r � supported�e�r � �N/usr/lib/python3/dist-packages/twisted/application/runner/test/test_pidfile.py�wrapper1 s ��� �z$ifPlatformSupported.<locals>.wrapper)r r )r r) r' r& r( �ifPlatformSupported s r* c @ s e Zd ZdZd1dee defdd�Zd2dd�Zd2d d �Z d2d d �Z d2d d�Z d2dd�Z d2dd�Z d2dd�Zd2dd�Zd2dd�Zd2dd�Zd2dd �Zed2d d ��Zed2d d ��Zed2d!d"��Zed2d#d$��Zed2d%d&��Zed2d'd(��Zd2d)d*�Zd2d+d,�Zed2d-d.��Z ed2d/d0��Z dS )3� PIDFileTestsz Tests for L{PIDFile}. N�contentr c C s" t | �� �}|d ur|�|� |S �N)r �mktemp� setContent)r r, �filePathr' r' r( r0 J s zPIDFileTests.filePathc C s t | �� �}tt|� dS )z5 L{PIDFile} conforms to L{IPIDFile}. N)r r0 r r �r �pidFiler' r' r( �test_interfaceP s zPIDFileTests.test_interfacec C s | � tjdd�d� dS )zR L{PIDFile._format} returns the expected format when given a PID. �9 ��pids 1337 N)� assertEqualr �_format)r r' r' r( �test_formatWithPIDW s z PIDFileTests.test_formatWithPIDc C s. d}t | �t j|d���}| �||�� � dS )zK L{PIDFile.read} returns the PID from the given file path. r4 r5 N)r r0 r8 r7 �read�r r6 r2 r' r' r( �test_readWithPID] s z PIDFileTests.test_readWithPIDc C s: d}t | �d��}| �t|j�}| �t|�d|��� dS )�f L{PIDFile.read} raises L{InvalidPIDFileError} when given an empty file path. � �#non-integer PID value in PID file: N�r r0 r r r: r7 r" �r �pidValuer2 r% r' r' r( �test_readEmptyPIDg � z PIDFileTests.test_readEmptyPIDc C s: d}t | �|��}| �t|j�}| �t|�d|��� dS )r= s $foo!r? Nr@ rA r' r' r( �test_readWithBogusPIDr rD z"PIDFileTests.test_readWithBogusPIDc C s. t | �� �}| �t|j�}| �t|�d� dS )zc L{PIDFile.read} raises L{NoPIDFound} when given a non-existing file path. �PID file does not existN)r r0 r r r: r7 r" �r r2 r% r' r' r( �test_readDoesntExist} s z!PIDFileTests.test_readDoesntExistc C sP ddt dtfdd�}| �td|� t| �� �}| �t|j�}| �|j t j � dS ) z� L{PIDFile.read} re-raises L{OSError} if the associated C{errno} is anything other than L{errno.ENOENT}. �r�moder c S � t tjd��)Nz I/O error)�OSError�errno�EIO)rJ r' r' r( �oops� � z>PIDFileTests.test_readOpenRaisesOSErrorNotENOENT.<locals>.oops�openN)rI ) r" r �patchr r0 r rL r: r7 rM rN )r rO r2 �errorr' r' r( �#test_readOpenRaisesOSErrorNotENOENT� s z0PIDFileTests.test_readOpenRaisesOSErrorNotENOENTc C s. d}t | �� �}|�|� | �|�� |� dS )z9 L{PIDFile._write} stores the given PID. i� N)r r0 �_writer7 r: r; r' r' r( � test_writePID� s zPIDFileTests.test_writePIDc C s t | �� �}| �t|jd� dS )zS L{PIDFile._write} raises L{ValueError} when given an invalid PID. �burpN)r r0 r � ValueErrorrU r1 r' r' r( �test_writePIDInvalid� s z!PIDFileTests.test_writePIDInvalidc C s* t | �� �}|�� | �|�� t� � dS )zT L{PIDFile.writeRunningPID} stores the PID for the current process. N)r r0 �writeRunningPIDr7 r: r r1 r' r' r( �test_writeRunningPID� s z!PIDFileTests.test_writeRunningPIDc C s: t | �d��}| �|j�� � |�� | �|j�� � dS )z9 L{PIDFile.remove} removes the PID file. r> N)r r0 r! �exists�remove� assertFalser1 r' r' r( � test_remove� s zPIDFileTests.test_removec C �L t | �� �}|�d� dtdtddfdd�}| �td|� | �|�� � dS ) zR L{PIDFile.isRunning} returns true for a process that does exist. r4 r6 �signalr Nc S � d S r- r' �r6 ra r' r' r( �kill� � z2PIDFileTests.test_isRunningDoesExist.<locals>.killrd �r r0 rU �intrR r r! � isRunning�r r2 rd r' r' r( �test_isRunningDoesExist� s z$PIDFileTests.test_isRunningDoesExistc C s& t | �� �}|�� | �|�� � dS )a@ L{PIDFile.isRunning} returns true for this process (which is running). @note: This differs from L{PIDFileTests.test_isRunningDoesExist} in that it actually invokes the C{kill} system call, which is useful for testing of our chosen method for probing the existence of a process. N)r r0 rZ r! rh r1 r' r' r( �test_isRunningThis� s z PIDFileTests.test_isRunningThisc C sL t | �� �}|�d� dtdtddfdd�}| �td|� | �t|j� dS ) z{ L{PIDFile.isRunning} raises L{StalePIDFileError} for a process that does not exist (errno=ESRCH). r4 r6 ra r Nc S rK �NzNo such process�rL rM �ESRCHrc r' r' r( rd � rP z5PIDFileTests.test_isRunningDoesNotExist.<locals>.killrd ) r r0 rU rg rR r r r rh ri r' r' r( �test_isRunningDoesNotExist� � z'PIDFileTests.test_isRunningDoesNotExistc C r` ) zx L{PIDFile.isRunning} returns true for a process that we are not allowed to kill (errno=EPERM). r4 r6 ra r Nc S rK )NzOperation not permitted)rL rM �EPERMrc r' r' r( rd � rP z3PIDFileTests.test_isRunningNotAllowed.<locals>.killrd rf ri r' r' r( �test_isRunningNotAllowed� rp z%PIDFileTests.test_isRunningNotAllowedc C s8 t dkrtd��t| �� �}|�d� | �|�� � dS )ac L{PIDFile.isRunning} returns true for a process that we are not allowed to kill (errno=EPERM). @note: This differs from L{PIDFileTests.test_isRunningNotAllowed} in that it actually invokes the C{kill} system call, which is useful for testing of our chosen method for probing the existence of a process that we are not allowed to kill. @note: In this case, we try killing C{init}, which is process #1 on POSIX systems, so this test is not portable. C{init} should always be running and should not be killable by non-root users. r zThis test assumes POSIX� N)� SYSTEM_NAMEr r r0 rU r! rh r1 r' r' r( �test_isRunningInit� s z PIDFileTests.test_isRunningInitc C sJ t | �� �}|�� dtdtddfdd�}| �td|� | �t|j� dS )z� L{PIDFile.isRunning} re-raises L{OSError} if the attached C{errno} value from L{os.kill} is not an expected one. r6 ra r Nc S rK )Nz File exists)rL rM �EEXISTrc r' r' r( rd rP z5PIDFileTests.test_isRunningUnknownErrno.<locals>.killrd ) r r0 rZ rg rR r r rL rh ri r' r' r( �test_isRunningUnknownErrno s z'PIDFileTests.test_isRunningUnknownErrnoc C s t | �� �}| �|�� � dS )zS L{PIDFile.isRunning} returns false if the PID file doesn't exist. N)r r0 r^ rh r1 r' r' r( �test_isRunningNoPIDFile! s z$PIDFileTests.test_isRunningNoPIDFilec C sv t | �� �}| �|j�� � |� | �|j�� � | �|�� t� � W d � n1 s,w Y | �|j�� � dS )z� When used as a context manager, a L{PIDFile} will store the current pid on entry, then removes the PID file on exit. N)r r0 r^ r\ r! r7 r: r r1 r' r' r( �test_contextManager) s �z PIDFileTests.test_contextManagerc C s� t | �� �}|�d� dtdtddfdd�}| �td|� | �t|j�}| � t |�d � |� | � |� � t � � W d � dS 1 sCw Y dS ) z� When used as a context manager, a L{PIDFile} will replace the underlying PIDFile rather than raising L{AlreadyRunningError} if the contained PID file exists but refers to a non-running PID. r4 r6 ra r Nc S rK rl rm rc r' r' r( rd A rP z9PIDFileTests.test_contextManagerDoesntExist.<locals>.killrd z'PID file refers to non-existing process) r r0 rU rg rR r r r rh r7 r" r: r )r r2 rd r% r' r' r( � test_contextManagerDoesntExist7 s "�z+PIDFileTests.test_contextManagerDoesntExistc C sZ t | �� �}|�d� dtdtddfdd�}| �td|� | �|�� � | �t |j � dS ) z� When used as a context manager, a L{PIDFile} will raise L{AlreadyRunningError} if the there is already a running process with the contained PID. r4 r6 ra r Nc S rb r- r' rc r' r' r( rd V re z<PIDFileTests.test_contextManagerAlreadyRunning.<locals>.killrd ) r r0 rU rg rR r r! rh r r � __enter__ri r' r' r( �!test_contextManagerAlreadyRunningL s z.PIDFileTests.test_contextManagerAlreadyRunningr- �r N) �__name__� __module__� __qualname__�__doc__r �bytesr r0 r3 r9 r< rC rE rH rT rV rY r[ r_ r* rj rk ro rr ru rw rx ry rz r| r' r' r' r( r+ E s@ r+ c @ sV e Zd ZdZddd�Zddd�Zddd �Zdd d �Zdd d �Zddd�Z ddd�Z dS )�NonePIDFileTestsz# Tests for L{NonePIDFile}. r Nc C s t � }tt|� dS )z9 L{NonePIDFile} conforms to L{IPIDFile}. N)r r r r1 r' r' r( r3 e s z NonePIDFileTests.test_interfacec C s( t � }| �t|j�}| �t|�d� dS )z; L{NonePIDFile.read} raises L{NoPIDFound}. rF N)r r r r: r7 r" rG r' r' r( � test_readl � zNonePIDFileTests.test_readc C s* t � }| �t|jd�}| �|jtj� dS )zZ L{NonePIDFile._write} raises L{OSError} with an errno of L{errno.EPERM}. r N)r r rL rU r7 rM rq �r r2 rS r' r' r( � test_writeu s zNonePIDFileTests.test_writec C �( t � }| �t|j�}| �|jtj� dS )zk L{NonePIDFile.writeRunningPID} raises L{OSError} with an errno of L{errno.EPERM}. N)r r rL rZ r7 rM rq r� r' r' r( r[ ~ s z%NonePIDFileTests.test_writeRunningPIDc C r� )zZ L{NonePIDFile.remove} raises L{OSError} with an errno of L{errno.EPERM}. N)r r rL r] r7 rM �ENOENTr� r' r' r( r_ � r� z NonePIDFileTests.test_removec C s t � }| �|�� d� dS )z< L{NonePIDFile.isRunning} returns L{False}. FN)r r7 rh r1 r' r' r( �test_isRunning� s z NonePIDFileTests.test_isRunningc C s0 t � }|� W d � dS 1 sw Y dS )zo When used as a context manager, a L{NonePIDFile} doesn't raise, despite not existing. N)r r1 r' r' r( ry � s "�z$NonePIDFileTests.test_contextManagerr} ) r~ r r� r� r3 r� r� r[ r_ r� ry r' r' r' r( r� ` s r� )$r� rM � functoolsr �osr r rt �typingr r r �zope.interface.verifyr �twisted.trial.unittest�twisted�twisted.python.filepathr �twisted.python.runtimer r �runnerr r r r r r r r r* �trial�unittest�TestCaser+ r� r' r' r' r( �<module> s" $" & PK Mb�Z��� � < application/runner/test/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z* Tests for L{twisted.application.runner}. N)�__doc__� r r �J/usr/lib/python3/dist-packages/twisted/application/runner/test/__init__.py�<module> s PK Mb�Z�{KQ< Q< ? application/runner/test/__pycache__/test_runner.cpython-310.pycnu �[��� o �b�8 � @ sd d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z m Z m Z m Z m Z mZmZmZmZ ddlmZmZmZ ddlZddlmZ dd lmZm Z m Z m Z m Z m Z m!Z! dd l"m#Z# d d l$m%Z% d dl&m'Z' d dl(m)Z)m*Z* d dl%m+Z+ G dd� dej,j-j.�Z/edd�G dd� de+��Z0G dd� de)�Z1G dd� d�Z2G dd � d �Z3G d d � d �Z4G d d � d �Z5dS )!z2 Tests for L{twisted.application.runner._runner}. � N)�StringIO)�SIGTERM)� TracebackType) �Any�Iterable�List�Optional�TextIO�Tuple�Type�Union�cast)�Factory�attrib�attrs)� MemoryReactor)�FileLogObserver�FilteringLogObserver� ILogObserver� LogBeginner�LogLevel�LogLevelFilterPredicate� LogPublisher)�FilePath� )�_runner� )� ExitStatus)� NonePIDFile�PIDFile)�Runnerc @ s� e Zd ZdZd)dee defdd�Zd*dd�Zd*d d �Z d*d d �Z d*d d�Z d*dd�Z d*dd�Z d*dd�Zd*dd�Zd*dd�Zd*dd�Zd*dd �Zd*d d �Zd*d d �Zd*d!d"�Zd*d#d$�Zd)d%ed&ee ddfd'd(�ZdS )+� RunnerTestsz Tests for L{Runner}. N�content�returnc C s" t | �� �}|d ur|�|� |S �N)r �mktemp� setContent)�selfr" �filePath� r) �M/usr/lib/python3/dist-packages/twisted/application/runner/test/test_runner.pyr( ' s zRunnerTests.filePathc C s� t � | _t� | _| �td| j� | �td| j� d| _| j� d��� | _t � | _ t � | _ t | j | j �| _ t� | _t� | _t| j| j j | j | j�| _| �td| j � | �td| j� d S )N�exit�killi9 � �stderr�globalLogBeginner)� DummyExitr+ � DummyKillr, �patchr �pid�encode�pidFileContentr �stdoutr. �DummyStandardIO�stdio�DummyWarningsModule�warningsr �globalLogPublisherr r/ �r' r) r) r* �setUp- s& �zRunnerTests.setUpc C s* t t� d�}|�� | �|jg d�� dS )zD L{Runner.run} calls the expected methods in order. ��reactor)�killIfRequested� startLogging� startReactor� reactorExitedN)� DummyRunnerr �run� assertEqual� calledMethods�r' �runnerr) r) r* �test_runInOrderO s �zRunnerTests.test_runInOrderc C sP t � }tt� |d�}| �|j� | �|j� |�� | �|j� | �|j� dS )z; L{Runner.run} uses the provided PID file. �r? �pidFileN)� DummyPIDFiler r � assertFalse�entered�exitedrE � assertTrue�r' rL rI r) r) r* �test_runUsesPIDFile` s z RunnerTests.test_runUsesPIDFilec C sV t | �| j��}dd� |_tt� |d�}|�� | �| jj t j � | �| jj d� dS )z� L{Runner.run} exits with L{ExitStatus.EX_USAGE} and the expected message if a process is already running that corresponds to the given PID file. c S � dS �NTr) r) r) r) r* �<lambda>w � z4RunnerTests.test_runAlreadyRunning.<locals>.<lambda>rK zAlready running.N) r r( r5 � isRunningr r rE rF r+ �statusr � EX_CONFIG�messagerR r) r) r* �test_runAlreadyRunningp s z"RunnerTests.test_runAlreadyRunningc C s6 t t� d�}|�� | �| jjg � | �| jj� dS )z� L{Runner.killIfRequested} when C{kill} is false doesn't exit and doesn't indiscriminately murder anyone. r> N) r r r@ rF r, �callsrN r+ rP rH r) r) r* �test_killNotRequested s z!RunnerTests.test_killNotRequestedc C sL t t� dd�}|�� | �| jjg � | �| jjtj � | �| jj d� dS )z� L{Runner.killIfRequested} when C{kill} is true but C{pidFile} is L{nonePIDFile} exits with L{ExitStatus.EX_USAGE} and the expected message; and also doesn't indiscriminately murder anyone. T)r? r, zNo PID file specified.N) r r r@ rF r, r] r+ rY r �EX_USAGEr[ rH r) r) r* � test_killRequestedWithoutPIDFile� s z,RunnerTests.test_killRequestedWithoutPIDFilec C sf t | �| j��}tt� d|d�}|�� | �| jj| j t fg� | �| j j t j� | �| j jd� dS )z� L{Runner.killIfRequested} when C{kill} is true and given a C{pidFile} performs a targeted killing of the appropriate process. T�r? r, rL N)r r( r5 r r r@ rF r, r] r3 r r+ rY r �EX_OK�assertIdenticalr[ rR r) r) r* � test_killRequestedWithPIDFile� s z)RunnerTests.test_killRequestedWithPIDFilec C s` t | �d��}dtfdd�}||_tt� d|d�}|�� | �| jj t j � | �| jj d� dS )z� L{Runner.killIfRequested} when C{kill} is true and given a C{pidFile} that it can't read exits with L{ExitStatus.EX_IOERR}. Nr# c S s t tjd��)NzPermission denied)�OSError�errno�EACCESr) r) r) r* �read� s z?RunnerTests.test_killRequestedWithPIDFileCantRead.<locals>.readTra zUnable to read PID file.) r r( �intrh r r r@ rF r+ rY r �EX_IOERRr[ )r' rL rh rI r) r) r* �%test_killRequestedWithPIDFileCantRead� s z1RunnerTests.test_killRequestedWithPIDFileCantReadc C �L t | �d��}tt� d|d�}|�� | �| jjtj � | �| jj d� dS )z� L{Runner.killIfRequested} when C{kill} is true and given a C{pidFile} containing no value exits with L{ExitStatus.EX_DATAERR}. � Tra �Invalid PID file.N� r r( r r r@ rF r+ rY r � EX_DATAERRr[ rR r) r) r* �"test_killRequestedWithPIDFileEmpty� � z.RunnerTests.test_killRequestedWithPIDFileEmptyc C rl )z� L{Runner.killIfRequested} when C{kill} is true and given a C{pidFile} containing a non-integer value exits with L{ExitStatus.EX_DATAERR}. s ** totally not a number, dude **Tra rn Nro rR r) r) r* �%test_killRequestedWithPIDFileNotAnInt� rr z1RunnerTests.test_killRequestedWithPIDFileNotAnIntc s t � }G � fdd�d�� | �td� � � G �fdd�dt��| �td�� G �fdd�dt��tt� tj|�d �}|� � | � t � j �d � | � � j d t� | � t �j�d � | � �jd t� | ��jd jtj� t��j�}| � |�� | �|j|� d S ) z� L{Runner.startLogging} sets up a filtering observer with a log level predicate set to the given log level that contains a file observer of the given type which writes to the given file. c s8 e Zd ZU g Zee ed< dee ddf� fdd� ZdS )z2RunnerTests.test_startLogging.<locals>.LogBeginner� observersr# Nc s t |�� _d S r$ )�listrt )r' rt �r r) r* �beginLoggingTo� � zARunnerTests.test_startLogging.<locals>.LogBeginner.beginLoggingTo) �__name__� __module__� __qualname__rt r r �__annotations__r rw r) rv r) r* r � s r r/ c sZ e Zd ZU dZee ed< g Zee ed< e edd� �fdede e def� fdd� Z dS ) z?RunnerTests.test_startLogging.<locals>.MockFilteringLogObserverN�observer� predicatesc S s d S r$ r) )�eventr) r) r* rV � rW zHRunnerTests.test_startLogging.<locals>.MockFilteringLogObserver.<lambda>�negativeObserverc s$ |� _ t|�� _t�| |||� d S r$ )r} ru r~ r �__init__)r' r} r~ r� ��MockFilteringLogObserverr) r* r� � s �zHRunnerTests.test_startLogging.<locals>.MockFilteringLogObserver.__init__) ry rz r{ r} r r r| r~ r r r r r� r) r� r) r* r� � s ����r� r c s4 e Zd ZU dZee ed< deddf� fdd� ZdS )z:RunnerTests.test_startLogging.<locals>.MockFileLogObserverN�outFiler# c s |� _ t�| |t� d S r$ )r� r r� �str)r' r� ��MockFileLogObserverr) r* r� � s zCRunnerTests.test_startLogging.<locals>.MockFileLogObserver.__init__)ry rz r{ r� r r r| r� r) r� r) r* r� � s r� )r? �defaultLogLevel�logFile�fileLogObserverFactory� r N)r r2 r r r r r r �criticalrA rF �lenrt �assertIsInstancer~ r rc r� r r} r� )r' r� rI r} r) )r r� r� r* �test_startLogging� s2 � �� z RunnerTests.test_startLoggingc C s( t � }t|d�}|�� | �|j� dS )ze L{Runner.startReactor} with the C{reactor} argument runs the given reactor. r> N)r r rB rQ �hasRun)r' r? rI r) r) r* � test_startReactorWithReactor s z(RunnerTests.test_startReactorWithReactorc C s | � dd� dS )z� L{Runner.startReactor} ensures that C{whenRunning} is called with C{whenRunningArguments} when the reactor is running. � whenRunningrB N�� _testHookr< r) r) r* � test_startReactorWhenRunning& s z(RunnerTests.test_startReactorWhenRunningc C � | � d� dS )zb L{Runner.whenRunning} calls C{whenRunning} with C{whenRunningArguments}. r� Nr� r< r) r) r* � test_whenRunningWithArguments- � z)RunnerTests.test_whenRunningWithArgumentsc C r� )zf L{Runner.whenRunning} calls C{reactorExited} with C{reactorExitedArguments}. rC Nr� r< r) r) r* � test_reactorExitedWithArguments4 r� z+RunnerTests.test_reactorExitedWithArguments� methodName� callerNamec s� |du r|}t t� t� t� d�}g � dtddf� fdd� }|||� d�|�� i}td dt� i|��}t||�}|� | �t� �d � | �� d |� dS ) a� Verify that the named hook is run with the expected arguments as specified by the arguments used to create the L{Runner}, when the specified caller is invoked. @param methodName: The name of the hook to verify. @param callerName: The name of the method that is expected to cause the hook to be called. If C{None}, use the L{Runner} method with the same name as the hook. N)�a�b�c� argumentsr# c s � � | � d S r$ )�append)r� �� argumentsSeenr) r* �hookN rx z#RunnerTests._testHook.<locals>.hook� Argumentsr? r� r r) )�dict�object�copyr r �getattrrF r� )r' r� r� r� r� �runnerArgumentsrI � hookCallerr) r� r* r� ; s" ��� zRunnerTests._testHookr$ �r# N)ry rz r{ �__doc__r �bytesr r( r= rJ rS r\ r^ r` rd rk rq rs r� r� r� r� r� r� r� r) r) r) r* r! " s& " M r! T)�frozenc @ sL e Zd ZdZeee ee�d�Z d dd�Z d dd�Z d d d �Z d d d �Z dS )rD zg Stub for L{Runner}. Keep track of calls to some methods without actually doing anything. )�type�defaultr# Nc C � | j �d� d S )Nr@ �rG r� r< r) r) r* r@ j � zDummyRunner.killIfRequestedc C r� )NrA r� r< r) r) r* rA m r� zDummyRunner.startLoggingc C r� )NrB r� r< r) r) r* rB p r� zDummyRunner.startReactorc C r� )NrC r� r< r) r) r* rC s r� zDummyRunner.reactorExitedr� )ry rz r{ r� r r r� r ru rG r@ rA rB rC r) r) r) r* rD ` s rD c @ sN e Zd ZdZd dd�Zddd�Zdeee d ee d ee ddfd d �Z dS )rM z] Stub for L{PIDFile}. Tracks context manager entry/exit without doing anything. r# Nc C s t �| � d| _d| _d S �NF)r r� rO rP r< r) r) r* r� ~ s zDummyPIDFile.__init__c C s d| _ | S rU )rO r< r) r) r* � __enter__� s zDummyPIDFile.__enter__�excType�excValue� tracebackc C � d| _ d S rU �rP )r' r� r� r� r) r) r* �__exit__� s zDummyPIDFile.__exit__r� )r# rM ) ry rz r{ r� r� r� r r � BaseExceptionr r� r) r) r) r* rM w s ����rM c @ s@ e Zd ZdZd dd�Z d deeef dee ddfdd �Z dS ) r0 zy Stub for L{_exit.exit} that remembers whether it's been called and, if it has, what arguments it was given. r# Nc C r� r� r� r< r) r) r* r� � � zDummyExit.__init__rY r[ c C s | j rJ �|| _|| _d| _ d S rU )rP rY r[ )r' rY r[ r) r) r* �__call__� s zDummyExit.__call__r� r$ ) ry rz r{ r� r� r ri r r r� r� r) r) r) r* r0 � s � ���r0 c @ s0 e Zd ZdZd dd�Zdededdfdd �ZdS ) r1 zv Stub for L{os.kill} that remembers whether it's been called and, if it has, what arguments it was given. r# Nc C s g | _ d S r$ )r] r< r) r) r* r� � r� zDummyKill.__init__r3 �sigc C s | j �||f� d S r$ )r] r� )r' r3 r� r) r) r* r� � s zDummyKill.__call__r� )ry rz r{ r� r� ri r� r) r) r) r* r1 � s r1 c @ �& e Zd ZdZdededdfdd�ZdS )r7 zR Stub for L{sys} which provides L{StringIO} streams as stdout and stderr. r6 r. r# Nc C s || _ || _d S r$ )r6 r. )r' r6 r. r) r) r* r� � s zDummyStandardIO.__init__)ry rz r{ r� r r� r) r) r) r* r7 � � r7 c @ r� )r9 zV Stub for L{warnings} which provides a C{showwarning} method that is a no-op. �args�kwargsr# Nc O rT )z\ Do nothing. @param args: ignored. @param kwargs: ignored. Nr) )r� r� r) r) r* � showwarning� rW z DummyWarningsModule.showwarning)ry rz r{ r� r r� r) r) r) r* r9 � r� r9 )6r� rf �ior �signalr �typesr �typingr r r r r r r r r �attrr r r �twisted.trial.unittest�twisted�twisted.internet.testingr �twisted.loggerr r r r r r r �twisted.python.filepathr rI r �_exitr �_pidfiler r r �trial�unittest�TestCaser! rD rM r0 r1 r7 r9 r) r) r) r* �<module> s2 , $ @ PK Mb�Z��\ � � = application/runner/test/__pycache__/test_exit.cpython-310.pycnu �[��� o �b� � @ sl d Z ddlmZ ddlmZmZ ddlZddlm Z ddl m Z m Z G d d � d ej j j�ZG d d � d �ZdS ) z0 Tests for L{twisted.application.runner._exit}. � )�StringIO)�Optional�UnionN� )�_exit� )� ExitStatus�exitc @ sB e Zd ZdZddd�Zddd�Zddd �Zdd d �Zdd d �ZdS )� ExitTestsz Tests for L{exit}. �returnNc C s t � | _| �td| j� d S )N�sysexit)� DummyExitr �patchr ��self� r �K/usr/lib/python3/dist-packages/twisted/application/runner/test/test_exit.py�setUp s zExitTests.setUpc C s d}t |� | �| j j|� dS )zR L{exit} given an L{int} status code will pass it to L{sys.exit}. i� N)r � assertEqual�arg�r �statusr r r �test_exitStatusInt s z ExitTests.test_exitStatusIntc C s$ t j}t|� | �| jj|j� dS )zu L{exit} given a L{ValueConstant} status code passes the corresponding value to L{sys.exit}. N)r � EX_CONFIGr r r �valuer r r r �test_exitConstant! s zExitTests.test_exitConstantc C �: t � }| �td|� d}td|� | �|�� |d � dS )zq L{exit} given a status code of zero (C{0}) writes the given message to standard output. �stdout� Hello, world.r � N�r r r r r �getvalue�r �out�messager r r �test_exitMessageZero* � z ExitTests.test_exitMessageZeroc C r )zj L{exit} given a non-zero status code writes the given message to standard error. �stderrr �@ r Nr r" r r r �test_exitMessageNonZero7 r& z!ExitTests.test_exitMessageNonZero�r N) �__name__� __module__� __qualname__�__doc__r r r r% r) r r r r r s r c @ s: e Zd ZdZd dd�Zd deeeef ddfdd�Z dS ) r zv Stub for L{sys.exit} that remembers whether it's been called and, if it has, what argument it was given. r Nc C s d| _ d S )NF)�exitedr r r r �__init__K s zDummyExit.__init__r c C s | j rJ �|| _d| _ d S )NT)r/ r )r r r r r �__call__N s zDummyExit.__call__r* )N) r+ r, r- r. r0 r r �int�strr1 r r r r r E s $r )r. �ior �typingr r �twisted.trial.unittest�twisted�runnerr r r �trial�unittest�TestCaser r r r r r �<module> s 5PK Mb�ZC�;2 ;2 ' application/runner/test/test_pidfile.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.application.runner._pidfile}. """ import errno from functools import wraps from os import getpid, name as SYSTEM_NAME from typing import Any, Callable, Optional from zope.interface.verify import verifyObject import twisted.trial.unittest from twisted.python.filepath import FilePath from twisted.python.runtime import platform from twisted.trial.unittest import SkipTest from ...runner import _pidfile from .._pidfile import ( AlreadyRunningError, InvalidPIDFileError, IPIDFile, NonePIDFile, NoPIDFound, PIDFile, StalePIDFileError, ) def ifPlatformSupported(f: Callable[..., Any]) -> Callable[..., Any]: """ Decorator for tests that are not expected to work on all platforms. Calling L{PIDFile.isRunning} currently raises L{NotImplementedError} on non-POSIX platforms. On an unsupported platform, we expect to see any test that calls L{PIDFile.isRunning} to raise either L{NotImplementedError}, L{SkipTest}, or C{self.failureException}. (C{self.failureException} may occur in a test that checks for a specific exception but it gets NotImplementedError instead.) @param f: The test method to decorate. @return: The wrapped callable. """ @wraps(f) def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any: supported = platform.getType() == "posix" if supported: return f(self, *args, **kwargs) else: e = self.assertRaises( (NotImplementedError, SkipTest, self.failureException), f, self, *args, **kwargs, ) if isinstance(e, NotImplementedError): self.assertTrue(str(e).startswith("isRunning is not implemented on ")) return wrapper class PIDFileTests(twisted.trial.unittest.TestCase): """ Tests for L{PIDFile}. """ def filePath(self, content: Optional[bytes] = None) -> FilePath: filePath = FilePath(self.mktemp()) if content is not None: filePath.setContent(content) return filePath def test_interface(self) -> None: """ L{PIDFile} conforms to L{IPIDFile}. """ pidFile = PIDFile(self.filePath()) verifyObject(IPIDFile, pidFile) def test_formatWithPID(self) -> None: """ L{PIDFile._format} returns the expected format when given a PID. """ self.assertEqual(PIDFile._format(pid=1337), b"1337\n") def test_readWithPID(self) -> None: """ L{PIDFile.read} returns the PID from the given file path. """ pid = 1337 pidFile = PIDFile(self.filePath(PIDFile._format(pid=pid))) self.assertEqual(pid, pidFile.read()) def test_readEmptyPID(self) -> None: """ L{PIDFile.read} raises L{InvalidPIDFileError} when given an empty file path. """ pidValue = b"" pidFile = PIDFile(self.filePath(b"")) e = self.assertRaises(InvalidPIDFileError, pidFile.read) self.assertEqual(str(e), f"non-integer PID value in PID file: {pidValue!r}") def test_readWithBogusPID(self) -> None: """ L{PIDFile.read} raises L{InvalidPIDFileError} when given an empty file path. """ pidValue = b"$foo!" pidFile = PIDFile(self.filePath(pidValue)) e = self.assertRaises(InvalidPIDFileError, pidFile.read) self.assertEqual(str(e), f"non-integer PID value in PID file: {pidValue!r}") def test_readDoesntExist(self) -> None: """ L{PIDFile.read} raises L{NoPIDFound} when given a non-existing file path. """ pidFile = PIDFile(self.filePath()) e = self.assertRaises(NoPIDFound, pidFile.read) self.assertEqual(str(e), "PID file does not exist") def test_readOpenRaisesOSErrorNotENOENT(self) -> None: """ L{PIDFile.read} re-raises L{OSError} if the associated C{errno} is anything other than L{errno.ENOENT}. """ def oops(mode: str = "r") -> FilePath: raise OSError(errno.EIO, "I/O error") self.patch(FilePath, "open", oops) pidFile = PIDFile(self.filePath()) error = self.assertRaises(OSError, pidFile.read) self.assertEqual(error.errno, errno.EIO) def test_writePID(self) -> None: """ L{PIDFile._write} stores the given PID. """ pid = 1995 pidFile = PIDFile(self.filePath()) pidFile._write(pid) self.assertEqual(pidFile.read(), pid) def test_writePIDInvalid(self) -> None: """ L{PIDFile._write} raises L{ValueError} when given an invalid PID. """ pidFile = PIDFile(self.filePath()) self.assertRaises(ValueError, pidFile._write, "burp") def test_writeRunningPID(self) -> None: """ L{PIDFile.writeRunningPID} stores the PID for the current process. """ pidFile = PIDFile(self.filePath()) pidFile.writeRunningPID() self.assertEqual(pidFile.read(), getpid()) def test_remove(self) -> None: """ L{PIDFile.remove} removes the PID file. """ pidFile = PIDFile(self.filePath(b"")) self.assertTrue(pidFile.filePath.exists()) pidFile.remove() self.assertFalse(pidFile.filePath.exists()) @ifPlatformSupported def test_isRunningDoesExist(self) -> None: """ L{PIDFile.isRunning} returns true for a process that does exist. """ pidFile = PIDFile(self.filePath()) pidFile._write(1337) def kill(pid: int, signal: int) -> None: return # Don't actually kill anything self.patch(_pidfile, "kill", kill) self.assertTrue(pidFile.isRunning()) @ifPlatformSupported def test_isRunningThis(self) -> None: """ L{PIDFile.isRunning} returns true for this process (which is running). @note: This differs from L{PIDFileTests.test_isRunningDoesExist} in that it actually invokes the C{kill} system call, which is useful for testing of our chosen method for probing the existence of a process. """ pidFile = PIDFile(self.filePath()) pidFile.writeRunningPID() self.assertTrue(pidFile.isRunning()) @ifPlatformSupported def test_isRunningDoesNotExist(self) -> None: """ L{PIDFile.isRunning} raises L{StalePIDFileError} for a process that does not exist (errno=ESRCH). """ pidFile = PIDFile(self.filePath()) pidFile._write(1337) def kill(pid: int, signal: int) -> None: raise OSError(errno.ESRCH, "No such process") self.patch(_pidfile, "kill", kill) self.assertRaises(StalePIDFileError, pidFile.isRunning) @ifPlatformSupported def test_isRunningNotAllowed(self) -> None: """ L{PIDFile.isRunning} returns true for a process that we are not allowed to kill (errno=EPERM). """ pidFile = PIDFile(self.filePath()) pidFile._write(1337) def kill(pid: int, signal: int) -> None: raise OSError(errno.EPERM, "Operation not permitted") self.patch(_pidfile, "kill", kill) self.assertTrue(pidFile.isRunning()) @ifPlatformSupported def test_isRunningInit(self) -> None: """ L{PIDFile.isRunning} returns true for a process that we are not allowed to kill (errno=EPERM). @note: This differs from L{PIDFileTests.test_isRunningNotAllowed} in that it actually invokes the C{kill} system call, which is useful for testing of our chosen method for probing the existence of a process that we are not allowed to kill. @note: In this case, we try killing C{init}, which is process #1 on POSIX systems, so this test is not portable. C{init} should always be running and should not be killable by non-root users. """ if SYSTEM_NAME != "posix": raise SkipTest("This test assumes POSIX") pidFile = PIDFile(self.filePath()) pidFile._write(1) # PID 1 is init on POSIX systems self.assertTrue(pidFile.isRunning()) @ifPlatformSupported def test_isRunningUnknownErrno(self) -> None: """ L{PIDFile.isRunning} re-raises L{OSError} if the attached C{errno} value from L{os.kill} is not an expected one. """ pidFile = PIDFile(self.filePath()) pidFile.writeRunningPID() def kill(pid: int, signal: int) -> None: raise OSError(errno.EEXIST, "File exists") self.patch(_pidfile, "kill", kill) self.assertRaises(OSError, pidFile.isRunning) def test_isRunningNoPIDFile(self) -> None: """ L{PIDFile.isRunning} returns false if the PID file doesn't exist. """ pidFile = PIDFile(self.filePath()) self.assertFalse(pidFile.isRunning()) def test_contextManager(self) -> None: """ When used as a context manager, a L{PIDFile} will store the current pid on entry, then removes the PID file on exit. """ pidFile = PIDFile(self.filePath()) self.assertFalse(pidFile.filePath.exists()) with pidFile: self.assertTrue(pidFile.filePath.exists()) self.assertEqual(pidFile.read(), getpid()) self.assertFalse(pidFile.filePath.exists()) @ifPlatformSupported def test_contextManagerDoesntExist(self) -> None: """ When used as a context manager, a L{PIDFile} will replace the underlying PIDFile rather than raising L{AlreadyRunningError} if the contained PID file exists but refers to a non-running PID. """ pidFile = PIDFile(self.filePath()) pidFile._write(1337) def kill(pid: int, signal: int) -> None: raise OSError(errno.ESRCH, "No such process") self.patch(_pidfile, "kill", kill) e = self.assertRaises(StalePIDFileError, pidFile.isRunning) self.assertEqual(str(e), "PID file refers to non-existing process") with pidFile: self.assertEqual(pidFile.read(), getpid()) @ifPlatformSupported def test_contextManagerAlreadyRunning(self) -> None: """ When used as a context manager, a L{PIDFile} will raise L{AlreadyRunningError} if the there is already a running process with the contained PID. """ pidFile = PIDFile(self.filePath()) pidFile._write(1337) def kill(pid: int, signal: int) -> None: return # Don't actually kill anything self.patch(_pidfile, "kill", kill) self.assertTrue(pidFile.isRunning()) self.assertRaises(AlreadyRunningError, pidFile.__enter__) class NonePIDFileTests(twisted.trial.unittest.TestCase): """ Tests for L{NonePIDFile}. """ def test_interface(self) -> None: """ L{NonePIDFile} conforms to L{IPIDFile}. """ pidFile = NonePIDFile() verifyObject(IPIDFile, pidFile) def test_read(self) -> None: """ L{NonePIDFile.read} raises L{NoPIDFound}. """ pidFile = NonePIDFile() e = self.assertRaises(NoPIDFound, pidFile.read) self.assertEqual(str(e), "PID file does not exist") def test_write(self) -> None: """ L{NonePIDFile._write} raises L{OSError} with an errno of L{errno.EPERM}. """ pidFile = NonePIDFile() error = self.assertRaises(OSError, pidFile._write, 0) self.assertEqual(error.errno, errno.EPERM) def test_writeRunningPID(self) -> None: """ L{NonePIDFile.writeRunningPID} raises L{OSError} with an errno of L{errno.EPERM}. """ pidFile = NonePIDFile() error = self.assertRaises(OSError, pidFile.writeRunningPID) self.assertEqual(error.errno, errno.EPERM) def test_remove(self) -> None: """ L{NonePIDFile.remove} raises L{OSError} with an errno of L{errno.EPERM}. """ pidFile = NonePIDFile() error = self.assertRaises(OSError, pidFile.remove) self.assertEqual(error.errno, errno.ENOENT) def test_isRunning(self) -> None: """ L{NonePIDFile.isRunning} returns L{False}. """ pidFile = NonePIDFile() self.assertEqual(pidFile.isRunning(), False) def test_contextManager(self) -> None: """ When used as a context manager, a L{NonePIDFile} doesn't raise, despite not existing. """ pidFile = NonePIDFile() with pidFile: pass PK Mb�Zkc� � $ application/runner/test/test_exit.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.application.runner._exit}. """ from io import StringIO from typing import Optional, Union import twisted.trial.unittest from ...runner import _exit from .._exit import ExitStatus, exit class ExitTests(twisted.trial.unittest.TestCase): """ Tests for L{exit}. """ def setUp(self) -> None: self.exit = DummyExit() self.patch(_exit, "sysexit", self.exit) def test_exitStatusInt(self) -> None: """ L{exit} given an L{int} status code will pass it to L{sys.exit}. """ status = 1234 exit(status) self.assertEqual(self.exit.arg, status) # type: ignore[unreachable] def test_exitConstant(self) -> None: """ L{exit} given a L{ValueConstant} status code passes the corresponding value to L{sys.exit}. """ status = ExitStatus.EX_CONFIG exit(status) self.assertEqual(self.exit.arg, status.value) # type: ignore[unreachable] def test_exitMessageZero(self) -> None: """ L{exit} given a status code of zero (C{0}) writes the given message to standard output. """ out = StringIO() self.patch(_exit, "stdout", out) message = "Hello, world." exit(0, message) self.assertEqual(out.getvalue(), message + "\n") # type: ignore[unreachable] def test_exitMessageNonZero(self) -> None: """ L{exit} given a non-zero status code writes the given message to standard error. """ out = StringIO() self.patch(_exit, "stderr", out) message = "Hello, world." exit(64, message) self.assertEqual(out.getvalue(), message + "\n") # type: ignore[unreachable] class DummyExit: """ Stub for L{sys.exit} that remembers whether it's been called and, if it has, what argument it was given. """ def __init__(self) -> None: self.exited = False def __call__(self, arg: Optional[Union[int, str]] = None) -> None: assert not self.exited self.arg = arg self.exited = True PK Mb�Z ud4�8 �8 & application/runner/test/test_runner.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.application.runner._runner}. """ import errno from io import StringIO from signal import SIGTERM from types import TracebackType from typing import Any, Iterable, List, Optional, TextIO, Tuple, Type, Union, cast from attr import Factory, attrib, attrs import twisted.trial.unittest from twisted.internet.testing import MemoryReactor from twisted.logger import ( FileLogObserver, FilteringLogObserver, ILogObserver, LogBeginner, LogLevel, LogLevelFilterPredicate, LogPublisher, ) from twisted.python.filepath import FilePath from ...runner import _runner from .._exit import ExitStatus from .._pidfile import NonePIDFile, PIDFile from .._runner import Runner class RunnerTests(twisted.trial.unittest.TestCase): """ Tests for L{Runner}. """ def filePath(self, content: Optional[bytes] = None) -> FilePath: filePath = FilePath(self.mktemp()) if content is not None: filePath.setContent(content) return filePath def setUp(self) -> None: # Patch exit and kill so we can capture usage and prevent actual exits # and kills. self.exit = DummyExit() self.kill = DummyKill() self.patch(_runner, "exit", self.exit) self.patch(_runner, "kill", self.kill) # Patch getpid so we get a known result self.pid = 1337 self.pidFileContent = f"{self.pid}\n".encode() # Patch globalLogBeginner so that we aren't trying to install multiple # global log observers. self.stdout = StringIO() self.stderr = StringIO() self.stdio = DummyStandardIO(self.stdout, self.stderr) self.warnings = DummyWarningsModule() self.globalLogPublisher = LogPublisher() self.globalLogBeginner = LogBeginner( self.globalLogPublisher, self.stdio.stderr, self.stdio, self.warnings, ) self.patch(_runner, "stderr", self.stderr) self.patch(_runner, "globalLogBeginner", self.globalLogBeginner) def test_runInOrder(self) -> None: """ L{Runner.run} calls the expected methods in order. """ runner = DummyRunner(reactor=MemoryReactor()) runner.run() self.assertEqual( runner.calledMethods, [ "killIfRequested", "startLogging", "startReactor", "reactorExited", ], ) def test_runUsesPIDFile(self) -> None: """ L{Runner.run} uses the provided PID file. """ pidFile = DummyPIDFile() runner = Runner(reactor=MemoryReactor(), pidFile=pidFile) self.assertFalse(pidFile.entered) self.assertFalse(pidFile.exited) runner.run() self.assertTrue(pidFile.entered) self.assertTrue(pidFile.exited) def test_runAlreadyRunning(self) -> None: """ L{Runner.run} exits with L{ExitStatus.EX_USAGE} and the expected message if a process is already running that corresponds to the given PID file. """ pidFile = PIDFile(self.filePath(self.pidFileContent)) pidFile.isRunning = lambda: True # type: ignore[assignment] runner = Runner(reactor=MemoryReactor(), pidFile=pidFile) runner.run() self.assertEqual(self.exit.status, ExitStatus.EX_CONFIG) self.assertEqual(self.exit.message, "Already running.") def test_killNotRequested(self) -> None: """ L{Runner.killIfRequested} when C{kill} is false doesn't exit and doesn't indiscriminately murder anyone. """ runner = Runner(reactor=MemoryReactor()) runner.killIfRequested() self.assertEqual(self.kill.calls, []) self.assertFalse(self.exit.exited) def test_killRequestedWithoutPIDFile(self) -> None: """ L{Runner.killIfRequested} when C{kill} is true but C{pidFile} is L{nonePIDFile} exits with L{ExitStatus.EX_USAGE} and the expected message; and also doesn't indiscriminately murder anyone. """ runner = Runner(reactor=MemoryReactor(), kill=True) runner.killIfRequested() self.assertEqual(self.kill.calls, []) self.assertEqual(self.exit.status, ExitStatus.EX_USAGE) self.assertEqual(self.exit.message, "No PID file specified.") def test_killRequestedWithPIDFile(self) -> None: """ L{Runner.killIfRequested} when C{kill} is true and given a C{pidFile} performs a targeted killing of the appropriate process. """ pidFile = PIDFile(self.filePath(self.pidFileContent)) runner = Runner(reactor=MemoryReactor(), kill=True, pidFile=pidFile) runner.killIfRequested() self.assertEqual(self.kill.calls, [(self.pid, SIGTERM)]) self.assertEqual(self.exit.status, ExitStatus.EX_OK) self.assertIdentical(self.exit.message, None) def test_killRequestedWithPIDFileCantRead(self) -> None: """ L{Runner.killIfRequested} when C{kill} is true and given a C{pidFile} that it can't read exits with L{ExitStatus.EX_IOERR}. """ pidFile = PIDFile(self.filePath(None)) def read() -> int: raise OSError(errno.EACCES, "Permission denied") pidFile.read = read # type: ignore[assignment] runner = Runner(reactor=MemoryReactor(), kill=True, pidFile=pidFile) runner.killIfRequested() self.assertEqual(self.exit.status, ExitStatus.EX_IOERR) self.assertEqual(self.exit.message, "Unable to read PID file.") def test_killRequestedWithPIDFileEmpty(self) -> None: """ L{Runner.killIfRequested} when C{kill} is true and given a C{pidFile} containing no value exits with L{ExitStatus.EX_DATAERR}. """ pidFile = PIDFile(self.filePath(b"")) runner = Runner(reactor=MemoryReactor(), kill=True, pidFile=pidFile) runner.killIfRequested() self.assertEqual(self.exit.status, ExitStatus.EX_DATAERR) self.assertEqual(self.exit.message, "Invalid PID file.") def test_killRequestedWithPIDFileNotAnInt(self) -> None: """ L{Runner.killIfRequested} when C{kill} is true and given a C{pidFile} containing a non-integer value exits with L{ExitStatus.EX_DATAERR}. """ pidFile = PIDFile(self.filePath(b"** totally not a number, dude **")) runner = Runner(reactor=MemoryReactor(), kill=True, pidFile=pidFile) runner.killIfRequested() self.assertEqual(self.exit.status, ExitStatus.EX_DATAERR) self.assertEqual(self.exit.message, "Invalid PID file.") def test_startLogging(self) -> None: """ L{Runner.startLogging} sets up a filtering observer with a log level predicate set to the given log level that contains a file observer of the given type which writes to the given file. """ logFile = StringIO() # Patch the log beginner so that we don't try to start the already # running (started by trial) logging system. class LogBeginner: observers: List[ILogObserver] = [] def beginLoggingTo(self, observers: Iterable[ILogObserver]) -> None: LogBeginner.observers = list(observers) self.patch(_runner, "globalLogBeginner", LogBeginner()) # Patch FilteringLogObserver so we can capture its arguments class MockFilteringLogObserver(FilteringLogObserver): observer: Optional[ILogObserver] = None predicates: List[LogLevelFilterPredicate] = [] def __init__( self, observer: ILogObserver, predicates: Iterable[LogLevelFilterPredicate], negativeObserver: ILogObserver = cast(ILogObserver, lambda event: None), ): MockFilteringLogObserver.observer = observer MockFilteringLogObserver.predicates = list(predicates) FilteringLogObserver.__init__( self, observer, predicates, negativeObserver ) self.patch(_runner, "FilteringLogObserver", MockFilteringLogObserver) # Patch FileLogObserver so we can capture its arguments class MockFileLogObserver(FileLogObserver): outFile: Optional[TextIO] = None def __init__(self, outFile: TextIO) -> None: MockFileLogObserver.outFile = outFile FileLogObserver.__init__(self, outFile, str) # Start logging runner = Runner( reactor=MemoryReactor(), defaultLogLevel=LogLevel.critical, logFile=logFile, fileLogObserverFactory=MockFileLogObserver, ) runner.startLogging() # Check for a filtering observer self.assertEqual(len(LogBeginner.observers), 1) self.assertIsInstance(LogBeginner.observers[0], FilteringLogObserver) # Check log level predicate with the correct default log level self.assertEqual(len(MockFilteringLogObserver.predicates), 1) self.assertIsInstance( MockFilteringLogObserver.predicates[0], LogLevelFilterPredicate ) self.assertIdentical( MockFilteringLogObserver.predicates[0].defaultLogLevel, LogLevel.critical ) # Check for a file observer attached to the filtering observer observer = cast(MockFileLogObserver, MockFilteringLogObserver.observer) self.assertIsInstance(observer, MockFileLogObserver) # Check for the file we gave it self.assertIdentical(observer.outFile, logFile) def test_startReactorWithReactor(self) -> None: """ L{Runner.startReactor} with the C{reactor} argument runs the given reactor. """ reactor = MemoryReactor() runner = Runner(reactor=reactor) runner.startReactor() self.assertTrue(reactor.hasRun) def test_startReactorWhenRunning(self) -> None: """ L{Runner.startReactor} ensures that C{whenRunning} is called with C{whenRunningArguments} when the reactor is running. """ self._testHook("whenRunning", "startReactor") def test_whenRunningWithArguments(self) -> None: """ L{Runner.whenRunning} calls C{whenRunning} with C{whenRunningArguments}. """ self._testHook("whenRunning") def test_reactorExitedWithArguments(self) -> None: """ L{Runner.whenRunning} calls C{reactorExited} with C{reactorExitedArguments}. """ self._testHook("reactorExited") def _testHook(self, methodName: str, callerName: Optional[str] = None) -> None: """ Verify that the named hook is run with the expected arguments as specified by the arguments used to create the L{Runner}, when the specified caller is invoked. @param methodName: The name of the hook to verify. @param callerName: The name of the method that is expected to cause the hook to be called. If C{None}, use the L{Runner} method with the same name as the hook. """ if callerName is None: callerName = methodName arguments = dict(a=object(), b=object(), c=object()) argumentsSeen = [] def hook(**arguments: object) -> None: argumentsSeen.append(arguments) runnerArguments = { methodName: hook, f"{methodName}Arguments": arguments.copy(), } runner = Runner( reactor=MemoryReactor(), **runnerArguments # type: ignore[arg-type] ) hookCaller = getattr(runner, callerName) hookCaller() self.assertEqual(len(argumentsSeen), 1) self.assertEqual(argumentsSeen[0], arguments) @attrs(frozen=True) class DummyRunner(Runner): """ Stub for L{Runner}. Keep track of calls to some methods without actually doing anything. """ calledMethods = attrib(type=List[str], default=Factory(list)) def killIfRequested(self) -> None: self.calledMethods.append("killIfRequested") def startLogging(self) -> None: self.calledMethods.append("startLogging") def startReactor(self) -> None: self.calledMethods.append("startReactor") def reactorExited(self) -> None: self.calledMethods.append("reactorExited") class DummyPIDFile(NonePIDFile): """ Stub for L{PIDFile}. Tracks context manager entry/exit without doing anything. """ def __init__(self) -> None: NonePIDFile.__init__(self) self.entered = False self.exited = False def __enter__(self) -> "DummyPIDFile": self.entered = True return self def __exit__( self, excType: Optional[Type[BaseException]], excValue: Optional[BaseException], traceback: Optional[TracebackType], ) -> None: self.exited = True class DummyExit: """ Stub for L{_exit.exit} that remembers whether it's been called and, if it has, what arguments it was given. """ def __init__(self) -> None: self.exited = False def __call__( self, status: Union[int, ExitStatus], message: Optional[str] = None ) -> None: assert not self.exited self.status = status self.message = message self.exited = True class DummyKill: """ Stub for L{os.kill} that remembers whether it's been called and, if it has, what arguments it was given. """ def __init__(self) -> None: self.calls: List[Tuple[int, int]] = [] def __call__(self, pid: int, sig: int) -> None: self.calls.append((pid, sig)) class DummyStandardIO: """ Stub for L{sys} which provides L{StringIO} streams as stdout and stderr. """ def __init__(self, stdout: TextIO, stderr: TextIO) -> None: self.stdout = stdout self.stderr = stderr class DummyWarningsModule: """ Stub for L{warnings} which provides a C{showwarning} method that is a no-op. """ def showwarning(*args: Any, **kwargs: Any) -> None: """ Do nothing. @param args: ignored. @param kwargs: ignored. """ PK Mb�Z�0�� � # application/runner/test/__init__.pynu �[��� # -*- test-case-name: twisted.application.runner.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.application.runner}. """ PK Mb�ZNe��� � application/runner/_runner.pynu �[��� # -*- test-case-name: twisted.application.runner.test.test_runner -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted application runner. """ from os import kill from signal import SIGTERM from sys import stderr from typing import Any, Callable, Mapping, TextIO from attr import Factory, attrib, attrs from constantly import NamedConstant # type: ignore[import] from twisted.internet.interfaces import IReactorCore from twisted.logger import ( FileLogObserver, FilteringLogObserver, Logger, LogLevel, LogLevelFilterPredicate, globalLogBeginner, textFileLogObserver, ) from ._exit import ExitStatus, exit from ._pidfile import AlreadyRunningError, InvalidPIDFileError, IPIDFile, nonePIDFile @attrs(frozen=True) class Runner: """ Twisted application runner. @cvar _log: The logger attached to this class. @ivar _reactor: The reactor to start and run the application in. @ivar _pidFile: The file to store the running process ID in. @ivar _kill: Whether this runner should kill an existing running instance of the application. @ivar _defaultLogLevel: The default log level to start the logging system with. @ivar _logFile: A file stream to write logging output to. @ivar _fileLogObserverFactory: A factory for the file log observer to use when starting the logging system. @ivar _whenRunning: Hook to call after the reactor is running; this is where the application code that relies on the reactor gets called. @ivar _whenRunningArguments: Keyword arguments to pass to C{whenRunning} when it is called. @ivar _reactorExited: Hook to call after the reactor exits. @ivar _reactorExitedArguments: Keyword arguments to pass to C{reactorExited} when it is called. """ _log = Logger() _reactor = attrib(type=IReactorCore) _pidFile = attrib(type=IPIDFile, default=nonePIDFile) _kill = attrib(type=bool, default=False) _defaultLogLevel = attrib(type=NamedConstant, default=LogLevel.info) _logFile = attrib(type=TextIO, default=stderr) _fileLogObserverFactory = attrib( type=Callable[[TextIO], FileLogObserver], default=textFileLogObserver ) _whenRunning = attrib(type=Callable[..., None], default=lambda **_: None) _whenRunningArguments = attrib(type=Mapping[str, Any], default=Factory(dict)) _reactorExited = attrib(type=Callable[..., None], default=lambda **_: None) _reactorExitedArguments = attrib(type=Mapping[str, Any], default=Factory(dict)) def run(self) -> None: """ Run this command. """ pidFile = self._pidFile self.killIfRequested() try: with pidFile: self.startLogging() self.startReactor() self.reactorExited() except AlreadyRunningError: exit(ExitStatus.EX_CONFIG, "Already running.") # When testing, patched exit doesn't exit return # type: ignore[unreachable] def killIfRequested(self) -> None: """ If C{self._kill} is true, attempt to kill a running instance of the application. """ pidFile = self._pidFile if self._kill: if pidFile is nonePIDFile: exit(ExitStatus.EX_USAGE, "No PID file specified.") # When testing, patched exit doesn't exit return # type: ignore[unreachable] try: pid = pidFile.read() except OSError: exit(ExitStatus.EX_IOERR, "Unable to read PID file.") # When testing, patched exit doesn't exit return # type: ignore[unreachable] except InvalidPIDFileError: exit(ExitStatus.EX_DATAERR, "Invalid PID file.") # When testing, patched exit doesn't exit return # type: ignore[unreachable] self.startLogging() self._log.info("Terminating process: {pid}", pid=pid) kill(pid, SIGTERM) exit(ExitStatus.EX_OK) # When testing, patched exit doesn't exit return # type: ignore[unreachable] def startLogging(self) -> None: """ Start the L{twisted.logger} logging system. """ logFile = self._logFile fileLogObserverFactory = self._fileLogObserverFactory fileLogObserver = fileLogObserverFactory(logFile) logLevelPredicate = LogLevelFilterPredicate( defaultLogLevel=self._defaultLogLevel ) filteringObserver = FilteringLogObserver(fileLogObserver, [logLevelPredicate]) globalLogBeginner.beginLoggingTo([filteringObserver]) def startReactor(self) -> None: """ Register C{self._whenRunning} with the reactor so that it is called once the reactor is running, then start the reactor. """ self._reactor.callWhenRunning(self.whenRunning) self._log.info("Starting reactor...") self._reactor.run() def whenRunning(self) -> None: """ Call C{self._whenRunning} with C{self._whenRunningArguments}. @note: This method is called after the reactor starts running. """ self._whenRunning(**self._whenRunningArguments) def reactorExited(self) -> None: """ Call C{self._reactorExited} with C{self._reactorExitedArguments}. @note: This method is called after the reactor exits. """ self._reactorExited(**self._reactorExitedArguments) PK Mb�Z2$�z| | application/runner/_exit.pynu �[��� # -*- test-case-name: twisted.application.runner.test.test_exit -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ System exit support. """ import typing from enum import IntEnum from sys import exit as sysexit, stderr, stdout from typing import Union try: import posix as Status except ImportError: class Status: # type: ignore[no-redef] """ Object to hang C{EX_*} values off of as a substitute for L{posix}. """ EX__BASE = 64 EX_OK = 0 EX_USAGE = EX__BASE EX_DATAERR = EX__BASE + 1 EX_NOINPUT = EX__BASE + 2 EX_NOUSER = EX__BASE + 3 EX_NOHOST = EX__BASE + 4 EX_UNAVAILABLE = EX__BASE + 5 EX_SOFTWARE = EX__BASE + 6 EX_OSERR = EX__BASE + 7 EX_OSFILE = EX__BASE + 8 EX_CANTCREAT = EX__BASE + 9 EX_IOERR = EX__BASE + 10 EX_TEMPFAIL = EX__BASE + 11 EX_PROTOCOL = EX__BASE + 12 EX_NOPERM = EX__BASE + 13 EX_CONFIG = EX__BASE + 14 class ExitStatus(IntEnum): """ Standard exit status codes for system programs. @cvar EX_OK: Successful termination. @cvar EX_USAGE: Command line usage error. @cvar EX_DATAERR: Data format error. @cvar EX_NOINPUT: Cannot open input. @cvar EX_NOUSER: Addressee unknown. @cvar EX_NOHOST: Host name unknown. @cvar EX_UNAVAILABLE: Service unavailable. @cvar EX_SOFTWARE: Internal software error. @cvar EX_OSERR: System error (e.g., can't fork). @cvar EX_OSFILE: Critical OS file missing. @cvar EX_CANTCREAT: Can't create (user) output file. @cvar EX_IOERR: Input/output error. @cvar EX_TEMPFAIL: Temporary failure; the user is invited to retry. @cvar EX_PROTOCOL: Remote error in protocol. @cvar EX_NOPERM: Permission denied. @cvar EX_CONFIG: Configuration error. """ EX_OK = Status.EX_OK EX_USAGE = Status.EX_USAGE EX_DATAERR = Status.EX_DATAERR EX_NOINPUT = Status.EX_NOINPUT EX_NOUSER = Status.EX_NOUSER EX_NOHOST = Status.EX_NOHOST EX_UNAVAILABLE = Status.EX_UNAVAILABLE EX_SOFTWARE = Status.EX_SOFTWARE EX_OSERR = Status.EX_OSERR EX_OSFILE = Status.EX_OSFILE EX_CANTCREAT = Status.EX_CANTCREAT EX_IOERR = Status.EX_IOERR EX_TEMPFAIL = Status.EX_TEMPFAIL EX_PROTOCOL = Status.EX_PROTOCOL EX_NOPERM = Status.EX_NOPERM EX_CONFIG = Status.EX_CONFIG def exit(status: Union[int, ExitStatus], message: str = "") -> "typing.NoReturn": """ Exit the python interpreter with the given status and an optional message. @param status: An exit status. An appropriate value from L{ExitStatus} is recommended. @param message: An optional message to print. """ if message: if status == ExitStatus.EX_OK: out = stdout else: out = stderr out.write(message) out.write("\n") sysexit(status) PK Mb�Z� �� � application/runner/__init__.pynu �[��� # -*- test-case-name: twisted.application.runner.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Facilities for running a Twisted application. """ PK Mb�Z�;�,� ,� application/internet.pynu �[��� # -*- test-case-name: twisted.application.test.test_internet,twisted.test.test_application,twisted.test.test_cooperator -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Reactor-based Services Here are services to run clients, servers and periodic services using the reactor. If you want to run a server service, L{StreamServerEndpointService} defines a service that can wrap an arbitrary L{IStreamServerEndpoint <twisted.internet.interfaces.IStreamServerEndpoint>} as an L{IService}. See also L{twisted.application.strports.service} for constructing one of these directly from a descriptive string. Additionally, this module (dynamically) defines various Service subclasses that let you represent clients and servers in a Service hierarchy. Endpoints APIs should be preferred for stream server services, but since those APIs do not yet exist for clients or datagram services, many of these are still useful. They are as follows:: TCPServer, TCPClient, UNIXServer, UNIXClient, SSLServer, SSLClient, UDPServer, UNIXDatagramServer, UNIXDatagramClient, MulticastServer These classes take arbitrary arguments in their constructors and pass them straight on to their respective reactor.listenXXX or reactor.connectXXX calls. For example, the following service starts a web server on port 8080: C{TCPServer(8080, server.Site(r))}. See the documentation for the reactor.listen/connect* methods for more information. """ from random import random as _goodEnoughRandom from typing import List from automat import MethodicalMachine # type: ignore[import] from twisted.application import service from twisted.internet import task from twisted.internet.defer import ( CancelledError, Deferred, fail, maybeDeferred, succeed, ) from twisted.logger import Logger from twisted.python import log from twisted.python.failure import Failure def _maybeGlobalReactor(maybeReactor): """ @return: the argument, or the global reactor if the argument is L{None}. """ if maybeReactor is None: from twisted.internet import reactor return reactor else: return maybeReactor class _VolatileDataService(service.Service): volatile: List[str] = [] def __getstate__(self): d = service.Service.__getstate__(self) for attr in self.volatile: if attr in d: del d[attr] return d class _AbstractServer(_VolatileDataService): """ @cvar volatile: list of attribute to remove from pickling. @type volatile: C{list} @ivar method: the type of method to call on the reactor, one of B{TCP}, B{UDP}, B{SSL} or B{UNIX}. @type method: C{str} @ivar reactor: the current running reactor. @type reactor: a provider of C{IReactorTCP}, C{IReactorUDP}, C{IReactorSSL} or C{IReactorUnix}. @ivar _port: instance of port set when the service is started. @type _port: a provider of L{twisted.internet.interfaces.IListeningPort}. """ volatile = ["_port"] method: str = "" reactor = None _port = None def __init__(self, *args, **kwargs): self.args = args if "reactor" in kwargs: self.reactor = kwargs.pop("reactor") self.kwargs = kwargs def privilegedStartService(self): service.Service.privilegedStartService(self) self._port = self._getPort() def startService(self): service.Service.startService(self) if self._port is None: self._port = self._getPort() def stopService(self): service.Service.stopService(self) # TODO: if startup failed, should shutdown skip stopListening? # _port won't exist if self._port is not None: d = self._port.stopListening() del self._port return d def _getPort(self): """ Wrapper around the appropriate listen method of the reactor. @return: the port object returned by the listen method. @rtype: an object providing L{twisted.internet.interfaces.IListeningPort}. """ return getattr( _maybeGlobalReactor(self.reactor), "listen{}".format( self.method, ), )(*self.args, **self.kwargs) class _AbstractClient(_VolatileDataService): """ @cvar volatile: list of attribute to remove from pickling. @type volatile: C{list} @ivar method: the type of method to call on the reactor, one of B{TCP}, B{UDP}, B{SSL} or B{UNIX}. @type method: C{str} @ivar reactor: the current running reactor. @type reactor: a provider of C{IReactorTCP}, C{IReactorUDP}, C{IReactorSSL} or C{IReactorUnix}. @ivar _connection: instance of connection set when the service is started. @type _connection: a provider of L{twisted.internet.interfaces.IConnector}. """ volatile = ["_connection"] method: str = "" reactor = None _connection = None def __init__(self, *args, **kwargs): self.args = args if "reactor" in kwargs: self.reactor = kwargs.pop("reactor") self.kwargs = kwargs def startService(self): service.Service.startService(self) self._connection = self._getConnection() def stopService(self): service.Service.stopService(self) if self._connection is not None: self._connection.disconnect() del self._connection def _getConnection(self): """ Wrapper around the appropriate connect method of the reactor. @return: the port object returned by the connect method. @rtype: an object providing L{twisted.internet.interfaces.IConnector}. """ return getattr(_maybeGlobalReactor(self.reactor), f"connect{self.method}")( *self.args, **self.kwargs ) _clientDoc = """Connect to {tran} Call reactor.connect{tran} when the service starts, with the arguments given to the constructor. """ _serverDoc = """Serve {tran} clients Call reactor.listen{tran} when the service starts, with the arguments given to the constructor. When the service stops, stop listening. See twisted.internet.interfaces for documentation on arguments to the reactor method. """ class TCPServer(_AbstractServer): __doc__ = _serverDoc.format(tran="TCP") method = "TCP" class TCPClient(_AbstractClient): __doc__ = _clientDoc.format(tran="TCP") method = "TCP" class UNIXServer(_AbstractServer): __doc__ = _serverDoc.format(tran="UNIX") method = "UNIX" class UNIXClient(_AbstractClient): __doc__ = _clientDoc.format(tran="UNIX") method = "UNIX" class SSLServer(_AbstractServer): __doc__ = _serverDoc.format(tran="SSL") method = "SSL" class SSLClient(_AbstractClient): __doc__ = _clientDoc.format(tran="SSL") method = "SSL" class UDPServer(_AbstractServer): __doc__ = _serverDoc.format(tran="UDP") method = "UDP" class UNIXDatagramServer(_AbstractServer): __doc__ = _serverDoc.format(tran="UNIXDatagram") method = "UNIXDatagram" class UNIXDatagramClient(_AbstractClient): __doc__ = _clientDoc.format(tran="UNIXDatagram") method = "UNIXDatagram" class MulticastServer(_AbstractServer): __doc__ = _serverDoc.format(tran="Multicast") method = "Multicast" class TimerService(_VolatileDataService): """ Service to periodically call a function Every C{step} seconds call the given function with the given arguments. The service starts the calls when it starts, and cancels them when it stops. @ivar clock: Source of time. This defaults to L{None} which is causes L{twisted.internet.reactor} to be used. Feel free to set this to something else, but it probably ought to be set *before* calling L{startService}. @type clock: L{IReactorTime<twisted.internet.interfaces.IReactorTime>} @ivar call: Function and arguments to call periodically. @type call: L{tuple} of C{(callable, args, kwargs)} """ volatile = ["_loop", "_loopFinished"] def __init__(self, step, callable, *args, **kwargs): """ @param step: The number of seconds between calls. @type step: L{float} @param callable: Function to call @type callable: L{callable} @param args: Positional arguments to pass to function @param kwargs: Keyword arguments to pass to function """ self.step = step self.call = (callable, args, kwargs) self.clock = None def startService(self): service.Service.startService(self) callable, args, kwargs = self.call # we have to make a new LoopingCall each time we're started, because # an active LoopingCall remains active when serialized. If # LoopingCall were a _VolatileDataService, we wouldn't need to do # this. self._loop = task.LoopingCall(callable, *args, **kwargs) self._loop.clock = _maybeGlobalReactor(self.clock) self._loopFinished = self._loop.start(self.step, now=True) self._loopFinished.addErrback(self._failed) def _failed(self, why): # make a note that the LoopingCall is no longer looping, so we don't # try to shut it down a second time in stopService. I think this # should be in LoopingCall. -warner self._loop.running = False log.err(why) def stopService(self): """ Stop the service. @rtype: L{Deferred<defer.Deferred>} @return: a L{Deferred<defer.Deferred>} which is fired when the currently running call (if any) is finished. """ if self._loop.running: self._loop.stop() self._loopFinished.addCallback(lambda _: service.Service.stopService(self)) return self._loopFinished class CooperatorService(service.Service): """ Simple L{service.IService} which starts and stops a L{twisted.internet.task.Cooperator}. """ def __init__(self): self.coop = task.Cooperator(started=False) def coiterate(self, iterator): return self.coop.coiterate(iterator) def startService(self): self.coop.start() def stopService(self): self.coop.stop() class StreamServerEndpointService(service.Service): """ A L{StreamServerEndpointService} is an L{IService} which runs a server on a listening port described by an L{IStreamServerEndpoint <twisted.internet.interfaces.IStreamServerEndpoint>}. @ivar factory: A server factory which will be used to listen on the endpoint. @ivar endpoint: An L{IStreamServerEndpoint <twisted.internet.interfaces.IStreamServerEndpoint>} provider which will be used to listen when the service starts. @ivar _waitingForPort: a Deferred, if C{listen} has yet been invoked on the endpoint, otherwise None. @ivar _raiseSynchronously: Defines error-handling behavior for the case where C{listen(...)} raises an exception before C{startService} or C{privilegedStartService} have completed. @type _raiseSynchronously: C{bool} @since: 10.2 """ _raiseSynchronously = False def __init__(self, endpoint, factory): self.endpoint = endpoint self.factory = factory self._waitingForPort = None def privilegedStartService(self): """ Start listening on the endpoint. """ service.Service.privilegedStartService(self) self._waitingForPort = self.endpoint.listen(self.factory) raisedNow = [] def handleIt(err): if self._raiseSynchronously: raisedNow.append(err) elif not err.check(CancelledError): log.err(err) self._waitingForPort.addErrback(handleIt) if raisedNow: raisedNow[0].raiseException() self._raiseSynchronously = False def startService(self): """ Start listening on the endpoint, unless L{privilegedStartService} got around to it already. """ service.Service.startService(self) if self._waitingForPort is None: self.privilegedStartService() def stopService(self): """ Stop listening on the port if it is already listening, otherwise, cancel the attempt to listen. @return: a L{Deferred<twisted.internet.defer.Deferred>} which fires with L{None} when the port has stopped listening. """ self._waitingForPort.cancel() def stopIt(port): if port is not None: return port.stopListening() d = self._waitingForPort.addCallback(stopIt) def stop(passthrough): self.running = False return passthrough d.addBoth(stop) return d class _ReconnectingProtocolProxy: """ A proxy for a Protocol to provide connectionLost notification to a client connection service, in support of reconnecting when connections are lost. """ def __init__(self, protocol, lostNotification): """ Create a L{_ReconnectingProtocolProxy}. @param protocol: the application-provided L{interfaces.IProtocol} provider. @type protocol: provider of L{interfaces.IProtocol} which may additionally provide L{interfaces.IHalfCloseableProtocol} and L{interfaces.IFileDescriptorReceiver}. @param lostNotification: a 1-argument callable to invoke with the C{reason} when the connection is lost. """ self._protocol = protocol self._lostNotification = lostNotification def connectionLost(self, reason): """ The connection was lost. Relay this information. @param reason: The reason the connection was lost. @return: the underlying protocol's result """ try: return self._protocol.connectionLost(reason) finally: self._lostNotification(reason) def __getattr__(self, item): return getattr(self._protocol, item) def __repr__(self) -> str: return f"<{self.__class__.__name__} wrapping {self._protocol!r}>" class _DisconnectFactory: """ A L{_DisconnectFactory} is a proxy for L{IProtocolFactory} that catches C{connectionLost} notifications and relays them. """ def __init__(self, protocolFactory, protocolDisconnected): self._protocolFactory = protocolFactory self._protocolDisconnected = protocolDisconnected def buildProtocol(self, addr): """ Create a L{_ReconnectingProtocolProxy} with the disconnect-notification callback we were called with. @param addr: The address the connection is coming from. @return: a L{_ReconnectingProtocolProxy} for a protocol produced by C{self._protocolFactory} """ return _ReconnectingProtocolProxy( self._protocolFactory.buildProtocol(addr), self._protocolDisconnected ) def __getattr__(self, item): return getattr(self._protocolFactory, item) def __repr__(self) -> str: return "<{} wrapping {!r}>".format( self.__class__.__name__, self._protocolFactory ) def backoffPolicy( initialDelay=1.0, maxDelay=60.0, factor=1.5, jitter=_goodEnoughRandom ): """ A timeout policy for L{ClientService} which computes an exponential backoff interval with configurable parameters. @since: 16.1.0 @param initialDelay: Delay for the first reconnection attempt (default 1.0s). @type initialDelay: L{float} @param maxDelay: Maximum number of seconds between connection attempts (default 60 seconds, or one minute). Note that this value is before jitter is applied, so the actual maximum possible delay is this value plus the maximum possible result of C{jitter()}. @type maxDelay: L{float} @param factor: A multiplicative factor by which the delay grows on each failed reattempt. Default: 1.5. @type factor: L{float} @param jitter: A 0-argument callable that introduces noise into the delay. By default, C{random.random}, i.e. a pseudorandom floating-point value between zero and one. @type jitter: 0-argument callable returning L{float} @return: a 1-argument callable that, given an attempt count, returns a floating point number; the number of seconds to delay. @rtype: see L{ClientService.__init__}'s C{retryPolicy} argument. """ def policy(attempt): try: delay = min(initialDelay * (factor ** min(100, attempt)), maxDelay) except OverflowError: delay = maxDelay return delay + jitter() return policy _defaultPolicy = backoffPolicy() def _firstResult(gen): """ Return the first element of a generator and exhaust it. C{MethodicalMachine.upon}'s C{collector} argument takes a generator of output results. If the generator is exhausted, the later outputs aren't actually run. @param gen: Generator to extract values from @return: The first element of the generator. """ return list(gen)[0] class _ClientMachine: """ State machine for maintaining a single outgoing connection to an endpoint. @ivar _awaitingConnected: notifications to make when connection succeeds, fails, or is cancelled @type _awaitingConnected: list of (Deferred, count) tuples @see: L{ClientService} """ _machine = MethodicalMachine() def __init__(self, endpoint, factory, retryPolicy, clock, prepareConnection, log): """ @see: L{ClientService.__init__} @param log: The logger for the L{ClientService} instance this state machine is associated to. @type log: L{Logger} """ self._endpoint = endpoint self._failedAttempts = 0 self._stopped = False self._factory = factory self._timeoutForAttempt = retryPolicy self._clock = clock self._prepareConnection = prepareConnection self._connectionInProgress = succeed(None) self._awaitingConnected = [] self._stopWaiters = [] self._log = log @_machine.state(initial=True) def _init(self): """ The service has not been started. """ @_machine.state() def _connecting(self): """ The service has started connecting. """ @_machine.state() def _waiting(self): """ The service is waiting for the reconnection period before reconnecting. """ @_machine.state() def _connected(self): """ The service is connected. """ @_machine.state() def _disconnecting(self): """ The service is disconnecting after being asked to shutdown. """ @_machine.state() def _restarting(self): """ The service is disconnecting and has been asked to restart. """ @_machine.state() def _stopped(self): """ The service has been stopped and is disconnected. """ @_machine.input() def start(self): """ Start this L{ClientService}, initiating the connection retry loop. """ @_machine.output() def _connect(self): """ Start a connection attempt. """ factoryProxy = _DisconnectFactory( self._factory, lambda _: self._clientDisconnected() ) self._connectionInProgress = ( self._endpoint.connect(factoryProxy) .addCallback(self._runPrepareConnection) .addCallback(self._connectionMade) .addErrback(self._connectionFailed) ) def _runPrepareConnection(self, protocol): """ Run any C{prepareConnection} callback with the connected protocol, ignoring its return value but propagating any failure. @param protocol: The protocol of the connection. @type protocol: L{IProtocol} @return: Either: - A L{Deferred} that succeeds with the protocol when the C{prepareConnection} callback has executed successfully. - A L{Deferred} that fails when the C{prepareConnection} callback throws or returns a failed L{Deferred}. - The protocol, when no C{prepareConnection} callback is defined. """ if self._prepareConnection: return maybeDeferred(self._prepareConnection, protocol).addCallback( lambda _: protocol ) return protocol @_machine.output() def _resetFailedAttempts(self): """ Reset the number of failed attempts. """ self._failedAttempts = 0 @_machine.input() def stop(self): """ Stop trying to connect and disconnect any current connection. @return: a L{Deferred} that fires when all outstanding connections are closed and all in-progress connection attempts halted. """ @_machine.output() def _waitForStop(self): """ Return a deferred that will fire when the service has finished disconnecting. @return: L{Deferred} that fires when the service has finished disconnecting. """ self._stopWaiters.append(Deferred()) return self._stopWaiters[-1] @_machine.output() def _stopConnecting(self): """ Stop pending connection attempt. """ self._connectionInProgress.cancel() @_machine.output() def _stopRetrying(self): """ Stop pending attempt to reconnect. """ self._retryCall.cancel() del self._retryCall @_machine.output() def _disconnect(self): """ Disconnect the current connection. """ self._currentConnection.transport.loseConnection() @_machine.input() def _connectionMade(self, protocol): """ A connection has been made. @param protocol: The protocol of the connection. @type protocol: L{IProtocol} """ @_machine.output() def _notifyWaiters(self, protocol): """ Notify all pending requests for a connection that a connection has been made. @param protocol: The protocol of the connection. @type protocol: L{IProtocol} """ # This should be in _resetFailedAttempts but the signature doesn't # match. self._failedAttempts = 0 self._currentConnection = protocol._protocol self._unawait(self._currentConnection) @_machine.input() def _connectionFailed(self, f): """ The current connection attempt failed. """ @_machine.output() def _wait(self): """ Schedule a retry attempt. """ self._doWait() @_machine.output() def _ignoreAndWait(self, f): """ Schedule a retry attempt, and ignore the Failure passed in. """ return self._doWait() def _doWait(self): self._failedAttempts += 1 delay = self._timeoutForAttempt(self._failedAttempts) self._log.info( "Scheduling retry {attempt} to connect {endpoint} " "in {delay} seconds.", attempt=self._failedAttempts, endpoint=self._endpoint, delay=delay, ) self._retryCall = self._clock.callLater(delay, self._reconnect) @_machine.input() def _reconnect(self): """ The wait between connection attempts is done. """ @_machine.input() def _clientDisconnected(self): """ The current connection has been disconnected. """ @_machine.output() def _forgetConnection(self): """ Forget the current connection. """ del self._currentConnection @_machine.output() def _cancelConnectWaiters(self): """ Notify all pending requests for a connection that no more connections are expected. """ self._unawait(Failure(CancelledError())) @_machine.output() def _ignoreAndCancelConnectWaiters(self, f): """ Notify all pending requests for a connection that no more connections are expected, after ignoring the Failure passed in. """ self._unawait(Failure(CancelledError())) @_machine.output() def _finishStopping(self): """ Notify all deferreds waiting on the service stopping. """ self._doFinishStopping() @_machine.output() def _ignoreAndFinishStopping(self, f): """ Notify all deferreds waiting on the service stopping, and ignore the Failure passed in. """ self._doFinishStopping() def _doFinishStopping(self): self._stopWaiters, waiting = [], self._stopWaiters for w in waiting: w.callback(None) @_machine.input() def whenConnected(self, failAfterFailures=None): """ Retrieve the currently-connected L{Protocol}, or the next one to connect. @param failAfterFailures: number of connection failures after which the Deferred will deliver a Failure (None means the Deferred will only fail if/when the service is stopped). Set this to 1 to make the very first connection failure signal an error. Use 2 to allow one failure but signal an error if the subsequent retry then fails. @type failAfterFailures: L{int} or None @return: a Deferred that fires with a protocol produced by the factory passed to C{__init__} @rtype: L{Deferred} that may: - fire with L{IProtocol} - fail with L{CancelledError} when the service is stopped - fail with e.g. L{DNSLookupError<twisted.internet.error.DNSLookupError>} or L{ConnectionRefusedError<twisted.internet.error.ConnectionRefusedError>} when the number of consecutive failed connection attempts equals the value of "failAfterFailures" """ @_machine.output() def _currentConnection(self, failAfterFailures=None): """ Return the currently connected protocol. @return: L{Deferred} that is fired with currently connected protocol. """ return succeed(self._currentConnection) @_machine.output() def _noConnection(self, failAfterFailures=None): """ Notify the caller that no connection is expected. @return: L{Deferred} that is fired with L{CancelledError}. """ return fail(CancelledError()) @_machine.output() def _awaitingConnection(self, failAfterFailures=None): """ Return a deferred that will fire with the next connected protocol. @return: L{Deferred} that will fire with the next connected protocol. """ result = Deferred() self._awaitingConnected.append((result, failAfterFailures)) return result @_machine.output() def _deferredSucceededWithNone(self): """ Return a deferred that has already fired with L{None}. @return: A L{Deferred} that has already fired with L{None}. """ return succeed(None) def _unawait(self, value): """ Fire all outstanding L{ClientService.whenConnected} L{Deferred}s. @param value: the value to fire the L{Deferred}s with. """ self._awaitingConnected, waiting = [], self._awaitingConnected for (w, remaining) in waiting: w.callback(value) @_machine.output() def _deliverConnectionFailure(self, f): """ Deliver connection failures to any L{ClientService.whenConnected} L{Deferred}s that have met their failAfterFailures threshold. @param f: the Failure to fire the L{Deferred}s with. """ ready = [] notReady = [] for (w, remaining) in self._awaitingConnected: if remaining is None: notReady.append((w, remaining)) elif remaining <= 1: ready.append(w) else: notReady.append((w, remaining - 1)) self._awaitingConnected = notReady for w in ready: w.callback(f) # State Transitions _init.upon(start, enter=_connecting, outputs=[_connect]) _init.upon( stop, enter=_stopped, outputs=[_deferredSucceededWithNone], collector=_firstResult, ) _connecting.upon(start, enter=_connecting, outputs=[]) # Note that this synchonously triggers _connectionFailed in the # _disconnecting state. _connecting.upon( stop, enter=_disconnecting, outputs=[_waitForStop, _stopConnecting], collector=_firstResult, ) _connecting.upon(_connectionMade, enter=_connected, outputs=[_notifyWaiters]) _connecting.upon( _connectionFailed, enter=_waiting, outputs=[_ignoreAndWait, _deliverConnectionFailure], ) _waiting.upon(start, enter=_waiting, outputs=[]) _waiting.upon( stop, enter=_stopped, outputs=[_waitForStop, _cancelConnectWaiters, _stopRetrying, _finishStopping], collector=_firstResult, ) _waiting.upon(_reconnect, enter=_connecting, outputs=[_connect]) _connected.upon(start, enter=_connected, outputs=[]) _connected.upon( stop, enter=_disconnecting, outputs=[_waitForStop, _disconnect], collector=_firstResult, ) _connected.upon( _clientDisconnected, enter=_waiting, outputs=[_forgetConnection, _wait] ) _disconnecting.upon(start, enter=_restarting, outputs=[_resetFailedAttempts]) _disconnecting.upon( stop, enter=_disconnecting, outputs=[_waitForStop], collector=_firstResult ) _disconnecting.upon( _clientDisconnected, enter=_stopped, outputs=[_cancelConnectWaiters, _finishStopping, _forgetConnection], ) # Note that this is triggered synchonously with the transition from # _connecting _disconnecting.upon( _connectionFailed, enter=_stopped, outputs=[_ignoreAndCancelConnectWaiters, _ignoreAndFinishStopping], ) _restarting.upon(start, enter=_restarting, outputs=[]) _restarting.upon( stop, enter=_disconnecting, outputs=[_waitForStop], collector=_firstResult ) _restarting.upon( _clientDisconnected, enter=_connecting, outputs=[_finishStopping, _connect] ) _stopped.upon(start, enter=_connecting, outputs=[_connect]) _stopped.upon( stop, enter=_stopped, outputs=[_deferredSucceededWithNone], collector=_firstResult, ) _init.upon( whenConnected, enter=_init, outputs=[_awaitingConnection], collector=_firstResult, ) _connecting.upon( whenConnected, enter=_connecting, outputs=[_awaitingConnection], collector=_firstResult, ) _waiting.upon( whenConnected, enter=_waiting, outputs=[_awaitingConnection], collector=_firstResult, ) _connected.upon( whenConnected, enter=_connected, outputs=[_currentConnection], collector=_firstResult, ) _disconnecting.upon( whenConnected, enter=_disconnecting, outputs=[_awaitingConnection], collector=_firstResult, ) _restarting.upon( whenConnected, enter=_restarting, outputs=[_awaitingConnection], collector=_firstResult, ) _stopped.upon( whenConnected, enter=_stopped, outputs=[_noConnection], collector=_firstResult ) class ClientService(service.Service): """ A L{ClientService} maintains a single outgoing connection to a client endpoint, reconnecting after a configurable timeout when a connection fails, either before or after connecting. @since: 16.1.0 """ _log = Logger() def __init__( self, endpoint, factory, retryPolicy=None, clock=None, prepareConnection=None ): """ @param endpoint: A L{stream client endpoint <interfaces.IStreamClientEndpoint>} provider which will be used to connect when the service starts. @param factory: A L{protocol factory <interfaces.IProtocolFactory>} which will be used to create clients for the endpoint. @param retryPolicy: A policy configuring how long L{ClientService} will wait between attempts to connect to C{endpoint}. @type retryPolicy: callable taking (the number of failed connection attempts made in a row (L{int})) and returning the number of seconds to wait before making another attempt. @param clock: The clock used to schedule reconnection. It's mainly useful to be parametrized in tests. If the factory is serialized, this attribute will not be serialized, and the default value (the reactor) will be restored when deserialized. @type clock: L{IReactorTime} @param prepareConnection: A single argument L{callable} that may return a L{Deferred}. It will be called once with the L{protocol <interfaces.IProtocol>} each time a new connection is made. It may call methods on the protocol to prepare it for use (e.g. authenticate) or validate it (check its health). The C{prepareConnection} callable may raise an exception or return a L{Deferred} which fails to reject the connection. A rejected connection is not used to fire an L{Deferred} returned by L{whenConnected}. Instead, L{ClientService} handles the failure and continues as if the connection attempt were a failure (incrementing the counter passed to C{retryPolicy}). L{Deferred}s returned by L{whenConnected} will not fire until any L{Deferred} returned by the C{prepareConnection} callable fire. Otherwise its successful return value is consumed, but ignored. Present Since Twisted 18.7.0 @type prepareConnection: L{callable} """ clock = _maybeGlobalReactor(clock) retryPolicy = _defaultPolicy if retryPolicy is None else retryPolicy self._machine = _ClientMachine( endpoint, factory, retryPolicy, clock, prepareConnection=prepareConnection, log=self._log, ) def whenConnected(self, failAfterFailures=None): """ Retrieve the currently-connected L{Protocol}, or the next one to connect. @param failAfterFailures: number of connection failures after which the Deferred will deliver a Failure (None means the Deferred will only fail if/when the service is stopped). Set this to 1 to make the very first connection failure signal an error. Use 2 to allow one failure but signal an error if the subsequent retry then fails. @type failAfterFailures: L{int} or None @return: a Deferred that fires with a protocol produced by the factory passed to C{__init__} @rtype: L{Deferred} that may: - fire with L{IProtocol} - fail with L{CancelledError} when the service is stopped - fail with e.g. L{DNSLookupError<twisted.internet.error.DNSLookupError>} or L{ConnectionRefusedError<twisted.internet.error.ConnectionRefusedError>} when the number of consecutive failed connection attempts equals the value of "failAfterFailures" """ return self._machine.whenConnected(failAfterFailures) def startService(self): """ Start this L{ClientService}, initiating the connection retry loop. """ if self.running: self._log.warn("Duplicate ClientService.startService {log_source}") return super().startService() self._machine.start() def stopService(self): """ Stop attempting to reconnect and close any existing connections. @return: a L{Deferred} that fires when all outstanding connections are closed and all in-progress connection attempts halted. """ super().stopService() return self._machine.stop() __all__ = [ "TimerService", "CooperatorService", "MulticastServer", "StreamServerEndpointService", "UDPServer", "ClientService", "TCPServer", "TCPClient", "UNIXServer", "UNIXClient", "SSLServer", "SSLClient", "UNIXDatagramServer", "UNIXDatagramClient", ] PK Mb�Zf��� � application/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Configuration objects for Twisted Applications. """ PK Mb�Z.{sa�# �# names/srvconnect.pynu �[��� # -*- test-case-name: twisted.names.test.test_srvconnect -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import random from zope.interface import implementer from twisted.internet import error, interfaces from twisted.names import client, dns from twisted.names.error import DNSNameError from twisted.python.compat import nativeString class _SRVConnector_ClientFactoryWrapper: def __init__(self, connector, wrappedFactory): self.__connector = connector self.__wrappedFactory = wrappedFactory def startedConnecting(self, connector): self.__wrappedFactory.startedConnecting(self.__connector) def clientConnectionFailed(self, connector, reason): self.__connector.connectionFailed(reason) def clientConnectionLost(self, connector, reason): self.__connector.connectionLost(reason) def __getattr__(self, key): return getattr(self.__wrappedFactory, key) @implementer(interfaces.IConnector) class SRVConnector: """ A connector that looks up DNS SRV records. RFC 2782 details how SRV records should be interpreted and selected for subsequent connection attempts. The algorithm for using the records' priority and weight is implemented in L{pickServer}. @ivar servers: List of candidate server records for future connection attempts. @type servers: L{list} of L{dns.Record_SRV} @ivar orderedServers: List of server records that have already been tried in this round of connection attempts. @type orderedServers: L{list} of L{dns.Record_SRV} """ stopAfterDNS = 0 def __init__( self, reactor, service, domain, factory, protocol="tcp", connectFuncName="connectTCP", connectFuncArgs=(), connectFuncKwArgs={}, defaultPort=None, ): """ @param domain: The domain to connect to. If passed as a text string, it will be encoded using C{idna} encoding. @type domain: L{bytes} or L{str} @param defaultPort: Optional default port number to be used when SRV lookup fails and the service name is unknown. This should be the port number associated with the service name as defined by the IANA registry. @type defaultPort: L{int} """ self.reactor = reactor self.service = service self.domain = None if domain is None else dns.domainString(domain) self.factory = factory self.protocol = protocol self.connectFuncName = connectFuncName self.connectFuncArgs = connectFuncArgs self.connectFuncKwArgs = connectFuncKwArgs self._defaultPort = defaultPort self.connector = None self.servers = None # list of servers already used in this round: self.orderedServers = None def connect(self): """Start connection to remote server.""" self.factory.doStart() self.factory.startedConnecting(self) if not self.servers: if self.domain is None: self.connectionFailed( error.DNSLookupError("Domain is not defined."), ) return d = client.lookupService( "_%s._%s.%s" % ( nativeString(self.service), nativeString(self.protocol), nativeString(self.domain), ), ) d.addCallbacks(self._cbGotServers, self._ebGotServers) d.addCallback(lambda x, self=self: self._reallyConnect()) if self._defaultPort: d.addErrback(self._ebServiceUnknown) d.addErrback(self.connectionFailed) elif self.connector is None: self._reallyConnect() else: self.connector.connect() def _ebGotServers(self, failure): failure.trap(DNSNameError) # Some DNS servers reply with NXDOMAIN when in fact there are # just no SRV records for that domain. Act as if we just got an # empty response and use fallback. self.servers = [] self.orderedServers = [] def _cbGotServers(self, result): answers, auth, add = result if ( len(answers) == 1 and answers[0].type == dns.SRV and answers[0].payload and answers[0].payload.target == dns.Name(b".") ): # decidedly not available raise error.DNSLookupError( "Service %s not available for domain %s." % (repr(self.service), repr(self.domain)) ) self.servers = [] self.orderedServers = [] for a in answers: if a.type != dns.SRV or not a.payload: continue self.orderedServers.append(a.payload) def _ebServiceUnknown(self, failure): """ Connect to the default port when the service name is unknown. If no SRV records were found, the service name will be passed as the port. If resolving the name fails with L{error.ServiceNameUnknownError}, a final attempt is done using the default port. """ failure.trap(error.ServiceNameUnknownError) self.servers = [dns.Record_SRV(0, 0, self._defaultPort, self.domain)] self.orderedServers = [] self.connect() def pickServer(self): """ Pick the next server. This selects the next server from the list of SRV records according to their priority and weight values, as set out by the default algorithm specified in RFC 2782. At the beginning of a round, L{servers} is populated with L{orderedServers}, and the latter is made empty. L{servers} is the list of candidates, and L{orderedServers} is the list of servers that have already been tried. First, all records are ordered by priority and weight in ascending order. Then for each priority level, a running sum is calculated over the sorted list of records for that priority. Then a random value between 0 and the final sum is compared to each record in order. The first record that is greater than or equal to that random value is chosen and removed from the list of candidates for this round. @return: A tuple of target hostname and port from the chosen DNS SRV record. @rtype: L{tuple} of native L{str} and L{int} """ assert self.servers is not None assert self.orderedServers is not None if not self.servers and not self.orderedServers: # no SRV record, fall back.. return nativeString(self.domain), self.service if not self.servers and self.orderedServers: # start new round self.servers = self.orderedServers self.orderedServers = [] assert self.servers self.servers.sort(key=lambda record: (record.priority, record.weight)) minPriority = self.servers[0].priority index = 0 weightSum = 0 weightIndex = [] for x in self.servers: if x.priority == minPriority: weightSum += x.weight weightIndex.append((index, weightSum)) index += 1 rand = random.randint(0, weightSum) for index, weight in weightIndex: if weight >= rand: chosen = self.servers[index] del self.servers[index] self.orderedServers.append(chosen) return str(chosen.target), chosen.port raise RuntimeError(f"Impossible {self.__class__.__name__} pickServer result.") def _reallyConnect(self): if self.stopAfterDNS: self.stopAfterDNS = 0 return self.host, self.port = self.pickServer() assert self.host is not None, "Must have a host to connect to." assert self.port is not None, "Must have a port to connect to." connectFunc = getattr(self.reactor, self.connectFuncName) self.connector = connectFunc( self.host, self.port, _SRVConnector_ClientFactoryWrapper(self, self.factory), *self.connectFuncArgs, **self.connectFuncKwArgs, ) def stopConnecting(self): """Stop attempting to connect.""" if self.connector: self.connector.stopConnecting() else: self.stopAfterDNS = 1 def disconnect(self): """Disconnect whatever our are state is.""" if self.connector is not None: self.connector.disconnect() else: self.stopConnecting() def getDestination(self): assert self.connector return self.connector.getDestination() def connectionFailed(self, reason): self.factory.clientConnectionFailed(self, reason) self.factory.doStop() def connectionLost(self, reason): self.factory.clientConnectionLost(self, reason) self.factory.doStop() PK Mb�Z�� }� � names/tap.pynu �[��� # -*- test-case-name: twisted.names.test.test_tap -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Domain Name Server """ import os import traceback from twisted.application import internet, service from twisted.names import authority, dns, secondary, server from twisted.python import usage class Options(usage.Options): optParameters = [ ["interface", "i", "", "The interface to which to bind"], ["port", "p", "53", "The port on which to listen"], [ "resolv-conf", None, None, "Override location of resolv.conf (implies --recursive)", ], ["hosts-file", None, None, "Perform lookups with a hosts file"], ] optFlags = [ ["cache", "c", "Enable record caching"], ["recursive", "r", "Perform recursive lookups"], ["verbose", "v", "Log verbosely"], ] compData = usage.Completions( optActions={"interface": usage.CompleteNetInterfaces()} ) zones = None zonefiles = None def __init__(self): usage.Options.__init__(self) self["verbose"] = 0 self.bindfiles = [] self.zonefiles = [] self.secondaries = [] def opt_pyzone(self, filename): """Specify the filename of a Python syntax zone definition""" if not os.path.exists(filename): raise usage.UsageError(filename + ": No such file") self.zonefiles.append(filename) def opt_bindzone(self, filename): """Specify the filename of a BIND9 syntax zone definition""" if not os.path.exists(filename): raise usage.UsageError(filename + ": No such file") self.bindfiles.append(filename) def opt_secondary(self, ip_domain): """Act as secondary for the specified domain, performing zone transfers from the specified IP (IP/domain) """ args = ip_domain.split("/", 1) if len(args) != 2: raise usage.UsageError("Argument must be of the form IP[:port]/domain") address = args[0].split(":") if len(address) == 1: address = (address[0], dns.PORT) else: try: port = int(address[1]) except ValueError: raise usage.UsageError( f"Specify an integer port number, not {address[1]!r}" ) address = (address[0], port) self.secondaries.append((address, [args[1]])) def opt_verbose(self): """Increment verbosity level""" self["verbose"] += 1 def postOptions(self): if self["resolv-conf"]: self["recursive"] = True self.svcs = [] self.zones = [] for f in self.zonefiles: try: self.zones.append(authority.PySourceAuthority(f)) except Exception: traceback.print_exc() raise usage.UsageError("Invalid syntax in " + f) for f in self.bindfiles: try: self.zones.append(authority.BindAuthority(f)) except Exception: traceback.print_exc() raise usage.UsageError("Invalid syntax in " + f) for f in self.secondaries: svc = secondary.SecondaryAuthorityService.fromServerAddressAndDomains(*f) self.svcs.append(svc) self.zones.append(self.svcs[-1].getAuthority()) try: self["port"] = int(self["port"]) except ValueError: raise usage.UsageError("Invalid port: {!r}".format(self["port"])) def _buildResolvers(config): """ Build DNS resolver instances in an order which leaves recursive resolving as a last resort. @type config: L{Options} instance @param config: Parsed command-line configuration @return: Two-item tuple of a list of cache resovers and a list of client resolvers """ from twisted.names import cache, client, hosts ca, cl = [], [] if config["cache"]: ca.append(cache.CacheResolver(verbose=config["verbose"])) if config["hosts-file"]: cl.append(hosts.Resolver(file=config["hosts-file"])) if config["recursive"]: cl.append(client.createResolver(resolvconf=config["resolv-conf"])) return ca, cl def makeService(config): ca, cl = _buildResolvers(config) f = server.DNSServerFactory(config.zones, ca, cl, config["verbose"]) p = dns.DNSDatagramProtocol(f) f.noisy = 0 ret = service.MultiService() for (klass, arg) in [(internet.TCPServer, f), (internet.UDPServer, p)]: s = klass(config["port"], arg, interface=config["interface"]) s.setServiceParent(ret) for svc in config.svcs: svc.setServiceParent(ret) return ret PK Mb�Z�UG�z! z! * names/__pycache__/_rfc1982.cpython-310.pycnu �[��� o �b�# � @ sR d Z ddlZddlmZmZ ddlmZ ddlmZ dZG dd� de�Z dgZ dS ) a� Utilities for handling RFC1982 Serial Number Arithmetic. @see: U{http://tools.ietf.org/html/rfc1982} @var RFC4034_TIME_FORMAT: RRSIG Time field presentation format. The Signature Expiration Time and Inception Time field values MUST be represented either as an unsigned decimal integer indicating seconds since 1 January 1970 00:00:00 UTC, or in the form YYYYMMDDHHmmSS in UTC. See U{RRSIG Presentation Format<https://tools.ietf.org/html/rfc4034#section-3.2>} � N)�datetime� timedelta)� nativeString)� FancyStrMixinz %Y%m%d%H%M%Sc @ s� e Zd ZdZdZd!dd�Zdedd fdd �Zdefd d �Z d d � Z dede fdd�Z dede fdd�Z dede fdd�Zdede fdd�Zdede fdd�Zdedd fdd�Zdd� Zed d � �Zd d � Zd S )"� SerialNumbera� An RFC1982 Serial Number. This class implements RFC1982 DNS Serial Number Arithmetic. SNA is used in DNS and specifically in DNSSEC as defined in RFC4034 in the DNSSEC Signature Expiration and Inception Fields. @see: U{https://tools.ietf.org/html/rfc1982} @see: U{https://tools.ietf.org/html/rfc4034} @ivar _serialBits: See C{serialBits} of L{__init__}. @ivar _number: See C{number} of L{__init__}. @ivar _modulo: The value at which wrapping will occur. @ivar _halfRing: Half C{_modulo}. If another L{SerialNumber} value is larger than this, it would lead to a wrapped value which is larger than the first and comparisons are therefore ambiguous. @ivar _maxAdd: Half C{_modulo} plus 1. If another L{SerialNumber} value is larger than this, it would lead to a wrapped value which is larger than the first. Comparisons with the original value would therefore be ambiguous. ))�_number�number�%d)� _serialBits� serialBitsr � c C sD || _ d| | _d|d | _d|d d | _t|�| j | _dS )a� Construct an L{SerialNumber} instance. @param number: An L{int} which will be stored as the modulo C{number % 2 ^ serialBits} @type number: L{int} @param serialBits: The size of the serial number space. The power of two which results in one larger than the largest integer corresponding to a serial number value. @type serialBits: L{int} � � N)r �_modulo� _halfRing�_maxAdd�intr )�selfr r � r �8/usr/lib/python3/dist-packages/twisted/names/_rfc1982.py�__init__8 s zSerialNumber.__init__�other�returnc C s> t |t�std| �d|����| j|jkr td| |f ��|S )a} Check that a foreign object is suitable for use in the comparison or arithmetic magic methods of this L{SerialNumber} instance. Raise L{TypeError} if not. @param other: The foreign L{object} to be checked. @return: C{other} after compatibility checks and possible coercion. @raise TypeError: If C{other} is not compatible. zcannot compare or combine z and zUcannot compare or combine SerialNumber instances with different serialBits. %r and %r)� isinstancer � TypeErrorr �r r r r r � _convertOtherK s ��zSerialNumber._convertOtherc C s t d| jf �S )zs Return a string representation of this L{SerialNumber} instance. @rtype: L{nativeString} r )r r �r r r r �__str__` s zSerialNumber.__str__c C s | j S )ze @return: The integer value of this L{SerialNumber} instance. @rtype: L{int} )r r r r r �__int__h s zSerialNumber.__int__c C s2 z| � |�}W n ty t Y S w |j| jkS )zW Allow rich equality comparison with another L{SerialNumber} instance. )r r �NotImplementedr r r r r �__eq__o s � zSerialNumber.__eq__c C sb z| � |�}W n ty t Y S w | j|jk o!|j| j | jk p0| j|jko0| j|j | jkS )zV Allow I{less than} comparison with another L{SerialNumber} instance. �r r r r r r r r r �__lt__y � � � �zSerialNumber.__lt__c C sb z| � |�}W n ty t Y S w | j|jk o!|j| j | jkp0| j|jko0| j|j | jk S )zY Allow I{greater than} comparison with another L{SerialNumber} instance. r" r r r r �__gt__� r$ zSerialNumber.__gt__c C s6 z| � |�}W n ty t Y S w | |kp| |k S )zg Allow I{less than or equal} comparison with another L{SerialNumber} instance. �r r r r r r r �__le__� � �zSerialNumber.__le__c C s6 z| � |�}W n ty t Y S w | |kp| |kS )zj Allow I{greater than or equal} comparison with another L{SerialNumber} instance. r& r r r r �__ge__� r( zSerialNumber.__ge__c C sb z| � |�}W n ty t Y S w |j| jkr't| j|j | j | jd�S td|j| jf ��)ab Allow I{addition} with another L{SerialNumber} instance. Serial numbers may be incremented by the addition of a positive integer n, where n is taken from the range of integers [0 .. (2^(SERIAL_BITS - 1) - 1)]. For a sequence number s, the result of such an addition, s', is defined as s' = (s + n) modulo (2 ^ SERIAL_BITS) where the addition and modulus operations here act upon values that are non-negative values of unbounded size in the usual ways of integer arithmetic. Addition of a value outside the range [0 .. (2^(SERIAL_BITS - 1) - 1)] is undefined. @see: U{http://tools.ietf.org/html/rfc1982#section-3.1} @raise ArithmeticError: If C{other} is more than C{_maxAdd} ie more than half the maximum value of this serial number. �r z"value %r outside the range 0 .. %r) r r r r r r r r �ArithmeticErrorr r r r �__add__� s" � ����zSerialNumber.__add__c C s t | j�S )zo Allow L{SerialNumber} instances to be hashed for use as L{dict} keys. @rtype: L{int} )�hashr r r r r �__hash__� s zSerialNumber.__hash__c C s& t �|t�}t�|�� �}| |dd�S )a� Create an L{SerialNumber} instance from a date string in format 'YYYYMMDDHHMMSS' described in U{RFC4034 3.2<https://tools.ietf.org/html/rfc4034#section-3.2>}. The L{SerialNumber} instance stores the date as a 32bit UNIX timestamp. @see: U{https://tools.ietf.org/html/rfc4034#section-3.1.5} @param utcDateString: A UTC date/time string of format I{YYMMDDhhmmss} which will be converted to seconds since the UNIX epoch. @type utcDateString: L{unicode} @return: An L{SerialNumber} instance containing the supplied date as a 32bit UNIX timestamp. r r* )r �strptime�RFC4034_TIME_FORMAT�calendar�timegm� utctimetuple)�cls� utcDateString� parsedDate�secondsSinceEpochr r r �fromRFC4034DateString� s z"SerialNumber.fromRFC4034DateStringc C s& t ddd�t| jd� }t|�t��S )a Calculate a date by treating the current L{SerialNumber} value as a UNIX timestamp and return a date string in the format described in U{RFC4034 3.2<https://tools.ietf.org/html/rfc4034#section-3.2>}. @return: The date string. i� r )�seconds)r r r r �strftimer0 )r �dr r r �toRFC4034DateString� s z SerialNumber.toRFC4034DateStringN)r )�__name__� __module__� __qualname__�__doc__�showAttributesr �objectr �strr r �boolr! r# r% r' r) r, r. � classmethodr8 r< r r r r r s" ) r ) r@ r1 r r �twisted.python.compatr �twisted.python.utilr r0 r �__all__r r r r �<module> s kPK Mb�Z��8Q� � + names/__pycache__/secondary.cpython-310.pycnu �[��� o �b� � @ s� d dgZ ddlmZ ddlmZmZ ddlmZmZm Z m Z ddl m Z ddl mZmZ ddlmZ G d d� dej�ZG d d � d e �Zd S ) �SecondaryAuthority�SecondaryAuthorityService� )�service)�defer�task)�client�common�dns�resolve)� FileAuthority)�failure�log)� nativeStringc @ sD e Zd ZdZdZdZdd� Zedd� �Zdd � Z d d � Z d d � Z dS )r a: A service that keeps one or more authorities up to date by doing hourly zone transfers from a master. @ivar primary: IP address of the master. @type primary: L{str} @ivar domains: An authority for each domain mirrored from the master. @type domains: L{list} of L{SecondaryAuthority} N�5 c s" t � �| _� fdd�|D �| _dS )a @param primary: The IP address of the server from which to perform zone transfers. @type primary: L{str} @param domains: A sequence of domain names for which to perform zone transfers. @type domains: L{list} of L{bytes} c s g | ]}t � |��qS � )r ��.0�d��primaryr �9/usr/lib/python3/dist-packages/twisted/names/secondary.py� <listcomp>+ s z6SecondaryAuthorityService.__init__.<locals>.<listcomp>N)r r �domains)�selfr r r r r �__init__ s z"SecondaryAuthorityService.__init__c s0 � \}}| |g �}||_ � fdd�|D �|_|S )a� Construct a new L{SecondaryAuthorityService} from a tuple giving a server address and a C{str} giving the name of a domain for which this is an authority. @param serverAddress: A two-tuple, the first element of which is a C{str} giving an IP address and the second element of which is a C{int} giving a port number. Together, these define where zone transfers will be attempted from. @param domains: Domain names for which to perform zone transfers. @type domains: sequence of L{bytes} @return: A new instance of L{SecondaryAuthorityService}. c s g | ]}t �� |��qS r )r �fromServerAddressAndDomainr �� serverAddressr r r A s ��zISecondaryAuthorityService.fromServerAddressAndDomains.<locals>.<listcomp>)�_portr )�clsr r r �portr r r r �fromServerAddressAndDomains- s �z5SecondaryAuthorityService.fromServerAddressAndDomainsc C s t �| j�S )z_ Get a resolver for the transferred domains. @rtype: L{ResolverChain} )r � ResolverChainr �r r r r � getAuthorityG s z&SecondaryAuthorityService.getAuthorityc C sV t j�| � dd� | jD �| _d}ddlm} | jD ]}|�||jd� |d7 }qd S )Nc S s g | ]}t �|j��qS r )r � LoopingCall�transferr r r r r Q s z:SecondaryAuthorityService.startService.<locals>.<listcomp>r ��reactori � ) r �Service� startServicer �calls�twisted.internetr( � callLater�start)r �ir( �cr r r r+ O s �z&SecondaryAuthorityService.startServicec C s$ t j�| � | jD ]}|�� q d S �N)r r* � stopServicer, �stop)r r1 r r r r3 Z s �z%SecondaryAuthorityService.stopService) �__name__� __module__� __qualname__�__doc__r, r r � classmethodr! r$ r+ r3 r r r r r s c @ sr e Zd ZdZdZd ZZdZdZdd� Z e dd� �Z d d � Z dd d �Z d d� Zdd� Zdd� Zdd� Zdd� ZdS )r a An Authority that keeps itself updated by performing zone transfers. @ivar primary: The IP address of the server from which zone transfers will be attempted. @type primary: L{str} @ivar _port: The port number of the server from which zone transfers will be attempted. @type _port: L{int} @ivar domain: The domain for which this is the secondary authority. @type domain: L{bytes} @ivar _reactor: The reactor to use to perform the zone transfers, or L{None} to use the global reactor. FNr c C s& t j�| � t|�| _t�|�| _dS )z� @param domain: The domain for which this will be the secondary authority. @type domain: L{bytes} or L{str} N)r � ResolverBaser r r r � domainString�domain)r � primaryIPr< r r r r x s zSecondaryAuthority.__init__c C s |\}}| ||�}||_ |S )af Construct a new L{SecondaryAuthority} from a tuple giving a server address and a C{bytes} giving the name of a domain for which this is an authority. @param serverAddress: A two-tuple, the first element of which is a C{str} giving an IP address and the second element of which is a C{int} giving a port number. Together, these define where zone transfers will be attempted from. @param domain: A C{bytes} giving the domain to transfer. @type domain: L{bytes} @return: A new instance of L{SecondaryAuthority}. )r )r r r< r r � secondaryr r r r � s z-SecondaryAuthority.fromServerAddressAndDomainc C s^ | j rdS d| _| j}|du rddlm} tj| j| jfg|d�}|� | j �� | j �� | j�S )z� Attempt a zone transfer. @returns: A L{Deferred} that fires with L{None} when attempted zone transfer has completed. NTr r' )�serversr( )� transferring� transfering�_reactorr- r( r �Resolverr r � lookupZoner< � addCallback�_cbZone� addErrback�_ebZone)r r( �resolverr r r r& � s � �zSecondaryAuthority.transferc C s4 | j r| jst�t�t�|���S t� | ||||�S r2 ) �soa�recordsr �failr �Failurer � DomainErrorr �_lookup)r �namer �type�timeoutr r r rO � s zSecondaryAuthority._lookupc C sf |\}}}i | _ }|D ]$}| js"|jtjkr"|jj�� |jf| _q |�|jj�� g �� |j� q d S r2 ) rK rJ rQ r �SOArP �lower�payload� setdefault�append)r �zone�ans�_�r�recr r r rF � s �zSecondaryAuthority._cbZonec C s$ t �d| j| jf � t �|� d S )Nz/Updating %s from %s failed during zone transfer)r �msgr< r �err�r r r r r rH � s ��zSecondaryAuthority._ebZonec C s | � � �| j| j� d S r2 )r& � addCallbacks�_cbTransferred�_ebTransferredr# r r r �update� s zSecondaryAuthority.updatec C s d| _ d S )NF)r@ )r �resultr r r ra � s z!SecondaryAuthority._cbTransferredc C s* d| _ t�d| j| jf � t�|� d S )NFz2Transferring %s from %s failed after zone transfer)� transferredr r] r< r r^ r_ r r r rb � s ��z!SecondaryAuthority._ebTransferredr2 )r5 r6 r7 r8 r@ rJ rK r rB r r9 r r& rO rF rH rc ra rb r r r r r ` s N)�__all__�twisted.applicationr r- r r � twisted.namesr r r r �twisted.names.authorityr �twisted.pythonr r �twisted.python.compatr r* r r r r r r �<module> s PPK Mb�ZER\w�R �R ( names/__pycache__/server.cpython-310.pycnu �[��� o �b�V � @ sJ d Z ddlZddlmZ ddlmZmZ ddlmZ G dd� dej �Z dS )a` Async DNS server Future plans: - Better config file format maybe - Make sure to differentiate between different classes - notice truncation bit Important: No additional processing is done on some of the record types. This violates the most basic RFC and is just plain annoying for resolvers to deal with. Fix it. @author: Jp Calderone � N)�protocol)�dns�resolve)�logc @ s� e Zd ZdZejZdZejZ d$dd�Z dd� Z dd � Z d d � Z d d � Zdd� Zejdddfdd�Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd%d d!�Zd"d#� ZdS )&�DNSServerFactorya Server factory and tracker for L{DNSProtocol} connections. This class also provides records for responses to DNS queries. @ivar cache: A L{Cache<twisted.names.cache.CacheResolver>} instance whose C{cacheResult} method is called when a response is received from one of C{clients}. Defaults to L{None} if no caches are specified. See C{caches} of L{__init__} for more details. @type cache: L{Cache<twisted.names.cache.CacheResolver>} or L{None} @ivar canRecurse: A flag indicating whether this server is capable of performing recursive DNS resolution. @type canRecurse: L{bool} @ivar resolver: A L{resolve.ResolverChain} containing an ordered list of C{authorities}, C{caches} and C{clients} to which queries will be dispatched. @type resolver: L{resolve.ResolverChain} @ivar verbose: See L{__init__} @ivar connections: A list of all the connected L{DNSProtocol} instances using this object as their controller. @type connections: C{list} of L{DNSProtocol} instances @ivar protocol: A callable used for building a DNS stream protocol. Called by L{DNSServerFactory.buildProtocol} and passed the L{DNSServerFactory} instance as the one and only positional argument. Defaults to L{dns.DNSProtocol}. @type protocol: L{IProtocolFactory} constructor @ivar _messageFactory: A response message constructor with an initializer signature matching L{dns.Message.__init__}. @type _messageFactory: C{callable} Nr c C sn g }|dur |� |� |dur|� |� |dur |� |� | | _t�|�| _|| _|r2|d | _g | _dS )a� @param authorities: Resolvers which provide authoritative answers. @type authorities: L{list} of L{IResolver} providers @param caches: Resolvers which provide cached non-authoritative answers. The first cache instance is assigned to C{DNSServerFactory.cache} and its C{cacheResult} method will be called when a response is received from one of C{clients}. @type caches: L{list} of L{Cache<twisted.names.cache.CacheResolver>} instances @param clients: Resolvers which are capable of performing recursive DNS lookups. @type clients: L{list} of L{IResolver} providers @param verbose: An integer controlling the verbosity of logging of queries and responses. Default is C{0} which means no logging. Set to C{2} to enable logging of full query and response messages. @type verbose: L{int} N���)�extend� canRecurser � ResolverChain�resolver�verbose�cache� connections)�self� authorities�caches�clientsr � resolvers� r �6/usr/lib/python3/dist-packages/twisted/names/server.py�__init__E s zDNSServerFactory.__init__c O s" | j dkrtj|i |�� dS dS )z� Log a message only if verbose logging is enabled. @param args: Positional arguments which will be passed to C{log.msg} @param kwargs: Keyword arguments which will be passed to C{log.msg} r N)r r �msg)r �args�kwargsr r r � _verboseLogh s �z DNSServerFactory._verboseLogc C s | � | �}| |_|S �N)r �factory)r �addr�pr r r � buildProtocolr s z DNSServerFactory.buildProtocolc C � | j �|� dS )z� Track a newly connected L{DNSProtocol}. @param protocol: The protocol instance to be tracked. @type protocol: L{dns.DNSProtocol} N)r �append�r r r r r �connectionMadew s z DNSServerFactory.connectionMadec C r )z� Stop tracking a no-longer connected L{DNSProtocol}. @param protocol: The tracked protocol instance to be which has been lost. @type protocol: L{dns.DNSProtocol} N)r �remover" r r r �connectionLost� s z DNSServerFactory.connectionLostc C s� | j dkrCd�dd� |jD ��}d�dd� |jD ��}d�dd� |jD ��}|s.t�d� nt�d| � t�d | � t�d | � |d u rM|�|� n|�||� | �d t � � |j � d S ) a] Send a response C{message} to a given C{address} via the supplied C{protocol}. Message payload will be logged if C{DNSServerFactory.verbose} is C{>1}. @param protocol: The DNS protocol instance to which to send the message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The DNS message to be sent. @type message: L{dns.Message} @param address: The address to which the message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} � � c S � g | ]}t |j��qS r ��str�payload��.0�ar r r � <listcomp>� � z.DNSServerFactory.sendReply.<locals>.<listcomp>c S r( r r) r, r r r r/ � r0 c S r( r r) r, r r r r/ � r0 zReplying with no answersz Answers are z Authority is zAdditional is Nz Processed query in %0.3f seconds) r �join�answers� authority� additionalr r � writeMessager �time� timeReceived)r r �message�address�s�auth�addr r r � sendReply� s �zDNSServerFactory.sendReplyc C s� |du rg }|du r g }|du rg }d}|D ] }|� � r d} nqtj| j|| j||d�}t|dd�|_|j|_||_||_ ||_ |S )a+ Generate a L{Message} instance suitable for use as the response to C{message}. C{queries} will be copied from the request to the response. C{rCode}, C{answers}, C{authority} and C{additional} will be assigned to the response, if supplied. The C{recAv} flag will be set on the response if the C{canRecurse} flag on this L{DNSServerFactory} is set to L{True}. The C{auth} flag will be set on the response if *any* of the supplied C{answers} have their C{auth} flag set to L{True}. The response will have the same C{maxSize} as the request. Additionally, the response will have a C{timeReceived} attribute whose value is that of the original request and the @see: L{dns._responseFromMessage} @param message: The request message @type message: L{Message} @param rCode: The response code which will be assigned to the response. @type message: L{int} @param answers: An optional list of answer records which will be assigned to the response. @type answers: L{list} of L{dns.RRHeader} @param authority: An optional list of authority records which will be assigned to the response. @type authority: L{list} of L{dns.RRHeader} @param additional: An optional list of additional records which will be assigned to the response. @type additional: L{list} of L{dns.RRHeader} @return: A response L{Message} instance. @rtype: L{Message} NFT)�responseConstructorr8 �recAv�rCoder; r7 ) �isAuthoritativer �_responseFromMessage�_messageFactoryr �getattrr7 �maxSizer2 r3 r4 ) r r8 r@ r2 r3 r4 �authoritativeAnswer�x�responser r r rB � s2 .�� z%DNSServerFactory._responseFromMessagec C s� |\}}}| j |tj|||d�}| �|||� t|�t|� t|� }| �d||dkr-dp.df � | jrF|rH| j�|jd |||f� dS dS dS )a� A callback used by L{DNSServerFactory.handleQuery} for handling the deferred response from C{self.resolver.query}. Constructs a response message by combining the original query message with the resolved answer, authority and additional records. Marks the response message as authoritative if any of the resolved answers are found to be authoritative. The resolved answers count will be logged if C{DNSServerFactory.verbose} is C{>1}. @param response: Answer records, authority records and additional records @type response: L{tuple} of L{list} of L{dns.RRHeader} instances @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} )r8 r@ r2 r3 r4 zLookup found %d record%sr& r: � r N) rB r �OKr= �lenr r � cacheResult�queries) r rH r r8 r9 �ansr; r< �lr r r �gotResolverResponse s � �z$DNSServerFactory.gotResolverResponsec C sR |� tjtj�r tj}ntj}t�|� | j||d�}| � |||� | � d� dS )a A callback used by L{DNSServerFactory.handleQuery} for handling deferred errors from C{self.resolver.query}. Constructs a response message from the original query message by assigning a suitable error code to C{rCode}. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. @param failure: The reason for the failed resolution (as reported by C{self.resolver.query}). @type failure: L{Failure<twisted.python.failure.Failure>} @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} )r8 r@ z Lookup failedN) �checkr � DomainError�AuthoritativeDomainError�ENAME�ESERVERr �errrB r= r )r �failurer r8 r9 r@ rH r r r �gotResolverError* s z!DNSServerFactory.gotResolverErrorc C s2 |j d }| j�|��| j|||��| j|||�S )a` Called by L{DNSServerFactory.messageReceived} when a query message is received. Takes the first query from the received message and dispatches it to C{self.resolver.query}. Adds callbacks L{DNSServerFactory.gotResolverResponse} and L{DNSServerFactory.gotResolverError} to the resulting deferred. Note: Multiple queries in a single message are not supported because there is no standard way to respond with multiple rCodes, auth, etc. This is consistent with other DNS server implementations. See U{http://tools.ietf.org/html/draft-ietf-dnsext-edns1-03} for a proposed solution. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} @return: A C{deferred} which fires with the resolved result or error of the first query in C{message}. @rtype: L{Deferred<twisted.internet.defer.Deferred>} r )rM r �query� addCallbackrP � addErrbackrX )r r8 r r9 rY r r r � handleQueryO s ! �z DNSServerFactory.handleQueryc C �* t j|_| �|||� | �d|��� dS )a# Called by L{DNSServerFactory.messageReceived} when an inverse query message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} zInverse query from N�r �ENOTIMPr@ r= r �r r8 r r9 r r r �handleInverseQueryx � z#DNSServerFactory.handleInverseQueryc C r] )a Called by L{DNSServerFactory.messageReceived} when a status message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} zStatus request from Nr^ r` r r r � handleStatus� rb z DNSServerFactory.handleStatusc C r] )a Called by L{DNSServerFactory.messageReceived} when a notify message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} zNotify message from Nr^ r` r r r � handleNotify� rb z DNSServerFactory.handleNotifyc C s. t j|_| �|||� | �d|j|f � dS )a0 Called by L{DNSServerFactory.messageReceived} when a message with unrecognised I{OPCODE} is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} z Unknown op code (%d) from %rN)r r_ r@ r= r �opCoder` r r r � handleOther� s z DNSServerFactory.handleOtherc C s< t � � |_| jrE| jdkrd�dd� |jD ��}n d�dd� |jD ��}t|�s6t�d|p1|j� � ��� nt�|� d|pA|j� � ��� | � |||�sYt j |_ | �|||� dS |jt jkrh| �|||� dS |jt jkrw| �|||� dS |jt jkr�| �|||� dS |jt jkr�| �|||� dS | �|||� dS ) a� L{DNSServerFactory.messageReceived} is called by protocols which are under the control of this L{DNSServerFactory} whenever they receive a DNS query message or an unexpected / duplicate / late DNS response message. L{DNSServerFactory.allowQuery} is called with the received message, protocol and origin address. If it returns L{False}, a C{dns.EREFUSED} response is sent back to the client. Otherwise the received message is dispatched to one of L{DNSServerFactory.handleQuery}, L{DNSServerFactory.handleInverseQuery}, L{DNSServerFactory.handleStatus}, L{DNSServerFactory.handleNotify}, or L{DNSServerFactory.handleOther} depending on the I{OPCODE} of the received message. If C{DNSServerFactory.verbose} is C{>0} all received messages will be logged in more or less detail depending on the value of C{verbose}. @param message: The DNS message that was received. @type message: L{dns.Message} @param proto: The DNS protocol instance which received the message @type proto: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param address: The address from which the message was received. Only provided for messages received by datagram protocols. The origin of Messages received from stream protocols can be gleaned from the protocol C{transport} attribute. @type address: L{tuple} or L{None} r& r' c S s g | ]}t |��qS r )r* �r- �qr r r r/ s z4DNSServerFactory.messageReceived.<locals>.<listcomp>c S s g | ] }t j�|jd ��qS )�UNKNOWN)r � QUERY_TYPES�get�typerg r r r r/ s zEmpty query from z query from N)r6 r7 r r1 rM rK r r � transport�getPeer� allowQueryr �EREFUSEDr@ r= re �OP_QUERYr\ � OP_INVERSEra � OP_STATUSrc � OP_NOTIFYrd rf )r r8 �protor9 r: r r r �messageReceived� s, � z DNSServerFactory.messageReceivedc C s t |j�S )a� Called by L{DNSServerFactory.messageReceived} to decide whether to process a received message or to reply with C{dns.EREFUSED}. This default implementation permits anything but empty queries. Override in a subclass to implement alternative policies. @param message: The DNS message that was received. @type message: L{dns.Message} @param protocol: The DNS protocol instance which received the message @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param address: The address from which the message was received. Only provided for messages received by datagram protocols. The origin of Messages received from stream protocols can be gleaned from the protocol C{transport} attribute. @type address: L{tuple} or L{None} @return: L{True} if the received message contained one or more queries, else L{False}. @rtype: L{bool} )rK rM r` r r r ro s zDNSServerFactory.allowQuery)NNNr r )�__name__� __module__� __qualname__�__doc__r � DNSProtocolr r �MessagerC r r r r# r% r= rJ rB rP rX r\ ra rc rd rf rv ro r r r r r s, % # & �R)%) <r ) rz r6 �twisted.internetr � twisted.namesr r �twisted.pythonr � ServerFactoryr r r r r �<module> s PK Mb�ZKG�&� � * names/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z7 Twisted Names: DNS server and client implementations. N)�__doc__� r r �8/usr/lib/python3/dist-packages/twisted/names/__init__.py�<module> s PK Mb�Z3Qb�V �V ( names/__pycache__/client.cpython-310.pycnu �[��� o �b�_ � @ s d Z ddlZddlZddlZddlmZ ddlmZmZm Z m Z ddl m Z ddl mZmZmZmZmZmZ ddlmZmZ ddlmZ dd lmZ dd l m Z ee j � G d d � d ej �Z G d d� d�Z!ddl"m#Z$ G dd� de$�Z#G dd� de j%�Z&dKdd�Z'da(dd� Z)dLdd�Z*dMdd �Z+dMd d �Z,dMd d �Z-dMd!d"�Z.dMd#d$�Z/dMd%d&�Z0dMd'd(�Z1dMd)d*�Z2dMd+d,�Z3dMd-d.�Z4dMd/d0�Z5dMd1d2�Z6dMd3d4�Z7dMd5d6�Z8dMd7d8�Z9dMd9d:�Z:dMd;d<�Z;dMd=d>�Z<dMd?d@�Z=dMdAdB�Z>dMdCdD�Z?dMdEdF�Z@dMdGdH�ZAdMdIdJ�ZBdS )Na� Asynchronous client DNS The functions exposed in this module can be used for asynchronous name resolution and dns queries. If you need to create a resolver with specific requirements, such as needing to do queries against a particular host, the L{createResolver} function will return an C{IResolver}. Future plans: Proper nameserver acquisition on Windows/MacOS, better caching, respect timeouts � N)�moduleProvides)�defer�error� interfaces�protocol)� isIPv6Address)�cache�common�dns�hosts�resolve�root)�failure�log)� nativeString)�FilePath)�platformc @ s� e Zd ZdZdZdZdZdZdZdZ dZ dZ dZ dZ d1dd�Zd d � Zd d � Zd d� Zdd� Zdd� Zdd� Zd2dd�Zdd� Zdd� Zd3d d �Zd d � Zd3d d!�Zd"d#� Zd4d%d&�Z d'd(� Z d)d*� Z d4d+d,�Z d-d.� Z d/d0� Z!dS )5�Resolvera� @ivar _waiting: A C{dict} mapping tuple keys of query name/type/class to Deferreds which will be called back with the result of those queries. This is used to avoid issuing the same query more than once in parallel. This is more efficient on the network and helps avoid a "birthday paradox" attack by keeping the number of outstanding requests for a particular query fixed at one instead of allowing the attacker to raise it to an arbitrary number. @ivar _reactor: A provider of L{IReactorTCP}, L{IReactorUDP}, and L{IReactorTime} which will be used to set up network resources and track timeouts. r N� �< �� � � �- c C s� t j�| � |du rddlm} || _|| _|du r g | _n|| _|| _t | j�s/|s/t d��t | |�| _ d| j _ g | _g | _i | _| �� dS )a� Construct a resolver which will query domain name servers listed in the C{resolv.conf(5)}-format file given by C{resolv} as well as those in the given C{servers} list. Servers are queried in a round-robin fashion. If given, C{resolv} is periodically checked for modification and re-parsed if it is noticed to have changed. @type servers: C{list} of C{(str, int)} or L{None} @param servers: If not None, interpreted as a list of (host, port) pairs specifying addresses of domain name servers to attempt to use for this lookup. Host addresses should be in IPv4 dotted-quad form. If specified, overrides C{resolv}. @type resolv: C{str} @param resolv: Filename to read and parse as a resolver(5) configuration file. @type timeout: Sequence of C{int} @param timeout: Default number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @param reactor: A provider of L{IReactorTime}, L{IReactorUDP}, and L{IReactorTCP} which will be used to establish connections, listen for DNS datagrams, and enforce timeouts. If not provided, the global reactor will be used. @raise ValueError: Raised if no nameserver addresses can be found. Nr ��reactorzNo nameservers specified)r � ResolverBase�__init__�twisted.internetr �_reactor�timeout�servers�resolv�len� ValueError�DNSClientFactory�factory�noisy� connections�pending�_waiting�maybeParseConfig)�selfr# r" r! r r r �6/usr/lib/python3/dist-packages/twisted/names/client.pyr B s" zResolver.__init__c C s | j �� }g |d< d |d< |S )Nr) � _parseCall)�__dict__�copy)r- �dr r r. � __getstate__| s zResolver.__getstate__c C s | j �|� | �� d S �N)r0 �updater, )r- �stater r r. � __setstate__� s zResolver.__setstate__c C s t |��� S )zr Wrapper used for opening files in the class, exists primarily for unit testing purposes. )r �open)r- �pathr r r. � _openFile� s zResolver._openFilec C s� | j d u rd S z| �| j �}W n ty. } z|jtjkr#| �d� n� W Y d }~n5d }~ww |�& t�|�� �j }|| j krPt � | j � d�� || _ | �|� W d � n1 sZw Y | j �| j| j�| _d S )Nr z changed, reparsing)r# r: �OSError�errno�ENOENT� parseConfig�os�fstat�fileno�st_mtime�_lastResolvTimer �msgr � callLater�_resolvReadIntervalr, r/ )r- � resolvConf�e�mtimer r r. r, � s, ��� � � �zResolver.maybeParseConfigc C s� g }|D ]U}|� � }|�d�r)t|�� d �tjf}|�|� t�d|�d�� q|�d�rHz |�� d | _ W n t yC d| _ Y nw d | _ q|�d�rY|�� dd � | _ d | _ q|sd|�dtjf� || _ d S ) Ns nameserverr zResolver added z to server lists domain� s search� 127.0.0.1) �strip� startswithr �splitr �PORT�appendr rD �domain� IndexError�search� dynServers)r- rG r" �L�resolverr r r. r> � s* � � zResolver.parseConfigc C sj | j s| jsdS t| j �}t| j�}| jd7 _| j|| ; _| j|k r-| j | j S | j| j| S )z� Return the address of a nameserver. TODO: Weight servers for response time so faster ones can be preferred. Nr )r" rT r$ �index)r- �serverL�dynLr r r. � pickServer� s zResolver.pickServer� c C s� d}t j| | jd�} z| jjt �� ||d� W |S tjyC } z |d7 }t|jd�r4|jj t j kr4� |dkr9� W Y d}~nd}~ww q ) zg Return a new L{DNSDatagramProtocol} bound to a randomly selected port number. r r T�� interfacer r< i� N) r �DNSDatagramProtocolr � listenUDP� randomSourcer �CannotListenError�hasattr� socketErrorr< �EMFILE)r- r] �failures�protorH r r r. �_connectedProtocol� s$ � � ����zResolver._connectedProtocolc C s@ | j �|� | jD ]\}}}| �||��|� q | jdd�= dS )zV Called by associated L{dns.DNSProtocol} instances when they connect. N)r) rP r* �queryTCP� chainDeferred)r- r r2 �q�tr r r. �connectionMade� s zResolver.connectionMadec C s || j v r | j �|� dS dS )zY Called by associated L{dns.DNSProtocol} instances when they disconnect. N)r) �remove�r- r r r r. �connectionLost� s �zResolver.connectionLostc C s t �d|j|f � d S )Nz(Unexpected message (%d) received from %r)r rD �id)r- �messager �addressr r r. �messageReceived� s zResolver.messageReceivedc sJ t |d d �r| jdd�� n| �� � � j|� }� fdd�}|�|� |S )a� Get a new L{DNSDatagramProtocol} instance from L{_connectedProtocol}, issue a query to it using C{*args}, and arrange for it to be disconnected from its transport after the query completes. @param args: Positional arguments to be passed to L{DNSDatagramProtocol.query}. @return: A L{Deferred} which will be called back with the result of the query. r z::r\ c s � j �� | S r4 )� transport� stopListening)�result�r r r. � cbQueried s z"Resolver._query.<locals>.cbQueried)r rg �query�addBoth)r- �argsr2 rx r rw r. �_query� s zResolver._queryc C sl |du r| j }| jt| j� }|st�td��S |�� |�� }| � |||d �}|� | j ||g||� |S )a� Make a number of DNS queries via UDP. @type queries: A C{list} of C{dns.Query} instances @param queries: The queries to make. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @rtype: C{Deferred} @raise C{twisted.internet.defer.TimeoutError}: When the query times out. N� No domain name servers availabler ) r! r" �listrT r �fail�IOError�reverse�popr| � addErrback�_reissue)r- �queriesr! � addresses�usedr2 r r r. �queryUDP s zResolver.queryUDPc C s� |� tj� |s|}|�� g }|dd � }|s t�t�|��S |�� }|� |� | � |||d |j j �}|� | j||||� |S )Nr r )�trapr �DNSQueryTimeoutErrorr� r �Failurer � TimeoutErrorr� rP r| �valuerp r� r� )r- �reason� addressesLeft� addressesUsedry r! rr r2 r r r. r� 7 s zResolver._reissue� c C sx t | j�s3| �� }|du rt�td��S |\}}| j�||| j� | j � t� � ||f� | j d d S | jd � ||�S )a) Make a number of DNS queries via TCP. @type queries: Any non-zero number of C{dns.Query} instances @param queries: The queries to make. @type timeout: C{int} @param timeout: The number of seconds after which to fail. @rtype: C{Deferred} Nr} ���r ) r$ r) rZ r r r� r � connectTCPr' r* rP �Deferredry )r- r� r! rr �host�portr r r. rh T s zResolver.queryTCPc C sL |j r | �|j��| j�S |jtjkr t� | � |j�|��S |j |j |j fS )a� Extract results from the given message. If the message was truncated, re-attempt the query over TCP and return a Deferred which will fire with the results of that query. If the message's result code is not C{twisted.names.dns.OK}, return a Failure indicating the type of error which occurred. Otherwise, return a three-tuple of lists containing the results from the answers section, the authority section, and the additional section. )�truncrh r� � addCallback� filterAnswers�rCoder �OKr r� �exceptionForCode�answers� authority� additional)r- rq r r r. r� k s zResolver.filterAnswersc s~ |||f� �j �� �}|du r4g �j � < ��t�|||�g|�}� �fdd�}|��j� |�|� |S t� � }|� |� |S )aZ Build a L{dns.Query} for the given parameters and dispatch it via UDP. If this query is already outstanding, it will not be re-issued. Instead, when the outstanding query receives a response, that response will be re-used for this query as well. @type name: C{str} @type type: C{int} @type cls: C{int} @return: A L{Deferred} which fires with a three-tuple giving the answer, authority, and additional sections of the response or with a L{Failure} if the response code is anything other than C{dns.OK}. Nc s �j �� �D ]}|�| � q| S r4 )r+ r� �callback)rv r2 ��keyr- r r. �cbResult� s z"Resolver._lookup.<locals>.cbResult) r+ �getr� r �Queryr� r� rz r r� rP )r- �name�cls�typer! �waitingr2 r� r r� r. �_lookup~ s � zResolver._lookupc s� | � � }|d u rt�td��S |\}}t�� }t||�� t� |�}d|_| j� |||�}| j� |p2d| j |� ||p:d�� _ � fdd�} |j | j| |fd�S )Nr} Fr� c s � j �� d � _ | S r4 )� timeoutCall�cancel)r �� controllerr r. �eliminateTimeout� s z-Resolver.lookupZone.<locals>.eliminateTimeout)� callbackArgs)rZ r r r� r� �AXFRControllerr& r( r r� rE � _timeoutZoner� � addCallbacks� _cbLookupZone) r- r� r! rr r� r� r2 r' � connectorr� r r� r. � lookupZone� s � �zResolver.lookupZonec C s. |� � d |_d |_|�t�d|f �� d S )Nz&Zone lookup timed out after %d seconds)� disconnectr� �deferred�errbackr r� )r- r2 r� r� �secondsr r r. r� � s �zResolver._timeoutZonec C s |� � |g g fS r4 )r� )r- rv r� r r r. r� � s zResolver._cbLookupZone)NNr N)r[ r4 �r� )"�__name__� __module__� __qualname__�__doc__rW r! r' r" rT r* r) r# rC rF r r3 r7 r: r, r> rZ rg rl ro rs r| r� r� rh r� r� r� r� r� r r r r. r & s@ : # r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � ZdS ) r� Nc C s& || _ || _d | _g | _|fg| _d S r4 )r� r� �soa�recordsr* )r- r� r� r r r. r � s zAXFRController.__init__c C s8 t j|�� dd�}t �| jt jt j�g|_|�|� d S )Nr )�recDes) r �Message�pickIDr� r� �AXFR�INr� � writeMessage)r- r rq r r r. rl � s z AXFRController.connectionMadec C � d S r4 r rn r r r. ro � s z AXFRController.connectionLostc C s� | j �|j� | j s d S | js | j d jtjkr | j d | _t| j �dkrL| j d jtjkrN| jd ur;| j� � d | _| j d urP| j � | j � d | _ d S d S d S d S )Nr r r� ) r� �extendr� r� r� r �SOAr$ r� r� r� r� )r- rq r r r r. rs � s �z AXFRController.messageReceived)r� r� r� r� r rl ro rs r r r r. r� � s r� )�ThreadedResolverc @ s e Zd Zddd�ZdS )r� Nc C s4 |d u r ddl m} t�| |� tjdtdd� d S )Nr r zztwisted.names.client.ThreadedResolver is deprecated since Twisted 9.0, use twisted.internet.base.ThreadedResolver instead.� )�category� stacklevel)r r �_ThreadedResolverImplr �warnings�warn�DeprecationWarning)r- r r r r. r � s �zThreadedResolver.__init__r4 )r� r� r� r r r r r. r� � s r� c @ s. e Zd Zd dd�Zdd� Zdd� Zdd � Zd S ) r& r� c C s || _ || _d S r4 )r� r! )r- r� r! r r r. r s zDNSClientFactory.__init__c C r� r4 r )r- r� r� r r r. �clientConnectionLost s z%DNSClientFactory.clientConnectionLostc C s> | j jdd� }| j jdd�= |D ] }|d }|�|� qdS )a Fail all pending TCP DNS queries if the TCP connection attempt fails. @see: L{twisted.internet.protocol.ClientFactory} @param connector: Not used. @type connector: L{twisted.internet.interfaces.IConnector} @param reason: A C{Failure} containing information about the cause of the connection failure. This will be passed as the argument to C{errback} on every pending TCP query C{deferred}. @type reason: L{twisted.python.failure.Failure} Nr )r� r* r� )r- r� r� r* � pendingStater2 r r r. �clientConnectionFailed s �z'DNSClientFactory.clientConnectionFailedc C s t �| j�}| |_|S r4 )r � DNSProtocolr� r' )r- �addr�pr r r. � buildProtocol% s z DNSClientFactory.buildProtocolNr� )r� r� r� r r� r� r� r r r r. r& s r& c C s� t �� dkr |du r d}|du rd}t|| �}t�|�}n |du r#d}ddlm} t|�}t�|�}tj|td�}|t � � |g}t � |�S ) a� Create and return a Resolver. @type servers: C{list} of C{(str, int)} or L{None} @param servers: If not L{None}, interpreted as a list of domain name servers to attempt to use. Each server is a tuple of address in C{str} dotted-quad form and C{int} port number. @type resolvconf: C{str} or L{None} @param resolvconf: If not L{None}, on posix systems will be interpreted as an alternate resolv.conf to use. Will do nothing on windows systems. If L{None}, /etc/resolv.conf will be used. @type hosts: C{str} or L{None} @param hosts: If not L{None}, an alternate hosts file to use. If L{None} on posix systems, /etc/hosts will be used. On windows, C:\windows\hosts will be used. @rtype: C{IResolver} �posixNs /etc/resolv.confs /etc/hostszc:\windows\hostsr r )�resolverFactory) r �getTyper � hostsModuler r r� r � bootstrapr � CacheResolverr � ResolverChain)r" � resolvconfr � theResolver� hostResolverr r� rU r r r. �createResolver+ s r� c C s: t du rzt� a W t S ty tdgd�a Y t S w t S )z� Get a Resolver instance. Create twisted.names.client.theResolver if it is L{None}, and then return that value. @rtype: C{IResolver} N)rK �5 )r" )r� r� r% r r r r. � getResolverX s ��r� r� c C s t � �| ||�S )aL Resolve a name to a valid ipv4 or ipv6 address. Will errback with C{DNSQueryTimeoutError} on a timeout, C{DomainError} or C{AuthoritativeDomainError} (or subclasses) on other errors. @type name: C{str} @param name: DNS name to resolve. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @type effort: C{int} @param effort: How many times CNAME and NS records to follow while resolving this name. @rtype: C{Deferred} )r� � getHostByName)r� r! �effortr r r. r� j s r� c C � t � �| |�S r4 )r� ry )ry r! r r r. ry � � ry c C r� r4 )r� � lookupAddress�r� r! r r r. r� � r� r� c C r� r4 )r� �lookupIPV6Addressr� r r r. r� � r� r� c C r� r4 )r� �lookupAddress6r� r r r. r� � r� r� c C r� r4 )r� �lookupMailExchanger� r r r. r� � r� r� c C r� r4 )r� �lookupNameserversr� r r r. r� � r� r� c C r� r4 )r� �lookupCanonicalNamer� r r r. r� � r� r� c C r� r4 )r� � lookupMailBoxr� r r r. r� � r� r� c C r� r4 )r� �lookupMailGroupr� r r r. r� � r� r� c C r� r4 )r� �lookupMailRenamer� r r r. r� � r� r� c C r� r4 )r� � lookupPointerr� r r r. r� � r� r� c C r� r4 )r� �lookupAuthorityr� r r r. r� � r� r� c C r� r4 )r� � lookupNullr� r r r. r� � r� r� c C r� r4 )r� �lookupWellKnownServicesr� r r r. r� � r� r� c C r� r4 )r� � lookupServicer� r r r. r� � r� r� c C r� r4 )r� �lookupHostInfor� r r r. r� � r� r� c C r� r4 )r� �lookupMailboxInfor� r r r. r� � r� r� c C r� r4 )r� � lookupTextr� r r r. r� � r� r� c C r� r4 )r� �lookupSenderPolicyr� r r r. r� � r� r� c C r� r4 )r� �lookupResponsibilityr� r r r. r� � r� r� c C r� r4 )r� �lookupAFSDatabaser� r r r. r� � r� r� c C r� r4 )r� r� r� r r r. r� � r� r� c C r� r4 )r� �lookupAllRecordsr� r r r. r � r� r c C r� r4 )r� � lookupNamingAuthorityPointerr� r r r. r � r� r )NNN)Nr� r4 )Cr� r< r? r� �zope.interfacer r r r r r �twisted.internet.abstractr � twisted.namesr r r r r� r r �twisted.pythonr r �twisted.python.compatr �twisted.python.filepathr �twisted.python.runtimer � IResolverr r r� �twisted.internet.baser� r� � ClientFactoryr& r� r� r� r� ry r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r. �<module> sb # , (* PK Mb�Z�?<3�9 �9 + names/__pycache__/authority.cpython-310.pycnu �[��� o �b+A � @ s� d Z ddlZddlZddlmZ ddlmZmZmZ ddl m Z ddl m Z m Z ddlmZ dd d �ZG d d � d ej�ZG d d� de�ZG dd� de�ZdS )z Authoritative resolvers. � N)�defer)�common�dns�error)�failure)�execfile� nativeString)�FilePath�/tmp/twisted-names.serialc C s t �d�}t�d�}z)tj�| �s-t| d��}|�|d � W d � n1 s(w Y W t�|� nt�|� w t| ��}|�� � � \}}W d � n1 sQw Y ||kr`t |�d pad}t| d��}|�d||f � W d � n1 s{w Y |d |f }|S ) a� Return a monotonically increasing (across program runs) integer. State is stored in the given file. If it does not exist, it is created with rw-/---/--- permissions. This manipulates process-global state by calling C{os.umask()}, so it isn't thread-safe. @param filename: Path to a file that is used to store the state across program runs. @type filename: L{str} @return: a monotonically increasing number @rtype: L{str} z%Y%m%d� �wz 0N� r z%s %dz%02d) �time�strftime�os�umask�path�exists�open�write�readline�split�int)�filename�serial�o�f� serialFile� lastSerial�zoneID� r �9/usr/lib/python3/dist-packages/twisted/names/authority.py� getSerial s$ �� � �r" c @ sp e Zd ZdZejejejfZej ej fZ dZ dZ dd� Zdd� Zdd� Zd d � Zdd d �Zddd�Zdd� ZdS )� FileAuthoritya� An Authority that is loaded from a file. This is an abstract class that implements record search logic. To create a functional resolver, subclass it and override the L{loadFile} method. @ivar _ADDITIONAL_PROCESSING_TYPES: Record types for which additional processing will be done. @ivar _ADDRESS_TYPES: Record types which are useful for inclusion in the additional section generated during additional processing. @ivar soa: A 2-tuple containing the SOA domain name as a L{bytes} and a L{dns.Record_SOA}. @ivar records: A mapping of domains (as lowercased L{bytes}) to records. @type records: L{dict} with L{bytes} keys Nc C s t j�| � | �|� i | _d S �N)r � ResolverBase�__init__�loadFile�_cache��selfr r r r! r& V s zFileAuthority.__init__c C s || _ d S r$ )�__dict__)r* �stater r r! � __setstate__[ s zFileAuthority.__setstate__c C s dS )ab Load DNS records from a file. This method populates the I{soa} and I{records} attributes. It must be overridden in a subclass. It is called once from the initializer. @param filename: The I{filename} parameter that was passed to the initilizer. @returns: L{None} -- the return value is ignored Nr r) r r r! r' ^ s zFileAuthority.loadFilec c sp � || D ]0}|j | jv r5|jjj}| j�|�� d�D ]}|j| jv r4t j ||jt j |j p.||dd�V qqdS )aW Find locally known information that could be useful to the consumer of the response and construct appropriate records to include in the I{additional} section of that response. Essentially, implement RFC 1034 section 4.3.2 step 6. @param answer: A L{list} of the records which will be included in the I{answer} section of the response. @param authority: A L{list} of the records which will be included in the I{authority} section of the response. @param ttl: The default TTL for records for which this is not otherwise specified. @return: A generator of L{dns.RRHeader} instances for inclusion in the I{additional} section. These instances represent extra information about the records in C{answer} and C{authority}. r T��authN) �type� _ADDITIONAL_PROCESSING_TYPES�payload�name�records�get�lower�TYPE�_ADDRESS_TYPESr �RRHeader�IN�ttl)r* �answer� authorityr; �recordr3 �recr r r! �_additionalRecordsk s � ���z FileAuthority._additionalRecordsc C s� g }g }g }g }t | jd j| jd j�} | j�|�� �} | r�| D ]_} | jdur,| j} n| } | jt j krP|�� | jd �� krP|� t j || jt j | | dd�� n| j|ksZ|t jkrj|� t j || jt j | | dd�� | jt jkr�|� t j || jt j | | dd�� q!|s�|}| �||| �} |r�|�| � n|�| � |s�|s�|� t j | jd t jt j | | jd dd�� t�|||f�S t �|| jd �r�t�t�t �|���S t�t�t�|���S )a� Determine a response to a particular DNS query. @param name: The name which is being queried and for which to lookup a response. @type name: L{bytes} @param cls: The class which is being queried. Only I{IN} is implemented here and this value is presently disregarded. @type cls: L{int} @param type: The type of records being queried. See the types defined in L{twisted.names.dns}. @type type: L{int} @param timeout: All processing is done locally and a result is available immediately, so the timeout value is ignored. @return: A L{Deferred} that fires with a L{tuple} of three sets of response records (to comprise the I{answer}, I{authority}, and I{additional} sections of a DNS response) or with a L{Failure} if there is a problem processing the query. r Nr Fr. T) �max�soa�minimum�expirer4 r5 r6 r; r7 r �NS�appendr9 r: � ALL_RECORDS�CNAMEr@ �extend�SOAr �succeed�_isSubdomainOf�failr �Failure�AuthoritativeDomainErrorr � DomainError)r* r3 �clsr0 �timeout�cnames�resultsr= � additional� default_ttl�domain_recordsr> r; �additionalInformationr r r! �_lookup� sT "�� ��� ��zFileAuthority._lookup� c C s t �|�}| jd �� |�� kr�t| jd j| jd j�}| jd jd ur,| jd j}n|}t j| jd t j t j || jd dd�g}| j � � D ]*\}}|D ]#}|jd urX|j} n|} |j t j krp|�t j||j t j | |dd�� qMqG|�|d � t�|ddf�S t�t�t �|���S )Nr r Tr. r )r � domainStringrB r6 rA rC rD r; r9 rJ r: r4 �itemsr7 rF r rK rM r rN rP ) r* r3 rR rV �soa_ttlrT �k�rr? r; r r r! � lookupZone� s0 �� ��� zFileAuthority.lookupZonec C sb g g g }}}|D ]!}|d r+|� |d d � |� |d d � |� |d d � q |||fS )Nr r � )rI )r* rT �ansr/ �add�resr r r! � _cbAllRecords� s � zFileAuthority._cbAllRecordsr$ )rZ )�__name__� __module__� __qualname__�__doc__r rH �MXrE r1 �A�AAAAr8 rB r4 r& r- r' r@ rY r` re r r r r! r# ; s Y r# c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �PySourceAuthorityzC A FileAuthority that is built up from Python source code. c C s| | � � i }}t|||� d|vrtd| ��i | _|d D ] }t|d tj�r+|| _| j�|d � � g �� |d � q d S )N�zonezNo zone defined in r r ) �setupConfigNamespacer � ValueErrorr4 � isinstancer � Record_SOArB � setdefaultr6 rF )r* r �g�l�rrr r r! r' s "�zPySourceAuthority.loadFilec s � fdd�}|S )Nc s t �| �� |i |��fS r$ )r r[ )r3 �arg�kw�r0 r r! �wrapRecordFunc s z4PySourceAuthority.wrapRecord.<locals>.wrapRecordFuncr )r* r0 rz r ry r! � wrapRecord s z PySourceAuthority.wrapRecordc C sN i }t j�� }dd� |D �D ]}tt |�}| �|�}|||td�d � < q|S )Nc S s g | ] }|� d �r|�qS )�Record_)� startswith)�.0�xr r r! � <listcomp>" s z:PySourceAuthority.setupConfigNamespace.<locals>.<listcomp>r| )r r+ �keys�getattrr{ �len)r* r_ r\ r> r0 r r r r! ro s z&PySourceAuthority.setupConfigNamespaceN)rf rg rh ri r' r{ ro r r r r! rm s rm c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )� BindAuthorityz� An Authority that loads U{BIND zone files <https://en.wikipedia.org/wiki/Zone_file>}. Supports only C{$ORIGIN} and C{$TTL} directives. c C sJ t |�}t|�� d �| _|�� �d�}| �|�}| �|�}| �|� dS )z} Load records from C{filename}. @param filename: file to read from @type filename: L{bytes} � .TN) r r �basename�origin� getContent� splitlines� stripComments�collapseContinuations� parseLines)r* r �fp�linesr r r! r' 1 s zBindAuthority.loadFilec C s dd� dd� |D �D �S )z� Strip comments from C{lines}. @param lines: lines to work on @type lines: iterable of L{bytes} @return: C{lines} sans comments. c s s4 � | ]}|� d �dkr |p|d|� d �� V qdS )� ;���N)�find)r~ �ar r r! � <genexpr>K s � "� �z.BindAuthority.stripComments.<locals>.<genexpr>c S s g | ]}|� � �qS r )�strip)r~ �br r r! r� M s z/BindAuthority.stripComments.<locals>.<listcomp>r )r* r� r r r! r� B s �zBindAuthority.stripCommentsc C s� g }d}|D ]G}|dkr(|� d�dkr|�|� q|�|d|� d�� � d}q|� d�dkrC|d d|d|� d�� 7 < d}q|d d| 7 < qtddd � |D ��S ) z� Transform multiline statements into single lines. @param lines: lines to work on @type lines: iterable of L{bytes} @return: iterable of continuous lines r � (r� Nr � )� c s s � | ]}|� � V qd S r$ )r )r~ �liner r r! r� h s � z6BindAuthority.collapseContinuations.<locals>.<genexpr>)r� rF �filter)r* r� ru r, r� r r r! r� P s "z#BindAuthority.collapseContinuationsc C s� d}| j }i | _|D ]6}|d dkrt�|d �}q |d dkr%|d }q |d dkr/td��|d dkr9td ��| �|||� q || _ d S ) zs Parse C{lines}. @param lines: lines to work on @type lines: iterable of L{bytes} i0* r s $TTLr s $ORIGINs $INCLUDEz"$INCLUDE directive not implementeds $GENERATEz#$GENERATE directive not implementedN)r� r4 r �str2time�NotImplementedError�parseRecordLine)r* r� r; r� r� r r r! r� j s zBindAuthority.parseLinesc C sd |� d�s|d |dd� }n|dd� }t| d|� �d�}|r*|||||� dS td|�d���)a Add a record to our authority. Expand domain with origin if necessary. @param owner: origin? @type owner: L{bytes} @param ttl: time to live for the record @type ttl: L{int} @param domain: the domain for which the record is to be added @type domain: L{bytes} @param type: record type @type type: L{str} @param cls: record class @type cls: L{str} @param rdata: record data @type rdata: L{list} of L{bytes} r� Nr� �class_z Record class � not supported)�endswithr� r� )r* �ownerr; r0 �domainrQ �rdatar r r r! � addRecord� s zBindAuthority.addRecordc C sn t tdt|�� �d�}|r-||� }||_| j�|�� g ��|� |dkr+||f| _dS dS t dt|��d���)a> Simulate a class IN and recurse into the actual class. @param ttl: time to live for the record @type ttl: L{int} @param type: record type @type type: str @param domain: the domain @type domain: bytes @param rdata: @type rdata: bytes r| NrJ z Record type r� ) r� r r r; r4 rs r6 rF rB r� )r* r; r0 r� r� r> r_ r r r! �class_IN� s ��zBindAuthority.class_INc C sv dd� t j�� D �}dd� t j�� D �}||B }d}|}|d dkr+|dd� }|}n|d �� sA|d |vrA|d }|dd� }|d �� sM|d |v rR|} |}n |d } |dd� }|d |v r|d }|dd� }|d �� r~t|d �}|dd� }n"|d �� r�t|d �}|dd� }|d |v r�|d }|dd� }|d } |dd� } | �||t| �| t|�| � dS ) a� Parse a C{line} from a zone file respecting C{origin} and C{ttl}. Add resulting records to authority. @param origin: starting point for the zone @type origin: L{bytes} @param ttl: time to live for the record @type ttl: L{int} @param line: zone file line to parse; split by word @type line: L{list} of L{bytes} c S � h | ]}|� d ��qS ��ascii��encode)r~ �qcr r r! � <setcomp>� � z0BindAuthority.parseRecordLine.<locals>.<setcomp>c S r� r� r� )r~ �qtr r r! r� � r� s INr � @r N)r � QUERY_CLASSES�values� QUERY_TYPES�isdigitr r� r ) r* r� r; r� � queryClasses� queryTypes�markersrQ r� r� r0 r� r r r! r� � s@ � z BindAuthority.parseRecordLineN) rf rg rh ri r' r� r� r� r� r� r� r r r r! r� ) s r� )r )ri r r �twisted.internetr � twisted.namesr r r �twisted.pythonr �twisted.python.compatr r �twisted.python.filepathr r" r% r# rm r� r r r r! �<module> s ' N!PK Mb�Z��� � ' names/__pycache__/hosts.cpython-310.pycnu �[��� o �b� � @ sz d Z ddlmZ ddlmZmZ ddlmZmZ ddl m Z ddl m Z ddl mZ dd � Zd d � ZG d d � d ej�ZdS )z hosts(5) support. � )�defer)� isIPAddress� isIPv6Address)�common�dns)�failure)� nativeString)�FilePathc C s� g }z| � � �� }W n ty | Y S w |�� }|D ]F}|�d�}|dkr-|d|� }|s0q |�� }|�� dd� |dd� D �v rbzt|d �}W n tyT Y q w t|�s]t |�rb|� |� q |S )a� Search the given file, which is in hosts(5) standard format, for addresses associated with a given name. @param hostsFile: The name of the hosts(5)-format file to search. @type hostsFile: L{FilePath} @param name: The name to search for. @type name: C{bytes} @return: L{None} if the name is not found in the file, otherwise a C{str} giving the address in the file associated with the name. � #���Nc S s g | ]}|� � �qS � )�lower)�.0�sr r �5/usr/lib/python3/dist-packages/twisted/names/hosts.py� <listcomp>/ s z$searchFileForAll.<locals>.<listcomp>� r ) � getContent� splitlines� BaseExceptionr �find�splitr � ValueErrorr r �append)� hostsFile�name�results�lines�line�idx�parts�maybeIPr r r �searchFileForAll s0 � � �r" c C s t t| �|�}|r |d S dS )a� Grep given file, which is in hosts(5) standard format, for an address entry with a given name. @param file: The name of the hosts(5)-format file to search. @type file: C{str} or C{bytes} @param name: The name to search for. @type name: C{bytes} @return: L{None} if the name is not found in the file, otherwise a C{str} giving the first address in the file associated with the name. r N)r" r )�filer � addressesr r r � searchFileFor9 s r% c @ sJ e Zd ZdZddd�Zdd� Zdd � Zd d � Zdd d�Zddd�Z eZ d S )�Resolverz9 A resolver that services hosts(5) format files. � /etc/hosts� c C s t j�| � || _|| _d S �N)r � ResolverBase�__init__r# �ttl)�selfr# r, r r r r+ S s zResolver.__init__c �$ t � �fdd�tt�j�� �D ��S )zv Return a tuple of L{dns.RRHeader} instances for all of the IPv4 addresses in the hosts file. c 3 �: � | ]}t |�rt�� tjtj�jt�|�j��V qd S r) )r r �RRHeader�A�INr, �Record_A�r �addr�r r- r r � <genexpr>] s � � �z%Resolver._aRecords.<locals>.<genexpr>��tupler" r r# �r- r r r6 r � _aRecordsX s �zResolver._aRecordsc r. )zv Return a tuple of L{dns.RRHeader} instances for all of the IPv6 addresses in the hosts file. c 3 r/ r) )r r r0 �AAAAr2 r, � Record_AAAAr4 r6 r r r7 h s � �� �z(Resolver._aaaaRecords.<locals>.<genexpr>r8 r: r r6 r � _aaaaRecordsc s �zResolver._aaaaRecordsc C s* |r t �|ddf�S t �t�t�|���S )aF Generate a response for the given name containing the given result records, or a failure if there are no result records. @param name: The DNS name the response is for. @type name: C{str} @param records: A tuple of L{dns.RRHeader} instances giving the results that will go into the response. @return: A L{Deferred} which will fire with a three-tuple of result records, authority records, and additional records, or which will fail with L{dns.DomainError} if there are no result records. r )r �succeed�failr �Failurer � DomainError)r- r �recordsr r r �_respondp s zResolver._respondNc C � t �|�}| �|| �|��S )zm Read any IPv4 addresses from C{self.file} and return them as L{Record_A} instances. )r � domainStringrD r; �r- r �timeoutr r r � lookupAddress� � zResolver.lookupAddressc C rE )zp Read any IPv6 addresses from C{self.file} and return them as L{Record_AAAA} instances. )r rF rD r> rG r r r �lookupIPV6Address� rJ zResolver.lookupIPV6Address)r' r( r) ) �__name__� __module__� __qualname__�__doc__r+ r; r> rD rI rK �lookupAllRecordsr r r r r& N s r& N)rO �twisted.internetr �twisted.internet.abstractr r � twisted.namesr r �twisted.pythonr �twisted.python.compatr �twisted.python.filepathr r" r% r* r& r r r r �<module> s 'PK Mb�ZNB<�� � % names/__pycache__/tap.cpython-310.pycnu �[��� o �b� � @ sn d Z ddlZddlZddlmZmZ ddlmZmZm Z m Z ddl m Z G dd� de j �Z dd � Zd d � ZdS ) z Domain Name Server � N)�internet�service)� authority�dns� secondary�server)�usagec @ s� e Zd Zg d�g d�g d�g d�gZg d�g d�g d�gZejde�� id �Zd Z d Z d d � Z d d� Z dd� Z dd� Zdd� Zdd� Zd S )�Options)� interface�i� z The interface to which to bind)�port�p�53zThe port on which to listen)� resolv-confNNz6Override location of resolv.conf (implies --recursive))� hosts-fileNNz!Perform lookups with a hosts file)�cache�czEnable record caching)� recursive�rzPerform recursive lookups)�verbose�vz Log verboselyr )� optActionsNc C s* t j�| � d| d< g | _g | _g | _d S )Nr r )r r �__init__� bindfiles� zonefiles� secondaries��self� r �3/usr/lib/python3/dist-packages/twisted/names/tap.pyr + s zOptions.__init__c C �* t j�|�s t�|d ��| j�|� dS )z7Specify the filename of a Python syntax zone definition�: No such fileN)�os�path�existsr � UsageErrorr �append�r �filenamer r r � opt_pyzone2 � zOptions.opt_pyzonec C r! )z6Specify the filename of a BIND9 syntax zone definitionr" N)r# r$ r% r r& r r' r( r r r � opt_bindzone8 r+ zOptions.opt_bindzonec C s� |� dd�}t|�dkrt�d��|d � d�}t|�dkr&|d tjf}n zt|d �}W n ty? t�d|d ����w |d |f}| j� ||d gf� dS ) zwAct as secondary for the specified domain, performing zone transfers from the specified IP (IP/domain) �/� � z-Argument must be of the form IP[:port]/domainr �:z$Specify an integer port number, not N) �split�lenr r& r �PORT�int� ValueErrorr r' )r � ip_domain�args�addressr r r r � opt_secondary> s �� zOptions.opt_secondaryc C s | d d7 < dS )zIncrement verbosity levelr r. Nr r r r r � opt_verboseR s zOptions.opt_verbosec C s | d rd| d< g | _ g | _| jD ] }z | j�t�|�� W q ty0 t�� t � d| ��w | j D ] }z | j�t� |�� W q4 tyS t�� t � d| ��w | j D ]}tjj|� }| j �|� | j�| j d �� � qWz t| d �| d< W d S ty� t � d�| d ���w )Nr Tr zInvalid syntax in ���r zInvalid port: {!r})�svcs�zonesr r' r �PySourceAuthority� Exception� traceback� print_excr r& r � BindAuthorityr r �SecondaryAuthorityService�fromServerAddressAndDomains� getAuthorityr4 r5 �format)r �f�svcr r r � postOptionsV s6 � � �zOptions.postOptions)�__name__� __module__� __qualname__� optParameters�optFlagsr � Completions�CompleteNetInterfaces�compDatar= r r r* r, r9 r: rI r r r r r s* � � � r c C s� ddl m}m}m} g g }}| d r |�|j| d d�� | d r-|�|j| d d�� | d r<|�|j| d d �� ||fS ) a% Build DNS resolver instances in an order which leaves recursive resolving as a last resort. @type config: L{Options} instance @param config: Parsed command-line configuration @return: Two-item tuple of a list of cache resovers and a list of client resolvers r )r �client�hostsr r )r r )�filer r )� resolvconf)� twisted.namesr rR rS r' � CacheResolver�Resolver�createResolver)�configr rR rS �ca�clr r r �_buildResolversr s r] c C s� t | �\}}t�| j||| d �}t�|�}d|_t�� }t j |ft j |ffD ]\}}|| d || d d�}|� |� q'| j D ]} | � |� q?|S )Nr r r r )r )r] r �DNSServerFactoryr= r �DNSDatagramProtocol�noisyr � MultiServicer � TCPServer� UDPServer�setServiceParentr< ) rZ r[ r\ rG r �ret�klass�arg�srH r r r � makeService� s ri )�__doc__r# r@ �twisted.applicationr r rV r r r r �twisted.pythonr r r] ri r r r r �<module> s a PK Mb�Z��U�p p % names/__pycache__/dns.cpython-310.pycnu �[��� o �b�� � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl m Z m Z m Z ddl mZmZmZ ddlmZmZ ddlmZ dd lmZmZmZmZ dd l m Z m Z m Z g d �Z ej!Z!d d � Z"dd� Z#dd� Z$dd� Z%dZ&e'dd�\Z(Z)Z*Z+Z,Z-Z.Z/Z0Z1Z2Z3Z4Z5Z6Z7Z8Z9dZ:dZ;dZ<dZ=dZ>d Z?d Z@d ZAd ZBd ZCi e(d!�e)d"�e*d#�e+d$�e,d%�e-d&�e.d'�e/d(�e0d)�e1d*�e2d+�e3d,�e4d-�e5d.�e6d/�e7d0�e8d1�e9d2e:d3e;d4e<d5e=d6e>d7e?d8e@d9eAd:eBd;eCd<i �ZDe'd=d>�\ZEZFZGZHZIeEd?eFd@eGdAeHdBeIdCiZJdDdE� eeD�K� eJ�K� �D �ZLe'ddF�\ZMZNZOZPdGZQeMdHeNdIeOdJePdKeQdLiZRdMdE� eR�K� D �ZSe'dN�\ZTZUZVdOZWdFZXe'dP�\ZYZZZ[Z\Z]Z^dQZ_e'dQd�\Z`ZaZbG dRdS� dSe�ZcddTldmeZemfZfmgZg dUdV� ZhdWdX� ZidYdZ� Zjd[d\� Zkd]d^� ZlG d_d`� d`e�ZmG dadb� dbemec�Zneem�G dcdd� dd��Zoeem�G dedf� df��Zpe eem�G dgdh� dh���Zqeem�G didj� djejrejs��Zteem�G dkdl� dlejrejs��Zueem�G dmdn� dnejs��Zveen�G dodp� dpejrejs��ZwG dqdr� drew�ZxG dsdt� dtew�ZyG dudv� dvew�ZzG dwdx� dxew�Z{G dydz� dzew�Z|G d{d|� d|ew�Z}G d}d~� d~ew�Z~G dd�� d�ew�ZG d�d�� d�ew�Z�een�G d�d�� d�ejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejrejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejrejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejrejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejrejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejrejs��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejsejr��Z�een�G d�d�� d�ejsejr��Z�G d�d�� d�e��Z�een�G d�d�� d�ejsejr��Z�d�d�� Z�d�d�� Z� d�d�d��Z�G d�d�� d�ejs�Z�G d�d�� d�ejs�Z�G d�d�� d��Z�G d�d�� d�e�ej��Z�G d�d�� d�e�ej��Z�dS )�zU DNS protocol implementation. Future Plans: - Get rid of some toplevels, maybe. � N)�BytesIO)�chain)�Optional� SupportsInt�Union)� Attribute� Interface� implementer)�defer�protocol)�CannotListenError)�failure�log� randbytes�util)�cmp� comparable� nativeString)d� IEncodable�IRecord�IEncodableRecord�A�A6�AAAA�AFSDB�CNAME�DNAME�HINFO�MAILA�MAILB�MB�MD�MF�MG�MINFO�MR�MX�NAPTR�NS�NULL�OPT�PTR�RP�SOA�SPF�SRV�TXT�SSHFP�TSIG�WKS�ANY�CH�CS�HS�IN� ALL_RECORDS�AXFR�IXFR�EFORMAT�ENAME�ENOTIMP�EREFUSED�ESERVER� EBADVERSION�EBADSIG�EBADKEY�EBADTIME�Record_A� Record_A6� Record_AAAA� Record_AFSDB� Record_CNAME� Record_DNAME� Record_HINFO� Record_MB� Record_MD� Record_MF� Record_MG� Record_MINFO� Record_MR� Record_MX� Record_NAPTR� Record_NS� Record_NULL� Record_PTR� Record_RP� Record_SOA� Record_SPF� Record_SRV� Record_SSHFP� Record_TSIG� Record_TXT� Record_WKS� UnknownRecord� QUERY_CLASSES� QUERY_TYPES� REV_CLASSES� REV_TYPES� EXT_QUERIES�Charstr�Message�Name�Query�RRHeader� SimpleRecord�DNSDatagramProtocol�DNSMixin� DNSProtocol�OK� OP_INVERSE� OP_NOTIFY�OP_QUERY� OP_STATUS� OP_UPDATE�PORT�AuthoritativeDomainError�DNSQueryTimeoutError� DomainErrorc C s t | g�S )z� Construct a bytes object representing a single byte with the given ordinal value. @type ordinal: L{int} @rtype: L{bytes} ��bytes)�ordinal� r{ �3/usr/lib/python3/dist-packages/twisted/names/dns.py� _ord2bytes� s r} c C s t | �dd� S )z� Represent a mostly textful bytes object in a way suitable for presentation to an end user. @param bytes: The bytes to represent. @rtype: L{str} � N)�reprrx r{ r{ r| � _nicebytes� s r� c C s d� d�dd� | D ���S )z� Represent a list of mostly textful bytes objects in a way suitable for presentation to an end user. @param list: The list of bytes to represent. @rtype: L{str} z[{}]�, c S s g | ]}t |��qS r{ )r� )�.0�br{ r{ r| � <listcomp>� s z"_nicebyteslist.<locals>.<listcomp>)�format�join)�listr{ r{ r| �_nicebyteslist� s r� c C s t �dtjddd��d S )z� Wrapper around L{twisted.python.randbytes.RandomFactory.secureRandom} to return 2 random bytes. @rtype: L{bytes} �H� T)�fallbackr )�struct�unpackr � secureRandomr{ r{ r{ r| � randomSource� s r� �5 r~ � � �! �# �& �' �) �, �c � � r r( r! r" r r- r r# r% r) r3 r+ r r$ r& r0 r, r r r/ r' r r r* r1 r. �TKEYr2 � � r; r: r r r9 c C � i | ]\}}||�qS r{ r{ �r� �k�vr{ r{ r| � <dictcomp> � r� � � r8 r6 r5 r7 r4 c C r� r{ r{ r� r{ r{ r| r� r� � � � � c @ s e Zd ZdZed�ZdS )r z0 A single entry in a zone of authority. z,An indicator of what kind of record this is.N)�__name__� __module__� __qualname__�__doc__r �TYPEr{ r{ r{ r| r s r )ru rv rw c C s2 | dv rdgS | � d�}|d dkr|�d� |S )a2 Split a domain name into its constituent labels. @type name: L{bytes} @param name: A fully qualified domain name (with or without a trailing dot). @return: A L{list} of labels ending with an empty label representing the DNS root zone. @rtype: L{list} of L{bytes} )� � .r� r� ���)�split�append)�name�labelsr{ r{ r| � _nameToLabels* s r� c C s> t | t�r | �d�} t | t�s td�tjtj| t| ����| S )a� Coerce a domain name string to bytes. L{twisted.names} represents domain names as L{bytes}, but many interfaces accept L{bytes} or a text string (L{unicode} on Python 2, L{str} on Python 3). This function coerces text strings using IDNA encoding --- see L{encodings.idna}. Note that DNS is I{case insensitive} but I{case preserving}. This function doesn't normalize case, so you'll still need to do that whenever comparing the strings it returns. @param domain: A domain name. If passed as a text string it will be C{idna} encoded. @type domain: L{bytes} or L{str} @returns: L{bytes} suitable for network transmission. @rtype: L{bytes} @since: Twisted 20.3.0 �idnaz+Expected {} or {} but found {!r} of type {})� isinstance�str�encodery � TypeErrorr� r� �type)�domainr{ r{ r| � domainString> s ��r� c C s. t | �� �}t |�� �}|t|� d� |kS )a) Test whether C{descendantName} is equal to or is a I{subdomain} of C{ancestorName}. The names are compared case-insensitively. The names are treated as byte strings containing one or more DNS labels separated by B{.}. C{descendantName} is considered equal if its sequence of labels exactly matches the labels of C{ancestorName}. C{descendantName} is considered a I{subdomain} if its sequence of labels ends with the labels of C{ancestorName}. @type descendantName: L{bytes} @param descendantName: The DNS subdomain name. @type ancestorName: L{bytes} @param ancestorName: The DNS parent or ancestor domain name. @return: C{True} if C{descendantName} is equal to or if it is a subdomain of C{ancestorName}. Otherwise returns C{False}. N)r� �lower�len)�descendantName� ancestorName�descendantLabels�ancestorLabelsr{ r{ r| �_isSubdomainOf_ s r� c C s� d}t | t�r | �d�} t | t�rF| �� �� } |D ]\}}| �|�r0tt| dd� �| � S qzt| �} W | S t yE t d| ��w | S )aE Parse a string description of an interval into an integer number of seconds. @param s: An interval definition constructed as an interval duration followed by an interval unit. An interval duration is a base ten representation of an integer. An interval unit is one of the following letters: S (seconds), M (minutes), H (hours), D (days), W (weeks), or Y (years). For example: C{"3S"} indicates an interval of three seconds; C{"5D"} indicates an interval of five days. Alternatively, C{s} may be any non-string and it will be returned unmodified. @type s: text string (L{bytes} or L{str}) for parsing; anything else for passthrough. @return: an L{int} giving the interval represented by the string C{s}, or whatever C{s} is if it is not a string. ))�Sr~ )�M�< )r� i )�Di�Q )�Wi�: )�Yi�3��asciiNr� z!Invalid time interval specifier: ) r� ry �decoder� �upper�strip�endswith�int�float� ValueError)�s�suffixes�suff�multr{ r{ r| �str2time} s � � �r� c C s | � |�}t|�|k r t�|S �N)�readr� �EOFError)�file�l�buffr{ r{ r| � readPrecisely� s r� c @ s$ e Zd ZdZddd�Zddd�ZdS )r z� Interface for something which can be encoded to and decoded to the DNS wire format. A binary-mode file object (such as L{io.BytesIO}) is used as a buffer when encoding or decoding. Nc C � dS )a� Write a representation of this object to the given file object. @type strio: File-like object @param strio: The buffer to write to. It must have a C{tell()} method. @type compDict: L{dict} of L{bytes} to L{int} r L{None} @param compDict: A mapping of names to byte offsets that have already been written to the buffer, which may be used for compression (see RFC 1035 section 4.1.4). When L{None}, encode without compression. Nr{ )�strio�compDictr{ r{ r| r� � � zIEncodable.encodec C r� )a� Reconstruct an object from data read from the given file object. @type strio: File-like object @param strio: A seekable buffer from which bytes may be read. @type length: L{int} or L{None} @param length: The number of bytes in this RDATA field. Most implementations can ignore this value. Only in the case of records similar to TXT where the total length is in no way encoded in the data is it necessary. Nr{ )r� �lengthr{ r{ r| r� � r� zIEncodable.decoder� )r� r� r� r� r� r� r{ r{ r{ r| r � s r c @ s e Zd ZdZdS )r z` Interface for DNS records that can be encoded and decoded. @since: Twisted 21.2.0 N)r� r� r� r� r{ r{ r{ r| r � s r c @ sR e Zd Zddd�Zddd�Zddd�Zd ed efd d �Zd d� Z d e fdd�Z dS )re r� c C s" t |t�s t|�d���|| _d S )Nz is not a byte string)r� ry r� �string)�selfr� r{ r{ r| �__init__� s zCharstr.__init__Nc C s* | j }t|�}|�t|�� |�|� dS )z� Encode this Character string into the appropriate byte format. @type strio: file @param strio: The byte representation of this Charstr will be written to this file. N)r� r� �writer} )r� r� r� r� �indr{ r{ r| r� � s zCharstr.encodec C s$ d| _ tt|d��}t||�| _ dS )a Decode a byte string into this Charstr. @type strio: file @param strio: Bytes will be read from this file until the full string is decoded. @raise EOFError: Raised when there are not enough bytes available from C{strio}. r� r~ N)r� �ordr� )r� r� r� r� r{ r{ r| r� � s zCharstr.decode�other�returnc C s t |t�r | j|jkS tS r� )r� re r� �NotImplemented�r� r� r{ r{ r| �__eq__� s zCharstr.__eq__c C � t | j�S r� )�hashr� �r� r{ r{ r| �__hash__ � zCharstr.__hash__c C r� )zI Represent this L{Charstr} instance by its string value. )r r� r� r{ r{ r| �__str__ � zCharstr.__str__�r� r� ) r� r� r� r� r� r� �object�boolr� r� r� r� r{ r{ r{ r| re � s re c @ sV e Zd ZdZddd�Zddd�Zddd �Zd ed efd d �Z dd� Z d e fdd�Z dS )rg z� A name in the domain name system, made up of multiple labels. For example, I{twistedmatrix.com}. @ivar name: A byte string giving the name. @type name: L{bytes} r� c C s t |�| _dS )zM @param name: A name. @type name: L{bytes} or L{str} N)r� r� )r� r� r{ r{ r| r� s z Name.__init__Nc C s� | j }|rT|dur%||v r |�t�dd|| B �� dS |�� tj ||< |�d�}|dkr>|d|� ||d d� }}n|}d}t|�}|�t |�� |�|� |s|�d� dS )a� Encode this Name into the appropriate byte format. @type strio: file @param strio: The byte representation of this Name will be written to this file. @type compDict: dict @param compDict: dictionary of Names that have already been encoded and whose addresses may be backreferenced by this Name (for the purpose of reducing the message size). N�!Hi � r� r r~ � ) r� r� r� �pack�tellrf � headerSize�findr� r} )r� r� r� r� r� �labelr{ r{ r| r� s" �z Name.encodec C s� t � }d| _d} tt|d��}|dkr |dkr |�|� dS |d? dkrM|d@ d> tt|d��B }||v r:td ��|�|� |dkrG|�� }|�|� qt||�}| jdkr[|| _n| jd | | _q ) a� Decode a byte string into this Name. @type strio: file @param strio: Bytes will be read from this file until the full Name is decoded. @raise EOFError: Raised when there are not enough bytes available from C{strio}. @raise ValueError: Raised when the name cannot be decoded (for example, because it contains a loop). r� r r~ Nr� r� �? � z Compression loop in encoded namer� )�setr� r� r� �seekr� �addr� )r� r� r� �visited�offr� �new_offr r{ r{ r| r� ? s. �z Name.decoder� r� c C s" t |t�r| j�� |j�� kS tS r� )r� rg r� r� r� r� r{ r{ r| r� e s z Name.__eq__c C r� r� �r� r� r� r{ r{ r| r� j r� z Name.__hash__c C r� )zE Represent this L{Name} instance by its string name. �r r� r� r{ r{ r| r� m r� z Name.__str__r� r� ) r� r� r� r� r� r� r� r� r� r� r� r� r� r{ r{ r{ r| rg s !&rg c @ sv e Zd ZdZdeefdeeef de de fdd�Z dd d �Z dd d �Z d d� Z dd� Zdefdd�Zdefdd�ZdS )rh z� Represent a single DNS query. @ivar name: The name about which this query is requesting information. @type name: L{Name} @ivar type: The query type. @type type: L{int} @ivar cls: The query class. @type cls: L{int} r� r� r� �clsc C s t |�| _|| _|| _dS )z� @type name: L{bytes} or L{str} @param name: See L{Query.name} @type type: L{int} @param type: The query type. @type cls: L{int} @param cls: The query class. N)rg r� r� r �r� r� r� r r{ r{ r| r� � s zQuery.__init__Nc C s* | j �||� |�t�d| j| j�� d S �N�!HH)r� r� r� r� r� r� r �r� r� r� r{ r{ r| r� � s z Query.encodec C s. | j �|� t|d�}t�d|�\| _| _d S )Nr� r )r� r� r� r� r� r� r )r� r� r� r� r{ r{ r| r� � s z Query.decodec C s t | jj�� | j| jf�S r� )r� r� r� r� r r� r{ r{ r| r� � s zQuery.__hash__c C s< t |t�r t| jj�� | j| jf|jj�� |j|jf�S tS r� )r� rh r r� r� r� r r� r� r{ r{ r| �__cmp__� s �z Query.__cmp__r� c C sL t �| jt�| jd| j ��}t�| jd| j �}d| j� d|� d|� d�S )N� UNKNOWN (%d)z<Query � �>)ra �getr� rd r` r r� �r� �t�cr{ r{ r| r� � s �z Query.__str__c C s d| j j �d| j�d| j�d�S )NzQuery(r� �))r� r� r r� r{ r{ r| �__repr__� � zQuery.__repr__r� )r� r� r� r� r r8 r ry r� r� r� r� r� r� r r� r r{ r{ r{ r| rh t s & rh c @ sz e Zd ZdZddd� fddddd d fZd Z d dd�Zedd� �Zedd� �Z d dd�Z d dd�Z e dd� �Z dS ) � _OPTHeaderaZ An OPT record header. @ivar name: The DNS name associated with this record. Since this is a pseudo record, the name is always an L{Name} instance with value b'', which represents the DNS root zone. This attribute is a readonly property. @ivar type: The DNS record type. This is a fixed value of 41 C{dns.OPT} for OPT Record. This attribute is a readonly property. @see: L{_OPTHeader.__init__} for documentation of other public instance attributes. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.2} @since: 13.2 r� c C r� r� r )�nr{ r{ r| �<lambda>� s z_OPTHeader.<lambda>r� �udpPayloadSize� extendedRCODE�version�dnssecOK�options)r� r� r r r! r" r# � r FNc C s. || _ || _|| _|| _|du rg }|| _dS )a� @type udpPayloadSize: L{int} @param udpPayloadSize: The number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type extendedRCODE: L{int} @param extendedRCODE: Forms the upper 8 bits of extended 12-bit RCODE (together with the 4 bits defined in [RFC1035]. Note that EXTENDED-RCODE value 0 indicates that an unextended RCODE is in use (values 0 through 15). @type version: L{int} @param version: Indicates the implementation level of the setter. Full conformance with this specification is indicated by version C{0}. @type dnssecOK: L{bool} @param dnssecOK: DNSSEC OK bit as defined by [RFC3225]. @type options: L{list} @param options: A L{list} of 0 or more L{_OPTVariableOption} instances. N�r r r! r" r# )r� r r r! r" r# r{ r{ r| r� � s z_OPTHeader.__init__c C s t d�S )a/ A readonly property for accessing the C{name} attribute of this record. @return: The DNS name associated with this record. Since this is a pseudo record, the name is always an L{Name} instance with value b'', which represents the DNS root zone. r� )rg r� r{ r{ r| r� s z_OPTHeader.namec C s t S )z� A readonly property for accessing the C{type} attribute of this record. @return: The DNS record type. This is a fixed value of 41 (C{dns.OPT} for OPT Record. )r* r� r{ r{ r| r� s z_OPTHeader.typec C sh t � }| jD ]}|�|� q|�� }t| jj| j| j| jd> | j d> B | j d> B t |�d��||� dS )a� Encode this L{_OPTHeader} instance to bytes. @type strio: file @param strio: the byte representation of this L{_OPTHeader} will be written to this file. @type compDict: L{dict} or L{None} @param compDict: A dictionary of backreference addresses that have already been written to this stream and that may be used for DNS name compression. � r� � )r� r� r �ttl�payloadN) r r# r� �getvalueri r� r� r r r! r" r_ )r� r� r� r� �o� optionBytesr{ r{ r| r� s �z_OPTHeader.encodec C sX t � }|�||� tt||j��|_| �|�}| jD ]}|dvr)t| |t ||�� qdS )a Decode bytes into an L{_OPTHeader} instance. @type strio: file @param strio: Bytes will be read from this file until the full L{_OPTHeader} is decoded. @type length: L{int} or L{None} @param length: Not used. )r� r� N) ri r� r_ r� �rdlengthr) � fromRRHeader�compareAttributes�setattr�getattr)r� r� r� �h� newOptHeader�attrNamer{ r{ r| r� 6 s ��z_OPTHeader.decodec C s� d}|j dur.g }t|j j�}t|j j�}|�� |k r.t� }|�|� |�|� |�� |k s| |j|j d? |j d? d@ |j d@ d? |d�S )ai A classmethod for constructing a new L{_OPTHeader} from the attributes and payload of an existing L{RRHeader} instance. @type rrHeader: L{RRHeader} @param rrHeader: An L{RRHeader} instance containing an L{UnknownRecord} payload. @return: An instance of L{_OPTHeader}. @rtype: L{_OPTHeader} Nr& r� r� i�� r' r% ) r) r �datar� r� �_OPTVariableOptionr� r� r r( )r �rrHeaderr# � optionsBytes�optionsBytesLengthr+ r{ r{ r| r. L s" � �z_OPTHeader.fromRRHeader)r$ r r FNr� )r� r� r� r� �showAttributesr/ r� �propertyr� r� r� r� � classmethodr. r{ r{ r{ r| r � s2 � �) r c @ sB e Zd ZdZddeffZdZdZddd �Zdd d �Z dd d�Z d S )r6 z� A class to represent OPT record variable options. @see: L{_OPTVariableOption.__init__} for documentation of public instance attributes. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.2} @since: 13.2 �coder5 �r= r5 r r r� c C s || _ || _dS )z� @type code: L{int} @param code: The option code @type data: L{bytes} @param data: The option data Nr> )r� r= r5 r{ r{ r| r� s z_OPTVariableOption.__init__Nc C s( |� t�| j| jt| j��| j � dS )a� Encode this L{_OPTVariableOption} to bytes. @type strio: file @param strio: the byte representation of this L{_OPTVariableOption} will be written to this file. @type compDict: L{dict} or L{None} @param compDict: A dictionary of backreference addresses that have already been written to this stream and that may be used for DNS name compression. N)r� r� r� �_fmtr= r� r5 r r{ r{ r| r� � s ( z_OPTVariableOption.encodec C s: t �| j�}t||�}t �| j|�\| _}t||�| _dS )a Decode bytes into an L{_OPTVariableOption} instance. @type strio: file @param strio: Bytes will be read from this file until the full L{_OPTVariableOption} is decoded. @type length: L{int} or L{None} @param length: Not used. N)r� �calcsizer? r� r� r= r5 )r� r� r� r� r� r{ r{ r| r� � s z_OPTVariableOption.decode)r r� r� ) r� r� r� r� r r: r/ r? r� r� r� r{ r{ r{ r| r6 m s r6 c @ s� e Zd ZdZdZdZdZdZdee dddfde e e f d e d e d ed ee d ef dd�Zddd�Zddd�Zdd� Zde fdd�ZeZdS )ri ak A resource record header. @cvar fmt: L{str} specifying the byte format of an RR. @ivar name: The name about which this reply contains information. @type name: L{Name} @ivar type: The query type of the original request. @type type: L{int} @ivar cls: The query class of the original request. @ivar ttl: The time-to-live for this record. @type ttl: L{int} @ivar payload: The record described by this header. @type payload: L{IEncodableRecord} or L{None} @ivar auth: A L{bool} indicating whether this C{RRHeader} was parsed from an authoritative message. )r� r� r r( r) �authz!HHIHNr� r Fr� r� r r( r) rA c C s� |du rdn|j }|dur!||kr!tdt�||�t�||�f ��t|�}|dk r-td��t|�| _|| _|| _|| _ || _ || _ dS )a� @type name: L{bytes} or L{str} @param name: See L{RRHeader.name} @type type: L{int} @param type: The query type. @type cls: L{int} @param cls: The query class. @type ttl: L{int} @param ttl: Time to live for this record. This will be converted to an L{int}. @type payload: L{IEncodableRecord} or L{None} @param payload: An optional Query Type specific data object. @raises TypeError: if the ttl cannot be converted to an L{int}. @raises ValueError: if the ttl is negative. @raises ValueError: if the payload type is not equal to the C{type} argument. Nz0Payload type (%s) does not match given type (%s)r zTTL cannot be negative) r� r� ra r r� rg r� r� r r( r) rA ) r� r� r� r r( r) rA � payloadType� integralTTLr{ r{ r| r� � s$ ��� zRRHeader.__init__c C s� | j �||� |�t�| j| j| j| jd�� | j rD|� � }| j �||� |� � }|� |d d� |�t�d|| �� |� |d� d S d S )Nr r� r� ) r� r� r� r� r� �fmtr� r r( r) r� r )r� r� r� �prefix�aftr{ r{ r| r� s �zRRHeader.encodec C sH | j �|� t�| j�}t||�}t�| j|�}|\| _| _| _ | _ d S r� ) r� r� r� r@ rD r� r� r� r r( r- )r� r� r� r� r� �rr{ r{ r| r� s zRRHeader.decodec C s | j S r� �rA r� r{ r{ r| �isAuthoritative s zRRHeader.isAuthoritativer� c C sR t �| jt�| jd| j ��}t�| jd| j �}d| j||| j| jr%dp&df S )Nr z-<RR name=%s type=%s class=%s ttl=%ds auth=%s>�True�False) ra r r� rd r` r r� r( rA r r{ r{ r| r� s � �zRRHeader.__str__r� )r� r� r� r� r/ rD r- �cachedResponser r8 r ry r� r� r r r r� r� r� r� rI r� r r{ r{ r{ r| ri � s< � ����� � 5 ri c @ sT e Zd ZU dZdZdZdZee e d< dZ ddd�Z dd d �Z dd d �Z d d� ZdS )rj a A Resource Record which consists of a single RFC 1035 domain-name. @type name: L{Name} @ivar name: The name associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. )�r� r� �%sr( )r� r( Nr� r� c C s t |�| _t|�| _dS )z^ @param name: See L{SimpleRecord.name} @type name: L{bytes} or L{str} N)rg r� r� r( )r� r� r( r{ r{ r| r� 8 s zSimpleRecord.__init__c C s | j �||� d S r� )r� r� r r{ r{ r| r� @ s zSimpleRecord.encodec C s t � | _| j�|� d S r� )rg r� r� �r� r� r� r{ r{ r| r� C s zSimpleRecord.decodec C r� r� r r� r{ r{ r| r� G r� zSimpleRecord.__hash__�r� Nr� )r� r� r� r� r: r/ r� r r� �__annotations__r� r� r� r� r� r{ r{ r{ r| rj % s rj c @ � e Zd ZdZeZdZdS )rT z& An authoritative nameserver. r( N)r� r� r� r� r( r� � fancybasenamer{ r{ r{ r| rT L � rT c @ rR )rM zX A mail destination. This record type is obsolete. @see: L{Record_MX} r! N)r� r� r� r� r! r� rS r{ r{ r{ r| rM U � rM c @ rR )rN zV A mail forwarder. This record type is obsolete. @see: L{Record_MX} r" N)r� r� r� r� r" r� rS r{ r{ r{ r| rN b rU rN c @ rR )rI z* The canonical name for an alias. r N)r� r� r� r� r r� rS r{ r{ r{ r| rI o rT rI c @ rR )rL zJ A mailbox domain name. This is an experimental record type. r N)r� r� r� r� r r� rS r{ r{ r{ r| rL x � rL c @ rR )rO zH A mail group member. This is an experimental record type. r# N)r� r� r� r� r# r� rS r{ r{ r{ r| rO � rV rO c @ rR )rQ zN A mail rename domain name. This is an experimental record type. r% N)r� r� r� r� r% r� rS r{ r{ r{ r| rQ � rV rQ c @ rR )rV z A domain name pointer. r+ N)r� r� r� r� r+ r� rS r{ r{ r{ r| rV � rT rV c @ rR )rJ a[ A non-terminal DNS name redirection. This record type provides the capability to map an entire subtree of the DNS name space to another domain. It differs from the CNAME record which maps a single node of the name space. @see: U{http://www.faqs.org/rfcs/rfc2672.html} @see: U{http://www.faqs.org/rfcs/rfc3363.html} r N)r� r� r� r� r r� rS r{ r{ r{ r| rJ � s rJ c @ s\ e Zd ZdZdZeZdZddd�Zddd�Z dd d �Z d d � Z d e fdd�Z e Zdd� ZdS )rE a An IPv4 host address. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv4 address associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. ��addressr( N�0.0.0.0c C s2 t |t�r |�d�}t�|�}|| _t|�| _dS )�� @type address: L{bytes} or L{str} @param address: The IPv4 address associated with this record, in quad-dotted notation. r� N)r� ry r� �socket� inet_atonrX r� r( �r� rX r( r{ r{ r| r� � s zRecord_A.__init__c C � |� | j� d S r� �r� rX r r{ r{ r| r� � � zRecord_A.encodec C � t |d�| _d S )Nr� �r� rX rO r{ r{ r| r� � r` zRecord_A.decodec C r� r� �r� rX r� r{ r{ r| r� � r� zRecord_A.__hash__r� c C s d| � � � d| j� d�S )Nz <A address=z ttl=r )� dottedQuadr( r� r{ r{ r| r� � � zRecord_A.__str__c C � t �| j�S r� �r[ � inet_ntoarX r� r{ r{ r| rd � s zRecord_A.dottedQuad)rY Nr� )r� r� r� r� r/ r r� rX r� r� r� r� r� r� r rd r{ r{ r{ r| rE � s rE c @ sV e Zd ZdZdZdZdZeZ ddd �Z dd d �Z dd d �Z dd� Z dS )rX aA Marks the start of a zone of authority. This record describes parameters which are shared by all records within a particular zone. @type mname: L{Name} @ivar mname: The domain-name of the name server that was the original or primary source of data for this zone. @type rname: L{Name} @ivar rname: A domain-name which specifies the mailbox of the person responsible for this zone. @type serial: L{int} @ivar serial: The unsigned 32 bit version number of the original copy of the zone. Zone transfers preserve this value. This value wraps and should be compared using sequence space arithmetic. @type refresh: L{int} @ivar refresh: A 32 bit time interval before the zone should be refreshed. @type minimum: L{int} @ivar minimum: The unsigned 32 bit minimum TTL field that should be exported with any RR from this zone. @type expire: L{int} @ivar expire: A 32 bit time value that specifies the upper limit on the time interval that can elapse before the zone is no longer authoritative. @type retry: L{int} @ivar retry: A 32 bit time interval that should elapse before a failed refresh should be retried. @type ttl: L{int} @ivar ttl: The default TTL to use for records served from this zone. r- )�serial�mname�rname�refresh�expire�retry�minimumr( ))rj rj rN )rk rk rN ri rl rn rm ro r( r� r Nc C sZ t |�t |�| _| _t|�t|�| _| _t|�t|�| _| _t|�| _t|�| _ dS )z� @param mname: See L{Record_SOA.mname} @type mname: L{bytes} or L{str} @param rname: See L{Record_SOA.rname} @type rname: L{bytes} or L{str} N) rg rj rk r� ri rl ro rm rn r( ) r� rj rk ri rl rn rm ro r( r{ r{ r| r� % s zRecord_SOA.__init__c C sD | j �||� | j�||� |�t�d| j| j| j| j | j �� d S )N�!LlllL) rj r� rk r� r� r� ri rl rn rm ro r r{ r{ r| r� = s ��zRecord_SOA.encodec C sX t � t � | _| _| j�|� | j�|� t�dt|d��}|\| _| _| _ | _ | _ d S )Nrp � ) rg rj rk r� r� r� r� ri rl rn rm ro �r� r� r� rG r{ r{ r| r� K s zRecord_SOA.decodec C � t | j| j| j| j| j| jf�S r� )r� ri rj rk rl rm rn r� r{ r{ r| r� R s �zRecord_SOA.__hash__)r� r� r r r r r Nr� ) r� r� r� r� rS r/ r: r- r� r� r� r� r� r{ r{ r{ r| rX � s$ ' � rX c @ sN e Zd ZdZdZdefdfZdZeZ ddd�Z dd d �Z dd d �Z d d� Z dS )rU z� A null record. This is an experimental record type. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r) r) r( )r) r( Nc C � || _ t|�| _d S r� )r) r� r( )r� r) r( r{ r{ r| r� j � zRecord_NULL.__init__c C r^ r� )r� r) r r{ r{ r| r� n r` zRecord_NULL.encodec C s t ||�| _d S r� )r� r) rO r{ r{ r| r� q r` zRecord_NULL.decodec C r� r� )r� r) r� r{ r{ r| r� t r� zRecord_NULL.__hash__)NNr� )r� r� r� r� rS r� r: r/ r) r� r� r� r� r� r{ r{ r{ r| rU X s rU c @ sV e Zd ZdZdZdZg d�ZeZe dd� �Z dd d �Z dd d�Z ddd�Z dd� Zd S )r^ aX A well known service description. This record type is obsolete. See L{Record_SRV}. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv4 address associated with this record. @type protocol: L{int} @ivar protocol: The 8 bit IP protocol number for which this service map is relevant. @type map: L{bytes} @ivar map: A bitvector indicating the services available at the specified address. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r3 )rX r �mapr( )��_addressrX rN r r( c C rf r� rg r� r{ r{ r| rx � s zRecord_WKS._addressrY r r� Nc C s< t |t�r |�d�}t�|�| _||| _| _t|�| _ dS )rZ r� N) r� ry r� r[ r\ rX r rv r� r( )r� rX r rv r( r{ r{ r| r� � s zRecord_WKS.__init__c C s0 |� | j� |� t�d| j�� |� | j� d S �N�!B)r� rX r� r� r rv r r{ r{ r| r� � s zRecord_WKS.encodec C s8 t |d�| _t�dt |d��d | _t ||d �| _d S )Nr� rz r~ r r� )r� rX r� r� r rv rO r{ r{ r| r� � s zRecord_WKS.decodec C � t | j| j| jf�S r� )r� rX r rv r� r{ r{ r| r� � � zRecord_WKS.__hash__)rY r r� Nr� )r� r� r� r� rS r/ r: r3 r� r; rx r� r� r� r� r{ r{ r{ r| r^ x s r^ c @ sR e Zd ZdZeZdZdZdZe dd� �Z dd d �Z dd d �Z dd d�Z dd� ZdS )rG aT An IPv6 host address. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv6 address associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1886.html} r )rw r( rW c C � t �t| j�S r� )r[ � inet_ntop�AF_INET6rX r� r{ r{ r| rx � � zRecord_AAAA._address�::Nc C s0 t |t�r |�d�}t�t|�| _t|�| _dS )z @type address: L{bytes} or L{str} @param address: The IPv6 address for this host, in RFC 2373 format. r� N) r� ry r� r[ � inet_ptonr rX r� r( r] r{ r{ r| r� � s zRecord_AAAA.__init__c C r^ r� r_ r r{ r{ r| r� � r` zRecord_AAAA.encodec C ra )Nr� rb rO r{ r{ r| r� � r` zRecord_AAAA.decodec C r� r� rc r� r{ r{ r| r� � r� zRecord_AAAA.__hash__)r� Nr� )r� r� r� r� r r� rS r: r/ r; rx r� r� r� r� r{ r{ r{ r| rG � s rG c @ sr e Zd ZdZeZdZdZdZe dd� �Z dd d �Z dd d�Z ddd�Z dedefdd�Zdd� Zdefdd�Zd S )rF a� An IPv6 address. This is an experimental record type. @type prefixLen: L{int} @ivar prefixLen: The length of the suffix. @type suffix: L{bytes} @ivar suffix: An IPv6 address suffix in network order. @type prefix: L{Name} @ivar prefix: If specified, a name which will be used as a prefix for other A6 records. @type bytes: L{int} @ivar bytes: The length of the prefix. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2874.html} @see: U{http://www.faqs.org/rfcs/rfc3363.html} @see: U{http://www.faqs.org/rfcs/rfc3364.html} r ))�_suffix�suffixrN )rE rE rN r( )� prefixLenrE r� r( c C r} r� )r[ r~ r r� r� r{ r{ r| r� r� zRecord_A6._suffixr r� r� Nc C sT t |t�r |�d�}|| _t�t|�| _t|�| _ t d| j d �| _t |�| _ dS )z� @param suffix: An IPv6 address suffix in in RFC 2373 format. @type suffix: L{bytes} or L{str} @param prefix: An IPv6 address prefix for other A6 records. @type prefix: L{bytes} or L{str} r� � � @N) r� ry r� r� r[ r� r r� rg rE r� r� r( )r� r� r� rE r( r{ r{ r| r� s zRecord_A6.__init__c C sN |� t�d| j�� | jr|� | j| j d � � | jr%| j�|d � d S d S ry )r� r� r� r� ry r� rE r� r r{ r{ r| r� s �zRecord_A6.encodec C sh t �dt|d��d | _td| j d �| _| jr'dd| j t|| j� | _| jr2| j�|� d S d S )Nrz r~ r r� r� r� r� ) r� r� r� r� r� ry r� rE r� rO r{ r{ r| r� $ s �zRecord_A6.decoder� r� c C sV t |t�r)| j|jko(| j| j d � |j| j d � ko(| j|jko(| j|jkS tS r� )r� rF r� r� ry rE r( r� r� r{ r{ r| r� , s "� � �zRecord_A6.__eq__c C s t | j| j| j d � | jf�S r� )r� r� r� ry rE r� r{ r{ r| r� 6 r zRecord_A6.__hash__c C s d| j t�t| j�| j| jf S )Nz<A6 %s %s (%d) ttl=%s>)rE r[ r~ r r� r� r( r� r{ r{ r| r� 9 s �zRecord_A6.__str__)r r� r� Nr� )r� r� r� r� r r� rS r: r/ r; r� r� r� r� r� r� r� r� r� r� r{ r{ r{ r| rF � s rF c @ �F e Zd ZdZeZdZdZdZddd �Z dd d �Z dd d �Z dd� Z dS )rZ a: The location of the server(s) for a specific protocol and domain. This is an experimental record type. @type priority: L{int} @ivar priority: The priority of this target host. A client MUST attempt to contact the target host with the lowest-numbered priority it can reach; target hosts with the same priority SHOULD be tried in an order defined by the weight field. @type weight: L{int} @ivar weight: Specifies a relative weight for entries with the same priority. Larger weights SHOULD be given a proportionately higher probability of being selected. @type port: L{int} @ivar port: The port on this target host of this service. @type target: L{Name} @ivar target: The domain name of the target host. There MUST be one or more address records for this name, the name MUST NOT be an alias (in the sense of RFC 1034 or RFC 2181). Implementors are urged, but not required, to return the address record(s) in the Additional Data section. Unless and until permitted by future standards action, name compression is not to be used for this field. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2782.html} r/ )�priority�weight�target�portr( )r� r� )r� r� rN r� r( r r� Nc C s6 t |�| _t |�| _t |�| _t|�| _t|�| _dS )zb @param target: See L{Record_SRV.target} @type target: L{bytes} or L{str} N)r� r� r� r� rg r� r� r( )r� r� r� r� r� r( r{ r{ r| r� l s zRecord_SRV.__init__c C s. |� t�d| j| j| j�� | j�|d � d S �N�!HHH)r� r� r� r� r� r� r� r� r r{ r{ r| r� w s zRecord_SRV.encodec C s@ t �dt|t �d���}|\| _| _| _t� | _| j� |� d S r� ) r� r� r� r@ r� r� r� rg r� r� rr r{ r{ r| r� | s zRecord_SRV.decodec C � t | j| j| j| jf�S r� )r� r� r� r� r� r� r{ r{ r| r� � re zRecord_SRV.__hash__)r r r r� Nr� ) r� r� r� r� r/ r� rS r/ r: r� r� r� r� r{ r{ r{ r| rZ B s " rZ c @ sT e Zd ZdZeZdZdZdZ ddd �Z dd d �Z dd d �Z dd� Z dS )rS a The location of the server(s) for a specific protocol and domain. @type order: L{int} @ivar order: An integer specifying the order in which the NAPTR records MUST be processed to ensure the correct ordering of rules. Low numbers are processed before high numbers. @type preference: L{int} @ivar preference: An integer that specifies the order in which NAPTR records with equal "order" values SHOULD be processed, low numbers being processed before high numbers. @type flag: L{Charstr} @ivar flag: A <character-string> containing flags to control aspects of the rewriting and interpretation of the fields in the record. Flags are single characters from the set [A-Z0-9]. The case of the alphabetic characters is not significant. At this time only four flags, "S", "A", "U", and "P", are defined. @type service: L{Charstr} @ivar service: Specifies the service(s) available down this rewrite path. It may also specify the particular protocol that is used to talk with a service. A protocol MUST be specified if the flags field states that the NAPTR is terminal. @type regexp: L{Charstr} @ivar regexp: A STRING containing a substitution expression that is applied to the original string held by the client in order to construct the next domain name to lookup. @type replacement: L{Name} @ivar replacement: The next NAME to query for NAPTR, SRV, or address records depending on the value of the flags field. This MUST be a fully qualified domain-name. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2915.html} )�order� preference�flags�service�regexp� replacementr' )r� r� )r� r� rN )r� r� rN )r� r� rN )r� r� rN r( r r� Nc C sJ t |�| _t |�| _t|�| _t|�| _t|�| _t|�| _t |�| _ dS )zs @param replacement: See L{Record_NAPTR.replacement} @type replacement: L{bytes} or L{str} N) r� r� r� re r� r� r� rg r� r� r( )r� r� r� r� r� r� r� r( r{ r{ r| r� � s zRecord_NAPTR.__init__c C sT |� t�d| j| j�� | j�|d � | j�|d � | j�|d � | j �|d � d S r ) r� r� r� r� r� r� r� r� r� r� r r{ r{ r| r� � s zRecord_NAPTR.encodec C sx t �dt|t �d���}|\| _| _t� | _t� | _t� | _ t � | _ | j� |� | j� |� | j � |� | j � |� d S r ) r� r� r� r@ r� r� re r� r� r� rg r� r� rr r{ r{ r| r� � s zRecord_NAPTR.decodec C rs r� )r� r� r� r� r� r� r� r� r{ r{ r| r� � s ��zRecord_NAPTR.__hash__)r r r� r� r� r� Nr� ) r� r� r� r� r' r� r/ rS r: r� r� r� r� r{ r{ r{ r| rS � s" , � rS c @ r� )rH a� Map from a domain name to the name of an AFS cell database server. @type subtype: L{int} @ivar subtype: In the case of subtype 1, the host has an AFS version 3.0 Volume Location Server for the named AFS cell. In the case of subtype 2, the host has an authenticated name server holding the cell-root directory node for the named DCE/NCA cell. @type hostname: L{Name} @ivar hostname: The domain name of a host that has a server for the cell named by this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1183.html} r )�subtype�hostnamer( )r� )r� r� rN r( r r� Nc C s" t |�| _t|�| _t|�| _dS )zj @param hostname: See L{Record_AFSDB.hostname} @type hostname: L{bytes} or L{str} N)r� r� rg r� r� r( )r� r� r� r( r{ r{ r| r� s zRecord_AFSDB.__init__c C �& |� t�d| j�� | j�||� d S �Nr� )r� r� r� r� r� r� r r{ r{ r| r� & � zRecord_AFSDB.encodec C s0 t �dt|t �d���}|\| _| j�|� d S r� )r� r� r� r@ r� r� r� rr r{ r{ r| r� * � zRecord_AFSDB.decodec C � t | j| jf�S r� )r� r� r� r� r{ r{ r| r� / r` zRecord_AFSDB.__hash__�r r� Nr� ) r� r� r� r� r r� rS r/ r: r� r� r� r� r{ r{ r{ r| rH s rH c @ sF e Zd ZdZeZdZdZdZddd�Z dd d �Z dd d �Z d d� Z dS )rW a� The responsible person for a domain. @type mbox: L{Name} @ivar mbox: A domain name that specifies the mailbox for the responsible person. @type txt: L{Name} @ivar txt: A domain name for which TXT RR's exist (indirection through which allows information sharing about the contents of this RP record). @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1183.html} r, )�mbox�txtr( ))r� r� rN )r� r� rN r( r� Nc C s" t |�| _t |�| _t|�| _dS )z� @param mbox: See L{Record_RP.mbox}. @type mbox: L{bytes} or L{str} @param txt: See L{Record_RP.txt} @type txt: L{bytes} or L{str} N)rg r� r� r� r( )r� r� r� r( r{ r{ r| r� M s zRecord_RP.__init__c C � | j �||� | j�||� d S r� )r� r� r� r r{ r{ r| r� Y � zRecord_RP.encodec C s, t � | _t � | _| j�|� | j�|� d S r� )rg r� r� r� rO r{ r{ r| r� ] s zRecord_RP.decodec C r� r� )r� r� r� r� r{ r{ r| r� c r` zRecord_RP.__hash__�r� r� Nr� ) r� r� r� r� r, r� rS r/ r: r� r� r� r� r{ r{ r{ r| rW 3 s rW c @ sf e Zd ZdZeZdZdefdefdfZdZ dd d �Z dd d �Z dd d�Z de defdd�Zdd� ZdS )rK a Host information. @type cpu: L{bytes} @ivar cpu: Specifies the CPU type. @type os: L{bytes} @ivar os: Specifies the OS. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r �cpu�osr( )r� r� r( r� Nc C s ||| _ | _t|�| _d S r� )r� r� r� r( )r� r� r� r( r{ r{ r| r� } s zRecord_HINFO.__init__c C s@ |� t�dt| j��| j � |� t�dt| j��| j � d S ry )r� r� r� r� r� r� r r{ r{ r| r� � s "zRecord_HINFO.encodec C sH t �dt|d��d }t||�| _t �dt|d��d }t||�| _d S )Nrz r~ r )r� r� r� r� r� )r� r� r� r� r� r{ r{ r| r� � s zRecord_HINFO.decoder� r� c C sB t |t�r | j�� |j�� ko | j�� |j�� ko | j|jkS tS r� )r� rK r� r� r� r( r� r� r{ r{ r| r� � s � �zRecord_HINFO.__eq__c C s t | j�� | j�� f�S r� )r� r� r� r� r� r{ r{ r| r� � re zRecord_HINFO.__hash__r� r� )r� r� r� r� r r� rS r� r: r/ r� r� r� r� r� r� r� r{ r{ r{ r| rK g s rK c @ sN e Zd ZdZeZdZdZdZdZ dZ ddd�Z dd d �Z dd d �Z d d� ZdS )rP a� Mailbox or mail list information. This is an experimental record type. @type rmailbx: L{Name} @ivar rmailbx: A domain-name which specifies a mailbox which is responsible for the mailing list or mailbox. If this domain name names the root, the owner of the MINFO RR is responsible for itself. @type emailbx: L{Name} @ivar emailbx: A domain-name which specifies a mailbox which is to receive error messages related to the mailing list or mailbox specified by the owner of the MINFO record. If this domain name names the root, errors should be returned to the sender of the message. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. Nr$ )�rmailbx�emailbxr( ))r� �responsibilityrN )r� �errorsrN r( r� c C s$ t |�t |�| _| _t|�| _dS )z� @param rmailbx: See L{Record_MINFO.rmailbx}. @type rmailbx: L{bytes} or L{str} @param emailbx: See L{Record_MINFO.rmailbx}. @type emailbx: L{bytes} or L{str} N)rg r� r� r� r( )r� r� r� r( r{ r{ r| r� � s zRecord_MINFO.__init__c C r� r� )r� r� r� r r{ r{ r| r� � r� zRecord_MINFO.encodec C s. t � t � | _| _| j�|� | j�|� d S r� )rg r� r� r� rO r{ r{ r| r� � s zRecord_MINFO.decodec C r� r� )r� r� r� r� r{ r{ r| r� � r` zRecord_MINFO.__hash__r� r� )r� r� r� r� r$ r� r� r� rS r/ r: r� r� r� r� r{ r{ r{ r| rP � s rP c @ r� )rR a� Mail exchange. @type preference: L{int} @ivar preference: Specifies the preference given to this RR among others at the same owner. Lower values are preferred. @type name: L{Name} @ivar name: A domain-name which specifies a host willing to act as a mail exchange. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r& )r� r� r( )r� rM r( r r� Nc K s* t |�| _t|�d|��| _t|�| _dS )z\ @param name: See L{Record_MX.name}. @type name: L{bytes} or L{str} �exchangeN)r� r� rg r r� r� r( )r� r� r� r( �kwargsr{ r{ r| r� � s zRecord_MX.__init__c C r� r� )r� r� r� r� r� r� r r{ r{ r| r� � r� zRecord_MX.encodec C s0 t �dt|d��d | _t� | _| j�|� d S )Nr� r� r )r� r� r� r� rg r� r� rO r{ r{ r| r� � r� zRecord_MX.decodec C r� r� )r� r� r� r� r{ r{ r| r� � r` zRecord_MX.__hash__r� r� ) r� r� r� r� r& r� rS r/ r: r� r� r� r� r{ r{ r{ r| rR � s rR c @ s^ e Zd ZdZdZdZdZeZdZ dZ dZ dZ dZ dZdd d �Zddd�Zddd�Zdd� Zd S )r[ ab A record containing the fingerprint of an SSH key. @type algorithm: L{int} @ivar algorithm: The SSH key's algorithm, such as L{ALGORITHM_RSA}. Note that the numbering used for SSH key algorithms is specific to the SSHFP record, and is not the same as the numbering used for KEY or SIG records. @type fingerprintType: L{int} @ivar fingerprintType: The fingerprint type, such as L{FINGERPRINT_TYPE_SHA256}. @type fingerprint: L{bytes} @ivar fingerprint: The key's fingerprint, e.g. a 32-byte SHA-256 digest. @cvar ALGORITHM_RSA: The algorithm value for C{ssh-rsa} keys. @cvar ALGORITHM_DSS: The algorithm value for C{ssh-dss} keys. @cvar ALGORITHM_ECDSA: The algorithm value for C{ecdsa-sha2-*} keys. @cvar ALGORITHM_Ed25519: The algorithm value for C{ed25519} keys. @cvar FINGERPRINT_TYPE_SHA1: The type for SHA-1 fingerprints. @cvar FINGERPRINT_TYPE_SHA256: The type for SHA-256 fingerprints. @see: U{RFC 4255 <https://tools.ietf.org/html/rfc4255>} and U{RFC 6594 <https://tools.ietf.org/html/rfc6594>} r1 �� algorithm�fingerprintType� fingerprintr( )r� r� r� r~ r� r� r� r r� c C s || _ || _|| _|| _d S r� r� )r� r� r� r� r( r{ r{ r| r� / s zRecord_SSHFP.__init__Nc C s( |� t�d| j| j�� |� | j� d S )N�!BB)r� r� r� r� r� r� r r{ r{ r| r� 5 s zRecord_SSHFP.encodec C s2 t �dt|d��}|\| _| _t||d �| _d S )Nr� r� )r� r� r� r� r� r� rr r{ r{ r| r� 9 s zRecord_SSHFP.decodec C r{ r� )r� r� r� r� r� r{ r{ r| r� > r| zRecord_SSHFP.__hash__)r r r� r r� )r� r� r� r� rS r/ r: r1 r� � ALGORITHM_RSA� ALGORITHM_DSS�ALGORITHM_ECDSA�ALGORITHM_Ed25519�FINGERPRINT_TYPE_SHA1�FINGERPRINT_TYPE_SHA256r� r� r� r� r{ r{ r{ r| r[ s r[ c @ sL e Zd ZdZeZdZdefdfZdZ dd� Z dd d �Z dd d �Z d d� Z dS )r] z� Freeform text. @type data: L{list} of L{bytes} @ivar data: Freeform text which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r0 r5 r( �r5 r( c O s t |�| _t|�dd ��| _d S )Nr( )r� r5 r� r r( )r� r5 �kwr{ r{ r| r� T s zRecord_TXT.__init__Nc C s* | j D ]}|�t�dt|��| � qd S ry )r5 r� r� r� r� )r� r� r� �dr{ r{ r| r� Y s �zRecord_TXT.encodec C st d}g | _ ||k r't�dt|d��d }| j �t||�� ||d 7 }||k s ||kr8t�d|| j|f � d S d S )Nr rz r~ z1Decoded %d bytes in %s record, but rdlength is %d)r5 r� r� r� r� r �msgrS )r� r� r� �soFar�Lr{ r{ r| r� ] s � ���zRecord_TXT.decodec C s t t| j��S r� )r� �tupler5 r� r{ r{ r| r� j s zRecord_TXT.__hash__r� )r� r� r� r� r0 r� rS r� r: r/ r� r� r� r� r{ r{ r{ r| r] B s r] c @ sN e Zd ZdZdZdZdZdefdfZddd �Z dd d �Z dd d �Z dd� Z dS )r_ a> Encapsulate the wire data for unknown record types so that they can pass through the system unchanged. @type data: L{bytes} @ivar data: Wire data which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @since: 11.1 N�UNKNOWNr� r5 r( r� c C rt r� )r5 r� r( )r� r5 r( r{ r{ r| r� � ru zUnknownRecord.__init__c C s |� | j� dS )zc Write the raw bytes corresponding to this record's payload to the stream. N)r� r5 r r{ r{ r| r� � � zUnknownRecord.encodec C s |du rt d��t||�| _dS )z~ Load the bytes which are part of this record from the stream and store them unparsed and unmodified. Nz)must know length for unknown record types)� Exceptionr� r5 rO r{ r{ r| r� � s zUnknownRecord.decodec C r� r� )r� r5 r( r� r{ r{ r| r� � r` zUnknownRecord.__hash__rP r� ) r� r� r� r� r� rS r/ r� r: r� r� r� r� r{ r{ r{ r| r_ n s r_ c @ rR )rY ao Structurally, freeform text. Semantically, a policy definition, formatted as defined in U{rfc 4408<http://www.faqs.org/rfcs/rfc4408.html>}. @type data: L{list} of L{bytes} @ivar data: Freeform text which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. r. N)r� r� r� r� r. r� rS r{ r{ r{ r| rY � s rY c @ sZ e Zd ZdZdZdZg d�ZeZddddde ddfd d �Z dd d �Z dd d�Z dd� Z dS )r\ a� A transaction signature, encapsulated in a RR, as described in U{RFC 2845 <https://tools.ietf.org/html/rfc2845>}. @type algorithm: L{Name} @ivar algorithm: The name of the signature or MAC algorithm. @type timeSigned: L{int} @ivar timeSigned: Signing time, as seconds from the POSIX epoch. @type fudge: L{int} @ivar fudge: Allowable time skew, in seconds. @type MAC: L{bytes} @ivar MAC: The message digest or signature. @type originalID: L{int} @ivar originalID: A message ID. @type error: L{int} @ivar error: An error code (extended C{RCODE}) carried in exceptional cases. @type otherData: L{bytes} @ivar otherData: Other data carried in exceptional cases. r2 )r� � timeSigned�fudge�MAC� originalID�error� otherDatar( )r� r� r� r� r� Nr� r r� c C sH |d u rd nt |�| _|| _t|�| _|| _|| _|| _|| _|| _ d S r� ) rg r� r� r� r� r� r� r� r� r( ) r� r� r� r� r� r� r� r� r( r{ r{ r| r� � s zRecord_TSIG.__init__c C s� | j �||� |�t�d| j�dd � � |�t�d| jt| j��� |�| j� |�t�d| j | j t| j ��� |�| j � d S )Nz!Qr� r r� ) r� r� r� r� r� r� r� r� r� r� r� r� r r{ r{ r| r� � s �zRecord_TSIG.encodec C sv t � }|�|� || _t�ddt|d� �}|\| _| _}t||�| _t�dt|d��}|\| _ | _ }t||�| _ d S )Nz!QHHs � r� r� ) rg r� r� r� r� r� r� r� r� r� r� r� )r� r� r� r� �fields� macLength� otherLengthr{ r{ r| r� � s zRecord_TSIG.decodec C r� r� )r� r� r� r� r� r� r{ r{ r| r� re zRecord_TSIG.__hash__r� )r� r� r� r� rS r/ r: r2 r� rn r� r� r� r� r{ r{ r{ r| r\ � s$ � r\ c K s* | d|j dd�|��}|jdd� |_|S )a� Generate a L{Message} like instance suitable for use as the response to C{message}. The C{queries}, C{id} attributes will be copied from C{message} and the C{answer} flag will be set to L{True}. @param responseConstructor: A response message constructor with an initializer signature matching L{dns.Message.__init__}. @type responseConstructor: C{callable} @param message: A request message. @type message: L{Message} @param kwargs: Keyword arguments which will be passed to the initialiser of the response message. @type kwargs: L{dict} @return: A L{Message} like response instance. @rtype: C{responseConstructor} T)�id�answerNr{ )r� �queries)�responseConstructor�messager� �responser{ r{ r| �_responseFromMessage s r� c C s^ g }t �| jj�}|D ]!}|j| j}t| ||�}||v s!||kr,|�d|� d|��� q |S )a� Inspect the function signature of C{obj}'s constructor, and get a list of which arguments should be displayed. This is a helper function for C{_compactRepr}. @param obj: The instance whose repr is being generated. @param alwaysShow: A L{list} of field names which should always be shown. @param fieldNames: A L{list} of field attribute names which should be shown if they have non-default values. @return: A L{list} of displayable arguments. r �=)�inspect� signature� __class__r� � parameters�defaultr1 r� )�obj� alwaysShow� fieldNames�displayableArgsr� r� � defaultValue� fieldValuer{ r{ r| �_getDisplayableArguments& s �r� c C s� |du rg }|du r g }|du rg }|du rg }g }|D ]}||v s*t | |d�dkr/|�|� q t| ||�}d| jjg| }|rK|�d�d�|��� |D ]}t | |g �} | rb|�d|� d| ��� qM|�d � d �|�S ) a� Return a L{str} representation of C{obj} which only shows fields with non-default values, flags which are True and sections which have been explicitly set. @param obj: The instance whose repr is being generated. @param alwaysShow: A L{list} of field names which should always be shown. @param flagNames: A L{list} of flag attribute names which should be shown if they are L{True}. @param fieldNames: A L{list} of field attribute names which should be shown if they have non-default values. @param sectionNames: A L{list} of section attribute names which should be shown if they have been assigned a value. @return: A L{str} representation of C{obj}. NFT�<z flags={}�,r r� r � )r1 r� r� r� r� r� r� ) r� r� � flagNamesr� � sectionNames�setFlagsr� r� �out�sectionr{ r{ r| � _compactRepr> s0 � � r� c @ s� e Zd ZdZdZdZe�e�Zd Z Z Z Z dddddde ddddf dd�Zd efd d �Zeefd d �Zdd� Zddd�Zdd� Zi Ze� D ]Ze�d�rYe� e ee� e j< qG[dd� Z dd� Z dd� Z dS ) rf ah L{Message} contains all the information represented by a single DNS request or response. @ivar id: See L{__init__} @ivar answer: See L{__init__} @ivar opCode: See L{__init__} @ivar recDes: See L{__init__} @ivar recAv: See L{__init__} @ivar auth: See L{__init__} @ivar rCode: See L{__init__} @ivar trunc: See L{__init__} @ivar maxSize: See L{__init__} @ivar authenticData: See L{__init__} @ivar checkingDisabled: See L{__init__} @ivar queries: The queries which are being asked of or answered by DNS server. @type queries: L{list} of L{Query} @ivar answers: Records containing the answers to C{queries} if this is a response message. @type answers: L{list} of L{RRHeader} @ivar authority: Records containing information about the authoritative DNS servers for the names in C{queries}. @type authority: L{list} of L{RRHeader} @ivar additional: Records containing IP addresses of host names in C{answers} and C{authority}. @type additional: L{list} of L{RRHeader} @ivar _flagNames: The names of attributes representing the flag header fields. @ivar _fieldNames: The names of attributes representing non-flag fixed header fields. @ivar _sectionNames: The names of attributes representing the record sections of this message. )r� r� �opCode�recDes�recAvrA �rCode�trunc�maxSize� authenticData�checkingDisabledr� �answers� authority� additionalz!H2B4HNr � c C s^ | | _ || _|| _|| _|| _|| _|| _|| _|| _| | _ | | _ g | _ g | _ g | _ g | _dS )a� @param id: A 16 bit identifier assigned by the program that generates any kind of query. This identifier is copied to the corresponding reply and can be used by the requester to match up replies to outstanding queries. @type id: L{int} @param answer: A one bit field that specifies whether this message is a query (0), or a response (1). @type answer: L{int} @param opCode: A four bit field that specifies kind of query in this message. This value is set by the originator of a query and copied into the response. @type opCode: L{int} @param recDes: Recursion Desired - this bit may be set in a query and is copied into the response. If RD is set, it directs the name server to pursue the query recursively. Recursive query support is optional. @type recDes: L{int} @param recAv: Recursion Available - this bit is set or cleared in a response and denotes whether recursive query support is available in the name server. @type recAv: L{int} @param auth: Authoritative Answer - this bit is valid in responses and specifies that the responding name server is an authority for the domain name in question section. @type auth: L{int} @ivar rCode: A response code, used to indicate success or failure in a message which is a response from a server to a client request. @type rCode: C{0 <= int < 16} @param trunc: A flag indicating that this message was truncated due to length greater than that permitted on the transmission channel. @type trunc: L{int} @param maxSize: The requestor's UDP payload size is the number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type maxSize: L{int} @param authenticData: A flag indicating in a response that all the data included in the answer and authority portion of the response has been authenticated by the server according to the policies of that server. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{int} @param checkingDisabled: A flag indicating in a query that pending (non-authenticated) data is acceptable to the resolver sending the query. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{int} N)r� r� r� r� rA r� r� r� r� r� r� r� r� r� r� ) r� r� r� r� r� r� rA r� r� r� r� r� r{ r{ r| r� � s J zMessage.__init__r� c C � t | ddddd�S )z� Generate a repr of this L{Message}. Only includes the non-default fields and sections and only includes flags which are set. The C{id} is always shown. @return: The native string repr. )r� rA r� r� r� r� r� )r� r� r� r� �r� r� r� r� �r� �r� r� r� r� �r� r� r{ r{ r| r s �zMessage.__repr__c C s | j �t|||�� dS )z� Add another query to this Message. @type name: L{bytes} @param name: The name to query. @type type: L{int} @param type: Query type @type cls: L{int} @param cls: Query class N)r� r� rh r r{ r{ r| �addQuery' s zMessage.addQueryc C sh i }t � }| jD ]}|�||� q| jD ]}|�||� q| jD ]}|�||� q | jD ]}|�||� q,|�� }t|�| j }| j rU|| j krUd| _ |d | j | j � }| j d@ d> | j d@ d> B | j d@ d> B | j d@ d> B | jd@ B }| jd@ d> | jd@ d> B | jd@ d> B | jd@ B }|�t�| j| j||t| j�t| j�t| j�t| j��� |�|� d S )Nr~ � r' r� r� r� r� )r r� r� r� r� r� r* r� r� r� r� r� r� rA r� r� r� r� r� r� r� r� � headerFmtr� ) r� r� r� �body_tmp�q�body�size�byte3�byte4r{ r{ r| r� 6 s\ � � ��� � ����� zMessage.encodec C s2 d| _ t|| j�}t�| j|�}|\| _}}}}} } |d? d@ | _|d? d@ | _|d? d@ | _ |d? d@ | _ |d@ | _ |d? d@ | _ |d? d@ | _ |d? d@ | _|d@ | _g | _t|�D ] } t� } z| �|� W n tys Y d S w | j�| � q\| j|f| j| f| j| ff} | D ] \}}| �|||� q�d S ) Nr r� r~ r� r' r� r� r� )r� r� r� r� r� r� r� r� r� rA r� r� r� r� r� r� r� �rangerh r� r� r� r� r� r� � parseRecords)r� r� r� �headerrG r� r �nqueries�nans�nns�nadd�ir� �itemsr� r r{ r{ r| r� b s4 � �zMessage.decodec C s� t |�D ]F}t| jd�}z|�|� W n ty Y d S w | �|j�}|s(q||jd�|_z |j�||j � W n tyD Y d S w |� |� qd S )NrH )r( ) r ri rA r� r� �lookupRecordTyper� r( r) r- r� )r� r� �numr� r r r r{ r{ r| r s$ � � �zMessage.parseRecords�Record_c C s | j �|t�S )aC Retrieve the L{IRecord} implementation for the given record type. @param type: A record type, such as C{A} or L{NS}. @type type: L{int} @return: An object which implements L{IRecord} or L{None} if none can be found for the given type. @rtype: C{Type[IRecord]} )� _recordTypesr r_ )r� r� r{ r{ r| r � s zMessage.lookupRecordTypec C s t � }| �|� |�� S )z� Encode this L{Message} into a byte string in the format described by RFC 1035. @rtype: L{bytes} )r r� r* )r� r� r{ r{ r| �toStr� s z Message.toStrc C s t |�}| �|� dS )z� Decode a byte string in the format described by RFC 1035 into this L{Message}. @param str: L{bytes} N)r r� )r� r� r� r{ r{ r| �fromStr� s zMessage.fromStrr� ) r� r� r� r� r/ r� r� r@ r� r� r� r �nsrn r� r� r r9 r8 r� r� r� r r �globalsr� � startswithr� r r r r{ r{ r{ r| rf r s@ ( �[ , � rf c @ sv e Zd ZdZdZeZddeddddddddddddddfdd�Zd e fd d �Z d d � Z dd� Z e dd� �Zdd� ZdS )� _EDNSMessagea� An I{EDNS} message. Designed for compatibility with L{Message} but with a narrower public interface. Most importantly, L{_EDNSMessage.fromStr} will interpret and remove I{OPT} records that are present in the additional records section. The I{OPT} records are used to populate certain I{EDNS} specific attributes. L{_EDNSMessage.toStr} will add suitable I{OPT} records to the additional section to represent the extended EDNS information. @see: U{https://tools.ietf.org/html/rfc6891} @ivar id: See L{__init__} @ivar answer: See L{__init__} @ivar opCode: See L{__init__} @ivar auth: See L{__init__} @ivar trunc: See L{__init__} @ivar recDes: See L{__init__} @ivar recAv: See L{__init__} @ivar rCode: See L{__init__} @ivar ednsVersion: See L{__init__} @ivar dnssecOK: See L{__init__} @ivar authenticData: See L{__init__} @ivar checkingDisabled: See L{__init__} @ivar maxSize: See L{__init__} @ivar queries: See L{__init__} @ivar answers: See L{__init__} @ivar authority: See L{__init__} @ivar additional: See L{__init__} @ivar _messageFactory: A constructor of L{Message} instances. Called by C{_toMessage} and C{_fromMessage}. �r� r� r� rA r� r� r� r� � ednsVersionr" r� r� r� r� r� r� r� r Fr� Nc C s� || _ || _|| _|| _|| _|| _|| _|| _| | _| | _ | | _ | | _ | | _ |du r-g }|| _ |du r6g }|| _|du r?g }|| _|du rHg }|| _dS )a+ Construct a new L{_EDNSMessage} @see: U{RFC1035 section-4.1.1<https://tools.ietf.org/html/rfc1035#section-4.1.1>} @see: U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>} @see: U{RFC3225 section-3<https://tools.ietf.org/html/rfc3225#section-3>} @see: U{RFC6891 section-6.1.3<https://tools.ietf.org/html/rfc6891#section-6.1.3>} @param id: A 16 bit identifier assigned by the program that generates any kind of query. This identifier is copied the corresponding reply and can be used by the requester to match up replies to outstanding queries. @type id: L{int} @param answer: A one bit field that specifies whether this message is a query (0), or a response (1). @type answer: L{bool} @param opCode: A four bit field that specifies kind of query in this message. This value is set by the originator of a query and copied into the response. @type opCode: L{int} @param auth: Authoritative Answer - this bit is valid in responses, and specifies that the responding name server is an authority for the domain name in question section. @type auth: L{bool} @param trunc: Truncation - specifies that this message was truncated due to length greater than that permitted on the transmission channel. @type trunc: L{bool} @param recDes: Recursion Desired - this bit may be set in a query and is copied into the response. If set, it directs the name server to pursue the query recursively. Recursive query support is optional. @type recDes: L{bool} @param recAv: Recursion Available - this bit is set or cleared in a response, and denotes whether recursive query support is available in the name server. @type recAv: L{bool} @param rCode: Extended 12-bit RCODE. Derived from the 4 bits defined in U{RFC1035 4.1.1<https://tools.ietf.org/html/rfc1035#section-4.1.1>} and the upper 8bits defined in U{RFC6891 6.1.3<https://tools.ietf.org/html/rfc6891#section-6.1.3>}. @type rCode: L{int} @param ednsVersion: Indicates the EDNS implementation level. Set to L{None} to prevent any EDNS attributes and options being added to the encoded byte string. @type ednsVersion: L{int} or L{None} @param dnssecOK: DNSSEC OK bit as defined by U{RFC3225 3<https://tools.ietf.org/html/rfc3225#section-3>}. @type dnssecOK: L{bool} @param authenticData: A flag indicating in a response that all the data included in the answer and authority portion of the response has been authenticated by the server according to the policies of that server. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{bool} @param checkingDisabled: A flag indicating in a query that pending (non-authenticated) data is acceptable to the resolver sending the query. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{bool} @param maxSize: The requestor's UDP payload size is the number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type maxSize: L{int} @param queries: The L{list} of L{Query} associated with this message. @type queries: L{list} of L{Query} @param answers: The L{list} of answers associated with this message. @type answers: L{list} of L{RRHeader} @param authority: The L{list} of authority records associated with this message. @type authority: L{list} of L{RRHeader} @param additional: The L{list} of additional records associated with this message. @type additional: L{list} of L{RRHeader} Nr )r� r� r� r� rA r� r� r� r� r r" r� r� r� r� r� r� r� r{ r{ r| r� � s2 m z_EDNSMessage.__init__r� c C r� )N)r� rA r� r� r� r� r� r" )r� r� r� r� r r� r� r� r� r� r{ r{ r| r � s �z_EDNSMessage.__repr__c C s� | j | j| j| j| j| j| j| j| jd@ | j | j d� }| j dd� |_ | j dd� |_ | j dd� |_ | jdd� |_| jdurTt| j| j| j| jd? d�}|j�|� |S )a= Convert to a standard L{dns.Message}. If C{ednsVersion} is not None, an L{_OPTHeader} instance containing all the I{EDNS} specific attributes and options will be appended to the list of C{additional} records. @return: A L{dns.Message} @rtype: L{dns.Message} r' ) r� r� r� rA r� r� r� r� r� r� Nr� )r! r" r r )�_messageFactoryr� r� r� rA r� r� r� r� r� r� r� r� r� r� r r r" r� r� )r� �mr+ r{ r{ r| � _toMessage� s2 � � z_EDNSMessage._toMessagec C s | � � �� S )z~ Encode to wire format by first converting to a standard L{dns.Message}. @return: A L{bytes} string. )r r r� r{ r{ r| r � s z_EDNSMessage.toStrc C s g }g }|j D ]}|jtkr|�t�|�� q|�|� q| di d|j�d|j�d|j�d|j �d|j �d|j �d|j �d|j �d |j�d |j�d d �d d�d|jd d � �d|jd d � �d|jd d � �d|��}t|�dkr�|d }|j|_|j|_|j|_|jd> |j B |_ |S )a� Construct and return a new L{_EDNSMessage} whose attributes and records are derived from the attributes and records of C{message} (a L{Message} instance). If present, an C{OPT} record will be extracted from the C{additional} section and its attributes and options will be used to set the EDNS specific attributes C{extendedRCODE}, C{ednsVersion}, C{dnssecOK}, C{ednsOptions}. The C{extendedRCODE} will be combined with C{message.rCode} and assigned to C{self.rCode}. @param message: The source L{Message}. @type message: L{Message} @return: A new L{_EDNSMessage} @rtype: L{_EDNSMessage} r� r� r� rA r� r� r� r� r� r� r Nr" Fr� r� r� r� r~ r r� r{ )r� r� r* r� r r. r� r� r� rA r� r� r� r� r� r� r� r� r� r� r! r r" r r� r )r r� r� � optRecordsrG � newMessage�optr{ r{ r| � _fromMessage� s\ �������� � � ������ z_EDNSMessage._fromMessagec C s> | � � }|�|� | �|�}| jD ] }t| |t||�� qdS )z� Decode from wire format, saving flags, values and records to this L{_EDNSMessage} instance in place. @param bytes: The full byte string to be decoded. @type bytes: L{bytes} N)r r r r/ r0 r1 )r� ry r � ednsMessager4 r{ r{ r| r s �z_EDNSMessage.fromStr)r� r� r� r� r/ rf r rq r� r� r r r r< r r r{ r{ r{ r| r � s: ' � * <r c @ sB e Zd ZdZdZdZd dd�Zdd� Zdd� Zd d � Z d d � Z dS )rl z� DNS protocol mixin shared by UDP and TCP implementations. @ivar _reactor: A L{IReactorTime} and L{IReactorUDP} provider which will be used to issue DNS queries and manage request timeouts. Nc C s2 || _ t�dd�| _|d u rddlm} || _d S )Ni i � r )�reactor)� controller�random� randranger� �twisted.internetr �_reactor)r� r r r{ r{ r| r� % s zDNSMixin.__init__c C s t � }|| jvr |S q)z1 Return a unique ID for queries. )r� � liveMessages�r� r� r{ r{ r| �pickID, s �zDNSMixin.pickIDc G s | j j||g|�R � S )zL Wrapper around reactor.callLater, mainly for test purpose. )r# � callLater)r� �period�func�argsr{ r{ r| r' 5 s zDNSMixin.callLaterc C sf t |dd�}||_z||� W n ty t�� Y S w t�� }| �|| j||�}||f| j|< |S )a� Send out a message with the given queries. @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @type timeout: L{int} or C{float} @param timeout: How long to wait before giving up @type id: L{int} @param id: Unique key for this request @type writeMessage: C{callable} @param writeMessage: One-parameter callback which writes the message @rtype: C{Deferred} @return: a C{Deferred} which will be fired with the result of the query, or errbacked with any errors that could happen (exceptions during writing of the query, timeout errors, ...). r~ )r� ) rf r� � BaseExceptionr �fail�Deferredr' � _clearFailedr$ )r� r� �timeoutr� � writeMessager �resultDeferred� cancelCallr{ r{ r| �_query; s �zDNSMixin._queryc C s8 z| j |= W n ty Y nw |�t�t|��� dS )z5 Clean the Deferred after a timeout. N)r$ �KeyError�errbackr �Failurerv )r� �deferredr� r{ r{ r| r. ^ s �zDNSMixin._clearFailedr� ) r� r� r� r� r� r$ r� r& r' r3 r. r{ r{ r{ r| rl s #rl c @ sN e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z ddd�Z dS )rk z DNS protocol over UDP. Nc C s i | _ i | _d| _dS )z7 Stop protocol: reset state variables. N)r$ �resends� transportr� r{ r{ r| � stopProtocolp s z DNSDatagramProtocol.stopProtocolc C s i | _ i | _dS )z3 Upon start, reset internal state. N)r$ r8 r� r{ r{ r| � startProtocolx s z!DNSDatagramProtocol.startProtocolc C s | j �|�� |� dS )�X Send a message holding DNS queries. @type message: L{Message} N)r9 r� r )r� r� rX r{ r{ r| r0 s z DNSDatagramProtocol.writeMessagec C s | j jd| dd� d S )Nr r� )� maxPacketSize)r# � listenUDPr� r{ r{ r| �startListening� s z"DNSDatagramProtocol.startListeningc C s� t � }z|�|� W n& ty t�dt|�|f � Y dS ty0 t�t� � d� Y dS w |j | j v r_| j |j \}}| j |j = |� � z|� |� W dS ty^ t�� Y dS w |j | jvro| j�|| |� dS dS )zi Read a datagram, extract the message in it and trigger the associated Deferred. z#Truncated packet (%d bytes) from %sNzUnexpected decoding error)rf r r� r r� r� r+ �errr r6 r� r$ �cancel�callbackr8 r �messageReceived)r� r5 �addrr r� � cancellerr{ r{ r| �datagramReceived� s, � � �z$DNSDatagramProtocol.datagramReceivedc C s$ z| j |= W dS ty Y dS w )zN Mark message ID as no longer having duplication suppression. N)r8 r4 r% r{ r{ r| � removeResend� s �z DNSDatagramProtocol.removeResendr� c sh �j sz��� W n ty t�� Y S w |du r ��� }nd�j|< � �fdd�}��||||�S )a4 Send out a message with the given queries. @type address: L{tuple} of L{str} and L{int} @param address: The address to which to send the query @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @rtype: C{Deferred} Nr~ c s �� | � � d S r� )r0 )r �rX r� r{ r| r0 � r` z/DNSDatagramProtocol.query.<locals>.writeMessage)r9 r? r r r, r& r8 r3 )r� rX r� r/ r� r0 r{ rH r| �query� s � zDNSDatagramProtocol.query)r� N) r� r� r� r� r8 r: r; r0 r? rF rG rI r{ r{ r{ r| rk i s rk c @ sB e Zd ZdZdZdZdd� Zdd� Zdd � Zd d � Z dd d�Z dS )rm z DNS protocol over TCP. Nr� c C s( |� � }| j�t�dt|��| � dS )r< r� N)r r9 r� r� r� r� )r� r� r� r{ r{ r| r0 � s zDNSProtocol.writeMessagec C s i | _ | j�| � dS )zV Connection is made: reset internal state, and notify the controller. N)r$ r �connectionMader� r{ r{ r| rJ � s zDNSProtocol.connectionMadec C s | j �| � dS )zZ Notify the controller that this protocol is no longer connected. N)r �connectionLost)r� �reasonr{ r{ r| rK � r� zDNSProtocol.connectionLostc C s& | j |7 _ | j r�| jd u r,t| j �dkr,t�d| j d d� �d | _| j dd � | _ t| j �| jkr�| j d | j� }t� }|�|� z | j|j \}}W n t y^ | j � || � Y n w | j|j= |� � z|� |� W n ty| t�� Y nw | j | jd � | _ d | _nd S | j s d S d S )Nr� r� r )�bufferr� r� r� r� rf r r$ r� r4 r rC rA rB r+ r r@ )r� r5 �myChunkr r� rE r{ r{ r| � dataReceived� s2 � ��zDNSProtocol.dataReceivedr� c C s | � � }| �|||| j�S )z� Send out a message with the given queries. @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @rtype: C{Deferred} )r& r3 r0 )r� r� r/ r� r{ r{ r| rI s zDNSProtocol.query)r� ) r� r� r� r� r� rM r0 rJ rK rO rI r{ r{ r{ r| rm � s rm )NNNN)�r� r� r r[ r� �ior � itertoolsr �typingr r r �zope.interfacer r r r" r r �twisted.internet.errorr �twisted.pythonr r r r �tputil�twisted.python.compatr r r �__all__r r} r� r� r� rt r r r( r! r" r r- r r# r% r) r3 r+ r r$ r& r0 r, r r r/ r' r r r* r1 r. r� r2 ra r; r: r r r9 rd r rc r8 r6 r5 r7 r4 r` rb rq ro rr rp rs rn r< r@ r= r> r? rA rB rC rD r �twisted.names.errorru rv rw r� r� r� r� r� r r re rg rh � FancyStrMixin� FancyEqMixinr r6 ri rj rT rM rN rI rL rO rQ rV rJ rE rX rU r^ rG rF rZ rS rH rW rK rP rR r[ r] r_ rY r\ r� r� r� rf r rl �DatagramProtocolrk �Protocolrm r{ r{ r{ r| �<module> s� h ��������� � � � � ������ � ! ('1f< ;<z& 1s <.]Cz130;-?+,^ �4 P \OhPK Mb�Z��>�+ + ' names/__pycache__/cache.cpython-310.pycnu �[��� o �b� � @ sF d Z ddlmZ ddlmZmZ ddlmZmZ G dd� dej �Z dS )z An in-memory caching resolver. � )�defer)�common�dns)�failure�logc @ sR e Zd ZdZdZddd�Zdd� Zdd � Zd d � Zdd d �Z ddd�Z dd� Z dS )� CacheResolverz� A resolver that serves records from a local, memory cache. @ivar _reactor: A provider of L{interfaces.IReactorTime}. Nr c C sh t j�| � i | _|| _i | _|d u rddlm} || _|r0|� � D ]\}\}}| � |||� q"d S d S )Nr )�reactor) r � ResolverBase�__init__�cache�verbose�cancel�twisted.internetr �_reactor�items� cacheResult)�selfr r r �query�seconds�payload� r �5/usr/lib/python3/dist-packages/twisted/names/cache.pyr s �zCacheResolver.__init__c C sb || _ | j�� }| j�� D ]!\}\}\}}}|| }|| | D ] } | j|k r-| j|= nq q d S �N)�__dict__r r r r �ttl) r �state�now�k�when�ans�add�ns�diff�recr r r � __setstate__& s ���zCacheResolver.__setstate__c C s( | j �� D ]}|� � q| j �� | jS r )r �values�clearr )r �cr r r � __getstate__1 s zCacheResolver.__getstate__c s | j �� }t�|||�}z | j| \}\}} } W n" ty: | jdkr-t�dt |� � t � t � t�|��� Y S w | jrGt�dt |� � || � z � fdd�|D �� fdd�| D �� fdd�| D �f} W n ty{ t � t � t�|��� Y S w t �| �S )N� zCache miss for zCache hit for c �. g | ]}t �|jj|j|j|j� |j��qS r �r �RRHeader�name�type�clsr r ��.0�r�r" r r � <listcomp>G � ���z)CacheResolver._lookup.<locals>.<listcomp>c r* r r+ r0 r3 r r r4 M r5 c r* r r+ r0 r3 r r r4 S r5 )r r r �Queryr �KeyErrorr r �msg�reprr �failr �Failure� DomainError� ValueError�succeed) r r- r/ r. �timeoutr �qr r �authr �resultr r3 r �_lookup7 s6 � � � �� � zCacheResolver._lookupc C s t �t�t�|���S r )r r: r r; r r< )r r- r? r r r �lookupAllRecords_ s z CacheResolver.lookupAllRecordsc C s� | j dkr t�d| � |p| j�� |f| j|< || jv r$| j| �� t|d �t|d � t|d � }|rI|d j}|D ]}t ||j�}q?nd}| j� || j |�| j|< dS )a� Cache a DNS entry. @param query: a L{dns.Query} instance. @param payload: a 3-tuple of lists of L{dns.RRHeader} records, the matching result of the query (answers, authority and additional). @param cacheTime: The time (seconds since epoch) at which the entry is considered to have been added to the cache. If L{None} is given, the current time is used. r) zAdding %r to cacher � N) r r r8 r r r r �listr �min� callLater� clearEntry)r r r � cacheTime�s�mr2 r r r r b s $ � zCacheResolver.cacheResultc C s | j |= | j|= d S r )r r )r r r r r rI � s zCacheResolver.clearEntry)Nr Nr ) �__name__� __module__� __qualname__�__doc__r r r$ r( rC rD r rI r r r r r s ( r N) rP r r � twisted.namesr r �twisted.pythonr r r r r r r r �<module> s PK Mb�Z��g�! �! , names/__pycache__/srvconnect.cpython-310.pycnu �[��� o �b�# � @ sv d dl Z d dlmZ d dlmZmZ d dlmZmZ d dl m Z d dl m Z G dd� d�Z eej�G d d � d ��ZdS ) � N)� implementer)�error� interfaces)�client�dns)� DNSNameError)� nativeStringc @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �"_SRVConnector_ClientFactoryWrapperc C s || _ || _d S �N)�-_SRVConnector_ClientFactoryWrapper__connector�2_SRVConnector_ClientFactoryWrapper__wrappedFactory)�self� connector�wrappedFactory� r �:/usr/lib/python3/dist-packages/twisted/names/srvconnect.py�__init__ s z+_SRVConnector_ClientFactoryWrapper.__init__c C s | j �| j� d S r )r �startedConnectingr )r r r r r r s z4_SRVConnector_ClientFactoryWrapper.startedConnectingc C � | j �|� d S r )r �connectionFailed�r r �reasonr r r �clientConnectionFailed � z9_SRVConnector_ClientFactoryWrapper.clientConnectionFailedc C r r )r �connectionLostr r r r �clientConnectionLost r z7_SRVConnector_ClientFactoryWrapper.clientConnectionLostc C s t | j|�S r )�getattrr )r �keyr r r � __getattr__ s z._SRVConnector_ClientFactoryWrapper.__getattr__N)�__name__� __module__� __qualname__r r r r r r r r r r s r c @ s� e Zd ZdZdZdddi dfdd�Zd d � Zd d � Zd d� Zdd� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd � Zd d � ZdS ) � SRVConnectoraD A connector that looks up DNS SRV records. RFC 2782 details how SRV records should be interpreted and selected for subsequent connection attempts. The algorithm for using the records' priority and weight is implemented in L{pickServer}. @ivar servers: List of candidate server records for future connection attempts. @type servers: L{list} of L{dns.Record_SRV} @ivar orderedServers: List of server records that have already been tried in this round of connection attempts. @type orderedServers: L{list} of L{dns.Record_SRV} r �tcp� connectTCPr Nc C s^ || _ || _|du r dnt�|�| _|| _|| _|| _|| _|| _ | | _ d| _ d| _ d| _ dS )a� @param domain: The domain to connect to. If passed as a text string, it will be encoded using C{idna} encoding. @type domain: L{bytes} or L{str} @param defaultPort: Optional default port number to be used when SRV lookup fails and the service name is unknown. This should be the port number associated with the service name as defined by the IANA registry. @type defaultPort: L{int} N)�reactor�servicer � domainString�domain�factory�protocol�connectFuncName�connectFuncArgs�connectFuncKwArgs� _defaultPortr �servers�orderedServers) r r% r& r( r) r* r+ r, r- � defaultPortr r r r 6 s zSRVConnector.__init__c C s� | j �� | j �| � | jsR| jdu r | �t�d�� dS t� dt | j �t | j �t | j�f �}|� | j| j� |�| fdd�� | jrJ|�| j� |�| j� dS | jdu r]| �� dS | j�� dS )z"Start connection to remote server.NzDomain is not defined.z _%s._%s.%sc S s |� � S r )�_reallyConnect)�xr r r r �<lambda>q s z&SRVConnector.connect.<locals>.<lambda>)r) �doStartr r/ r( r r �DNSLookupErrorr � lookupServicer r& r* � addCallbacks� _cbGotServers� _ebGotServers� addCallbackr. � addErrback�_ebServiceUnknownr r2 �connect)r �dr r r r> ] s0 ���� zSRVConnector.connectc C s |� t� g | _g | _d S r )�trapr r/ r0 �r �failurer r r r: z s zSRVConnector._ebGotServersc C s� |\}}}t |�dkr2|d jtjkr2|d jr2|d jjt�d�kr2t�dt | j �t | j �f ��g | _ g | _ |D ]}|jtjksE|jsFq:| j �|j� q:d S )N� r � .z'Service %s not available for domain %s.)�len�typer �SRV�payload�target�Namer r6 �reprr& r( r/ r0 �append)r �result�answers�auth�add�ar r r r9 � s$ ����zSRVConnector._cbGotServersc C s6 |� tj� t�dd| j| j�g| _g | _| � � dS )a. Connect to the default port when the service name is unknown. If no SRV records were found, the service name will be passed as the port. If resolving the name fails with L{error.ServiceNameUnknownError}, a final attempt is done using the default port. r N) r@ r �ServiceNameUnknownErrorr � Record_SRVr. r( r/ r0 r> rA r r r r= � s z SRVConnector._ebServiceUnknownc C s$ | j dusJ �| jdusJ �| j s | js t| j�| jfS | j s)| jr)| j| _ g | _| j s.J �| j jdd� d� | j d j}d}d}g }| j D ]}|j|kr]||j7 }|�||f� |d7 }qFt � d|�}|D ]!\}}||kr�| j | }| j |= | j�|� t |j �|j f S qftd| jj� d���) a; Pick the next server. This selects the next server from the list of SRV records according to their priority and weight values, as set out by the default algorithm specified in RFC 2782. At the beginning of a round, L{servers} is populated with L{orderedServers}, and the latter is made empty. L{servers} is the list of candidates, and L{orderedServers} is the list of servers that have already been tried. First, all records are ordered by priority and weight in ascending order. Then for each priority level, a running sum is calculated over the sorted list of records for that priority. Then a random value between 0 and the final sum is compared to each record in order. The first record that is greater than or equal to that random value is chosen and removed from the list of candidates for this round. @return: A tuple of target hostname and port from the chosen DNS SRV record. @rtype: L{tuple} of native L{str} and L{int} Nc S s | j | jfS r )�priority�weight)�recordr r r r4 � s z)SRVConnector.pickServer.<locals>.<lambda>)r r rC z Impossible z pickServer result.)r/ r0 r r( r& �sortrT rU rL �random�randint�strrI �port� RuntimeError� __class__r ) r � minPriority�index� weightSum� weightIndexr3 �randrU �chosenr r r � pickServer� s8 � �zSRVConnector.pickServerc C s� | j rd| _ d S | �� \| _| _| jd usJ d��| jd us"J d��t| j| j�}|| j| jt| | j�g| j �R i | j ��| _ d S )Nr z Must have a host to connect to.z Must have a port to connect to.) � stopAfterDNSrd �hostr[ r r% r+ r r) r, r- r )r � connectFuncr r r r2 � s �� �zSRVConnector._reallyConnectc C s | j r | j �� dS d| _dS )zStop attempting to connect.rC N)r �stopConnectingre �r r r r rh � s zSRVConnector.stopConnectingc C s$ | j dur | j �� dS | �� dS )z%Disconnect whatever our are state is.N)r � disconnectrh ri r r r rj � s zSRVConnector.disconnectc C s | j sJ �| j �� S r )r �getDestinationri r r r rk s zSRVConnector.getDestinationc C � | j �| |� | j �� d S r )r) r �doStop�r r r r r r � z SRVConnector.connectionFailedc C rl r )r) r rm rn r r r r ro zSRVConnector.connectionLost)r r r! �__doc__re r r> r: r9 r= rd r2 rh rj rk r r r r r r r" " s( �' = r" )rX �zope.interfacer �twisted.internetr r � twisted.namesr r �twisted.names.errorr �twisted.python.compatr r � IConnectorr" r r r r �<module> s PK Mb�Z{T;�. �. & names/__pycache__/root.cpython-310.pycnu �[��� o �b�0 � @ st d Z ddlmZ ddlmZmZmZ ddlmZ G dd� d�Z G dd� dej �Z d d � Z G d d � d �Z ddd�Zd S )z� Resolver implementation for querying successive authoritative servers to lookup a record, starting from the root nameservers. @author: Jp Calderone todo:: robustify it documentation � )�defer)�common�dns�error)�Failurec @ s e Zd ZdZdd� ZdS )�_DummyControllerz� A do-nothing DNS controller. This is useful when all messages received will be responses to previously issued queries. Anything else received will be ignored. c G s d S �N� )�self�argsr r �4/usr/lib/python3/dist-packages/twisted/names/root.py�messageReceived s z _DummyController.messageReceivedN)�__name__� __module__� __qualname__�__doc__r r r r r r s r c @ sB e Zd ZdZddd�Zdd� Zdd � Zd d � Zd d � Zdd� Z dS )�Resolverao L{Resolver} implements recursive lookup starting from a specified list of root servers. @ivar hints: See C{hints} parameter of L{__init__} @ivar _maximumQueries: See C{maximumQueries} parameter of L{__init__} @ivar _reactor: See C{reactor} parameter of L{__init__} @ivar _resolverFactory: See C{resolverFactory} parameter of L{__init__} � Nc C s< t j�| � || _|| _|| _|du rddlm} || _dS )a� @param hints: A L{list} of L{str} giving the dotted quad representation of IP addresses of root servers at which to begin resolving names. @type hints: L{list} of L{str} @param maximumQueries: An optional L{int} giving the maximum number of queries which will be attempted to resolve a single name. @type maximumQueries: L{int} @param reactor: An optional L{IReactorTime} and L{IReactorUDP} provider to use to bind UDP ports and manage timeouts. @type reactor: L{IReactorTime} and L{IReactorUDP} provider @param resolverFactory: An optional callable which accepts C{reactor} and C{servers} arguments and returns an instance that provides a C{queryUDP} method. Defaults to L{twisted.names.client.Resolver}. @type resolverFactory: callable Nr �r ) r � ResolverBase�__init__�hints�_maximumQueries�_reactor�twisted.names.clientr �_resolverFactory)r r �maximumQueries�reactor�resolverFactoryr r r r + s zResolver.__init__c C s dd� | j D �S )z� Return a list of two-tuples representing the addresses of the root servers, as defined by C{self.hints}. c S s g | ]}|t jf�qS r )r �PORT)�.0�ipr r r � <listcomp>M s z#Resolver._roots.<locals>.<listcomp>)r )r r r r �_rootsH s zResolver._rootsc C s2 | j || jd�}|�|g|�}|r|�|j� |S )a� Issue one query and return a L{Deferred} which fires with its response. @param query: The query to issue. @type query: L{dns.Query} @param servers: The servers which might have an answer for this query. @type servers: L{list} of L{tuple} of L{str} and L{int} @param timeout: A timeout on how long to wait for the response. @type timeout: L{tuple} of L{int} @param filter: A flag indicating whether to filter the results. If C{True}, the returned L{Deferred} will fire with a three-tuple of lists of L{twisted.names.dns.RRHeader} (like the return value of the I{lookup*} methods of L{IResolver}. IF C{False}, the result will be a L{Message} instance. @type filter: L{bool} @return: A L{Deferred} which fires with the response or a timeout error. @rtype: L{Deferred} )�serversr )r r �queryUDP� addCallback� filterAnswers)r �queryr$ �timeout�filter�r�dr r r �_queryO s zResolver._queryc C s, |du rd}| � t�|||�| �� || j�S )z� Implement name lookup by recursively discovering the authoritative server for the name and then asking it, starting at one of the servers in C{self.hints}. N)� � � �- )�_discoverAuthorityr �Queryr# r )r �name�cls�typer) r r r �_lookupn s �zResolver._lookupc C s@ |dkr t t�d��S | �|||d�}|�| j|||d � |S )a# Issue a query to a server and follow a delegation if necessary. @param query: The query to issue. @type query: L{dns.Query} @param servers: The servers which might have an answer for this query. @type servers: L{list} of L{tuple} of L{str} and L{int} @param timeout: A C{tuple} of C{int} giving the timeout to use for this query. @param queriesLeft: A C{int} giving the number of queries which may yet be attempted to answer this query before the attempt will be abandoned. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} giving the response, or with a L{Failure} if there is a timeout or response error. r z"Query limit reached without resultFr. )r r � ResolverErrorr- r& �_discoveredAuthority)r r( r$ r) � queriesLeftr, r r r r2 | s zResolver._discoverAuthorityc s� |j tjkrt��|j �|��S i �|jD ] }��|jg ��|� q�fdd�}t � }�j}d} |� |� | � ||�j �j �} | du rj|�jkrJn>�� t�t|��j �j ���� ���} � fdd�} | �| � | S | j �j krx|j|j|jfS | jj|v r�t�d��| jj}q1i } |jD ]} | j tjkr�| j�� | | jj< q�g }g }|jD ]!} | j tjkr�| jjj}|| v r�|�| | tjf� q�|�|� q�|r҈� �|���S |r��|d ��} d d � }| �|� | �����fd d �� | S tt�d ��S )as Interpret the response to a query, checking for error codes and following delegations if necessary. @param response: The L{Message} received in response to issuing C{query}. @type response: L{Message} @param query: The L{dns.Query} which was issued. @type query: L{dns.Query}. @param timeout: The timeout to use if another query is indicated by this response. @type timeout: L{tuple} of L{int} @param queriesLeft: A C{int} giving the number of queries which may yet be attempted to answer this query before the attempt will be abandoned. @return: A L{Failure} indicating a response error, a three-tuple of lists of L{twisted.names.dns.RRHeader} giving the response to C{query} or a L{Deferred} which will fire with one of those. c sF d }� � | g �D ]}|j|kr |j|kr| S |jtjkr |}q|S r )�getr5 r6 r �CNAME)r4 r6 r5 �cname�record)�recordsr r �findAnswerOrCName� s �z8Resolver._discoveredAuthority.<locals>.findAnswerOrCNameNTc s | \}}}|� d� � |||fS �Nr )�insert��results�answers� authority� additional)�previousr r � cbResolved� s z1Resolver._discoveredAuthority.<locals>.cbResolvedzCycle in CNAME processingr c S s | \}}}|d j �� S rA )�payload� dottedQuadrC r r r � getOneAddress s z4Resolver._discoveredAuthority.<locals>.getOneAddressc s �� �| tjfg�� d �S )Nr. )r2 r r )�hint)r: r( r r) r r �<lambda> s �z/Resolver._discoveredAuthority.<locals>.<lambda>z/Stuck at response without answers or delegation) �rCoder �OKr �exceptionForCoderE � setdefaultr4 �append�set�addr6 r5 r2 r3 �strr# r& rF rG rJ r r8 �ArK �NSr � lookupAddress)r �responser( r) r: �answerr@ �seenr4 r> r, rI � addresses�rrr �traps�nsrL r )rH r: r( r? r r) r r9 � st � �% � � ��z Resolver._discoveredAuthority)r NN) r r r r r r# r- r7 r2 r9 r r r r r s r c s � �fdd�}|S )Nc s �� � ��fdd�� �S )Nc s t | ��� i ���S r )�getattr)r+ )r �kwr4 r r rN s z6makePlaceholder.<locals>.placeholder.<locals>.<lambda>)r& �r rb ��deferredr4 rc r � placeholder s z$makePlaceholder.<locals>.placeholderr )re r4 rf r rd r �makePlaceholder s rg c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�DeferredResolverc C s g | _ |�| j� d S r )�waitingr& �gotRealResolver)r �resolverDeferredr r r r s zDeferredResolver.__init__c C s. | j }|j| _|j| _|D ]}|�|� q d S r )ri �__dict__� __class__�callback)r �resolver�wr, r r r rj s �z DeferredResolver.gotRealResolverc C s: |� d�s |dv r| j�t�� � t| jd |�S t|��)N�lookup)� getHostByNamer( ���)� startswithri rS r �Deferredrg �AttributeError)r r4 r r r � __getattr__% s z DeferredResolver.__getattr__N)r r r r rj rw r r r r rh s rh Nc sP dd� t d�D �}� fdd�|D �}tj|dd�}�fdd�}|�|� t|�S ) a� Lookup the root nameserver addresses using the given resolver Return a Resolver which will eventually become a C{root.Resolver} instance that has references to all the root servers that we were able to look up. @param resolver: The resolver instance which will be used to lookup the root nameserver addresses. @type resolver: L{twisted.internet.interfaces.IResolverSimple} @param resolverFactory: An optional callable which returns a resolver instance. It will passed as the C{resolverFactory} argument to L{Resolver.__init__}. @type resolverFactory: callable @return: A L{DeferredResolver} which will be dynamically replaced with L{Resolver} when the root nameservers have been looked up. c S s g | ] }t td �| ��qS )�a)�chr�ord)r �ir r r r" @ � z bootstrap.<locals>.<listcomp>� c s g | ] }� � d | ��qS )z%s.root-servers.net)rr )r r, )ro r r r" A s T)� consumeErrorsc s t dd� | D �� d�S )Nc S s g | ] }|d r|d �qS )r r. r )r �er r r r" F r| z4bootstrap.<locals>.buildResolver.<locals>.<listcomp>)r r r )�res)r r r � buildResolverD s �z bootstrap.<locals>.buildResolver)�ranger � DeferredListr& rh )ro r �domains�Lr, r� r )ro r r � bootstrap, s r� r )r �twisted.internetr � twisted.namesr r r �twisted.python.failurer r r r rg rh r� r r r r �<module> s rPK Mb�Z��S�� � ' names/__pycache__/error.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ G dd� de�ZG dd� de�ZG dd� de�ZG d d � d e�ZG d d � d e�ZG d d� de�Z G dd� de�Z G dd� de�Z G dd� de�Z G dd� de �Zg d�ZdS )z0 Exception class definitions for Twisted Names. � )� TimeoutErrorc @ � e Zd ZdZdS )� DomainErrorzu Indicates a lookup failed because there were no records matching the given C{name, class, type} triple. N��__name__� __module__� __qualname__�__doc__� r r �5/usr/lib/python3/dist-packages/twisted/names/error.pyr � r c @ r )�AuthoritativeDomainErrorz� Indicates a lookup failed for a name for which this server is authoritative because there were no records matching the given C{name, class, type} triple. Nr r r r r r r r c @ s e Zd ZdZdd� ZdS )�DNSQueryTimeoutErrorzk Indicates a lookup failed due to a timeout. @ivar id: The id of the message which timed out. c C s t �| � || _d S )N)r �__init__�id)�selfr r r r r # s z DNSQueryTimeoutError.__init__N)r r r r r r r r r r s r c @ r )�DNSFormatErrorzQ Indicates a query failed with a result of C{twisted.names.dns.EFORMAT}. Nr r r r r r ( r r c @ r )�DNSServerErrorzQ Indicates a query failed with a result of C{twisted.names.dns.ESERVER}. Nr r r r r r . r r c @ r )� DNSNameErrorzO Indicates a query failed with a result of C{twisted.names.dns.ENAME}. Nr r r r r r 4 r r c @ r )�DNSNotImplementedErrorzQ Indicates a query failed with a result of C{twisted.names.dns.ENOTIMP}. Nr r r r r r : r r c @ r )�DNSQueryRefusedErrorzR Indicates a query failed with a result of C{twisted.names.dns.EREFUSED}. Nr r r r r r @ r r c @ r )�DNSUnknownErrorz: Indicates a query failed with an unknown result. Nr r r r r r F r r c @ r )� ResolverErrorz_ Indicates a query failed because of a decision made by the local resolver object. Nr r r r r r L r r ) r r r r r r r r r r N)r �twisted.internet.deferr � ValueErrorr r r r r r r r r � Exceptionr �__all__r r r r �<module> s PK Mb�ZDž7 7 ) names/__pycache__/resolve.cpython-310.pycnu �[��� o �b� � @ sb d Z ddlmZ ddlmZmZ ddlmZmZm Z G dd� d�Z eej �G dd� dej ��Z d S ) z� Lookup a name using multiple resolvers. Future Plans: This needs someway to specify which resolver answered the query, or someway to specify (authority|ttl|cache behavior|more?) � )� implementer)�defer� interfaces)�common�dns�errorc @ s e Zd Zdd� Zdd� ZdS )�FailureHandlerc C s || _ || _|| _d S �N)�resolver�query�timeout)�selfr r r � r �7/usr/lib/python3/dist-packages/twisted/names/resolve.py�__init__ s zFailureHandler.__init__c C s" |� tjtjt� | �| j| j�S r ) �trapr � DomainErrorr � TimeoutError�NotImplementedErrorr r r )r �failurer r r �__call__ s zFailureHandler.__call__N)�__name__� __module__� __qualname__r r r r r r r s r c @ s* e Zd ZdZdd� Zdd� Zd dd�ZdS ) � ResolverChainz8 Lookup an address using multiple L{IResolver}s c C s t j�| � || _dS )zi @type resolvers: L{list} @param resolvers: A L{list} of L{IResolver} providers. N)r � ResolverBaser � resolvers)r r r r r r % s zResolverChain.__init__c C s` | j s t�t�� �S t�|||�}| j d �||�}| j dd� D ] }|�t |j||��}q!|S )aN Build a L{dns.Query} for the given parameters and dispatch it to each L{IResolver} in C{self.resolvers} until an answer or L{error.AuthoritativeDomainError} is returned. @type name: C{str} @param name: DNS name to resolve. @type type: C{int} @param type: DNS record type. @type cls: C{int} @param cls: DNS record class. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @rtype: L{Deferred} @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. r � N) r r �failr r r �Queryr � addErrbackr )r �name�cls�typer �q�d�rr r r �_lookup- s zResolverChain._lookupNc C sR | j s t�t�� �S | j d �||�}| j dd � D ] }|�t|j||��}q|S )Nr r )r r r r r �lookupAllRecordsr r )r r! r r% r& r r r r( Q s z ResolverChain.lookupAllRecordsr )r r r �__doc__r r' r( r r r r r s $r N)r) �zope.interfacer �twisted.internetr r � twisted.namesr r r r � IResolverr r r r r r �<module> s PK Mb�Z%�%�# �# ( names/__pycache__/common.cpython-310.pycnu �[��� o �b�$ � @ sP d Z ddlZddlmZ ddlmZmZmZ ddlm Z ddl m Z ddl m Z mZmZmZmZmZ ed�\ZZZd Zeej�G d d � d ��Zd&d d�Zi e jd�e j d�e j d�e j d�e j d�e j d�e j!d�e j"d�e j#d�e j$d�e j%d�e j&d�e j'd�e j(d �e j)d �e j*d �e j+d �e j,d e j-d!e j.d"e j/d#e j0d$e j1d%i�Z2dS )'z> Base functionality useful to various parts of Twisted Names. � N)� implementer)�defer�error� interfaces)�Logger)�dns)�DNSFormatError� DNSNameError�DNSNotImplementedError�DNSQueryRefusedError�DNSServerError�DNSUnknownError� )� r r c @ sV e Zd ZdZe� Zejeej e ej e ej eejeiZdZdd� Zdd� Zd>dd�Zd d � Zd>d d �Zd>d d�Zd>dd�Zd>dd�Zd>dd�Zd>dd�Z d>dd�Z d>dd�Z d>dd �Z d>d d �Z d>d d �Z!d>d!d"�Z"d>d#d$�Z#d>d%d&�Z$d>d'd(�Z%d>d)d*�Z&d>d+d,�Z'd>d-d.�Z(d>d/d0�Z)d>d1d2�Z*d>d3d4�Z+d>d5d6�Z,d>d7d8�Z-d?d:d;�Z.d<d=� Z/dS )@� ResolverBaseaN L{ResolverBase} is a base class for implementations of L{interfaces.IResolver} which deals with a lot of the boilerplate of implementing all of the lookup methods. @cvar _errormap: A C{dict} mapping DNS protocol failure response codes to exception classes which will be used to represent those failures. Nc C s, i | _ t �� D ] \}}t| |�| j |< qd S �N)� typeToMethod�items�getattr)�self�k�vr r �6/usr/lib/python3/dist-packages/twisted/names/common.py�__init__7 s �zResolverBase.__init__c C s | j �|t�S )z� Convert a response code (one of the possible values of L{dns.Message.rCode} to an exception instance representing it. @since: 10.0 )� _errormap�getr )r � responseCoder r r �exceptionForCode< s z ResolverBase.exceptionForCodec C sb z| j |j }W n ty' | jjd|d� t�| j|jjt j |j|� Y S w t�||jj|�S )Nz:Query of unknown type {query.type} for {query.name.name!r})�query) r �type�KeyError�_log�debugr � maybeDeferred�_lookup�namer �IN)r r �timeout�methodr r r r E s ��� zResolverBase.queryc C s t �td��S )N�ResolverBase._lookup)r �fail�NotImplementedError)r r% �clsr r' r r r r$ S s r) c C � | � t�|�tjtj|�S r )r$ r � domainStringr& �A�r r% r' r r r � lookupAddressV � zResolverBase.lookupAddressc C r- r )r$ r r. r& �AAAAr0 r r r �lookupIPV6AddressY r2 z ResolverBase.lookupIPV6Addressc C r- r )r$ r r. r& �A6r0 r r r �lookupAddress6\ r2 zResolverBase.lookupAddress6c C r- r )r$ r r. r& �MXr0 r r r �lookupMailExchange_ r2 z ResolverBase.lookupMailExchangec C r- r )r$ r r. r& �NSr0 r r r �lookupNameserversb r2 z ResolverBase.lookupNameserversc C r- r )r$ r r. r& �CNAMEr0 r r r �lookupCanonicalNamee r2 z ResolverBase.lookupCanonicalNamec C r- r )r$ r r. r& �MBr0 r r r � lookupMailBoxh r2 zResolverBase.lookupMailBoxc C r- r )r$ r r. r& �MGr0 r r r �lookupMailGroupk r2 z ResolverBase.lookupMailGroupc C r- r )r$ r r. r& �MRr0 r r r �lookupMailRenamen r2 z ResolverBase.lookupMailRenamec C r- r )r$ r r. r& �PTRr0 r r r � lookupPointerq r2 zResolverBase.lookupPointerc C r- r )r$ r r. r& �SOAr0 r r r �lookupAuthorityt r2 z ResolverBase.lookupAuthorityc C r- r )r$ r r. r& �NULLr0 r r r � lookupNullw r2 zResolverBase.lookupNullc C r- r )r$ r r. r& �WKSr0 r r r �lookupWellKnownServicesz r2 z$ResolverBase.lookupWellKnownServicesc C r- r )r$ r r. r& �SRVr0 r r r � lookupService} r2 zResolverBase.lookupServicec C r- r )r$ r r. r& �HINFOr0 r r r �lookupHostInfo� r2 zResolverBase.lookupHostInfoc C r- r )r$ r r. r& �MINFOr0 r r r �lookupMailboxInfo� r2 z ResolverBase.lookupMailboxInfoc C r- r )r$ r r. r& �TXTr0 r r r � lookupText� r2 zResolverBase.lookupTextc C r- r )r$ r r. r& �SPFr0 r r r �lookupSenderPolicy� r2 z ResolverBase.lookupSenderPolicyc C r- r )r$ r r. r& �RPr0 r r r �lookupResponsibility� r2 z!ResolverBase.lookupResponsibilityc C r- r )r$ r r. r& �AFSDBr0 r r r �lookupAFSDatabase� r2 z ResolverBase.lookupAFSDatabasec C r- r )r$ r r. r& �AXFRr0 r r r � lookupZone� r2 zResolverBase.lookupZonec C r- r )r$ r r. r& �NAPTRr0 r r r � lookupNamingAuthorityPointer� r2 z)ResolverBase.lookupNamingAuthorityPointerc C r- r )r$ r r. r& � ALL_RECORDSr0 r r r �lookupAllRecords� r2 z ResolverBase.lookupAllRecords� c C s* t �|�}| �||�}|�| j||� |S r )r r. r^ � addCallback� _cbRecords)r r% r' �effort�dr r r � getHostByName� s zResolverBase.getHostByNamec C s8 |\}}}t | t�|�|| | |�}|st�|��|S r )� extractRecordr �Namer �DNSLookupError)r �recordsr% rb �ans�auth�add�resultr r r ra � s zResolverBase._cbRecordsr )Nr_ )0�__name__� __module__� __qualname__�__doc__r r! r �EFORMATr �ESERVERr �ENAMEr �ENOTIMPr �EREFUSEDr r r r r r r$ r1 r4 r6 r8 r: r< r> r@ rB rD rF rH rJ rL rN rP rR rT rV rX rZ r\ r^ rd ra r r r r r ! sN � r r_ c s~ � sdS t td�r?|D ]}|j�kr#|jtjkr#t�tj|jj � S q |D ]}|j�kr>|jtj kr>t�tj|jj � S q&|D ]}|j�krY|jtj krYt�tj |jj � S qA|D ],}|j�kr�|jtj kr�t| |jj|� d �}|s�| j|jjj� d d� S | S q\|D ]1}|jtjkr�q�ddlm} |j|jjj�d�tjfgd��� ��fd d �}���j��|� S dS ) am Resolve a name to an IP address, following I{CNAME} records and I{NS} referrals recursively. This is an implementation detail of L{ResolverBase.getHostByName}. @param resolver: The resolver to use for the next query (unless handling an I{NS} referral). @type resolver: L{IResolver} @param name: The name being looked up. @type name: L{dns.Name} @param answers: All of the records returned by the previous query (answers, authority, and additional concatenated). @type answers: L{list} of L{dns.RRHeader} @param level: Remaining recursion budget. This is decremented at each recursion. The query returns L{None} when it reaches 0. @type level: L{int} @returns: The first IPv4 or IPv6 address (as a dotted quad or colon quibbles), or L{None} when no result is found. @rtype: native L{str} or L{None} N� inet_ntop� )rb r )�client�ascii)�serversc s$ | \}}}t ��|| | � d �S )Nrw )re )rh ri rj rk ��levelr% � nsResolverr r � queryAgain� s z!extractRecord.<locals>.queryAgain)�hasattr�socketr% r r r5 rv �AF_INET6�payload�addressr3 r/ �AF_INETr; re rd r9 � twisted.namesrx �Resolver�decode�PORTr1 r` )�resolverr% �answersr| �rrl rx r~ r r{ r re � sB ��� � ���re r1 r4 r6 r: r< rF r> r@ rB rH rJ rD rN rP r8 rR rT rV rX rL r\ rZ r^ )r_ )3rp r� �zope.interfacer �twisted.internetr r r �twisted.loggerr r� r �twisted.names.errorr r r r r r �range�_ANS�_AUTH�_ADD� EMPTY_RESULT� IResolverr re r/ r3 r5 r9 r; rE r= r? rA rG rI rC rM rO r7 rQ rS rU rW rK r[ rY r] r r r r r �<module> sn B�������� � � � � ����� �PK Mb�Z�z���# �# names/_rfc1982.pynu �[��� # -*- test-case-name: twisted.names.test.test_rfc1982 -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Utilities for handling RFC1982 Serial Number Arithmetic. @see: U{http://tools.ietf.org/html/rfc1982} @var RFC4034_TIME_FORMAT: RRSIG Time field presentation format. The Signature Expiration Time and Inception Time field values MUST be represented either as an unsigned decimal integer indicating seconds since 1 January 1970 00:00:00 UTC, or in the form YYYYMMDDHHmmSS in UTC. See U{RRSIG Presentation Format<https://tools.ietf.org/html/rfc4034#section-3.2>} """ import calendar from datetime import datetime, timedelta from twisted.python.compat import nativeString from twisted.python.util import FancyStrMixin RFC4034_TIME_FORMAT = "%Y%m%d%H%M%S" class SerialNumber(FancyStrMixin): """ An RFC1982 Serial Number. This class implements RFC1982 DNS Serial Number Arithmetic. SNA is used in DNS and specifically in DNSSEC as defined in RFC4034 in the DNSSEC Signature Expiration and Inception Fields. @see: U{https://tools.ietf.org/html/rfc1982} @see: U{https://tools.ietf.org/html/rfc4034} @ivar _serialBits: See C{serialBits} of L{__init__}. @ivar _number: See C{number} of L{__init__}. @ivar _modulo: The value at which wrapping will occur. @ivar _halfRing: Half C{_modulo}. If another L{SerialNumber} value is larger than this, it would lead to a wrapped value which is larger than the first and comparisons are therefore ambiguous. @ivar _maxAdd: Half C{_modulo} plus 1. If another L{SerialNumber} value is larger than this, it would lead to a wrapped value which is larger than the first. Comparisons with the original value would therefore be ambiguous. """ showAttributes = ( ("_number", "number", "%d"), ("_serialBits", "serialBits", "%d"), ) def __init__(self, number, serialBits=32): """ Construct an L{SerialNumber} instance. @param number: An L{int} which will be stored as the modulo C{number % 2 ^ serialBits} @type number: L{int} @param serialBits: The size of the serial number space. The power of two which results in one larger than the largest integer corresponding to a serial number value. @type serialBits: L{int} """ self._serialBits = serialBits self._modulo = 2 ** serialBits self._halfRing = 2 ** (serialBits - 1) self._maxAdd = 2 ** (serialBits - 1) - 1 self._number = int(number) % self._modulo def _convertOther(self, other: object) -> "SerialNumber": """ Check that a foreign object is suitable for use in the comparison or arithmetic magic methods of this L{SerialNumber} instance. Raise L{TypeError} if not. @param other: The foreign L{object} to be checked. @return: C{other} after compatibility checks and possible coercion. @raise TypeError: If C{other} is not compatible. """ if not isinstance(other, SerialNumber): raise TypeError(f"cannot compare or combine {self!r} and {other!r}") if self._serialBits != other._serialBits: raise TypeError( "cannot compare or combine SerialNumber instances with " "different serialBits. %r and %r" % (self, other) ) return other def __str__(self) -> str: """ Return a string representation of this L{SerialNumber} instance. @rtype: L{nativeString} """ return nativeString("%d" % (self._number,)) def __int__(self): """ @return: The integer value of this L{SerialNumber} instance. @rtype: L{int} """ return self._number def __eq__(self, other: object) -> bool: """ Allow rich equality comparison with another L{SerialNumber} instance. """ try: other = self._convertOther(other) except TypeError: return NotImplemented return other._number == self._number def __lt__(self, other: object) -> bool: """ Allow I{less than} comparison with another L{SerialNumber} instance. """ try: other = self._convertOther(other) except TypeError: return NotImplemented return ( self._number < other._number and (other._number - self._number) < self._halfRing ) or ( self._number > other._number and (self._number - other._number) > self._halfRing ) def __gt__(self, other: object) -> bool: """ Allow I{greater than} comparison with another L{SerialNumber} instance. """ try: other = self._convertOther(other) except TypeError: return NotImplemented return ( self._number < other._number and (other._number - self._number) > self._halfRing ) or ( self._number > other._number and (self._number - other._number) < self._halfRing ) def __le__(self, other: object) -> bool: """ Allow I{less than or equal} comparison with another L{SerialNumber} instance. """ try: other = self._convertOther(other) except TypeError: return NotImplemented return self == other or self < other def __ge__(self, other: object) -> bool: """ Allow I{greater than or equal} comparison with another L{SerialNumber} instance. """ try: other = self._convertOther(other) except TypeError: return NotImplemented return self == other or self > other def __add__(self, other: object) -> "SerialNumber": """ Allow I{addition} with another L{SerialNumber} instance. Serial numbers may be incremented by the addition of a positive integer n, where n is taken from the range of integers [0 .. (2^(SERIAL_BITS - 1) - 1)]. For a sequence number s, the result of such an addition, s', is defined as s' = (s + n) modulo (2 ^ SERIAL_BITS) where the addition and modulus operations here act upon values that are non-negative values of unbounded size in the usual ways of integer arithmetic. Addition of a value outside the range [0 .. (2^(SERIAL_BITS - 1) - 1)] is undefined. @see: U{http://tools.ietf.org/html/rfc1982#section-3.1} @raise ArithmeticError: If C{other} is more than C{_maxAdd} ie more than half the maximum value of this serial number. """ try: other = self._convertOther(other) except TypeError: return NotImplemented if other._number <= self._maxAdd: return SerialNumber( (self._number + other._number) % self._modulo, serialBits=self._serialBits, ) else: raise ArithmeticError( "value %r outside the range 0 .. %r" % ( other._number, self._maxAdd, ) ) def __hash__(self): """ Allow L{SerialNumber} instances to be hashed for use as L{dict} keys. @rtype: L{int} """ return hash(self._number) @classmethod def fromRFC4034DateString(cls, utcDateString): """ Create an L{SerialNumber} instance from a date string in format 'YYYYMMDDHHMMSS' described in U{RFC4034 3.2<https://tools.ietf.org/html/rfc4034#section-3.2>}. The L{SerialNumber} instance stores the date as a 32bit UNIX timestamp. @see: U{https://tools.ietf.org/html/rfc4034#section-3.1.5} @param utcDateString: A UTC date/time string of format I{YYMMDDhhmmss} which will be converted to seconds since the UNIX epoch. @type utcDateString: L{unicode} @return: An L{SerialNumber} instance containing the supplied date as a 32bit UNIX timestamp. """ parsedDate = datetime.strptime(utcDateString, RFC4034_TIME_FORMAT) secondsSinceEpoch = calendar.timegm(parsedDate.utctimetuple()) return cls(secondsSinceEpoch, serialBits=32) def toRFC4034DateString(self): """ Calculate a date by treating the current L{SerialNumber} value as a UNIX timestamp and return a date string in the format described in U{RFC4034 3.2<https://tools.ietf.org/html/rfc4034#section-3.2>}. @return: The date string. """ # Can't use datetime.utcfromtimestamp, because it seems to overflow the # signed 32bit int used in the underlying C library. SNA is unsigned # and capable of handling all timestamps up to 2**32. d = datetime(1970, 1, 1) + timedelta(seconds=self._number) return nativeString(d.strftime(RFC4034_TIME_FORMAT)) __all__ = ["SerialNumber"] PK Mb�Z�B��1 1 names/test/test_resolve.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.names.resolve}. """ from twisted.names.error import DomainError from twisted.names.resolve import ResolverChain from twisted.trial.unittest import TestCase class ResolverChainTests(TestCase): """ Tests for L{twisted.names.resolve.ResolverChain} """ def test_emptyResolversList(self): """ L{ResolverChain._lookup} returns a L{DomainError} failure if its C{resolvers} list is empty. """ r = ResolverChain([]) d = r.lookupAddress("www.example.com") f = self.failureResultOf(d) self.assertIs(f.trap(DomainError), DomainError) def test_emptyResolversListLookupAllRecords(self): """ L{ResolverChain.lookupAllRecords} returns a L{DomainError} failure if its C{resolvers} list is empty. """ r = ResolverChain([]) d = r.lookupAllRecords("www.example.com") f = self.failureResultOf(d) self.assertIs(f.trap(DomainError), DomainError) PK Mb�Z\�)wǢ Ǣ names/test/test_server.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.names.server}. """ from zope.interface.verify import verifyClass from twisted.internet import defer from twisted.internet.interfaces import IProtocolFactory from twisted.names import dns, error, resolve, server from twisted.python import failure, log from twisted.trial import unittest class RaisedArguments(Exception): """ An exception containing the arguments raised by L{raiser}. """ def __init__(self, args, kwargs): self.args = args self.kwargs = kwargs def raiser(*args, **kwargs): """ Raise a L{RaisedArguments} exception containing the supplied arguments. Used as a fake when testing the call signatures of methods and functions. """ raise RaisedArguments(args, kwargs) class NoResponseDNSServerFactory(server.DNSServerFactory): """ A L{server.DNSServerFactory} subclass which does not attempt to reply to any received messages. Used for testing logged messages in C{messageReceived} without having to fake or patch the preceding code which attempts to deliver a response message. """ def allowQuery(self, message, protocol, address): """ Deny all queries. @param message: See L{server.DNSServerFactory.allowQuery} @param protocol: See L{server.DNSServerFactory.allowQuery} @param address: See L{server.DNSServerFactory.allowQuery} @return: L{False} @rtype: L{bool} """ return False def sendReply(self, protocol, message, address): """ A noop send reply. @param protocol: See L{server.DNSServerFactory.sendReply} @param message: See L{server.DNSServerFactory.sendReply} @param address: See L{server.DNSServerFactory.sendReply} """ class RaisingDNSServerFactory(server.DNSServerFactory): """ A L{server.DNSServerFactory} subclass whose methods raise an exception containing the supplied arguments. Used for stopping L{messageReceived} and testing the arguments supplied to L{allowQuery}. """ class AllowQueryArguments(Exception): """ Contains positional and keyword arguments in C{args}. """ def allowQuery(self, *args, **kwargs): """ Raise the arguments supplied to L{allowQuery}. @param args: Positional arguments which will be recorded in the raised exception. @type args: L{tuple} @param kwargs: Keyword args which will be recorded in the raised exception. @type kwargs: L{dict} """ raise self.AllowQueryArguments(args, kwargs) class RaisingProtocol: """ A partial fake L{IProtocol} whose methods raise an exception containing the supplied arguments. """ class WriteMessageArguments(Exception): """ Contains positional and keyword arguments in C{args}. """ def writeMessage(self, *args, **kwargs): """ Raises the supplied arguments. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} """ raise self.WriteMessageArguments(args, kwargs) class NoopProtocol: """ A partial fake L{dns.DNSProtocolMixin} with a noop L{writeMessage} method. """ def writeMessage(self, *args, **kwargs): """ A noop version of L{dns.DNSProtocolMixin.writeMessage}. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} """ class RaisingResolver: """ A partial fake L{IResolver} whose methods raise an exception containing the supplied arguments. """ class QueryArguments(Exception): """ Contains positional and keyword arguments in C{args}. """ def query(self, *args, **kwargs): """ Raises the supplied arguments. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} """ raise self.QueryArguments(args, kwargs) class RaisingCache: """ A partial fake L{twisted.names.cache.Cache} whose methods raise an exception containing the supplied arguments. """ class CacheResultArguments(Exception): """ Contains positional and keyword arguments in C{args}. """ def cacheResult(self, *args, **kwargs): """ Raises the supplied arguments. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} """ raise self.CacheResultArguments(args, kwargs) def assertLogMessage(testCase, expectedMessages, callable, *args, **kwargs): """ Assert that the callable logs the expected messages when called. XXX: Put this somewhere where it can be re-used elsewhere. See #6677. @param testCase: The test case controlling the test which triggers the logged messages and on which assertions will be called. @type testCase: L{unittest.SynchronousTestCase} @param expectedMessages: A L{list} of the expected log messages @type expectedMessages: L{list} @param callable: The function which is expected to produce the C{expectedMessages} when called. @type callable: L{callable} @param args: Positional arguments to be passed to C{callable}. @type args: L{list} @param kwargs: Keyword arguments to be passed to C{callable}. @type kwargs: L{dict} """ loggedMessages = [] log.addObserver(loggedMessages.append) testCase.addCleanup(log.removeObserver, loggedMessages.append) callable(*args, **kwargs) testCase.assertEqual([m["message"][0] for m in loggedMessages], expectedMessages) class DNSServerFactoryTests(unittest.TestCase): """ Tests for L{server.DNSServerFactory}. """ def test_resolverType(self): """ L{server.DNSServerFactory.resolver} is a L{resolve.ResolverChain} instance """ self.assertIsInstance(server.DNSServerFactory().resolver, resolve.ResolverChain) def test_resolverDefaultEmpty(self): """ L{server.DNSServerFactory.resolver} is an empty L{resolve.ResolverChain} by default. """ self.assertEqual(server.DNSServerFactory().resolver.resolvers, []) def test_authorities(self): """ L{server.DNSServerFactory.__init__} accepts an C{authorities} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. """ dummyResolver = object() self.assertEqual( server.DNSServerFactory(authorities=[dummyResolver]).resolver.resolvers, [dummyResolver], ) def test_caches(self): """ L{server.DNSServerFactory.__init__} accepts a C{caches} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. """ dummyResolver = object() self.assertEqual( server.DNSServerFactory(caches=[dummyResolver]).resolver.resolvers, [dummyResolver], ) def test_clients(self): """ L{server.DNSServerFactory.__init__} accepts a C{clients} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. """ dummyResolver = object() self.assertEqual( server.DNSServerFactory(clients=[dummyResolver]).resolver.resolvers, [dummyResolver], ) def test_resolverOrder(self): """ L{server.DNSServerFactory.resolver} contains an ordered list of authorities, caches and clients. """ # Use classes here so that we can see meaningful names in test results class DummyAuthority: pass class DummyCache: pass class DummyClient: pass self.assertEqual( server.DNSServerFactory( authorities=[DummyAuthority], caches=[DummyCache], clients=[DummyClient] ).resolver.resolvers, [DummyAuthority, DummyCache, DummyClient], ) def test_cacheDefault(self): """ L{server.DNSServerFactory.cache} is L{None} by default. """ self.assertIsNone(server.DNSServerFactory().cache) def test_cacheOverride(self): """ L{server.DNSServerFactory.__init__} assigns the last object in the C{caches} list to L{server.DNSServerFactory.cache}. """ dummyResolver = object() self.assertEqual( server.DNSServerFactory(caches=[object(), dummyResolver]).cache, dummyResolver, ) def test_canRecurseDefault(self): """ L{server.DNSServerFactory.canRecurse} is a flag indicating that this server is capable of performing recursive DNS lookups. It defaults to L{False}. """ self.assertFalse(server.DNSServerFactory().canRecurse) def test_canRecurseOverride(self): """ L{server.DNSServerFactory.__init__} sets C{canRecurse} to L{True} if it is supplied with C{clients}. """ self.assertEqual(server.DNSServerFactory(clients=[None]).canRecurse, True) def test_verboseDefault(self): """ L{server.DNSServerFactory.verbose} defaults to L{False}. """ self.assertFalse(server.DNSServerFactory().verbose) def test_verboseOverride(self): """ L{server.DNSServerFactory.__init__} accepts a C{verbose} argument which overrides L{server.DNSServerFactory.verbose}. """ self.assertTrue(server.DNSServerFactory(verbose=True).verbose) def test_interface(self): """ L{server.DNSServerFactory} implements L{IProtocolFactory}. """ self.assertTrue(verifyClass(IProtocolFactory, server.DNSServerFactory)) def test_defaultProtocol(self): """ L{server.DNSServerFactory.protocol} defaults to L{dns.DNSProtocol}. """ self.assertIs(server.DNSServerFactory.protocol, dns.DNSProtocol) def test_buildProtocolProtocolOverride(self): """ L{server.DNSServerFactory.buildProtocol} builds a protocol by calling L{server.DNSServerFactory.protocol} with its self as a positional argument. """ class FakeProtocol: factory = None args = None kwargs = None stubProtocol = FakeProtocol() def fakeProtocolFactory(*args, **kwargs): stubProtocol.args = args stubProtocol.kwargs = kwargs return stubProtocol f = server.DNSServerFactory() f.protocol = fakeProtocolFactory p = f.buildProtocol(addr=None) self.assertEqual((stubProtocol, (f,), {}), (p, p.args, p.kwargs)) def test_verboseLogQuiet(self): """ L{server.DNSServerFactory._verboseLog} does not log messages unless C{verbose > 0}. """ f = server.DNSServerFactory() assertLogMessage(self, [], f._verboseLog, "Foo Bar") def test_verboseLogVerbose(self): """ L{server.DNSServerFactory._verboseLog} logs a message if C{verbose > 0}. """ f = server.DNSServerFactory(verbose=1) assertLogMessage(self, ["Foo Bar"], f._verboseLog, "Foo Bar") def test_messageReceivedLoggingNoQuery(self): """ L{server.DNSServerFactory.messageReceived} logs about an empty query if the message had no queries and C{verbose} is C{>0}. """ m = dns.Message() f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Empty query from ('192.0.2.100', 53)"], f.messageReceived, message=m, proto=None, address=("192.0.2.100", 53), ) def test_messageReceivedLogging1(self): """ L{server.DNSServerFactory.messageReceived} logs the query types of all queries in the message if C{verbose} is set to C{1}. """ m = dns.Message() m.addQuery(name="example.com", type=dns.MX) m.addQuery(name="example.com", type=dns.AAAA) f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["MX AAAA query from ('192.0.2.100', 53)"], f.messageReceived, message=m, proto=None, address=("192.0.2.100", 53), ) def test_messageReceivedLogging2(self): """ L{server.DNSServerFactory.messageReceived} logs the repr of all queries in the message if C{verbose} is set to C{2}. """ m = dns.Message() m.addQuery(name="example.com", type=dns.MX) m.addQuery(name="example.com", type=dns.AAAA) f = NoResponseDNSServerFactory(verbose=2) assertLogMessage( self, [ "<Query example.com MX IN> " "<Query example.com AAAA IN> query from ('192.0.2.100', 53)" ], f.messageReceived, message=m, proto=None, address=("192.0.2.100", 53), ) def test_messageReceivedTimestamp(self): """ L{server.DNSServerFactory.messageReceived} assigns a unix timestamp to the received message. """ m = dns.Message() f = NoResponseDNSServerFactory() t = object() self.patch(server.time, "time", lambda: t) f.messageReceived(message=m, proto=None, address=None) self.assertEqual(m.timeReceived, t) def test_messageReceivedAllowQuery(self): """ L{server.DNSServerFactory.messageReceived} passes all messages to L{server.DNSServerFactory.allowQuery} along with the receiving protocol and origin address. """ message = dns.Message() dummyProtocol = object() dummyAddress = object() f = RaisingDNSServerFactory() e = self.assertRaises( RaisingDNSServerFactory.AllowQueryArguments, f.messageReceived, message=message, proto=dummyProtocol, address=dummyAddress, ) args, kwargs = e.args self.assertEqual(args, (message, dummyProtocol, dummyAddress)) self.assertEqual(kwargs, {}) def test_allowQueryFalse(self): """ If C{allowQuery} returns C{False}, L{server.DNSServerFactory.messageReceived} calls L{server.sendReply} with a message whose C{rCode} is L{dns.EREFUSED}. """ class SendReplyException(Exception): pass class RaisingDNSServerFactory(server.DNSServerFactory): def allowQuery(self, *args, **kwargs): return False def sendReply(self, *args, **kwargs): raise SendReplyException(args, kwargs) f = RaisingDNSServerFactory() e = self.assertRaises( SendReplyException, f.messageReceived, message=dns.Message(), proto=None, address=None, ) (proto, message, address), kwargs = e.args self.assertEqual(message.rCode, dns.EREFUSED) def _messageReceivedTest(self, methodName, message): """ Assert that the named method is called with the given message when it is passed to L{DNSServerFactory.messageReceived}. @param methodName: The name of the method which is expected to be called. @type methodName: L{str} @param message: The message which is expected to be passed to the C{methodName} method. @type message: L{dns.Message} """ # Make it appear to have some queries so that # DNSServerFactory.allowQuery allows it. message.queries = [None] receivedMessages = [] def fakeHandler(message, protocol, address): receivedMessages.append((message, protocol, address)) protocol = NoopProtocol() factory = server.DNSServerFactory(None) setattr(factory, methodName, fakeHandler) factory.messageReceived(message, protocol) self.assertEqual(receivedMessages, [(message, protocol, None)]) def test_queryMessageReceived(self): """ L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_QUERY} on to L{DNSServerFactory.handleQuery}. """ self._messageReceivedTest("handleQuery", dns.Message(opCode=dns.OP_QUERY)) def test_inverseQueryMessageReceived(self): """ L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_INVERSE} on to L{DNSServerFactory.handleInverseQuery}. """ self._messageReceivedTest( "handleInverseQuery", dns.Message(opCode=dns.OP_INVERSE) ) def test_statusMessageReceived(self): """ L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_STATUS} on to L{DNSServerFactory.handleStatus}. """ self._messageReceivedTest("handleStatus", dns.Message(opCode=dns.OP_STATUS)) def test_notifyMessageReceived(self): """ L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_NOTIFY} on to L{DNSServerFactory.handleNotify}. """ self._messageReceivedTest("handleNotify", dns.Message(opCode=dns.OP_NOTIFY)) def test_updateMessageReceived(self): """ L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_UPDATE} on to L{DNSServerFactory.handleOther}. This may change if the implementation ever covers update messages. """ self._messageReceivedTest("handleOther", dns.Message(opCode=dns.OP_UPDATE)) def test_connectionTracking(self): """ The C{connectionMade} and C{connectionLost} methods of L{DNSServerFactory} cooperate to keep track of all L{DNSProtocol} objects created by a factory which are connected. """ protoA, protoB = object(), object() factory = server.DNSServerFactory() factory.connectionMade(protoA) self.assertEqual(factory.connections, [protoA]) factory.connectionMade(protoB) self.assertEqual(factory.connections, [protoA, protoB]) factory.connectionLost(protoA) self.assertEqual(factory.connections, [protoB]) factory.connectionLost(protoB) self.assertEqual(factory.connections, []) def test_handleQuery(self): """ L{server.DNSServerFactory.handleQuery} takes the first query from the supplied message and dispatches it to L{server.DNSServerFactory.resolver.query}. """ m = dns.Message() m.addQuery(b"one.example.com") m.addQuery(b"two.example.com") f = server.DNSServerFactory() f.resolver = RaisingResolver() e = self.assertRaises( RaisingResolver.QueryArguments, f.handleQuery, message=m, protocol=NoopProtocol(), address=None, ) (query,), kwargs = e.args self.assertEqual(query, m.queries[0]) def test_handleQueryCallback(self): """ L{server.DNSServerFactory.handleQuery} adds L{server.DNSServerFactory.resolver.gotResolverResponse} as a callback to the deferred returned by L{server.DNSServerFactory.resolver.query}. It is called with the query response, the original protocol, message and origin address. """ f = server.DNSServerFactory() d = defer.Deferred() class FakeResolver: def query(self, *args, **kwargs): return d f.resolver = FakeResolver() gotResolverResponseArgs = [] def fakeGotResolverResponse(*args, **kwargs): gotResolverResponseArgs.append((args, kwargs)) f.gotResolverResponse = fakeGotResolverResponse m = dns.Message() m.addQuery(b"one.example.com") stubProtocol = NoopProtocol() dummyAddress = object() f.handleQuery(message=m, protocol=stubProtocol, address=dummyAddress) dummyResponse = object() d.callback(dummyResponse) self.assertEqual( gotResolverResponseArgs, [((dummyResponse, stubProtocol, m, dummyAddress), {})], ) def test_handleQueryErrback(self): """ L{server.DNSServerFactory.handleQuery} adds L{server.DNSServerFactory.resolver.gotResolverError} as an errback to the deferred returned by L{server.DNSServerFactory.resolver.query}. It is called with the query failure, the original protocol, message and origin address. """ f = server.DNSServerFactory() d = defer.Deferred() class FakeResolver: def query(self, *args, **kwargs): return d f.resolver = FakeResolver() gotResolverErrorArgs = [] def fakeGotResolverError(*args, **kwargs): gotResolverErrorArgs.append((args, kwargs)) f.gotResolverError = fakeGotResolverError m = dns.Message() m.addQuery(b"one.example.com") stubProtocol = NoopProtocol() dummyAddress = object() f.handleQuery(message=m, protocol=stubProtocol, address=dummyAddress) stubFailure = failure.Failure(Exception()) d.errback(stubFailure) self.assertEqual( gotResolverErrorArgs, [((stubFailure, stubProtocol, m, dummyAddress), {})] ) def test_gotResolverResponse(self): """ L{server.DNSServerFactory.gotResolverResponse} accepts a tuple of resource record lists and triggers a response message containing those resource record lists. """ f = server.DNSServerFactory() answers = [] authority = [] additional = [] e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.gotResolverResponse, (answers, authority, additional), protocol=RaisingProtocol(), message=dns.Message(), address=None, ) (message,), kwargs = e.args self.assertIs(message.answers, answers) self.assertIs(message.authority, authority) self.assertIs(message.additional, additional) def test_gotResolverResponseCallsResponseFromMessage(self): """ L{server.DNSServerFactory.gotResolverResponse} calls L{server.DNSServerFactory._responseFromMessage} to generate a response. """ factory = NoResponseDNSServerFactory() factory._responseFromMessage = raiser request = dns.Message() request.timeReceived = 1 e = self.assertRaises( RaisedArguments, factory.gotResolverResponse, ([], [], []), protocol=None, message=request, address=None, ) self.assertEqual( ( (), dict( message=request, rCode=dns.OK, answers=[], authority=[], additional=[], ), ), (e.args, e.kwargs), ) def test_responseFromMessageNewMessage(self): """ L{server.DNSServerFactory._responseFromMessage} generates a response message which is a copy of the request message. """ factory = server.DNSServerFactory() request = dns.Message(answer=False, recAv=False) response = (factory._responseFromMessage(message=request),) self.assertIsNot(request, response) def test_responseFromMessageRecursionAvailable(self): """ L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{recAV} attribute is L{True} if L{server.DNSServerFactory.canRecurse} is L{True}. """ factory = server.DNSServerFactory() factory.canRecurse = True response1 = factory._responseFromMessage(message=dns.Message(recAv=False)) factory.canRecurse = False response2 = factory._responseFromMessage(message=dns.Message(recAv=True)) self.assertEqual((True, False), (response1.recAv, response2.recAv)) def test_responseFromMessageTimeReceived(self): """ L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{timeReceived} attribute has the same value as that found on the request. """ factory = server.DNSServerFactory() request = dns.Message() request.timeReceived = 1234 response = factory._responseFromMessage(message=request) self.assertEqual(request.timeReceived, response.timeReceived) def test_responseFromMessageMaxSize(self): """ L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{maxSize} attribute has the same value as that found on the request. """ factory = server.DNSServerFactory() request = dns.Message() request.maxSize = 0 response = factory._responseFromMessage(message=request) self.assertEqual(request.maxSize, response.maxSize) def test_messageFactory(self): """ L{server.DNSServerFactory} has a C{_messageFactory} attribute which is L{dns.Message} by default. """ self.assertIs(dns.Message, server.DNSServerFactory._messageFactory) def test_responseFromMessageCallsMessageFactory(self): """ L{server.DNSServerFactory._responseFromMessage} calls C{dns._responseFromMessage} to generate a response message from the request message. It supplies the request message and other keyword arguments which should be passed to the response message initialiser. """ factory = server.DNSServerFactory() self.patch(dns, "_responseFromMessage", raiser) request = dns.Message() e = self.assertRaises( RaisedArguments, factory._responseFromMessage, message=request, rCode=dns.OK ) self.assertEqual( ( (), dict( responseConstructor=factory._messageFactory, message=request, rCode=dns.OK, recAv=factory.canRecurse, auth=False, ), ), (e.args, e.kwargs), ) def test_responseFromMessageAuthoritativeMessage(self): """ L{server.DNSServerFactory._responseFromMessage} marks the response message as authoritative if any of the answer records are authoritative. """ factory = server.DNSServerFactory() response1 = factory._responseFromMessage( message=dns.Message(), answers=[dns.RRHeader(auth=True)] ) response2 = factory._responseFromMessage( message=dns.Message(), answers=[dns.RRHeader(auth=False)] ) self.assertEqual( (True, False), (response1.auth, response2.auth), ) def test_gotResolverResponseLogging(self): """ L{server.DNSServerFactory.gotResolverResponse} logs the total number of records in the response if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) answers = [dns.RRHeader()] authority = [dns.RRHeader()] additional = [dns.RRHeader()] assertLogMessage( self, ["Lookup found 3 records"], f.gotResolverResponse, (answers, authority, additional), protocol=NoopProtocol(), message=dns.Message(), address=None, ) def test_gotResolverResponseCaching(self): """ L{server.DNSServerFactory.gotResolverResponse} caches the response if at least one cache was provided in the constructor. """ f = NoResponseDNSServerFactory(caches=[RaisingCache()]) m = dns.Message() m.addQuery(b"example.com") expectedAnswers = [dns.RRHeader()] expectedAuthority = [] expectedAdditional = [] e = self.assertRaises( RaisingCache.CacheResultArguments, f.gotResolverResponse, (expectedAnswers, expectedAuthority, expectedAdditional), protocol=NoopProtocol(), message=m, address=None, ) (query, (answers, authority, additional)), kwargs = e.args self.assertEqual(query.name.name, b"example.com") self.assertIs(answers, expectedAnswers) self.assertIs(authority, expectedAuthority) self.assertIs(additional, expectedAdditional) def test_gotResolverErrorCallsResponseFromMessage(self): """ L{server.DNSServerFactory.gotResolverError} calls L{server.DNSServerFactory._responseFromMessage} to generate a response. """ factory = NoResponseDNSServerFactory() factory._responseFromMessage = raiser request = dns.Message() request.timeReceived = 1 e = self.assertRaises( RaisedArguments, factory.gotResolverError, failure.Failure(error.DomainError()), protocol=None, message=request, address=None, ) self.assertEqual( ((), dict(message=request, rCode=dns.ENAME)), (e.args, e.kwargs) ) def _assertMessageRcodeForError(self, responseError, expectedMessageCode): """ L{server.DNSServerFactory.gotResolver} accepts a L{failure.Failure} and triggers a response message whose rCode corresponds to the DNS error contained in the C{Failure}. @param responseError: The L{Exception} instance which is expected to trigger C{expectedMessageCode} when it is supplied to C{gotResolverError} @type responseError: L{Exception} @param expectedMessageCode: The C{rCode} which is expected in the message returned by C{gotResolverError} in response to C{responseError}. @type expectedMessageCode: L{int} """ f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.gotResolverError, failure.Failure(responseError), protocol=RaisingProtocol(), message=dns.Message(), address=None, ) (message,), kwargs = e.args self.assertEqual(message.rCode, expectedMessageCode) def test_gotResolverErrorDomainError(self): """ L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ENAME} if supplied with a L{error.DomainError}. """ self._assertMessageRcodeForError(error.DomainError(), dns.ENAME) def test_gotResolverErrorAuthoritativeDomainError(self): """ L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ENAME} if supplied with a L{error.AuthoritativeDomainError}. """ self._assertMessageRcodeForError(error.AuthoritativeDomainError(), dns.ENAME) def test_gotResolverErrorOtherError(self): """ L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ESERVER} if supplied with another type of error and logs the error. """ self._assertMessageRcodeForError(KeyError(), dns.ESERVER) e = self.flushLoggedErrors(KeyError) self.assertEqual(len(e), 1) def test_gotResolverErrorLogging(self): """ L{server.DNSServerFactory.gotResolver} logs a message if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Lookup failed"], f.gotResolverError, failure.Failure(error.DomainError()), protocol=NoopProtocol(), message=dns.Message(), address=None, ) def test_gotResolverErrorResetsResponseAttributes(self): """ L{server.DNSServerFactory.gotResolverError} does not allow request attributes to leak into the response ie it sends a response with AD, CD set to 0 and empty response record sections. """ factory = server.DNSServerFactory() responses = [] factory.sendReply = lambda protocol, response, address: responses.append( response ) request = dns.Message(authenticData=True, checkingDisabled=True) request.answers = [object(), object()] request.authority = [object(), object()] request.additional = [object(), object()] factory.gotResolverError( failure.Failure(error.DomainError()), protocol=None, message=request, address=None, ) self.assertEqual([dns.Message(rCode=3, answer=True)], responses) def test_gotResolverResponseResetsResponseAttributes(self): """ L{server.DNSServerFactory.gotResolverResponse} does not allow request attributes to leak into the response ie it sends a response with AD, CD set to 0 and none of the records in the request answer sections are copied to the response. """ factory = server.DNSServerFactory() responses = [] factory.sendReply = lambda protocol, response, address: responses.append( response ) request = dns.Message(authenticData=True, checkingDisabled=True) request.answers = [object(), object()] request.authority = [object(), object()] request.additional = [object(), object()] factory.gotResolverResponse( ([], [], []), protocol=None, message=request, address=None ) self.assertEqual([dns.Message(rCode=0, answer=True)], responses) def test_sendReplyWithAddress(self): """ If L{server.DNSServerFactory.sendReply} is supplied with a protocol *and* an address tuple it will supply that address to C{protocol.writeMessage}. """ m = dns.Message() dummyAddress = object() f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.sendReply, protocol=RaisingProtocol(), message=m, address=dummyAddress, ) args, kwargs = e.args self.assertEqual(args, (m, dummyAddress)) self.assertEqual(kwargs, {}) def test_sendReplyWithoutAddress(self): """ If L{server.DNSServerFactory.sendReply} is supplied with a protocol but no address tuple it will supply only a message to C{protocol.writeMessage}. """ m = dns.Message() f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.sendReply, protocol=RaisingProtocol(), message=m, address=None, ) args, kwargs = e.args self.assertEqual(args, (m,)) self.assertEqual(kwargs, {}) def test_sendReplyLoggingNoAnswers(self): """ If L{server.DNSServerFactory.sendReply} logs a "no answers" message if the supplied message has no answers. """ self.patch(server.time, "time", lambda: 86402) m = dns.Message() m.timeReceived = 86401 f = server.DNSServerFactory(verbose=2) assertLogMessage( self, ["Replying with no answers", "Processed query in 1.000 seconds"], f.sendReply, protocol=NoopProtocol(), message=m, address=None, ) def test_sendReplyLoggingWithAnswers(self): """ If L{server.DNSServerFactory.sendReply} logs a message for answers, authority, additional if the supplied a message has records in any of those sections. """ self.patch(server.time, "time", lambda: 86402) m = dns.Message() m.answers.append(dns.RRHeader(payload=dns.Record_A("127.0.0.1"))) m.authority.append(dns.RRHeader(payload=dns.Record_A("127.0.0.1"))) m.additional.append(dns.RRHeader(payload=dns.Record_A("127.0.0.1"))) m.timeReceived = 86401 f = server.DNSServerFactory(verbose=2) assertLogMessage( self, [ "Answers are <A address=127.0.0.1 ttl=None>", "Authority is <A address=127.0.0.1 ttl=None>", "Additional is <A address=127.0.0.1 ttl=None>", "Processed query in 1.000 seconds", ], f.sendReply, protocol=NoopProtocol(), message=m, address=None, ) def test_handleInverseQuery(self): """ L{server.DNSServerFactory.handleInverseQuery} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. """ f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.handleInverseQuery, message=dns.Message(), protocol=RaisingProtocol(), address=None, ) (message,), kwargs = e.args self.assertEqual(message.rCode, dns.ENOTIMP) def test_handleInverseQueryLogging(self): """ L{server.DNSServerFactory.handleInverseQuery} logs the message origin address if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Inverse query from ('::1', 53)"], f.handleInverseQuery, message=dns.Message(), protocol=NoopProtocol(), address=("::1", 53), ) def test_handleStatus(self): """ L{server.DNSServerFactory.handleStatus} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. """ f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.handleStatus, message=dns.Message(), protocol=RaisingProtocol(), address=None, ) (message,), kwargs = e.args self.assertEqual(message.rCode, dns.ENOTIMP) def test_handleStatusLogging(self): """ L{server.DNSServerFactory.handleStatus} logs the message origin address if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Status request from ('::1', 53)"], f.handleStatus, message=dns.Message(), protocol=NoopProtocol(), address=("::1", 53), ) def test_handleNotify(self): """ L{server.DNSServerFactory.handleNotify} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. """ f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.handleNotify, message=dns.Message(), protocol=RaisingProtocol(), address=None, ) (message,), kwargs = e.args self.assertEqual(message.rCode, dns.ENOTIMP) def test_handleNotifyLogging(self): """ L{server.DNSServerFactory.handleNotify} logs the message origin address if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Notify message from ('::1', 53)"], f.handleNotify, message=dns.Message(), protocol=NoopProtocol(), address=("::1", 53), ) def test_handleOther(self): """ L{server.DNSServerFactory.handleOther} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. """ f = server.DNSServerFactory() e = self.assertRaises( RaisingProtocol.WriteMessageArguments, f.handleOther, message=dns.Message(), protocol=RaisingProtocol(), address=None, ) (message,), kwargs = e.args self.assertEqual(message.rCode, dns.ENOTIMP) def test_handleOtherLogging(self): """ L{server.DNSServerFactory.handleOther} logs the message origin address if C{verbose > 0}. """ f = NoResponseDNSServerFactory(verbose=1) assertLogMessage( self, ["Unknown op code (0) from ('::1', 53)"], f.handleOther, message=dns.Message(), protocol=NoopProtocol(), address=("::1", 53), ) PK Mb�Z���}� � names/test/test_cache.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.names.cache}. """ import time from zope.interface.verify import verifyClass from twisted.internet import interfaces, task from twisted.names import cache, dns from twisted.trial import unittest class CachingTests(unittest.TestCase): """ Tests for L{cache.CacheResolver}. """ def test_interface(self): """ L{cache.CacheResolver} implements L{interfaces.IResolver} """ verifyClass(interfaces.IResolver, cache.CacheResolver) def test_lookup(self): c = cache.CacheResolver( { dns.Query(name=b"example.com", type=dns.MX, cls=dns.IN): ( time.time(), ([], [], []), ) } ) return c.lookupMailExchange(b"example.com").addCallback( self.assertEqual, ([], [], []) ) def test_constructorExpires(self): """ Cache entries passed into L{cache.CacheResolver.__init__} get cancelled just like entries added with cacheResult """ r = ( [ dns.RRHeader( b"example.com", dns.A, dns.IN, 60, dns.Record_A("127.0.0.1", 60) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 50, dns.Record_A("127.0.0.1", 50) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 40, dns.Record_A("127.0.0.1", 40) ) ], ) clock = task.Clock() query = dns.Query(name=b"example.com", type=dns.A, cls=dns.IN) c = cache.CacheResolver({query: (clock.seconds(), r)}, reactor=clock) # 40 seconds is enough to expire the entry because expiration is based # on the minimum TTL. clock.advance(40) self.assertNotIn(query, c.cache) return self.assertFailure(c.lookupAddress(b"example.com"), dns.DomainError) def test_normalLookup(self): """ When a cache lookup finds a cached entry from 1 second ago, it is returned with a TTL of original TTL minus the elapsed 1 second. """ r = ( [ dns.RRHeader( b"example.com", dns.A, dns.IN, 60, dns.Record_A("127.0.0.1", 60) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 50, dns.Record_A("127.0.0.1", 50) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 40, dns.Record_A("127.0.0.1", 40) ) ], ) clock = task.Clock() c = cache.CacheResolver(reactor=clock) c.cacheResult(dns.Query(name=b"example.com", type=dns.A, cls=dns.IN), r) clock.advance(1) def cbLookup(result): self.assertEqual(result[0][0].ttl, 59) self.assertEqual(result[1][0].ttl, 49) self.assertEqual(result[2][0].ttl, 39) self.assertEqual(result[0][0].name.name, b"example.com") return c.lookupAddress(b"example.com").addCallback(cbLookup) def test_cachedResultExpires(self): """ Once the TTL has been exceeded, the result is removed from the cache. """ r = ( [ dns.RRHeader( b"example.com", dns.A, dns.IN, 60, dns.Record_A("127.0.0.1", 60) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 50, dns.Record_A("127.0.0.1", 50) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 40, dns.Record_A("127.0.0.1", 40) ) ], ) clock = task.Clock() c = cache.CacheResolver(reactor=clock) query = dns.Query(name=b"example.com", type=dns.A, cls=dns.IN) c.cacheResult(query, r) clock.advance(40) self.assertNotIn(query, c.cache) return self.assertFailure(c.lookupAddress(b"example.com"), dns.DomainError) def test_expiredTTLLookup(self): """ When the cache is queried exactly as the cached entry should expire but before it has actually been cleared, the cache does not return the expired entry. """ r = ( [ dns.RRHeader( b"example.com", dns.A, dns.IN, 60, dns.Record_A("127.0.0.1", 60) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 50, dns.Record_A("127.0.0.1", 50) ) ], [ dns.RRHeader( b"example.com", dns.A, dns.IN, 40, dns.Record_A("127.0.0.1", 40) ) ], ) clock = task.Clock() # Make sure timeouts never happen, so entries won't get cleared: clock.callLater = lambda *args, **kwargs: None c = cache.CacheResolver( { dns.Query(name=b"example.com", type=dns.A, cls=dns.IN): ( clock.seconds(), r, ) }, reactor=clock, ) clock.advance(60.1) return self.assertFailure(c.lookupAddress(b"example.com"), dns.DomainError) PK Mb�Z��V� 6 6 names/test/test_rfc1982.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.names.rfc1982}. """ import calendar from datetime import datetime from functools import partial from twisted.names._rfc1982 import SerialNumber from twisted.trial import unittest class SerialNumberTests(unittest.TestCase): """ Tests for L{SerialNumber}. """ def test_serialBitsDefault(self): """ L{SerialNumber.serialBits} has default value 32. """ self.assertEqual(SerialNumber(1)._serialBits, 32) def test_serialBitsOverride(self): """ L{SerialNumber.__init__} accepts a C{serialBits} argument whose value is assigned to L{SerialNumber.serialBits}. """ self.assertEqual(SerialNumber(1, serialBits=8)._serialBits, 8) def test_repr(self): """ L{SerialNumber.__repr__} returns a string containing number and serialBits. """ self.assertEqual( "<SerialNumber number=123 serialBits=32>", repr(SerialNumber(123, serialBits=32)), ) def test_str(self): """ L{SerialNumber.__str__} returns a string representation of the current value. """ self.assertEqual(str(SerialNumber(123)), "123") def test_int(self): """ L{SerialNumber.__int__} returns an integer representation of the current value. """ self.assertEqual(int(SerialNumber(123)), 123) def test_hash(self): """ L{SerialNumber.__hash__} allows L{SerialNumber} instances to be hashed for use as dictionary keys. """ self.assertEqual(hash(SerialNumber(1)), hash(SerialNumber(1))) self.assertNotEqual(hash(SerialNumber(1)), hash(SerialNumber(2))) def test_convertOtherSerialBitsMismatch(self): """ L{SerialNumber._convertOther} raises L{TypeError} if the other SerialNumber instance has a different C{serialBits} value. """ s1 = SerialNumber(0, serialBits=8) s2 = SerialNumber(0, serialBits=16) self.assertRaises(TypeError, s1._convertOther, s2) def test_eq(self): """ L{SerialNumber.__eq__} provides rich equality comparison. """ self.assertEqual(SerialNumber(1), SerialNumber(1)) def test_eqForeignType(self): """ == comparison of L{SerialNumber} with a non-L{SerialNumber} instance returns L{NotImplemented}. """ self.assertFalse(SerialNumber(1) == object()) self.assertIs(SerialNumber(1).__eq__(object()), NotImplemented) def test_ne(self): """ L{SerialNumber.__ne__} provides rich equality comparison. """ self.assertFalse(SerialNumber(1) != SerialNumber(1)) self.assertNotEqual(SerialNumber(1), SerialNumber(2)) def test_neForeignType(self): """ != comparison of L{SerialNumber} with a non-L{SerialNumber} instance returns L{NotImplemented}. """ self.assertTrue(SerialNumber(1) != object()) self.assertIs(SerialNumber(1).__ne__(object()), NotImplemented) def test_le(self): """ L{SerialNumber.__le__} provides rich <= comparison. """ self.assertTrue(SerialNumber(1) <= SerialNumber(1)) self.assertTrue(SerialNumber(1) <= SerialNumber(2)) def test_leForeignType(self): """ <= comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. """ self.assertRaises(TypeError, lambda: SerialNumber(1) <= object()) def test_ge(self): """ L{SerialNumber.__ge__} provides rich >= comparison. """ self.assertTrue(SerialNumber(1) >= SerialNumber(1)) self.assertTrue(SerialNumber(2) >= SerialNumber(1)) def test_geForeignType(self): """ >= comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. """ self.assertRaises(TypeError, lambda: SerialNumber(1) >= object()) def test_lt(self): """ L{SerialNumber.__lt__} provides rich < comparison. """ self.assertTrue(SerialNumber(1) < SerialNumber(2)) def test_ltForeignType(self): """ < comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. """ self.assertRaises(TypeError, lambda: SerialNumber(1) < object()) def test_gt(self): """ L{SerialNumber.__gt__} provides rich > comparison. """ self.assertTrue(SerialNumber(2) > SerialNumber(1)) def test_gtForeignType(self): """ > comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. """ self.assertRaises(TypeError, lambda: SerialNumber(2) > object()) def test_add(self): """ L{SerialNumber.__add__} allows L{SerialNumber} instances to be summed. """ self.assertEqual(SerialNumber(1) + SerialNumber(1), SerialNumber(2)) def test_addForeignType(self): """ Addition of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. """ self.assertRaises(TypeError, lambda: SerialNumber(1) + object()) def test_addOutOfRangeHigh(self): """ L{SerialNumber} cannot be added with other SerialNumber values larger than C{_maxAdd}. """ maxAdd = SerialNumber(1)._maxAdd self.assertRaises( ArithmeticError, lambda: SerialNumber(1) + SerialNumber(maxAdd + 1) ) def test_maxVal(self): """ L{SerialNumber.__add__} returns a wrapped value when s1 plus the s2 would result in a value greater than the C{maxVal}. """ s = SerialNumber(1) maxVal = s._halfRing + s._halfRing - 1 maxValPlus1 = maxVal + 1 self.assertTrue(SerialNumber(maxValPlus1) > SerialNumber(maxVal)) self.assertEqual(SerialNumber(maxValPlus1), SerialNumber(0)) def test_fromRFC4034DateString(self): """ L{SerialNumber.fromRFC4034DateString} accepts a datetime string argument of the form 'YYYYMMDDhhmmss' and returns an L{SerialNumber} instance whose value is the unix timestamp corresponding to that UTC date. """ self.assertEqual( SerialNumber(1325376000), SerialNumber.fromRFC4034DateString("20120101000000"), ) def test_toRFC4034DateString(self): """ L{DateSerialNumber.toRFC4034DateString} interprets the current value as a unix timestamp and returns a date string representation of that date. """ self.assertEqual( "20120101000000", SerialNumber(1325376000).toRFC4034DateString() ) def test_unixEpoch(self): """ L{SerialNumber.toRFC4034DateString} stores 32bit timestamps relative to the UNIX epoch. """ self.assertEqual(SerialNumber(0).toRFC4034DateString(), "19700101000000") def test_Y2106Problem(self): """ L{SerialNumber} wraps unix timestamps in the year 2106. """ self.assertEqual(SerialNumber(-1).toRFC4034DateString(), "21060207062815") def test_Y2038Problem(self): """ L{SerialNumber} raises ArithmeticError when used to add dates more than 68 years in the future. """ maxAddTime = calendar.timegm(datetime(2038, 1, 19, 3, 14, 7).utctimetuple()) self.assertEqual( maxAddTime, SerialNumber(0)._maxAdd, ) self.assertRaises( ArithmeticError, lambda: SerialNumber(0) + SerialNumber(maxAddTime + 1) ) def assertUndefinedComparison(testCase, s1, s2): """ A custom assertion for L{SerialNumber} values that cannot be meaningfully compared. "Note that there are some pairs of values s1 and s2 for which s1 is not equal to s2, but for which s1 is neither greater than, nor less than, s2. An attempt to use these ordering operators on such pairs of values produces an undefined result." @see: U{https://tools.ietf.org/html/rfc1982#section-3.2} @param testCase: The L{unittest.TestCase} on which to call assertion methods. @type testCase: L{unittest.TestCase} @param s1: The first value to compare. @type s1: L{SerialNumber} @param s2: The second value to compare. @type s2: L{SerialNumber} """ testCase.assertFalse(s1 == s2) testCase.assertFalse(s1 <= s2) testCase.assertFalse(s1 < s2) testCase.assertFalse(s1 > s2) testCase.assertFalse(s1 >= s2) serialNumber2 = partial(SerialNumber, serialBits=2) class SerialNumber2BitTests(unittest.TestCase): """ Tests for correct answers to example calculations in RFC1982 5.1. The simplest meaningful serial number space has SERIAL_BITS == 2. In this space, the integers that make up the serial number space are 0, 1, 2, and 3. That is, 3 == 2^SERIAL_BITS - 1. https://tools.ietf.org/html/rfc1982#section-5.1 """ def test_maxadd(self): """ In this space, the largest integer that it is meaningful to add to a sequence number is 2^(SERIAL_BITS - 1) - 1, or 1. """ self.assertEqual(SerialNumber(0, serialBits=2)._maxAdd, 1) def test_add(self): """ Then, as defined 0+1 == 1, 1+1 == 2, 2+1 == 3, and 3+1 == 0. """ self.assertEqual(serialNumber2(0) + serialNumber2(1), serialNumber2(1)) self.assertEqual(serialNumber2(1) + serialNumber2(1), serialNumber2(2)) self.assertEqual(serialNumber2(2) + serialNumber2(1), serialNumber2(3)) self.assertEqual(serialNumber2(3) + serialNumber2(1), serialNumber2(0)) def test_gt(self): """ Further, 1 > 0, 2 > 1, 3 > 2, and 0 > 3. """ self.assertTrue(serialNumber2(1) > serialNumber2(0)) self.assertTrue(serialNumber2(2) > serialNumber2(1)) self.assertTrue(serialNumber2(3) > serialNumber2(2)) self.assertTrue(serialNumber2(0) > serialNumber2(3)) def test_undefined(self): """ It is undefined whether 2 > 0 or 0 > 2, and whether 1 > 3 or 3 > 1. """ assertUndefinedComparison(self, serialNumber2(2), serialNumber2(0)) assertUndefinedComparison(self, serialNumber2(0), serialNumber2(2)) assertUndefinedComparison(self, serialNumber2(1), serialNumber2(3)) assertUndefinedComparison(self, serialNumber2(3), serialNumber2(1)) serialNumber8 = partial(SerialNumber, serialBits=8) class SerialNumber8BitTests(unittest.TestCase): """ Tests for correct answers to example calculations in RFC1982 5.2. Consider the case where SERIAL_BITS == 8. In this space the integers that make up the serial number space are 0, 1, 2, ... 254, 255. 255 == 2^SERIAL_BITS - 1. https://tools.ietf.org/html/rfc1982#section-5.2 """ def test_maxadd(self): """ In this space, the largest integer that it is meaningful to add to a sequence number is 2^(SERIAL_BITS - 1) - 1, or 127. """ self.assertEqual(SerialNumber(0, serialBits=8)._maxAdd, 127) def test_add(self): """ Addition is as expected in this space, for example: 255+1 == 0, 100+100 == 200, and 200+100 == 44. """ self.assertEqual(serialNumber8(255) + serialNumber8(1), serialNumber8(0)) self.assertEqual(serialNumber8(100) + serialNumber8(100), serialNumber8(200)) self.assertEqual(serialNumber8(200) + serialNumber8(100), serialNumber8(44)) def test_gt(self): """ Comparison is more interesting, 1 > 0, 44 > 0, 100 > 0, 100 > 44, 200 > 100, 255 > 200, 0 > 255, 100 > 255, 0 > 200, and 44 > 200. """ self.assertTrue(serialNumber8(1) > serialNumber8(0)) self.assertTrue(serialNumber8(44) > serialNumber8(0)) self.assertTrue(serialNumber8(100) > serialNumber8(0)) self.assertTrue(serialNumber8(100) > serialNumber8(44)) self.assertTrue(serialNumber8(200) > serialNumber8(100)) self.assertTrue(serialNumber8(255) > serialNumber8(200)) self.assertTrue(serialNumber8(100) > serialNumber8(255)) self.assertTrue(serialNumber8(0) > serialNumber8(200)) self.assertTrue(serialNumber8(44) > serialNumber8(200)) def test_surprisingAddition(self): """ Note that 100+100 > 100, but that (100+100)+100 < 100. Incrementing a serial number can cause it to become "smaller". Of course, incrementing by a smaller number will allow many more increments to be made before this occurs. However this is always something to be aware of, it can cause surprising errors, or be useful as it is the only defined way to actually cause a serial number to decrease. """ self.assertTrue(serialNumber8(100) + serialNumber8(100) > serialNumber8(100)) self.assertTrue( serialNumber8(100) + serialNumber8(100) + serialNumber8(100) < serialNumber8(100) ) def test_undefined(self): """ The pairs of values 0 and 128, 1 and 129, 2 and 130, etc, to 127 and 255 are not equal, but in each pair, neither number is defined as being greater than, or less than, the other. """ assertUndefinedComparison(self, serialNumber8(0), serialNumber8(128)) assertUndefinedComparison(self, serialNumber8(1), serialNumber8(129)) assertUndefinedComparison(self, serialNumber8(2), serialNumber8(130)) assertUndefinedComparison(self, serialNumber8(127), serialNumber8(255)) PK Mb�Z!/ӏ� � 1 names/test/__pycache__/test_names.cpython-310.pycnu �[��� o �b^� � @ s� d Z ddlZddlZddlZddlmZmZ ddlmZ ddl m Z ddl m Z m Z mZ ddlmZ ddlmZmZmZmZmZ dd lmZ dd lmZmZm Z m Z m Z m Z dd l m!Z! dd l"m#Z#m$Z$ dd l%m&Z& ddl'm(Z( ddl)m*Z*m+Z+m,Z, ddl-m.Z. dd� Z/G dd� dej0�Z1ej dddddddd d �Z2ej d d d d d!d"d#d$d �Z3ej d%d&d'd(d d)dd*�Z4e1de2fe2e� d+�e�5d,�e�6d-�e�6d.d/�e�7d0d1�ej8d2d3d4�e�9d5�e�:d6�e�;d7�e�<d8d9�e�=dd:d;�e�=d<d=d>�e�=d?d@dA�e�<dB�e�>dC�ej?dDdEdF�ej@d dGdH�ejAdIdJdK�e�BdLejCdM�e�Ddd0dNdOdP�e�EdQ�ge�FdRdSdTdU�ge� dV�e� dW�ge� dX�e� dY�ge�9d�ge� dZ�gd[�d\�ZGe1d e3fd]e�Hd^�e3gid\�ZIe1d_e4fd_e4ej dZd`da�ej5dbdcda�ej5dddeda�ejFdRdSdTdUdfda�gid\�ZJG dgdh� dhe.jK�ZLG didj� dje.jK�ZMG dkdl� dle.jK�ZNG dmdn� dne.jK�ZOG dodp� dpe.jK�ZPG dqdr� dre.jK�ZQG dsdt� dte.jK�ZRG dudv� dve.jK�ZSG dwdx� dxe.jK�ZTdyZUG dzd{� d{e.jK�ZVd|ZWG d}d~� d~e.jK�ZXdS )z Test cases for twisted.names. � N)�partial�reduce)�BytesIO)�pack)�defer�error�reactor)�succeed)� authority�client�common�dns�server)�Resolver)�SOA�Message�Query�Record_A� Record_SOA�RRHeader)� DomainError)�SecondaryAuthority�SecondaryAuthorityService)� nativeString)�FilePath)�MemoryReactorClock�StringTransport�waitUntilAllDisconnected)�unittestc C s dd� | d D �S )Nc S s g | ]}|j �qS � ��payload��.0�rr r �?/usr/lib/python3/dist-packages/twisted/names/test/test_names.py� <listcomp>" � z justPayload.<locals>.<listcomp>r r ��resultsr r r% � justPayload! s r* c @ � e Zd Zdd� ZdS )�NoFileAuthorityc C s t j�| � ||| _| _d S �N)r � ResolverBase�__init__�soa�records)�selfr0 r1 r r r% r/ & s zNoFileAuthority.__init__N)�__name__� __module__� __qualname__r/ r r r r% r, % � r, � test-domain.comzroot.test-domain.com�d �� i� �H?&� � ��mname�rname�serial�refresh�minimum�expire�retry�ttls 93.84.28.in-addr.arpa�x i1� i~ �Ϊ � � � my-domain.coms postmaster.test-domain.com� i90 i?B )r> r? r@ rA rB rC rD s 127.0.0.1s 39.28.189.39�# v=spf1 mx/30 mx:example.org/30 -all� v=spf1 +mx a: colo� .example.com/28 -all not valid� �host.test-domain.com� Linux� A Fast One, Dontcha know)�os�cpus canonical.name.coms mailbox.test-domain.coms mail.group.someplace� A First piece of Text� a SecoNd pieces ABCD::4321� � s 0:0069::0s some.network.tld� s$ 0:5634:1294:AFCB:56AC:48EF:34C3:01FFs tra.la.la.net�+ Some more text, haha! Yes. Still here?s mail.redirect.or.whatevers r mail boxs e mail box)�rmailbx�emailbxs afsdb.test-domain.com)�subtype�hostnames whatever.i.dunnos some.more.text)�mbox�txts 12.54.78.12� �� � u� sip+E2U�! !^.*$!sip:information@domain.tld!s' AF43:5634:1294:AFCB:56AC:48EF:34C3:01FF� �? 骪 s some.other.place.fool� 123.242.1.5� 0.255.0.255s 255.255.255.254s 0.0.0.0s 1.2.3.4)r7 s http.tcp.test-domain.com� host.test-domain.coms host-two.test-domain.coms cname.test-domain.coms anothertest-domain.com�r0 r1 s 123.93.84.28.in-addr.arpas test.host-reverse.lookup.coms my-domain.com�1S�rE s ns1.domains 2Ms ns2.domain�3H�4Dc @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<S )=�ServerDNSTestsz/ Test cases for DNS server and client. c C s� t jtttgdd�| _t�| j�} tj d| jdd�}| � |j � |� � j }z tj||dd�}W n tjy: Y nw | � |j � nq|| _|| _tjd|fgd�| _d S )N� )�verboser< r � 127.0.0.1)� interface��servers)r �DNSServerFactory�test_domain_com�reverse_domain� my_domain_com�factoryr �DNSDatagramProtocolr � listenTCP� addCleanup� stopListening�getHost�port� listenUDPr �CannotListenError� listenerTCP� listenerUDPr r �resolver)r2 �pr� r� r� r r r% �setUp� s& � � �zServerDNSTests.setUpc C s6 | j jdd� D ]}|j�� qtt| j jdd� �S )zu Clean up any server connections associated with the L{DNSServerFactory} created in L{setUp} N)r{ � connections� transport�loseConnectionr r )r2 �connr r r% �tearDown� s zServerDNSTests.tearDownc s � �fdd�}|� |� |S )aD Assert that the DNS response C{querying} will eventually fire with contains exactly a certain collection of records. @param querying: A L{Deferred} returned from one of the DNS client I{lookup} methods. @param expectedRecords: A L{list} of L{IRecord} providers which must be in the response or the test will be failed. @return: A L{Deferred} that fires when the assertion has been made. It fires with a success result if the assertion succeeds and with a L{Failure} if it fails. c s t | �}��t� �t|�� d S r- )r* � assertEqual�set)�response�receivedRecords��expectedRecordsr2 r r% � checkResults� s z.ServerDNSTests.namesTest.<locals>.checkResults)� addCallback)r2 �queryingr� r� r r� r% � namesTest� s zServerDNSTests.namesTestc C � | � | j�d�tjddd�g�S )z"Test simple DNS 'A' record queries�test-domain.comrs r: rm �r� r� � lookupAddressr r �r2 r r r% �test_addressRecord1� � �z"ServerDNSTests.test_addressRecord1c C �, | � | j�d�tjddd�tjddd�g�S )z1Test DNS 'A' record queries with multiple answersrP z 123.242.1.5r: rm z 0.255.0.255r� r� r r r% �test_addressRecord2� � ��z"ServerDNSTests.test_addressRecord2c C r� )z+Test DNS 'A' record queries with edge caseszhost-two.test-domain.comz255.255.255.254r: rm �0.0.0.0r� r� r r r% �test_addressRecord3� r� z"ServerDNSTests.test_addressRecord3c C s | � | j�d�tg�S )z Test DNS 'SOA' record queriesr� )r� r� �lookupAuthority� soa_recordr� r r r% �test_authority� s �z ServerDNSTests.test_authorityc C s: | � | j�d�tjdddd�tjddd�tjddd�g�S )z� The DNS client can issue an MX query and receive a response including an MX record as well as any A record hints. r7 rO rj r: rm rh ri )r� r� �lookupMailExchanger � Record_MXr r� r r r% �test_mailExchangeRecord s ��z&ServerDNSTests.test_mailExchangeRecordc C r� )z Test DNS 'NS' record queriesr� z 39.28.189.39r: rm )r� r� �lookupNameserversr � Record_NSr� r r r% �test_nameserver r� z ServerDNSTests.test_nameserverc C �" | � | j�d�tjdddd�g�S )z Test DNS 'HINFO' record queriesr� rQ rR r: )rS rT rE )r� r� �lookupHostInfor � Record_HINFOr� r r r% � test_HINFO � ���zServerDNSTests.test_HINFOc C r� )z Test DNS 'PTR' record queriesz123.93.84.28.in-addr.arpaz test.host-reverse.lookup.comrG rm )r� r� � lookupPointerr � Record_PTRr� r r r% �test_PTR r� zServerDNSTests.test_PTRc C r� )z Test DNS 'CNAME' record queriesr� zcanonical.name.comr: rm )r� r� �lookupCanonicalNamer � Record_CNAMEr� r r r% � test_CNAME' r� zServerDNSTests.test_CNAMEc C r� )z Test DNS 'MB' record queriesr� zmailbox.test-domain.comr: rm )r� r� � lookupMailBoxr � Record_MBr� r r r% �test_MB. r� zServerDNSTests.test_MBc C r� )z Test DNS 'MG' record queriesr� zmail.group.someplacer: rm )r� r� �lookupMailGroupr � Record_MGr� r r r% �test_MG5 r� zServerDNSTests.test_MGc C r� )z Test DNS 'MR' record queriesr� zmail.redirect.or.whateverr: rm )r� r� �lookupMailRenamer � Record_MRr� r r r% �test_MR< r� zServerDNSTests.test_MRc C r� )z Test DNS 'MINFO' record queriesr� z r mail boxz e mail boxr: )r[ r\ rE )r� r� �lookupMailboxInfor � Record_MINFOr� r r r% � test_MINFOC r� zServerDNSTests.test_MINFOc C s& | � | j�d�tjdddddd�g�S )z Test DNS 'SRV' record querieszhttp.tcp.test-domain.comre rf rg �some.other.place.foolr: rm )r� r� � lookupServicer � Record_SRVr� r r r% �test_SRVN s �zServerDNSTests.test_SRVc C r� )z Test DNS 'AFSDB' record queriesr� r< zafsdb.test-domain.comr: )r] r^ rE )r� r� �lookupAFSDatabaser � Record_AFSDBr� r r r% � test_AFSDBU r� zServerDNSTests.test_AFSDBc C r� )z Test DNS 'RP' record queriesr� zwhatever.i.dunnozsome.more.textr: )r_ r` rE )r� r� �lookupResponsibilityr � Record_RPr� r r r% �test_RP` r� zServerDNSTests.test_RPc C s. | � | j�d�tjdddd�tjddd�g�S )z Test DNS 'TXT' record queriesr� rU rV r: rm rZ )r� r� � lookupTextr � Record_TXTr� r r r% �test_TXTk s ����zServerDNSTests.test_TXTc C s. | � | j�d�tjddd�tjdddd�g�S )zH L{DNSServerFactory} can serve I{SPF} resource records. r� rL r: rm rM rN )r� r� �lookupSenderPolicyr � Record_SPFr� r r r% �test_spfy s ���zServerDNSTests.test_spfc C s& | � | j�d�tjdtjddd�g�S )z Test DNS 'WKS' record queriesr� z 12.54.78.12ra r: rm )r� r� �lookupWellKnownServicesr � Record_WKS�socket� IPPROTO_TCPr� r r r% �test_WKS� s ���zServerDNSTests.test_WKSc C s^ t � t�}tj|_| �| j�d�|tjddd�tj ddd�tj ddd�tj d d d d d d�g�S )NrJ �1.2.3.4rl rm z ns1.domain�2Mz ns2.domainrn re rf rg r� ro ) �copy�my_soarC rE r� r� �lookupAllRecordsr r r� r� )r2 � result_soar r r% �test_someRecordsWithTTLs� s ��z'ServerDNSTests.test_someRecordsWithTTLsc C r� )z%Test DNS 'AAAA' record queries (IPv6)r� z'AF43:5634:1294:AFCB:56AC:48EF:34C3:01FFr: rm )r� r� �lookupIPV6Addressr � Record_AAAAr� r r r% � test_AAAA� r� zServerDNSTests.test_AAAAc C sD | � | j�d�tjddddd�tjddd dd�tjd d d dd�g�S ) z#Test DNS 'A6' record queries (IPv6)r� r z ABCD::4321� r: rm rX z 0:0069::0zsome.network.tldrY z$0:5634:1294:AFCB:56AC:48EF:34C3:01FFz tra.la.la.net)r� r� �lookupAddress6r � Record_A6r� r r r% �test_A6� s ���zServerDNSTests.test_A6c C sZ t j}dd� ttjtj�� �D �}|D ] }|jdu r ||_q| � | j � d�� dd� �|�S )z9 Test DNS 'AXFR' queries (Zone transfer) c S s g | ]}t � |��qS r )r� r" r r r% r& � s �z4ServerDNSTests.test_zoneTransfer.<locals>.<listcomp>Nr� c S s | d d d� fS )Nr ���r )r$ r r r% �<lambda>� r' z2ServerDNSTests.test_zoneTransfer.<locals>.<lambda>) r� rC r �operator�addrx r1 �valuesrE r� r� � lookupZoner� )r2 � default_ttlr) r$ r r r% �test_zoneTransfer� s � � ��z ServerDNSTests.test_zoneTransferc C s t dgd�}| �|�d�tj�S )zu A failed AXFR TCP connection errbacks the L{Deferred} returned from L{Resolver.lookupZone}. )znameserver.invalid�5 ru zimpossible.invalid)r � assertFailurer� r �DNSLookupError)r2 r� r r r% � test_zoneTransferConnectionFails� s �z/ServerDNSTests.test_zoneTransferConnectionFailsc C r� )z6Tests that unrelated zones don't mess with each other.zanothertest-domain.comr� r: rm r� r� r r r% � test_similarZonesDontInterfere� r� z-ServerDNSTests.test_similarZonesDontInterferec C s( | � | j�d�tjddddddd�g�S ) z2 Test DNS 'NAPTR' record queries. r� r8 rO rb rc rd r: rm )r� r� � lookupNamingAuthorityPointerr � Record_NAPTRr� r r r% � test_NAPTR� s ���zServerDNSTests.test_NAPTRN)!r3 r4 r5 �__doc__r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r% rp � s> rp c @ r+ )� HelperTestsc C s@ | � � }t�|�}td�D ]}t�|�}| �||k � |}q d S )N� )�mktempr � getSerial�range� assertTrue)r2 �f�a�i�br r r% �test_serialGenerator� s �z HelperTests.test_serialGeneratorN)r3 r4 r5 r r r r r% r� � r6 r� c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) � AXFRTestsc C s� d | _ t�� | _| j�| j� t�d| j�| _t j dt j t j ddt j ddddddd d d �d �| _| jt j dt jt j d dt jdd d�d �t j dt jt j d dt jddd d�d �t j dt jt j d dt jdd d�d �| jg| _d S )N� fooby.comi�Q Fzhooj.fooby.comr8 �� i, i� i� iX )r> r? r@ rA rD rC rB rE ��name�type�clsrE �authr! � �ns.twistedmatrix.com�r rE rO z mail.mv3d.com)� preference�exchangerE z 64.123.27.105)�addressrE )r) r �Deferred�dr� � _gotResultsr �AXFRController� controllerr r r �INr r0 �NSr� �MXr� �Ar r1 r� r r r% r� � s` �� �� � �zAXFRTests.setUpc C s t jdddddddddd� S )N�� r< r � �id�answer�opCode�recDes�recAvr �rCode�trunc�maxSize)r r r� r r r% � _makeMessage2 s �zAXFRTests._makeMessagec C sH | � � }t�dtjtj�g|_| j|_| j� |d � | � | j | j� d S )Nr ) r$ r r �AXFRr �queriesr1 �answersr �messageReceivedr� r) )r2 �mr r r% �test_bindAndTNamesStyle@ s z!AXFRTests.test_bindAndTNamesStylec C s || _ d S r- r( )r2 �resultr r r% r H s zAXFRTests._gotResultsc C sT | j d d � }|r | �� }g |_|�d�g|_| j�|d � |s | �| j| j � d S �Nr ) r1 r$ r& �popr' r r( r� r) )r2 r1 r) r r r% � test_DJBStyleK s �zAXFRTests.test_DJBStyleN)r3 r4 r5 r� r$ r* r r. r r r r% r � s 5 r c @ s e Zd Zdd� Zdd� ZdS )�ResolvConfHandlingTestsc C s2 | � � }tj|d�}| �|jdg� |j�� d S )N��resolv�rs r� )r� r r r� � dynServers� _parseCall�cancel�r2 � resolvConfr$ r r r% � test_missingW s z$ResolvConfHandlingTests.test_missingc C s@ | � � }t|d��� tj|d�}| �|jdg� |j�� d S )N�wr0 r2 ) r� �open�closer r r� r3 r4 r5 r6 r r r% � test_empty] s z"ResolvConfHandlingTests.test_emptyN)r3 r4 r5 r8 r< r r r r% r/ V s r/ c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�AuthorityTestszs Tests for the basic response record selection code in L{FileAuthority} (independent of its fileness). c C s4 t }d|jd }| �|�|��}| �|jt� dS )aJ L{FileAuthority} lookup methods errback with L{DomainError} if the requested C{name} shares a common suffix with its zone but is not actually a descendant of its zone, in terms of its sequence of DNS name labels. eg www.the-example.com has nothing to do with the zone example.com. � nonexistent.prefix-r N)rx r0 �failureResultOfr� �assertIsInstance�valuer )r2 � testDomain�testDomainNamer� r r r% �'test_domainErrorForNameWithCommonSuffixk s z6AuthorityTests.test_domainErrorForNameWithCommonSuffixc C s� t tjjtftjjtt�d�gid�}| �|�tjj��\}}}| �|g � | �|tj tjjtj tj tdd�g� | �|g � dS )a! If a L{FileAuthority} has a zone which includes an I{NS} record for a particular name and that authority is asked for another record for the same name which does not exist, the I{NS} record is not included in the authority section of the response. r� rk T�rE r! r N) r, r� r> r r r� �successResultOfr� r� r �TYPErC )r2 r r � additionalr r r% �test_recordMissingx s0 ��� � ��� z!AuthorityTests.test_recordMissingc C sJ t }d|jd }ttj�d }| �|�t||d���}| �|j t � dS )z� Requesting a record of unknown type where no records exist for the name in question results in L{DomainError}. r> r r< �r r N) rx r0 �maxr � typeToMethodr? �queryr r@ rA r )r2 rB rC � unknownTyper� r r r% �test_unknownTypeNXDOMAIN� s �z'AuthorityTests.test_unknownTypeNXDOMAINc C s< t tj�d }| �t�td|d���\}}}| �|g � dS )z� Requesting a record of unknown type where other records exist for the name in question results in an empty answer set. r< rJ rJ N)rK r rL rF rz rM r r� )r2 rN r r rH r r r% �test_unknownTypeMissing� s �z&AuthorityTests.test_unknownTypeMissingc C s� dt jj }t�d�}tt jjt f||gid�}t||�|�}| �|�\}}}| �|g � | �|tj |tj t j |dd�g� | �|g � dS )z� Create an authority and make a request against it. Then verify that the result is a referral, including no records in the answers or additional sections, but with an I{NS} record in the authority section. s example.r� rk FrE N) r� r> r r r� r, �getattrrF r� r r rC )r2 �method� subdomain� nameserverr r r rH r r r% � _referralTest� s0 ��� ��� z AuthorityTests._referralTestc C � | � d� dS )a When an I{NS} record is found for a child zone, it is included in the authority section of the response. It is marked as non-authoritative if the authority is not also authoritative for the child zone (RFC 2181, section 6.1). r� N�rU r� r r r% � test_referral� s z AuthorityTests.test_referralc C rV )zT A referral is also generated for a request of type C{ALL_RECORDS}. r� NrW r� r r r% �test_allRecordsReferral� s z&AuthorityTests.test_allRecordsReferralN) r3 r4 r5 r� rD rI rO rP rU rX rY r r r r% r= e s " ! r= c @ s� e Zd ZdZe�d�Ze�d�Zdd� Z dd� Z dd � Z d d � Z d d � Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�AdditionalProcessingTestszz Tests for L{FileAuthority}'s additional processing for those record types which require it (MX, CNAME, etc). s 10.0.0.1s f080::1c C s8 t |jj|f|jj||�g||id�}t||�tjj�S )a Perform a DNS lookup against a L{FileAuthority} configured with records as defined by C{makeRecord} and C{addresses}. @param method: The name of the lookup method to use; for example, C{"lookupNameservers"}. @type method: L{str} @param soa: A L{Record_SOA} for the zone for which the L{FileAuthority} is authoritative. @param makeRecord: A one-argument callable which accepts a name and returns an L{IRecord} provider. L{FileAuthority} is constructed with this record. The L{FileAuthority} is queried for a record of the resulting type with the given name. @param target: The extra name which the record returned by C{makeRecord} will be pointed at; this is the name which might require extra processing by the server so that all the available, useful information is returned. For example, this is the target of a CNAME record or the mail exchange host pointed to by an MX record. @type target: L{bytes} @param addresses: A L{list} of records giving addresses of C{target}. @return: A L{Deferred} that fires with the result of the resolver method give by C{method}. rk )r, r> r rQ r� )r2 rR r0 � makeRecord�target� addressesr r r r% �_lookupSomeRecords� s ��z,AdditionalProcessingTests._lookupSomeRecordsc C s( dd� }| � t||d�t||d�� dS )a Assert that the L{RRHeader} instances given by C{expected} and C{computed} carry all the same information but without requiring the records appear in the same order. @param expected: A L{list} of L{RRHeader} instances giving the expected records. @param computed: A L{list} of L{RRHeader} instances giving the records computed by the scenario under test. @raise self.failureException: If the two collections of records disagree. c S s | j S r- )r )�rrr r r% r� $ s z>AdditionalProcessingTests.assertRecordsMatch.<locals>.<lambda>)�keyN)r� �sorted)r2 �expected�computedr` r r r% �assertRecordsMatch s z,AdditionalProcessingTests.assertRecordsMatchc sL dt jj � | �|t |� |�}| �|�\}}}| �� fdd�|D �|� dS )aT Verify that certain address records are included in the I{additional} section of a response generated by L{FileAuthority}. @param method: See L{_lookupSomeRecords} @param makeRecord: See L{_lookupSomeRecords} @param addresses: A L{list} of L{IRecord} providers which the I{additional} section of the response is required to match (ignoring order). @raise self.failureException: If the I{additional} section of the response consists of different records than those given by C{addresses}. s mail.c �$ g | ]}t j� |jtj|d d��qS �TrE �r r rG r� rC �r# r �r\ r r% r& = � ���z=AdditionalProcessingTests._additionalTest.<locals>.<listcomp>N)r� r> r r^ rF rd )r2 rR r[ r] r r r rH r ri r% �_additionalTest' s � �z)AdditionalProcessingTests._additionalTestc C s | � dttjd�|� dS )z� Verify that a response to an MX query has certain records in the I{additional} section. @param addresses: See C{_additionalTest} r� rO N)rk r r r� �r2 r] r r r% �_additionalMXTestJ s �z+AdditionalProcessingTests._additionalMXTestc C � | � | jg� dS )z� If the name of the MX response has A records, they are included in the additional section of the response. N)rm �_Ar� r r r% � test_mailExchangeAdditionalAU � z6AdditionalProcessingTests.test_mailExchangeAdditionalAc C rn )z� If the name of the MX response has AAAA records, they are included in the additional section of the response. N)rm �_AAAAr� r r r% � test_mailExchangeAdditionalAAAA\ rq z9AdditionalProcessingTests.test_mailExchangeAdditionalAAAAc C � | � | j| jg� dS )z� If the name of the MX response has both A and AAAA records, they are all included in the additional section of the response. N)rm ro rr r� r r r% � test_mailExchangeAdditionalBothc � z9AdditionalProcessingTests.test_mailExchangeAdditionalBothc C s | � dtj|� dS )z� Verify that a response to an NS query has certain records in the I{additional} section. @param addresses: See C{_additionalTest} r� N)rk r r� rl r r r% �_additionalNSTestj s z+AdditionalProcessingTests._additionalNSTestc C rn )z� If the name of the NS response has A records, they are included in the additional section of the response. N)rw ro r� r r r% �test_nameserverAdditionalAs rq z4AdditionalProcessingTests.test_nameserverAdditionalAc C rn )z� If the name of the NS response has AAAA records, they are included in the additional section of the response. N)rw rr r� r r r% � test_nameserverAdditionalAAAAz rq z7AdditionalProcessingTests.test_nameserverAdditionalAAAAc C rt )z� If the name of the NS response has both A and AAAA records, they are all included in the additional section of the response. N)rw ro rr r� r r r% � test_nameserverAdditionalBoth� rv z7AdditionalProcessingTests.test_nameserverAdditionalBothc sv dt jj � | �dt tj� |�}| �|�\}}}tjt jjtjt j t�� �dd�}| � � fdd�|D �|g |� dS )z� Verify that a response to a CNAME query has certain records in the I{answer} section. @param addresses: See C{_additionalTest} s www.r� TrE c re rf rg rh ri r r% r& � rj z>AdditionalProcessingTests._answerCNAMETest.<locals>.<listcomp>N) r� r> r r^ r r� rF r �CNAMErC rd )r2 r] r r r rH �aliasr ri r% �_answerCNAMETest� s( �� � � �z*AdditionalProcessingTests._answerCNAMETestc C rn )z� If the name of the CNAME response has A records, they are included in the answer section of the response. N)r} ro r� r r r% �test_canonicalNameAnswerA� rq z3AdditionalProcessingTests.test_canonicalNameAnswerAc C rn )z� If the name of the CNAME response has AAAA records, they are included in the answer section of the response. N)r} rr r� r r r% � test_canonicalNameAnswerAAAA� rq z6AdditionalProcessingTests.test_canonicalNameAnswerAAAAc C rt )z� If the name of the CNAME response has both A and AAAA records, they are all included in the answer section of the response. N)r} ro rr r� r r r% � test_canonicalNameAnswerBoth� rv z6AdditionalProcessingTests.test_canonicalNameAnswerBothN)r3 r4 r5 r� r r ro r� rr r^ rd rk rm rp rs ru rw rx ry rz r} r~ r r� r r r r% rZ � s& &# # rZ c @ r+ )�NoInitialResponseTestsc s� � fdd�}dd� }t dgd�}||_g � | �tjd|� tjdtjtjd d tjd d d �d �g}tj dddddddddd� }||_ � � |� | � |� d�tj�S )z� If a request returns a L{dns.NS} response, but we can't connect to the given server, the request fails with the error returned at connection. c s t � �d��S r, )r r- )r2 �args��messagesr r% rM � s z3NoInitialResponseTests.test_noAnswer.<locals>.queryc _ s t �t�d��S )NzCouldn't connect)r �failr� �gaierror)r2 r� �kwargsr r r% � queryProtocol� � z;NoInitialResponseTests.test_noAnswer.<locals>.queryProtocol)r� r ru rM z fooba.comr Fr r r r r< r r r )r �_query�patchr r| r r r r� r r' �appendr� � getHostByNamer� r� )r2 rM r� r� r1 r) r r� r% � test_noAnswer� s: �� � z$NoInitialResponseTests.test_noAnswerN)r3 r4 r5 r� r r r r% r� � r6 r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � SecondaryAuthorityServiceTestsz� Tests for L{SecondaryAuthorityService}, a service which keeps one or more authorities up to date by doing zone transfers from a master. c C s� d}t |ddg�}| �|j|� | �|jd� | �|jd j|� | �|jd jd� | �|jd jd� | �|jd j|� | �|jd jd� | �|jd jd� dS ) a L{SecondaryAuthorityService} can be constructed with a C{str} giving a master server address and several domains, causing the creation of a secondary authority for each domain and that master server address and the default DNS port. � 192.168.1.2� example.comz example.orgr� r r< s example.orgN)r r� �primary�_port�domains�domain�r2 r� �servicer r r% � test_constructAuthorityFromHost� s z>SecondaryAuthorityServiceTests.test_constructAuthorityFromHostc C s� d}d}t �||fddg�}| �|j|� | �|jd� | �|jd j|� | �|jd j|� | �|jd jd� | �|jd j|� | �|jd j|� | �|jd jd� dS ) a\ L{SecondaryAuthorityService.fromServerAddressAndDomains} constructs a new L{SecondaryAuthorityService} from a C{str} giving a master server address and DNS port and several domains, causing the creation of a secondary authority for each domain and that master server address and the given DNS port. � 192.168.1.3i� z example.net� example.edur � example.netr< N)r �fromServerAddressAndDomainsr� r� r� r� r� )r2 r� r� r� r r r% �&test_constructAuthorityFromHostAndPort s �zESecondaryAuthorityServiceTests.test_constructAuthorityFromHostAndPortc C sx d}t |�� ddg�}| �|j|� | �|jd j|� | �|jd jd� | �|jd j|� | �|jd jd� dS )aQ L{SecondaryAuthorityService.fromServerAddressAndDomains} constructs a new L{SecondaryAuthorityService} from a C{bytes} giving a master server address and several domains, causing the creation of a secondary authority for each domain and that master server address and the given DNS port. r� r� z example.edur r< r� N)r �encoder� r� r� r� r� r r r% � test_constructAuthorityFromBytes# s �z?SecondaryAuthorityServiceTests.test_constructAuthorityFromBytesN)r3 r4 r5 r� r� r� r� r r r r% r� � s r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �SecondaryAuthorityTestsz� L{twisted.names.secondary.SecondaryAuthority} correctly constructs objects with a specified IP address and optionally specified DNS port. c C s8 t dd�}| �|jd� | �|jd� | �|jd� dS )zp When constructed using L{SecondaryAuthority.__init__}, the default port of 53 is used. � 192.168.1.1� inside.comr� � inside.comN)r r� r� r� r� �r2 � secondaryr r r% �test_defaultPort? s z(SecondaryAuthorityTests.test_defaultPortc C s: t �dd�}| �|jd� | �|jd� | �|jd� dS )z~ When constructed using L{SecondaryAuthority.fromServerAddressAndDomain}, the specified port is used. )r� �� r� r� r� r� N)r �fromServerAddressAndDomainr� r� r� r� r� r r r% �test_explicitPortI s �z)SecondaryAuthorityTests.test_explicitPortc C s� t �dd�}t� |_}|�� |j�d�\}}}}}| �|d� | �|d� |�||f�}t � } |� | � t � } | � t | �� dd� �� | �t�dtjtj�g| j� dS )z� An attempt is made to transfer the zone for the domain the L{SecondaryAuthority} was constructed with from the server address it was constructed with when L{SecondaryAuthority.transfer} is called. �r� r9 � example.comr r� r9 rq N)r r� r �_reactor�transfer� tcpClientsr- r� � buildProtocolr �makeConnectionr �decoder rA r r r% r r& ) r2 r� r �hostr� r{ �timeout� bindAddress�protor� �msgr r r% � test_transferU s � "z%SecondaryAuthorityTests.test_transferc C s. t �dd�}t� |_}|�� |j�d�\}}}}}|�||f�}t� } |� | � t ddd�} | � t | � � dd� �� tdd d d d d ddd�} tddd�} t | jddd�} | j�tdt| d�td| d�tdt| d�g� | �� }|�tdt|��| � | �|�d��}| �td| dd�gg g f|� dS )z� L{SecondaryAuthority.lookupAddress} returns a L{Deferred} that fires with the I{A} records the authority has cached from the primary. r� r� r r< )r r rq Ns ns1.example.comzadmin.example.comi@� i i� i i�% i�. r= s 192.168.1.2rm )r r r )r r! r z!Hr� T)r! r ) r r� r r� r� r� r- r� r r� r r� r rA r r r r' �extendr r �toStr� dataReceivedr �lenrF r� r� )r2 r� r r� r� r{ r� r� r� r� rM r0 r� r �datar+ r r r% �test_lookupAddresss sF � � ���z*SecondaryAuthorityTests.test_lookupAddressN)r3 r4 r5 r� r� r� r� r� r r r r% r� 9 s r� sY $ORIGIN example.com. $TTL 1w example.com. IN SOA dns.example.com ( 2013120201 ; serial number of this zone file 1d ; slave refresh 2h ; slave retry time in case of a problem 4w ; slave expiration time 1h ; maximum caching time in case of failed lookups ) ; A comment. @ IN AAAA 2001:db8:10::1 example.com. IN A 10.0.0.1 no-in.example.com. A 10.0.0.2 ; technically wrong but used to work not-fqdn IN MX 10 mx.example.com www IN CNAME example.comc @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )�BindAuthorityTestsz= Tests for L{twisted.names.authority.BindAuthority}. c C s( t | �� �d��}|�|� t�|j�S )z� Create a new L{twisted.names.authority.BindAuthority} from C{s}. @param s: A string with BIND zone data. @type s: bytes @return: a new bind authority @rtype: L{twisted.names.authority.BindAuthority} �ascii)r r� r� � setContentr � BindAuthority�path)r2 �s�fpr r r% �loadBindString� s z!BindAuthorityTests.loadBindStringc C � | � t�| _d S r- )r� �sampleBindZoner r� r r r% r� � r� zBindAuthorityTests.setUpc C s8 | j j�� D ]}| j j| D ] }| �d|jk� qqdS )zG Loads the default $TTL and applies it to all records. �: N)r r1 �keysr� rE )r2 �dom�recr r r% �test_ttl� s ��zBindAuthorityTests.test_ttlc C s$ | � d| jj� | �d| jj� dS )z, Loads the default $ORIGIN. s example.com.� not-fqdn.example.comN)r� r �origin�assertInr1 r� r r r% �test_originFromFile� s ��z&BindAuthorityTests.test_originFromFilec C sB dD ] \}}| � | j�|��\\}\ \ | �t�|d�|j� qdS )�' A records are loaded. �)r� z10.0.0.1)� no-in.example.comz10.0.0.2r� N�rF r r� r� r r r! �r2 r� �ipr_ r r r% � test_aRecords� s ���z BindAuthorityTests.test_aRecordsc C s4 | � | j�d��\\}\ \ | �t�dd�|j� dS )�* AAAA records are loaded. r� �2001:db8:10::1r� N�rF r r� r� r r� r! �r2 r_ r r r% �test_aaaaRecords� s ���z#BindAuthorityTests.test_aaaaRecordsc C s8 | � | j�d��\\}\ \ | �tjdddd�|j� dS )�( MX records are loaded. r� rO zmx.example.comr� )r r rE N�rF r r� r� r r� r! r� r r r% �test_mxRecords s ���z!BindAuthorityTests.test_mxRecordsc C s< | � | j�d��\}\ \ |d }| �tjddd�|j� dS )�+ CNAME records are loaded. � www.example.comr r� r� r N�rF r r� r� r r� r! �r2 r' r_ r r r% �test_cnameRecords s ���z$BindAuthorityTests.test_cnameRecordsc C sL | � t�� }| �d� W d � n1 sw Y | �d|jjd � dS )zO loadBindString raises NotImplementedError on invalid records. s example.com. IN LOL 192.168.0.1Nz Record type 'LOL' not supportedr )� assertRaises�NotImplementedErrorr� r� � exceptionr� )r2 �er r r% �test_invalidRecordClass% s �z*BindAuthorityTests.test_invalidRecordClassc C sb dD ],}| � t��}| �|d � W d � n1 sw Y | �t|d �|jjd � qdS )zC $INCLUDE and $GENERATE raise NotImplementedError. )s $INCLUDEs $GENERATEs doesNotMatterNs directive not implementedr )r� r� r� r� r r� r� )r2 � directiver� r r r% �test_invalidDirectives- s � ��z)BindAuthorityTests.test_invalidDirectivesN)r3 r4 r5 r� r� r� r� r� r� r� r� r� r� r� r r r r% r� � s r� a� zone = [ SOA( # For whom we are the authority 'example.com', # This nameserver's name mname = "dns.example.com", # Mailbox of individual who handles this rname = "root.example.com", # Unique serial identifying this SOA data serial = 86400, # Time interval before zone should be refreshed refresh = "2H", # Interval before failed refresh should be retried retry = "1H", # Upper limit on time interval before expiry expire = "1H", # Minimum TTL minimum = "3H" ), AAAA('example.com', '2001:db8:10::1'), A('example.com', '10.0.0.1'), NS('example.com', 'dns.example.com'), A('no-in.example.com', '10.0.0.2'), PTR('2.0.0.10.in-addr.arpa', 'no-in.example.com'), CNAME('www.example.com', 'example.com'), CNAME('ftp.example.com', 'example.com'), MX('not-fqdn.example.com', 10, 'mail.example.com'), ] c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )�PySourceAuthorityTestszA Tests for L{twisted.names.authority.PySourceAuthority}. c C sN t | �� �}t|jd�� }|�|� W d � n1 s w Y t�|j�S )a Create a new L{twisted.names.authority.PySourceAuthority} from C{s}. @param s: A string with BIND zone data in a Python source file. @type s: L{str} @return: a new bind authority @rtype: L{twisted.names.authority.PySourceAuthority} r9 N)r r� r: r� �writer �PySourceAuthority)r2 r� r� r� r r r% �loadPySourceStringj s � z)PySourceAuthorityTests.loadPySourceStringc C r� r- )r� �samplePySourcer r� r r r% r� z r� z PySourceAuthorityTests.setUpc C s@ dD ]\}}| � | j�|��\\}\ \ | �t�|�|j� qdS )r� r� Nr� r� r r r% r� } s ��z$PySourceAuthorityTests.test_aRecordsc C s2 | � | j�d��\\}\ \ | �t�d�|j� dS )r� r� r� Nr� r� r r r% r� � s ��z'PySourceAuthorityTests.test_aaaaRecordsc C s6 | � | j�d��\\}\ \ | �tjddd�|j� dS )r� r� rO zmail.example.com)r r Nr� r� r r r% r� � s ���z%PySourceAuthorityTests.test_mxRecordsc C �: | � | j�d��\}\ \ |d }| �tjdd�|j� dS )r� r� r r� �r Nr� r� r r r% r� � � ���z(PySourceAuthorityTests.test_cnameRecordsc C r� )z) PTR records are loaded. s 2.0.0.10.in-addr.arpar r� r� N)rF r r� r� r r� r! r� r r r% r� � r� z PySourceAuthorityTests.test_PTRc C s d}| � t| j|� dS )z1 Input file has no zone variable z nothing = []N)r� � ValueErrorr� )r2 � badPySourcer r r% �test_badInputNoZone� s z*PySourceAuthorityTests.test_badInputNoZoneN) r3 r4 r5 r� r� r� r� r� r� r� r� r� r r r r% r� e s r� )Yr� r� r� r� � functoolsr r �ior �structr �twisted.internetr r r �twisted.internet.deferr � twisted.namesr r r r r �twisted.names.clientr �twisted.names.dnsr r r r r r �twisted.names.errorr �twisted.names.secondaryr r �twisted.python.compatr �twisted.python.filepathr �twisted.test.proto_helpersr r r � twisted.trialr r* � FileAuthorityr, r� � reverse_soar� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rx r� ry rz �TestCaserp r� r r/ r= rZ r� r� r� r� r� r� r� r r r r% �<module> s� � � � � �� �� � ��3��� ��� \ Z~ _0Hm +PK Mb�Z� -m m 3 names/test/__pycache__/test_resolve.cpython-310.pycnu �[��� o �b1 � @ s< d Z ddlmZ ddlmZ ddlmZ G dd� de�ZdS )z% Tests for L{twisted.names.resolve}. � )� DomainError)� ResolverChain)�TestCasec @ s e Zd ZdZdd� Zdd� ZdS )�ResolverChainTestsz: Tests for L{twisted.names.resolve.ResolverChain} c C �2 t g �}|�d�}| �|�}| �|�t�t� dS )zv L{ResolverChain._lookup} returns a L{DomainError} failure if its C{resolvers} list is empty. �www.example.comN)r � lookupAddress�failureResultOf�assertIs�trapr ��self�r�d�f� r �A/usr/lib/python3/dist-packages/twisted/names/test/test_resolve.py�test_emptyResolversList � z*ResolverChainTests.test_emptyResolversListc C r )z L{ResolverChain.lookupAllRecords} returns a L{DomainError} failure if its C{resolvers} list is empty. r N)r �lookupAllRecordsr r r r r r r r �'test_emptyResolversListLookupAllRecords r z:ResolverChainTests.test_emptyResolversListLookupAllRecordsN)�__name__� __module__� __qualname__�__doc__r r r r r r r s r N)r �twisted.names.errorr �twisted.names.resolver �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z52@�> �> 3 names/test/__pycache__/test_rfc1982.cpython-310.pycnu �[��� o �b 6 � @ s� d Z ddlZddlmZ ddlmZ ddlmZ ddlmZ G dd� dej �Z d d � Z eed d �Z G d d� dej �Z eedd �ZG dd� dej �ZdS )z* Test cases for L{twisted.names.rfc1982}. � N)�datetime)�partial�� SerialNumber)�unittestc @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:S );�SerialNumberTestsz$ Tests for L{SerialNumber}. c C s | � td�jd� dS )zB L{SerialNumber.serialBits} has default value 32. � � N�� assertEqualr � _serialBits��self� r �A/usr/lib/python3/dist-packages/twisted/names/test/test_rfc1982.py�test_serialBitsDefault s z(SerialNumberTests.test_serialBitsDefaultc C s | � tddd�jd� dS )z� L{SerialNumber.__init__} accepts a C{serialBits} argument whose value is assigned to L{SerialNumber.serialBits}. r � �� serialBitsNr r r r r �test_serialBitsOverride � z)SerialNumberTests.test_serialBitsOverridec C s | � dttddd��� dS )ze L{SerialNumber.__repr__} returns a string containing number and serialBits. z'<SerialNumber number=123 serialBits=32>�{ r r N)r �reprr r r r r � test_repr# s �zSerialNumberTests.test_reprc C s | � ttd��d� dS )zg L{SerialNumber.__str__} returns a string representation of the current value. r �123N)r �strr r r r r �test_str- � zSerialNumberTests.test_strc C s | � ttd��d� dS )zi L{SerialNumber.__int__} returns an integer representation of the current value. r N)r �intr r r r r �test_int4 r zSerialNumberTests.test_intc C s< | � ttd��ttd��� | �ttd��ttd��� dS )z| L{SerialNumber.__hash__} allows L{SerialNumber} instances to be hashed for use as dictionary keys. r � N)r �hashr �assertNotEqualr r r r � test_hash; s zSerialNumberTests.test_hashc C s, t ddd�}t ddd�}| �t|j|� dS )z� L{SerialNumber._convertOther} raises L{TypeError} if the other SerialNumber instance has a different C{serialBits} value. r r r � N)r � assertRaises� TypeError� _convertOther)r �s1�s2r r r �#test_convertOtherSerialBitsMismatchC s z5SerialNumberTests.test_convertOtherSerialBitsMismatchc C s | � td�td�� dS )zK L{SerialNumber.__eq__} provides rich equality comparison. r N�r r r r r r �test_eqM � zSerialNumberTests.test_eqc C s0 | � td�t� k� | �td��t� �t� dS )zy == comparison of L{SerialNumber} with a non-L{SerialNumber} instance returns L{NotImplemented}. r N)� assertFalser �object�assertIs�__eq__�NotImplementedr r r r �test_eqForeignTypeS � z$SerialNumberTests.test_eqForeignTypec C s. | � td�td�k� | �td�td�� dS )zK L{SerialNumber.__ne__} provides rich equality comparison. r r N)r. r r" r r r r �test_ne[ s zSerialNumberTests.test_nec C s0 | � td�t� k� | �td��t� �t� dS )zy != comparison of L{SerialNumber} with a non-L{SerialNumber} instance returns L{NotImplemented}. r N)� assertTruer r/ r0 �__ne__r2 r r r r �test_neForeignTypeb r4 z$SerialNumberTests.test_neForeignTypec C s0 | � td�td�k� | � td�td�k� dS )zE L{SerialNumber.__le__} provides rich <= comparison. r r N�r6 r r r r r �test_lej � zSerialNumberTests.test_lec C � | � tdd� � dS )zs <= comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. c S s t d�t� kS �Nr �r r/ r r r r �<lambda>v � z6SerialNumberTests.test_leForeignType.<locals>.<lambda>N�r% r& r r r r �test_leForeignTypeq � z$SerialNumberTests.test_leForeignTypec C s0 | � td�td�k� | � td�td�k� dS )zE L{SerialNumber.__ge__} provides rich >= comparison. r r Nr9 r r r r �test_gex r; zSerialNumberTests.test_gec C r< )zs >= comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. c S s t d�t� kS r= r> r r r r r? � r@ z6SerialNumberTests.test_geForeignType.<locals>.<lambda>NrA r r r r �test_geForeignType rC z$SerialNumberTests.test_geForeignTypec C s | � td�td�k � dS )zD L{SerialNumber.__lt__} provides rich < comparison. r r Nr9 r r r r �test_lt� � zSerialNumberTests.test_ltc C r< )zr < comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. c S s t d�t� k S r= r> r r r r r? � r@ z6SerialNumberTests.test_ltForeignType.<locals>.<lambda>NrA r r r r �test_ltForeignType� rC z$SerialNumberTests.test_ltForeignTypec C s | � td�td�k� dS )zD L{SerialNumber.__gt__} provides rich > comparison. r r Nr9 r r r r �test_gt� rG zSerialNumberTests.test_gtc C r< )zt > comparison of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. c S s t d�t� kS )Nr r> r r r r r? � r@ z6SerialNumberTests.test_gtForeignType.<locals>.<lambda>NrA r r r r �test_gtForeignType� rC z$SerialNumberTests.test_gtForeignTypec C s | � td�td� td�� dS )zX L{SerialNumber.__add__} allows L{SerialNumber} instances to be summed. r r Nr+ r r r r �test_add� s zSerialNumberTests.test_addc C r< )zn Addition of L{SerialNumber} with a non-L{SerialNumber} instance raises L{TypeError}. c S s t d�t� S r= r> r r r r r? � r@ z7SerialNumberTests.test_addForeignType.<locals>.<lambda>NrA r r r r �test_addForeignType� rC z%SerialNumberTests.test_addForeignTypec s" t d�j� | �t� fdd�� dS )zp L{SerialNumber} cannot be added with other SerialNumber values larger than C{_maxAdd}. r c s t d�t � d � S r= r r ��maxAddr r r? � � z:SerialNumberTests.test_addOutOfRangeHigh.<locals>.<lambda>N)r �_maxAddr% �ArithmeticErrorr r rM r �test_addOutOfRangeHigh� s �z(SerialNumberTests.test_addOutOfRangeHighc C sN t d�}|j|j d }|d }| �t |�t |�k� | �t |�t d�� dS )z� L{SerialNumber.__add__} returns a wrapped value when s1 plus the s2 would result in a value greater than the C{maxVal}. r r N)r � _halfRingr6 r )r �s�maxVal� maxValPlus1r r r � test_maxVal� s z SerialNumberTests.test_maxValc C s | � td�t�d�� dS )z� L{SerialNumber.fromRFC4034DateString} accepts a datetime string argument of the form 'YYYYMMDDhhmmss' and returns an L{SerialNumber} instance whose value is the unix timestamp corresponding to that UTC date. � ��N�20120101000000N)r r �fromRFC4034DateStringr r r r �test_fromRFC4034DateString� s �z,SerialNumberTests.test_fromRFC4034DateStringc C s | � dtd��� � dS )z� L{DateSerialNumber.toRFC4034DateString} interprets the current value as a unix timestamp and returns a date string representation of that date. rY rX N�r r �toRFC4034DateStringr r r r �test_toRFC4034DateString� s �z*SerialNumberTests.test_toRFC4034DateStringc C � | � td��� d� dS )zq L{SerialNumber.toRFC4034DateString} stores 32bit timestamps relative to the UNIX epoch. r �19700101000000Nr\ r r r r �test_unixEpoch� r z SerialNumberTests.test_unixEpochc C r_ )zI L{SerialNumber} wraps unix timestamps in the year 2106. ����21060207062815Nr\ r r r r �test_Y2106Problem� r- z#SerialNumberTests.test_Y2106Problemc sF t �tdddddd��� �� | �� td�j� | �t� fdd �� d S ) zy L{SerialNumber} raises ArithmeticError when used to add dates more than 68 years in the future. i� r � � � � r c s t d�t � d � S )Nr r r r �� maxAddTimer r r? � rO z5SerialNumberTests.test_Y2038Problem.<locals>.<lambda>N) �calendar�timegmr � utctimetupler r rP r% rQ r r ri r �test_Y2038Problem� s � �z#SerialNumberTests.test_Y2038ProblemN) �__name__� __module__� __qualname__�__doc__r r r r r r# r* r, r3 r5 r8 r: rB rD rE rF rH rI rJ rK rL rR rW r[ r^ ra rd rn r r r r r s< r c C sJ | � ||k� | � ||k� | � ||k � | � ||k� | � ||k� dS )a� A custom assertion for L{SerialNumber} values that cannot be meaningfully compared. "Note that there are some pairs of values s1 and s2 for which s1 is not equal to s2, but for which s1 is neither greater than, nor less than, s2. An attempt to use these ordering operators on such pairs of values produces an undefined result." @see: U{https://tools.ietf.org/html/rfc1982#section-3.2} @param testCase: The L{unittest.TestCase} on which to call assertion methods. @type testCase: L{unittest.TestCase} @param s1: The first value to compare. @type s1: L{SerialNumber} @param s2: The second value to compare. @type s2: L{SerialNumber} N)r. )�testCaser( r) r r r �assertUndefinedComparison� s rt r r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �SerialNumber2BitTestsaF Tests for correct answers to example calculations in RFC1982 5.1. The simplest meaningful serial number space has SERIAL_BITS == 2. In this space, the integers that make up the serial number space are 0, 1, 2, and 3. That is, 3 == 2^SERIAL_BITS - 1. https://tools.ietf.org/html/rfc1982#section-5.1 c C � | � tddd�jd� dS )z� In this space, the largest integer that it is meaningful to add to a sequence number is 2^(SERIAL_BITS - 1) - 1, or 1. r r r r N�r r rP r r r r � test_maxadd r z!SerialNumber2BitTests.test_maxaddc C st | � td�td� td�� | � td�td� td�� | � td�td� td�� | � td�td� td�� dS )zN Then, as defined 0+1 == 1, 1+1 == 2, 2+1 == 3, and 3+1 == 0. r r r rf N)r � serialNumber2r r r r rK & s z SerialNumber2BitTests.test_addc C s\ | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� dS )z: Further, 1 > 0, 2 > 1, 3 > 2, and 0 > 3. r r r rf N)r6 ry r r r r rI / s z SerialNumber2BitTests.test_gtc C sT t | td�td�� t | td�td�� t | td�td�� t | td�td�� dS )zU It is undefined whether 2 > 0 or 0 > 2, and whether 1 > 3 or 3 > 1. r r r rf N)rt ry r r r r �test_undefined8 s z$SerialNumber2BitTests.test_undefinedN)ro rp rq rr rx rK rI rz r r r r ru s ru r c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �SerialNumber8BitTestsa. Tests for correct answers to example calculations in RFC1982 5.2. Consider the case where SERIAL_BITS == 8. In this space the integers that make up the serial number space are 0, 1, 2, ... 254, 255. 255 == 2^SERIAL_BITS - 1. https://tools.ietf.org/html/rfc1982#section-5.2 c C rv )z� In this space, the largest integer that it is meaningful to add to a sequence number is 2^(SERIAL_BITS - 1) - 1, or 127. r r r � Nrw r r r r rx P r z!SerialNumber8BitTests.test_maxaddc C sX | � td�td� td�� | � td�td� td�� | � td�td� td�� dS )z| Addition is as expected in this space, for example: 255+1 == 0, 100+100 == 200, and 200+100 == 44. � r r �d �� �, N)r � serialNumber8r r r r rK W s z SerialNumber8BitTests.test_addc C s� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� | � td�td�k� dS )z� Comparison is more interesting, 1 > 0, 44 > 0, 100 > 0, 100 > 44, 200 > 100, 255 > 200, 0 > 255, 100 > 255, 0 > 200, and 44 > 200. r r r� r~ r r} N�r6 r� r r r r rI ` s z SerialNumber8BitTests.test_gtc C sH | � td�td� td�k� | � td�td� td� td�k � dS )a� Note that 100+100 > 100, but that (100+100)+100 < 100. Incrementing a serial number can cause it to become "smaller". Of course, incrementing by a smaller number will allow many more increments to be made before this occurs. However this is always something to be aware of, it can cause surprising errors, or be useful as it is the only defined way to actually cause a serial number to decrease. r~ Nr� r r r r �test_surprisingAdditiono s ��z-SerialNumber8BitTests.test_surprisingAdditionc C sT t | td�td�� t | td�td�� t | td�td�� t | td�td�� d S ) z� The pairs of values 0 and 128, 1 and 129, 2 and 130, etc, to 127 and 255 are not equal, but in each pair, neither number is defined as being greater than, or less than, the other. r � r � r � r| r} N)rt r� r r r r rz ~ s z$SerialNumber8BitTests.test_undefinedN) ro rp rq rr rx rK rI r� rz r r r r r{ E s r{ )rr rk r � functoolsr �twisted.names._rfc1982r � twisted.trialr �TestCaser rt ry ru r� r{ r r r r �<module> s d .PK Mb�Z�^^� � 4 names/test/__pycache__/test_examples.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZm Z G dd� d�Z G dd � d e e �Z G d d � d e e �Z G d d � d e e �Z G dd� de e �ZdS )z- Tests for L{twisted.names} example scripts. � N)�StringIO)�FilePath)�SkipTest�TestCasec @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �ExampleTestBasea� This is a mixin which adds an example to the path, tests it, and then removes it from the path and unimports the modules which the test loaded. Test cases which test example code and documentation listings should use this. This is done this way so that examples can live in isolated path entries, next to the documentation, replete with their own plugin packages and whatever other metadata they need. Also, example code is a rare instance of it being valid to have multiple versions of the same code in the repository at once, rather than relying on version control, because documentation will often show the progression of a single piece of code as features are added to it, and we want to test each one. c C s� t jdd� | _t j�� | _t� | _| �t d| j� t� | _ | �t d| j � z t t j d �� d�}W n ty= td��w | j�d�D ]}|� |�}|�� sXtd|j� d ���qD|| _t j�| j�� j� | j�� �d �d }t|�| _dS ) zn Add our example directory to the path and record which modules are currently loaded. N�stderr�stdout� TOX_INI_DIR�docsz5Examples not found ($TOX_INI_DIR unset) - cannot test�/z Examples (z) not found - cannot test�.r )�sys�path� originalPath�modules�copy�originalModulesr �fakeErr�patch�fakeOutr �os�environ�child�KeyErrorr �exampleRelativePath�split�exists� examplePath�append�parent�basename� __import__�example)�self�here� childName� moduleName� r' �B/usr/lib/python3/dist-packages/twisted/names/test/test_examples.py�setUp! s, �� �zExampleTestBase.setUpc C s, t j�� t j�| j� | jt jdd�< dS )z� Remove the example directory from the path and remove all modules loaded by the test from sys.modules. N)r r �clear�updater r r )r# r' r' r( �tearDownE s zExampleTestBase.tearDownc C sD | j �� �}| �|�� �� d� W d � dS 1 sw Y dS )zK The example scripts start with the standard shebang line. s #!/usr/bin/env pythonN)r �open� assertEqual�readline�rstrip)r# �fr' r' r( � test_shebangN s "�z ExampleTestBase.test_shebangc C sF | � t| jjdd� | j�� �� }| �|d �d�d|d f � dS )z� The example script prints a usage message to stdout if it is passed a --help option and then exits. The first line should contain a USAGE summary, explaining the accepted command arguments. Nz--helpr �Usage:�?Usage message first line should start with "Usage:". Actual: %r) � assertRaises� SystemExitr" �mainr �getvalue� splitlines� assertTrue� startswith)r# �outr' r' r( �test_usageConsistencyU s ��z%ExampleTestBase.test_usageConsistencyc C sf | � t| jjdd� | j�� �� }| �|d �d�d|d f � | �|d �d�d|d f � dS ) a` The example script prints a usage message to stderr if it is passed unrecognized command line arguments. The first line should contain a USAGE summary, explaining the accepted command arguments. The last line should contain an ERROR summary, explaining that incorrect arguments were supplied. Nz--unexpected_argumentr r3 r4 ���zERROR:z=Usage message last line should start with "ERROR:" Actual: %r) r5 r6 r" r7 r r8 r9 r: r; )r# �errr' r' r( � test_usageConsistencyOnErrorh s �� ��z,ExampleTestBase.test_usageConsistencyOnErrorN) �__name__� __module__� __qualname__�__doc__r) r, r2 r= r@ r' r' r' r( r s $ r c @ � e Zd ZdZdZdS )� TestDnsTestsz- Test the testdns.py example script. znames/examples/testdns.pyN�rA rB rC rD r r' r' r' r( rF � � rF c @ rE )�GetHostByNameTestsz3 Test the gethostbyname.py example script. z names/examples/gethostbyname.pyNrG r' r' r' r( rI � rH rI c @ rE )�DnsServiceTestsz1 Test the dns-service.py example script. z names/examples/dns-service.pyNrG r' r' r' r( rJ � rH rJ c @ rE )�MultiReverseLookupTestsz: Test the multi_reverse_lookup.py example script. z&names/examples/multi_reverse_lookup.pyNrG r' r' r' r( rK � rH rK )rD r r �ior �twisted.python.filepathr �twisted.trial.unittestr r r rF rI rJ rK r' r' r' r( �<module> s sPK Mb�Z�� � / names/test/__pycache__/test_dns.cpython-310.pycnu �[��� o �b�s � @ s d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z m Z ddl m Z m Z ddlmZ dd lmZ dd lmZmZ dd lmZ dd lmZ dd lmZ ejej ej ej ej ej ej!ej"ej#ej$ej%ej&ej'ej(ej)ej*ej+ej,ej-ej.ej/ej0ej1ej2ej3ej4gZ5G dd� dej6�Z7G dd� dej8�Z9G dd� dej8�Z:G dd� dej8�Z;G dd� dej8�Z<dZ=dZ>G dd� dej6�Z?G d d � d eej6�Z@G d d � d �ZAG d d!� d!ej8�ZBG d"d#� d#eA�ZCG d$d%� d%ej8�ZDG d&d'� d'ej8�ZEG d(d)� d)eej8�ZFG d*d+� d+ej8�ZGG d,d-� d-ej6�ZHd.d/� ZId0d1� ZJG d2d3� d3ej6�ZKG d4d5� d5�ZLG d6d7� d7eej8�ZMG d8d9� d9eej8�ZNG d:d;� d;eO�ZPG d<d=� d=�ZQG d>d?� d?�ZRG d@dA� dA�ZSG dBdC� dC�ZTG dDdE� dE�ZUG dFdG� dG�ZVG dHdI� dI�ZWG dJdK� dK�ZXG dLdM� dMee�ZY djdNdO�ZZG dPdQ� dQ�Z[G dRdS� dS�Z\G dTdU� dUe[e\ej6�Z]G dVdW� dWe[e\ej6�Z^G dXdY� dYe[ej6�Z_G dZd[� d[eej6�Z`G d\d]� d]�ZaG d^d_� d_eaej6�ZbG d`da� daeaej6�ZcG dbdc� dcej6�ZdG ddde� deej6�ZeG dfdg� dg�ZfG dhdi� diej6�ZgdS )kz Tests for twisted.names.dns. � N)�BytesIO)�cast)� verifyClass)�address�task)�CannotListenError�ConnectionDone)�dns)�Failure)� FancyEqMixin� FancyStrMixin)� proto_helpers)�ComparisonTestsMixin)�unittestc @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �DomainStringTestsc C s | � dt�d�� dS )zA L{dns.domainString} returns L{bytes} unchanged. s twistedmatrix.comN�� assertEqualr � domainString��self� r �=/usr/lib/python3/dist-packages/twisted/names/test/test_dns.py� test_bytes8 s �z DomainStringTests.test_bytesc C � | � dt�d�� dS )z` L{dns.domainString} converts a native string to L{bytes} if necessary. � example.com� example.comNr r r r r � test_nativeA � z DomainStringTests.test_nativec C r )zS L{dns.domainString} always converts a unicode string to L{bytes}. s foo.examplez foo.exampleNr r r r r � test_textH � zDomainStringTests.test_textc C r )�A L{dns.domainString} encodes Unicode using IDNA. s xn--fwg.testu ‽.testNr r r r r � test_idnaN r zDomainStringTests.test_idnac C s* | � ttjd� | � ttjt�d�� dS )r i(# z bar.exampleN)� assertRaises� TypeErrorr r �Namer r r r � test_nonsenseT s z DomainStringTests.test_nonsenseN)�__name__� __module__� __qualname__r r r r! r% r r r r r 7 s r c @ � e Zd ZdZdd� ZdS )� Ord2ByteTestsz& Tests for L{dns._ord2bytes}. c C r )z� L{dns._ord2byte} accepts an integer and returns a byte string of length one with an ordinal value equal to the given integer. � � N)r r � _ord2bytesr r r r � test_ord2bytea r zOrd2ByteTests.test_ord2byteN)r& r' r( �__doc__r. r r r r r* \ � r* c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )� Str2TimeTestsz$ Tests for L{dns.str2name}. c C s t � }| �|t�|�� dS )zY When passed a non-string object, L{dns.str2name} returns it unmodified. N)�object�assertIsr �str2time)r �timer r r �test_nonStringn s z Str2TimeTests.test_nonStringc C r )z� Passed a string giving a number of seconds, L{dns.str2time} returns the number of seconds represented. For example, C{"10S"} represents C{10} seconds. � �10SN�r r r4 r r r r � test_secondsu � zStr2TimeTests.test_secondsc C r )z� Like C{test_seconds}, but for the C{"M"} suffix which multiplies the time value by C{60} (the number of seconds in a minute!). �x �2MNr9 r r r r � test_minutes} r zStr2TimeTests.test_minutesc C r )z� Like C{test_seconds}, but for the C{"H"} suffix which multiplies the time value by C{3600}, the number of seconds in an hour. i0* �3HNr9 r r r r � test_hours� r zStr2TimeTests.test_hoursc C r )z� Like L{test_seconds}, but for the C{"D"} suffix which multiplies the time value by C{86400}, the number of seconds in a day. i F �4DNr9 r r r r � test_days� r zStr2TimeTests.test_daysc C r )z� Like L{test_seconds}, but for the C{"W"} suffix which multiplies the time value by C{604800}, the number of seconds in a week. i�$. �5WNr9 r r r r � test_weeks� r zStr2TimeTests.test_weeksc C r )z� Like L{test_seconds}, but for the C{"Y"} suffix which multiplies the time value by C{31536000}, the number of seconds in a year. i 5G �6YNr9 r r r r � test_years� r zStr2TimeTests.test_yearsc C s | � ttjd� dS )zY If a non-integer prefix is given, L{dns.str2time} raises L{ValueError}. �fooSN)r" � ValueErrorr r4 r r r r �test_invalidPrefix� � z Str2TimeTests.test_invalidPrefixN) r& r' r( r/ r6 r: r> r@ rB rD rF rI r r r r r1 i s r1 c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )� NameTestsz� Tests for L{Name}, the representation of a single domain name with support for encoding into and decoding from DNS message format. c C s6 | � ttjd� | � ttjt� � | � ttjg � dS )zy When constructed with a name which is neither C{bytes} nor C{str}, L{Name} raises L{TypeError}. �{ N)r" r# r r$ r2 r r r r �test_nonStringName� s z NameTests.test_nonStringNamec C s* t �d�}| �|jt� | �d|j� dS )zg L{dns.Name} automatically encodes unicode domain name using C{idna} encoding. u échec.example.orgs xn--chec-9oa.example.orgN)r r$ �assertIsInstance�name�bytesr )r rO r r r �test_unicodeName� s zNameTests.test_unicodeNamec C s( t �� }|�td�� | �|jd� dS )z� L{Name.decode} populates the L{Name} instance with name information read from the file-like object passed to it. � examplecom r N)r r$ �decoder r rO )r �nr r r � test_decode� s zNameTests.test_decodec C s. t �d�}t� }|�|� | �|�� d� dS )zy L{Name.encode} encodes its name information and writes it to the file-like object passed to it. � foo.example.coms fooexamplecom N)r r$ r �encoder �getvalue�r rO �streamr r r � test_encode� s zNameTests.test_encodec C st t �d�}ddi}d}t� }|�|� t|�t jj }|�||� | �d|� � t|�d� � | �d|d�|� dS )am If a compression dictionary is passed to it, L{Name.encode} uses offset information from it to encode its name with references to existing labels in the stream instead of including another copy of them in the output. It also updates the compression dictionary with the location of the name it writes to the stream. rV r � s some prefix to change .tell()s foo�N)r rV ) r r$ r �write�len�Message� headerSizerW r rX )r rO � compression�previousrZ �expectedr r r �test_encodeWithCompression� s �z$NameTests.test_encodeWithCompressionc C s� d}t �� }|�|� | �|jt jdddd�g� | �|jt jddddt jddd�d �g� | �|j t jd t j t j dt j d dd�d �g� |� � }| �||� d S ) z� A resource record of unknown type and class is parsed into an L{UnknownRecord} instance with its data preserved, and an L{UnknownRecord} instance is serialized to a string equal to the one it was parsed from. sD foobar ޭ�� ޭ�� somedatabazban � foo.bari�� i� )�type�clsi s somedata��ttl�rf rg ri �payloads baz.ban�1.2.3.4N)r r_ �fromStrr �queries�Query�answers�RRHeader� UnknownRecord� additional�A�IN�Record_A�toStr)r �wire�msg�encr r r � test_unknown� sB � �� ��� ��� zNameTests.test_unknownc C s� t d�}|�d� t�� }|�|� | �d|j� | �d|�� � |�|� | �|jd� | �d|�� � |�|� | �|jd� | �d|�� � d S ) a If the leading byte of an encoded label (in bytes read from a stream passed to L{Name.decode}) has its two high bits set, the next byte is treated as a pointer to another label in the stream and that label is included in the name being decoded. s, xxxxxxxxxxxxxxxxxxxxfisiarpa foo�bar� � s f.isi.arpa� s foo.f.isi.arpa�& s bar.foo.f.isi.arpa�, N)r �seekr r$ rS r rO �tell)r rZ rO r r r �test_decodeWithCompression5 s � z$NameTests.test_decodeWithCompressionc C s$ t �� }td�}| �t|j|� dS )z� L{Name.decode} raises L{ValueError} if the stream passed to it includes a compression pointer which forms a loop, causing the name to be undecodable. s � N)r r$ r r" rH rS rY r r r �test_rejectCompressionLoopT s z$NameTests.test_rejectCompressionLoopc C s: t �d�}t �d�}| �||� t �d�}| �||� dS )z� L{Name} instances are equal as long as they have the same value for L{Name.name}, regardless of the case. re s fOO.barN)r r$ r )r �name1�name2�name3r r r � test_equality^ s zNameTests.test_equalityc C s$ t �d�}t �d�}| �||� dS )zq L{Name} instances are not equal as long as they have different L{Name.name} attributes. re s bar.fooN)r r$ �assertNotEqual)r r� r� r r r �test_inequalityj s zNameTests.test_inequalityN)r& r' r( r/ rM rQ rU r[ rd r{ r� r� r� r� r r r r rK � s J rK c @ s� e Zd ZdZg d�Zdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Z d3d4� Z d5S )6�RoundtripDNSTestsz5 Encoding and then decoding various objects. )� example.orgs go-away.fish.tvs 23strikesback.netc C sR | j D ]#}t� }t�|��|� |�dd� t�� }|�|� | �|j|� qd S )Nr ) �namesr r r$ rW r� rS r rO �r rT �f�resultr r r � test_name{ s �zRoundtripDNSTests.test_namec C s� | j D ]D}tdd�D ]<}tdd�D ]4}t� }t�|||��|� |�dd� t�� }|�|� | �|j j |� | �|j |� | �|j |� qq qdS )z� L{dns.Query.encode} returns a byte string representing the fields of the query which can be decoded into a new L{dns.Query} instance using L{dns.Query.decode}. � � � r N) r� �ranger r ro rW r� rS r rO rf rg )r rT �dnstype�dnsclsr� r� r r r � test_query� s ���z RoundtripDNSTests.test_queryc C s| t � }t�dddd��|� |�dd� t�� }|�|� | �|jt�d�� | �|j d� | �|j d� | �|j d� dS )a L{dns.RRHeader.encode} encodes the record header's information and writes it to the file-like object passed to it and L{dns.RRHeader.decode} reads from a file-like object to re-construct a L{dns.RRHeader} instance. s test.org� � r� r N) r r rq rW r� rS r rO r$ rf rg ri )r r� r� r r r �test_resourceRecordHeader� s z+RoundtripDNSTests.test_resourceRecordHeaderc C sF | � td�� tjtjt�� d� W d � dS 1 s w Y dS )zy L{RRHeader()} raises L{ValueError} when the given type and the type of the payload don't match. z#Payload type \(AAAA\) .* type \(A\)�rf rk N)�assertRaisesRegexrH r rq rt � Record_AAAAr r r r �%test_resourceRecordHeaderTypeMismatch� s "�z7RoundtripDNSTests.test_resourceRecordHeaderTypeMismatchc C sZ d}|D ]&}t � }t�|��|� |�dd� t�� }|�|� | �|jt�|�� qdS )a L{dns.SimpleRecord.encode} encodes the record's name information and writes it to the file-like object passed to it and L{dns.SimpleRecord.decode} reads from a file-like object to re-construct a L{dns.SimpleRecord} instance. )s this.are.test.names0 will.compress.will.this.will.name.will.hopefullys test.CASE.preSErVatIOn.YeAHs a.s.h.o.r.t.c.a.s.e.t.o.t.e.s.ts singletonr N) r r � SimpleRecordrW r� rS r rO r$ )r r� �sr� r� r r r �test_resources� s �z RoundtripDNSTests.test_resourcesc C sL t D ]!}|� |� }}t|�}t|�}| �|||� d|� d|� d�� qdS )z= Instances of all record types are hashable. z != z (for �)N)� RECORD_TYPES�hashr )r �k�k1�k2�hk1�hk2r r r � test_hashable� s "�z RoundtripDNSTests.test_hashablec C sR | j D ]#}t� }t�|��|� |�dd� t�� }|�|� | �|j|� qdS )z8 Test L{dns.Charstr} encode and decode. r N) r� r r �CharstrrW r� rS r �stringr� r r r � test_Charstr� s �z RoundtripDNSTests.test_Charstrc C sH t � }|�|� |�� }|�dd� |�� }|�||� | �||� dS )z� Assert that encoding C{record} and then decoding the resulting bytes creates a record which compares equal to C{record}. @type record: L{dns.IEncodable} @param record: A record instance to encode r N)r rW r� r� � __class__rS r )r �recordrZ �length�replicar r r �_recordRoundtripTest� s z&RoundtripDNSTests._recordRoundtripTestc C s$ t � }|�|� | �|�� |� dS )a3 Assert that encoding C{record} produces the expected bytes. @type record: L{dns.IEncodable} @param record: A record instance to encode @type expectedEncoding: L{bytes} @param expectedEncoding: The value which C{record.encode()} should produce. N)r rW r rX )r �expectedEncodingr� rZ r r r �assertEncodedFormat� s z%RoundtripDNSTests.assertEncodedFormatc C s" | � tjdddddddd�� d S ) z� The byte stream written by L{dns.Record_SOA.encode} can be used by L{dns.Record_SOA.decode} to reconstruct the state of the original L{dns.Record_SOA} instance. � foo� bar� �" �8 �N �Z )�mname�rname�serial�refresh�retry�expire�minimumN)r� r � Record_SOAr r r r �test_SOA s ��zRoundtripDNSTests.test_SOAc C � | � t�d�� dS )z� The byte stream written by L{dns.Record_A.encode} can be used by L{dns.Record_A.decode} to reconstruct the state of the original L{dns.Record_A} instance. rl N)r� r rv r r r r �test_A � zRoundtripDNSTests.test_Ac C r� )z� The byte stream written by L{dns.Record_NULL.encode} can be used by L{dns.Record_NULL.decode} to reconstruct the state of the original L{dns.Record_NULL} instance. s foo barN)r� r � Record_NULLr r r r � test_NULL# r� zRoundtripDNSTests.test_NULLc C � | � t�ddd�� dS )z� The byte stream written by L{dns.Record_WKS.encode} can be used by L{dns.Record_WKS.decode} to reconstruct the state of the original L{dns.Record_WKS} instance. rl r� s xyzN)r� r � Record_WKSr r r r �test_WKS+ � zRoundtripDNSTests.test_WKSc C r� )z� The byte stream written by L{dns.Record_AAAA.encode} can be used by L{dns.Record_AAAA.decode} to reconstruct the state of the original L{dns.Record_AAAA} instance. z::1N)r� r r� r r r r � test_AAAA3 r� zRoundtripDNSTests.test_AAAAc C r� )z� The byte stream written by L{dns.Record_A6.encode} can be used by L{dns.Record_A6.decode} to reconstruct the state of the original L{dns.Record_A6} instance. � z::1:2r� N)r� r � Record_A6r r r r �test_A6; r� zRoundtripDNSTests.test_A6c C s | � tjddddd�� dS )z� The byte stream written by L{dns.Record_SRV.encode} can be used by L{dns.Record_SRV.decode} to reconstruct the state of the original L{dns.Record_SRV} instance. r� � r� r )�priority�weight�port�targetN)r� r � Record_SRVr r r r �test_SRVC � �zRoundtripDNSTests.test_SRVc C s: d}t jt jjt jj|d�}| �|� | �d| |� dS )z� The byte stream written by L{dns.Record_SSHFP.encode} can be used by L{dns.Record_SSHFP.decode} to reconstruct the state of the original L{dns.Record_SSHFP} instance. s �9��^kK 2U��`��� )� algorithm�fingerprintType� fingerprints N)r � Record_SSHFP� ALGORITHM_DSS�FINGERPRINT_TYPE_SHA1r� r� )r �fp�rrr r r � test_SSHFPM s �� z RoundtripDNSTests.test_SSHFPc C s� ddg}|D ]c\}}}}}}t �||||||�}t� } |�| � | �dd� t �� } | �| � | �|j| j� | �|j| j� | �|j | j � | �|j | j � | �|j | j � | �|j j | j j � | �|j| j� qdS )z= Test L{dns.Record_NAPTR} encode and decode. )�d r7 � u� sip+E2Us! !^.*$!sip:information@domain.tld!� )r� �2 � ss http+I2L+I2C+I2Rr� s _http._tcp.gatech.edur N)r � Record_NAPTRr rW r� rS r �order� preference�flags�service�regexp� replacementrO ri ) r �naptrsr� r� r� r� r� r� �rin�e�routr r r � test_NAPTR` s( � � �z RoundtripDNSTests.test_NAPTRc C � | � tjddd�� dS )z� The byte stream written by L{dns.Record_AFSDB.encode} can be used by L{dns.Record_AFSDB.decode} to reconstruct the state of the original L{dns.Record_AFSDB} instance. r� r )�subtype�hostnameN)r� r � Record_AFSDBr r r r � test_AFSDBz r� z RoundtripDNSTests.test_AFSDBc C r� )z� The byte stream written by L{dns.Record_RP.encode} can be used by L{dns.Record_RP.decode} to reconstruct the state of the original L{dns.Record_RP} instance. � alice.example.comr )�mbox�txtN)r� r � Record_RPr r r r �test_RP� s �zRoundtripDNSTests.test_RPc C r� )z� The byte stream written by L{dns.Record_HINFO.encode} can be used by L{dns.Record_HINFO.decode} to reconstruct the state of the original L{dns.Record_HINFO} instance. s fasts great)�cpu�osN)r� r � Record_HINFOr r r r � test_HINFO� r� z RoundtripDNSTests.test_HINFOc C r� )z� The byte stream written by L{dns.Record_MINFO.encode} can be used by L{dns.Record_MINFO.decode} to reconstruct the state of the original L{dns.Record_MINFO} instance. r� r� )�rmailbx�emailbxN)r� r � Record_MINFOr r r r � test_MINFO� r� z RoundtripDNSTests.test_MINFOc C r� )z� The byte stream written by L{dns.Record_MX.encode} can be used by L{dns.Record_MX.decode} to reconstruct the state of the original L{dns.Record_MX} instance. r� r )r� rO N)r� r � Record_MXr r r r �test_MX� r� zRoundtripDNSTests.test_MXc C sx d}t jdddd|d�}| �|� d| d }| �||� t jd d d t jd |d �}| �|� d| d }| �||� dS )z� The byte stream written by L{dns.Record_TSIG.encode} can be used by L{dns.Record_TSIG.decode} to reconstruct the state of the original L{dns.Record_TSIG} instance. s !"#0123zhmac-md5.sig-alg.reg.int�/qUZ�* r� )r� � timeSigned� originalID�fudge�MACs$ hmac-md5sig-algregint ZUq/ s * z hmac-sha256l '� � s � )r� r r �error� otherDatar s hmac-sha256 �' s �� � N)r � Record_TSIGr� r� �EBADTIME)r �macr� �rdatar r r � test_TSIG� s@ � ��� � ���zRoundtripDNSTests.test_TSIGc C s | � t�dd�� dS )z� The byte stream written by L{dns.Record_TXT.encode} can be used by L{dns.Record_TXT.decode} to reconstruct the state of the original L{dns.Record_TXT} instance. r� r� N)r� r � Record_TXTr r r r �test_TXT� r; zRoundtripDNSTests.test_TXTN) r& r' r( r/ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r� t s8 )r� s s c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&S )'� MessageTestsz1 Tests for L{twisted.names.dns.Message}. c C � | � t�� jd� dS )zC L{dns.Message.authenticData} has default value 0. r N�r r r_ � authenticDatar r r r �test_authenticDataDefault� r z&MessageTests.test_authenticDataDefaultc C � | � tjdd�jd� dS )z� L{dns.Message.__init__} accepts a C{authenticData} argument which is assigned to L{dns.Message.authenticData}. r� �r Nr r r r r �test_authenticDataOverride� � z'MessageTests.test_authenticDataOverridec C � | � tjdd��� t� dS )zr L{dns.Message.toStr} encodes L{dns.Message.authenticData} into byte4 of the byte string. r� r N)r r r_ rw � MESSAGE_AUTHENTIC_DATA_BYTESr r r r �test_authenticDataEncode� � �z%MessageTests.test_authenticDataEncodec C �$ t �� }|�t� | �|jd� dS )zp L{dns.Message.fromStr} decodes byte4 and assigns bit3 to L{dns.Message.authenticData}. r� N)r r_ rm r# r r �r �mr r r �test_authenticDataDecode � z%MessageTests.test_authenticDataDecodec C r )zF L{dns.Message.checkingDisabled} has default value 0. r N�r r r_ �checkingDisabledr r r r � test_checkingDisabledDefault r z)MessageTests.test_checkingDisabledDefaultc C r )z� L{dns.Message.__init__} accepts a C{checkingDisabled} argument which is assigned to L{dns.Message.checkingDisabled}. r� �r, Nr+ r r r r � test_checkingDisabledOverride r! z*MessageTests.test_checkingDisabledOverridec C r" )zu L{dns.Message.toStr} encodes L{dns.Message.checkingDisabled} into byte4 of the byte string. r� r. N)r r r_ rw � MESSAGE_CHECKING_DISABLED_BYTESr r r r �test_checkingDisabledEncode r% z(MessageTests.test_checkingDisabledEncodec C r& )zs L{dns.Message.fromStr} decodes byte4 and assigns bit4 to L{dns.Message.checkingDisabled}. r� N)r r_ rm r0 r r, r' r r r �test_checkingDisabledDecode' r* z(MessageTests.test_checkingDisabledDecodec C s | � dtt�� �� dS )z� L{dns.Message.__repr__} omits field values and sections which are identical to their defaults. The id field value is always shown. z<Message id=0>N)r �reprr r_ r r r r �test_reprDefaults1 � z MessageTests.test_reprDefaultsc C s, t jdddddddd�}| �dt|�� dS )zM L{dns.Message.__repr__} displays flags if they are L{True}. T)�answer�auth�trunc�recDes�recAvr r, zR<Message id=0 flags=answer,auth,trunc,recDes,recAv,authenticData,checkingDisabled>N�r r_ r r3 r' r r r �test_reprFlagsIfSet8 s � �z MessageTests.test_reprFlagsIfSetc C s& t jddddd�}| �dt|�� dS )zk L{dns.Message.__repr__} displays field values if they differ from their defaults. r7 r| � �( )�id�opCode�rCode�maxSizez-<Message id=10 opCode=20 rCode=30 maxSize=40>Nr; r' r r r �test_reprNonDefautFieldsN s �z%MessageTests.test_reprNonDefautFieldsc C sD t �� }g d�|_g d�|_g d�|_g d�|_| �dt|�� dS )�e L{dns.Message.__repr__} displays sections which differ from their defaults. �r� r� r� �r� r� � �� r� � �r7 � r� z^<Message id=0 queries=[1, 2, 3] answers=[4, 5, 6] authority=[7, 8, 9] additional=[10, 11, 12]>N)r r_ rn rp � authorityrs r r3 r' r r r �test_reprNonDefaultSectionsY � �z(MessageTests.test_reprNonDefaultSectionsc C s t �� }| �t|jd� dS )zy Test that a message which has been truncated causes an EOFError to be raised when it is parsed. r� N)r r_ r" �EOFErrorrm �r ry r r r �test_emptyMessagen s z MessageTests.test_emptyMessagec C s� t �� }|�d� | �|jd� | �|jd� | �|jt j� | �|j d� | �|j d� | �|j g � | �|j g � | �|j g � | �|jg � dS )ze Test that bytes representing an empty query message can be decoded as such. s � z)Message was not supposed to be an answer.z-Message was not supposed to be authoritative.z)Message was not supposed to be truncated.N)r r_ rm r r? � assertFalser6 r@ �OP_QUERYr7 r8 rn rp rM rs rQ r r r �test_emptyQueryv s � z MessageTests.test_emptyQueryc C s� d� dd� td�D ��}t�|�}tjdtj|d�}t�� }|j�|� t � }|� |� |� dd� t�� }|� |� | � |jd jtj� | �|jd jj|� dS ) z| A I{NULL} record with an arbitrary payload can be encoded and decoded as part of a L{dns.Message}. r� c S � g | ]}t �|��qS r �r r- ��.0�ir r r � <listcomp>� � z*MessageTests.test_NULL.<locals>.<listcomp>rS � testname�rk r N)�joinr� r r� rq �NULLr_ rp �appendr rW r� rS rN rk r �r rP �recr� �msg1r� �msg2r r r r� � s zMessageTests.test_NULLc C s | � t�� �d�tj� dS )z� L{Message.lookupRecordType} returns C{dns.UnknownRecord} if it is called with an integer which doesn't correspond to any known record type. i � N)r3 r r_ �lookupRecordTyperr r r r r � test_lookupRecordTypeDefault� s z)MessageTests.test_lookupRecordTypeDefaultc C sf t � }tjtjddd�d�}|�|� t�� }|�d|�� � | �|j |g� | � |j d j � dS )z� The L{RRHeader} instances created by L{Message} from a non-authoritative message are marked as not authoritative. rl r rh r_ s N) r r rq rv rW r_ rm rX r rp rT r7 �r �bufr6 �messager r r � test_nonAuthoritativeMessage� s �� z)MessageTests.test_nonAuthoritativeMessagec C sl t � }tjtjddd�d�}|�|� t�� }|�d|�� � d|_| � |j |g� | � |j d j� dS )z� The L{RRHeader} instances created by L{Message} from an authoritative message are marked as authoritative. rl r rh r_ s TN) r r rq rv rW r_ rm rX r7 r rp � assertTrueri r r r �test_authoritativeMessage� s �� z&MessageTests.test_authoritativeMessageN)r& r' r( r/ r r r$ r) r- r/ r1 r2 r4 r< rC rN rR rV r� rh rl rn r r r r r � s( r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�MessageComparisonTestszD Tests for the rich comparison of L{dns.Message} instances. c O sl |� dg �}|� dg �}|� dg �}|� dg �}tjdi |��}|r%||_|r*||_|r/||_|r4||_|S )a� Create a L{dns.Message}. The L{dns.Message} constructor doesn't accept C{queries}, C{answers}, C{authority}, C{additional} arguments, so we extract them from the kwargs supplied to this factory function and assign them to the message. @param args: Positional arguments. @param kwargs: Keyword arguments. @return: A L{dns.Message} instance. rn rp rM rs Nr )�popr r_ rn rp rM rs )r �args�kwargsrn rp rM rs r( r r r �messageFactory� s z%MessageComparisonTests.messageFactoryc C �* | � | jdd�| jdd�| jdd�� dS )zd Two L{dns.Message} instances compare equal if they have the same id value. r7 �r? r| N��"assertNormalEqualityImplementationrs r r r r �test_id � �z MessageComparisonTests.test_idc C rt )zg Two L{dns.Message} instances compare equal if they have the same answer flag. r� �r6 r Nrv r r r r � test_answer ry z"MessageComparisonTests.test_answerc C rt )zh Two L{dns.Message} instances compare equal if they have the same opCode value. r7 �r@ r| Nrv r r r r � test_opCode ry z"MessageComparisonTests.test_opCodec C rt )zg Two L{dns.Message} instances compare equal if they have the same recDes flag. r� �r9 r Nrv r r r r � test_recDes! ry z"MessageComparisonTests.test_recDesc C rt )zf Two L{dns.Message} instances compare equal if they have the same recAv flag. r� �r: r Nrv r r r r � test_recAv, ry z!MessageComparisonTests.test_recAvc C rt )ze Two L{dns.Message} instances compare equal if they have the same auth flag. r� �r7 r Nrv r r r r � test_auth7 ry z MessageComparisonTests.test_authc C rt )zg Two L{dns.Message} instances compare equal if they have the same rCode value. r7 �rA r| Nrv r r r r � test_rCodeB ry z!MessageComparisonTests.test_rCodec C rt )zf Two L{dns.Message} instances compare equal if they have the same trunc flag. r� �r8 r Nrv r r r r � test_truncM ry z!MessageComparisonTests.test_truncc C rt )zi Two L{dns.Message} instances compare equal if they have the same maxSize value. r7 �rB r| Nrv r r r r � test_maxSizeX ry z#MessageComparisonTests.test_maxSizec C rt )zn Two L{dns.Message} instances compare equal if they have the same authenticData flag. r� r r Nrv r r r r �test_authenticDatac ry z)MessageComparisonTests.test_authenticDatac C rt )zq Two L{dns.Message} instances compare equal if they have the same checkingDisabled flag. r� r. r Nrv r r r r �test_checkingDisabledn ry z,MessageComparisonTests.test_checkingDisabledc C �B | � | jt�d�gd�| jt�d�gd�| jt�d�gd�� dS )zc Two L{dns.Message} instances compare equal if they have the same queries. r �rn r� N�rw rs r ro r r r r � test_queriesy � �z#MessageComparisonTests.test_queriesc C �` | � | jtjdt�d�d�gd�| jtjdt�d�d�gd�| jtjdt�d�d�gd�� dS )zc Two L{dns.Message} instances compare equal if they have the same answers. r rl r_ �rp r� �4.3.2.1N�rw rs r rq rv r r r r � test_answers� � ����z#MessageComparisonTests.test_answersc C �f | � | jtjdtjt�� d�gd�| jtjdtjt�� d�gd�| jtjdtjt�� d�gd�� dS )zm Two L{dns.Message} instances compare equal if they have the same authority records. r r� �rM r� N�rw rs r rq �SOAr� r r r r �test_authority� � �������z%MessageComparisonTests.test_authorityc C �` | � | jtjdt�d�d�gd�| jtjdt�d�d�gd�| jtjdt�d�d�gd�� dS )zn Two L{dns.Message} instances compare equal if they have the same additional records. r rl r_ �rs r� Nr� r r r r �test_additional� � �������z&MessageComparisonTests.test_additionalN)r& r' r( r/ rs rx r{ r} r r� r� r� r� r� r� r� r� r� r� r� r r r r ro � s$ ro c @ s" e Zd ZdZdd� Zddd�ZdS )�TestControllerz� Pretend to be a DNS query processor for a DNSDatagramProtocol. @ivar messages: the list of received messages. @type messages: C{list} of (msg, protocol, address) c C s g | _ dS )zG Initialize the controller: create a list of messages. N)�messagesr r r r �__init__� s zTestController.__init__Nc C s | j �|||f� dS )zN Save the message so that it can be checked during the tests. N)r� rb )r ry �proto�addrr r r �messageReceived� r z TestController.messageReceived�N)r& r' r( r/ r� r� r r r r r� � s r� c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�DatagramProtocolTestsz= Test various aspects of L{dns.DNSDatagramProtocol}. c C sD t �� | _t� | _t�| j�| _t� � }| j� |� | jj | j_ dS )zQ Create a L{dns.DNSDatagramProtocol} with a deterministic clock. N) r �Clock�clockr� � controllerr �DNSDatagramProtocolr� r �FakeDatagramTransport�makeConnection� callLater)r � transportr r r �setUp� s zDatagramProtocolTests.setUpc C s, | j �dt�ddd�� | �| jjg � dS )z� Test that when a short datagram is received, datagramReceived does not raise an exception while processing it. r� �UDP� 127.0.0.1i90 N)r� �datagramReceivedr � IPv4Addressr r� r� r r r r �test_truncatedPacket� s z*DatagramProtocolTests.test_truncatedPacketc s� � j �dt�d�g�}� �t� j j�� �d� t�� }t t � j j�� ��|_ tj tj dd�d�g|_� fdd�}|�|� � j �|�� d� |S ) �6 Test content received after a query. �r� iaS r� r� rl �r r_ c � � � | jd j�� d� d S �Nr rl �r rp rk � dottedQuad�r� r r r �cb� � z2DatagramProtocolTests.test_simpleQuery.<locals>.cb)r� �queryr ro r r^ � liveMessages�keysr_ �next�iterr? rq rv rp � addCallbackr� rw )r �dr( r� r r r �test_simpleQuery� s z&DatagramProtocolTests.test_simpleQueryc C s\ | j �dt�d�g�}| �t| j j�d� | j�d� | � |tj � | �t| j j�d� |S )�> Test that query timeouts after some seconds. r� r� r� r7 r � r� r� r ro r r^ r� r� �advance� assertFailure�DNSQueryTimeoutError�r r� r r r �test_queryTimeout s z'DatagramProtocolTests.test_queryTimeoutc C s4 dd� }|| j j_| j �dt�d�g�}| �|t�S )z� Exceptions raised by the transport's write method should be turned into C{Failure}s passed to errbacks of the C{Deferred} returned by L{DNSDatagramProtocol.query}. c S � t d���N�bar�� RuntimeError)rk r� r r r � writeError � z9DatagramProtocolTests.test_writeError.<locals>.writeErrorr� r� �r� r� r] r� r ro r� r� �r r� r� r r r �test_writeError s z%DatagramProtocolTests.test_writeErrorc C s: dd� }|| j _d| j _| j �dt�d�g�}| �|t�S )z� Exception L{CannotListenError} raised by C{listenUDP} should be turned into a C{Failure} passed to errback of the C{Deferred} returned by L{DNSDatagramProtocol.query}. c S s t d d d ��r� )r r r r r �startListeningError# � zCDatagramProtocolTests.test_listenError.<locals>.startListeningErrorNr� r� )r� �startListeningr� r� r ro r� r )r r� r� r r r �test_listenError s z&DatagramProtocolTests.test_listenErrorc C s\ t �� }d|_t jt jdd�d�g|_| j�|�� d� | � | j j d d �� |�� � dS ) z� When receiving a message whose id is not in L{DNSDatagramProtocol.liveMessages} or L{DNSDatagramProtocol.resends}, the message will be received by L{DNSDatagramProtocol.controller}. r� rl r� r_ r� ���r N) r r_ r? rq rv rp r� r� rw r r� r� )r rk r r r �$test_receiveMessageNotInLiveMessages- s $z:DatagramProtocolTests.test_receiveMessageNotInLiveMessagesN) r& r' r( r/ r� r� r� r� r� r� r� r r r r r� � s r� c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �TestTCPControllera Pretend to be a DNS query processor for a DNSProtocol. @ivar connections: A list of L{DNSProtocol} instances which have notified this controller that they are connected and have not yet notified it that their connection has been lost. c C s t �| � g | _d S r� )r� r� � connectionsr r r r r� C s zTestTCPController.__init__c C � | j �|� d S r� )r� rb �r r� r r r �connectionMadeG � z TestTCPController.connectionMadec C r� r� )r� �remover� r r r �connectionLostJ r� z TestTCPController.connectionLostN)r& r' r( r/ r� r� r� r r r r r� : s r� c @ �@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�DNSProtocolTestsz5 Test various aspects of L{dns.DNSProtocol}. c C s@ t �� | _t� | _t�| j�| _| j�t � � � | jj | j_ dS )zI Create a L{dns.DNSProtocol} with a deterministic clock. N) r r� r� r� r� r � DNSProtocolr� r� r �StringTransportr� r r r r r� S s zDNSProtocolTests.setUpc C s< | � | jj| jg� | j�ttd��� | � | jjg � dS )z� L{dns.DNSProtocol} calls its controller's C{connectionMade} method with itself when it is connected to a transport and its controller's C{connectionLost} method when it is disconnected. zFake Connection DoneN)r r� r� r� r� r r r r r r �test_connectionTracking] s z(DNSProtocolTests.test_connectionTrackingc C sZ | j �t�d�g�}| �t| j j�d� | j�d� | � |tj � | �t| j j�d� |S )r� r� r� �< r r� r� r r r r� g s z"DNSProtocolTests.test_queryTimeoutc s� � j �t�d�g�}� �t� j j�� �d� t�� }t t � j j�� ��|_ tj tj dd�d�g|_� fdd�}|�|� |�� }t�dt|��| }� j �|� |S ) r� r� r� rl r� r_ c r� r� r� r� r r r r� | r� z-DNSProtocolTests.test_simpleQuery.<locals>.cb�!H)r� r� r ro r r^ r� r� r_ r� r� r? rq rv rp r� rw �struct�pack� dataReceived)r r� r( r� r� r r r r� r s z!DNSProtocolTests.test_simpleQueryc C s2 dd� }|| j j_| j �t�d�g�}| �|t�S )z� Exceptions raised by the transport's write method should be turned into C{Failure}s passed to errbacks of the C{Deferred} returned by L{DNSProtocol.query}. c S r� r� r� )rk r r r r� � r� z4DNSProtocolTests.test_writeError.<locals>.writeErrorr� r� r� r r r r� � s z DNSProtocolTests.test_writeErrorc C sr t �� }d|_t jt jdd�d�g|_|�� }t�dt |��| }| j � |� | � | j jd d �� |�� � dS ) z� When receiving a message whose id is not in L{DNSProtocol.liveMessages} the message will be received by L{DNSProtocol.controller}. r� rl r� r_ r� r� r N)r r_ r? rq rv rp rw r� r� r^ r� r� r r� r� )r rk r� r r r r� � s $z5DNSProtocolTests.test_receiveMessageNotInLiveMessagesN) r& r' r( r/ r� r� r� r� r� r� r r r r r� N s r� c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4S )5� ReprTestszE Tests for the C{__repr__} implementation of record classes. c C � | � tt�dd��d� dS )z� The repr of a L{dns.Record_NS} instance includes the name of the nameserver and the TTL of the record. r �� z <NS name=example.com ttl=4321>N)r r3 r � Record_NSr r r r �test_ns� r% zReprTests.test_nsc C r� )z� The repr of a L{dns.Record_MD} instance includes the name of the mail destination and the TTL of the record. r r� z <MD name=example.com ttl=4321>N)r r3 r � Record_MDr r r r �test_md� r% zReprTests.test_mdc C r� )z� The repr of a L{dns.Record_MF} instance includes the name of the mail forwarder and the TTL of the record. r r� z <MF name=example.com ttl=4321>N)r r3 r � Record_MFr r r r �test_mf� r% zReprTests.test_mfc C r� )z� The repr of a L{dns.Record_CNAME} instance includes the name of the mail forwarder and the TTL of the record. r r� z!<CNAME name=example.com ttl=4321>N)r r3 r � Record_CNAMEr r r r � test_cname� � �zReprTests.test_cnamec C r� )z} The repr of a L{dns.Record_MB} instance includes the name of the mailbox and the TTL of the record. r r� z <MB name=example.com ttl=4321>N)r r3 r � Record_MBr r r r �test_mb� r% zReprTests.test_mbc C r� )z� The repr of a L{dns.Record_MG} instance includes the name of the mail group member and the TTL of the record. r r� z <MG name=example.com ttl=4321>N)r r3 r � Record_MGr r r r �test_mg� r% zReprTests.test_mgc C r� )z� The repr of a L{dns.Record_MR} instance includes the name of the mail rename domain and the TTL of the record. r r� z <MR name=example.com ttl=4321>N)r r3 r � Record_MRr r r r �test_mr� r% zReprTests.test_mrc C r� )z~ The repr of a L{dns.Record_PTR} instance includes the name of the pointer and the TTL of the record. r r� z <PTR name=example.com ttl=4321>N)r r3 r � Record_PTRr r r r �test_ptr� r� zReprTests.test_ptrc C r� )z� The repr of a L{dns.Record_DNAME} instance includes the name of the non-terminal DNS name redirection and the TTL of the record. r r� z!<DNAME name=example.com ttl=4321>N)r r3 r � Record_DNAMEr r r r � test_dname� r� zReprTests.test_dnamec C r� )z� The repr of a L{dns.Record_A} instance includes the dotted-quad string representation of the address it is for and the TTL of the record. rl i7 z<A address=1.2.3.4 ttl=567>N)r r3 r rv r r r r �test_a� r� zReprTests.test_ac C s* | � ttjddddddddd ��d � d S ) zh The repr of a L{dns.Record_SOA} instance includes all of the authority fields. s mNames rNamerL �� � r7 rL r� )r� r� r� r� r� r� r� ri zZ<SOA mname=mName rname=rName serial=123 refresh=456 retry=789 expire=10 minimum=11 ttl=12>N)r r3 r r� r r r r �test_soa s �� �zReprTests.test_soac C r� )z The repr of a L{dns.Record_NULL} instance includes the repr of its payload and the TTL of the record. s abcdrL z <NULL payload='abcd' ttl=123>N)r r3 r r� r r r r � test_null r% zReprTests.test_nullc C � | � ttjdddd��d� dS )z� The repr of a L{dns.Record_WKS} instance includes the dotted-quad string representation of the address it is for, the IP protocol number it is for, and the TTL of the record. z2.3.4.5rI r� rh z&<WKS address=2.3.4.5 protocol=7 ttl=8>N)r r3 r r� r r r r �test_wks$ s �zReprTests.test_wksc C s | � ttjddd��d� dS )z� The repr of a L{dns.Record_AAAA} instance includes the colon-separated hex string representation of the address it is for and the TTL of the record. z 8765::1234r7 rh z <AAAA address=8765::1234 ttl=10>N)r r3 r r� r r r r � test_aaaa/ s �zReprTests.test_aaaac C s" | � ttjddddd��d� dS )z� The repr of a L{dns.Record_A6} instance includes the colon-separated hex string representation of the address it is for and the TTL of the record. r z 1234::5678re r7 rh z,<A6 suffix=1234::5678 prefix=foo.bar ttl=10>N)r r3 r r� r r r r �test_a6: s �zReprTests.test_a6c C s" | � tt�ddddd��d� dS )z� The repr of a L{dns.Record_SRV} instance includes the name and port of the target and the priority, weight, and TTL of the record. r� r� r� r� r� z9<SRV priority=1 weight=2 target=example.org port=3 ttl=4>N)r r3 r r� r r r r �test_srvE s �zReprTests.test_srvc C s* t �ddddddd�}| �t|�d� d S ) z� The repr of a L{dns.Record_NAPTR} instance includes the order, preference, flags, service, regular expression, replacement, and TTL of the record. r� rJ � S� https /foo/bar/i� bazr� zY<NAPTR order=5 preference=9 flags=S service=http regexp=/foo/bar/i replacement=baz ttl=3>N)r r� r r3 �r r� r r r � test_naptrO s �zReprTests.test_naptrc C � | � tt�ddd��d� dS )z{ The repr of a L{dns.Record_AFSDB} instance includes the subtype, hostname, and TTL of the record. r� r� r� z,<AFSDB subtype=3 hostname=example.org ttl=5>N)r r3 r r� r r r r � test_afsdb\ � �zReprTests.test_afsdbc C r )zw The repr of a L{dns.Record_RP} instance includes the mbox, txt, and TTL fields of the record. r� s admin.example.comr� z7<RP mbox=alice.example.com txt=admin.example.com ttl=3>N)r r3 r r� r r r r �test_rpf r zReprTests.test_rpc C r )zx The repr of a L{dns.Record_HINFO} instance includes the cpu, os, and TTL fields of the record. s sparcs minixr� z%<HINFO cpu='sparc' os='minix' ttl=12>N)r r3 r r r r r r � test_hinfop r zReprTests.test_hinfoc C s" t �ddd�}| �t|�d� dS )z� The repr of a L{dns.Record_MINFO} instance includes the rmailbx, emailbx, and TTL fields of the record. r� � bob.example.com� zF<MINFO responsibility=alice.example.com errors=bob.example.com ttl=15>N)r r r r3 r r r r � test_minfoz s �zReprTests.test_minfoc C r )z~ The repr of a L{dns.Record_MX} instance includes the preference, name, and TTL fields of the record. � s mx.example.comr� z,<MX preference=13 name=mx.example.com ttl=2>N)r r3 r r r r r r �test_mx� r zReprTests.test_mxc C r )zr The repr of a L{dns.Record_TXT} instance includes the data and ttl fields of the record. r� r� r rh z <TXT data=['foo', 'bar'] ttl=15>N)r r3 r r r r r r �test_txt� � �zReprTests.test_txtc C r )zr The repr of a L{dns.Record_SPF} instance includes the data and ttl fields of the record. r� r� r rh z <SPF data=['foo', 'bar'] ttl=15>N)r r3 r � Record_SPFr r r r �test_spf� r# zReprTests.test_spfc C r� )zu The repr of a L{dns.UnknownRecord} instance includes the data and ttl fields of the record. s foo barr� z"<UNKNOWN data='foo\x1fbar' ttl=12>N)r r3 r rr r r r r r{ � r� zReprTests.test_unknownN) r& r' r( r/ r� r� r� r� r r r r r r r r r r r r r r r r r r! r" r% r{ r r r r r� � s6 r� c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@dA� Z#dBS )C� EqualityTestszM Tests for the equality and non-equality behavior of record classes. c C s | � |||�S r� )rw )r � firstValueOne�secondValueOne�valueTwor r r � _equalityTest� s �zEqualityTests._equalityTestc C �$ | � t�d�t�d�t�d�� dS )zt Two L{dns.Charstr} instances compare equal if and only if they have the same string value. � abc� defN)r* r r� r r r r � test_charstr� s �zEqualityTests.test_charstrc C r+ )zo Two L{dns.Name} instances compare equal if and only if they have the same name value. r, r- N)r* r r$ r r r r r� � s $zEqualityTests.test_namec C sD | � |dd�|dd�|dd�� | � |dd�|dd�|dd�� dS )z� Assert that instances of C{cls} with the same attributes compare equal to each other and instances with different attributes compare as not equal. @param cls: A L{dns.SimpleRecord} subclass. r rL iA r� N)r* )r rg r r r �_simpleEqualityTest� s ��z!EqualityTests._simpleEqualityTestc C s~ | � tjdt�d�d�tjdt�d�d�tjdt�d�d�� | � tjdt�d�d�tjdt�d�d�tjdt�d�d�� | � t�dtj�t�dtj�t�dtj�� | � tjdtjt�d�d�tjdtjt�d�d�tjdtjt�d�d�� | � tjddt�d�d�tjddt�d�d�tjdd t�d�d�� | � tjdd t�d�d �tjdd t�d�d �tjdd t�d�d �� d S )z� Two L{dns.RRHeader} instances compare equal if and only if they have the same name, type, class, time to live, payload, and authoritative bit. r rl r_ r� �1.2.3.5)rg rk r� )ri rk r< r� )r7 rk r N)r* r rq rv rt �MXru �CSr r r r � test_rrheader� s< �� ����zEqualityTests.test_rrheaderc C � | � tj� dS )zv Two L{dns.Record_NS} instances compare equal if and only if they have the same name and TTL. N)r/ r r� r r r r r� � zEqualityTests.test_nsc C r4 �zv Two L{dns.Record_MD} instances compare equal if and only if they have the same name and TTL. N)r/ r r� r r r r r� r5 zEqualityTests.test_mdc C r4 )zv Two L{dns.Record_MF} instances compare equal if and only if they have the same name and TTL. N)r/ r r� r r r r r� r5 zEqualityTests.test_mfc C r4 )zy Two L{dns.Record_CNAME} instances compare equal if and only if they have the same name and TTL. N)r/ r r� r r r r r� r5 zEqualityTests.test_cnamec C r4 )zv Two L{dns.Record_MB} instances compare equal if and only if they have the same name and TTL. N)r/ r r� r r r r r & r5 zEqualityTests.test_mbc C r4 )zv Two L{dns.Record_MG} instances compare equal if and only if they have the same name and TTL. N)r/ r r r r r r r - r5 zEqualityTests.test_mgc C r4 )zv Two L{dns.Record_MR} instances compare equal if and only if they have the same name and TTL. N)r/ r r r r r r r 4 r5 zEqualityTests.test_mrc C r4 )zw Two L{dns.Record_PTR} instances compare equal if and only if they have the same name and TTL. N)r/ r r r r r r r ; r5 zEqualityTests.test_ptrc C r4 r6 )r/ r r r r r r r B r5 zEqualityTests.test_dnamec C sP | � t�dd�t�dd�t�dd�� | � t�dd�t�dd�t�dd�� dS )zx Two L{dns.Record_A} instances compare equal if and only if they have the same address and TTL. rl r� rG r0 N)r* r rv r r r r r I � � �zEqualityTests.test_ac C sT | � t�dddddddd�t�dddddddd�t�d ddddddd�� | � t�dddddddd�t�dddddddd�t�dd dddddd�� | � t�dddddddd�t�dddddddd�t�ddd ddddd�� | � t�dddddddd�t�dddddddd�t�dddd dddd�� | � t�dddddddd�t�dddddddd�t�ddddd ddd�� | � t�dddddddd�t�dddddddd�t�dddddd dd�� | � t�dddddddd�t�dddddddd�t�ddddddd d�� | � t�dddddddd�t�dddddddd�t�dd dddddd �� d S ) z� Two L{dns.Record_SOA} instances compare equal if and only if they have the same mname, rname, serial, refresh, minimum, expire, retry, and ttl. s mnames rnamerL r r r7 r| r= s xnamer� N)r* r r� r r r r r [ sP ��������zEqualityTests.test_soac C �P | � t�dd�t�dd�t�dd�� | � t�dd�t�dd�t�dd�� dS )z{ Two L{dns.Record_NULL} instances compare equal if and only if they have the same payload and ttl. zfoo barr7 zbar foor� N)r* r r� r r r r r � r7 zEqualityTests.test_nullc C �� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� d S ) z� Two L{dns.Record_WKS} instances compare equal if and only if they have the same address, protocol, map, and ttl. rl r� �foor� r� r� r� �� N)r* r r� r r r r r � �( ����zEqualityTests.test_wksc C r8 )z{ Two L{dns.Record_AAAA} instances compare equal if and only if they have the same address and ttl. z1::2r� z2::1r7 N)r* r r� r r r r r � r7 zEqualityTests.test_aaaac C r9 ) z� Two L{dns.Record_A6} instances compare equal if and only if they have the same prefix, prefix length, suffix, and ttl. r, z::abcdr r7 r} z::abcd:0r� r� N)r* r r� r r r r r � s( ����zEqualityTests.test_a6c C s | � t�ddddd�t�ddddd�t�ddddd�� | � t�ddddd�t�ddddd�t�ddddd�� | � t�ddddd�t�ddddd�t�ddddd�� | � t�ddddd�t�ddddd�t�dddd d�� | � t�ddddd�t�ddddd�t�ddddd �� d S ) z� Two L{dns.Record_SRV} instances compare equal if and only if they have the same priority, weight, port, target, and ttl. r7 r| r= r r> r� r; i, r� � N)r* r r� r r r r r � s2 �����zEqualityTests.test_srvc C s� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� | � t�dddd�t�dddd�t�dddd�� dS )z� Two L{dns.Record_SSHFP} instances compare equal if and only if they have the same key type, fingerprint type, fingerprint, and ttl. r� r� s happydayr> s happxday�- N)r* r r� r r r r � test_sshfp r< zEqualityTests.test_sshfpc C s� | � t�ddddddd�t�ddddddd�t�ddddddd�� | � t�ddddddd�t�ddddddd�t�ddddddd�� | � t�ddddddd�t�ddddddd�t�ddd dddd�� | � t�ddddddd�t�ddddddd�t�dddd ddd�� | � t�ddddddd�t�ddddddd�t�ddddd dd�� | � t�ddddddd�t�ddddddd�t�ddddd d d�� | � t�ddddddd�t�ddddddd�t�ddddd dd �� dS )z� Two L{dns.Record_NAPTR} instances compare equal if and only if they have the same order, preference, flags, service, regexp, replacement, and ttl. r� r� r� r� s /foo/bar/r r� r� � pr s /bar/foo/s quuxr� N)r* r r� r r r r r 7 sF �������zEqualityTests.test_naptrc C s� | � t�ddd�t�ddd�t�ddd�� | � t�ddd�t�ddd�t�ddd�� | � t�ddd�t�ddd�t�ddd�� dS )z� Two L{dns.Record_AFSDB} instances compare equal if and only if they have the same subtype, hostname, and ttl. r� r r� r� r� N)r* r r� r r r r r h � � � �zEqualityTests.test_afsdbc C � | � t�ddd�t�ddd�t�ddd�� | � t�ddd�t�ddd�t�ddd�� | � t�ddd�t�ddd�t�ddd�� dS )zx Two L{Record_RP} instances compare equal if and only if they have the same mbox, txt, and ttl. r� s alice is nicer7 r s alice is not nicer� N)r* r r� r r r r r � rA zEqualityTests.test_rpc C rB )z} Two L{dns.Record_HINFO} instances compare equal if and only if they have the same cpu, os, and ttl. zx86-64�plan9r7 �i386�plan11r� N)r* r r r r r r r � rA zEqualityTests.test_hinfoc C rB )z� Two L{dns.Record_MINFO} instances compare equal if and only if they have the same rmailbx, emailbx, and ttl. s rmailboxs emailboxr7 s someplaces somethingr� N)r* r r r r r r r � rA zEqualityTests.test_minfoc C rB )z� Two L{dns.Record_MX} instances compare equal if and only if they have the same preference, name, and ttl. r7 r� r| r� s example.netr; N)r* r r r r r r r! � rA zEqualityTests.test_mxc C � | � tjdddd�tjdddd�tjddddd�� | � tjdddd�tjdddd�tjdddd�� | � tjdddd�tjdddd�tjdddd�� dS )zw Two L{dns.Record_TXT} instances compare equal if and only if they have the same data and ttl. r: r� r7 rh �bazr� N)r* r r r r r r r" � � ���zEqualityTests.test_txtc C rF )zs L{dns.Record_SPF} instances compare equal if and only if they have the same data and ttl. r: r� r7 rh rG r� N)r* r r$ r r r r r% � rH zEqualityTests.test_spfc C s� dddddt jddd�}d d d d d t jddd�}|�� D ]%}|�� }|| ||< | �t jdi |��t jdi |��t jdi |��� q dS )z� L{dns.Record_TSIG} instances compare equal if and only if they have the same RDATA (algorithm, timestamp, MAC, etc.) and ttl. z hmac-sha224r r� s �c r� r> )r� r r r r r r ri z hmac-sha512i�pUZr s i�� � r= Nr )r �OKr r� �copyr* r )r �baseargs�altargs�kw�alteredr r r � test_tsig s6 � � ��zEqualityTests.test_tsigc C s� | � tjddd�tjddd�tjddd�� | � tjddd�tjddd�tjddd�� | � tjddd�tjddd�tjddd�� dS )zv L{dns.UnknownRecord} instances compare equal if and only if they have the same data and ttl. r: r7 rh �foobarr� r� N)r* r rr r r r r r{ 2 rA zEqualityTests.test_unknownN)$r& r' r( r/ r* r. r� r/ r3 r� r� r� r� r r r r r r r r r r r r r? r r r r r r! r" r% rQ r{ r r r r r& � sD 17 !$ 1 "r& c @ r� ) � RRHeaderTestsz2 Tests for L{twisted.names.dns.RRHeader}. c C �& | � ttjdtjtjdt�d�� dS )z� Attempting to create a L{dns.RRHeader} instance with a negative TTL causes L{ValueError} to be raised. r r� r� N�r" rH r rq rt ru rv r r r r �test_negativeTTLP � �z RRHeaderTests.test_negativeTTLc C s6 d}t �dt jt j|t �d��}| �|jt|�� dS )z< L{dns.RRHeader} converts TTLs to integers. g������^@r r� N)r rq rt ru rv r ri �int)r � ttlAsFloat�headerr r r �test_nonIntegralTTL_ s �z!RRHeaderTests.test_nonIntegralTTLc C rT )z� Attempting to create a L{dns.RRHeader} instance with a TTL that L{int} cannot convert to an integer raises a L{TypeError}. r zthis is not a numberr� NrU r r r r �!test_nonNumericTTLRaisesTypeErrori rW z/RRHeaderTests.test_nonNumericTTLRaisesTypeErrorN)r& r' r( r/ rV r[ r\ r r r r rS K s rS c @ r� )�NameToLabelsTestsz7 Tests for L{twisted.names.dns._nameToLabels}. c C s | � t�d�dg� dS )zp L{dns._nameToLabels} returns a list containing a single empty label for an empty name. r� N�r r � _nameToLabelsr r r r � test_empty~ r5 z NameToLabelsTests.test_emptyc C s | � t�d�dg� dS )z L{dns._nameToLabels} returns a list containing a single empty label for a name containing only a dot. � .r� Nr^ r r r r � test_onlyDot� r5 z NameToLabelsTests.test_onlyDotc C s | � t�d�ddg� dS )z{ L{dns._nameToLabels} returns a list ending with an empty label for a name without a trailing dot. � comr� Nr^ r r r r �test_withoutTrailingDot� r! z)NameToLabelsTests.test_withoutTrailingDotc C s | � t�d�ddg� dS )zx L{dns._nameToLabels} returns a list ending with an empty label for a name with a trailing dot. s com.rc r� Nr^ r r r r �test_withTrailingDot� r! z&NameToLabelsTests.test_withTrailingDotc C � | � t�d�g d�� dS )zt L{dns._nameToLabels} returns a list containing entries for all labels in a subdomain name. s foo.bar.baz.example.com.)r� r� r s examplerc r� Nr^ r r r r �test_subdomain� s �z NameToLabelsTests.test_subdomainc C rf )z` L{dns._nameToLabels} preserves the case of ascii characters in labels. � EXAMPLE.COM)s EXAMPLEs COMr� Nr^ r r r r �test_casePreservation� r! z'NameToLabelsTests.test_casePreservationN) r& r' r( r/ r` rb rd re rg ri r r r r r] y s r] c C �" | � t�||�|�d|��� dS )a\ Assert that C{descendant} *is* a subdomain of C{ancestor}. @type testCase: L{unittest.SynchronousTestCase} @param testCase: The test case on which to run the assertions. @type descendant: C{str} @param descendant: The subdomain name to test. @type ancestor: C{str} @param ancestor: The superdomain name to test. z is not a subdomain of N)rm r �_isSubdomainOf��testCase� descendant�ancestorr r r �assertIsSubdomainOf� � �rp c C rj )a` Assert that C{descendant} *is not* a subdomain of C{ancestor}. @type testCase: L{unittest.SynchronousTestCase} @param testCase: The test case on which to run the assertions. @type descendant: C{str} @param descendant: The subdomain name to test. @type ancestor: C{str} @param ancestor: The superdomain name to test. z is a subdomain of N)rT r rk rl r r r �assertIsNotSubdomainOf� rq rr c @ sp e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� ZdS )�IsSubdomainOfTestsz8 Tests for L{twisted.names.dns._isSubdomainOf}. c C s t | dd� dS )z[ L{dns._isSubdomainOf} returns C{True} for identical domain names. r N�rp r r r r �test_identical� r5 z!IsSubdomainOfTests.test_identicalc C � t | dd� dS )z� L{dns._isSubdomainOf} returns C{True} when the first name is an immediate descendant of the second name. rV r Nrt r r r r � test_parent� r5 z IsSubdomainOfTests.test_parentc C rv )z L{dns._isSubdomainOf} returns C{True} when the first name is a distant descendant of the second name. s foo.bar.baz.example.comrc Nrt r r r r �test_distantAncestor� r5 z'IsSubdomainOfTests.test_distantAncestorc C rv )zw L{dns._isSubdomainOf} returns C{False} when the first name is an ancestor of the second name. r rV N�rr r r r r �test_superdomain� r5 z#IsSubdomainOfTests.test_superdomainc C rv )zs L{dns._isSubdomainOf} returns C{False} if the first name is a sibling of the second name. rV s bar.example.comNry r r r r � test_sibling� r5 z IsSubdomainOfTests.test_siblingc C rv )zx L{dns._isSubdomainOf} returns C{False} even when domain names happen to share a common suffix. s foo.myexample.comr Nry r r r r �test_unrelatedCommonSuffix� r5 z-IsSubdomainOfTests.test_unrelatedCommonSuffixc C rv )z� L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name but the first name has a trailing ".". � foo.example.com.r Nrt r r r r � test_subdomainWithTrailingDot � z0IsSubdomainOfTests.test_subdomainWithTrailingDotc C rv )z� L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name but the second name has a trailing ".". rV � example.com.Nrt r r r r � test_superdomainWithTrailingDot r z2IsSubdomainOfTests.test_superdomainWithTrailingDotc C rv )z� L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name and both names have a trailing ".". r} r� Nrt r r r r �test_bothWithTrailingDot r z+IsSubdomainOfTests.test_bothWithTrailingDotc C rv )zw L{dns._isSubdomainOf} returns C{False} if the first name is empty and the second name is not. r� r Nry r r r r �test_emptySubdomain r5 z&IsSubdomainOfTests.test_emptySubdomainc C rv )zv L{dns._isSubdomainOf} returns C{True} if the second name is empty and the first name is not. rV r� Nrt r r r r �test_emptySuperdomain r5 z(IsSubdomainOfTests.test_emptySuperdomainc C s t | dd� t | dd� dS )z` L{dns._isSubdomainOf} does case-insensitive comparison of name labels. rV rh s FOO.EXAMPLE.COMr Nrt r r r r � test_caseInsensitiveComparison' s z1IsSubdomainOfTests.test_caseInsensitiveComparisonN)r& r' r( r/ ru rw rx rz r{ r| r~ r� r� r� r� r� r r r r rs � s rs c @ s* e Zd ZdZeddd��Zedd� �ZdS ) �OPTNonStandardAttributesz� Generate byte and instance representations of an L{dns._OPTHeader} where all attributes are set to non-default values. For testing whether attributes have really been read from the byte string during decoding. Fc C s d}|rd}d| S )aT Return L{bytes} representing an encoded OPT record. @param excludeName: A flag that controls whether to exclude the name field. This allows a non-standard name to be prepended during the test. @type excludeName: L{bool} @param excludeOptions: A flag that controls whether to exclude the RDLEN field. This allows encoded variable options to be appended during the test. @type excludeOptions: L{bool} @return: L{bytes} representing the encoded OPT record returned by L{object}. rJ r� s ) � r )rg � excludeName�excludeOptions�rdlenr r r rP : s �z OPTNonStandardAttributes.bytesc C s t jddddd�S )z� Return a new L{dns._OPTHeader} instance. @return: A L{dns._OPTHeader} instance with attributes that match the encoded record returned by L{bytes}. � r� r� T)�udpPayloadSize� extendedRCODE�version�dnssecOK)r � _OPTHeader�rg r r r r2 Y s �z OPTNonStandardAttributes.objectN)FF)r& r' r( r/ � classmethodrP r2 r r r r r� 1 s r� c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@S )A�OPTHeaderTestsz4 Tests for L{twisted.names.dns._OPTHeader}. c C � t tjtj� dS )zA L{dns._OPTHeader} implements L{dns.IEncodable}. N)r r � IEncodabler� r r r r �test_interfacek � z OPTHeaderTests.test_interfacec C s | � t�� jt�d�� dS )zq L{dns._OPTHeader.name} is an instance attribute whose value is fixed as the root domain r� N)r r r� rO r$ r r r r r� q s zOPTHeaderTests.test_namec C s$ t �� }| �tt|dt �d�� dS )z5 L{dns._OPTHeader.name} is readonly. rO r N)r r� r" �AttributeError�setattrr$ �r �hr r r �test_nameReadonlyx s z OPTHeaderTests.test_nameReadonlyc C r )z^ L{dns._OPTHeader.type} is an instance attribute with fixed value 41. �) N)r r r� rf r r r r � test_type r zOPTHeaderTests.test_typec C s t �� }| �tt|dt j� dS )z5 L{dns._OPTHeader.type} is readonly. rf N)r r� r" r� r� rt r� r r r �test_typeReadonly� s z OPTHeaderTests.test_typeReadonlyc C r )zt L{dns._OPTHeader.udpPayloadSize} defaults to 4096 as recommended in rfc6891 section-6.2.5. � N�r r r� r� r r r r �test_udpPayloadSize� r z"OPTHeaderTests.test_udpPayloadSizec C r )z` L{dns._OPTHeader.udpPayloadSize} can be overridden in the constructor. r� �r� Nr� r r r r �test_udpPayloadSizeOverride� r! z*OPTHeaderTests.test_udpPayloadSizeOverridec C r )z@ L{dns._OPTHeader.extendedRCODE} defaults to 0. r N�r r r� r� r r r r �test_extendedRCODE� r z!OPTHeaderTests.test_extendedRCODEc C r )z_ L{dns._OPTHeader.extendedRCODE} can be overridden in the constructor. r� �r� Nr� r r r r �test_extendedRCODEOverride� r! z)OPTHeaderTests.test_extendedRCODEOverridec C r )z: L{dns._OPTHeader.version} defaults to 0. r N�r r r� r� r r r r � test_version� r zOPTHeaderTests.test_versionc C r )zY L{dns._OPTHeader.version} can be overridden in the constructor. r� �r� Nr� r r r r �test_versionOverride� r! z#OPTHeaderTests.test_versionOverridec C s | � t�� j� dS )z? L{dns._OPTHeader.dnssecOK} defaults to False. N)rT r r� r� r r r r � test_dnssecOK� rJ z OPTHeaderTests.test_dnssecOKc C s | � tjdd�j� dS )zZ L{dns._OPTHeader.dnssecOK} can be overridden in the constructor. T�r� N)rm r r� r� r r r r �test_dnssecOKOverride� r5 z$OPTHeaderTests.test_dnssecOKOverridec C s | � t�� jg � dS )zC L{dns._OPTHeader.options} defaults to empty list. N)r r r� �optionsr r r r � test_options� r zOPTHeaderTests.test_optionsc C s" t jdgd�}| �|jdg� dS )zY L{dns._OPTHeader.options} can be overridden in the constructor. )r� r� � �r� N)r r� r r� r� r r r �test_optionsOverride� s z#OPTHeaderTests.test_optionsOverridec C s, t � }t�� �|� | �|�� t�� � dS )z� L{dns._OPTHeader.encode} packs the header fields and writes them to a file like object passed in as an argument. N)r r� r2 rW r rX rP )r �br r r r[ � s zOPTHeaderTests.test_encodec C sR t �� }t�dd�t�dd�g|_t� }|�|� | �|�� t j dd�d � dS ) z� L{dns._OPTHeader.options} is a list of L{dns._OPTVariableOption} instances which are packed into the rdata area of the header. r� � foobarbazr� � quxT�r� � foobarbaz quxN) r� r2 r �_OPTVariableOptionr� r rW r rX rP )r r� r� r r r �test_encodeWithOptions� s � ��z%OPTHeaderTests.test_encodeWithOptionsc C s. t �� }|�tt�� �� | �|t�� � dS )z� L{dns._OPTHeader.decode} unpacks the header fields from a file like object and populates the attributes of an existing L{dns._OPTHeader} instance. N)r r� rS r r� rP r r2 )r � decodedHeaderr r r rU � s zOPTHeaderTests.test_decodec C s: t t�� �}t�� }|�|� | �|�� t|� � �� dS )zk L{dns._OPTHeader.decode} reads all the bytes of the record that is being decoded. N� r r� rP r r� rS r r� r^ rX �r r� r� r r r �test_decodeAllExpectedBytes s z*OPTHeaderTests.test_decodeAllExpectedBytesc C sF t t�� d �}t�� }|�|� | �|�� t|� � �td� � dS )z� L{dns._OPTHeader.decode} reads only the bytes from the current file position to the end of the record that is being decoded. Trailing bytes are not consumed. s xxxxNr� r� r r r � test_decodeOnlyExpectedBytes s $z+OPTHeaderTests.test_decodeOnlyExpectedBytesc C s> t tjdd�d �}t�� }|�|� | �|jt�d�� dS )z� L{dns._OPTHeader.decode} discards the name which is encoded in the supplied bytes. The name attribute of the resulting L{dns._OPTHeader} instance will always be L{dns.Name(b'')}. T)r� rR r� N) r r� rP r r� rS r rO r$ �r r� r� r r r �test_decodeDiscardsName s � z&OPTHeaderTests.test_decodeDiscardsNamec C �0 t tjdd�d �}t�� }| �t|j|� dS )zj L{dns._OPTHeader.decode} raises an exception if the supplied RDLEN is too short. Tr� s N�r r� rP r r� r" rP rS r� r r r �test_decodeRdlengthTooShort( � �� z*OPTHeaderTests.test_decodeRdlengthTooShortc C r� )zi L{dns._OPTHeader.decode} raises an exception if the supplied RDLEN is too long. Tr� s Nr� r� r r r �test_decodeRdlengthTooLong9 r� z)OPTHeaderTests.test_decodeRdlengthTooLongc C sL t tjdd�d �}t�� }|�|� | �|jt�dd�t�dd�g� dS ) z� If the OPT bytes contain variable options, L{dns._OPTHeader.decode} will populate a list L{dns._OPTHeader.options} with L{dns._OPTVariableOption} instances. Tr� r� r� r� r� r� N) r r� rP r r� rS r r� r� r� r r r �test_decodeWithOptionsJ s �� ��z%OPTHeaderTests.test_decodeWithOptionsc C sX t jdt jddt �d�d�}t j�|�}t jddddt jdd d �gd �}| �||� d S ) z� L{_OPTHeader.fromRRHeader} accepts an L{RRHeader} instance and returns an L{_OPTHeader} instance whose attribute values have been derived from the C{cls}, C{ttl} and C{payload} attributes of the original header. r r l �} s �� abcrj � � Tr, )�code�data)r� r� r� r� r� N)r rq �OPTrr r� � fromRRHeaderr� r )r � genericHeader�decodedOptHeader�expectedOptHeaderr r r �test_fromRRHeaderi s � �z OPTHeaderTests.test_fromRRHeaderc C s | � tt�� �d� dS )z� L{dns._OPTHeader.__repr__} displays the name and type and all the fixed and extended header values of the OPT record. zb<_OPTHeader name= type=41 udpPayloadSize=4096 extendedRCODE=0 version=0 dnssecOK=False options=[]>N)r r3 r r� r r r r � test_repr� s �zOPTHeaderTests.test_reprc C �* | � tjdd�tjdd�tjdd�� dS )zh Two L{OPTHeader} instances compare equal if they have the same udpPayloadSize. r� r� r� N�rw r r� r r r r �test_equalityUdpPayloadSize� ry z*OPTHeaderTests.test_equalityUdpPayloadSizec C r� )zg Two L{OPTHeader} instances compare equal if they have the same extendedRCODE. r� r� r� Nr� r r r r �test_equalityExtendedRCODE� ry z)OPTHeaderTests.test_equalityExtendedRCODEc C r� )za Two L{OPTHeader} instances compare equal if they have the same version. r� r� r� Nr� r r r r �test_equalityVersion� ry z#OPTHeaderTests.test_equalityVersionc C r� )zh Two L{OPTHeader} instances compare equal if they have the same dnssecOK flags. Tr� FNr� r r r r �test_equalityDnssecOK� ry z$OPTHeaderTests.test_equalityDnssecOKc C sH | � tjt�dd�gd�tjt�dd�gd�tjt�dd�gd�� dS )za Two L{OPTHeader} instances compare equal if they have the same options. r� � xr� r� � yN)rw r r� r� r r r r �test_equalityOptions� s �z#OPTHeaderTests.test_equalityOptionsN)#r& r' r( r/ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r[ r� rU r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� f sB r� c @ r� )�OPTVariableOptionTestsz. Tests for L{dns._OPTVariableOption}. c C r� )zI L{dns._OPTVariableOption} implements L{dns.IEncodable}. N)r r r� r� r r r r r� � r� z%OPTVariableOptionTests.test_interfacec C s, t �dd�}| �|jd� | �|jd� dS )z� L{dns._OPTVariableOption.__init__} requires code and data arguments which are saved as public instance attributes. r� r� N)r r� r r� r� r� r r r �test_constructorArguments� s z0OPTVariableOptionTests.test_constructorArgumentsc C r� )zf L{dns._OPTVariableOption.__repr__} displays the code and data of the option. r� r� z"<_OPTVariableOption code=1 data=x>N)r r3 r r� r r r r r� � r� z OPTVariableOptionTests.test_reprc C r8 )zs Two OPTVariableOption instances compare equal if they have the same code and data values. r� r� r� r� N)rw r r� r r r r r� � s � �z$OPTVariableOptionTests.test_equalityc C s0 t �dd�}t� }|�|� | �|�� d� dS )z� L{dns._OPTVariableOption.encode} encodes the code and data instance attributes to a byte string which also includes the data length. r� � foobar� foobarN)r r� r rW r rX )r �or� r r r r[ � s �z"OPTVariableOptionTests.test_encodec C s: t d�}t�� }|�|� | �|jd� | �|jd� dS )z� L{dns._OPTVariableOption.decode} is a classmethod that decodes a byte string and returns a L{dns._OPTVariableOption} instance. r� r� r� N)r r r� rS r r� r� )r r� r� r r r rU s � z"OPTVariableOptionTests.test_decodeN) r& r' r( r/ r� r� r� r� r[ rU r r r r r� � s r� c @ r) )� RaisedArgszp An exception which can be raised by fakes to test that the fake is called with expected arguments. c C s || _ || _dS )z� Store the positional and keyword arguments as attributes. @param args: The positional args. @param kwargs: The keyword args. N�rq rr �r rq rr r r r r� # s zRaisedArgs.__init__N)r& r' r( r/ r� r r r r r� s r� c @ �( e Zd ZdZedd� �Zedd� �ZdS )� MessageEmptyz^ Generate byte string and constructor arguments for an empty L{dns._EDNSMessage}. c C � dS )�� Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. s �� r r� r r r rP 4 � �zMessageEmpty.bytesc C s t ddtjddddddd� S )�� Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. rS Tr N� r? r6 r@ r7 r8 r9 r: rA � ednsVersion)�dictr � OP_STATUSr� r r r rr G s �zMessageEmpty.kwargsN�r& r' r( r/ r� rP rr r r r r r� . s r� c @ r� )�MessageTruncatedz= An empty response message whose TR bit is set to 1. c C r� )r� s � r r� r r r rP a r� zMessageTruncated.bytesc C s t dddddddddd� S )r� rS r� r Nr� )r� r� r r r rr t s �zMessageTruncated.kwargsNr� r r r r r� \ s r� c @ r� )�MessageNonAuthoritativez. A minimal non-authoritative message. c C r� )r� s r r� r r r rP � r� z MessageNonAuthoritative.bytesc C s( t dddtjdtjddd�dd�gd �S ) r� rS r Nr� rl rh F�rk r7 �r? r7 r� rp �r� r rq rv r� r r r rr � � ��z MessageNonAuthoritative.kwargsNr� r r r r r� � � r� c @ r� )�MessageAuthoritativez* A minimal authoritative message. c C r� )r� s r r� r r r rP � r� zMessageAuthoritative.bytesc C s( t dddtjdtjddd�dd �gd �S ) r� rS r� Nr� rl r rh Tr� r� r� r� r r r rr � r� zMessageAuthoritative.kwargsNr� r r r r r� � r� r� c @ r� )�MessageCompletez� An example of a fully populated non-edns response message. Contains name compression, answers, authority, and additional records. c C r� )r� sn �� examplecom � ���� 'ns1� hostmaster� ������������������ ���� �)�) ���� r r� r r r rP � r� zMessageComplete.bytesc C s� t ddtjdddddt�dtj�gtjdtjddtjddd d d d d dd�d�gtjdtjddtjddd�d�gtjdtj ddtj ddd�d�gd� S )r� rS r� r Nr � �� T� ns1.example.com� hostmaster.example.com� �� ������� �� �ri r� r� r� r� r� r� r� �rf ri r7 rk �ns1.example.comrh �5.6.7.8) r? r6 r@ r7 r9 r: rA r� rn rp rM rs � r� r r� ro r� rq r� �NSr� rt rv r� r r r rr $ sX ��� �� ���zMessageComplete.kwargsNr� r r r r r� � s 1r� c @ r� )�MessageEDNSQueryz' A minimal EDNS query message. c C r� )r� s, wwwexamplecom ) r r� r r r rP b r� zMessageEDNSQuery.bytesc C s, t ddtjddddddt�dtj�gg d� S )r� r r� Fs www.example.com) r? r6 r@ r7 r9 r: rA r� r� rn rs )r� r rU ro rt r� r r r rr � s �zMessageEDNSQuery.kwargsNr� r r r r r ] s r c @ r� )�MessageEDNSCompletez� An example of a fully populated edns response message. Contains name compression, answers, authority, and additional records. c C r� )r� sy �� examplecom � ���� 'ns1� hostmaster� ������������������ ���� �)�) ���� ) � r r� r r r rP � r� zMessageEDNSComplete.bytesc C s� t d(i dd�dd�dtj�dd�dd�d d�d d�d d �d d�dd�dd�dd�dd�dt�dtj�g�dtjdtjddtjddddd d d d d �d!�g�d"tjdtjddtjd#dd$�d!�g�d%tjdtj ddtj d&dd$�d!�g��S ))r� r? rS r6 r� r@ r7 r8 r r9 r: rA r r� r� r� Tr r, rB � rn r rp r� r� r� r� r� r� r� r� r r rM r rh rs r Nr r r� r r r rr � s� �������� � � � � ������" ���+ ���zMessageEDNSComplete.kwargsNr� r r r r r � s 9r c @ r� )�MessageEDNSExtendedRCODEz? An example of an EDNS message with an extended RCODE. c C r� )r� s ) � r r� r r r rP r� z MessageEDNSExtendedRCODE.bytesc C s( t ddtjddddddddg g g g d�S )r� r Fi� r� )r? r6 r@ r7 r8 r9 r: rA r� r� rB rn rp rM rs )r� r rU r� r r r rr 7 s" �z MessageEDNSExtendedRCODE.kwargsNr� r r r r r s r c @ s( e Zd ZdZd ZZdd� Zdd� ZdS )�MessageComparablez� A wrapper around L{dns.Message} which is comparable so that it can be tested using some of the L{dns._EDNSMessage} tests. ) r? r6 r@ r7 r8 r9 r: rA rn rp rM rs c C s || _ d S r� )�original)r r r r r r� g � zMessageComparable.__init__c C s t | j|�S r� )�getattrr )r �keyr r r � __getattr__j r� z MessageComparable.__getattr__N)r& r' r( r/ �showAttributes�compareAttributesr� r r r r r r R s r c C s^ |du r|}i }||d�}|� }t ||�|d< |di ||i��}t ||�|d< | �||� dS )a� Verify that an attribute has the expected default value and that a corresponding argument passed to a constructor is assigned to that attribute. @param testCase: The L{TestCase} whose assert methods will be called. @type testCase: L{unittest.TestCase} @param cls: The constructor under test. @type cls: L{type} @param argName: The name of the constructor argument under test. @type argName: L{str} @param defaultVal: The expected default value of C{attrName} / C{argName} @type defaultVal: L{object} @param altVal: A value which is different from the default. Used to test that supplied constructor arguments are actually assigned to the correct attribute. @type altVal: L{object} @param attrName: The name of the attribute under test if different from C{argName}. Defaults to C{argName} @type attrName: L{str} N�� defaultVal�altValr r r )r r ) rm rg �argNamer r �attrName�actualrc r� r r r �verifyConstructorArgumentn s r c @ s e Zd ZdZdd� Zdd� ZdS )�ConstructorTestsMixinzl Helper methods for verifying default attribute values and corresponding constructor arguments. c C s t | | j|||d� dS )a� Wrap L{verifyConstructorArgument} to provide simpler interface for testing Message and _EDNSMessage constructor arguments. @param argName: The name of the constructor argument. @param defaultVal: The expected default value. @param altVal: An alternative value which is expected to be assigned to a correspondingly named attribute. �rm rg r r r N�r rs )r r r r r r r �_verifyConstructorArgument� s �z0ConstructorTestsMixin._verifyConstructorArgumentc C s& |dv sJ �t | | j||| d� dS )a Wrap L{verifyConstructorArgument} to provide simpler interface for testing _EDNSMessage constructor flags. @param argName: The name of the constructor flag argument @param defaultVal: The expected default value of the flag )TFr Nr )r r r r r r �_verifyConstructorFlag� s �z,ConstructorTestsMixin._verifyConstructorFlagN)r& r' r( r/ r r r r r r r � s r c @ sx e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd S ) �CommonConstructorTestsMixina� Tests for constructor arguments and their associated attributes that are common to both L{twisted.names.dns._EDNSMessage} and L{dns.Message}. TestCase classes that use this mixin must provide a C{messageFactory} method which accepts any argment supported by L{dns.Message.__init__}. TestCases must also mixin ConstructorTestsMixin which provides some custom assertions for testing constructor arguments. c C � | j dddd� dS )zk L{dns._EDNSMessage.id} defaults to C{0} and can be overridden in the constructor. r? r r� r N�r r r r r rx � � z#CommonConstructorTestsMixin.test_idc C � | j ddd� dS )zs L{dns._EDNSMessage.answer} defaults to C{False} and can be overridden in the constructor. r6 F�r N�r r r r r r{ � � z'CommonConstructorTestsMixin.test_answerc C s | j dtjtjd� dS )zz L{dns._EDNSMessage.opCode} defaults to L{dns.OP_QUERY} and can be overridden in the constructor. r@ r N)r r rU r� r r r r r} � s �z'CommonConstructorTestsMixin.test_opCodec C r" )zq L{dns._EDNSMessage.auth} defaults to C{False} and can be overridden in the constructor. r7 Fr# Nr$ r r r r r� � r% z%CommonConstructorTestsMixin.test_authc C r" )zr L{dns._EDNSMessage.trunc} defaults to C{False} and can be overridden in the constructor. r8 Fr# Nr$ r r r r r� � r% z&CommonConstructorTestsMixin.test_truncc C r" )zs L{dns._EDNSMessage.recDes} defaults to C{False} and can be overridden in the constructor. r9 Fr# Nr$ r r r r r � r% z'CommonConstructorTestsMixin.test_recDesc C r" )zr L{dns._EDNSMessage.recAv} defaults to C{False} and can be overridden in the constructor. r: Fr# Nr$ r r r r r� � r% z&CommonConstructorTestsMixin.test_recAvc C r )zn L{dns._EDNSMessage.rCode} defaults to C{0} and can be overridden in the constructor. rA r rL r Nr r r r r r� r! z&CommonConstructorTestsMixin.test_rCodec C r )zr L{dns._EDNSMessage.maxSize} defaults to C{512} and can be overridden in the constructor. rB r� r r Nr r r r r r� r! z(CommonConstructorTestsMixin.test_maxSizec C � | � | �� jg � dS )z@ L{dns._EDNSMessage.queries} defaults to C{[]}. N)r rs rn r r r r r� r z(CommonConstructorTestsMixin.test_queriesc C r& )z@ L{dns._EDNSMessage.answers} defaults to C{[]}. N)r rs rp r r r r r� r z(CommonConstructorTestsMixin.test_answersc C r& )zB L{dns._EDNSMessage.authority} defaults to C{[]}. N)r rs rM r r r r r� r z*CommonConstructorTestsMixin.test_authorityc C r& )zC L{dns._EDNSMessage.additional} defaults to C{[]}. N)r rs rs r r r r r� % r z+CommonConstructorTestsMixin.test_additionalN)r& r' r( r/ rx r{ r} r� r� r r� r� r� r� r� r� r� r r r r r � s r c @ � e Zd ZdZejZdS )�EDNSMessageConstructorTestszt Tests for L{twisted.names.dns._EDNSMessage} constructor arguments that are shared with L{dns.Message}. N�r& r' r( r/ r � _EDNSMessagers r r r r r( , � r( c @ r' )�MessageConstructorTestszt Tests for L{twisted.names.dns.Message} constructor arguments that are shared with L{dns._EDNSMessage}. N)r& r' r( r/ r r_ rs r r r r r, 7 r+ r, c @ s� e Zd ZdZejZdd� Zdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�EDNSMessageSpecificsTestsz� Tests for L{dns._EDNSMessage}. These tests are for L{dns._EDNSMessage} APIs which are not shared with L{dns.Message}. c C s | j dddd� dS )zt L{dns._EDNSMessage.ednsVersion} defaults to C{0} and can be overridden in the constructor. r� r Nr r r r r r �test_ednsVersionL r! z*EDNSMessageSpecificsTests.test_ednsVersionc C r" )zu L{dns._EDNSMessage.dnssecOK} defaults to C{False} and can be overridden in the constructor. r� Fr# Nr$ r r r r r� S r% z'EDNSMessageSpecificsTests.test_dnssecOKc C r" )zz L{dns._EDNSMessage.authenticData} defaults to C{False} and can be overridden in the constructor. r Fr# Nr$ r r r r r� Z r% z,EDNSMessageSpecificsTests.test_authenticDatac C r" )z} L{dns._EDNSMessage.checkingDisabled} defaults to C{False} and can be overridden in the constructor. r, Fr# Nr$ r r r r r� a r% z/EDNSMessageSpecificsTests.test_checkingDisabledc C s. | j t�d�gd�}| �|jt�d�g� dS )zS L{dns._EDNSMessage.queries} can be overridden in the constructor. r r� N)rs r ro r rn rQ r r r �test_queriesOverrideh s z.EDNSMessageSpecificsTests.test_queriesOverridec C �B | j tjdt�d�d�gd�}| �|jtjdt�d�d�g� dS )zS L{dns._EDNSMessage.answers} can be overridden in the constructor. r rl r_ r� N)rs r rq rv r rp rQ r r r �test_answersOverridep s ��z.EDNSMessageSpecificsTests.test_answersOverridec C sF | j tjdtjt�� d�gd�}| �|jtjdtjt�� d�g� dS )�U L{dns._EDNSMessage.authority} can be overridden in the constructor. r r� r� N)rs r rq r� r� r rM rQ r r r �test_authorityOverride| s ���z0EDNSMessageSpecificsTests.test_authorityOverridec C r0 )r2 r rl r_ r� N)rs r rq rv r rs rQ r r r �test_additionalOverride� s ��z1EDNSMessageSpecificsTests.test_additionalOverridec C � | � dt| �� �� dS )z� L{dns._EDNSMessage.__repr__} omits field values and sections which are identical to their defaults. The id field value is always shown. z<_EDNSMessage id=0>N�r r3 rs r r r r r4 � r5 z+EDNSMessageSpecificsTests.test_reprDefaultsc C s. | j ddddddddd�}| �dt|�� dS )zR L{dns._EDNSMessage.__repr__} displays flags if they are L{True}. T)r6 r7 r8 r9 r: r r, r� z`<_EDNSMessage id=0 flags=answer,auth,trunc,recDes,recAv,authenticData,checkingDisabled,dnssecOK>N�rs r r3 r' r r r r< � s � �z-EDNSMessageSpecificsTests.test_reprFlagsIfSetc C s( | j dddddd�}| �dt|�� dS ) zp L{dns._EDNSMessage.__repr__} displays field values if they differ from their defaults. r7 r| r= r> r� )r? r@ rA rB r� zA<_EDNSMessage id=10 opCode=20 rCode=30 maxSize=40 ednsVersion=50>Nr7 r' r r r rC � s �z2EDNSMessageSpecificsTests.test_reprNonDefautFieldsc C sD | � � }g d�|_g d�|_g d�|_g d�|_| �dt|�� dS )rD rE rF rH rK zc<_EDNSMessage id=0 queries=[1, 2, 3] answers=[4, 5, 6] authority=[7, 8, 9] additional=[10, 11, 12]>N)rs rn rp rM rs r r3 r' r r r rN � rO z5EDNSMessageSpecificsTests.test_reprNonDefaultSectionsc C sP G dd� d�}t �� }||_t� }| �t|j|�}| �|fi f|j|j f� dS )z� L{dns._EDNSMessage.fromString} calls L{dns._EDNSMessage._messageFactory} to create a new L{dns.Message} instance which is used to decode the supplied bytes. c @ r) )zUEDNSMessageSpecificsTests.test_fromStrCallsMessageFactory.<locals>.FakeMessageFactory�/ Fake message factory. c _ s t ||��)z� Fake fromStr method which raises the arguments it was passed. @param args: positional arguments @param kwargs: keyword arguments �r� r� r r r rm � s z]EDNSMessageSpecificsTests.test_fromStrCallsMessageFactory.<locals>.FakeMessageFactory.fromStrN�r& r' r( r/ rm r r r r �FakeMessageFactory� r0 r; N) r r* �_messageFactoryr2 r" r� rm r rq rr )r r; r( � dummyBytesr� r r r � test_fromStrCallsMessageFactory� s z9EDNSMessageSpecificsTests.test_fromStrCallsMessageFactoryc sf t �� }G dd� d�}|� � � fdd�|_dd� }||_| �t|jd�}| �� fi f|j|j f� dS ) z~ L{dns._EDNSMessage.fromString} calls L{dns._EDNSMessage._fromMessage} with a L{dns.Message} instance c @ r) )zREDNSMessageSpecificsTests.test_fromStrCallsFromMessage.<locals>.FakeMessageFactoryr8 c S s dS )zw A noop fake version of fromStr @param bytes: the bytes to be decoded Nr )r rP r r r rm � zZEDNSMessageSpecificsTests.test_fromStrCallsFromMessage.<locals>.FakeMessageFactory.fromStrNr: r r r r r; � r0 r; c � � S r� r r �� fakeMessager r �<lambda> r? zHEDNSMessageSpecificsTests.test_fromStrCallsFromMessage.<locals>.<lambda>c _ � t | |��r� r9 r� r r r �fakeFromMessage r zOEDNSMessageSpecificsTests.test_fromStrCallsFromMessage.<locals>.fakeFromMessager� N) r r* r< � _fromMessager" r� rm r rq rr )r r( r; rE r� r rA r � test_fromStrCallsFromMessage� s z6EDNSMessageSpecificsTests.test_fromStrCallsFromMessagec C s@ t �� }dd� }||_| �t|j�}| �di f|j|jf� dS )zP L{dns._EDNSMessage.toStr} calls L{dns._EDNSMessage._toMessage} c _ rD r� r9 r� r r r � fakeToMessage r zIEDNSMessageSpecificsTests.test_toStrCallsToMessage.<locals>.fakeToMessager N) r r* � _toMessager" r� rw r rq rr )r r( rH r� r r r �test_toStrCallsToMessage s z2EDNSMessageSpecificsTests.test_toStrCallsToMessagec sF t �� }t� �G �fdd�d�� � fdd�}||_| ��|�� � dS )z} L{dns._EDNSMessage.toStr} calls C{toStr} on the message returned by L{dns._EDNSMessage._toMessage}. c s e Zd ZdZ� fdd�ZdS )zLEDNSMessageSpecificsTests.test_toStrCallsToMessageToStr.<locals>.FakeMessagez& Fake Message c r@ )zk Fake toStr which returns dummyBytes. @return: dummyBytes r r �r= r r rw . s zREDNSMessageSpecificsTests.test_toStrCallsToMessageToStr.<locals>.FakeMessage.toStrN)r& r' r( r/ rw r rK r r � FakeMessage) s rL c s � � S r� r r� )rL r r rH 6 s zNEDNSMessageSpecificsTests.test_toStrCallsToMessageToStr.<locals>.fakeToMessageN)r r* r2 rI r rw )r r( rH r )rL r= r � test_toStrCallsToMessageToStr! s z7EDNSMessageSpecificsTests.test_toStrCallsToMessageToStrN)r& r' r( r/ r r* rs r. r� r� r� r/ r1 r3 r4 r4 r< rC rN r> rG rJ rM r r r r r- B s& r- c @ s� e Zd ZdZejZdd� Zdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$S )%�EDNSMessageEqualityTestsz� Tests for equality between L{dns._EDNSMessage} instances. These tests will not work with L{dns.Message} because it does not use L{twisted.python.util.FancyEqMixin}. c C rt )zc Two L{dns._EDNSMessage} instances compare equal if they have the same id. r� ru r� Nrv r r r r rx H ry z EDNSMessageEqualityTests.test_idc C rt )zl Two L{dns._EDNSMessage} instances compare equal if they have the same answer flag. Trz FNrv r r r r r{ S ry z$EDNSMessageEqualityTests.test_answerc C s0 | � | jtjd�| jtjd�| jtjd�� dS )zg Two L{dns._EDNSMessage} instances compare equal if they have the same opCode. r| N)rw rs r r� � OP_INVERSEr r r r r} ^ s �z$EDNSMessageEqualityTests.test_opCodec C rt )zj Two L{dns._EDNSMessage} instances compare equal if they have the same auth flag. Tr� FNrv r r r r r� i ry z"EDNSMessageEqualityTests.test_authc C rt )zk Two L{dns._EDNSMessage} instances compare equal if they have the same trunc flag. Tr� FNrv r r r r r� t ry z#EDNSMessageEqualityTests.test_truncc C rt )zl Two L{dns._EDNSMessage} instances compare equal if they have the same recDes flag. Tr~ FNrv r r r r r ry z$EDNSMessageEqualityTests.test_recDesc C rt )zk Two L{dns._EDNSMessage} instances compare equal if they have the same recAv flag. Tr� FNrv r r r r r� � ry z#EDNSMessageEqualityTests.test_recAvc C rt )zf Two L{dns._EDNSMessage} instances compare equal if they have the same rCode. r, r� r Nrv r r r r r� � ry z#EDNSMessageEqualityTests.test_rCodec C s* | � | jdd�| jdd�| jdd�� dS )zl Two L{dns._EDNSMessage} instances compare equal if they have the same ednsVersion. r� �r� Nrv r r r r r. � ry z)EDNSMessageEqualityTests.test_ednsVersionc C rt )zi Two L{dns._EDNSMessage} instances compare equal if they have the same dnssecOK. Tr� FNrv r r r r r� � ry z&EDNSMessageEqualityTests.test_dnssecOKc C rt )zt Two L{dns._EDNSMessage} instances compare equal if they have the same authenticData flags. Tr FNrv r r r r r� � ry z+EDNSMessageEqualityTests.test_authenticDatac C rt )zw Two L{dns._EDNSMessage} instances compare equal if they have the same checkingDisabled flags. Tr. FNrv r r r r r� � ry z.EDNSMessageEqualityTests.test_checkingDisabledc C rt )zh Two L{dns._EDNSMessage} instances compare equal if they have the same maxSize. i r� r Nrv r r r r r� � ry z%EDNSMessageEqualityTests.test_maxSizec C r� )zh Two L{dns._EDNSMessage} instances compare equal if they have the same queries. r r� r� Nr� r r r r r� � r� z%EDNSMessageEqualityTests.test_queriesc C r� )zh Two L{dns._EDNSMessage} instances compare equal if they have the same answers. r rl r_ r� r� r� Nr� r r r r r� � r� z%EDNSMessageEqualityTests.test_answersc C r� )zr Two L{dns._EDNSMessage} instances compare equal if they have the same authority records. r r� r� r� Nr� r r r r r� � r� z'EDNSMessageEqualityTests.test_authorityc C r� )zs Two L{dns._EDNSMessage} instances compare equal if they have the same additional records. r rl r_ r� r� Nr� r r r r r� r� z(EDNSMessageEqualityTests.test_additionalN)r& r' r( r/ r r* rs rx r{ r} r� r� r r� r� r. r� r� r� r� r� r� r� r� r r r r rN > s( rN c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�StandardEncodingTestsMixina� Tests for the encoding and decoding of various standard (not EDNS) messages. These tests should work with both L{dns._EDNSMessage} and L{dns.Message}. TestCase classes that use this mixin must provide a C{messageFactory} method which accepts any argment supported by L{dns._EDNSMessage.__init__}. EDNS specific arguments may be discarded if not supported by the message class under construction. c C �( | � | jdi t�� ���� t�� � dS )z2 An empty message can be encoded. Nr )r rs r� rr rw rP r r r r �test_emptyMessageEncode/ s �z2StandardEncodingTestsMixin.test_emptyMessageEncodec C �6 | � � }|�t�� � | �|| j di t�� ��� dS )z@ An empty message byte sequence can be decoded. Nr )rs rm r� rP r rr r' r r r �test_emptyMessageDecode7 s z2StandardEncodingTestsMixin.test_emptyMessageDecodec C rR )zA A fully populated query message can be encoded. Nr )r rs r� rr rw rP r r r r �test_completeQueryEncode@ s �z3StandardEncodingTestsMixin.test_completeQueryEncodec C s8 | � � }|�t�� �f | �|| j di t�� ��� dS )zG A fully populated message byte string can be decoded. Nr )rs rm r� rP r rr r' r r r �test_completeQueryDecodeI s z3StandardEncodingTestsMixin.test_completeQueryDecodec C s� d� dd� td�D ��}t�|�}tjdtj|d�}| �� }|j�|� |� � }| �� }|� |� | � |jd j tj� | � |jd j j |� dS ) zu A I{NULL} record with an arbitrary payload can be encoded and decoded as part of a message. r� c S rW r rX rY r r r r\ W r] z8StandardEncodingTestsMixin.test_NULL.<locals>.<listcomp>rS r^ r_ r N)r` r� r r� rq ra rs rp rb rw rm rN rk r rc r r r r� R s z$StandardEncodingTestsMixin.test_NULLc C rR )zv If the message C{authoritative} attribute is set to 0, the encoded bytes will have AA bit 0. Nr )r rs r� rr rw rP r r r r �"test_nonAuthoritativeMessageEncoded � �z=StandardEncodingTestsMixin.test_nonAuthoritativeMessageEncodec C rT )z� The L{dns.RRHeader} instances created by a message from a non-authoritative message byte string are marked as not authoritative. Nr )rs rm r� rP r rr r' r r r �"test_nonAuthoritativeMessageDecoden � z=StandardEncodingTestsMixin.test_nonAuthoritativeMessageDecodec C rR )zv If the message C{authoritative} attribute is set to 1, the encoded bytes will have AA bit 1. Nr )r rs r� rr rw rP r r r r � test_authoritativeMessageEncodex rY z:StandardEncodingTestsMixin.test_authoritativeMessageEncodec C rT )z� The message and its L{dns.RRHeader} instances created by C{decode} from an authoritative message byte string, are marked as authoritative. Nr )rs rm r� rP r rr r' r r r � test_authoritativeMessageDecode� r[ z:StandardEncodingTestsMixin.test_authoritativeMessageDecodec C rR )zm If the message C{trunc} attribute is set to 1 the encoded bytes will have TR bit 1. Nr )r rs r� rr rw rP r r r r �test_truncatedMessageEncode� rY z6StandardEncodingTestsMixin.test_truncatedMessageEncodec C rT )zn The message instance created by decoding a truncated message is marked as truncated. Nr )rs rm r� rP r rr r' r r r �test_truncatedMessageDecode� r[ z6StandardEncodingTestsMixin.test_truncatedMessageDecodeN)r& r' r( r/ rS rU rV rW r� rX rZ r\ r] r^ r_ r r r r rQ " s rQ c @ r' )� EDNSMessageStandardEncodingTestszq Tests for the encoding and decoding of various standard (non-EDNS) messages by L{dns._EDNSMessage}. Nr) r r r r r` � r+ r` c @ s e Zd ZdZedd� �ZdS )� MessageStandardEncodingTestszl Tests for the encoding and decoding of various standard (non-EDNS) messages by L{dns.Message}. c K sl | � dg �}| � dg �}| � dg �}| � dg �}| � dd� tjdi | ��}||_||_||_||_t|�S )a� This function adapts constructor arguments expected by _EDNSMessage.__init__ to arguments suitable for use with the Message.__init__. Also handles the fact that unlike L{dns._EDNSMessage}, L{dns.Message.__init__} does not accept queries, answers etc as arguments. Also removes any L{dns._EDNSMessage} specific arguments. @param args: The positional arguments which will be passed to L{dns.Message.__init__}. @param kwargs: The keyword arguments which will be stripped of EDNS specific arguments before being passed to L{dns.Message.__init__}. @return: An L{dns.Message} instance. rn rp rM rs r� Nr )rp r r_ rn rp rM rs r )rr rn rp rM rs r( r r r rs � s z+MessageStandardEncodingTests.messageFactoryN)r& r' r( r/ � staticmethodrs r r r r ra � s ra c @ sf e Zd ZdZejZdd� Zdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� ZdS )� EDNSMessageEDNSEncodingTestszz Tests for the encoding and decoding of various EDNS messages. These test will not work with L{dns.Message}. c C s( | � � }|�t�� � | �|jg � dS )z� The L(_EDNSMessage} instance created by L{dns._EDNSMessage.decode} from an EDNS query never includes OPT records in the additional section. N)rs rm r rP r rs r' r r r �&test_ednsMessageDecodeStripsOptRecords� s zCEDNSMessageEDNSEncodingTests.test_ednsMessageDecodeStripsOptRecordsc C sH t �� }t jdd�t jdd�g|_t �� }|�|�� � | �|j� dS )a An L(_EDNSMessage} instance created from a byte string containing multiple I{OPT} records will discard all the C{OPT} records. C{ednsVersion} will be set to L{None}. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.1} r� r� r� N) r r_ r� rs r* rm rw � assertIsNoner� )r r( � ednsMessager r r �(test_ednsMessageDecodeMultipleOptRecords� s zEEDNSMessageEDNSEncodingTests.test_ednsMessageDecodeMultipleOptRecordsc C sj t �� }|�t�� � t j�|�}g }dD ]}t||�t||�u r&|�|� q|r3| � d|f � dS dS )z� L{dns._EDNSMessage._fromMessage} returns an L{_EDNSMessage} instance whose queries, answers, authority and additional lists are copies (not references to) the original message lists. )rn rp rM rs z\Message and _EDNSMessage shared references to the following section lists after decoding: %sN) r r_ rm r rP r* rF r rb �fail)r �standardMessagerf � duplicatesr r r r � test_fromMessageCopiesSections� s ����z;EDNSMessageEDNSEncodingTests.test_fromMessageCopiesSectionsc C s& t jdd�}|�� | �|jg � dS )zf L{dns._EDNSMessage.toStr} makes no in place changes to the message instance. r� rP N)r r* rw r rs )r rf r r r � test_toMessageCopiesSections s z9EDNSMessageEDNSEncodingTests.test_toMessageCopiesSectionsc C s� t � }tjdd�}|�|� t�� }|�d� |�|� t�� }|g|_g }|� tj � |�j � |j� tjtj d�� |� tj � |�j � |j�dtjtj d�� |� tj � |�j � | �dgd |� dS )a L{dns._EDNSMessage} can decode OPT records, regardless of their position in the additional records section. "The OPT RR MAY be placed anywhere within the additional data section." @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.1} r� r� r )rf r� N)r r r� rW rq r� rS r_ rs rb r* rF r� rt �insertr )r r� � optRecord� optRRHeaderr( �actualMessagesr r r �test_optHeaderPosition s z3EDNSMessageEDNSEncodingTests.test_optHeaderPositionc C rT )z� The L(_EDNSMessage} instance created by L{dns._EDNSMessage.fromStr} derives its edns specific values (C{ednsVersion}, etc) from the supplied OPT record. Nr )rs rm r rP r rr r' r r r �test_ednsDecode9 s z,EDNSMessageEDNSEncodingTests.test_ednsDecodec C rR )z� The L(_EDNSMessage} instance created by L{dns._EDNSMessage.toStr} encodes its edns specific values (C{ednsVersion}, etc) into an OPT record added to the additional section. Nr )r rs r rr rw rP r r r r �test_ednsEncodeD � �z,EDNSMessageEDNSEncodingTests.test_ednsEncodec C rR )z� The L(_EDNSMessage.toStr} encodes the extended I{RCODE} (>=16) by assigning the lower 4bits to the message RCODE field and the upper 4bits to the OPT pseudo record. Nr )r rs r rr rw rP r r r r �test_extendedRcodeEncodeO rt z5EDNSMessageEDNSEncodingTests.test_extendedRcodeEncodec C rT )z� The L(_EDNSMessage} instance created by L{dns._EDNSMessage.fromStr} derives RCODE from the supplied OPT record. Nr )rs rm r rP r rr r' r r r �test_extendedRcodeDecodeZ r[ z5EDNSMessageEDNSEncodingTests.test_extendedRcodeDecodec C s4 | j ddd�}|�� }| �d|j|jd jf� dS )z� Note that EXTENDED-RCODE value 0 indicates that an unextended RCODE is in use (values 0 through 15). https://tools.ietf.org/html/rfc6891#section-6.1.3 r r )rA r� )r r N)rs rI r rA rs r� )r rf ri r r r �test_extendedRcodeZerod s �z3EDNSMessageEDNSEncodingTests.test_extendedRcodeZeroN)r& r' r( r/ r r* rs rd rg rk rl rq rr rs ru rv rw r r r r rc � s rc c @ r� )�ResponseFromMessageTestsz0 Tests for L{dns._responseFromMessage}. c C s( t �� }t jt j|d�}| �||� dS )z� L{dns.Message._responseFromMessage} is a constructor function which generates a new I{answer} message from an existing L{dns.Message} like instance. ��responseConstructorrk N)r r_ �_responseFromMessage� assertIsNot�r �request�responser r r �$test_responseFromMessageResponseTypey s �z=ResponseFromMessageTests.test_responseFromMessageResponseTypec C s0 G dd� d�}t j}| �t j||� d�|� dS )zN L{dns._responseFromMessage} returns a new instance of C{cls} c @ s e Zd ZdZg ZdS )zAResponseFromMessageTests.test_responseType.<locals>.SuppliedClassr� N)r& r' r( r? rn r r r r � SuppliedClass� s r� ry N)r r_ rN r{ )r r� � expectedClassr r r �test_responseType� s ��z*ResponseFromMessageTests.test_responseTypec C s& | � dtjtjtjdd�d�j� dS )zi L{dns._responseFromMessage} copies the C{id} attribute of the original message. i� ru ry N)r r r{ r_ r? r r r r �test_responseId� s ��z(ResponseFromMessageTests.test_responseIdc C s0 t �� }t jt j|d�}| �d|j|jf� dS )zP L{dns._responseFromMessage} sets the C{answer} flag to L{True} ry )FTN)r r_ r{ r r6 r} r r r �test_responseAnswer� s �z,ResponseFromMessageTests.test_responseAnswerc C sD t �� }t� t� t� g}|dd� |_| �|t jt j|d�j� dS )zn L{dns._responseFromMessage} copies the C{queries} attribute of the original message. Nry )r r_ r2 rn r r{ )r r~ �expectedQueriesr r r �test_responseQueries� s ��z-ResponseFromMessageTests.test_responseQueriesc C s$ | � dtjtjt�� dd�j� dS )z� L{dns._responseFromMessage} accepts other C{kwargs} which are assigned to the new message before it is returned. rL )rz rk rA N)r r r{ r_ rA r r r r �test_responseKwargs� s ��z,ResponseFromMessageTests.test_responseKwargsN) r& r' r( r/ r� r� r� r� r� r� r r r r rx t s rx c @ s4 e Zd ZdZ d dd �Zd efd d �ZdS )�Fooz� An example class for use in L{dns._compactRepr} tests. It follows the pattern of initialiser settable flags, fields and sections found in L{dns.Message} and L{dns._EDNSMessage}. r� r� �ASTFNc C s4 || _ || _|| _|| _|| _|du rg }|| _dS )zK Set some flags, fields and sections as public attributes. N)�field1�field2�alwaysShowField�flagTrue� flagFalse�section1)r r� r� r� r� r� r� r r r r� � s z Foo.__init__�returnc C s* t ttj| d�� d�� d�� d�� d��S )zO Call L{dns._compactRepr} to generate a string representation. r� z field1 field2 alwaysShowFieldzflagTrue flagFalsezsection1 section2)� alwaysShow� fieldNames� flagNames� sectionNames)r �strr � _compactRepr�splitr r r r �__repr__� s ��z Foo.__repr__)r� r� r� TFN)r& r' r( r/ r� r� r� r r r r r� � s �r� c @ s4 e Zd ZdZeZdd� Zdd� Zdd� Zdd � Z d S ) �CompactReprTestsz( Tests for L{dns._compactRepr}. c C r5 )z� L{dns._compactRepr} omits field values and sections which have the default value. Flags which are True are always shown. z)<Foo alwaysShowField='AS' flags=flagTrue>Nr6 r r r r � test_defaults� s �z CompactReprTests.test_defaultsc C s" | j ddd�}| �dt|�� dS )zV L{dns._compactRepr} displays flags if they have a non-default value. T)r� r� z3<Foo alwaysShowField='AS' flags=flagTrue,flagFalse>Nr7 r' r r r �test_flagsIfSet s �z CompactReprTests.test_flagsIfSetc C s" | j ddd�}| �dt|�� dS )zg L{dns._compactRepr} displays field values if they differ from their defaults. r7 r| )r� r� z=<Foo field1=10 field2=20 alwaysShowField='AS' flags=flagTrue>Nr7 r' r r r �test_nonDefautFields s �z%CompactReprTests.test_nonDefautFieldsc C s0 | � � }g d�|_g d�|_| �dt|�� dS )zY L{dns._compactRepr} displays sections which differ from their defaults. )r� r� r� )r� r� r� zO<Foo alwaysShowField='AS' flags=flagTrue section1=[1, 1, 1] section2=[2, 2, 2]>N)rs r� �section2r r3 r' r r r �test_nonDefaultSections! s �z(CompactReprTests.test_nonDefaultSectionsN) r& r' r( r/ r� rs r� r� r� r� r r r r r� � s r� r� )hr/ r� �ior �typingr �zope.interface.verifyr �twisted.internetr r �twisted.internet.errorr r � twisted.namesr �twisted.python.failurer �twisted.python.utilr r � twisted.testr �twisted.test.testutilsr � twisted.trialr r� r� r� r� r� r r r r rv r� r� r� r� r� r� r r r r r� r� r� r� r rr r� �SynchronousTestCaser �TestCaser* r1 rK r� r# r0 r ro r� r� r� r� r� r& rS r] rp rr rs r� r� r� � Exceptionr� r� r� r� r� r� r r r r r r r r( r, r- rN rQ r` ra rc rx r� r� r r r r �<module> s� � % > N e� � u eaT ".3_5 iP.-11r;; �.* f� � } e � �, V-PK Mb�Z�ѽ � / names/test/__pycache__/__init__.cpython-310.pycnu �[��� o �b � @ s d Z dS )zTests for twisted.namesN)�__doc__� r r �=/usr/lib/python3/dist-packages/twisted/names/test/__init__.py�<module> s PK Mb�Z��q��W �W 7 names/test/__pycache__/test_rootresolve.cpython-310.pycnu �[��� o �b4d � @ s� d Z ddlmZ ddlmZ ddlmZmZmZm Z ddl m Z ddl m Z mZ ddlmZmZmZmZmZmZmZmZmZmZmZmZm Z m Z ddl m Z m Z dd l!m"Z" dd l#m$Z$ dd l%m&Z& dd l'm(Z( dd l)m*Z*m+Z+ dd� Z,dd� Z-G dd� de+�Z.G dd� de/�Z0dd� Z1G dd� de+�Z2g d�Z3ee �G dd � d ��Z4ee e4� G d d � d e*�Z5G d d � d �Z6e(j7e8d!d"�Z9d#S )$z. Test cases for Twisted.names' root resolver. � )� implementer)� verifyClass)�Deferred� TimeoutError� gatherResults�succeed)�IResolverSimple)�client�root)�CNAME�ENAME�HS�IN�NS�OK�A�Message�Name�Query�Record_A� Record_CNAME� Record_NS�RRHeader)� DNSNameError� ResolverError)�Resolver)� MemoryReactor)�msg)�util)�SynchronousTestCase�TestCasec C s | \}}}|d j S )z� From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, return the payload of the first record in the answer section. r ��payload��results�ans�auth�add� r( �E/usr/lib/python3/dist-packages/twisted/names/test/test_rootresolve.py� getOnePayload& s r* c C s t | ��� S )z� From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, return the first IPv4 address from the answer section. )r* � dottedQuad�r$ r( r( r) � getOneAddress/ s r- c @ s� e Zd ZdZdd� Zdd� Zdd� Zg g g efdd �Zd&d d �Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%S )'�RootResolverTestsz3 Tests for L{twisted.names.root.Resolver}. c C s� t � }tg |d�}|�tdtt�dgd|�}|j�� \}}|j\\}}t � } | � |� | � | j tdtt�g� | � | j g � | � | jg � | � | jg � g } |�| j� | � | g � | j dd�= d| _| j �tdtd�d�� |j�| �� d� | d S ) aK Invoke L{Resolver._query} and verify that it sends the correct DNS query. Deliver a canned response to the query and return whatever the L{Deferred} returned by L{Resolver._query} fires with. @param filter: The value to pass for the C{filter} parameter to L{Resolver._query}. )�reactor� foo.example.com)�1.1.2.3i )� N� � 5.8.13.21r! r )r r �_queryr r r �udpPorts�popitem� _sentPacketsr �fromStr� assertEqual�queries�answers� authority� additional� addCallback�append�answerr r � _protocol�datagramReceived�toStr) �self�filterr/ �resolver�d� portNumber� transport�packet�address�message�responser( r( r) � _queryTest< s. � �z RootResolverTests._queryTestc C sJ | � d�\}}}| �|tdtddd�d�g� | �|g � | �|g � dS )a) L{Resolver._query} accepts a L{Query} instance and an address, issues the query, and returns a L{Deferred} which fires with the response to the query. If a true value is passed for the C{filter} parameter, the result is a three-tuple of lists of records. Tr0 r4 r ��ttlr! N)rO r: r r )rE rA r= r> r( r( r) �test_filteredQueryg s � z$RootResolverTests.test_filteredQueryc C sd | � d�}| �|t� | �|jg � | �|jtdtddd�d�g� | �|jg � | �|j g � dS )z� Similar to L{test_filteredQuery}, but for the case where a false value is passed for the C{filter} parameter. In this case, the result is a L{Message} instance. Fr0 r4 r rP r! N) rO �assertIsInstancer r: r; r< r r r= r> )rE rM r( r( r) �test_unfilteredQueryu s �z&RootResolverTests.test_unfilteredQueryc C sH t |d�}|j|f|j|f|j|ffD ]\}}|�dd� |D �� q|S )a� Create a L{Message} suitable for use as a response to a query. @param answers: A C{list} of two-tuples giving data for the answers section of the message. The first element of each tuple is a name for the L{RRHeader}. The second element is the payload. @param authority: A C{list} like C{answers}, but for the authority section of the response. @param additional: A C{list} like C{answers}, but for the additional section of the response. @param rCode: The response code the message will be created with. @return: A new L{Message} initialized with the given values. )�rCodec S s* g | ]\}}t ||jt|d t�|d��qS )�CLASSr! )r �TYPE�getattrr )�.0�name�recordr( r( r) � <listcomp>� s ���z.RootResolverTests._respond.<locals>.<listcomp>)r r< r= r> �extend)rE r< r= r> rU rN �section�datar( r( r) �_respond� s ���zRootResolverTests._respond� c s( dg}t ||�}� �fdd�}||_|S )a� Create and return a new L{root.Resolver} modified to resolve queries against the record data represented by C{servers}. @param serverResponses: A mapping from dns server addresses to mappings. The inner mappings are from query two-tuples (name, type) to dictionaries suitable for use as **arguments to L{_respond}. See that method for details. r1 c sl t d| j� d|��� |D ]&}z�| }W n ty Y q w || jj| jf }t� jdi |��� S d S )NzQuery for QNAME z at r( )r rZ �KeyError�typer r` )�query�serverAddresses�timeoutrF �addr�server�records�rE �serverResponsesr( r) rd � s ��z-RootResolverTests._getResolver.<locals>.query)r r5 )rE rk �maximumQueries�rootsrG rd r( rj r) � _getResolver� s z RootResolverTests._getResolverc C sr dt fdtd�fgdtd�fgd�idt fddtd�fgiid�}| �|�}|�d�}|�t� |�| jd� |S )a L{root.Resolver.lookupAddress} looks up the I{A} records for the specified hostname by first querying one of the root servers the resolver was created with and then following the authority delegations until a result is received. r0 � ns1.example.com� 34.55.89.144�r= r> r< �10.0.0.1)�r1 �5 )rp rt �r r r rn � lookupAddressr? r- r: �rE �serversrG rH r( r( r) �test_lookupAddress� s ����� z$RootResolverTests.test_lookupAddressc C s� t d�}t|_dtfd|fgdtd�fgdt d�fgd�idtfddt d�fgiid�}| �|�}|�d�}|�t� |�| j t d�� |S ) z� If a response includes a record with a class different from the one in the query, it is ignored and lookup continues until a record with the right class is found. rr r0 ro �10.0.0.2)r< r= r> r< �10.0.0.3)rs �rz rt ) r r rV r r rn rv r? r* r: )rE �badClassrx rG rH r( r( r) �test_lookupChecksClass� s$ ����� z(RootResolverTests.test_lookupChecksClassc C s| dt fddtd�fgidt fddtd�fgiidt fddtd�fgiid�}| �|�}|�d�}|�t� |�| jd� |S )z� If an intermediate response includes no glue records for the authorities, separate queries are made to find those addresses. r0 r= s ns1.example.orgr< rr rz )rs )rr rt ru rw r( r( r) �test_missingGlue� s" ��� ��� z"RootResolverTests.test_missingGluec C s4 ddt fdtiii}| �|�}|�d�}| �|t�S )z� If a name is missing, L{Resolver.lookupAddress} returns a L{Deferred} which fails with L{DNSNameError}. rs r0 rU )r r rn rv � assertFailurer rw r( r( r) �test_missingName s ��� z"RootResolverTests.test_missingNamec C s0 ddt fi ii}| �|�}|�d�}| �|t�S )z� If a query is responded to with no answers or nameserver records, the L{Deferred} returned by L{Resolver.lookupAddress} fires with L{ResolverError}. rs � example.com)r rn rv r� r rw r( r( r) �test_answerless s �� z!RootResolverTests.test_answerlessc C sJ ddt fddtd�fgidt fdtiii}| �|�}|�d�}| �|t�S )z� If there is an error resolving the nameserver in a delegation response, the L{Deferred} returned by L{Resolver.lookupAddress} fires with that error. rs r� r= ro rU )r r r rn rv r� r rw r( r( r) �test_delegationLookupError. s ���� z,RootResolverTests.test_delegationLookupErrorc C sF ddt fddtd�fgidt fi ii}| �|�}|�d�}| �|t�S )z� If there are no records in the response to a lookup of a delegation nameserver, the L{Deferred} returned by L{Resolver.lookupAddress} fires with L{ResolverError}. rs r� r= ro )r r rn rv r� r rw r( r( r) �test_delegationLookupEmptyB s ��� z,RootResolverTests.test_delegationLookupEmptyc C sf ddt fdtidtfddtd�fgiii}| �|�}|�d�}dd� }|�|� |�| jtd�� |S )z� L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except it queries for I{NS} records instead of I{A} records. rs r� rU r< ro c S s | \}}}|d j jS �Nr )r" rZ r# r( r( r) � getOneNamef s z<RootResolverTests.test_lookupNameservers.<locals>.getOneName) r r r r rn �lookupNameserversr? r: r )rE rx rG rH r� r( r( r) �test_lookupNameserversT s ���� z(RootResolverTests.test_lookupNameserversc C s| ddt fddtd�fdtd�fgiii}| �|�}|�d�}|�dd� � |�| jtdttd�d�tdt td�d�g� |S ) z� If a I{CNAME} record is encountered as the answer to a query for another record type, that record is returned as the answer. rs r� r< � example.netz10.0.0.7c S � | d S r� r( r, r( r( r) �<lambda> � z<RootResolverTests.test_returnCanonicalName.<locals>.<lambda>r! � r r r rn rv r? r: r r rw r( r( r) �test_returnCanonicalNamen s& ���� ��z*RootResolverTests.test_returnCanonicalNamec C s� ddt fddtd�fgidt fddtd�fgiii}| �|�}|�d�}|�dd� � |�| jtdttd�d�tdt td�d�g� |S ) z� If no record of the requested type is included in a response, but a I{CNAME} record for the query name is included, queries are made to resolve the value of the I{CNAME}. rs r� r< r� z10.0.0.5c S r� r� r( r, r( r( r) r� � r� z<RootResolverTests.test_followCanonicalName.<locals>.<lambda>r! r� rw r( r( r) �test_followCanonicalName� s& ���� ��z*RootResolverTests.test_followCanonicalNamec C sH ddt fddtd�fdtd�fgiii}| �|�}|�d�}| �|t�S )z� If there is a cycle between I{CNAME} records in a response, this is detected and the L{Deferred} returned by the lookup method fails with L{ResolverError}. rs r� r< r� )r r rn rv r� r rw r( r( r) � test_detectCanonicalNameLoop� s ���� z.RootResolverTests.test_detectCanonicalNameLoopc C s� dt fddtd�fgidt fddtd�fgiidt fdtd�fgdtd�fgd�idt fddtd �fgiid �}| �|d �}| �|�d�t�}| �|d �}|�d�}|�t� |�| j td �� t ||g�S ) z� L{Resolver.lookupAddress} won't issue more queries following delegations than the limit passed to its initializer. r� r= ro r< rz s ns2.example.comr{ rq z10.0.0.4)rs r| )r{ rt � � ) r r r rn r� rv r r? r* r: r )rE rx �failer�failD� succeeder�succeedDr( r( r) �test_boundedQueries� s0 ��� �� ��� ! z%RootResolverTests.test_boundedQueriesN)ra )�__name__� __module__� __qualname__�__doc__rO rR rT r r` rn ry r~ r r� r� r� r� r� r� r� r� r� r( r( r( r) r. 7 s& + r. c @ � e Zd ZdZdd� ZdS )�ResolverFactoryArgumentszf Raised by L{raisingResolverFactory} with the *args and **kwargs passed to that function. c C s || _ || _dS )z� Store the supplied args and kwargs as attributes. @param args: Positional arguments. @param kwargs: Keyword arguments. N��args�kwargs)rE r� r� r( r( r) �__init__� � z!ResolverFactoryArguments.__init__N)r� r� r� r� r� r( r( r( r) r� � � r� c O s t | |��)a= Raise a L{ResolverFactoryArguments} exception containing the positional and keyword arguments passed to resolverFactory. @param args: A L{list} of all the positional arguments supplied by the caller. @param kwargs: A L{list} of all the keyword arguments supplied by the caller. )r� r� r( r( r) �raisingResolverFactory� s r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � RootResolverResolverFactoryTestsz6 Tests for L{root.Resolver._resolverFactory}. c C s t dgtd�}| �|jt� dS )z� L{root.Resolver.__init__} accepts a C{resolverFactory} argument and assigns it to C{self._resolverFactory}. N)�hints�resolverFactory)r r� �assertIs�_resolverFactory�rE �rr( r( r) �#test_resolverFactoryArgumentPresent s zDRootResolverResolverFactoryTests.test_resolverFactoryArgumentPresentc C s t dgd�}| �|jtj � dS )z� L{root.Resolver.__init__} sets L{client.Resolver} as the C{_resolverFactory} if a C{resolverFactory} argument is not supplied. N)r� )r r� r� r r� r( r( r) �"test_resolverFactoryArgumentAbsent s zCRootResolverResolverFactoryTests.test_resolverFactoryArgumentAbsentc C sJ t � }tdgt|d�}| �t|jd�}| �d|dgd�f|j|jf� dS )zy L{root.Resolver._resolverFactory} is supplied with C{reactor} and C{servers} keyword arguments. � 192.0.2.101)r� r� r/ z example.comr( )r� rt )r/ rx N) �objectr r� � assertRaisesr� rv r: r� r� )rE � dummyReactorr� �er( r( r) �)test_resolverFactoryOnlyExpectedArguments s � �zJRootResolverResolverFactoryTests.test_resolverFactoryOnlyExpectedArgumentsN)r� r� r� r� r� r� r� r( r( r( r) r� s r� ) za.root-servers.netzb.root-servers.netzc.root-servers.netzd.root-servers.netze.root-servers.netzf.root-servers.netzg.root-servers.netzh.root-servers.netzi.root-servers.netzj.root-servers.netzk.root-servers.netzl.root-servers.netzm.root-servers.netc @ s e Zd ZdZdd� Zdd� ZdS )� StubResolverz� An L{IResolverSimple} implementer which traces all getHostByName calls and their deferred results. The deferred results can be accessed and fired synchronously. c C s g | _ g | _dS )z� @type calls: L{list} of L{tuple} containing C{args} and C{kwargs} supplied to C{getHostByName} calls. @type pendingResults: L{list} of L{Deferred} returned by C{getHostByName}. N)�calls�pendingResults)rE r( r( r) r� L r� zStubResolver.__init__c O s& | j �||f� t� }| j�|� |S )al A fake implementation of L{IResolverSimple.getHostByName} @param args: A L{list} of all the positional arguments supplied by the caller. @param kwargs: A L{list} of all the keyword arguments supplied by the caller. @return: A L{Deferred} which may be fired later from the test fixture. )r� r@ r r� )rE r� r� rH r( r( r) � getHostByNameV s zStubResolver.getHostByNameN)r� r� r� r� r� r� r( r( r( r) r� D s r� c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�BootstrapTestsz% Tests for L{root.bootstrap} c C s t �t� �}| �|t j� dS )zl L{root.bootstrap} returns an object which is initially a L{root.DeferredResolver}. N)r � bootstrapr� rS �DeferredResolver)rE �deferredResolverr( r( r) � test_returnsDeferredResolverq s z+BootstrapTests.test_returnsDeferredResolverc C s, t � }t�|� | �|jdd� tD �� dS )z� The L{IResolverSimple} supplied to L{root.bootstrap} is used to lookup the IP addresses of the 13 root name servers. c S s g | ]}|fi f�qS r( r( )rY �sr( r( r) r\ � s z=BootstrapTests.test_resolves13RootServers.<locals>.<listcomp>N)r� r r� r: r� � ROOT_SERVERS)rE � stubResolverr( r( r) �test_resolves13RootServersy s z)BootstrapTests.test_resolves13RootServersc C s6 t � }t�|�}|jD ]}|�d� q | �|t� dS )z� The L{root.DeferredResolver} initially returned by L{root.bootstrap} becomes a L{root.Resolver} when the supplied resolver has successfully looked up all root hints. r� N)r� r r� r� �callbackrS r �rE r� r� rH r( r( r) �test_becomesResolver� s z#BootstrapTests.test_becomesResolverc C s> t � }t�|�}|jD ]}|�d� q | �|jdgd � dS )z� The L{root.Resolver} which eventually replaces L{root.DeferredResolver} is supplied with the IP addresses of the 13 root servers. r� � N)r� r r� r� r� r: r� r� r( r( r) � test_resolverReceivesRootHints� s z-BootstrapTests.test_resolverReceivesRootHintsc s^ t � }t�|�� t|j�}t|�}|D ]}|�d� q|�t� � � �fdd�}|� |� dS )z� The L{root.Resolver} is eventually created, even if some of the root hint lookups fail. Only the working root hint IP addresses are supplied to the L{root.Resolver}. r� c s �� � jdgd � d S )Nr� � �r: r� ��res�r� rE r( r) � checkHints� s zFBootstrapTests.test_continuesWhenSomeRootHintsFail.<locals>.checkHintsN) r� r r� �iterr� �nextr� �errbackr �addBoth�rE r� r$ �d1rH r� r( r� r) �#test_continuesWhenSomeRootHintsFail� s z2BootstrapTests.test_continuesWhenSomeRootHintsFailc sn t � }t�|�� t|j�}t|�}|D ]}|�t� � q|�t� � � �fdd�}|�|� �� �j t� dS )z� The L{root.Resolver} is eventually created, even if all of the root hint lookups fail. Pending and new lookups will then fail with AttributeError. c s �� � jg � d S �Nr� r� r� r( r) r� � s zEBootstrapTests.test_continuesWhenAllRootHintsFail.<locals>.checkHintsN) r� r r� r� r� r� r� r r� � addCleanup�flushLoggedErrorsr� r( r� r) �"test_continuesWhenAllRootHintsFail� s z1BootstrapTests.test_continuesWhenAllRootHintsFailc C s< t � }tj|td�}|jD ]}|�d� q | �|jt� dS )z� L{root.bootstrap} accepts a C{resolverFactory} argument which is passed as an argument to L{root.Resolver} when it has successfully looked up root hints. )r� r� N)r� r r� r� r� r� r� r� r� r( r( r) �test_passesResolverFactory� s � z)BootstrapTests.test_passesResolverFactoryN) r� r� r� r� r� r� r� r� r� r� r� r( r( r( r) r� l s r� c @ r� )�StubDNSDatagramProtocolz� A do-nothing stand-in for L{DNSDatagramProtocol} which can be used to avoid network traffic in tests where that kind of thing doesn't matter. c O s t � S r� )r )rE �a�kwr( r( r) rd � s z StubDNSDatagramProtocol.queryN)r� r� r� r� rd r( r( r( r) r� � r� r� zbtwisted.names.root.retry is deprecated since Twisted 10.0. Use a Resolver object for retry logic.)�categoryrM N):r� �zope.interfacer �zope.interface.verifyr �twisted.internet.deferr r r r �twisted.internet.interfacesr � twisted.namesr r �twisted.names.dnsr r r r r r r r r r r r r r �twisted.names.errorr r �twisted.names.rootr � twisted.names.test.test_utilr �twisted.python.logr � twisted.trialr �twisted.trial.unittestr r r* r- r. � Exceptionr� r� r� r� r� r� r� �suppress�DeprecationWarning�_retrySuppressionr( r( r( r) �<module> s@ @ 6* $f �PK Mb�ZS>�� � 0 names/test/__pycache__/test_util.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z m Z ddlmZ ee �G d d � d ��Zee e� ee �G d d � d e��Zee e� d S )z$ Utilities for Twisted.names tests. � )� randrange)� implementer)� verifyClass)� IPv4Address)�succeed)� IReactorUDP� IUDPTransport)�Clockc @ sJ e Zd ZdZdd� Zdd� Zdd� Zdd d �Zd d � Zd d� Z dd� Z dS )�MemoryDatagramTransporta� This L{IUDPTransport} implementation enforces the usual connection rules and captures sent traffic in a list for later inspection. @ivar _host: The host address to which this transport is bound. @ivar _protocol: The protocol connected to this transport. @ivar _sentPackets: A C{list} of two-tuples of the datagrams passed to C{write} and the addresses to which they are destined. @ivar _connectedTo: L{None} if this transport is unconnected, otherwise an address to which all traffic is supposedly sent. @ivar _maxPacketSize: An C{int} giving the maximum length of a datagram which will be successfully handled by C{write}. c C s" || _ || _g | _d | _|| _d S �N)�_host� _protocol� _sentPackets� _connectedTo�_maxPacketSize)�self�host�protocol� maxPacketSize� r �>/usr/lib/python3/dist-packages/twisted/names/test/test_util.py�__init__& s z MemoryDatagramTransport.__init__c C s t dg| j�R � S )z_ Return the address which this transport is pretending to be bound to. �UDP)r r �r r r r �getHost- s z MemoryDatagramTransport.getHostc C s | j dur td��||f| _ dS )z> Connect this transport to the given address. NzAlready connected)r � ValueError)r r �portr r r �connect4 s z MemoryDatagramTransport.connectNc C sH |du r| j }|du rtd��t|�| jkrtd��| j�||f� dS )z* Send the given datagram. NzNeed an addresszPacket too big)r r �lenr r �append)r �datagram�addrr r r �write< s z MemoryDatagramTransport.writec C s | j �� td�S )z+ Shut down this transport. N)r � stopProtocolr r r r r � stopListeningH s z%MemoryDatagramTransport.stopListeningc C � dS �zC Dummy implementation to satisfy L{IUDPTransport}. Nr )r �enabledr r r �setBroadcastAllowedO � z+MemoryDatagramTransport.setBroadcastAllowedc C r% r& r r r r r �getBroadcastAllowedU r) z+MemoryDatagramTransport.getBroadcastAllowedr ) �__name__� __module__� __qualname__�__doc__r r r r" r$ r( r* r r r r r s r c @ s" e Zd ZdZdd� Zd dd�ZdS ) � MemoryReactoraO An L{IReactorTime} and L{IReactorUDP} provider. Time is controlled deterministically via the base class, L{Clock}. UDP is handled in-memory by connecting protocols to instances of L{MemoryDatagramTransport}. @ivar udpPorts: A C{dict} mapping port numbers to instances of L{MemoryDatagramTransport}. c C s t �| � i | _d S r )r r �udpPortsr r r r r l s zMemoryReactor.__init__� � c C s\ |dkr t dd�}|| jvrnq|| jv rtd��t||f||�}|| j|< |�|� |S )zR Pretend to bind a UDP port and connect the given protocol to it. r T� i zAddress in use)r r0 r r �makeConnection)r r r � interfacer � transportr r r � listenUDPp s � zMemoryReactor.listenUDPN)r1 r2 )r+ r, r- r. r r7 r r r r r/ _ s r/ N)r. �randomr �zope.interfacer �zope.interface.verifyr �twisted.internet.addressr �twisted.internet.deferr �twisted.internet.interfacesr r �twisted.internet.taskr r r/ r r r r �<module> s G!PK Mb�Z ^��r� r� 2 names/test/__pycache__/test_client.cpython-310.pycnu �[��� o �b � � @ s� d Z ddlZddlmZmZ ddlmZ ddlmZm Z ddl m Z ddl m Z ddlmZ dd lmZmZmZmZmZ dd lmZ dd lmZ dd lmZ dd l m Z ddl m Z ddl m!Z! ddl"m#Z# ddl$m%Z% ddl&m'Z' e#�(� sydZ)ndZ)G dd� de�Z*G dd� d�Z+G dd� d�Z,G dd� de'j-�Z.G d d � d e'j-e �Z/G d d � d e'j-�Z0G d d!� d!e'j-�Z1G d"d#� d#e'j-�Z2G d$d%� d%�Z3G d&d'� d'e'j-�Z4G d(d)� d)e'j-�Z5dS )*z) Test cases for L{twisted.names.client}. � N)� verifyClass� verifyObject)�defer)�CannotListenError�ConnectionRefusedError)� IResolver)�Clock)�AlternateReactor)�cache�client�dns�error�hosts)� ResolverBase)�DNSQueryTimeoutError)� test_util)�GoodTempPathMixin)�failure)�FilePath)�platform)� proto_helpers)�unittestz:These tests need more work before they'll work on Windows.c @ s e Zd Zdd� ZdS )� FakeResolverc C sZ |dkrt j|t j|dt jddd�d�}n t j|||dd�}|g}g }g }t�|||f�S )z� The getHostByNameTest does a different type of query that requires it return an A record from an ALL_RECORDS lookup, so we accommodate that here. � getHostByNameTest�< � 127.0.0.1)�address�ttl)�name�type�clsr �payload)r r r r )r �RRHeader�A�Record_Ar �succeed) �selfr r �qtype�timeout�rr�results� authority� additional� r- �@/usr/lib/python3/dist-packages/twisted/names/test/test_client.py�_lookup$ s �zFakeResolver._lookupN)�__name__� __module__� __qualname__r/ r- r- r- r. r # s r c @ s e Zd ZdZdZdd� ZdS )�StubPortz� A partial implementation of L{IListeningPort} which only keeps track of whether it has been stopped. @ivar disconnected: A C{bool} which is C{False} until C{stopListening} is called, C{True} afterwards. Fc C s d| _ d S )NT)� disconnected�r& r- r- r. � stopListeningF s zStubPort.stopListeningN)r0 r1 r2 �__doc__r4 r6 r- r- r- r. r3 ; s r3 c @ s" e Zd ZdZdd� Zddd�ZdS ) �StubDNSDatagramProtocolz� L{dns.DNSDatagramProtocol}-alike. @ivar queries: A C{list} of tuples giving the arguments passed to C{query} along with the L{defer.Deferred} which was returned from the call. c C � g | _ t� | _d S �N��queriesr3 � transportr5 r- r- r. �__init__S � z StubDNSDatagramProtocol.__init__� Nc C s" t �� }| j�|||||f� |S )zv Record the given arguments and return a Deferred which will not be called back by this code. )r �Deferredr< �append)r& r r< r( �id�resultr- r- r. �queryW s z StubDNSDatagramProtocol.query�r@ N)r0 r1 r2 r7 r> rE r- r- r- r. r8 J s r8 c @ s$ e Zd ZdZeZdd� Zdd� ZdS )�GetResolverTestsz* Tests for L{client.getResolver}. c C sF t t� �� t�� }W d � n1 sw Y | �tt|�� dS )zQ L{client.getResolver} returns an object providing L{IResolver}. N)r r r � getResolver� assertTruer r �r& �resolverr- r- r. �test_interfaceh s �z GetResolverTests.test_interfacec C sJ t t� �� t�� }t�� }W d � n1 sw Y | �||� dS )zn Multiple calls to L{client.getResolver} return the same L{IResolver} implementation. N)r r r rH �assertIs)r& �a�br- r- r. �test_idempotentp s �z GetResolverTests.test_idempotentN)r0 r1 r2 r7 � windowsSkip�skiprL rP r- r- r- r. rG a s rG c @ sd e Zd ZdZeZdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dd� Zdd� ZdS )�CreateResolverTestsz- Tests for L{client.createResolver}. c C s6 dd� |j D �}| �dt|�� | �|d j|� d S )Nc S � g | ] }t |tj�r|�qS r- )� isinstancer �Resolver��.0�rr- r- r. � <listcomp>� � z2CreateResolverTests._hostsTest.<locals>.<listcomp>� r )� resolvers� assertEqual�len�file�r& rK �filename�resr- r- r. � _hostsTest� s z CreateResolverTests._hostsTestc C �B t t� �� t�� }W d � n1 sw Y | �|d� dS )z� L{client.createResolver} returns a L{resolve.ResolverChain} including a L{hosts.Resolver} using I{/etc/hosts} if no alternate hosts file is specified. Ns /etc/hosts�r r r �createResolverrd rJ r- r- r. �test_defaultHosts� � �z%CreateResolverTests.test_defaultHostsc C �F t t� �� tjdd�}W d � n1 sw Y | �|d� dS )z� The I{hosts} parameter to L{client.createResolver} overrides the hosts file used by the L{hosts.Resolver} in the L{resolve.ResolverChain} it returns. � /foo/bar)r Nrf rJ r- r- r. �test_overrideHosts� � �z&CreateResolverTests.test_overrideHostsc C s6 dd� |j D �}| �dt|�� | �|d j|� dS )z| Verify that C{resolver} has a L{client.Resolver} with a configuration filename set to C{filename}. c S rT r- �rU r rV rW r- r- r. rZ � r[ z7CreateResolverTests._resolvConfTest.<locals>.<listcomp>r\ r N)r] r^ r_ �resolvra r- r- r. �_resolvConfTest� s z#CreateResolverTests._resolvConfTestc C sl t � }t|�� t�� }W d � n1 sw Y dd� |jD �}| �dt|�� | �||d j� dS )z� The L{client.Resolver} included in the L{resolve.ResolverChain} returned by L{client.createResolver} uses the global reactor. Nc S rT r- rn rW r- r- r. rZ � r[ z4CreateResolverTests.test_reactor.<locals>.<listcomp>r\ r ) r r r rg r] r^ r_ rM �_reactor)r& �reactorrK rc r- r- r. � test_reactor� s �z CreateResolverTests.test_reactorc C re )z� L{client.createResolver} returns a L{resolve.ResolverChain} including a L{client.Resolver} using I{/etc/resolv.conf} if no alternate resolver configuration file is specified. Ns /etc/resolv.conf�r r r rg rp rJ r- r- r. �test_defaultResolvConf� ri z*CreateResolverTests.test_defaultResolvConfc C rj )z� The I{resolvconf} parameter to L{client.createResolver} overrides the resolver configuration file used by the L{client.Resolver} in the L{resolve.ResolverChain} it returns. rk �� resolvconfNrt rJ r- r- r. �test_overrideResolvConf� rm z+CreateResolverTests.test_overrideResolvConfc C s� | � � }|�d� tt� �� tj|j d�}W d � n1 s w Y dd� |jD �}| �dt|�� | �g |d j � | �dg|d j � dS ) z� If no servers are given, addresses are taken from the file given by the I{resolvconf} parameter to L{client.createResolver}. � nameserver 127.1.2.3 rv Nc S rT r- rn rW r- r- r. rZ � r[ z;CreateResolverTests.test_defaultServers.<locals>.<listcomp>r\ r �z 127.1.2.3�5 � �path� setContentr r r rg r] r^ r_ �servers� dynServers�r& rw rK rc r- r- r. �test_defaultServers� s �z'CreateResolverTests.test_defaultServersc C s� | � � }|�d� tt� �� tjdg|j d�}W d � n1 s"w Y dd� |jD �}| �dt|�� | �dg|d j � | �d g|d j � dS ) z� Servers passed to L{client.createResolver} are used in addition to any found in the file given by the I{resolvconf} parameter. ry )z 127.3.2.1r{ )r rw Nc S rT r- rn rW r- r- r. rZ � r[ z<CreateResolverTests.test_overrideServers.<locals>.<listcomp>r\ r rz r| r� r- r- r. �test_overrideServers� s � �z(CreateResolverTests.test_overrideServersc C sV t t� �� t�� }W d � n1 sw Y dd� |jD �}| �dt|�� dS )zy L{client.createResolver} returns a L{resolve.ResolverChain} including a L{cache.CacheResolver}. Nc S rT r- )rU r � CacheResolverrW r- r- r. rZ � r[ z2CreateResolverTests.test_cache.<locals>.<listcomp>r\ )r r r rg r] r^ r_ )r& rK rc r- r- r. � test_cache� s �z CreateResolverTests.test_cacheN)r0 r1 r2 r7 rQ rR rd rh rl rp rs ru rx r� r� r� r- r- r- r. rS { s rS c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:S );� ResolverTestsz' Tests for L{client.Resolver}. c C s t tt� dS )z] L{client} provides L{IResolver} through a series of free functions. N)r r r r5 r- r- r. � test_clientProvidesIResolver� s z*ResolverTests.test_clientProvidesIResolverc C s t ttj� dS )z; L{client.Resolver} provides L{IResolver}. N)r r r rV r5 r- r- r. �$test_clientResolverProvidesIResolver� � z2ResolverTests.test_clientResolverProvidesIResolverc C s | � ttj� dS )z� L{client.Resolver} raises L{ValueError} if constructed with neither servers nor a nameserver configuration file. N)� assertRaises� ValueErrorr rV r5 r- r- r. �test_noServers� s z ResolverTests.test_noServersc C s( t j| �� t� d�}| �dg|j� dS )z� A missing nameserver configuration file results in no server information being loaded from it (ie, not an exception) and a default server being provided. �ro rr �r r{ N)r rV �mktempr r^ r� rJ r- r- r. �test_missingConfiguration s z'ResolverTests.test_missingConfigurationc sR t | �� �}|jdd�� G � fdd�dtj�}|ddgdt� d� | �� j� d S ) z� As part of its constructor, C{StubResolver} opens C{/etc/resolv.conf}; then, explicitly closes it and does not count on the GC to do so for it. zw+)�modec � e Zd Z� fdd�ZdS )z9ResolverTests.test_closesResolvConf.<locals>.StubResolverc � � S r: r- )r& r �� resolvConfr- r. � _openFile s zCResolverTests.test_closesResolvConf.<locals>.StubResolver._openFileN)r0 r1 r2 r� r- r� r- r. � StubResolver � r� � example.comr{ z/etc/resolv.conf)r ro rr N)r r� �openr rV r rI �closed)r& �handler� r- r� r. �test_closesResolvConf s �z#ResolverTests.test_closesResolvConfc C s, t jdgd�}|�dg� | �d|j� dS )z� L{client.Resolver.parseConfig} treats a I{domain} line without an argument as indicating a domain of C{b""}. r� �r s domain � N)r rV � parseConfigr^ �domainrJ r- r- r. �test_domainEmptyArgument! � z&ResolverTests.test_domainEmptyArgumentc C s, t jdgd�}|�dg� | �g |j� dS )z� L{client.Resolver.parseConfig} treats a I{search} line without an argument as indicating an empty search suffix. r� r� s search N)r rV r� r^ �searchrJ r- r- r. �test_searchEmptyArgument* r� z&ResolverTests.test_searchEmptyArgumentc sd t � � ddg}ddg}tj|d�}||_� fdd�|_t� }|�d�}|�| j|� | �t � j �d � | � � j d d |d � � j d d � t d �� | �t � j �d � | � � j d d |d � � j d d � t d �� | �t � j �d � | � � j d d |d � � j d d � t d �� | �t � j �d� | � � j d d |d � � j d d �|� |S )a L{client.Resolver.queryUDP} should issue queries to its L{dns.DNSDatagramProtocol} with server addresses taken from its own C{servers} and C{dynServers} lists, proceeding through them in order as L{DNSQueryTimeoutError}s occur. �z::1r{ )z::2r{ )z::3r{ )z::4r{ r� c r� r: r- )� interface��protocolr- r. �<lambda>@ � z=ResolverTests.test_datagramQueryServerOrder.<locals>.<lambda>Nr\ r ���� � � )r8 r rV r� �_connectedProtocol�object�queryUDP� addCallbackr^ r_ r< rM �errbackr �callback)r& r r� rK �expectedResult� queryResultr- r� r. � test_datagramQueryServerOrder3 s, z+ResolverTests.test_datagramQueryServerOrderc s� t � �tjdgd�}�fdd�|_�j}t�dtjtj�}|� |�}�� t |�d� |� |�}�� t |�d� t � � t� � }|j�� � |�� d �|� t�||g�}� �fdd �}|�|� |S ) z� L{client.Resolver.query} only issues one request at a time per query. Subsequent requests made before responses to prior ones are received are queued and given the same response as is given to the first one. �r� r{ r� c r� r: r- r- r� r- r. r� ] r� z<ResolverTests.test_singleConcurrentRequest.<locals>.<lambda>� foo.example.comr\ r� c s4 | \}}�� |� gg g f� �� |� gg g f� d S r: �r^ )� responses� firstResponse�secondResponse)�answerr& r- r. � cbFinishedr s z>ResolverTests.test_singleConcurrentRequest.<locals>.cbFinished)r8 r rV r� r< r �Queryr# �INrE r^ r_ r� �Message�answersrB �popr� r � gatherResultsr� ) r& rK r< rE � firstResult� secondResult�response�dr� r- )r� r� r& r. � test_singleConcurrentRequestU s" z*ResolverTests.test_singleConcurrentRequestc s� t � � tjdgd�}� fdd�|_� j}t�dtj�}|�|� | � t |�d� t�dtj�}|�|� | � t |�d� t�dtj �}|�|� | � t |�d � d S ) zh L{client.Resolver.query} issues a request for each different concurrent query. r� r� c r� r: r- r- r� r- r. r� � r� z?ResolverTests.test_multipleConcurrentRequests.<locals>.<lambda>r� r\ � bar.example.comr� r� N) r8 r rV r� r< r r� r# rE r^ r_ �A6)r& rK r< � firstQuery� secondQuery� thirdQueryr- r� r. � test_multipleConcurrentRequestsz s z-ResolverTests.test_multipleConcurrentRequestsc s� t � � tjdgd�}� fdd�|_� j}t�dtj�}|�|� | � t |�d� |� � d � t� � � |�|� | � t |�d� dS ) z� After a response is received to a query issued with L{client.Resolver.query}, another query with the same parameters results in a new network request. r� r� c r� r: r- r- r� r- r. r� � r� z?ResolverTests.test_multipleSequentialRequests.<locals>.<lambda>r� r\ r� N)r8 r rV r� r< r r� r# rE r^ r_ r� r� r� )r& rK r< rE r- r� r. � test_multipleSequentialRequests� s z-ResolverTests.test_multipleSequentialRequestsc s� t � � tjdgd�}� fdd�|_� j}t�dtj�}|�|�}|�|�}G dd� dt �}|� � d � t � |� �� t�| �||�| �||�g�S ) z� If the result of a request is an error response, the Deferreds for all concurrently issued requests associated with that result fire with the L{Failure}. r� r� c r� r: r- r- r� r- r. r� � r� z>ResolverTests.test_multipleConcurrentFailure.<locals>.<lambda>r� c @ � e Zd ZdS )zGResolverTests.test_multipleConcurrentFailure.<locals>.ExpectedExceptionN�r0 r1 r2 r- r- r- r. �ExpectedException� � r� r� )r8 r rV r� r< r r� r# rE � Exceptionr� r� r �Failurer r� � assertFailure)r& rK r< rE r� r� r� r- r� r. � test_multipleConcurrentFailure� s ��z,ResolverTests.test_multipleConcurrentFailurec C st t jdgd�}|�� }|�� }| �|j� | �|j� | �|j�� j|j�� j� t� t� |jj �t� |jj �g�S )z� L{client.Resolver._connectedProtocol} returns a new L{DNSDatagramProtocol} connected to a new address with a cryptographically secure random port number. r� r� ) r rV r� �assertIsNotNoner= �assertNotEqual�getHost�portr r� � maybeDeferredr6 )r& rK � firstProto� secondProtor- r- r. �test_connectedProtocol� s � ��z$ResolverTests.test_connectedProtocolc C s4 t �� }tj| �� |d�}|�� }| �|j|� dS )z� If a reactor instance is supplied to L{client.Resolver} L{client.Resolver._connectedProtocol} should pass that reactor to L{twisted.names.dns.DNSDatagramProtocol}. r� N)r � MemoryReactorr rV r� r� rM rq )r& rr rK �protor- r- r. �)test_resolverUsesOnlyParameterizedReactor� s z7ResolverTests.test_resolverUsesOnlyParameterizedReactorc sb t jdgd�}g � G � fdd�d�}||_|�t�d�� |�t�d�� | �tt� ��d� dS ) z� L{client.Resolver._connectedProtocol} is called once each time a UDP request needs to be issued and the resulting protocol instance is used for that request. r� r� c s" e Zd Zdd� Zd� fdd� ZdS )z:ResolverTests.test_differentProtocol.<locals>.FakeProtocolc S � t � | _d S r: �r3 r= r5 r- r- r. r> � � zCResolverTests.test_differentProtocol.<locals>.FakeProtocol.__init__r@ Nc s � � | � t�t�� �S r: )rB r r% r r� �r& r rE r( rC �� protocolsr- r. rE � s z@ResolverTests.test_differentProtocol.<locals>.FakeProtocol.queryrF �r0 r1 r2 r> rE r- r� r- r. � FakeProtocol� s r� r� r� r� N) r rV r� rE r r� r^ r_ �set�r& rK r� r- r� r. �test_differentProtocol� s z$ResolverTests.test_differentProtocolc C sR t �� }tjdg|d�}|�t�d�� |j�� \\}}|� � j }| � d|� dS )z< If the resolver is ipv6, open a ipv6 port. r� �r rr r� z::N) r r� r rV rE r r� �udpPorts�itemsr� �hostr^ )r& �fakerK r� r= r� r- r- r. �test_ipv6Resolver s z ResolverTests.test_ipv6Resolverc sL g � G � fdd�d�}t jdgd�}|� |_|�� | �tt� ��d� dS )z� If a port number is initially selected which cannot be bound, the L{CannotListenError} is handled and another port number is attempted. c r� )z6ResolverTests.test_disallowedPort.<locals>.FakeReactorc s& � � |� t� �dkrtd |d ��d S )Nr\ )rB r_ r �r& r� �args�kwargs��portsr- r. � listenUDP s �z@ResolverTests.test_disallowedPort.<locals>.FakeReactor.listenUDPN�r0 r1 r2 r� r- r� r- r. � FakeReactor r� r� r� r� r� N)r rV rq r� r^ r_ r� �r& r� rK r- r� r. �test_disallowedPort s z!ResolverTests.test_disallowedPortc sN g � G � fdd�d�}t jdgd�}|� |_| �t|j� | �t� �d� dS )z� If port numbers that cannot be bound are repeatedly selected, L{resolver._connectedProtocol} will give up eventually. c r� )z@ResolverTests.test_disallowedPortRepeatedly.<locals>.FakeReactorc s � � |� td |d ��r: )rB r r� r� r- r. r� ' s zJResolverTests.test_disallowedPortRepeatedly.<locals>.FakeReactor.listenUDPNr� r- r� r- r. r� & r� r� r� r� i� N)r rV rq r� r r� r^ r_ r� r- r� r. � test_disallowedPortRepeatedly s z+ResolverTests.test_disallowedPortRepeatedlyc s` g � G � fdd�d�}t jdgd�}|� |_| �t|j�}| �|jjtj � | �t � �d� dS )zf If the process is out of files, L{Resolver._connectedProtocol} will give up. c r� )z5ResolverTests.test_runOutOfFiles.<locals>.FakeReactorc s" � � |� ttjd�}td ||��)NzOut of files :()rB �OSError�errno�EMFILEr )r& r� r� r� �errr� r- r. r� : s z?ResolverTests.test_runOutOfFiles.<locals>.FakeReactor.listenUDPNr� r- r� r- r. r� 9 r� r� r� r� r\ N) r rV rq r� r r� r^ � socketErrorr r r_ )r& r� rK �excr- r� r. �test_runOutOfFiles2 s z ResolverTests.test_runOutOfFilesc sv t jdgd�}g � t�t�td���t�t� � �g�G � �fdd�d�}||_ |� t� d�� | � tt� ��d� dS )z| When a query issued by L{client.Resolver.query} times out, the retry uses a new protocol instance. r� r� Nc �$ e Zd Zdd� Zd� �fdd� ZdS )zFResolverTests.test_differentProtocolAfterTimeout.<locals>.FakeProtocolc S r� r: r� r5 r- r- r. r> U r� zOResolverTests.test_differentProtocolAfterTimeout.<locals>.FakeProtocol.__init__r@ Nc � � � | � ��d�S �Nr �rB r� r� �r� r* r- r. rE X � zLResolverTests.test_differentProtocolAfterTimeout.<locals>.FakeProtocol.queryrF r� r- r r- r. r� T � r� r� r� )r rV r �failr r� r r% r r� r� rE r� r^ r_ r� r� r- r r. �"test_differentProtocolAfterTimeoutH s �z0ResolverTests.test_differentProtocolAfterTimeoutc sz t jdgd�}g � t�� �G � �fdd�d�}||_|�t�d�� | �� d j j � �� t� � � | � � d j j � dS )z� After the L{Deferred} returned by L{DNSDatagramProtocol.query} is called back, the L{DNSDatagramProtocol} is disconnected from its transport. r� r� c r )z9ResolverTests.test_protocolShutDown.<locals>.FakeProtocolc S r� r: r� r5 r- r- r. r> k r� zBResolverTests.test_protocolShutDown.<locals>.FakeProtocol.__init__r@ Nc � � � | � �S r: �rB r� �r� rD r- r. rE n � z?ResolverTests.test_protocolShutDown.<locals>.FakeProtocol.queryrF r� r- r r- r. r� j r r� r� r N)r rV r rA r� rE r r� � assertFalser= r4 r� r� rI r� r- r r. �test_protocolShutDown` s z#ResolverTests.test_protocolShutDownc s� t jdgd�}g � t�� }t�t�td���|g�G � �fdd�d�}||_|� t � d�� | � � d j j� |�t �� � | �� d j j� dS )z� The L{DNSDatagramProtocol} created when an interim timeout occurs is also disconnected from its transport after the Deferred returned by its query method completes. r� r� Nc r )zEResolverTests.test_protocolShutDownAfterTimeout.<locals>.FakeProtocolc S r� r: r� r5 r- r- r. r> � r� zNResolverTests.test_protocolShutDownAfterTimeout.<locals>.FakeProtocol.__init__r@ Nc r r r r� r r- r. rE � r zKResolverTests.test_protocolShutDownAfterTimeout.<locals>.FakeProtocol.queryrF r� r- r r- r. r� � r r� r� r\ )r rV r rA r r r� r r� rE r r� r r= r4 r� r� rI )r& rK rD r� r- r r. �!test_protocolShutDownAfterTimeouty s z/ResolverTests.test_protocolShutDownAfterTimeoutc s� G dd� dt �}tjdgd�}g � t�� �G � �fdd�d�}||_|�t�d��}| � � d j j � �� t �|� �� | �� d j j � | �||�S ) z� If the L{Deferred} returned by L{DNSDatagramProtocol.query} fires with a failure, the L{DNSDatagramProtocol} is still disconnected from its transport. c @ r� )zJResolverTests.test_protocolShutDownAfterFailure.<locals>.ExpectedExceptionNr� r- r- r- r. r� � r� r� r� r� c r )zEResolverTests.test_protocolShutDownAfterFailure.<locals>.FakeProtocolc S r� r: r� r5 r- r- r. r> � r� zNResolverTests.test_protocolShutDownAfterFailure.<locals>.FakeProtocol.__init__r@ Nc r r: r r� r r- r. rE � r zKResolverTests.test_protocolShutDownAfterFailure.<locals>.FakeProtocol.queryrF r� r- r r- r. r� � r r� r� r )r� r rV r rA r� rE r r� r r= r4 r� r r� rI r� )r& r� rK r� r� r- r r. �!test_protocolShutDownAfterFailure� s z/ResolverTests.test_protocolShutDownAfterFailurec C sN t jdgd�}|j�d�}|�d� | �||j� |�d� | �||j� dS )z� When a TCP DNS protocol associated with a Resolver disconnects, it is removed from the Resolver's connection list. r� r� N) r rV �factory� buildProtocol�makeConnection�assertIn� connections�connectionLost� assertNotIn)r& rK r� r- r- r. �(test_tcpDisconnectRemovesFromConnections� s z6ResolverTests.test_tcpDisconnectRemovesFromConnectionsc C sv t �� }tjdg|d�}|�t�d��}|jd \}}}}}G dd� dt�} |� |j d t � | � �� | � || � dS )z� The deferred returned by L{client.Resolver.queryTCP} will errback when the TCP connection attempt fails. The reason for the connection failure is passed as the argument to errback. �z 192.0.2.100r{ r� r� r c @ r� )zVResolverTests.test_singleTCPQueryErrbackOnConnectionFailure.<locals>.SentinelExceptionNr� r- r- r- r. �SentinelException� r� r# N)r r� r rV �queryTCPr r� � tcpClientsr� �clientConnectionFailed� connectorsr r� �failureResultOf) r& rr rK r� r� r� r r( � bindAddressr# r- r- r. �-test_singleTCPQueryErrbackOnConnectionFailure� s �z;ResolverTests.test_singleTCPQueryErrbackOnConnectionFailurec C s� t �� }tjdg|d�}|�t�d��}|�t�d��}|jd \}}}}} G dd� dt�} |� |j d t � | � �� | � || �} | � || �} | �| | � dS ) z� All pending L{resolver.queryTCP} C{deferred}s will C{errback} with the same C{Failure} if the connection attempt fails. r" r� r� z example.netr c @ r� )zXResolverTests.test_multipleTCPQueryErrbackOnConnectionFailure.<locals>.SentinelExceptionNr� r- r- r- r. r# � r� r# N)r r� r rV r$ r r� r% r� r& r' r r� r( rM ) r& rr rK �d1�d2r� r� r r( r) r# �f1�f2r- r- r. �/test_multipleTCPQueryErrbackOnConnectionFailure� s � z=ResolverTests.test_multipleTCPQueryErrbackOnConnectionFailurec s t �� }tjdg|d��t�d�� ��� �}� �fdd�}|�|� | �t |j �d� | �t |j �d� |j d \}}}}}t � t� �} |�|j d | � | �t |j �d� | �t |j �d� | �|� t � t� �} |�|j d | � | �|t�} | �| | � d S ) z{ An errback on the deferred returned by L{client.Resolver.queryTCP} may trigger another TCP query. )r iE' r� r� c s | � t� ��� �S r: )�trapr r$ )�e��qrK r- r. �reissue� r zOResolverTests.test_reentrantTCPQueryErrbackOnConnectionFailure.<locals>.reissuer\ r r� N)r r� r rV r r� r$ � addErrbackr^ r_ r% r' r r� r r& �assertNoResultr( rM ) r& rr r� r4 r� r� r r( r) r- r. �fr- r2 r. �0test_reentrantTCPQueryErrbackOnConnectionFailure� s$ z>ResolverTests.test_reentrantTCPQueryErrbackOnConnectionFailurec C s� t �� }tjdg|d�}|�t�d��}|jd \}}}}}|j} | � t | �d� G dd� dt �} |� |j d t�| � �� | �|| � | �|j| � | � t | �d� dS ) z� When the TCP connection attempt fails, the L{client.Resolver.pending} list is emptied in place. It is not replaced with a new empty list. r" r� r� r r\ c @ r� )zJResolverTests.test_pendingEmptiedInPlaceOnError.<locals>.SentinelExceptionNr� r- r- r- r. r# ' r� r# N)r r� r rV r$ r r� r% �pendingr^ r_ r� r& r' r r� r( rM ) r& rr rK r� r� r� r r( r) � prePendingr# r- r- r. �!test_pendingEmptiedInPlaceOnError s � z/ResolverTests.test_pendingEmptiedInPlaceOnErrorN) r0 r1 r2 r7 r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r! r* r/ r8 r; r- r- r- r. r� � s< "% +r� c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Z d5d6� Z d7d8� Z d9d:� Z d;S )<� ClientTestsc C s t � t_d| _d| _dS )z: Replace the resolver with a FakeResolver � example.comr N)r r � theResolver�hostname�hostnameForGetHostByNamer5 r- r- r. �setUp4 s zClientTests.setUpc C s dt _dS )zp By setting the resolver to None, it will be recreated next time a name lookup is done. N)r r> r5 r- r- r. �tearDown< s zClientTests.tearDownc C s6 |\}}}|d }| � |jj| j� | � |j|� dS )zT Verify that the result is the same query type as what is expected. r N)r^ r r? r )r& r* r' r� r+ r, rD r- r- r. � checkResultC s zClientTests.checkResultc C s | � |d� dS )zR Test that the getHostByName query returns the 127.0.0.1 address. r Nr� �r& rD r- r- r. �checkGetHostByNameL r� z ClientTests.checkGetHostByNamec C s t �| j�}|�| j� |S )zM do a getHostByName of a value that should return 127.0.0.1. )r � getHostByNamer@ r� rE �r& r� r- r- r. �test_getHostByNameR s z ClientTests.test_getHostByNamec C � t �| j�}|�| jtj� |S )z� Do a lookup and test that the resolver will issue the correct type of query type. We do this by checking that FakeResolver returns a result record with the same query type as what we issued. )r � lookupAddressr? r� rC r r# rG r- r- r. �test_lookupAddressZ s z ClientTests.test_lookupAddressc C rI �z+ See L{test_lookupAddress} )r �lookupIPV6Addressr? r� rC r �AAAArG r- r- r. �test_lookupIPV6Addressd � z"ClientTests.test_lookupIPV6Addressc C rI rL )r �lookupAddress6r? r� rC r r� rG r- r- r. �test_lookupAddress6l rP z ClientTests.test_lookupAddress6c C rI rL )r �lookupNameserversr? r� rC r �NSrG r- r- r. �test_lookupNameserverst rP z"ClientTests.test_lookupNameserversc C rI rL )r �lookupCanonicalNamer? r� rC r �CNAMErG r- r- r. �test_lookupCanonicalName| rP z$ClientTests.test_lookupCanonicalNamec C rI rL )r �lookupAuthorityr? r� rC r �SOArG r- r- r. �test_lookupAuthority� rP z ClientTests.test_lookupAuthorityc C rI rL )r � lookupMailBoxr? r� rC r �MBrG r- r- r. �test_lookupMailBox� rP z ClientTests.test_lookupMailBoxc C rI rL )r �lookupMailGroupr? r� rC r �MGrG r- r- r. �test_lookupMailGroup� rP z ClientTests.test_lookupMailGroupc C rI rL )r �lookupMailRenamer? r� rC r �MRrG r- r- r. �test_lookupMailRename� rP z!ClientTests.test_lookupMailRenamec C rI rL )r � lookupNullr? r� rC r �NULLrG r- r- r. �test_lookupNull� rP zClientTests.test_lookupNullc C rI rL )r �lookupWellKnownServicesr? r� rC r �WKSrG r- r- r. � test_lookupWellKnownServices� rP z(ClientTests.test_lookupWellKnownServicesc C rI rL )r � lookupPointerr? r� rC r �PTRrG r- r- r. �test_lookupPointer� rP z ClientTests.test_lookupPointerc C rI rL )r �lookupHostInfor? r� rC r �HINFOrG r- r- r. �test_lookupHostInfo� rP z ClientTests.test_lookupHostInfoc C rI rL )r �lookupMailboxInfor? r� rC r �MINFOrG r- r- r. �test_lookupMailboxInfo� rP z"ClientTests.test_lookupMailboxInfoc C rI rL )r �lookupMailExchanger? r� rC r �MXrG r- r- r. �test_lookupMailExchange� rP z#ClientTests.test_lookupMailExchangec C rI rL )r � lookupTextr? r� rC r �TXTrG r- r- r. �test_lookupText� rP zClientTests.test_lookupTextc C rI rL )r �lookupSenderPolicyr? r� rC r �SPFrG r- r- r. �test_lookupSenderPolicy� rP z#ClientTests.test_lookupSenderPolicyc C rI rL )r �lookupResponsibilityr? r� rC r �RPrG r- r- r. �test_lookupResponsibility� rP z%ClientTests.test_lookupResponsibilityc C rI rL )r �lookupAFSDatabaser? r� rC r �AFSDBrG r- r- r. �test_lookupAFSDatabase� rP z"ClientTests.test_lookupAFSDatabasec C rI rL )r � lookupServicer? r� rC r �SRVrG r- r- r. �test_lookupService� rP z ClientTests.test_lookupServicec C rI rL )r � lookupZoner? r� rC r �AXFRrG r- r- r. �test_lookupZone� rP zClientTests.test_lookupZonec C rI rL )r �lookupAllRecordsr? r� rC r � ALL_RECORDSrG r- r- r. �test_lookupAllRecords rP z!ClientTests.test_lookupAllRecordsc C rI rL )r � lookupNamingAuthorityPointerr? r� rC r �NAPTRrG r- r- r. �!test_lookupNamingAuthorityPointer rP z-ClientTests.test_lookupNamingAuthorityPointerc C s. t �| jt j�}t�|�}|�| jt j� |S )a L{client.query} accepts a L{dns.Query} instance and dispatches it to L{client.theResolver}.C{query}, which in turn dispatches to an appropriate C{lookup*} method of L{client.theResolver}, based on the L{dns.Query} type. )r r� r? r# r rE r� rC )r& r3 r� r- r- r. � test_query s zClientTests.test_queryN) r0 r1 r2 rA rB rC rE rH rK rO rR rU rX r[ r^ ra rd rg rj rm rp rs rv ry r| r r� r� r� r� r� r� r- r- r- r. r< 3 s< r< c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�FilterAnswersTestsz| Test L{twisted.names.client.Resolver.filterAnswers}'s handling of various error conditions it might encounter. c C s t jdgd�| _d S )N)z0.0.0.0r r� )r rV rK r5 r- r- r. rA ' s zFilterAnswersTests.setUpc sV t jdd�� � �d� � �fdd�}|�j_�j�� �}|��jdgdgdgf� |S ) zf Test that a truncated message results in an equivalent request made via TCP. T)�truncr= c s8 �� | � j� t�� }dg|_dg|_dg|_t�|�S )Nr� r+ r, ) r^ r< r r� r� r+ r, r r% )r< r� ��mr& r- r. r$ 4 s z:FilterAnswersTests.test_truncatedMessage.<locals>.queryTCPr� r+ r, )r r� �addQueryrK r$ � filterAnswersr� r^ )r& r$ r� r- r� r. �test_truncatedMessage, s z(FilterAnswersTests.test_truncatedMessagec C s& t j|d�}| j�|�}|�|� d S )N)�rCode)r r� rK r� r0 )r& �rcoder r� r r- r- r. � _rcodeTestA s z FilterAnswersTests._rcodeTestc C � | � tjtj�S )z� Test that a message with a result code of C{EFORMAT} results in a failure wrapped around L{DNSFormatError}. )r� r �EFORMATr �DNSFormatErrorr5 r- r- r. �test_formatErrorF s z#FilterAnswersTests.test_formatErrorc C r� )zP Like L{test_formatError} but for C{ESERVER}/L{DNSServerError}. )r� r �ESERVERr �DNSServerErrorr5 r- r- r. �test_serverErrorM r� z#FilterAnswersTests.test_serverErrorc C r� )zL Like L{test_formatError} but for C{ENAME}/L{DNSNameError}. )r� r �ENAMEr � DNSNameErrorr5 r- r- r. �test_nameErrorS r� z!FilterAnswersTests.test_nameErrorc C r� )zX Like L{test_formatError} but for C{ENOTIMP}/L{DNSNotImplementedError}. )r� r �ENOTIMPr �DNSNotImplementedErrorr5 r- r- r. �test_notImplementedErrorY r� z+FilterAnswersTests.test_notImplementedErrorc C r� )zW Like L{test_formatError} but for C{EREFUSED}/L{DNSQueryRefusedError}. )r� r �EREFUSEDr �DNSQueryRefusedErrorr5 r- r- r. �test_refusedError_ r� z$FilterAnswersTests.test_refusedErrorc C s | � tjd tj�S )zm Like L{test_formatError} but for an unrecognized error code and L{DNSUnknownError}. r\ )r� r r� r �DNSUnknownErrorr5 r- r- r. �test_refusedErrorUnknowne s z+FilterAnswersTests.test_refusedErrorUnknownN) r0 r1 r2 r7 rA r� r� r� r� r� r� r� r� r- r- r- r. r� ! s r� c @ s& e Zd Zdd� Zd dd�Zdd� ZdS ) �FakeDNSDatagramProtocolc C r9 r: r; r5 r- r- r. r> n r? z FakeDNSDatagramProtocol.__init__r@ Nc C s$ | j �||||f� t�t�|��S r: )r< rB r r r r )r& r r< r( rC r- r- r. rE r s z FakeDNSDatagramProtocol.queryc C s d S r: r- )r& rC r- r- r. � removeResendv s z$FakeDNSDatagramProtocol.removeResendrF )r0 r1 r2 r> rE r� r- r- r- r. r� m s r� c @ s0 e Zd ZdZg d�Zdd� Zdd� Zdd� Zd S ) �RetryLogicTestszE Tests for query retrying implemented by L{client.Resolver}. )z1.2.3.4z4.3.2.1za.b.c.dzz.y.x.wc sN dd� | j D �}tjd|d�}t� � � fdd�|_|�d��| j��| j � �S )a When timeouts occur waiting for responses to queries, the next configured server is issued the query. When the query has been issued to all configured servers, the timeout is increased and the process begins again at the beginning. c S s g | ]}|d f�qS )r{ r- )rX �xr- r- r. rZ � s z:RetryLogicTests.test_roundRobinBackoff.<locals>.<listcomp>N)ro r c r� r: r- r- �r� r- r. r� � r� z8RetryLogicTests.test_roundRobinBackoff.<locals>.<lambda>r� ) � testServersr rV r� r� rJ r� �_cbRoundRobinBackoffr5 �_ebRoundRobinBackoff)r& �addrsrY r- r� r. �test_roundRobinBackoff� s �z&RetryLogicTests.test_roundRobinBackoffc C s | � d� d S )Nz/Lookup address succeeded, should have timed out)r rD r- r- r. r� � s z$RetryLogicTests._cbRoundRobinBackoffc C s� |� tj� dD ]>}|jd t| j�� }|jd t| j��= |�� t| j�}|�� t||�D ]\\}}}} } | � || df� | � ||� q/q| � |j� d S )N)r\ r� � �- r{ ) r0 r � TimeoutErrorr< r_ r� �sort�list�zipr^ r ) r& r � fakeProto�t�tries�expected�addrrE r( rC � expectedAddrr- r- r. r� � s �z$RetryLogicTests._ebRoundRobinBackoffN)r0 r1 r2 r7 r� r� r� r� r- r- r- r. r� { s r� c @ s e Zd ZdZdd� ZdS )�ThreadedResolverTestsz/ Tests for L{client.ThreadedResolver}. c C sT t �� | j| jgd�}| �|d d d� | �|d d t� | �t|�d� dS )z� L{client.ThreadedResolver} is deprecated. Instantiating it emits a deprecation warning pointing at the code that does the instantiation. )�offendingFunctionsr �messagezztwisted.names.client.ThreadedResolver is deprecated since Twisted 9.0, use twisted.internet.base.ThreadedResolver instead.�categoryr\ N)r �ThreadedResolver� flushWarnings�test_deprecatedr^ �DeprecationWarningr_ )r& �warningsr- r- r. r� � s �z%ThreadedResolverTests.test_deprecatedN)r0 r1 r2 r7 r� r- r- r- r. r� � s r� )6r7 r �zope.interface.verifyr r �twisted.internetr �twisted.internet.errorr r �twisted.internet.interfacesr �twisted.internet.taskr �#twisted.internet.test.modulehelpersr � twisted.namesr r r r r �twisted.names.commonr �twisted.names.errorr �twisted.names.testr � twisted.names.test.test_hostsr �twisted.pythonr �twisted.python.filepathr �twisted.python.runtimer � twisted.testr � twisted.trialr � isWindowsrQ r r3 r8 �TestCaserG rS r� r< r� r� r� r� r- r- r- r. �<module> sJ r J oL0PK Mb�Z�;� u u / names/test/__pycache__/test_tap.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z m Z ddlmZ dd lmZ dd lmZ G d d � d e�Zd S )z! Tests for L{twisted.names.tap}. � )�ThreadedResolver)�Resolver)�PORT)� ResolverChain)�SecondaryAuthorityService)�Options�_buildResolvers)�platform)� UsageError)�SynchronousTestCasec @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � OptionsTestszf Tests for L{Options}, defining how command line arguments for the DNS server are parsed. c C sZ t � }| �t|jddg� | �t|jddg� | �t|jddg� | �t|jddg� dS )z� If the value supplied for an I{--secondary} option does not provide a server IP address, optional port number, and domain name, L{Options.parseOptions} raises L{UsageError}. � --secondary� �1.2.3.4z 1.2.3.4:helloz1.2.3.4:hello/example.comN)r � assertRaisesr � parseOptions��self�options� r �=/usr/lib/python3/dist-packages/twisted/names/test/test_tap.py�test_malformedSecondary s ��z$OptionsTests.test_malformedSecondaryc C s2 t � }|�ddg� | �dtfdgfg|j� dS )z� An argument of the form C{"ip/domain"} is parsed by L{Options} for the I{--secondary} option and added to its list of secondaries, using the default DNS port number. r z1.2.3.4/example.comr � example.comN)r r � assertEqualr � secondariesr r r r �test_secondary+ s zOptionsTests.test_secondaryc C s. t � }|�ddg� | �ddgfg|j� dS )z� An argument of the form C{"ip:port/domain"} can be used to specify an alternate port number for which to act as a secondary. r �1.2.3.4:5353/example.com)r �� r N)r r r r r r r r �test_secondaryExplicitPort5 s z'OptionsTests.test_secondaryExplicitPortc C s� t � }|�g d�� | �t|j�d� |jd }| �|jd t� | �|jd� | �|jd� |jd }| �|jd t� | �|jd� | �|jd� d S ) z� After parsing I{--secondary} options, L{Options} constructs a L{SecondaryAuthorityService} instance for each configured secondary. )r r r z1.2.3.5:5354/example.com� r r r � z1.2.3.5i� N) r r r �len�svcs�assertIsInstancer �primary�_port)r r � secondaryr r r � test_secondaryAuthorityServices> s � z,OptionsTests.test_secondaryAuthorityServicesc C s� t � }|�g d�� t|�\}}|D ]}t|t�r(|jd }t|t�r(|j�� qt � � dkrHddl m } |j D ]}| �|jjtj� |�� q8| �|d t� dS )z� Recursive DNS lookups, if enabled, should be a last-resort option. Any other lookup method (cache, local lookup, etc.) should take precedence over recursive lookups )z --hosts-filez hosts.txtz --recursive����posixr )�reactorN)r r r � isinstancer � resolversr � _parseCall�cancelr �getType�twisted.internetr* �_newTimedCallsr �func�__func__r �_cleanupr# )r r �ca�cl�x�recurserr* r r r �test_recursiveConfigurationV s � z(OptionsTests.test_recursiveConfigurationN) �__name__� __module__� __qualname__�__doc__r r r r' r9 r r r r r s r N)r= �twisted.internet.baser �twisted.names.clientr �twisted.names.dnsr �twisted.names.resolver �twisted.names.secondaryr �twisted.names.tapr r �twisted.python.runtimer �twisted.python.usager �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z�Fa£ £ 2 names/test/__pycache__/test_server.cpython-310.pycnu �[��� o �bǢ � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZm Z m Z m Z ddl m Z mZ ddlmZ G dd � d e�Zd d � ZG d d � d e j�ZG dd� de j�ZG dd� d�ZG dd� d�ZG dd� d�ZG dd� d�Zdd� ZG dd� dej �Z d S ) z) Test cases for L{twisted.names.server}. � )� verifyClass)�defer)�IProtocolFactory)�dns�error�resolve�server)�failure�log)�unittestc @ � e Zd ZdZdd� ZdS )�RaisedArgumentszD An exception containing the arguments raised by L{raiser}. c C s || _ || _d S �N��args�kwargs��selfr r � r �@/usr/lib/python3/dist-packages/twisted/names/test/test_server.py�__init__ s zRaisedArguments.__init__N)�__name__� __module__� __qualname__�__doc__r r r r r r � r c O s t | |��)z� Raise a L{RaisedArguments} exception containing the supplied arguments. Used as a fake when testing the call signatures of methods and functions. )r r r r r �raiser s r c @ s e Zd ZdZdd� Zdd� ZdS )�NoResponseDNSServerFactorya A L{server.DNSServerFactory} subclass which does not attempt to reply to any received messages. Used for testing logged messages in C{messageReceived} without having to fake or patch the preceding code which attempts to deliver a response message. c C � dS )a Deny all queries. @param message: See L{server.DNSServerFactory.allowQuery} @param protocol: See L{server.DNSServerFactory.allowQuery} @param address: See L{server.DNSServerFactory.allowQuery} @return: L{False} @rtype: L{bool} Fr )r �message�protocol�addressr r r � allowQuery. s z%NoResponseDNSServerFactory.allowQueryc C r )z� A noop send reply. @param protocol: See L{server.DNSServerFactory.sendReply} @param message: See L{server.DNSServerFactory.sendReply} @param address: See L{server.DNSServerFactory.sendReply} Nr )r r r r! r r r � sendReply; � z$NoResponseDNSServerFactory.sendReplyN)r r r r r" r# r r r r r $ s r c @ �( e Zd ZdZG dd� de�Zdd� ZdS )�RaisingDNSServerFactoryz� A L{server.DNSServerFactory} subclass whose methods raise an exception containing the supplied arguments. Used for stopping L{messageReceived} and testing the arguments supplied to L{allowQuery}. c @ � e Zd ZdZdS )z+RaisingDNSServerFactory.AllowQueryArguments�G Contains positional and keyword arguments in C{args}. N�r r r r r r r r �AllowQueryArgumentsN � r* c O � | � ||��)aC Raise the arguments supplied to L{allowQuery}. @param args: Positional arguments which will be recorded in the raised exception. @type args: L{tuple} @param kwargs: Keyword args which will be recorded in the raised exception. @type kwargs: L{dict} )r* r r r r r" S s z"RaisingDNSServerFactory.allowQueryN)r r r r � Exceptionr* r" r r r r r& E s r& c @ r% )�RaisingProtocolzm A partial fake L{IProtocol} whose methods raise an exception containing the supplied arguments. c @ r' )z%RaisingProtocol.WriteMessageArgumentsr( Nr) r r r r �WriteMessageArgumentsh r+ r/ c O r, �z� Raises the supplied arguments. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} )r/ r r r r � writeMessagem � z RaisingProtocol.writeMessageN)r r r r r- r/ r1 r r r r r. b � r. c @ r )� NoopProtocolzT A partial fake L{dns.DNSProtocolMixin} with a noop L{writeMessage} method. c O r )z� A noop version of L{dns.DNSProtocolMixin.writeMessage}. @param args: Positional arguments @type args: L{tuple} @param kwargs: Keyword args @type kwargs: L{dict} Nr r r r r r1 r$ zNoopProtocol.writeMessageN)r r r r r1 r r r r r4 z r r4 c @ r% )�RaisingResolverzm A partial fake L{IResolver} whose methods raise an exception containing the supplied arguments. c @ r' )z RaisingResolver.QueryArgumentsr( Nr) r r r r �QueryArguments� r+ r6 c O r, r0 )r6 r r r r �query� r2 zRaisingResolver.queryN)r r r r r- r6 r7 r r r r r5 � r3 r5 c @ r% )� RaisingCachez} A partial fake L{twisted.names.cache.Cache} whose methods raise an exception containing the supplied arguments. c @ r' )z!RaisingCache.CacheResultArgumentsr( Nr) r r r r �CacheResultArguments� r+ r9 c O r, r0 )r9 r r r r � cacheResult� r2 zRaisingCache.cacheResultN)r r r r r- r9 r: r r r r r8 � r3 r8 c O sH g }t �|j� | �t j|j� ||i |�� | �dd� |D �|� dS )a Assert that the callable logs the expected messages when called. XXX: Put this somewhere where it can be re-used elsewhere. See #6677. @param testCase: The test case controlling the test which triggers the logged messages and on which assertions will be called. @type testCase: L{unittest.SynchronousTestCase} @param expectedMessages: A L{list} of the expected log messages @type expectedMessages: L{list} @param callable: The function which is expected to produce the C{expectedMessages} when called. @type callable: L{callable} @param args: Positional arguments to be passed to C{callable}. @type args: L{list} @param kwargs: Keyword arguments to be passed to C{callable}. @type kwargs: L{dict} c S s g | ]}|d d �qS )r r r )�.0�mr r r � <listcomp>� s z$assertLogMessage.<locals>.<listcomp>N)r � addObserver�append� addCleanup�removeObserver� assertEqual)�testCase�expectedMessages�callabler r �loggedMessagesr r r �assertLogMessage� s rG c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@dA� Z#dBdC� Z$dDdE� Z%dFdG� Z&dHdI� Z'dJdK� Z(dLdM� Z)dNdO� Z*dPdQ� Z+dRdS� Z,dTdU� Z-dVdW� Z.dXdY� Z/dZd[� Z0d\d]� Z1d^d_� Z2d`da� Z3dbdc� Z4ddde� Z5dfdg� Z6dhdi� Z7djdk� Z8dldm� Z9dndo� Z:dpdq� Z;drds� Z<dtdu� Z=dvdw� Z>dxdy� Z?dzd{� Z@d|d}� ZAd~d� ZBd�d�� ZCd�S )��DNSServerFactoryTestsz/ Tests for L{server.DNSServerFactory}. c C s | � t�� jtj� dS )zd L{server.DNSServerFactory.resolver} is a L{resolve.ResolverChain} instance N)�assertIsInstancer �DNSServerFactory�resolverr � ResolverChain�r r r r �test_resolverType� � z'DNSServerFactoryTests.test_resolverTypec C s | � t�� jjg � dS )zn L{server.DNSServerFactory.resolver} is an empty L{resolve.ResolverChain} by default. N�rB r rJ rK � resolversrM r r r �test_resolverDefaultEmpty� rO z/DNSServerFactoryTests.test_resolverDefaultEmptyc C �& t � }| �tj|gd�jj|g� dS )z� L{server.DNSServerFactory.__init__} accepts an C{authorities} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. )� authoritiesN��objectrB r rJ rK rQ �r � dummyResolverr r r �test_authorities� � �z&DNSServerFactoryTests.test_authoritiesc C rS )z� L{server.DNSServerFactory.__init__} accepts a C{caches} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. ��cachesNrU rW r r r � test_caches� rZ z!DNSServerFactoryTests.test_cachesc C rS )z� L{server.DNSServerFactory.__init__} accepts a C{clients} argument. The value of this argument is a list and is used to extend the C{resolver} L{resolve.ResolverChain}. ��clientsNrU rW r r r � test_clients rZ z"DNSServerFactoryTests.test_clientsc C sV G dd� d�}G dd� d�}G dd� d�}| � tj|g|g|gd�jj|||g� dS ) zz L{server.DNSServerFactory.resolver} contains an ordered list of authorities, caches and clients. c @ � e Zd ZdS )z@DNSServerFactoryTests.test_resolverOrder.<locals>.DummyAuthorityN�r r r r r r r �DummyAuthority � rc c @ ra )z<DNSServerFactoryTests.test_resolverOrder.<locals>.DummyCacheNrb r r r r � DummyCache rd re c @ ra )z=DNSServerFactoryTests.test_resolverOrder.<locals>.DummyClientNrb r r r r � DummyClient rd rf )rT r\ r_ NrP )r rc re rf r r r �test_resolverOrder s ��z(DNSServerFactoryTests.test_resolverOrderc C � | � t�� j� dS )zI L{server.DNSServerFactory.cache} is L{None} by default. N)� assertIsNoner rJ �cacherM r r r �test_cacheDefault( � z'DNSServerFactoryTests.test_cacheDefaultc C s& t � }| �tjt � |gd�j|� dS )z� L{server.DNSServerFactory.__init__} assigns the last object in the C{caches} list to L{server.DNSServerFactory.cache}. r[ N)rV rB r rJ rj rW r r r �test_cacheOverride. s �z(DNSServerFactoryTests.test_cacheOverridec C rh )z� L{server.DNSServerFactory.canRecurse} is a flag indicating that this server is capable of performing recursive DNS lookups. It defaults to L{False}. N)� assertFalser rJ � canRecurserM r r r �test_canRecurseDefault9 s z,DNSServerFactoryTests.test_canRecurseDefaultc C s | � tjdgd�jd� dS )z~ L{server.DNSServerFactory.__init__} sets C{canRecurse} to L{True} if it is supplied with C{clients}. Nr^ T)rB r rJ ro rM r r r �test_canRecurseOverrideA s z-DNSServerFactoryTests.test_canRecurseOverridec C rh )zJ L{server.DNSServerFactory.verbose} defaults to L{False}. N)rn r rJ �verboserM r r r �test_verboseDefaultH rl z)DNSServerFactoryTests.test_verboseDefaultc C s | � tjdd�j� dS )z� L{server.DNSServerFactory.__init__} accepts a C{verbose} argument which overrides L{server.DNSServerFactory.verbose}. T�rr N)� assertTruer rJ rr rM r r r �test_verboseOverrideN rO z*DNSServerFactoryTests.test_verboseOverridec C s | � tttj�� dS )zL L{server.DNSServerFactory} implements L{IProtocolFactory}. N)ru r r r rJ rM r r r �test_interfaceU � z$DNSServerFactoryTests.test_interfacec C s | � tjjtj� dS )zU L{server.DNSServerFactory.protocol} defaults to L{dns.DNSProtocol}. N)�assertIsr rJ r r � DNSProtocolrM r r r �test_defaultProtocol[ rx z*DNSServerFactoryTests.test_defaultProtocolc s\ G dd� d�}|� � � fdd�}t �� }||_|jdd�}| �� |fi f||j|jf� dS )z� L{server.DNSServerFactory.buildProtocol} builds a protocol by calling L{server.DNSServerFactory.protocol} with its self as a positional argument. c @ s e Zd ZdZdZdZdS )zNDNSServerFactoryTests.test_buildProtocolProtocolOverride.<locals>.FakeProtocolN)r r r �factoryr r r r r r � FakeProtocolh s r} c s | � _ |� _� S r r r �� stubProtocolr r �fakeProtocolFactoryo s zUDNSServerFactoryTests.test_buildProtocolProtocolOverride.<locals>.fakeProtocolFactoryN)�addr)r rJ r � buildProtocolrB r r )r r} r� �f�pr r~ r �"test_buildProtocolProtocolOverridea s "z8DNSServerFactoryTests.test_buildProtocolProtocolOverridec C s t �� }t| g |jd� dS )zm L{server.DNSServerFactory._verboseLog} does not log messages unless C{verbose > 0}. �Foo BarN�r rJ rG � _verboseLog�r r� r r r �test_verboseLogQuietz s z*DNSServerFactoryTests.test_verboseLogQuietc C s" t jdd�}t| dg|jd� dS )zZ L{server.DNSServerFactory._verboseLog} logs a message if C{verbose > 0}. � rt r� Nr� r� r r r �test_verboseLogVerbose� s z,DNSServerFactoryTests.test_verboseLogVerbosec C s. t �� }tdd�}t| dg|j|ddd� dS )z� L{server.DNSServerFactory.messageReceived} logs about an empty query if the message had no queries and C{verbose} is C{>0}. r� rt z$Empty query from ('192.0.2.100', 53)N�z 192.0.2.100�5 �r �protor! )r �Messager rG �messageReceived�r r< r� r r r �"test_messageReceivedLoggingNoQuery� s �z8DNSServerFactoryTests.test_messageReceivedLoggingNoQueryc C �N t �� }|jdt jd� |jdt jd� tdd�}t| dg|j|ddd� dS ) z� L{server.DNSServerFactory.messageReceived} logs the query types of all queries in the message if C{verbose} is set to C{1}. � example.com��name�typer� rt z&MX AAAA query from ('192.0.2.100', 53)Nr� r� �r r� �addQuery�MX�AAAAr rG r� r� r r r � test_messageReceivedLogging1� s �z2DNSServerFactoryTests.test_messageReceivedLogging1c C r� ) z� L{server.DNSServerFactory.messageReceived} logs the repr of all queries in the message if C{verbose} is set to C{2}. r� r� � rt zT<Query example.com MX IN> <Query example.com AAAA IN> query from ('192.0.2.100', 53)Nr� r� r� r� r r r � test_messageReceivedLogging2� s � �z2DNSServerFactoryTests.test_messageReceivedLogging2c sN t �� }t� }t� � | �tjd� fdd�� |j|ddd� | �|j � � dS )zv L{server.DNSServerFactory.messageReceived} assigns a unix timestamp to the received message. �timec � � S r r r ��tr r �<lambda>� r$ zEDNSServerFactoryTests.test_messageReceivedTimestamp.<locals>.<lambda>Nr� ) r r� r rV �patchr r� r� rB � timeReceivedr� r r� r � test_messageReceivedTimestamp� s z3DNSServerFactoryTests.test_messageReceivedTimestampc C s^ t �� }t� }t� }t� }| jtj|j|||d�}|j\}}| �||||f� | �|i � dS )z� L{server.DNSServerFactory.messageReceived} passes all messages to L{server.DNSServerFactory.allowQuery} along with the receiving protocol and origin address. r� N) r r� rV r& � assertRaisesr* r� r rB )r r � dummyProtocol� dummyAddressr� �er r r r r � test_messageReceivedAllowQuery� s � z4DNSServerFactoryTests.test_messageReceivedAllowQueryc sj G dd� dt �� G � fdd�dtj�}|� }| j� |jt�� ddd�}|j\\}}}}| �|j tj � dS )z� If C{allowQuery} returns C{False}, L{server.DNSServerFactory.messageReceived} calls L{server.sendReply} with a message whose C{rCode} is L{dns.EREFUSED}. c @ ra )zFDNSServerFactoryTests.test_allowQueryFalse.<locals>.SendReplyExceptionNrb r r r r �SendReplyException� rd r� c s e Zd Zdd� Z� fdd�ZdS )zKDNSServerFactoryTests.test_allowQueryFalse.<locals>.RaisingDNSServerFactoryc _ r )NFr r r r r r" � � zVDNSServerFactoryTests.test_allowQueryFalse.<locals>.RaisingDNSServerFactory.allowQueryc s � ||��r r r �r� r r r# � s zUDNSServerFactoryTests.test_allowQueryFalse.<locals>.RaisingDNSServerFactory.sendReplyN)r r r r" r# r r� r r r& � s r& Nr� ) r- r rJ r� r� r r� r rB �rCode�EREFUSED)r r& r� r� r� r r! r r r� r �test_allowQueryFalse� s �z*DNSServerFactoryTests.test_allowQueryFalsec sX dg|_ g � � fdd�}t� }t�d�}t|||� |�||� | �� ||dfg� dS )a� Assert that the named method is called with the given message when it is passed to L{DNSServerFactory.messageReceived}. @param methodName: The name of the method which is expected to be called. @type methodName: L{str} @param message: The message which is expected to be passed to the C{methodName} method. @type message: L{dns.Message} Nc s � � | ||f� d S r �r? �r r r! ��receivedMessagesr r � fakeHandler s z?DNSServerFactoryTests._messageReceivedTest.<locals>.fakeHandler)�queriesr4 r rJ �setattrr� rB )r � methodNamer r� r r| r r� r �_messageReceivedTest s z*DNSServerFactoryTests._messageReceivedTestc C � | � dtjtjd�� dS )z� L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_QUERY} on to L{DNSServerFactory.handleQuery}. � handleQuery��opCodeN)r� r r� �OP_QUERYrM r r r �test_queryMessageReceived � z/DNSServerFactoryTests.test_queryMessageReceivedc C r� )z� L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_INVERSE} on to L{DNSServerFactory.handleInverseQuery}. �handleInverseQueryr� N)r� r r� � OP_INVERSErM r r r � test_inverseQueryMessageReceived& s �z6DNSServerFactoryTests.test_inverseQueryMessageReceivedc C r� )z� L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_STATUS} on to L{DNSServerFactory.handleStatus}. � handleStatusr� N)r� r r� � OP_STATUSrM r r r �test_statusMessageReceived/ r� z0DNSServerFactoryTests.test_statusMessageReceivedc C r� )z� L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_NOTIFY} on to L{DNSServerFactory.handleNotify}. � handleNotifyr� N)r� r r� � OP_NOTIFYrM r r r �test_notifyMessageReceived6 r� z0DNSServerFactoryTests.test_notifyMessageReceivedc C r� )z� L{DNSServerFactory.messageReceived} passes messages with an opcode of C{OP_UPDATE} on to L{DNSServerFactory.handleOther}. This may change if the implementation ever covers update messages. � handleOtherr� N)r� r r� � OP_UPDATErM r r r �test_updateMessageReceived= s z0DNSServerFactoryTests.test_updateMessageReceivedc C s� t � t � }}t�� }|�|� | �|j|g� |�|� | �|j||g� |�|� | �|j|g� |�|� | �|jg � dS )z� The C{connectionMade} and C{connectionLost} methods of L{DNSServerFactory} cooperate to keep track of all L{DNSProtocol} objects created by a factory which are connected. N)rV r rJ �connectionMaderB � connections�connectionLost)r �protoA�protoBr| r r r �test_connectionTrackingF s z-DNSServerFactoryTests.test_connectionTrackingc C sh t �� }|�d� |�d� t�� }t� |_| jtj|j |t � dd�}|j \\}}| � ||j d � dS )z� L{server.DNSServerFactory.handleQuery} takes the first query from the supplied message and dispatches it to L{server.DNSServerFactory.resolver.query}. � one.example.coms two.example.comNr� r )r r� r� r rJ r5 rK r� r6 r� r4 r rB r� )r r< r� r� r7 r r r r �test_handleQueryW s � z&DNSServerFactoryTests.test_handleQueryc s� t �� }t�� � G � fdd�d�}|� |_g ��fdd�}||_t�� }|�d� t � }t � }|j |||d� t � }� � |� | � �||||fi fg� dS )aC L{server.DNSServerFactory.handleQuery} adds L{server.DNSServerFactory.resolver.gotResolverResponse} as a callback to the deferred returned by L{server.DNSServerFactory.resolver.query}. It is called with the query response, the original protocol, message and origin address. c � e Zd Z� fdd�ZdS )zDDNSServerFactoryTests.test_handleQueryCallback.<locals>.FakeResolverc r� r r r ��dr r r7 z r� zJDNSServerFactoryTests.test_handleQueryCallback.<locals>.FakeResolver.queryN�r r r r7 r r� r r � FakeResolvery � r� c � � � | |f� d S r r� r )�gotResolverResponseArgsr r �fakeGotResolverResponse� � zODNSServerFactoryTests.test_handleQueryCallback.<locals>.fakeGotResolverResponser� r� N)r rJ r �DeferredrK �gotResolverResponser r� r� r4 rV r� �callbackrB )r r� r� r� r< r r� � dummyResponser )r� r� r �test_handleQueryCallbackm s$ �z.DNSServerFactoryTests.test_handleQueryCallbackc s� t �� }t�� � G � fdd�d�}|� |_g ��fdd�}||_t�� }|�d� t � }t � }|j |||d� t � t� �}� �|� | ��||||fi fg� dS )a? L{server.DNSServerFactory.handleQuery} adds L{server.DNSServerFactory.resolver.gotResolverError} as an errback to the deferred returned by L{server.DNSServerFactory.resolver.query}. It is called with the query failure, the original protocol, message and origin address. c r� )zCDNSServerFactoryTests.test_handleQueryErrback.<locals>.FakeResolverc r� r r r r� r r r7 � r� zIDNSServerFactoryTests.test_handleQueryErrback.<locals>.FakeResolver.queryNr� r r� r r r� � r� r� c r� r r� r )�gotResolverErrorArgsr r �fakeGotResolverError� r� zKDNSServerFactoryTests.test_handleQueryErrback.<locals>.fakeGotResolverErrorr� r� N)r rJ r r� rK �gotResolverErrorr r� r� r4 rV r� r �Failurer- �errbackrB )r r� r� r� r< r r� � stubFailurer )r� r� r �test_handleQueryErrback� s" �z-DNSServerFactoryTests.test_handleQueryErrbackc C st t �� }g }g }g }| jtj|j|||ft� t�� dd�}|j\\}}| � |j |� | � |j |� | � |j |� dS )z� L{server.DNSServerFactory.gotResolverResponse} accepts a tuple of resource record lists and triggers a response message containing those resource record lists. N�r r r! ) r rJ r� r. r/ r� r r� r ry �answers� authority� additional)r r� r� r� r� r� r r r r r �test_gotResolverResponse� s � z.DNSServerFactoryTests.test_gotResolverResponsec C sd t � }t|_t�� }d|_| jt|jg g g fd|dd�}| � dt |tj g g g d�f|j |j f� dS )z� L{server.DNSServerFactory.gotResolverResponse} calls L{server.DNSServerFactory._responseFromMessage} to generate a response. r� Nr� r )r r� r� r� r� )r r �_responseFromMessager r� r� r� r r� rB �dict�OKr r �r r| �requestr� r r r �0test_gotResolverResponseCallsResponseFromMessage� s0 ��� �zFDNSServerFactoryTests.test_gotResolverResponseCallsResponseFromMessagec C s4 t �� }tjddd�}|j|d�f}| �||� dS )z� L{server.DNSServerFactory._responseFromMessage} generates a response message which is a copy of the request message. F)�answer�recAv�r N)r rJ r r� r� � assertIsNot�r r| r� �responser r r �"test_responseFromMessageNewMessage� s z8DNSServerFactoryTests.test_responseFromMessageNewMessagec C sT t �� }d|_|jtjdd�d�}d|_|jtjdd�d�}| �d|j|jf� dS )z� L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{recAV} attribute is L{True} if L{server.DNSServerFactory.canRecurse} is L{True}. TF)r� r� �TFN)r rJ ro r� r r� rB r� �r r| � response1� response2r r r �*test_responseFromMessageRecursionAvailable s z@DNSServerFactoryTests.test_responseFromMessageRecursionAvailablec C �6 t �� }t�� }d|_|j|d�}| �|j|j� dS )z� L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{timeReceived} attribute has the same value as that found on the request. i� r� N)r rJ r r� r� r� rB r� r r r �$test_responseFromMessageTimeReceived � z:DNSServerFactoryTests.test_responseFromMessageTimeReceivedc C r )z� L{server.DNSServerFactory._responseFromMessage} generates a response message whose C{maxSize} attribute has the same value as that found on the request. r r� N)r rJ r r� �maxSizer� rB r� r r r � test_responseFromMessageMaxSize r z5DNSServerFactoryTests.test_responseFromMessageMaxSizec C s | � tjtjj� dS )z{ L{server.DNSServerFactory} has a C{_messageFactory} attribute which is L{dns.Message} by default. N)ry r r� r rJ �_messageFactoryrM r r r �test_messageFactory' � z)DNSServerFactoryTests.test_messageFactoryc C sd t �� }| �tdt� t�� }| jt|j|tj d�}| � dt |j |tj |j dd�f|j|jf� dS )a4 L{server.DNSServerFactory._responseFromMessage} calls C{dns._responseFromMessage} to generate a response message from the request message. It supplies the request message and other keyword arguments which should be passed to the response message initialiser. r� �r r� r F)�responseConstructorr r� r� �authN)r rJ r� r r r� r� r r� r� rB r� r ro r r r� r r r �+test_responseFromMessageCallsMessageFactory. s$ ��� �zADNSServerFactoryTests.test_responseFromMessageCallsMessageFactoryc C sX t �� }|jt�� tjdd�gd�}|jt�� tjdd�gd�}| �d|j|jf� dS )z� L{server.DNSServerFactory._responseFromMessage} marks the response message as authoritative if any of the answer records are authoritative. T)r )r r� Fr N)r rJ r� r r� �RRHeaderrB r r r r r �,test_responseFromMessageAuthoritativeMessageK s �� �zBDNSServerFactoryTests.test_responseFromMessageAuthoritativeMessagec C sR t dd�}t�� g}t�� g}t�� g}t| dg|j|||ft� t�� dd� dS )z� L{server.DNSServerFactory.gotResolverResponse} logs the total number of records in the response if C{verbose > 0}. r� rt zLookup found 3 recordsNr� )r r r rG r� r4 r� )r r� r� r� r� r r r � test_gotResolverResponseLogging\ s �z5DNSServerFactoryTests.test_gotResolverResponseLoggingc C s� t t� gd�}t�� }|�d� t�� g}g }g }| jtj|j|||ft � |dd�}|j \\}\}} } } | � |j j d� | � ||� | � | |� | � | |� dS )z� L{server.DNSServerFactory.gotResolverResponse} caches the response if at least one cache was provided in the constructor. r[ s example.comNr� )r r8 r r� r� r r� r9 r� r4 r rB r� ry ) r r� r< �expectedAnswers�expectedAuthority�expectedAdditionalr� r7 r� r� r� r r r r � test_gotResolverResponseCachingp s& � z5DNSServerFactoryTests.test_gotResolverResponseCachingc C sb t � }t|_t�� }d|_| jt|jt � t � � �d|dd�}| � dt|tjd�f|j|jf� dS )z� L{server.DNSServerFactory.gotResolverError} calls L{server.DNSServerFactory._responseFromMessage} to generate a response. r� Nr� r r )r r r� r r� r� r� r r� r r� r � DomainErrorrB r� �ENAMEr r r� r r r �-test_gotResolverErrorCallsResponseFromMessage� s ��zCDNSServerFactoryTests.test_gotResolverErrorCallsResponseFromMessagec C sL t �� }| jtj|jt�|�t� t� � dd�}|j \\}}| � |j |� dS )a{ L{server.DNSServerFactory.gotResolver} accepts a L{failure.Failure} and triggers a response message whose rCode corresponds to the DNS error contained in the C{Failure}. @param responseError: The L{Exception} instance which is expected to trigger C{expectedMessageCode} when it is supplied to C{gotResolverError} @type responseError: L{Exception} @param expectedMessageCode: The C{rCode} which is expected in the message returned by C{gotResolverError} in response to C{responseError}. @type expectedMessageCode: L{int} Nr� ) r rJ r� r. r/ r� r r� r r� r rB r� )r � responseError�expectedMessageCoder� r� r r r r r �_assertMessageRcodeForError� s � z1DNSServerFactoryTests._assertMessageRcodeForErrorc C � | � t�� tj� dS )z� L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ENAME} if supplied with a L{error.DomainError}. N)r r r r r rM r r r � test_gotResolverErrorDomainError� r z6DNSServerFactoryTests.test_gotResolverErrorDomainErrorc C r )z� L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ENAME} if supplied with a L{error.AuthoritativeDomainError}. N)r r �AuthoritativeDomainErrorr r rM r r r �-test_gotResolverErrorAuthoritativeDomainError� s zCDNSServerFactoryTests.test_gotResolverErrorAuthoritativeDomainErrorc C s. | � t� tj� | �t�}| �t|�d� dS )z� L{server.DNSServerFactory.gotResolver} triggers a response message with an C{rCode} of L{dns.ESERVER} if supplied with another type of error and logs the error. r� N)r �KeyErrorr �ESERVER�flushLoggedErrorsrB �len)r r� r r r � test_gotResolverErrorOtherError� s z5DNSServerFactoryTests.test_gotResolverErrorOtherErrorc C s8 t dd�}t| dg|jt�t�� �t� t� � dd� dS )zZ L{server.DNSServerFactory.gotResolver} logs a message if C{verbose > 0}. r� rt z Lookup failedNr� ) r rG r� r r� r r r4 r r� r� r r r � test_gotResolverErrorLogging� s �z2DNSServerFactoryTests.test_gotResolverErrorLoggingc s� t �� }g � � fdd�|_tjddd�}t� t� g|_t� t� g|_t� t� g|_|j t � t � � �d|dd� | �tjddd�g� � dS ) z� L{server.DNSServerFactory.gotResolverError} does not allow request attributes to leak into the response ie it sends a response with AD, CD set to 0 and empty response record sections. c � � � |�S r r� �r r� r! �� responsesr r r� � � �zUDNSServerFactoryTests.test_gotResolverErrorResetsResponseAttributes.<locals>.<lambda>T�� authenticData�checkingDisabledNr� � �r� r� )r rJ r# r r� rV r� r� r� r� r r� r r rB �r r| r� r r* r �-test_gotResolverErrorResetsResponseAttributes� s � zCDNSServerFactoryTests.test_gotResolverErrorResetsResponseAttributesc s� t �� }g � � fdd�|_tjddd�}t� t� g|_t� t� g|_t� t� g|_|j g g g fd|dd� | � tjddd�g� � dS ) a L{server.DNSServerFactory.gotResolverResponse} does not allow request attributes to leak into the response ie it sends a response with AD, CD set to 0 and none of the records in the request answer sections are copied to the response. c r( r r� r) r* r r r� r, zXDNSServerFactoryTests.test_gotResolverResponseResetsResponseAttributes.<locals>.<lambda>Tr- Nr� r r1 ) r rJ r# r r� rV r� r� r� r� rB r2 r r* r �0test_gotResolverResponseResetsResponseAttributes s � zFDNSServerFactoryTests.test_gotResolverResponseResetsResponseAttributesc C sZ t �� }t� }t�� }| jtj|jt� ||d�}|j \}}| � |||f� | � |i � dS )z� If L{server.DNSServerFactory.sendReply} is supplied with a protocol *and* an address tuple it will supply that address to C{protocol.writeMessage}. r� N) r r� rV r rJ r� r. r/ r# r rB )r r< r� r� r� r r r r r �test_sendReplyWithAddress s � z/DNSServerFactoryTests.test_sendReplyWithAddressc C sR t �� }t�� }| jtj|jt� |dd�}|j\}}| � ||f� | � |i � dS )z� If L{server.DNSServerFactory.sendReply} is supplied with a protocol but no address tuple it will supply only a message to C{protocol.writeMessage}. Nr� ) r r� r rJ r� r. r/ r# r rB )r r< r� r� r r r r r � test_sendReplyWithoutAddress+ s � z2DNSServerFactoryTests.test_sendReplyWithoutAddressc C sN | � tjddd� � t�� }d|_tjdd�}t| ddg|jt � |d d � d S ) z� If L{server.DNSServerFactory.sendReply} logs a "no answers" message if the supplied message has no answers. r� c S r �Ni�Q r r r r r r� C r$ zFDNSServerFactoryTests.test_sendReplyLoggingNoAnswers.<locals>.<lambda>�Q r� rt zReplying with no answers� Processed query in 1.000 secondsNr� ) r� r r� r r� r� rJ rG r# r4 r� r r r � test_sendReplyLoggingNoAnswers> s �z4DNSServerFactoryTests.test_sendReplyLoggingNoAnswersc C s� | � tjddd� � t�� }|j�tjt�d�d�� |j �tjt�d�d�� |j �tjt�d�d�� d|_ tj dd�}t | g d �|jt� |d d � d S ) z� If L{server.DNSServerFactory.sendReply} logs a message for answers, authority, additional if the supplied a message has records in any of those sections. r� c S r r7 r r r r r r� V r$ zHDNSServerFactoryTests.test_sendReplyLoggingWithAnswers.<locals>.<lambda>z 127.0.0.1)�payloadr8 r� rt )z*Answers are <A address=127.0.0.1 ttl=None>z+Authority is <A address=127.0.0.1 ttl=None>z,Additional is <A address=127.0.0.1 ttl=None>r9 Nr� )r� r r� r r� r� r? r �Record_Ar� r� r� rJ rG r# r4 r� r r r � test_sendReplyLoggingWithAnswersP s �z6DNSServerFactoryTests.test_sendReplyLoggingWithAnswersc C �F t �� }| jtj|jt�� t� dd�}|j\\}}| � |j tj � dS )z� L{server.DNSServerFactory.handleInverseQuery} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. Nr� ) r rJ r� r. r/ r� r r� r rB r� �ENOTIMP�r r� r� r r r r r �test_handleInverseQueryk � � z-DNSServerFactoryTests.test_handleInverseQueryc C �, t dd�}t| dg|jt�� t� dd� dS )zz L{server.DNSServerFactory.handleInverseQuery} logs the message origin address if C{verbose > 0}. r� rt z Inverse query from ('::1', 53)�z::1r� r� N)r rG r� r r� r4 r� r r r � test_handleInverseQueryLogging| � �z4DNSServerFactoryTests.test_handleInverseQueryLoggingc C r> )z� L{server.DNSServerFactory.handleStatus} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. Nr� ) r rJ r� r. r/ r� r r� r rB r� r? r@ r r r �test_handleStatus� rB z'DNSServerFactoryTests.test_handleStatusc C rC )zt L{server.DNSServerFactory.handleStatus} logs the message origin address if C{verbose > 0}. r� rt z Status request from ('::1', 53)rD r� N)r rG r� r r� r4 r� r r r �test_handleStatusLogging� rF z.DNSServerFactoryTests.test_handleStatusLoggingc C r> )z� L{server.DNSServerFactory.handleNotify} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. Nr� ) r rJ r� r. r/ r� r r� r rB r� r? r@ r r r �test_handleNotify� rB z'DNSServerFactoryTests.test_handleNotifyc C rC )zt L{server.DNSServerFactory.handleNotify} logs the message origin address if C{verbose > 0}. r� rt z Notify message from ('::1', 53)rD r� N)r rG r� r r� r4 r� r r r �test_handleNotifyLogging� rF z.DNSServerFactoryTests.test_handleNotifyLoggingc C r> )z� L{server.DNSServerFactory.handleOther} triggers the sending of a response message with C{rCode} set to L{dns.ENOTIMP}. Nr� ) r rJ r� r. r/ r� r r� r rB r� r? r@ r r r �test_handleOther� rB z&DNSServerFactoryTests.test_handleOtherc C rC )zs L{server.DNSServerFactory.handleOther} logs the message origin address if C{verbose > 0}. r� rt z$Unknown op code (0) from ('::1', 53)rD r� N)r rG r� r r� r4 r� r r r �test_handleOtherLogging� rF z-DNSServerFactoryTests.test_handleOtherLoggingN)Dr r r r rN rR rY r] r` rg rk rm rp rq rs rv rw r{ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r r r! r& r' r3 r4 r5 r6 r: r= rA rE rG rH rI rJ rK rL r r r r rH � s� ('! rH N) r �zope.interface.verifyr �twisted.internetr �twisted.internet.interfacesr � twisted.namesr r r r �twisted.pythonr r � twisted.trialr r- r r rJ r r& r. r4 r5 r8 rG �TestCaserH r r r r �<module> s" ! PK Mb�Z��h.5 5 2 names/test/__pycache__/test_common.cpython-310.pycnu �[��� o �b � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZm Z m Z m Z m Z m Z ddlmZmZmZmZmZmZ ddlmZ ddlmZ G d d � d e�ZG d d � d e�Zd S )z$ Tests for L{twisted.names.common}. � )� verifyClass)� IResolver)� ResolverBase)�EFORMAT�ENAME�ENOTIMP�EREFUSED�ESERVER�Query)�DNSFormatError� DNSNameError�DNSNotImplementedError�DNSQueryRefusedError�DNSServerError�DNSUnknownError)�Failure)�SynchronousTestCasec @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�ExceptionForCodeTestsz5 Tests for L{ResolverBase.exceptionForCode}. c C s t � j| _d S �N)r �exceptionForCode��self� r �@/usr/lib/python3/dist-packages/twisted/names/test/test_common.py�setUp s zExceptionForCodeTests.setUpc C � | � | �t�t� dS )zd L{ResolverBase.exceptionForCode} converts L{EFORMAT} to L{DNSFormatError}. N)�assertIsr r r r r r r � test_eformat" � z"ExceptionForCodeTests.test_eformatc C r )zd L{ResolverBase.exceptionForCode} converts L{ESERVER} to L{DNSServerError}. N)r r r r r r r r � test_eserver) r z"ExceptionForCodeTests.test_eserverc C r )zX L{ResolverBase.exceptionForCode} converts L{ENAME} to L{DNSNameError}. N)r r r r r r r r � test_ename0 s z ExceptionForCodeTests.test_enamec C r )zl L{ResolverBase.exceptionForCode} converts L{ENOTIMP} to L{DNSNotImplementedError}. N)r r r r r r r r � test_enotimp6 r z"ExceptionForCodeTests.test_enotimpc C r )zk L{ResolverBase.exceptionForCode} converts L{EREFUSED} to L{DNSQueryRefusedError}. N)r r r r r r r r � test_erefused= r z#ExceptionForCodeTests.test_erefusedc C s | � | �t� �t� dS )zr L{ResolverBase.exceptionForCode} converts any other response code to L{DNSUnknownError}. N)r r �objectr r r r r � test_otherD s z ExceptionForCodeTests.test_otherN) �__name__� __module__� __qualname__�__doc__r r r r r! r" r$ r r r r r s r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � QueryTestsz* Tests for L{ResolverBase.query}. c C s t tt� dS )zF L{ResolverBase} provides the L{IResolver} interface. N)r r r r r r r �"test_resolverBaseProvidesIResolverQ s z-QueryTests.test_resolverBaseProvidesIResolverc sF g � t � }d� fdd�i|_tddd�}|�|d� | �dg� � dS ) z� L{ResolverBase.query} looks up a method to invoke using the type of the query passed to it and the C{typeToMethod} mapping on itself. �90 c s � � | |f�S r )�append��query�timeout��resultsr r �<lambda>_ s z6QueryTests.test_typeToMethodDispatch.<locals>.<lambda>� example.com��name�type�{ )r3 r7 N)r � typeToMethodr r. � assertEqual)r �resolverr. r r0 r �test_typeToMethodDispatchW s � z$QueryTests.test_typeToMethodDispatchc sZ t � � t� }d� fdd�i|_tddd�}|�|d�}g }|�|j� | �� |d � dS ) z� L{ResolverBase.query} returns a L{Deferred} which fires with the result of the method found in the C{typeToMethod} mapping for the type of the query passed to it. i1� c s � S r r r- ��expectedr r r2 m s z4QueryTests.test_typeToMethodResult.<locals>.<lambda>r3 r4 r7 r N)r# r r8 r r. �addBothr, r9 �r r: r. � queryDeferred�resultr r< r �test_typeToMethodResulte s z"QueryTests.test_typeToMethodResultc C sV t � }i |_tddd�}|�|d�}g }|�|j� | �|d t� |d �t � dS )z� L{ResolverBase.query} returns a L{Deferred} which fails with L{NotImplementedError} when called with a query of a type not present in its C{typeToMethod} dictionary. r3 r+ r4 r7 r N) r r8 r r. r> r, �assertIsInstancer �trap�NotImplementedErrorr? r r r �test_unknownQueryTypet s z QueryTests.test_unknownQueryTypeN)r% r& r' r( r* r; rB rF r r r r r) L s r) N)r( �zope.interface.verifyr �twisted.internet.interfacesr �twisted.names.commonr �twisted.names.dnsr r r r r r �twisted.names.errorr r r r r r �twisted.python.failurer �twisted.trial.unittestr r r) r r r r �<module> s 2PK Mb�Z����P% P% 6 names/test/__pycache__/test_srvconnect.cpython-310.pycnu �[��� o �b�$ � @ s� d Z ddlZddlmZ ddlmZmZ ddlmZm Z ddl m Z ddl m Z mZmZ ddlmZ dd lmZ dd lmZ dd lmZ G d d � d e�ZG dd� dej�ZG dd� dej�Z dS )z- Test cases for L{twisted.names.srvconnect}. � N)� verifyObject)�defer�protocol)�DNSLookupError�ServiceNameUnknownError)� IConnector)�client�dns� srvconnect)� ResolverBase)� DNSNameError)� MemoryReactor)�unittestc @ s" e Zd ZdZddd�Zdd� ZdS )� FakeResolvera� Resolver that only gives out one given result. Either L{results} or L{failure} must be set and will be used for the return value of L{_lookup} @ivar results: List of L{dns.RRHeader} for the desired result. @type results: C{list} @ivar failure: Failure with an exception from L{twisted.names.error}. @type failure: L{Failure<twisted.python.failure.Failure>} Nc C s || _ || _g | _d S �N)�results�failure�lookups)�selfr r � r �D/usr/lib/python3/dist-packages/twisted/names/test/test_srvconnect.py�__init__$ s zFakeResolver.__init__c C s< | j �||||f� | jdurt�| jg g f�S t�| j�S )z9 Return the result or failure on lookup. N)r �appendr r �succeed�failr )r �name�cls�qtype�timeoutr r r �_lookup) s zFakeResolver._lookup)NN)�__name__� __module__� __qualname__�__doc__r r r r r r r s r c @ s e Zd ZdZdd� Zdd� ZdS )� DummyFactoryzL Dummy client factory that stores the reason of connection failure. c C s d | _ d S r ��reason�r r r r r 9 � zDummyFactory.__init__c C s || _ d S r r% )r � connectorr& r r r �clientConnectionFailed< r( z#DummyFactory.clientConnectionFailedN)r r! r" r# r r* r r r r r$ 4 s r$ c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd S )!�SRVConnectorTestsz/ Tests for L{srvconnect.SRVConnector}. c C sF | � tdt� � t� | _t� | _t�| jdd| j�| _ g | _ g | _ d S )N� theResolver� xmpp-server� example.org) �patchr r r �reactorr$ �factoryr � SRVConnectorr) � randIntArgs�randIntResultsr' r r r �setUpE s � zSRVConnectorTests.setUpc C s | j �||f� | j�d�S )a� Fake randint. Returns the first element of L{randIntResults} and records the arguments passed to it in L{randIntArgs}. @param min: Lower bound of the random number. @type min: L{int} @param max: Higher bound of the random number. @type max: L{int} @return: Fake random number from L{randIntResults}. @rtype: L{int} r )r3 r r4 �pop)r �min�maxr r r �_randintO s zSRVConnectorTests._randintc C s t t| j� dS )zF L{srvconnect.SRVConnector} implements L{IConnector}. N)r r r) r' r r r �test_interfaceb s z SRVConnectorTests.test_interfacec C sf t jdddd�}t jdt jt jd|d�gtj_| j� � | � | j j � | � | jj�� dd� d � dS ) zS Test connectTCP gets called with the address from the SRV record. �} �host.example.org�< ��port�target�ttlr. �r �typer rA �payloadN� )r< r; )r � Record_SRV�RRHeader�SRV�INr r, r r) �connect� assertIsNoner1 r& � assertEqualr0 � tcpClientsr6 �r rD r r r �test_SRVPresenth s �� z!SRVConnectorTests.test_SRVPresentc C sD t d�tj_| j�� | �| jj� | � | j j � � dd� d� dS )zS Test connectTCP gets called with fallback parameters on NXDOMAIN. s example.orgNrE �r. r- ) r r r, r r) rJ rK r1 r& rL r0 rM r6 r' r r r �test_SRVNotPresentw s �z$SRVConnectorTests.test_SRVNotPresentc C s@ g t j_| j�� | �| jj� | �| j j � � dd� d� dS )zW Test connectTCP gets called with fallback parameters on empty result. NrE rP ) r r, r r) rJ rK r1 r& rL r0 rM r6 r' r r r �test_SRVNoResult� s �z"SRVConnectorTests.test_SRVNoResultc C s\ t j| jdd| jdd�| _t� tj_| j� � | � | jj � | � | jj �� dd� d� dS )zY connectTCP gets called with default port if the service is not defined. �thisbetternotexistr. �f )� defaultPortNrE )r. rT )r r2 r0 r1 r) r r r, r rJ rK r& rL rM r6 r' r r r �)test_SRVNoResultUnknownServiceDefaultPort� s � z;SRVConnectorTests.test_SRVNoResultUnknownServiceDefaultPortc C sB t �| jdd| j�| _t� tj_| j� � | � | jj � t�� dS )zR Connect fails on no result, unknown service and no default port. rS r. N) r r2 r0 r1 r) r r r, r rJ � assertTruer& �checkr' r r r �+test_SRVNoResultUnknownServiceNoDefaultPort� s � z=SRVConnectorTests.test_SRVNoResultUnknownServiceNoDefaultPortc C sV t jdt jt jddd�gtj_| j�� | � | j j � | � | j j�� dd� d� dS )zU Test connectTCP gets called with fallback parameters on bad result. r. r= NrB rE rP )r rG �CNAMErI r r, r r) rJ rK r1 r& rL r0 rM r6 r' r r r �test_SRVBadResult� s �� �z#SRVConnectorTests.test_SRVBadResultc C sh t jdddd�}t jdt jt jd|d�gtj_| j� � | � | j j � | j j � t� | �| jjg � dS )zH Test that connecting fails when no service is present. i� � .r= r> r. rB N)r rF rG rH rI r r, r r) rJ �assertIsNotNoner1 r& �trapr rL r0 rM rN r r r �test_SRVNoService� s �� z#SRVConnectorTests.test_SRVNoServicec C s2 g t j_| j�� t jjd d }| �d|� dS )zW The lookup name is a native string from service, protocol and domain. ���r s _xmpp-server._tcp.example.orgN)r r, r r) rJ r rL )r r r r r �test_SRVLookupName� s z$SRVConnectorTests.test_SRVLookupNamec C s* t �| jdd| j�| _| �d| jj� dS )zq L{srvconnect.SRVConnector} automatically encodes unicode domain using C{idna} encoding. z xmpp-clientu échec.example.orgs xn--chec-9oa.example.orgN)r r2 r0 r1 r) rL �domainr' r r r �test_unicodeDomain� s �z$SRVConnectorTests.test_unicodeDomainc C s� t �dddd�}t �dddd�}||g| j_g | j_| �td| j� ddg| _| j� � | � | j d d � | j� � | � | j d d � ddg| _| j� � | � | j d d � | j� � | � | j d d� dS )a pickServer calculates running sum of weights and calls randint. This exercises the server selection algorithm specified in RFC 2782 by preparing fake L{random.randint} results and checking the values it was called with. � rT �host1.example.org� �host2.example.org�randint� r )r � � )r rd rE � )r rf N) r rF r) �orderedServers�serversr/ �randomr9 r4 � pickServerrL r3 �r �record1�record2r r r �test_pickServerWeights� s z(SRVConnectorTests.test_pickServerWeightsc C sv t �dddd�}t �dddd�}||g| j_g | j_| �td| j� ddg| _| � d| j� � � | � d | j� � � d S ) zR Two records with equal priorities compare on weight (ascending). rd rT re rf rg rh r �re rT �rg rT N� r rF r) rm rn r/ ro r9 r4 rL rp rq r r r � test_pickServerSamePriorities � z/SRVConnectorTests.test_pickServerSamePrioritiesc C sv t �dddd�}t �dddd�}||g| j_g | j_| �td| j� ddg| _| � d| j� � � | � d | j� � � d S ) zX Two records with differing priorities compare on priority (ascending). rd r rT re rf rg rh ru rv Nrw rq r r r �test_srvDifferentPriorities ry z-SRVConnectorTests.test_srvDifferentPrioritiesN)r r! r" r# r5 r9 r: rO rQ rR rV rY r[ r_ ra rc rt rx rz r r r r r+ @ s" ! r+ ) r# ro �zope.interface.verifyr �twisted.internetr r �twisted.internet.errorr r �twisted.internet.interfacesr � twisted.namesr r r �twisted.names.commonr �twisted.names.errorr �twisted.test.proto_helpersr � twisted.trialr r � ClientFactoryr$ �TestCaser+ r r r r �<module> s PK Mb�Z<�d( ( 1 names/test/__pycache__/test_hosts.cpython-310.pycnu �[��� o �b�& � @ s� d Z ddlmZ ddlmZmZmZmZmZm Z m Z m Z ddl m Z mZmZ ddlmZ ddlmZ G dd� d�ZG d d � d ee�ZG d d � d ee�ZG d d� dee�ZdS )zC Tests for the I{hosts(5)}-based resolver, L{twisted.names.hosts}. � )� gatherResults)�AAAA�IN�A� DomainError�Query�Record_A� Record_AAAA�RRHeader)�Resolver� searchFileFor�searchFileForAll)�FilePath)�SynchronousTestCasec @ s e Zd Zdd� ZdS )�GoodTempPathMixinc C s t | �� �d��S )Nzutf-8)r �mktemp�encode��self� r �?/usr/lib/python3/dist-packages/twisted/names/test/test_hosts.py�path s zGoodTempPathMixin.pathN)�__name__� __module__� __qualname__r r r r r r s r c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �SearchHostsFileTestsz� Tests for L{searchFileFor}, a helper which finds the first address for a particular hostname in a I{hosts(5)}-style file. c C �* | � � }|�d� | �dt|j d�� dS )zr If there is an IPv4 address for the hostname passed to L{searchFileFor}, it is returned. � 10.2.3.4 foo.example.com z10.2.3.4� foo.example.comN�r � setContent� assertEqualr �r �hostsr r r �test_findAddress$ s z%SearchHostsFileTests.test_findAddressc C s( | � � }|�d� | �t|j d�� dS )z~ If there is no address information for the hostname passed to L{searchFileFor}, L{None} is returned. r s bar.example.comN)r r! � assertIsNoner r# r r r �test_notFoundAddress- s z)SearchHostsFileTests.test_notFoundAddressc C r )zS The first address associated with the given hostname is returned. sV ::1 foo.example.com 10.1.2.3 foo.example.com fe80::21b:fcff:feee:5a1d foo.example.com �::1r Nr r# r r r �test_firstAddress6 s �z&SearchHostsFileTests.test_firstAddressc C sz | � � }|�d� | �t|j d�d� | �t|j d�d� | �t|j d�d� | �t|j d�d� | �t|j d�d� d S ) z� For a host with a canonical name and one or more aliases, L{searchFileFor} can find an address given any of the names. sY 127.0.1.1 helmut.example.org helmut # a comment ::1 localhost ip6-localhost ip6-loopback s helmutz 127.0.1.1s helmut.example.orgs ip6-localhostr( s ip6-loopbacks localhostNr r# r r r �test_searchFileForAliasesB s �z.SearchHostsFileTests.test_searchFileForAliasesN)r r r �__doc__r% r' r) r* r r r r r s r c @ r ) �SearchHostsFileForAllTestsz� Tests for L{searchFileForAll}, a helper which finds all addresses for a particular hostname in a I{hosts(5)}-style file. c C s, | � � }|�d� | �g d�t|d�� dS )zt L{searchFileForAll} returns a list of all addresses associated with the name passed to it. sc 127.0.0.1 foobar.example.com 127.0.0.2 foobar.example.com ::1 foobar.example.com )� 127.0.0.1z 127.0.0.2r( s foobar.example.comN�r r! r" r r# r r r �test_allAddressesZ s ��z,SearchHostsFileForAllTests.test_allAddressesc C s* | � � }|�d� | �dgt|d�� dS )zL L{searchFileForAll} searches for names case-insensitively. s! 127.0.0.1 foobar.EXAMPLE.com r- s FOOBAR.example.comNr. r# r r r �test_caseInsensitivelyj s z1SearchHostsFileForAllTests.test_caseInsensitivelyc C s | � g t| �� d�� dS )z� If there is an error reading the contents of the hosts file, L{searchFileForAll} returns an empty list. s example.comN)r" r r r r r r �test_readErrorr s z)SearchHostsFileForAllTests.test_readErrorc C s, | � � }|�d� | �ddgt|d�� dS )zw L{searchFileForAll} ignores any malformed IP addresses associated with the name passed to it. s[ 127.0.0.1 miser.example.org miser not-an-ip miser �not-ascii miser # miser miser ::1 miserr- r( s miserNr. r# r r r �test_malformedIPy s ��z+SearchHostsFileForAllTests.test_malformedIPN)r r r r+ r/ r0 r1 r2 r r r r r, T s r, c @ sx e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd S ) � HostsTestszJ Tests for the I{hosts(5)}-based L{twisted.names.hosts.Resolver}. c C s, | � � }|�d� d| _t|j | j�| _d S )Ns 1.1.1.1 EXAMPLE EXAMPLE.EXAMPLETHING ::2 mixed 1.1.1.2 MIXED ::1 ip6thingy 1.1.1.3 multiple 1.1.1.4 multiple ::3 ip6-multiple ::4 ip6-multiple not-an-ip malformed malformed # malformed 1.1.1.5 malformed ::5 malformed ih )r r! �ttlr �resolver)r �fr r r �setUp� s �zHostsTests.setUpc C s t � }| �d|j� dS )z� The default hosts file used by L{Resolver} is I{/etc/hosts} if no value is given for the C{file} initializer parameter. s /etc/hostsN)r r" �file)r r5 r r r �test_defaultPath� s zHostsTests.test_defaultPathc s, g d�}� fdd�|D �}� � t|�� dS )z� L{hosts.Resolver.getHostByName} returns a L{Deferred} which fires with a string giving the address of the queried name as found in the resolver's hosts file. ))� EXAMPLE�1.1.1.1)s EXAMPLE.EXAMPLETHINGr; )s MIXED�1.1.1.2c s& g | ]\}}� j �|��� j|��qS r )r5 � getHostByName� addCallbackr" )�.0�n�ipr r r � <listcomp>� s ��z1HostsTests.test_getHostByName.<locals>.<listcomp>N)�successResultOfr )r �data�dsr r r �test_getHostByName� s �z HostsTests.test_getHostByNamec C �\ | j �d�}| �|�\}}}| �tdtt| jtd| j��tdtt| jtd| j��f|� dS )z L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with A records from the hosts file. s multiplez1.1.1.3z1.1.1.4N� r5 � lookupAddressrC r" r r r r4 r �r �d�answers� authority� additionalr r r �test_lookupAddress� s ��z HostsTests.test_lookupAddressc C rG )z� L{hosts.Resolver.lookupIPV6Address} returns a L{Deferred} which fires with AAAA records from the hosts file. s ip6-multiplez::3z::4N� r5 �lookupIPV6AddressrC r" r r r r4 r rJ r r r �test_lookupIPV6Address� s ����z!HostsTests.test_lookupIPV6Addressc C sD | j �d�}| �|�\}}}| �tdtt| jtd| j��f|� dS )z� L{hosts.Resolver.lookupAllRecords} returns a L{Deferred} which fires with A records from the hosts file. s mixedr< N) r5 �lookupAllRecordsrC r" r r r r4 r rJ r r r �test_lookupAllRecords� s �z HostsTests.test_lookupAllRecordsc C � | � | j�d�t� dS )z| L{hosts.Resolver} fails with L{NotImplementedError} for L{IResolver} methods it doesn't implement. r: N)�failureResultOfr5 �lookupMailExchange�NotImplementedErrorr r r r �test_notImplemented� s �z HostsTests.test_notImplementedc C s8 | j �td��}| �|�\\}}}| �|j�� d� d S )Nr: r; )r5 �queryr rC r" �payload� dottedQuad�r rK �answerrM rN r r r � test_query� s zHostsTests.test_queryc C rU )z� L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with L{dns.DomainError} if the name passed in has no addresses in the hosts file. � foueoaN)rV r5 rI r r r r r �test_lookupAddressNotFound� s z%HostsTests.test_lookupAddressNotFoundc C rU )zj Like L{test_lookupAddressNotFound}, but for L{hosts.Resolver.lookupIPV6Address}. r` N)rV r5 rQ r r r r r � test_lookupIPV6AddressNotFound � z)HostsTests.test_lookupIPV6AddressNotFoundc C rU )zi Like L{test_lookupAddressNotFound}, but for L{hosts.Resolver.lookupAllRecords}. r` N)rV r5 rS r r r r r � test_lookupAllRecordsNotFound rc z(HostsTests.test_lookupAllRecordsNotFoundc C �D | j �d�}| �|�\\}}}| �tdtt| jtd| j��|� dS )z� L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with the valid addresses from the hosts file, ignoring any entries that aren't valid IP addresses. � malformedz1.1.1.5NrH r] r r r �test_lookupMalformed s �z HostsTests.test_lookupMalformedc C re )zk Like L{test_lookupAddressMalformed}, but for L{hosts.Resolver.lookupIPV6Address}. rf z::5NrP r] r r r �test_lookupIPV6Malformed s �z#HostsTests.test_lookupIPV6MalformedN)r r r r+ r7 r9 rF rO rR rT rY r_ ra rb rd rg rh r r r r r3 � s r3 N)r+ �twisted.internet.deferr �twisted.names.dnsr r r r r r r r �twisted.names.hostsr r r �twisted.python.filepathr �twisted.trial.unittestr r r r, r3 r r r r �<module> s ( 69PK Mb�Z ��% 1 names/test/__pycache__/test_cache.cpython-310.pycnu �[��� o �b� � @ sZ d Z ddlZddlmZ ddlmZmZ ddlmZm Z ddl m Z G dd� de j �Z dS ) z# Tests for L{twisted.names.cache}. � N)� verifyClass)� interfaces�task)�cache�dns)�unittestc @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� CachingTestsz+ Tests for L{cache.CacheResolver}. c C s t tjtj� dS )zK L{cache.CacheResolver} implements L{interfaces.IResolver} N)r r � IResolverr � CacheResolver��self� r �?/usr/lib/python3/dist-packages/twisted/names/test/test_cache.py�test_interface s zCachingTests.test_interfacec C sF t �tjdtjtjd�t�� g g g ffi�}|�d��| j g g g f�S )N� example.com��name�type�cls) r r r �Query�MX�IN�time�lookupMailExchange� addCallback� assertEqual)r �cr r r � test_lookup s ��� �zCachingTests.test_lookupc C s� t �dt jt jdt �dd��gt �dt jt jdt �dd��gt �dt jt jdt �dd��gf}t�� }t jdt jt jd�}tj ||� � |fi|d�}|� d� | � ||j� | � |�d�t j�S )z� Cache entries passed into L{cache.CacheResolver.__init__} get cancelled just like entries added with cacheResult r �< � 127.0.0.1�2 �( r ��reactor)r �RRHeader�Ar �Record_Ar �Clockr r r �seconds�advance� assertNotIn� assertFailure� lookupAddress� DomainError)r �r�clock�queryr r r r �test_constructorExpires* s& ������� z$CachingTests.test_constructorExpiresc s� t �dt jt jdt �dd��gt �dt jt jdt �dd��gt �dt jt jdt �dd��gf}t�� }tj|d�}|� t j dt jt jd�|� |� d� � fd d �}|� d�� |�S ) z� When a cache lookup finds a cached entry from 1 second ago, it is returned with a TTL of original TTL minus the elapsed 1 second. r r r r r! r" r � c s^ � � | d d jd� � � | d d jd� � � | d d jd� � � | d d jjd� d S )Nr �; r2 �1 � �' r )r �ttlr )�resultr r r �cbLookupl s z0CachingTests.test_normalLookup.<locals>.cbLookup)r r$ r% r r& r r' r r � cacheResultr r) r, r )r r. r/ r r9 r r r �test_normalLookupN s& ������� z CachingTests.test_normalLookupc C s� t �dt jt jdt �dd��gt �dt jt jdt �dd��gt �dt jt jdt �dd��gf}t�� }tj|d�}t j dt jt jd�}|� ||� |� d� | � ||j� | � |�d�t j�S )zW Once the TTL has been exceeded, the result is removed from the cache. r r r r r! r" r )r r$ r% r r& r r' r r r r: r) r* r+ r, r- )r r. r/ r r0 r r r �test_cachedResultExpirest s( ������� z%CachingTests.test_cachedResultExpiresc C s� t �dt jt jdt �dd��gt �dt jt jdt �dd��gt �dt jt jdt �dd��gf}t�� }dd� |_tj t j dt jt jd�|� � |fi|d �}|� d � | � |�d�t j�S ) z� When the cache is queried exactly as the cached entry should expire but before it has actually been cleared, the cache does not return the expired entry. r r r r r! c _ s d S )Nr )�args�kwargsr r r �<lambda>� s z4CachingTests.test_expiredTTLLookup.<locals>.<lambda>r r" g����� N@)r r$ r% r r& r r' � callLaterr r r r( r) r+ r, r- )r r. r/ r r r r �test_expiredTTLLookup� s2 ������� ��� z"CachingTests.test_expiredTTLLookupN) �__name__� __module__� __qualname__�__doc__r r r1 r; r< rA r r r r r s $& "r )rE r �zope.interface.verifyr �twisted.internetr r � twisted.namesr r � twisted.trialr �TestCaser r r r r �<module> s PK Mb�Z�����& �& names/test/test_hosts.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for the I{hosts(5)}-based resolver, L{twisted.names.hosts}. """ from twisted.internet.defer import gatherResults from twisted.names.dns import ( AAAA, IN, A, DomainError, Query, Record_A, Record_AAAA, RRHeader, ) from twisted.names.hosts import Resolver, searchFileFor, searchFileForAll from twisted.python.filepath import FilePath from twisted.trial.unittest import SynchronousTestCase class GoodTempPathMixin: def path(self): return FilePath(self.mktemp().encode("utf-8")) class SearchHostsFileTests(SynchronousTestCase, GoodTempPathMixin): """ Tests for L{searchFileFor}, a helper which finds the first address for a particular hostname in a I{hosts(5)}-style file. """ def test_findAddress(self): """ If there is an IPv4 address for the hostname passed to L{searchFileFor}, it is returned. """ hosts = self.path() hosts.setContent(b"10.2.3.4 foo.example.com\n") self.assertEqual("10.2.3.4", searchFileFor(hosts.path, b"foo.example.com")) def test_notFoundAddress(self): """ If there is no address information for the hostname passed to L{searchFileFor}, L{None} is returned. """ hosts = self.path() hosts.setContent(b"10.2.3.4 foo.example.com\n") self.assertIsNone(searchFileFor(hosts.path, b"bar.example.com")) def test_firstAddress(self): """ The first address associated with the given hostname is returned. """ hosts = self.path() hosts.setContent( b"::1 foo.example.com\n" b"10.1.2.3 foo.example.com\n" b"fe80::21b:fcff:feee:5a1d foo.example.com\n" ) self.assertEqual("::1", searchFileFor(hosts.path, b"foo.example.com")) def test_searchFileForAliases(self): """ For a host with a canonical name and one or more aliases, L{searchFileFor} can find an address given any of the names. """ hosts = self.path() hosts.setContent( b"127.0.1.1\thelmut.example.org\thelmut\n" b"# a comment\n" b"::1 localhost ip6-localhost ip6-loopback\n" ) self.assertEqual(searchFileFor(hosts.path, b"helmut"), "127.0.1.1") self.assertEqual(searchFileFor(hosts.path, b"helmut.example.org"), "127.0.1.1") self.assertEqual(searchFileFor(hosts.path, b"ip6-localhost"), "::1") self.assertEqual(searchFileFor(hosts.path, b"ip6-loopback"), "::1") self.assertEqual(searchFileFor(hosts.path, b"localhost"), "::1") class SearchHostsFileForAllTests(SynchronousTestCase, GoodTempPathMixin): """ Tests for L{searchFileForAll}, a helper which finds all addresses for a particular hostname in a I{hosts(5)}-style file. """ def test_allAddresses(self): """ L{searchFileForAll} returns a list of all addresses associated with the name passed to it. """ hosts = self.path() hosts.setContent( b"127.0.0.1 foobar.example.com\n" b"127.0.0.2 foobar.example.com\n" b"::1 foobar.example.com\n" ) self.assertEqual( ["127.0.0.1", "127.0.0.2", "::1"], searchFileForAll(hosts, b"foobar.example.com"), ) def test_caseInsensitively(self): """ L{searchFileForAll} searches for names case-insensitively. """ hosts = self.path() hosts.setContent(b"127.0.0.1 foobar.EXAMPLE.com\n") self.assertEqual(["127.0.0.1"], searchFileForAll(hosts, b"FOOBAR.example.com")) def test_readError(self): """ If there is an error reading the contents of the hosts file, L{searchFileForAll} returns an empty list. """ self.assertEqual([], searchFileForAll(self.path(), b"example.com")) def test_malformedIP(self): """ L{searchFileForAll} ignores any malformed IP addresses associated with the name passed to it. """ hosts = self.path() hosts.setContent( b"127.0.0.1\tmiser.example.org\tmiser\n" b"not-an-ip\tmiser\n" b"\xffnot-ascii\t miser\n" b"# miser\n" b"miser\n" b"::1 miser" ) self.assertEqual( ["127.0.0.1", "::1"], searchFileForAll(hosts, b"miser"), ) class HostsTests(SynchronousTestCase, GoodTempPathMixin): """ Tests for the I{hosts(5)}-based L{twisted.names.hosts.Resolver}. """ def setUp(self): f = self.path() f.setContent( b""" 1.1.1.1 EXAMPLE EXAMPLE.EXAMPLETHING ::2 mixed 1.1.1.2 MIXED ::1 ip6thingy 1.1.1.3 multiple 1.1.1.4 multiple ::3 ip6-multiple ::4 ip6-multiple not-an-ip malformed malformed # malformed 1.1.1.5 malformed ::5 malformed """ ) self.ttl = 4200 self.resolver = Resolver(f.path, self.ttl) def test_defaultPath(self): """ The default hosts file used by L{Resolver} is I{/etc/hosts} if no value is given for the C{file} initializer parameter. """ resolver = Resolver() self.assertEqual(b"/etc/hosts", resolver.file) def test_getHostByName(self): """ L{hosts.Resolver.getHostByName} returns a L{Deferred} which fires with a string giving the address of the queried name as found in the resolver's hosts file. """ data = [ (b"EXAMPLE", "1.1.1.1"), (b"EXAMPLE.EXAMPLETHING", "1.1.1.1"), (b"MIXED", "1.1.1.2"), ] ds = [ self.resolver.getHostByName(n).addCallback(self.assertEqual, ip) for n, ip in data ] self.successResultOf(gatherResults(ds)) def test_lookupAddress(self): """ L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with A records from the hosts file. """ d = self.resolver.lookupAddress(b"multiple") answers, authority, additional = self.successResultOf(d) self.assertEqual( ( RRHeader(b"multiple", A, IN, self.ttl, Record_A("1.1.1.3", self.ttl)), RRHeader(b"multiple", A, IN, self.ttl, Record_A("1.1.1.4", self.ttl)), ), answers, ) def test_lookupIPV6Address(self): """ L{hosts.Resolver.lookupIPV6Address} returns a L{Deferred} which fires with AAAA records from the hosts file. """ d = self.resolver.lookupIPV6Address(b"ip6-multiple") answers, authority, additional = self.successResultOf(d) self.assertEqual( ( RRHeader( b"ip6-multiple", AAAA, IN, self.ttl, Record_AAAA("::3", self.ttl) ), RRHeader( b"ip6-multiple", AAAA, IN, self.ttl, Record_AAAA("::4", self.ttl) ), ), answers, ) def test_lookupAllRecords(self): """ L{hosts.Resolver.lookupAllRecords} returns a L{Deferred} which fires with A records from the hosts file. """ d = self.resolver.lookupAllRecords(b"mixed") answers, authority, additional = self.successResultOf(d) self.assertEqual( (RRHeader(b"mixed", A, IN, self.ttl, Record_A("1.1.1.2", self.ttl)),), answers, ) def test_notImplemented(self): """ L{hosts.Resolver} fails with L{NotImplementedError} for L{IResolver} methods it doesn't implement. """ self.failureResultOf( self.resolver.lookupMailExchange(b"EXAMPLE"), NotImplementedError ) def test_query(self): d = self.resolver.query(Query(b"EXAMPLE")) [answer], authority, additional = self.successResultOf(d) self.assertEqual(answer.payload.dottedQuad(), "1.1.1.1") def test_lookupAddressNotFound(self): """ L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with L{dns.DomainError} if the name passed in has no addresses in the hosts file. """ self.failureResultOf(self.resolver.lookupAddress(b"foueoa"), DomainError) def test_lookupIPV6AddressNotFound(self): """ Like L{test_lookupAddressNotFound}, but for L{hosts.Resolver.lookupIPV6Address}. """ self.failureResultOf(self.resolver.lookupIPV6Address(b"foueoa"), DomainError) def test_lookupAllRecordsNotFound(self): """ Like L{test_lookupAddressNotFound}, but for L{hosts.Resolver.lookupAllRecords}. """ self.failureResultOf(self.resolver.lookupAllRecords(b"foueoa"), DomainError) def test_lookupMalformed(self): """ L{hosts.Resolver.lookupAddress} returns a L{Deferred} which fires with the valid addresses from the hosts file, ignoring any entries that aren't valid IP addresses. """ d = self.resolver.lookupAddress(b"malformed") [answer], authority, additional = self.successResultOf(d) self.assertEqual( RRHeader(b"malformed", A, IN, self.ttl, Record_A("1.1.1.5", self.ttl)), answer, ) def test_lookupIPV6Malformed(self): """ Like L{test_lookupAddressMalformed}, but for L{hosts.Resolver.lookupIPV6Address}. """ d = self.resolver.lookupIPV6Address(b"malformed") [answer], authority, additional = self.successResultOf(d) self.assertEqual( RRHeader(b"malformed", AAAA, IN, self.ttl, Record_AAAA("::5", self.ttl)), answer, ) PK Mb�ZI�Q��s �s names/test/test_dns.pynu �[��� # test-case-name: twisted.names.test.test_dns # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for twisted.names.dns. """ import struct from io import BytesIO from typing import cast from zope.interface.verify import verifyClass from twisted.internet import address, task from twisted.internet.error import CannotListenError, ConnectionDone from twisted.names import dns from twisted.python.failure import Failure from twisted.python.util import FancyEqMixin, FancyStrMixin from twisted.test import proto_helpers from twisted.test.testutils import ComparisonTestsMixin from twisted.trial import unittest RECORD_TYPES = [ dns.Record_NS, dns.Record_MD, dns.Record_MF, dns.Record_CNAME, dns.Record_MB, dns.Record_MG, dns.Record_MR, dns.Record_PTR, dns.Record_DNAME, dns.Record_A, dns.Record_SOA, dns.Record_NULL, dns.Record_WKS, dns.Record_SRV, dns.Record_AFSDB, dns.Record_RP, dns.Record_HINFO, dns.Record_MINFO, dns.Record_MX, dns.Record_TXT, dns.Record_AAAA, dns.Record_A6, dns.Record_NAPTR, dns.Record_SSHFP, dns.Record_TSIG, dns.UnknownRecord, ] class DomainStringTests(unittest.SynchronousTestCase): def test_bytes(self): """ L{dns.domainString} returns L{bytes} unchanged. """ self.assertEqual( b"twistedmatrix.com", dns.domainString(b"twistedmatrix.com"), ) def test_native(self): """ L{dns.domainString} converts a native string to L{bytes} if necessary. """ self.assertEqual(b"example.com", dns.domainString("example.com")) def test_text(self): """ L{dns.domainString} always converts a unicode string to L{bytes}. """ self.assertEqual(b"foo.example", dns.domainString("foo.example")) def test_idna(self): """ L{dns.domainString} encodes Unicode using IDNA. """ self.assertEqual(b"xn--fwg.test", dns.domainString("\u203D.test")) def test_nonsense(self): """ L{dns.domainString} encodes Unicode using IDNA. """ self.assertRaises(TypeError, dns.domainString, 9000) self.assertRaises(TypeError, dns.domainString, dns.Name("bar.example")) class Ord2ByteTests(unittest.TestCase): """ Tests for L{dns._ord2bytes}. """ def test_ord2byte(self): """ L{dns._ord2byte} accepts an integer and returns a byte string of length one with an ordinal value equal to the given integer. """ self.assertEqual(b"\x10", dns._ord2bytes(0x10)) class Str2TimeTests(unittest.TestCase): """ Tests for L{dns.str2name}. """ def test_nonString(self): """ When passed a non-string object, L{dns.str2name} returns it unmodified. """ time = object() self.assertIs(time, dns.str2time(time)) def test_seconds(self): """ Passed a string giving a number of seconds, L{dns.str2time} returns the number of seconds represented. For example, C{"10S"} represents C{10} seconds. """ self.assertEqual(10, dns.str2time("10S")) def test_minutes(self): """ Like C{test_seconds}, but for the C{"M"} suffix which multiplies the time value by C{60} (the number of seconds in a minute!). """ self.assertEqual(2 * 60, dns.str2time("2M")) def test_hours(self): """ Like C{test_seconds}, but for the C{"H"} suffix which multiplies the time value by C{3600}, the number of seconds in an hour. """ self.assertEqual(3 * 3600, dns.str2time("3H")) def test_days(self): """ Like L{test_seconds}, but for the C{"D"} suffix which multiplies the time value by C{86400}, the number of seconds in a day. """ self.assertEqual(4 * 86400, dns.str2time("4D")) def test_weeks(self): """ Like L{test_seconds}, but for the C{"W"} suffix which multiplies the time value by C{604800}, the number of seconds in a week. """ self.assertEqual(5 * 604800, dns.str2time("5W")) def test_years(self): """ Like L{test_seconds}, but for the C{"Y"} suffix which multiplies the time value by C{31536000}, the number of seconds in a year. """ self.assertEqual(6 * 31536000, dns.str2time("6Y")) def test_invalidPrefix(self): """ If a non-integer prefix is given, L{dns.str2time} raises L{ValueError}. """ self.assertRaises(ValueError, dns.str2time, "fooS") class NameTests(unittest.TestCase): """ Tests for L{Name}, the representation of a single domain name with support for encoding into and decoding from DNS message format. """ def test_nonStringName(self): """ When constructed with a name which is neither C{bytes} nor C{str}, L{Name} raises L{TypeError}. """ self.assertRaises(TypeError, dns.Name, 123) self.assertRaises(TypeError, dns.Name, object()) self.assertRaises(TypeError, dns.Name, []) def test_unicodeName(self): """ L{dns.Name} automatically encodes unicode domain name using C{idna} encoding. """ name = dns.Name("\u00e9chec.example.org") self.assertIsInstance(name.name, bytes) self.assertEqual(b"xn--chec-9oa.example.org", name.name) def test_decode(self): """ L{Name.decode} populates the L{Name} instance with name information read from the file-like object passed to it. """ n = dns.Name() n.decode(BytesIO(b"\x07example\x03com\x00")) self.assertEqual(n.name, b"example.com") def test_encode(self): """ L{Name.encode} encodes its name information and writes it to the file-like object passed to it. """ name = dns.Name(b"foo.example.com") stream = BytesIO() name.encode(stream) self.assertEqual(stream.getvalue(), b"\x03foo\x07example\x03com\x00") def test_encodeWithCompression(self): """ If a compression dictionary is passed to it, L{Name.encode} uses offset information from it to encode its name with references to existing labels in the stream instead of including another copy of them in the output. It also updates the compression dictionary with the location of the name it writes to the stream. """ name = dns.Name(b"foo.example.com") compression = {b"example.com": 0x17} # Some bytes already encoded into the stream for this message previous = b"some prefix to change .tell()" stream = BytesIO() stream.write(previous) # The position at which the encoded form of this new name will appear in # the stream. expected = len(previous) + dns.Message.headerSize name.encode(stream, compression) self.assertEqual(b"\x03foo\xc0\x17", stream.getvalue()[len(previous) :]) self.assertEqual( {b"example.com": 0x17, b"foo.example.com": expected}, compression ) def test_unknown(self): """ A resource record of unknown type and class is parsed into an L{UnknownRecord} instance with its data preserved, and an L{UnknownRecord} instance is serialized to a string equal to the one it was parsed from. """ wire = ( b"\x01\x00" # Message ID b"\x00" # answer bit, opCode nibble, auth bit, trunc bit, recursive # bit b"\x00" # recursion bit, empty bit, authenticData bit, # checkingDisabled bit, response code nibble b"\x00\x01" # number of queries b"\x00\x01" # number of answers b"\x00\x00" # number of authorities b"\x00\x01" # number of additionals # query b"\x03foo\x03bar\x00" # foo.bar b"\xde\xad" # type=0xdead b"\xbe\xef" # cls=0xbeef # 1st answer b"\xc0\x0c" # foo.bar - compressed b"\xde\xad" # type=0xdead b"\xbe\xef" # cls=0xbeef b"\x00\x00\x01\x01" # ttl=257 b"\x00\x08somedata" # some payload data # 1st additional b"\x03baz\x03ban\x00" # baz.ban b"\x00\x01" # type=A b"\x00\x01" # cls=IN b"\x00\x00\x01\x01" # ttl=257 b"\x00\x04" # len=4 b"\x01\x02\x03\x04" # 1.2.3.4 ) msg = dns.Message() msg.fromStr(wire) self.assertEqual( msg.queries, [ dns.Query(b"foo.bar", type=0xDEAD, cls=0xBEEF), ], ) self.assertEqual( msg.answers, [ dns.RRHeader( b"foo.bar", type=0xDEAD, cls=0xBEEF, ttl=257, payload=dns.UnknownRecord(b"somedata", ttl=257), ), ], ) self.assertEqual( msg.additional, [ dns.RRHeader( b"baz.ban", type=dns.A, cls=dns.IN, ttl=257, payload=dns.Record_A("1.2.3.4", ttl=257), ), ], ) enc = msg.toStr() self.assertEqual(enc, wire) def test_decodeWithCompression(self): """ If the leading byte of an encoded label (in bytes read from a stream passed to L{Name.decode}) has its two high bits set, the next byte is treated as a pointer to another label in the stream and that label is included in the name being decoded. """ # Slightly modified version of the example from RFC 1035, section 4.1.4. stream = BytesIO( b"x" * 20 + b"\x01f\x03isi\x04arpa\x00" b"\x03foo\xc0\x14" b"\x03bar\xc0\x20" ) stream.seek(20) name = dns.Name() name.decode(stream) # Verify we found the first name in the stream and that the stream # position is left at the first byte after the decoded name. self.assertEqual(b"f.isi.arpa", name.name) self.assertEqual(32, stream.tell()) # Get the second name from the stream and make the same assertions. name.decode(stream) self.assertEqual(name.name, b"foo.f.isi.arpa") self.assertEqual(38, stream.tell()) # Get the third and final name name.decode(stream) self.assertEqual(name.name, b"bar.foo.f.isi.arpa") self.assertEqual(44, stream.tell()) def test_rejectCompressionLoop(self): """ L{Name.decode} raises L{ValueError} if the stream passed to it includes a compression pointer which forms a loop, causing the name to be undecodable. """ name = dns.Name() stream = BytesIO(b"\xc0\x00") self.assertRaises(ValueError, name.decode, stream) def test_equality(self): """ L{Name} instances are equal as long as they have the same value for L{Name.name}, regardless of the case. """ name1 = dns.Name(b"foo.bar") name2 = dns.Name(b"foo.bar") self.assertEqual(name1, name2) name3 = dns.Name(b"fOO.bar") self.assertEqual(name1, name3) def test_inequality(self): """ L{Name} instances are not equal as long as they have different L{Name.name} attributes. """ name1 = dns.Name(b"foo.bar") name2 = dns.Name(b"bar.foo") self.assertNotEqual(name1, name2) class RoundtripDNSTests(unittest.TestCase): """ Encoding and then decoding various objects. """ names = [b"example.org", b"go-away.fish.tv", b"23strikesback.net"] def test_name(self): for n in self.names: # encode the name f = BytesIO() dns.Name(n).encode(f) # decode the name f.seek(0, 0) result = dns.Name() result.decode(f) self.assertEqual(result.name, n) def test_query(self): """ L{dns.Query.encode} returns a byte string representing the fields of the query which can be decoded into a new L{dns.Query} instance using L{dns.Query.decode}. """ for n in self.names: for dnstype in range(1, 17): for dnscls in range(1, 5): # encode the query f = BytesIO() dns.Query(n, dnstype, dnscls).encode(f) # decode the result f.seek(0, 0) result = dns.Query() result.decode(f) self.assertEqual(result.name.name, n) self.assertEqual(result.type, dnstype) self.assertEqual(result.cls, dnscls) def test_resourceRecordHeader(self): """ L{dns.RRHeader.encode} encodes the record header's information and writes it to the file-like object passed to it and L{dns.RRHeader.decode} reads from a file-like object to re-construct a L{dns.RRHeader} instance. """ # encode the RR f = BytesIO() dns.RRHeader(b"test.org", 3, 4, 17).encode(f) # decode the result f.seek(0, 0) result = dns.RRHeader() result.decode(f) self.assertEqual(result.name, dns.Name(b"test.org")) self.assertEqual(result.type, 3) self.assertEqual(result.cls, 4) self.assertEqual(result.ttl, 17) def test_resourceRecordHeaderTypeMismatch(self): """ L{RRHeader()} raises L{ValueError} when the given type and the type of the payload don't match. """ with self.assertRaisesRegex(ValueError, r"Payload type \(AAAA\) .* type \(A\)"): dns.RRHeader(type=dns.A, payload=dns.Record_AAAA()) def test_resources(self): """ L{dns.SimpleRecord.encode} encodes the record's name information and writes it to the file-like object passed to it and L{dns.SimpleRecord.decode} reads from a file-like object to re-construct a L{dns.SimpleRecord} instance. """ names = ( b"this.are.test.name", b"will.compress.will.this.will.name.will.hopefully", b"test.CASE.preSErVatIOn.YeAH", b"a.s.h.o.r.t.c.a.s.e.t.o.t.e.s.t", b"singleton", ) for s in names: f = BytesIO() dns.SimpleRecord(s).encode(f) f.seek(0, 0) result = dns.SimpleRecord() result.decode(f) self.assertEqual(result.name, dns.Name(s)) def test_hashable(self): """ Instances of all record types are hashable. """ for k in RECORD_TYPES: k1, k2 = k(), k() hk1 = hash(k1) hk2 = hash(k2) self.assertEqual(hk1, hk2, f"{hk1} != {hk2} (for {k})") def test_Charstr(self): """ Test L{dns.Charstr} encode and decode. """ for n in self.names: # encode the name f = BytesIO() dns.Charstr(n).encode(f) # decode the name f.seek(0, 0) result = dns.Charstr() result.decode(f) self.assertEqual(result.string, n) def _recordRoundtripTest(self, record): """ Assert that encoding C{record} and then decoding the resulting bytes creates a record which compares equal to C{record}. @type record: L{dns.IEncodable} @param record: A record instance to encode """ stream = BytesIO() record.encode(stream) length = stream.tell() stream.seek(0, 0) replica = record.__class__() replica.decode(stream, length) self.assertEqual(record, replica) def assertEncodedFormat(self, expectedEncoding, record): """ Assert that encoding C{record} produces the expected bytes. @type record: L{dns.IEncodable} @param record: A record instance to encode @type expectedEncoding: L{bytes} @param expectedEncoding: The value which C{record.encode()} should produce. """ stream = BytesIO() record.encode(stream) self.assertEqual(stream.getvalue(), expectedEncoding) def test_SOA(self): """ The byte stream written by L{dns.Record_SOA.encode} can be used by L{dns.Record_SOA.decode} to reconstruct the state of the original L{dns.Record_SOA} instance. """ self._recordRoundtripTest( dns.Record_SOA( mname=b"foo", rname=b"bar", serial=12, refresh=34, retry=56, expire=78, minimum=90, ) ) def test_A(self): """ The byte stream written by L{dns.Record_A.encode} can be used by L{dns.Record_A.decode} to reconstruct the state of the original L{dns.Record_A} instance. """ self._recordRoundtripTest(dns.Record_A("1.2.3.4")) def test_NULL(self): """ The byte stream written by L{dns.Record_NULL.encode} can be used by L{dns.Record_NULL.decode} to reconstruct the state of the original L{dns.Record_NULL} instance. """ self._recordRoundtripTest(dns.Record_NULL(b"foo bar")) def test_WKS(self): """ The byte stream written by L{dns.Record_WKS.encode} can be used by L{dns.Record_WKS.decode} to reconstruct the state of the original L{dns.Record_WKS} instance. """ self._recordRoundtripTest(dns.Record_WKS("1.2.3.4", 3, b"xyz")) def test_AAAA(self): """ The byte stream written by L{dns.Record_AAAA.encode} can be used by L{dns.Record_AAAA.decode} to reconstruct the state of the original L{dns.Record_AAAA} instance. """ self._recordRoundtripTest(dns.Record_AAAA("::1")) def test_A6(self): """ The byte stream written by L{dns.Record_A6.encode} can be used by L{dns.Record_A6.decode} to reconstruct the state of the original L{dns.Record_A6} instance. """ self._recordRoundtripTest(dns.Record_A6(8, "::1:2", b"foo")) def test_SRV(self): """ The byte stream written by L{dns.Record_SRV.encode} can be used by L{dns.Record_SRV.decode} to reconstruct the state of the original L{dns.Record_SRV} instance. """ self._recordRoundtripTest( dns.Record_SRV(priority=1, weight=2, port=3, target=b"example.com") ) def test_SSHFP(self): """ The byte stream written by L{dns.Record_SSHFP.encode} can be used by L{dns.Record_SSHFP.decode} to reconstruct the state of the original L{dns.Record_SSHFP} instance. """ fp = ( b"\xda\x39\xa3\xee\x5e\x6b\x4b\x0d" + b"\x32\x55\xbf\xef\x95\x60\x18\x90\xaf\xd8\x07\x09" ) rr = dns.Record_SSHFP( algorithm=dns.Record_SSHFP.ALGORITHM_DSS, fingerprintType=dns.Record_SSHFP.FINGERPRINT_TYPE_SHA1, fingerprint=fp, ) self._recordRoundtripTest(rr) self.assertEncodedFormat(b"\x02\x01" + fp, rr) def test_NAPTR(self): """ Test L{dns.Record_NAPTR} encode and decode. """ naptrs = [ (100, 10, b"u", b"sip+E2U", b"!^.*$!sip:information@domain.tld!", b""), (100, 50, b"s", b"http+I2L+I2C+I2R", b"", b"_http._tcp.gatech.edu"), ] for (order, preference, flags, service, regexp, replacement) in naptrs: rin = dns.Record_NAPTR( order, preference, flags, service, regexp, replacement ) e = BytesIO() rin.encode(e) e.seek(0, 0) rout = dns.Record_NAPTR() rout.decode(e) self.assertEqual(rin.order, rout.order) self.assertEqual(rin.preference, rout.preference) self.assertEqual(rin.flags, rout.flags) self.assertEqual(rin.service, rout.service) self.assertEqual(rin.regexp, rout.regexp) self.assertEqual(rin.replacement.name, rout.replacement.name) self.assertEqual(rin.ttl, rout.ttl) def test_AFSDB(self): """ The byte stream written by L{dns.Record_AFSDB.encode} can be used by L{dns.Record_AFSDB.decode} to reconstruct the state of the original L{dns.Record_AFSDB} instance. """ self._recordRoundtripTest(dns.Record_AFSDB(subtype=3, hostname=b"example.com")) def test_RP(self): """ The byte stream written by L{dns.Record_RP.encode} can be used by L{dns.Record_RP.decode} to reconstruct the state of the original L{dns.Record_RP} instance. """ self._recordRoundtripTest( dns.Record_RP(mbox=b"alice.example.com", txt=b"example.com") ) def test_HINFO(self): """ The byte stream written by L{dns.Record_HINFO.encode} can be used by L{dns.Record_HINFO.decode} to reconstruct the state of the original L{dns.Record_HINFO} instance. """ self._recordRoundtripTest(dns.Record_HINFO(cpu=b"fast", os=b"great")) def test_MINFO(self): """ The byte stream written by L{dns.Record_MINFO.encode} can be used by L{dns.Record_MINFO.decode} to reconstruct the state of the original L{dns.Record_MINFO} instance. """ self._recordRoundtripTest(dns.Record_MINFO(rmailbx=b"foo", emailbx=b"bar")) def test_MX(self): """ The byte stream written by L{dns.Record_MX.encode} can be used by L{dns.Record_MX.decode} to reconstruct the state of the original L{dns.Record_MX} instance. """ self._recordRoundtripTest(dns.Record_MX(preference=1, name=b"example.com")) def test_TSIG(self): """ The byte stream written by L{dns.Record_TSIG.encode} can be used by L{dns.Record_TSIG.decode} to reconstruct the state of the original L{dns.Record_TSIG} instance. """ mac = b"\x00\x01\x02\x03\x10\x11\x12\x13" b"\x20\x21\x22\x23\x30\x31\x32\x33" rr = dns.Record_TSIG( algorithm="hmac-md5.sig-alg.reg.int", timeSigned=1515548975, originalID=42, fudge=5, MAC=mac, ) self._recordRoundtripTest(rr) rdata = ( b"\x08hmac-md5\x07sig-alg\x03reg\x03int\x00" b"\x00\x00\x5a\x55\x71\x2f\x00\x05\x00\x10" + mac + b"\x00\x2A\x00\x00\x00\x00" ) self.assertEncodedFormat(rdata, rr) rr = dns.Record_TSIG( algorithm="hmac-sha256", timeSigned=4511798055, # More than 32 bits originalID=65535, error=dns.EBADTIME, otherData=b"\x80\x00\x00\x00\x00\x08", MAC=mac, ) self._recordRoundtripTest(rr) rdata = ( b"\x0Bhmac-sha256\x00" b"\x00\x01\x0c\xec\x93\x27\x00\x05\x00\x10" + mac + b"\xff\xff\x00\x12\x00\x06" b"\x80\x00\x00\x00\x00\x08" ) self.assertEncodedFormat(rdata, rr) def test_TXT(self): """ The byte stream written by L{dns.Record_TXT.encode} can be used by L{dns.Record_TXT.decode} to reconstruct the state of the original L{dns.Record_TXT} instance. """ self._recordRoundtripTest(dns.Record_TXT(b"foo", b"bar")) MESSAGE_AUTHENTIC_DATA_BYTES = ( b"\x00\x00" # ID b"\x00" # b"\x20" # RA, Z, AD=1, CD, RCODE b"\x00\x00" # Query count b"\x00\x00" # Answer count b"\x00\x00" # Authority count b"\x00\x00" # Additional count ) MESSAGE_CHECKING_DISABLED_BYTES = ( b"\x00\x00" # ID b"\x00" # b"\x10" # RA, Z, AD, CD=1, RCODE b"\x00\x00" # Query count b"\x00\x00" # Answer count b"\x00\x00" # Authority count b"\x00\x00" # Additional count ) class MessageTests(unittest.SynchronousTestCase): """ Tests for L{twisted.names.dns.Message}. """ def test_authenticDataDefault(self): """ L{dns.Message.authenticData} has default value 0. """ self.assertEqual(dns.Message().authenticData, 0) def test_authenticDataOverride(self): """ L{dns.Message.__init__} accepts a C{authenticData} argument which is assigned to L{dns.Message.authenticData}. """ self.assertEqual(dns.Message(authenticData=1).authenticData, 1) def test_authenticDataEncode(self): """ L{dns.Message.toStr} encodes L{dns.Message.authenticData} into byte4 of the byte string. """ self.assertEqual( dns.Message(authenticData=1).toStr(), MESSAGE_AUTHENTIC_DATA_BYTES ) def test_authenticDataDecode(self): """ L{dns.Message.fromStr} decodes byte4 and assigns bit3 to L{dns.Message.authenticData}. """ m = dns.Message() m.fromStr(MESSAGE_AUTHENTIC_DATA_BYTES) self.assertEqual(m.authenticData, 1) def test_checkingDisabledDefault(self): """ L{dns.Message.checkingDisabled} has default value 0. """ self.assertEqual(dns.Message().checkingDisabled, 0) def test_checkingDisabledOverride(self): """ L{dns.Message.__init__} accepts a C{checkingDisabled} argument which is assigned to L{dns.Message.checkingDisabled}. """ self.assertEqual(dns.Message(checkingDisabled=1).checkingDisabled, 1) def test_checkingDisabledEncode(self): """ L{dns.Message.toStr} encodes L{dns.Message.checkingDisabled} into byte4 of the byte string. """ self.assertEqual( dns.Message(checkingDisabled=1).toStr(), MESSAGE_CHECKING_DISABLED_BYTES ) def test_checkingDisabledDecode(self): """ L{dns.Message.fromStr} decodes byte4 and assigns bit4 to L{dns.Message.checkingDisabled}. """ m = dns.Message() m.fromStr(MESSAGE_CHECKING_DISABLED_BYTES) self.assertEqual(m.checkingDisabled, 1) def test_reprDefaults(self): """ L{dns.Message.__repr__} omits field values and sections which are identical to their defaults. The id field value is always shown. """ self.assertEqual("<Message id=0>", repr(dns.Message())) def test_reprFlagsIfSet(self): """ L{dns.Message.__repr__} displays flags if they are L{True}. """ m = dns.Message( answer=True, auth=True, trunc=True, recDes=True, recAv=True, authenticData=True, checkingDisabled=True, ) self.assertEqual( "<Message " "id=0 " "flags=answer,auth,trunc,recDes,recAv,authenticData," "checkingDisabled" ">", repr(m), ) def test_reprNonDefautFields(self): """ L{dns.Message.__repr__} displays field values if they differ from their defaults. """ m = dns.Message(id=10, opCode=20, rCode=30, maxSize=40) self.assertEqual( "<Message " "id=10 " "opCode=20 " "rCode=30 " "maxSize=40" ">", repr(m), ) def test_reprNonDefaultSections(self): """ L{dns.Message.__repr__} displays sections which differ from their defaults. """ m = dns.Message() m.queries = [1, 2, 3] m.answers = [4, 5, 6] m.authority = [7, 8, 9] m.additional = [10, 11, 12] self.assertEqual( "<Message " "id=0 " "queries=[1, 2, 3] " "answers=[4, 5, 6] " "authority=[7, 8, 9] " "additional=[10, 11, 12]" ">", repr(m), ) def test_emptyMessage(self): """ Test that a message which has been truncated causes an EOFError to be raised when it is parsed. """ msg = dns.Message() self.assertRaises(EOFError, msg.fromStr, b"") def test_emptyQuery(self): """ Test that bytes representing an empty query message can be decoded as such. """ msg = dns.Message() msg.fromStr( b"\x01\x00" # Message ID b"\x00" # answer bit, opCode nibble, auth bit, trunc bit, recursive bit b"\x00" # recursion bit, empty bit, authenticData bit, # checkingDisabled bit, response code nibble b"\x00\x00" # number of queries b"\x00\x00" # number of answers b"\x00\x00" # number of authorities b"\x00\x00" # number of additionals ) self.assertEqual(msg.id, 256) self.assertFalse(msg.answer, "Message was not supposed to be an answer.") self.assertEqual(msg.opCode, dns.OP_QUERY) self.assertFalse(msg.auth, "Message was not supposed to be authoritative.") self.assertFalse(msg.trunc, "Message was not supposed to be truncated.") self.assertEqual(msg.queries, []) self.assertEqual(msg.answers, []) self.assertEqual(msg.authority, []) self.assertEqual(msg.additional, []) def test_NULL(self): """ A I{NULL} record with an arbitrary payload can be encoded and decoded as part of a L{dns.Message}. """ bytes = b"".join([dns._ord2bytes(i) for i in range(256)]) rec = dns.Record_NULL(bytes) rr = dns.RRHeader(b"testname", dns.NULL, payload=rec) msg1 = dns.Message() msg1.answers.append(rr) s = BytesIO() msg1.encode(s) s.seek(0, 0) msg2 = dns.Message() msg2.decode(s) self.assertIsInstance(msg2.answers[0].payload, dns.Record_NULL) self.assertEqual(msg2.answers[0].payload.payload, bytes) def test_lookupRecordTypeDefault(self): """ L{Message.lookupRecordType} returns C{dns.UnknownRecord} if it is called with an integer which doesn't correspond to any known record type. """ # 65280 is the first value in the range reserved for private # use, so it shouldn't ever conflict with an officially # allocated value. self.assertIs(dns.Message().lookupRecordType(65280), dns.UnknownRecord) def test_nonAuthoritativeMessage(self): """ The L{RRHeader} instances created by L{Message} from a non-authoritative message are marked as not authoritative. """ buf = BytesIO() answer = dns.RRHeader(payload=dns.Record_A("1.2.3.4", ttl=0)) answer.encode(buf) message = dns.Message() message.fromStr( b"\x01\x00" # Message ID # answer bit, opCode nibble, auth bit, trunc bit, recursive bit b"\x00" # recursion bit, empty bit, authenticData bit, # checkingDisabled bit, response code nibble b"\x00" b"\x00\x00" # number of queries b"\x00\x01" # number of answers b"\x00\x00" # number of authorities b"\x00\x00" + buf.getvalue() # number of additionals ) self.assertEqual(message.answers, [answer]) self.assertFalse(message.answers[0].auth) def test_authoritativeMessage(self): """ The L{RRHeader} instances created by L{Message} from an authoritative message are marked as authoritative. """ buf = BytesIO() answer = dns.RRHeader(payload=dns.Record_A("1.2.3.4", ttl=0)) answer.encode(buf) message = dns.Message() message.fromStr( b"\x01\x00" # Message ID # answer bit, opCode nibble, auth bit, trunc bit, recursive bit b"\x04" # recursion bit, empty bit, authenticData bit, # checkingDisabled bit, response code nibble b"\x00" b"\x00\x00" # number of queries b"\x00\x01" # number of answers b"\x00\x00" # number of authorities b"\x00\x00" + buf.getvalue() # number of additionals ) answer.auth = True self.assertEqual(message.answers, [answer]) self.assertTrue(message.answers[0].auth) class MessageComparisonTests(ComparisonTestsMixin, unittest.SynchronousTestCase): """ Tests for the rich comparison of L{dns.Message} instances. """ def messageFactory(self, *args, **kwargs): """ Create a L{dns.Message}. The L{dns.Message} constructor doesn't accept C{queries}, C{answers}, C{authority}, C{additional} arguments, so we extract them from the kwargs supplied to this factory function and assign them to the message. @param args: Positional arguments. @param kwargs: Keyword arguments. @return: A L{dns.Message} instance. """ queries = kwargs.pop("queries", []) answers = kwargs.pop("answers", []) authority = kwargs.pop("authority", []) additional = kwargs.pop("additional", []) m = dns.Message(**kwargs) if queries: m.queries = queries if answers: m.answers = answers if authority: m.authority = authority if additional: m.additional = additional return m def test_id(self): """ Two L{dns.Message} instances compare equal if they have the same id value. """ self.assertNormalEqualityImplementation( self.messageFactory(id=10), self.messageFactory(id=10), self.messageFactory(id=20), ) def test_answer(self): """ Two L{dns.Message} instances compare equal if they have the same answer flag. """ self.assertNormalEqualityImplementation( self.messageFactory(answer=1), self.messageFactory(answer=1), self.messageFactory(answer=0), ) def test_opCode(self): """ Two L{dns.Message} instances compare equal if they have the same opCode value. """ self.assertNormalEqualityImplementation( self.messageFactory(opCode=10), self.messageFactory(opCode=10), self.messageFactory(opCode=20), ) def test_recDes(self): """ Two L{dns.Message} instances compare equal if they have the same recDes flag. """ self.assertNormalEqualityImplementation( self.messageFactory(recDes=1), self.messageFactory(recDes=1), self.messageFactory(recDes=0), ) def test_recAv(self): """ Two L{dns.Message} instances compare equal if they have the same recAv flag. """ self.assertNormalEqualityImplementation( self.messageFactory(recAv=1), self.messageFactory(recAv=1), self.messageFactory(recAv=0), ) def test_auth(self): """ Two L{dns.Message} instances compare equal if they have the same auth flag. """ self.assertNormalEqualityImplementation( self.messageFactory(auth=1), self.messageFactory(auth=1), self.messageFactory(auth=0), ) def test_rCode(self): """ Two L{dns.Message} instances compare equal if they have the same rCode value. """ self.assertNormalEqualityImplementation( self.messageFactory(rCode=10), self.messageFactory(rCode=10), self.messageFactory(rCode=20), ) def test_trunc(self): """ Two L{dns.Message} instances compare equal if they have the same trunc flag. """ self.assertNormalEqualityImplementation( self.messageFactory(trunc=1), self.messageFactory(trunc=1), self.messageFactory(trunc=0), ) def test_maxSize(self): """ Two L{dns.Message} instances compare equal if they have the same maxSize value. """ self.assertNormalEqualityImplementation( self.messageFactory(maxSize=10), self.messageFactory(maxSize=10), self.messageFactory(maxSize=20), ) def test_authenticData(self): """ Two L{dns.Message} instances compare equal if they have the same authenticData flag. """ self.assertNormalEqualityImplementation( self.messageFactory(authenticData=1), self.messageFactory(authenticData=1), self.messageFactory(authenticData=0), ) def test_checkingDisabled(self): """ Two L{dns.Message} instances compare equal if they have the same checkingDisabled flag. """ self.assertNormalEqualityImplementation( self.messageFactory(checkingDisabled=1), self.messageFactory(checkingDisabled=1), self.messageFactory(checkingDisabled=0), ) def test_queries(self): """ Two L{dns.Message} instances compare equal if they have the same queries. """ self.assertNormalEqualityImplementation( self.messageFactory(queries=[dns.Query(b"example.com")]), self.messageFactory(queries=[dns.Query(b"example.com")]), self.messageFactory(queries=[dns.Query(b"example.org")]), ) def test_answers(self): """ Two L{dns.Message} instances compare equal if they have the same answers. """ self.assertNormalEqualityImplementation( self.messageFactory( answers=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ), self.messageFactory( answers=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ), self.messageFactory( answers=[dns.RRHeader(b"example.org", payload=dns.Record_A("4.3.2.1"))] ), ) def test_authority(self): """ Two L{dns.Message} instances compare equal if they have the same authority records. """ self.assertNormalEqualityImplementation( self.messageFactory( authority=[ dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA()) ] ), self.messageFactory( authority=[ dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA()) ] ), self.messageFactory( authority=[ dns.RRHeader(b"example.org", type=dns.SOA, payload=dns.Record_SOA()) ] ), ) def test_additional(self): """ Two L{dns.Message} instances compare equal if they have the same additional records. """ self.assertNormalEqualityImplementation( self.messageFactory( additional=[ dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")) ] ), self.messageFactory( additional=[ dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")) ] ), self.messageFactory( additional=[ dns.RRHeader(b"example.org", payload=dns.Record_A("1.2.3.4")) ] ), ) class TestController: """ Pretend to be a DNS query processor for a DNSDatagramProtocol. @ivar messages: the list of received messages. @type messages: C{list} of (msg, protocol, address) """ def __init__(self): """ Initialize the controller: create a list of messages. """ self.messages = [] def messageReceived(self, msg, proto, addr=None): """ Save the message so that it can be checked during the tests. """ self.messages.append((msg, proto, addr)) class DatagramProtocolTests(unittest.TestCase): """ Test various aspects of L{dns.DNSDatagramProtocol}. """ def setUp(self): """ Create a L{dns.DNSDatagramProtocol} with a deterministic clock. """ self.clock = task.Clock() self.controller = TestController() self.proto = dns.DNSDatagramProtocol(self.controller) transport = proto_helpers.FakeDatagramTransport() self.proto.makeConnection(transport) self.proto.callLater = self.clock.callLater def test_truncatedPacket(self): """ Test that when a short datagram is received, datagramReceived does not raise an exception while processing it. """ self.proto.datagramReceived(b"", address.IPv4Address("UDP", "127.0.0.1", 12345)) self.assertEqual(self.controller.messages, []) def test_simpleQuery(self): """ Test content received after a query. """ d = self.proto.query(("127.0.0.1", 21345), [dns.Query(b"foo")]) self.assertEqual(len(self.proto.liveMessages.keys()), 1) m = dns.Message() m.id = next(iter(self.proto.liveMessages.keys())) m.answers = [dns.RRHeader(payload=dns.Record_A(address="1.2.3.4"))] def cb(result): self.assertEqual(result.answers[0].payload.dottedQuad(), "1.2.3.4") d.addCallback(cb) self.proto.datagramReceived(m.toStr(), ("127.0.0.1", 21345)) return d def test_queryTimeout(self): """ Test that query timeouts after some seconds. """ d = self.proto.query(("127.0.0.1", 21345), [dns.Query(b"foo")]) self.assertEqual(len(self.proto.liveMessages), 1) self.clock.advance(10) self.assertFailure(d, dns.DNSQueryTimeoutError) self.assertEqual(len(self.proto.liveMessages), 0) return d def test_writeError(self): """ Exceptions raised by the transport's write method should be turned into C{Failure}s passed to errbacks of the C{Deferred} returned by L{DNSDatagramProtocol.query}. """ def writeError(message, addr): raise RuntimeError("bar") self.proto.transport.write = writeError d = self.proto.query(("127.0.0.1", 21345), [dns.Query(b"foo")]) return self.assertFailure(d, RuntimeError) def test_listenError(self): """ Exception L{CannotListenError} raised by C{listenUDP} should be turned into a C{Failure} passed to errback of the C{Deferred} returned by L{DNSDatagramProtocol.query}. """ def startListeningError(): raise CannotListenError(None, None, None) self.proto.startListening = startListeningError # Clean up transport so that the protocol calls startListening again self.proto.transport = None d = self.proto.query(("127.0.0.1", 21345), [dns.Query(b"foo")]) return self.assertFailure(d, CannotListenError) def test_receiveMessageNotInLiveMessages(self): """ When receiving a message whose id is not in L{DNSDatagramProtocol.liveMessages} or L{DNSDatagramProtocol.resends}, the message will be received by L{DNSDatagramProtocol.controller}. """ message = dns.Message() message.id = 1 message.answers = [dns.RRHeader(payload=dns.Record_A(address="1.2.3.4"))] self.proto.datagramReceived(message.toStr(), ("127.0.0.1", 21345)) self.assertEqual(self.controller.messages[-1][0].toStr(), message.toStr()) class TestTCPController(TestController): """ Pretend to be a DNS query processor for a DNSProtocol. @ivar connections: A list of L{DNSProtocol} instances which have notified this controller that they are connected and have not yet notified it that their connection has been lost. """ def __init__(self): TestController.__init__(self) self.connections = [] def connectionMade(self, proto): self.connections.append(proto) def connectionLost(self, proto): self.connections.remove(proto) class DNSProtocolTests(unittest.TestCase): """ Test various aspects of L{dns.DNSProtocol}. """ def setUp(self): """ Create a L{dns.DNSProtocol} with a deterministic clock. """ self.clock = task.Clock() self.controller = TestTCPController() self.proto = dns.DNSProtocol(self.controller) self.proto.makeConnection(proto_helpers.StringTransport()) self.proto.callLater = self.clock.callLater def test_connectionTracking(self): """ L{dns.DNSProtocol} calls its controller's C{connectionMade} method with itself when it is connected to a transport and its controller's C{connectionLost} method when it is disconnected. """ self.assertEqual(self.controller.connections, [self.proto]) self.proto.connectionLost(Failure(ConnectionDone("Fake Connection Done"))) self.assertEqual(self.controller.connections, []) def test_queryTimeout(self): """ Test that query timeouts after some seconds. """ d = self.proto.query([dns.Query(b"foo")]) self.assertEqual(len(self.proto.liveMessages), 1) self.clock.advance(60) self.assertFailure(d, dns.DNSQueryTimeoutError) self.assertEqual(len(self.proto.liveMessages), 0) return d def test_simpleQuery(self): """ Test content received after a query. """ d = self.proto.query([dns.Query(b"foo")]) self.assertEqual(len(self.proto.liveMessages.keys()), 1) m = dns.Message() m.id = next(iter(self.proto.liveMessages.keys())) m.answers = [dns.RRHeader(payload=dns.Record_A(address="1.2.3.4"))] def cb(result): self.assertEqual(result.answers[0].payload.dottedQuad(), "1.2.3.4") d.addCallback(cb) s = m.toStr() s = struct.pack("!H", len(s)) + s self.proto.dataReceived(s) return d def test_writeError(self): """ Exceptions raised by the transport's write method should be turned into C{Failure}s passed to errbacks of the C{Deferred} returned by L{DNSProtocol.query}. """ def writeError(message): raise RuntimeError("bar") self.proto.transport.write = writeError d = self.proto.query([dns.Query(b"foo")]) return self.assertFailure(d, RuntimeError) def test_receiveMessageNotInLiveMessages(self): """ When receiving a message whose id is not in L{DNSProtocol.liveMessages} the message will be received by L{DNSProtocol.controller}. """ message = dns.Message() message.id = 1 message.answers = [dns.RRHeader(payload=dns.Record_A(address="1.2.3.4"))] string = message.toStr() string = struct.pack("!H", len(string)) + string self.proto.dataReceived(string) self.assertEqual(self.controller.messages[-1][0].toStr(), message.toStr()) class ReprTests(unittest.TestCase): """ Tests for the C{__repr__} implementation of record classes. """ def test_ns(self): """ The repr of a L{dns.Record_NS} instance includes the name of the nameserver and the TTL of the record. """ self.assertEqual( repr(dns.Record_NS(b"example.com", 4321)), "<NS name=example.com ttl=4321>" ) def test_md(self): """ The repr of a L{dns.Record_MD} instance includes the name of the mail destination and the TTL of the record. """ self.assertEqual( repr(dns.Record_MD(b"example.com", 4321)), "<MD name=example.com ttl=4321>" ) def test_mf(self): """ The repr of a L{dns.Record_MF} instance includes the name of the mail forwarder and the TTL of the record. """ self.assertEqual( repr(dns.Record_MF(b"example.com", 4321)), "<MF name=example.com ttl=4321>" ) def test_cname(self): """ The repr of a L{dns.Record_CNAME} instance includes the name of the mail forwarder and the TTL of the record. """ self.assertEqual( repr(dns.Record_CNAME(b"example.com", 4321)), "<CNAME name=example.com ttl=4321>", ) def test_mb(self): """ The repr of a L{dns.Record_MB} instance includes the name of the mailbox and the TTL of the record. """ self.assertEqual( repr(dns.Record_MB(b"example.com", 4321)), "<MB name=example.com ttl=4321>" ) def test_mg(self): """ The repr of a L{dns.Record_MG} instance includes the name of the mail group member and the TTL of the record. """ self.assertEqual( repr(dns.Record_MG(b"example.com", 4321)), "<MG name=example.com ttl=4321>" ) def test_mr(self): """ The repr of a L{dns.Record_MR} instance includes the name of the mail rename domain and the TTL of the record. """ self.assertEqual( repr(dns.Record_MR(b"example.com", 4321)), "<MR name=example.com ttl=4321>" ) def test_ptr(self): """ The repr of a L{dns.Record_PTR} instance includes the name of the pointer and the TTL of the record. """ self.assertEqual( repr(dns.Record_PTR(b"example.com", 4321)), "<PTR name=example.com ttl=4321>", ) def test_dname(self): """ The repr of a L{dns.Record_DNAME} instance includes the name of the non-terminal DNS name redirection and the TTL of the record. """ self.assertEqual( repr(dns.Record_DNAME(b"example.com", 4321)), "<DNAME name=example.com ttl=4321>", ) def test_a(self): """ The repr of a L{dns.Record_A} instance includes the dotted-quad string representation of the address it is for and the TTL of the record. """ self.assertEqual( repr(dns.Record_A("1.2.3.4", 567)), "<A address=1.2.3.4 ttl=567>" ) def test_soa(self): """ The repr of a L{dns.Record_SOA} instance includes all of the authority fields. """ self.assertEqual( repr( dns.Record_SOA( mname=b"mName", rname=b"rName", serial=123, refresh=456, retry=789, expire=10, minimum=11, ttl=12, ) ), "<SOA mname=mName rname=rName serial=123 refresh=456 " "retry=789 expire=10 minimum=11 ttl=12>", ) def test_null(self): """ The repr of a L{dns.Record_NULL} instance includes the repr of its payload and the TTL of the record. """ self.assertEqual( repr(dns.Record_NULL(b"abcd", 123)), "<NULL payload='abcd' ttl=123>" ) def test_wks(self): """ The repr of a L{dns.Record_WKS} instance includes the dotted-quad string representation of the address it is for, the IP protocol number it is for, and the TTL of the record. """ self.assertEqual( repr(dns.Record_WKS("2.3.4.5", 7, ttl=8)), "<WKS address=2.3.4.5 protocol=7 ttl=8>", ) def test_aaaa(self): """ The repr of a L{dns.Record_AAAA} instance includes the colon-separated hex string representation of the address it is for and the TTL of the record. """ self.assertEqual( repr(dns.Record_AAAA("8765::1234", ttl=10)), "<AAAA address=8765::1234 ttl=10>", ) def test_a6(self): """ The repr of a L{dns.Record_A6} instance includes the colon-separated hex string representation of the address it is for and the TTL of the record. """ self.assertEqual( repr(dns.Record_A6(0, "1234::5678", b"foo.bar", ttl=10)), "<A6 suffix=1234::5678 prefix=foo.bar ttl=10>", ) def test_srv(self): """ The repr of a L{dns.Record_SRV} instance includes the name and port of the target and the priority, weight, and TTL of the record. """ self.assertEqual( repr(dns.Record_SRV(1, 2, 3, b"example.org", 4)), "<SRV priority=1 weight=2 target=example.org port=3 ttl=4>", ) def test_naptr(self): """ The repr of a L{dns.Record_NAPTR} instance includes the order, preference, flags, service, regular expression, replacement, and TTL of the record. """ record = dns.Record_NAPTR(5, 9, b"S", b"http", b"/foo/bar/i", b"baz", 3) self.assertEqual( repr(record), "<NAPTR order=5 preference=9 flags=S service=http " "regexp=/foo/bar/i replacement=baz ttl=3>", ) def test_afsdb(self): """ The repr of a L{dns.Record_AFSDB} instance includes the subtype, hostname, and TTL of the record. """ self.assertEqual( repr(dns.Record_AFSDB(3, b"example.org", 5)), "<AFSDB subtype=3 hostname=example.org ttl=5>", ) def test_rp(self): """ The repr of a L{dns.Record_RP} instance includes the mbox, txt, and TTL fields of the record. """ self.assertEqual( repr(dns.Record_RP(b"alice.example.com", b"admin.example.com", 3)), "<RP mbox=alice.example.com txt=admin.example.com ttl=3>", ) def test_hinfo(self): """ The repr of a L{dns.Record_HINFO} instance includes the cpu, os, and TTL fields of the record. """ self.assertEqual( repr(dns.Record_HINFO(b"sparc", b"minix", 12)), "<HINFO cpu='sparc' os='minix' ttl=12>", ) def test_minfo(self): """ The repr of a L{dns.Record_MINFO} instance includes the rmailbx, emailbx, and TTL fields of the record. """ record = dns.Record_MINFO(b"alice.example.com", b"bob.example.com", 15) self.assertEqual( repr(record), "<MINFO responsibility=alice.example.com " "errors=bob.example.com ttl=15>", ) def test_mx(self): """ The repr of a L{dns.Record_MX} instance includes the preference, name, and TTL fields of the record. """ self.assertEqual( repr(dns.Record_MX(13, b"mx.example.com", 2)), "<MX preference=13 name=mx.example.com ttl=2>", ) def test_txt(self): """ The repr of a L{dns.Record_TXT} instance includes the data and ttl fields of the record. """ self.assertEqual( repr(dns.Record_TXT(b"foo", b"bar", ttl=15)), "<TXT data=['foo', 'bar'] ttl=15>", ) def test_spf(self): """ The repr of a L{dns.Record_SPF} instance includes the data and ttl fields of the record. """ self.assertEqual( repr(dns.Record_SPF(b"foo", b"bar", ttl=15)), "<SPF data=['foo', 'bar'] ttl=15>", ) def test_unknown(self): """ The repr of a L{dns.UnknownRecord} instance includes the data and ttl fields of the record. """ self.assertEqual( repr(dns.UnknownRecord(b"foo\x1fbar", 12)), "<UNKNOWN data='foo\\x1fbar' ttl=12>", ) class EqualityTests(ComparisonTestsMixin, unittest.TestCase): """ Tests for the equality and non-equality behavior of record classes. """ def _equalityTest(self, firstValueOne, secondValueOne, valueTwo): return self.assertNormalEqualityImplementation( firstValueOne, secondValueOne, valueTwo ) def test_charstr(self): """ Two L{dns.Charstr} instances compare equal if and only if they have the same string value. """ self._equalityTest( dns.Charstr(b"abc"), dns.Charstr(b"abc"), dns.Charstr(b"def") ) def test_name(self): """ Two L{dns.Name} instances compare equal if and only if they have the same name value. """ self._equalityTest(dns.Name(b"abc"), dns.Name(b"abc"), dns.Name(b"def")) def _simpleEqualityTest(self, cls): """ Assert that instances of C{cls} with the same attributes compare equal to each other and instances with different attributes compare as not equal. @param cls: A L{dns.SimpleRecord} subclass. """ # Vary the TTL self._equalityTest( cls(b"example.com", 123), cls(b"example.com", 123), cls(b"example.com", 321) ) # Vary the name self._equalityTest( cls(b"example.com", 123), cls(b"example.com", 123), cls(b"example.org", 123) ) def test_rrheader(self): """ Two L{dns.RRHeader} instances compare equal if and only if they have the same name, type, class, time to live, payload, and authoritative bit. """ # Vary the name self._equalityTest( dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.org", payload=dns.Record_A("1.2.3.4")), ) # Vary the payload self._equalityTest( dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.5")), ) # Vary the type. Leave the payload as None so that we don't have to # provide non-equal values. self._equalityTest( dns.RRHeader(b"example.com", dns.A), dns.RRHeader(b"example.com", dns.A), dns.RRHeader(b"example.com", dns.MX), ) # Probably not likely to come up. Most people use the internet. self._equalityTest( dns.RRHeader(b"example.com", cls=dns.IN, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", cls=dns.IN, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", cls=dns.CS, payload=dns.Record_A("1.2.3.4")), ) # Vary the ttl self._equalityTest( dns.RRHeader(b"example.com", ttl=60, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", ttl=60, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", ttl=120, payload=dns.Record_A("1.2.3.4")), ) # Vary the auth bit self._equalityTest( dns.RRHeader(b"example.com", auth=1, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", auth=1, payload=dns.Record_A("1.2.3.4")), dns.RRHeader(b"example.com", auth=0, payload=dns.Record_A("1.2.3.4")), ) def test_ns(self): """ Two L{dns.Record_NS} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_NS) def test_md(self): """ Two L{dns.Record_MD} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_MD) def test_mf(self): """ Two L{dns.Record_MF} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_MF) def test_cname(self): """ Two L{dns.Record_CNAME} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_CNAME) def test_mb(self): """ Two L{dns.Record_MB} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_MB) def test_mg(self): """ Two L{dns.Record_MG} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_MG) def test_mr(self): """ Two L{dns.Record_MR} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_MR) def test_ptr(self): """ Two L{dns.Record_PTR} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_PTR) def test_dname(self): """ Two L{dns.Record_MD} instances compare equal if and only if they have the same name and TTL. """ self._simpleEqualityTest(dns.Record_DNAME) def test_a(self): """ Two L{dns.Record_A} instances compare equal if and only if they have the same address and TTL. """ # Vary the TTL self._equalityTest( dns.Record_A("1.2.3.4", 5), dns.Record_A("1.2.3.4", 5), dns.Record_A("1.2.3.4", 6), ) # Vary the address self._equalityTest( dns.Record_A("1.2.3.4", 5), dns.Record_A("1.2.3.4", 5), dns.Record_A("1.2.3.5", 5), ) def test_soa(self): """ Two L{dns.Record_SOA} instances compare equal if and only if they have the same mname, rname, serial, refresh, minimum, expire, retry, and ttl. """ # Vary the mname self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"xname", b"rname", 123, 456, 789, 10, 20, 30), ) # Vary the rname self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"xname", 123, 456, 789, 10, 20, 30), ) # Vary the serial self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 1, 456, 789, 10, 20, 30), ) # Vary the refresh self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 1, 789, 10, 20, 30), ) # Vary the minimum self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 1, 10, 20, 30), ) # Vary the expire self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 1, 20, 30), ) # Vary the retry self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 1, 30), ) # Vary the ttl self._equalityTest( dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"rname", 123, 456, 789, 10, 20, 30), dns.Record_SOA(b"mname", b"xname", 123, 456, 789, 10, 20, 1), ) def test_null(self): """ Two L{dns.Record_NULL} instances compare equal if and only if they have the same payload and ttl. """ # Vary the payload self._equalityTest( dns.Record_NULL("foo bar", 10), dns.Record_NULL("foo bar", 10), dns.Record_NULL("bar foo", 10), ) # Vary the ttl self._equalityTest( dns.Record_NULL("foo bar", 10), dns.Record_NULL("foo bar", 10), dns.Record_NULL("foo bar", 100), ) def test_wks(self): """ Two L{dns.Record_WKS} instances compare equal if and only if they have the same address, protocol, map, and ttl. """ # Vary the address self._equalityTest( dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("4.3.2.1", 1, "foo", 2), ) # Vary the protocol self._equalityTest( dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 100, "foo", 2), ) # Vary the map self._equalityTest( dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "bar", 2), ) # Vary the ttl self._equalityTest( dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "foo", 2), dns.Record_WKS("1.2.3.4", 1, "foo", 200), ) def test_aaaa(self): """ Two L{dns.Record_AAAA} instances compare equal if and only if they have the same address and ttl. """ # Vary the address self._equalityTest( dns.Record_AAAA("1::2", 1), dns.Record_AAAA("1::2", 1), dns.Record_AAAA("2::1", 1), ) # Vary the ttl self._equalityTest( dns.Record_AAAA("1::2", 1), dns.Record_AAAA("1::2", 1), dns.Record_AAAA("1::2", 10), ) def test_a6(self): """ Two L{dns.Record_A6} instances compare equal if and only if they have the same prefix, prefix length, suffix, and ttl. """ # Note, A6 is crazy, I'm not sure these values are actually legal. # Hopefully that doesn't matter for this test. -exarkun # Vary the prefix length self._equalityTest( dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(32, "::abcd", b"example.com", 10), ) # Vary the suffix self._equalityTest( dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd:0", b"example.com", 10), ) # Vary the prefix self._equalityTest( dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.org", 10), ) # Vary the ttl self._equalityTest( dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.com", 10), dns.Record_A6(16, "::abcd", b"example.com", 100), ) def test_srv(self): """ Two L{dns.Record_SRV} instances compare equal if and only if they have the same priority, weight, port, target, and ttl. """ # Vary the priority self._equalityTest( dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(100, 20, 30, b"example.com", 40), ) # Vary the weight self._equalityTest( dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 200, 30, b"example.com", 40), ) # Vary the port self._equalityTest( dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 300, b"example.com", 40), ) # Vary the target self._equalityTest( dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.org", 40), ) # Vary the ttl self._equalityTest( dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 40), dns.Record_SRV(10, 20, 30, b"example.com", 400), ) def test_sshfp(self): """ Two L{dns.Record_SSHFP} instances compare equal if and only if they have the same key type, fingerprint type, fingerprint, and ttl. """ # Vary the key type. self._equalityTest( dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(2, 2, b"happyday", 40), ) # Vary the fingerprint type. self._equalityTest( dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 1, b"happyday", 40), ) # Vary the fingerprint itself. self._equalityTest( dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happxday", 40), ) # Vary the ttl. self._equalityTest( dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happyday", 40), dns.Record_SSHFP(1, 2, b"happyday", 45), ) def test_naptr(self): """ Two L{dns.Record_NAPTR} instances compare equal if and only if they have the same order, preference, flags, service, regexp, replacement, and ttl. """ # Vary the order self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(2, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), ) # Vary the preference self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 3, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), ) # Vary the flags self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"p", b"sip+E2U", b"/foo/bar/", b"baz", 12), ) # Vary the service self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"http", b"/foo/bar/", b"baz", 12), ) # Vary the regexp self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/bar/foo/", b"baz", 12), ) # Vary the replacement self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/bar/foo/", b"quux", 12), ) # Vary the ttl self._equalityTest( dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/foo/bar/", b"baz", 12), dns.Record_NAPTR(1, 2, b"u", b"sip+E2U", b"/bar/foo/", b"baz", 5), ) def test_afsdb(self): """ Two L{dns.Record_AFSDB} instances compare equal if and only if they have the same subtype, hostname, and ttl. """ # Vary the subtype self._equalityTest( dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(2, b"example.com", 2), ) # Vary the hostname self._equalityTest( dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(1, b"example.org", 2), ) # Vary the ttl self._equalityTest( dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(1, b"example.com", 2), dns.Record_AFSDB(1, b"example.com", 3), ) def test_rp(self): """ Two L{Record_RP} instances compare equal if and only if they have the same mbox, txt, and ttl. """ # Vary the mbox self._equalityTest( dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"bob.example.com", b"alice is nice", 10), ) # Vary the txt self._equalityTest( dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"alice.example.com", b"alice is not nice", 10), ) # Vary the ttl self._equalityTest( dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"alice.example.com", b"alice is nice", 10), dns.Record_RP(b"alice.example.com", b"alice is nice", 100), ) def test_hinfo(self): """ Two L{dns.Record_HINFO} instances compare equal if and only if they have the same cpu, os, and ttl. """ # Vary the cpu self._equalityTest( dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("i386", "plan9", 10), ) # Vary the os self._equalityTest( dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("x86-64", "plan11", 10), ) # Vary the ttl self._equalityTest( dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("x86-64", "plan9", 10), dns.Record_HINFO("x86-64", "plan9", 100), ) def test_minfo(self): """ Two L{dns.Record_MINFO} instances compare equal if and only if they have the same rmailbx, emailbx, and ttl. """ # Vary the rmailbx self._equalityTest( dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"someplace", b"emailbox", 10), ) # Vary the emailbx self._equalityTest( dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"rmailbox", b"something", 10), ) # Vary the ttl self._equalityTest( dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"rmailbox", b"emailbox", 10), dns.Record_MINFO(b"rmailbox", b"emailbox", 100), ) def test_mx(self): """ Two L{dns.Record_MX} instances compare equal if and only if they have the same preference, name, and ttl. """ # Vary the preference self._equalityTest( dns.Record_MX(10, b"example.org", 20), dns.Record_MX(10, b"example.org", 20), dns.Record_MX(100, b"example.org", 20), ) # Vary the name self._equalityTest( dns.Record_MX(10, b"example.org", 20), dns.Record_MX(10, b"example.org", 20), dns.Record_MX(10, b"example.net", 20), ) # Vary the ttl self._equalityTest( dns.Record_MX(10, b"example.org", 20), dns.Record_MX(10, b"example.org", 20), dns.Record_MX(10, b"example.org", 200), ) def test_txt(self): """ Two L{dns.Record_TXT} instances compare equal if and only if they have the same data and ttl. """ # Vary the length of the data self._equalityTest( dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("foo", "bar", "baz", ttl=10), ) # Vary the value of the data self._equalityTest( dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("bar", "foo", ttl=10), ) # Vary the ttl self._equalityTest( dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("foo", "bar", ttl=10), dns.Record_TXT("foo", "bar", ttl=100), ) def test_spf(self): """ L{dns.Record_SPF} instances compare equal if and only if they have the same data and ttl. """ # Vary the length of the data self._equalityTest( dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("foo", "bar", "baz", ttl=10), ) # Vary the value of the data self._equalityTest( dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("bar", "foo", ttl=10), ) # Vary the ttl self._equalityTest( dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("foo", "bar", ttl=10), dns.Record_SPF("foo", "bar", ttl=100), ) def test_tsig(self): """ L{dns.Record_TSIG} instances compare equal if and only if they have the same RDATA (algorithm, timestamp, MAC, etc.) and ttl. """ baseargs = { "algorithm": "hmac-sha224", "timeSigned": 1515548975, "fudge": 5, "MAC": b"\x01\x02\x03\x04\x05", "originalID": 99, "error": dns.OK, "otherData": b"", "ttl": 40, } altargs = { "algorithm": "hmac-sha512", "timeSigned": 1515548875, "fudge": 0, "MAC": b"\x05\x04\x03\x02\x01", "originalID": 65437, "error": dns.EBADTIME, "otherData": b"\x00\x00", "ttl": 400, } for kw in baseargs.keys(): altered = baseargs.copy() altered[kw] = altargs[kw] self._equalityTest( dns.Record_TSIG(**altered), dns.Record_TSIG(**altered), dns.Record_TSIG(**baseargs), ) def test_unknown(self): """ L{dns.UnknownRecord} instances compare equal if and only if they have the same data and ttl. """ # Vary the length of the data self._equalityTest( dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("foobar", ttl=10), ) # Vary the value of the data self._equalityTest( dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("bar", ttl=10), ) # Vary the ttl self._equalityTest( dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("foo", ttl=10), dns.UnknownRecord("foo", ttl=100), ) class RRHeaderTests(unittest.TestCase): """ Tests for L{twisted.names.dns.RRHeader}. """ def test_negativeTTL(self): """ Attempting to create a L{dns.RRHeader} instance with a negative TTL causes L{ValueError} to be raised. """ self.assertRaises( ValueError, dns.RRHeader, "example.com", dns.A, dns.IN, -1, dns.Record_A("127.0.0.1"), ) def test_nonIntegralTTL(self): """ L{dns.RRHeader} converts TTLs to integers. """ ttlAsFloat = 123.45 header = dns.RRHeader( "example.com", dns.A, dns.IN, ttlAsFloat, dns.Record_A("127.0.0.1") ) self.assertEqual(header.ttl, int(ttlAsFloat)) def test_nonNumericTTLRaisesTypeError(self): """ Attempting to create a L{dns.RRHeader} instance with a TTL that L{int} cannot convert to an integer raises a L{TypeError}. """ self.assertRaises( ValueError, dns.RRHeader, "example.com", dns.A, dns.IN, "this is not a number", dns.Record_A("127.0.0.1"), ) class NameToLabelsTests(unittest.SynchronousTestCase): """ Tests for L{twisted.names.dns._nameToLabels}. """ def test_empty(self): """ L{dns._nameToLabels} returns a list containing a single empty label for an empty name. """ self.assertEqual(dns._nameToLabels(b""), [b""]) def test_onlyDot(self): """ L{dns._nameToLabels} returns a list containing a single empty label for a name containing only a dot. """ self.assertEqual(dns._nameToLabels(b"."), [b""]) def test_withoutTrailingDot(self): """ L{dns._nameToLabels} returns a list ending with an empty label for a name without a trailing dot. """ self.assertEqual(dns._nameToLabels(b"com"), [b"com", b""]) def test_withTrailingDot(self): """ L{dns._nameToLabels} returns a list ending with an empty label for a name with a trailing dot. """ self.assertEqual(dns._nameToLabels(b"com."), [b"com", b""]) def test_subdomain(self): """ L{dns._nameToLabels} returns a list containing entries for all labels in a subdomain name. """ self.assertEqual( dns._nameToLabels(b"foo.bar.baz.example.com."), [b"foo", b"bar", b"baz", b"example", b"com", b""], ) def test_casePreservation(self): """ L{dns._nameToLabels} preserves the case of ascii characters in labels. """ self.assertEqual(dns._nameToLabels(b"EXAMPLE.COM"), [b"EXAMPLE", b"COM", b""]) def assertIsSubdomainOf(testCase, descendant, ancestor): """ Assert that C{descendant} *is* a subdomain of C{ancestor}. @type testCase: L{unittest.SynchronousTestCase} @param testCase: The test case on which to run the assertions. @type descendant: C{str} @param descendant: The subdomain name to test. @type ancestor: C{str} @param ancestor: The superdomain name to test. """ testCase.assertTrue( dns._isSubdomainOf(descendant, ancestor), f"{descendant!r} is not a subdomain of {ancestor!r}", ) def assertIsNotSubdomainOf(testCase, descendant, ancestor): """ Assert that C{descendant} *is not* a subdomain of C{ancestor}. @type testCase: L{unittest.SynchronousTestCase} @param testCase: The test case on which to run the assertions. @type descendant: C{str} @param descendant: The subdomain name to test. @type ancestor: C{str} @param ancestor: The superdomain name to test. """ testCase.assertFalse( dns._isSubdomainOf(descendant, ancestor), f"{descendant!r} is a subdomain of {ancestor!r}", ) class IsSubdomainOfTests(unittest.SynchronousTestCase): """ Tests for L{twisted.names.dns._isSubdomainOf}. """ def test_identical(self): """ L{dns._isSubdomainOf} returns C{True} for identical domain names. """ assertIsSubdomainOf(self, b"example.com", b"example.com") def test_parent(self): """ L{dns._isSubdomainOf} returns C{True} when the first name is an immediate descendant of the second name. """ assertIsSubdomainOf(self, b"foo.example.com", b"example.com") def test_distantAncestor(self): """ L{dns._isSubdomainOf} returns C{True} when the first name is a distant descendant of the second name. """ assertIsSubdomainOf(self, b"foo.bar.baz.example.com", b"com") def test_superdomain(self): """ L{dns._isSubdomainOf} returns C{False} when the first name is an ancestor of the second name. """ assertIsNotSubdomainOf(self, b"example.com", b"foo.example.com") def test_sibling(self): """ L{dns._isSubdomainOf} returns C{False} if the first name is a sibling of the second name. """ assertIsNotSubdomainOf(self, b"foo.example.com", b"bar.example.com") def test_unrelatedCommonSuffix(self): """ L{dns._isSubdomainOf} returns C{False} even when domain names happen to share a common suffix. """ assertIsNotSubdomainOf(self, b"foo.myexample.com", b"example.com") def test_subdomainWithTrailingDot(self): """ L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name but the first name has a trailing ".". """ assertIsSubdomainOf(self, b"foo.example.com.", b"example.com") def test_superdomainWithTrailingDot(self): """ L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name but the second name has a trailing ".". """ assertIsSubdomainOf(self, b"foo.example.com", b"example.com.") def test_bothWithTrailingDot(self): """ L{dns._isSubdomainOf} returns C{True} if the first name is a subdomain of the second name and both names have a trailing ".". """ assertIsSubdomainOf(self, b"foo.example.com.", b"example.com.") def test_emptySubdomain(self): """ L{dns._isSubdomainOf} returns C{False} if the first name is empty and the second name is not. """ assertIsNotSubdomainOf(self, b"", b"example.com") def test_emptySuperdomain(self): """ L{dns._isSubdomainOf} returns C{True} if the second name is empty and the first name is not. """ assertIsSubdomainOf(self, b"foo.example.com", b"") def test_caseInsensitiveComparison(self): """ L{dns._isSubdomainOf} does case-insensitive comparison of name labels. """ assertIsSubdomainOf(self, b"foo.example.com", b"EXAMPLE.COM") assertIsSubdomainOf(self, b"FOO.EXAMPLE.COM", b"example.com") class OPTNonStandardAttributes: """ Generate byte and instance representations of an L{dns._OPTHeader} where all attributes are set to non-default values. For testing whether attributes have really been read from the byte string during decoding. """ @classmethod def bytes(cls, excludeName=False, excludeOptions=False): """ Return L{bytes} representing an encoded OPT record. @param excludeName: A flag that controls whether to exclude the name field. This allows a non-standard name to be prepended during the test. @type excludeName: L{bool} @param excludeOptions: A flag that controls whether to exclude the RDLEN field. This allows encoded variable options to be appended during the test. @type excludeOptions: L{bool} @return: L{bytes} representing the encoded OPT record returned by L{object}. """ rdlen = b"\x00\x00" # RDLEN 0 if excludeOptions: rdlen = b"" return ( b"\x00" # 0 root zone b"\x00\x29" # type 41 b"\x02\x00" # udpPayloadsize 512 b"\x03" # extendedRCODE 3 b"\x04" # version 4 b"\x80\x00" # DNSSEC OK 1 + Z ) + rdlen @classmethod def object(cls): """ Return a new L{dns._OPTHeader} instance. @return: A L{dns._OPTHeader} instance with attributes that match the encoded record returned by L{bytes}. """ return dns._OPTHeader( udpPayloadSize=512, extendedRCODE=3, version=4, dnssecOK=True ) class OPTHeaderTests(ComparisonTestsMixin, unittest.TestCase): """ Tests for L{twisted.names.dns._OPTHeader}. """ def test_interface(self): """ L{dns._OPTHeader} implements L{dns.IEncodable}. """ verifyClass(dns.IEncodable, dns._OPTHeader) def test_name(self): """ L{dns._OPTHeader.name} is an instance attribute whose value is fixed as the root domain """ self.assertEqual(dns._OPTHeader().name, dns.Name(b"")) def test_nameReadonly(self): """ L{dns._OPTHeader.name} is readonly. """ h = dns._OPTHeader() self.assertRaises(AttributeError, setattr, h, "name", dns.Name(b"example.com")) def test_type(self): """ L{dns._OPTHeader.type} is an instance attribute with fixed value 41. """ self.assertEqual(dns._OPTHeader().type, 41) def test_typeReadonly(self): """ L{dns._OPTHeader.type} is readonly. """ h = dns._OPTHeader() self.assertRaises(AttributeError, setattr, h, "type", dns.A) def test_udpPayloadSize(self): """ L{dns._OPTHeader.udpPayloadSize} defaults to 4096 as recommended in rfc6891 section-6.2.5. """ self.assertEqual(dns._OPTHeader().udpPayloadSize, 4096) def test_udpPayloadSizeOverride(self): """ L{dns._OPTHeader.udpPayloadSize} can be overridden in the constructor. """ self.assertEqual(dns._OPTHeader(udpPayloadSize=512).udpPayloadSize, 512) def test_extendedRCODE(self): """ L{dns._OPTHeader.extendedRCODE} defaults to 0. """ self.assertEqual(dns._OPTHeader().extendedRCODE, 0) def test_extendedRCODEOverride(self): """ L{dns._OPTHeader.extendedRCODE} can be overridden in the constructor. """ self.assertEqual(dns._OPTHeader(extendedRCODE=1).extendedRCODE, 1) def test_version(self): """ L{dns._OPTHeader.version} defaults to 0. """ self.assertEqual(dns._OPTHeader().version, 0) def test_versionOverride(self): """ L{dns._OPTHeader.version} can be overridden in the constructor. """ self.assertEqual(dns._OPTHeader(version=1).version, 1) def test_dnssecOK(self): """ L{dns._OPTHeader.dnssecOK} defaults to False. """ self.assertFalse(dns._OPTHeader().dnssecOK) def test_dnssecOKOverride(self): """ L{dns._OPTHeader.dnssecOK} can be overridden in the constructor. """ self.assertTrue(dns._OPTHeader(dnssecOK=True).dnssecOK) def test_options(self): """ L{dns._OPTHeader.options} defaults to empty list. """ self.assertEqual(dns._OPTHeader().options, []) def test_optionsOverride(self): """ L{dns._OPTHeader.options} can be overridden in the constructor. """ h = dns._OPTHeader(options=[(1, 1, b"\x00")]) self.assertEqual(h.options, [(1, 1, b"\x00")]) def test_encode(self): """ L{dns._OPTHeader.encode} packs the header fields and writes them to a file like object passed in as an argument. """ b = BytesIO() OPTNonStandardAttributes.object().encode(b) self.assertEqual(b.getvalue(), OPTNonStandardAttributes.bytes()) def test_encodeWithOptions(self): """ L{dns._OPTHeader.options} is a list of L{dns._OPTVariableOption} instances which are packed into the rdata area of the header. """ h = OPTNonStandardAttributes.object() h.options = [ dns._OPTVariableOption(1, b"foobarbaz"), dns._OPTVariableOption(2, b"qux"), ] b = BytesIO() h.encode(b) self.assertEqual( b.getvalue(), OPTNonStandardAttributes.bytes(excludeOptions=True) + ( b"\x00\x14" # RDLEN 20 b"\x00\x01" # OPTION-CODE b"\x00\x09" # OPTION-LENGTH b"foobarbaz" # OPTION-DATA b"\x00\x02" # OPTION-CODE b"\x00\x03" # OPTION-LENGTH b"qux" # OPTION-DATA ), ) def test_decode(self): """ L{dns._OPTHeader.decode} unpacks the header fields from a file like object and populates the attributes of an existing L{dns._OPTHeader} instance. """ decodedHeader = dns._OPTHeader() decodedHeader.decode(BytesIO(OPTNonStandardAttributes.bytes())) self.assertEqual(decodedHeader, OPTNonStandardAttributes.object()) def test_decodeAllExpectedBytes(self): """ L{dns._OPTHeader.decode} reads all the bytes of the record that is being decoded. """ # Check that all the input data has been consumed. b = BytesIO(OPTNonStandardAttributes.bytes()) decodedHeader = dns._OPTHeader() decodedHeader.decode(b) self.assertEqual(b.tell(), len(b.getvalue())) def test_decodeOnlyExpectedBytes(self): """ L{dns._OPTHeader.decode} reads only the bytes from the current file position to the end of the record that is being decoded. Trailing bytes are not consumed. """ b = BytesIO(OPTNonStandardAttributes.bytes() + b"xxxx") # Trailing bytes decodedHeader = dns._OPTHeader() decodedHeader.decode(b) self.assertEqual(b.tell(), len(b.getvalue()) - len(b"xxxx")) def test_decodeDiscardsName(self): """ L{dns._OPTHeader.decode} discards the name which is encoded in the supplied bytes. The name attribute of the resulting L{dns._OPTHeader} instance will always be L{dns.Name(b'')}. """ b = BytesIO( OPTNonStandardAttributes.bytes(excludeName=True) + b"\x07example\x03com\x00" ) h = dns._OPTHeader() h.decode(b) self.assertEqual(h.name, dns.Name(b"")) def test_decodeRdlengthTooShort(self): """ L{dns._OPTHeader.decode} raises an exception if the supplied RDLEN is too short. """ b = BytesIO( OPTNonStandardAttributes.bytes(excludeOptions=True) + ( b"\x00\x05" # RDLEN 5 Too short - should be 6 b"\x00\x01" # OPTION-CODE b"\x00\x02" # OPTION-LENGTH b"\x00\x00" # OPTION-DATA ) ) h = dns._OPTHeader() self.assertRaises(EOFError, h.decode, b) def test_decodeRdlengthTooLong(self): """ L{dns._OPTHeader.decode} raises an exception if the supplied RDLEN is too long. """ b = BytesIO( OPTNonStandardAttributes.bytes(excludeOptions=True) + ( b"\x00\x07" # RDLEN 7 Too long - should be 6 b"\x00\x01" # OPTION-CODE b"\x00\x02" # OPTION-LENGTH b"\x00\x00" # OPTION-DATA ) ) h = dns._OPTHeader() self.assertRaises(EOFError, h.decode, b) def test_decodeWithOptions(self): """ If the OPT bytes contain variable options, L{dns._OPTHeader.decode} will populate a list L{dns._OPTHeader.options} with L{dns._OPTVariableOption} instances. """ b = BytesIO( OPTNonStandardAttributes.bytes(excludeOptions=True) + ( b"\x00\x14" # RDLEN 20 b"\x00\x01" # OPTION-CODE b"\x00\x09" # OPTION-LENGTH b"foobarbaz" # OPTION-DATA b"\x00\x02" # OPTION-CODE b"\x00\x03" # OPTION-LENGTH b"qux" # OPTION-DATA ) ) h = dns._OPTHeader() h.decode(b) self.assertEqual( h.options, [ dns._OPTVariableOption(1, b"foobarbaz"), dns._OPTVariableOption(2, b"qux"), ], ) def test_fromRRHeader(self): """ L{_OPTHeader.fromRRHeader} accepts an L{RRHeader} instance and returns an L{_OPTHeader} instance whose attribute values have been derived from the C{cls}, C{ttl} and C{payload} attributes of the original header. """ genericHeader = dns.RRHeader( b"example.com", type=dns.OPT, cls=0xFFFF, ttl=(0xFE << 24 | 0xFD << 16 | True << 15), payload=dns.UnknownRecord(b"\xff\xff\x00\x03abc"), ) decodedOptHeader = dns._OPTHeader.fromRRHeader(genericHeader) expectedOptHeader = dns._OPTHeader( udpPayloadSize=0xFFFF, extendedRCODE=0xFE, version=0xFD, dnssecOK=True, options=[dns._OPTVariableOption(code=0xFFFF, data=b"abc")], ) self.assertEqual(decodedOptHeader, expectedOptHeader) def test_repr(self): """ L{dns._OPTHeader.__repr__} displays the name and type and all the fixed and extended header values of the OPT record. """ self.assertEqual( repr(dns._OPTHeader()), "<_OPTHeader " "name= " "type=41 " "udpPayloadSize=4096 " "extendedRCODE=0 " "version=0 " "dnssecOK=False " "options=[]>", ) def test_equalityUdpPayloadSize(self): """ Two L{OPTHeader} instances compare equal if they have the same udpPayloadSize. """ self.assertNormalEqualityImplementation( dns._OPTHeader(udpPayloadSize=512), dns._OPTHeader(udpPayloadSize=512), dns._OPTHeader(udpPayloadSize=4096), ) def test_equalityExtendedRCODE(self): """ Two L{OPTHeader} instances compare equal if they have the same extendedRCODE. """ self.assertNormalEqualityImplementation( dns._OPTHeader(extendedRCODE=1), dns._OPTHeader(extendedRCODE=1), dns._OPTHeader(extendedRCODE=2), ) def test_equalityVersion(self): """ Two L{OPTHeader} instances compare equal if they have the same version. """ self.assertNormalEqualityImplementation( dns._OPTHeader(version=1), dns._OPTHeader(version=1), dns._OPTHeader(version=2), ) def test_equalityDnssecOK(self): """ Two L{OPTHeader} instances compare equal if they have the same dnssecOK flags. """ self.assertNormalEqualityImplementation( dns._OPTHeader(dnssecOK=True), dns._OPTHeader(dnssecOK=True), dns._OPTHeader(dnssecOK=False), ) def test_equalityOptions(self): """ Two L{OPTHeader} instances compare equal if they have the same options. """ self.assertNormalEqualityImplementation( dns._OPTHeader(options=[dns._OPTVariableOption(1, b"x")]), dns._OPTHeader(options=[dns._OPTVariableOption(1, b"x")]), dns._OPTHeader(options=[dns._OPTVariableOption(2, b"y")]), ) class OPTVariableOptionTests(ComparisonTestsMixin, unittest.TestCase): """ Tests for L{dns._OPTVariableOption}. """ def test_interface(self): """ L{dns._OPTVariableOption} implements L{dns.IEncodable}. """ verifyClass(dns.IEncodable, dns._OPTVariableOption) def test_constructorArguments(self): """ L{dns._OPTVariableOption.__init__} requires code and data arguments which are saved as public instance attributes. """ h = dns._OPTVariableOption(1, b"x") self.assertEqual(h.code, 1) self.assertEqual(h.data, b"x") def test_repr(self): """ L{dns._OPTVariableOption.__repr__} displays the code and data of the option. """ self.assertEqual( repr(dns._OPTVariableOption(1, b"x")), "<_OPTVariableOption " "code=1 " "data=x" ">", ) def test_equality(self): """ Two OPTVariableOption instances compare equal if they have the same code and data values. """ self.assertNormalEqualityImplementation( dns._OPTVariableOption(1, b"x"), dns._OPTVariableOption(1, b"x"), dns._OPTVariableOption(2, b"x"), ) self.assertNormalEqualityImplementation( dns._OPTVariableOption(1, b"x"), dns._OPTVariableOption(1, b"x"), dns._OPTVariableOption(1, b"y"), ) def test_encode(self): """ L{dns._OPTVariableOption.encode} encodes the code and data instance attributes to a byte string which also includes the data length. """ o = dns._OPTVariableOption(1, b"foobar") b = BytesIO() o.encode(b) self.assertEqual( b.getvalue(), b"\x00\x01" # OPTION-CODE 1 b"\x00\x06" # OPTION-LENGTH 6 b"foobar", # OPTION-DATA ) def test_decode(self): """ L{dns._OPTVariableOption.decode} is a classmethod that decodes a byte string and returns a L{dns._OPTVariableOption} instance. """ b = BytesIO( b"\x00\x01" # OPTION-CODE 1 b"\x00\x06" # OPTION-LENGTH 6 b"foobar" # OPTION-DATA ) o = dns._OPTVariableOption() o.decode(b) self.assertEqual(o.code, 1) self.assertEqual(o.data, b"foobar") class RaisedArgs(Exception): """ An exception which can be raised by fakes to test that the fake is called with expected arguments. """ def __init__(self, args, kwargs): """ Store the positional and keyword arguments as attributes. @param args: The positional args. @param kwargs: The keyword args. """ self.args = args self.kwargs = kwargs class MessageEmpty: """ Generate byte string and constructor arguments for an empty L{dns._EDNSMessage}. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # id: 256 b"\x97" # QR: 1, OPCODE: 2, AA: 0, TC: 0, RD: 1 b"\x8f" # RA: 1, Z, RCODE: 15 b"\x00\x00" # number of queries b"\x00\x00" # number of answers b"\x00\x00" # number of authorities b"\x00\x00" # number of additionals ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, answer=True, opCode=dns.OP_STATUS, auth=True, trunc=True, recDes=True, recAv=True, rCode=15, ednsVersion=None, ) class MessageTruncated: """ An empty response message whose TR bit is set to 1. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # ID: 256 b"\x82" # QR: 1, OPCODE: 0, AA: 0, TC: 1, RD: 0 b"\x00" # RA: 0, Z, RCODE: 0 b"\x00\x00" # Number of queries b"\x00\x00" # Number of answers b"\x00\x00" # Number of authorities b"\x00\x00" # Number of additionals ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, answer=1, opCode=0, auth=0, trunc=1, recDes=0, recAv=0, rCode=0, ednsVersion=None, ) class MessageNonAuthoritative: """ A minimal non-authoritative message. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # ID 256 b"\x00" # QR: 0, OPCODE: 0, AA: 0, TC: 0, RD: 0 b"\x00" # RA: 0, Z, RCODE: 0 b"\x00\x00" # Query count b"\x00\x01" # Answer count b"\x00\x00" # Authorities count b"\x00\x00" # Additionals count # Answer b"\x00" # RR NAME (root) b"\x00\x01" # RR TYPE 1 (A) b"\x00\x01" # RR CLASS 1 (IN) b"\x00\x00\x00\x00" # RR TTL b"\x00\x04" # RDLENGTH 4 b"\x01\x02\x03\x04" # IPv4 1.2.3.4 ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, auth=0, ednsVersion=None, answers=[ dns.RRHeader(b"", payload=dns.Record_A("1.2.3.4", ttl=0), auth=False) ], ) class MessageAuthoritative: """ A minimal authoritative message. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # ID: 256 b"\x04" # QR: 0, OPCODE: 0, AA: 1, TC: 0, RD: 0 b"\x00" # RA: 0, Z, RCODE: 0 b"\x00\x00" # Query count b"\x00\x01" # Answer count b"\x00\x00" # Authorities count b"\x00\x00" # Additionals count # Answer b"\x00" # RR NAME (root) b"\x00\x01" # RR TYPE 1 (A) b"\x00\x01" # RR CLASS 1 (IN) b"\x00\x00\x00\x00" # RR TTL b"\x00\x04" # RDLENGTH 4 b"\x01\x02\x03\x04" # IPv4 1.2.3.4 ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, auth=1, ednsVersion=None, answers=[ dns.RRHeader(b"", payload=dns.Record_A("1.2.3.4", ttl=0), auth=True) ], ) class MessageComplete: """ An example of a fully populated non-edns response message. Contains name compression, answers, authority, and additional records. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # ID: 256 b"\x95" # QR: 1, OPCODE: 2, AA: 1, TC: 0, RD: 1 b"\x8f" # RA: 1, Z, RCODE: 15 b"\x00\x01" # Query count b"\x00\x01" # Answer count b"\x00\x01" # Authorities count b"\x00\x01" # Additionals count # Query begins at Byte 12 b"\x07example\x03com\x00" # QNAME b"\x00\x06" # QTYPE 6 (SOA) b"\x00\x01" # QCLASS 1 (IN) # Answers b"\xc0\x0c" # RR NAME (compression ref b12) b"\x00\x06" # RR TYPE 6 (SOA) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x27" # RDLENGTH 39 b"\x03ns1\xc0\x0c" # Mname (ns1.example.com (compression ref b15) b"\x0ahostmaster\xc0\x0c" # rname (hostmaster.example.com) b"\xff\xff\xff\xfe" # Serial b"\x7f\xff\xff\xfd" # Refresh b"\x7f\xff\xff\xfc" # Retry b"\x7f\xff\xff\xfb" # Expire b"\xff\xff\xff\xfa" # Minimum # Authority b"\xc0\x0c" # RR NAME (example.com compression ref b12) b"\x00\x02" # RR TYPE 2 (NS) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x02" # RDLENGTH b"\xc0\x29" # RDATA (ns1.example.com (compression ref b41) # Additional b"\xc0\x29" # RR NAME (ns1.example.com compression ref b41) b"\x00\x01" # RR TYPE 1 (A) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x04" # RDLENGTH b"\x05\x06\x07\x08" # RDATA 5.6.7.8 ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, answer=1, opCode=dns.OP_STATUS, auth=1, recDes=1, recAv=1, rCode=15, ednsVersion=None, queries=[dns.Query(b"example.com", dns.SOA)], answers=[ dns.RRHeader( b"example.com", type=dns.SOA, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_SOA( ttl=0xFFFFFFFF, mname=b"ns1.example.com", rname=b"hostmaster.example.com", serial=0xFFFFFFFE, refresh=0x7FFFFFFD, retry=0x7FFFFFFC, expire=0x7FFFFFFB, minimum=0xFFFFFFFA, ), ) ], authority=[ dns.RRHeader( b"example.com", type=dns.NS, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_NS("ns1.example.com", ttl=0xFFFFFFFF), ) ], additional=[ dns.RRHeader( b"ns1.example.com", type=dns.A, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_A("5.6.7.8", ttl=0xFFFFFFFF), ) ], ) class MessageEDNSQuery: """ A minimal EDNS query message. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x00\x00" # ID: 0 b"\x00" # QR: 0, OPCODE: 0, AA: 0, TC: 0, RD: 0 b"\x00" # RA: 0, Z, RCODE: 0 b"\x00\x01" # Queries count b"\x00\x00" # Anwers count b"\x00\x00" # Authority count b"\x00\x01" # Additionals count # Queries b"\x03www\x07example\x03com\x00" # QNAME b"\x00\x01" # QTYPE (A) b"\x00\x01" # QCLASS (IN) # Additional OPT record b"\x00" # NAME (.) b"\x00\x29" # TYPE (OPT 41) b"\x10\x00" # UDP Payload Size (4096) b"\x00" # Extended RCODE b"\x03" # EDNS version b"\x00\x00" # DO: False + Z b"\x00\x00" # RDLENGTH ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=0, answer=0, opCode=dns.OP_QUERY, auth=0, recDes=0, recAv=0, rCode=0, ednsVersion=3, dnssecOK=False, queries=[dns.Query(b"www.example.com", dns.A)], additional=[], ) class MessageEDNSComplete: """ An example of a fully populated edns response message. Contains name compression, answers, authority, and additional records. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x01\x00" # ID: 256 b"\x95" # QR: 1, OPCODE: 2, AA: 1, TC: 0, RD: 1 b"\xbf" # RA: 1, AD: 1, RCODE: 15 b"\x00\x01" # Query count b"\x00\x01" # Answer count b"\x00\x01" # Authorities count b"\x00\x02" # Additionals count # Query begins at Byte 12 b"\x07example\x03com\x00" # QNAME b"\x00\x06" # QTYPE 6 (SOA) b"\x00\x01" # QCLASS 1 (IN) # Answers b"\xc0\x0c" # RR NAME (compression ref b12) b"\x00\x06" # RR TYPE 6 (SOA) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x27" # RDLENGTH 39 b"\x03ns1\xc0\x0c" # mname (ns1.example.com (compression ref b15) b"\x0ahostmaster\xc0\x0c" # rname (hostmaster.example.com) b"\xff\xff\xff\xfe" # Serial b"\x7f\xff\xff\xfd" # Refresh b"\x7f\xff\xff\xfc" # Retry b"\x7f\xff\xff\xfb" # Expire b"\xff\xff\xff\xfa" # Minimum # Authority b"\xc0\x0c" # RR NAME (example.com compression ref b12) b"\x00\x02" # RR TYPE 2 (NS) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x02" # RDLENGTH b"\xc0\x29" # RDATA (ns1.example.com (compression ref b41) # Additional b"\xc0\x29" # RR NAME (ns1.example.com compression ref b41) b"\x00\x01" # RR TYPE 1 (A) b"\x00\x01" # RR CLASS 1 (IN) b"\xff\xff\xff\xff" # RR TTL b"\x00\x04" # RDLENGTH b"\x05\x06\x07\x08" # RDATA 5.6.7.8 # Additional OPT record b"\x00" # NAME (.) b"\x00\x29" # TYPE (OPT 41) b"\x04\x00" # UDP Payload Size (1024) b"\x00" # Extended RCODE b"\x03" # EDNS version b"\x80\x00" # DO: True + Z b"\x00\x00" # RDLENGTH ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=256, answer=1, opCode=dns.OP_STATUS, auth=1, trunc=0, recDes=1, recAv=1, rCode=15, ednsVersion=3, dnssecOK=True, authenticData=True, checkingDisabled=True, maxSize=1024, queries=[dns.Query(b"example.com", dns.SOA)], answers=[ dns.RRHeader( b"example.com", type=dns.SOA, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_SOA( ttl=0xFFFFFFFF, mname=b"ns1.example.com", rname=b"hostmaster.example.com", serial=0xFFFFFFFE, refresh=0x7FFFFFFD, retry=0x7FFFFFFC, expire=0x7FFFFFFB, minimum=0xFFFFFFFA, ), ) ], authority=[ dns.RRHeader( b"example.com", type=dns.NS, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_NS("ns1.example.com", ttl=0xFFFFFFFF), ) ], additional=[ dns.RRHeader( b"ns1.example.com", type=dns.A, ttl=0xFFFFFFFF, auth=True, payload=dns.Record_A("5.6.7.8", ttl=0xFFFFFFFF), ) ], ) class MessageEDNSExtendedRCODE: """ An example of an EDNS message with an extended RCODE. """ @classmethod def bytes(cls): """ Bytes which are expected when encoding an instance constructed using C{kwargs} and which are expected to result in an identical instance when decoded. @return: The L{bytes} of a wire encoded message. """ return ( b"\x00\x00" b"\x00" b"\x0c" # RA: 0, Z, RCODE: 12 b"\x00\x00" b"\x00\x00" b"\x00\x00" b"\x00\x01" # 1 additionals # Additional OPT record b"\x00" b"\x00\x29" b"\x10\x00" b"\xab" # Extended RCODE: 171 b"\x00" b"\x00\x00" b"\x00\x00" ) @classmethod def kwargs(cls): """ Keyword constructor arguments which are expected to result in an instance which returns C{bytes} when encoded. @return: A L{dict} of keyword arguments. """ return dict( id=0, answer=False, opCode=dns.OP_QUERY, auth=False, trunc=False, recDes=False, recAv=False, rCode=0xABC, # Combined OPT extended RCODE + Message RCODE ednsVersion=0, dnssecOK=False, maxSize=4096, queries=[], answers=[], authority=[], additional=[], ) class MessageComparable(FancyEqMixin, FancyStrMixin): """ A wrapper around L{dns.Message} which is comparable so that it can be tested using some of the L{dns._EDNSMessage} tests. """ showAttributes = compareAttributes = ( "id", "answer", "opCode", "auth", "trunc", "recDes", "recAv", "rCode", "queries", "answers", "authority", "additional", ) def __init__(self, original): self.original = original def __getattr__(self, key): return getattr(self.original, key) def verifyConstructorArgument( testCase, cls, argName, defaultVal, altVal, attrName=None ): """ Verify that an attribute has the expected default value and that a corresponding argument passed to a constructor is assigned to that attribute. @param testCase: The L{TestCase} whose assert methods will be called. @type testCase: L{unittest.TestCase} @param cls: The constructor under test. @type cls: L{type} @param argName: The name of the constructor argument under test. @type argName: L{str} @param defaultVal: The expected default value of C{attrName} / C{argName} @type defaultVal: L{object} @param altVal: A value which is different from the default. Used to test that supplied constructor arguments are actually assigned to the correct attribute. @type altVal: L{object} @param attrName: The name of the attribute under test if different from C{argName}. Defaults to C{argName} @type attrName: L{str} """ if attrName is None: attrName = argName actual = {} expected = {"defaultVal": defaultVal, "altVal": altVal} o = cls() actual["defaultVal"] = getattr(o, attrName) o = cls(**{argName: altVal}) actual["altVal"] = getattr(o, attrName) testCase.assertEqual(expected, actual) class ConstructorTestsMixin: """ Helper methods for verifying default attribute values and corresponding constructor arguments. """ def _verifyConstructorArgument(self, argName, defaultVal, altVal): """ Wrap L{verifyConstructorArgument} to provide simpler interface for testing Message and _EDNSMessage constructor arguments. @param argName: The name of the constructor argument. @param defaultVal: The expected default value. @param altVal: An alternative value which is expected to be assigned to a correspondingly named attribute. """ verifyConstructorArgument( testCase=self, cls=self.messageFactory, argName=argName, defaultVal=defaultVal, altVal=altVal, ) def _verifyConstructorFlag(self, argName, defaultVal): """ Wrap L{verifyConstructorArgument} to provide simpler interface for testing _EDNSMessage constructor flags. @param argName: The name of the constructor flag argument @param defaultVal: The expected default value of the flag """ assert defaultVal in (True, False) verifyConstructorArgument( testCase=self, cls=self.messageFactory, argName=argName, defaultVal=defaultVal, altVal=not defaultVal, ) class CommonConstructorTestsMixin: """ Tests for constructor arguments and their associated attributes that are common to both L{twisted.names.dns._EDNSMessage} and L{dns.Message}. TestCase classes that use this mixin must provide a C{messageFactory} method which accepts any argment supported by L{dns.Message.__init__}. TestCases must also mixin ConstructorTestsMixin which provides some custom assertions for testing constructor arguments. """ def test_id(self): """ L{dns._EDNSMessage.id} defaults to C{0} and can be overridden in the constructor. """ self._verifyConstructorArgument("id", defaultVal=0, altVal=1) def test_answer(self): """ L{dns._EDNSMessage.answer} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("answer", defaultVal=False) def test_opCode(self): """ L{dns._EDNSMessage.opCode} defaults to L{dns.OP_QUERY} and can be overridden in the constructor. """ self._verifyConstructorArgument( "opCode", defaultVal=dns.OP_QUERY, altVal=dns.OP_STATUS ) def test_auth(self): """ L{dns._EDNSMessage.auth} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("auth", defaultVal=False) def test_trunc(self): """ L{dns._EDNSMessage.trunc} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("trunc", defaultVal=False) def test_recDes(self): """ L{dns._EDNSMessage.recDes} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("recDes", defaultVal=False) def test_recAv(self): """ L{dns._EDNSMessage.recAv} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("recAv", defaultVal=False) def test_rCode(self): """ L{dns._EDNSMessage.rCode} defaults to C{0} and can be overridden in the constructor. """ self._verifyConstructorArgument("rCode", defaultVal=0, altVal=123) def test_maxSize(self): """ L{dns._EDNSMessage.maxSize} defaults to C{512} and can be overridden in the constructor. """ self._verifyConstructorArgument("maxSize", defaultVal=512, altVal=1024) def test_queries(self): """ L{dns._EDNSMessage.queries} defaults to C{[]}. """ self.assertEqual(self.messageFactory().queries, []) def test_answers(self): """ L{dns._EDNSMessage.answers} defaults to C{[]}. """ self.assertEqual(self.messageFactory().answers, []) def test_authority(self): """ L{dns._EDNSMessage.authority} defaults to C{[]}. """ self.assertEqual(self.messageFactory().authority, []) def test_additional(self): """ L{dns._EDNSMessage.additional} defaults to C{[]}. """ self.assertEqual(self.messageFactory().additional, []) class EDNSMessageConstructorTests( ConstructorTestsMixin, CommonConstructorTestsMixin, unittest.SynchronousTestCase ): """ Tests for L{twisted.names.dns._EDNSMessage} constructor arguments that are shared with L{dns.Message}. """ messageFactory = dns._EDNSMessage class MessageConstructorTests( ConstructorTestsMixin, CommonConstructorTestsMixin, unittest.SynchronousTestCase ): """ Tests for L{twisted.names.dns.Message} constructor arguments that are shared with L{dns._EDNSMessage}. """ messageFactory = dns.Message class EDNSMessageSpecificsTests(ConstructorTestsMixin, unittest.SynchronousTestCase): """ Tests for L{dns._EDNSMessage}. These tests are for L{dns._EDNSMessage} APIs which are not shared with L{dns.Message}. """ messageFactory = dns._EDNSMessage def test_ednsVersion(self): """ L{dns._EDNSMessage.ednsVersion} defaults to C{0} and can be overridden in the constructor. """ self._verifyConstructorArgument("ednsVersion", defaultVal=0, altVal=None) def test_dnssecOK(self): """ L{dns._EDNSMessage.dnssecOK} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("dnssecOK", defaultVal=False) def test_authenticData(self): """ L{dns._EDNSMessage.authenticData} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("authenticData", defaultVal=False) def test_checkingDisabled(self): """ L{dns._EDNSMessage.checkingDisabled} defaults to C{False} and can be overridden in the constructor. """ self._verifyConstructorFlag("checkingDisabled", defaultVal=False) def test_queriesOverride(self): """ L{dns._EDNSMessage.queries} can be overridden in the constructor. """ msg = self.messageFactory(queries=[dns.Query(b"example.com")]) self.assertEqual(msg.queries, [dns.Query(b"example.com")]) def test_answersOverride(self): """ L{dns._EDNSMessage.answers} can be overridden in the constructor. """ msg = self.messageFactory( answers=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ) self.assertEqual( msg.answers, [dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ) def test_authorityOverride(self): """ L{dns._EDNSMessage.authority} can be overridden in the constructor. """ msg = self.messageFactory( authority=[ dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA()) ] ) self.assertEqual( msg.authority, [dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA())], ) def test_additionalOverride(self): """ L{dns._EDNSMessage.authority} can be overridden in the constructor. """ msg = self.messageFactory( additional=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ) self.assertEqual( msg.additional, [dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))], ) def test_reprDefaults(self): """ L{dns._EDNSMessage.__repr__} omits field values and sections which are identical to their defaults. The id field value is always shown. """ self.assertEqual("<_EDNSMessage id=0>", repr(self.messageFactory())) def test_reprFlagsIfSet(self): """ L{dns._EDNSMessage.__repr__} displays flags if they are L{True}. """ m = self.messageFactory( answer=True, auth=True, trunc=True, recDes=True, recAv=True, authenticData=True, checkingDisabled=True, dnssecOK=True, ) self.assertEqual( "<_EDNSMessage " "id=0 " "flags=answer,auth,trunc,recDes,recAv,authenticData," "checkingDisabled,dnssecOK" ">", repr(m), ) def test_reprNonDefautFields(self): """ L{dns._EDNSMessage.__repr__} displays field values if they differ from their defaults. """ m = self.messageFactory(id=10, opCode=20, rCode=30, maxSize=40, ednsVersion=50) self.assertEqual( "<_EDNSMessage " "id=10 " "opCode=20 " "rCode=30 " "maxSize=40 " "ednsVersion=50" ">", repr(m), ) def test_reprNonDefaultSections(self): """ L{dns.Message.__repr__} displays sections which differ from their defaults. """ m = self.messageFactory() m.queries = [1, 2, 3] m.answers = [4, 5, 6] m.authority = [7, 8, 9] m.additional = [10, 11, 12] self.assertEqual( "<_EDNSMessage " "id=0 " "queries=[1, 2, 3] " "answers=[4, 5, 6] " "authority=[7, 8, 9] " "additional=[10, 11, 12]" ">", repr(m), ) def test_fromStrCallsMessageFactory(self): """ L{dns._EDNSMessage.fromString} calls L{dns._EDNSMessage._messageFactory} to create a new L{dns.Message} instance which is used to decode the supplied bytes. """ class FakeMessageFactory: """ Fake message factory. """ def fromStr(self, *args, **kwargs): """ Fake fromStr method which raises the arguments it was passed. @param args: positional arguments @param kwargs: keyword arguments """ raise RaisedArgs(args, kwargs) m = dns._EDNSMessage() m._messageFactory = FakeMessageFactory dummyBytes = object() e = self.assertRaises(RaisedArgs, m.fromStr, dummyBytes) self.assertEqual(((dummyBytes,), {}), (e.args, e.kwargs)) def test_fromStrCallsFromMessage(self): """ L{dns._EDNSMessage.fromString} calls L{dns._EDNSMessage._fromMessage} with a L{dns.Message} instance """ m = dns._EDNSMessage() class FakeMessageFactory: """ Fake message factory. """ def fromStr(self, bytes): """ A noop fake version of fromStr @param bytes: the bytes to be decoded """ fakeMessage = FakeMessageFactory() m._messageFactory = lambda: fakeMessage def fakeFromMessage(*args, **kwargs): raise RaisedArgs(args, kwargs) m._fromMessage = fakeFromMessage e = self.assertRaises(RaisedArgs, m.fromStr, b"") self.assertEqual(((fakeMessage,), {}), (e.args, e.kwargs)) def test_toStrCallsToMessage(self): """ L{dns._EDNSMessage.toStr} calls L{dns._EDNSMessage._toMessage} """ m = dns._EDNSMessage() def fakeToMessage(*args, **kwargs): raise RaisedArgs(args, kwargs) m._toMessage = fakeToMessage e = self.assertRaises(RaisedArgs, m.toStr) self.assertEqual(((), {}), (e.args, e.kwargs)) def test_toStrCallsToMessageToStr(self): """ L{dns._EDNSMessage.toStr} calls C{toStr} on the message returned by L{dns._EDNSMessage._toMessage}. """ m = dns._EDNSMessage() dummyBytes = object() class FakeMessage: """ Fake Message """ def toStr(self): """ Fake toStr which returns dummyBytes. @return: dummyBytes """ return dummyBytes def fakeToMessage(*args, **kwargs): return FakeMessage() m._toMessage = fakeToMessage self.assertEqual(dummyBytes, m.toStr()) class EDNSMessageEqualityTests(ComparisonTestsMixin, unittest.SynchronousTestCase): """ Tests for equality between L{dns._EDNSMessage} instances. These tests will not work with L{dns.Message} because it does not use L{twisted.python.util.FancyEqMixin}. """ messageFactory = dns._EDNSMessage def test_id(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same id. """ self.assertNormalEqualityImplementation( self.messageFactory(id=1), self.messageFactory(id=1), self.messageFactory(id=2), ) def test_answer(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same answer flag. """ self.assertNormalEqualityImplementation( self.messageFactory(answer=True), self.messageFactory(answer=True), self.messageFactory(answer=False), ) def test_opCode(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same opCode. """ self.assertNormalEqualityImplementation( self.messageFactory(opCode=dns.OP_STATUS), self.messageFactory(opCode=dns.OP_STATUS), self.messageFactory(opCode=dns.OP_INVERSE), ) def test_auth(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same auth flag. """ self.assertNormalEqualityImplementation( self.messageFactory(auth=True), self.messageFactory(auth=True), self.messageFactory(auth=False), ) def test_trunc(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same trunc flag. """ self.assertNormalEqualityImplementation( self.messageFactory(trunc=True), self.messageFactory(trunc=True), self.messageFactory(trunc=False), ) def test_recDes(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same recDes flag. """ self.assertNormalEqualityImplementation( self.messageFactory(recDes=True), self.messageFactory(recDes=True), self.messageFactory(recDes=False), ) def test_recAv(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same recAv flag. """ self.assertNormalEqualityImplementation( self.messageFactory(recAv=True), self.messageFactory(recAv=True), self.messageFactory(recAv=False), ) def test_rCode(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same rCode. """ self.assertNormalEqualityImplementation( self.messageFactory(rCode=16), self.messageFactory(rCode=16), self.messageFactory(rCode=15), ) def test_ednsVersion(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same ednsVersion. """ self.assertNormalEqualityImplementation( self.messageFactory(ednsVersion=1), self.messageFactory(ednsVersion=1), self.messageFactory(ednsVersion=None), ) def test_dnssecOK(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same dnssecOK. """ self.assertNormalEqualityImplementation( self.messageFactory(dnssecOK=True), self.messageFactory(dnssecOK=True), self.messageFactory(dnssecOK=False), ) def test_authenticData(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same authenticData flags. """ self.assertNormalEqualityImplementation( self.messageFactory(authenticData=True), self.messageFactory(authenticData=True), self.messageFactory(authenticData=False), ) def test_checkingDisabled(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same checkingDisabled flags. """ self.assertNormalEqualityImplementation( self.messageFactory(checkingDisabled=True), self.messageFactory(checkingDisabled=True), self.messageFactory(checkingDisabled=False), ) def test_maxSize(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same maxSize. """ self.assertNormalEqualityImplementation( self.messageFactory(maxSize=2048), self.messageFactory(maxSize=2048), self.messageFactory(maxSize=1024), ) def test_queries(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same queries. """ self.assertNormalEqualityImplementation( self.messageFactory(queries=[dns.Query(b"example.com")]), self.messageFactory(queries=[dns.Query(b"example.com")]), self.messageFactory(queries=[dns.Query(b"example.org")]), ) def test_answers(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same answers. """ self.assertNormalEqualityImplementation( self.messageFactory( answers=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ), self.messageFactory( answers=[dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4"))] ), self.messageFactory( answers=[dns.RRHeader(b"example.org", payload=dns.Record_A("4.3.2.1"))] ), ) def test_authority(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same authority records. """ self.assertNormalEqualityImplementation( self.messageFactory( authority=[ dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA()) ] ), self.messageFactory( authority=[ dns.RRHeader(b"example.com", type=dns.SOA, payload=dns.Record_SOA()) ] ), self.messageFactory( authority=[ dns.RRHeader(b"example.org", type=dns.SOA, payload=dns.Record_SOA()) ] ), ) def test_additional(self): """ Two L{dns._EDNSMessage} instances compare equal if they have the same additional records. """ self.assertNormalEqualityImplementation( self.messageFactory( additional=[ dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")) ] ), self.messageFactory( additional=[ dns.RRHeader(b"example.com", payload=dns.Record_A("1.2.3.4")) ] ), self.messageFactory( additional=[ dns.RRHeader(b"example.org", payload=dns.Record_A("1.2.3.4")) ] ), ) class StandardEncodingTestsMixin: """ Tests for the encoding and decoding of various standard (not EDNS) messages. These tests should work with both L{dns._EDNSMessage} and L{dns.Message}. TestCase classes that use this mixin must provide a C{messageFactory} method which accepts any argment supported by L{dns._EDNSMessage.__init__}. EDNS specific arguments may be discarded if not supported by the message class under construction. """ def test_emptyMessageEncode(self): """ An empty message can be encoded. """ self.assertEqual( self.messageFactory(**MessageEmpty.kwargs()).toStr(), MessageEmpty.bytes() ) def test_emptyMessageDecode(self): """ An empty message byte sequence can be decoded. """ m = self.messageFactory() m.fromStr(MessageEmpty.bytes()) self.assertEqual(m, self.messageFactory(**MessageEmpty.kwargs())) def test_completeQueryEncode(self): """ A fully populated query message can be encoded. """ self.assertEqual( self.messageFactory(**MessageComplete.kwargs()).toStr(), MessageComplete.bytes(), ) def test_completeQueryDecode(self): """ A fully populated message byte string can be decoded. """ m = self.messageFactory() m.fromStr(MessageComplete.bytes()), self.assertEqual(m, self.messageFactory(**MessageComplete.kwargs())) def test_NULL(self): """ A I{NULL} record with an arbitrary payload can be encoded and decoded as part of a message. """ bytes = b"".join([dns._ord2bytes(i) for i in range(256)]) rec = dns.Record_NULL(bytes) rr = dns.RRHeader(b"testname", dns.NULL, payload=rec) msg1 = self.messageFactory() msg1.answers.append(rr) s = msg1.toStr() msg2 = self.messageFactory() msg2.fromStr(s) self.assertIsInstance(msg2.answers[0].payload, dns.Record_NULL) self.assertEqual(msg2.answers[0].payload.payload, bytes) def test_nonAuthoritativeMessageEncode(self): """ If the message C{authoritative} attribute is set to 0, the encoded bytes will have AA bit 0. """ self.assertEqual( self.messageFactory(**MessageNonAuthoritative.kwargs()).toStr(), MessageNonAuthoritative.bytes(), ) def test_nonAuthoritativeMessageDecode(self): """ The L{dns.RRHeader} instances created by a message from a non-authoritative message byte string are marked as not authoritative. """ m = self.messageFactory() m.fromStr(MessageNonAuthoritative.bytes()) self.assertEqual(m, self.messageFactory(**MessageNonAuthoritative.kwargs())) def test_authoritativeMessageEncode(self): """ If the message C{authoritative} attribute is set to 1, the encoded bytes will have AA bit 1. """ self.assertEqual( self.messageFactory(**MessageAuthoritative.kwargs()).toStr(), MessageAuthoritative.bytes(), ) def test_authoritativeMessageDecode(self): """ The message and its L{dns.RRHeader} instances created by C{decode} from an authoritative message byte string, are marked as authoritative. """ m = self.messageFactory() m.fromStr(MessageAuthoritative.bytes()) self.assertEqual(m, self.messageFactory(**MessageAuthoritative.kwargs())) def test_truncatedMessageEncode(self): """ If the message C{trunc} attribute is set to 1 the encoded bytes will have TR bit 1. """ self.assertEqual( self.messageFactory(**MessageTruncated.kwargs()).toStr(), MessageTruncated.bytes(), ) def test_truncatedMessageDecode(self): """ The message instance created by decoding a truncated message is marked as truncated. """ m = self.messageFactory() m.fromStr(MessageTruncated.bytes()) self.assertEqual(m, self.messageFactory(**MessageTruncated.kwargs())) class EDNSMessageStandardEncodingTests( StandardEncodingTestsMixin, unittest.SynchronousTestCase ): """ Tests for the encoding and decoding of various standard (non-EDNS) messages by L{dns._EDNSMessage}. """ messageFactory = dns._EDNSMessage class MessageStandardEncodingTests( StandardEncodingTestsMixin, unittest.SynchronousTestCase ): """ Tests for the encoding and decoding of various standard (non-EDNS) messages by L{dns.Message}. """ @staticmethod def messageFactory(**kwargs): """ This function adapts constructor arguments expected by _EDNSMessage.__init__ to arguments suitable for use with the Message.__init__. Also handles the fact that unlike L{dns._EDNSMessage}, L{dns.Message.__init__} does not accept queries, answers etc as arguments. Also removes any L{dns._EDNSMessage} specific arguments. @param args: The positional arguments which will be passed to L{dns.Message.__init__}. @param kwargs: The keyword arguments which will be stripped of EDNS specific arguments before being passed to L{dns.Message.__init__}. @return: An L{dns.Message} instance. """ queries = kwargs.pop("queries", []) answers = kwargs.pop("answers", []) authority = kwargs.pop("authority", []) additional = kwargs.pop("additional", []) kwargs.pop("ednsVersion", None) m = dns.Message(**kwargs) m.queries = queries m.answers = answers m.authority = authority m.additional = additional return MessageComparable(m) class EDNSMessageEDNSEncodingTests(unittest.SynchronousTestCase): """ Tests for the encoding and decoding of various EDNS messages. These test will not work with L{dns.Message}. """ messageFactory = dns._EDNSMessage def test_ednsMessageDecodeStripsOptRecords(self): """ The L(_EDNSMessage} instance created by L{dns._EDNSMessage.decode} from an EDNS query never includes OPT records in the additional section. """ m = self.messageFactory() m.fromStr(MessageEDNSQuery.bytes()) self.assertEqual(m.additional, []) def test_ednsMessageDecodeMultipleOptRecords(self): """ An L(_EDNSMessage} instance created from a byte string containing multiple I{OPT} records will discard all the C{OPT} records. C{ednsVersion} will be set to L{None}. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.1} """ m = dns.Message() m.additional = [dns._OPTHeader(version=2), dns._OPTHeader(version=3)] ednsMessage = dns._EDNSMessage() ednsMessage.fromStr(m.toStr()) self.assertIsNone(ednsMessage.ednsVersion) def test_fromMessageCopiesSections(self): """ L{dns._EDNSMessage._fromMessage} returns an L{_EDNSMessage} instance whose queries, answers, authority and additional lists are copies (not references to) the original message lists. """ standardMessage = dns.Message() standardMessage.fromStr(MessageEDNSQuery.bytes()) ednsMessage = dns._EDNSMessage._fromMessage(standardMessage) duplicates = [] for attrName in ("queries", "answers", "authority", "additional"): if getattr(standardMessage, attrName) is getattr(ednsMessage, attrName): duplicates.append(attrName) if duplicates: self.fail( "Message and _EDNSMessage shared references to the following " "section lists after decoding: %s" % (duplicates,) ) def test_toMessageCopiesSections(self): """ L{dns._EDNSMessage.toStr} makes no in place changes to the message instance. """ ednsMessage = dns._EDNSMessage(ednsVersion=1) ednsMessage.toStr() self.assertEqual(ednsMessage.additional, []) def test_optHeaderPosition(self): """ L{dns._EDNSMessage} can decode OPT records, regardless of their position in the additional records section. "The OPT RR MAY be placed anywhere within the additional data section." @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.1} """ # XXX: We need an _OPTHeader.toRRHeader method. See #6779. b = BytesIO() optRecord = dns._OPTHeader(version=1) optRecord.encode(b) optRRHeader = dns.RRHeader() b.seek(0) optRRHeader.decode(b) m = dns.Message() m.additional = [optRRHeader] actualMessages = [] actualMessages.append(dns._EDNSMessage._fromMessage(m).ednsVersion) m.additional.append(dns.RRHeader(type=dns.A)) actualMessages.append(dns._EDNSMessage._fromMessage(m).ednsVersion) m.additional.insert(0, dns.RRHeader(type=dns.A)) actualMessages.append(dns._EDNSMessage._fromMessage(m).ednsVersion) self.assertEqual([1] * 3, actualMessages) def test_ednsDecode(self): """ The L(_EDNSMessage} instance created by L{dns._EDNSMessage.fromStr} derives its edns specific values (C{ednsVersion}, etc) from the supplied OPT record. """ m = self.messageFactory() m.fromStr(MessageEDNSComplete.bytes()) self.assertEqual(m, self.messageFactory(**MessageEDNSComplete.kwargs())) def test_ednsEncode(self): """ The L(_EDNSMessage} instance created by L{dns._EDNSMessage.toStr} encodes its edns specific values (C{ednsVersion}, etc) into an OPT record added to the additional section. """ self.assertEqual( self.messageFactory(**MessageEDNSComplete.kwargs()).toStr(), MessageEDNSComplete.bytes(), ) def test_extendedRcodeEncode(self): """ The L(_EDNSMessage.toStr} encodes the extended I{RCODE} (>=16) by assigning the lower 4bits to the message RCODE field and the upper 4bits to the OPT pseudo record. """ self.assertEqual( self.messageFactory(**MessageEDNSExtendedRCODE.kwargs()).toStr(), MessageEDNSExtendedRCODE.bytes(), ) def test_extendedRcodeDecode(self): """ The L(_EDNSMessage} instance created by L{dns._EDNSMessage.fromStr} derives RCODE from the supplied OPT record. """ m = self.messageFactory() m.fromStr(MessageEDNSExtendedRCODE.bytes()) self.assertEqual(m, self.messageFactory(**MessageEDNSExtendedRCODE.kwargs())) def test_extendedRcodeZero(self): """ Note that EXTENDED-RCODE value 0 indicates that an unextended RCODE is in use (values 0 through 15). https://tools.ietf.org/html/rfc6891#section-6.1.3 """ ednsMessage = self.messageFactory(rCode=15, ednsVersion=0) standardMessage = ednsMessage._toMessage() self.assertEqual( (15, 0), (standardMessage.rCode, standardMessage.additional[0].extendedRCODE), ) class ResponseFromMessageTests(unittest.SynchronousTestCase): """ Tests for L{dns._responseFromMessage}. """ def test_responseFromMessageResponseType(self): """ L{dns.Message._responseFromMessage} is a constructor function which generates a new I{answer} message from an existing L{dns.Message} like instance. """ request = dns.Message() response = dns._responseFromMessage( responseConstructor=dns.Message, message=request ) self.assertIsNot(request, response) def test_responseType(self): """ L{dns._responseFromMessage} returns a new instance of C{cls} """ class SuppliedClass: id = 1 queries = [] expectedClass = dns.Message self.assertIsInstance( dns._responseFromMessage( responseConstructor=expectedClass, message=SuppliedClass() ), expectedClass, ) def test_responseId(self): """ L{dns._responseFromMessage} copies the C{id} attribute of the original message. """ self.assertEqual( 1234, dns._responseFromMessage( responseConstructor=dns.Message, message=dns.Message(id=1234) ).id, ) def test_responseAnswer(self): """ L{dns._responseFromMessage} sets the C{answer} flag to L{True} """ request = dns.Message() response = dns._responseFromMessage( responseConstructor=dns.Message, message=request ) self.assertEqual((False, True), (request.answer, response.answer)) def test_responseQueries(self): """ L{dns._responseFromMessage} copies the C{queries} attribute of the original message. """ request = dns.Message() expectedQueries = [object(), object(), object()] request.queries = expectedQueries[:] self.assertEqual( expectedQueries, dns._responseFromMessage( responseConstructor=dns.Message, message=request ).queries, ) def test_responseKwargs(self): """ L{dns._responseFromMessage} accepts other C{kwargs} which are assigned to the new message before it is returned. """ self.assertEqual( 123, dns._responseFromMessage( responseConstructor=dns.Message, message=dns.Message(), rCode=123 ).rCode, ) class Foo: """ An example class for use in L{dns._compactRepr} tests. It follows the pattern of initialiser settable flags, fields and sections found in L{dns.Message} and L{dns._EDNSMessage}. """ def __init__( self, field1=1, field2=2, alwaysShowField="AS", flagTrue=True, flagFalse=False, section1=None, ): """ Set some flags, fields and sections as public attributes. """ self.field1 = field1 self.field2 = field2 self.alwaysShowField = alwaysShowField self.flagTrue = flagTrue self.flagFalse = flagFalse if section1 is None: section1 = [] self.section1 = section1 def __repr__(self) -> str: """ Call L{dns._compactRepr} to generate a string representation. """ return cast( str, dns._compactRepr( self, alwaysShow="alwaysShowField".split(), fieldNames="field1 field2 alwaysShowField".split(), flagNames="flagTrue flagFalse".split(), sectionNames="section1 section2".split(), ), ) class CompactReprTests(unittest.SynchronousTestCase): """ Tests for L{dns._compactRepr}. """ messageFactory = Foo def test_defaults(self): """ L{dns._compactRepr} omits field values and sections which have the default value. Flags which are True are always shown. """ self.assertEqual( "<Foo alwaysShowField='AS' flags=flagTrue>", repr(self.messageFactory()) ) def test_flagsIfSet(self): """ L{dns._compactRepr} displays flags if they have a non-default value. """ m = self.messageFactory(flagTrue=True, flagFalse=True) self.assertEqual( "<Foo " "alwaysShowField='AS' " "flags=flagTrue,flagFalse" ">", repr(m), ) def test_nonDefautFields(self): """ L{dns._compactRepr} displays field values if they differ from their defaults. """ m = self.messageFactory(field1=10, field2=20) self.assertEqual( "<Foo " "field1=10 " "field2=20 " "alwaysShowField='AS' " "flags=flagTrue" ">", repr(m), ) def test_nonDefaultSections(self): """ L{dns._compactRepr} displays sections which differ from their defaults. """ m = self.messageFactory() m.section1 = [1, 1, 1] m.section2 = [2, 2, 2] self.assertEqual( "<Foo " "alwaysShowField='AS' " "flags=flagTrue " "section1=[1, 1, 1] " "section2=[2, 2, 2]" ">", repr(m), ) PK Mb�Z�H�4d 4d names/test/test_rootresolve.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for Twisted.names' root resolver. """ from zope.interface import implementer from zope.interface.verify import verifyClass from twisted.internet.defer import Deferred, TimeoutError, gatherResults, succeed from twisted.internet.interfaces import IResolverSimple from twisted.names import client, root from twisted.names.dns import ( CNAME, ENAME, HS, IN, NS, OK, A, Message, Name, Query, Record_A, Record_CNAME, Record_NS, RRHeader, ) from twisted.names.error import DNSNameError, ResolverError from twisted.names.root import Resolver from twisted.names.test.test_util import MemoryReactor from twisted.python.log import msg from twisted.trial import util from twisted.trial.unittest import SynchronousTestCase, TestCase def getOnePayload(results): """ From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, return the payload of the first record in the answer section. """ ans, auth, add = results return ans[0].payload def getOneAddress(results): """ From the result of a L{Deferred} returned by L{IResolver.lookupAddress}, return the first IPv4 address from the answer section. """ return getOnePayload(results).dottedQuad() class RootResolverTests(TestCase): """ Tests for L{twisted.names.root.Resolver}. """ def _queryTest(self, filter): """ Invoke L{Resolver._query} and verify that it sends the correct DNS query. Deliver a canned response to the query and return whatever the L{Deferred} returned by L{Resolver._query} fires with. @param filter: The value to pass for the C{filter} parameter to L{Resolver._query}. """ reactor = MemoryReactor() resolver = Resolver([], reactor=reactor) d = resolver._query( Query(b"foo.example.com", A, IN), [("1.1.2.3", 1053)], (30,), filter ) # A UDP port should have been started. portNumber, transport = reactor.udpPorts.popitem() # And a DNS packet sent. [(packet, address)] = transport._sentPackets message = Message() message.fromStr(packet) # It should be a query with the parameters used above. self.assertEqual(message.queries, [Query(b"foo.example.com", A, IN)]) self.assertEqual(message.answers, []) self.assertEqual(message.authority, []) self.assertEqual(message.additional, []) response = [] d.addCallback(response.append) self.assertEqual(response, []) # Once a reply is received, the Deferred should fire. del message.queries[:] message.answer = 1 message.answers.append( RRHeader(b"foo.example.com", payload=Record_A("5.8.13.21")) ) transport._protocol.datagramReceived(message.toStr(), ("1.1.2.3", 1053)) return response[0] def test_filteredQuery(self): """ L{Resolver._query} accepts a L{Query} instance and an address, issues the query, and returns a L{Deferred} which fires with the response to the query. If a true value is passed for the C{filter} parameter, the result is a three-tuple of lists of records. """ answer, authority, additional = self._queryTest(True) self.assertEqual( answer, [RRHeader(b"foo.example.com", payload=Record_A("5.8.13.21", ttl=0))] ) self.assertEqual(authority, []) self.assertEqual(additional, []) def test_unfilteredQuery(self): """ Similar to L{test_filteredQuery}, but for the case where a false value is passed for the C{filter} parameter. In this case, the result is a L{Message} instance. """ message = self._queryTest(False) self.assertIsInstance(message, Message) self.assertEqual(message.queries, []) self.assertEqual( message.answers, [RRHeader(b"foo.example.com", payload=Record_A("5.8.13.21", ttl=0))], ) self.assertEqual(message.authority, []) self.assertEqual(message.additional, []) def _respond(self, answers=[], authority=[], additional=[], rCode=OK): """ Create a L{Message} suitable for use as a response to a query. @param answers: A C{list} of two-tuples giving data for the answers section of the message. The first element of each tuple is a name for the L{RRHeader}. The second element is the payload. @param authority: A C{list} like C{answers}, but for the authority section of the response. @param additional: A C{list} like C{answers}, but for the additional section of the response. @param rCode: The response code the message will be created with. @return: A new L{Message} initialized with the given values. """ response = Message(rCode=rCode) for (section, data) in [ (response.answers, answers), (response.authority, authority), (response.additional, additional), ]: section.extend( [ RRHeader( name, record.TYPE, getattr(record, "CLASS", IN), payload=record ) for (name, record) in data ] ) return response def _getResolver(self, serverResponses, maximumQueries=10): """ Create and return a new L{root.Resolver} modified to resolve queries against the record data represented by C{servers}. @param serverResponses: A mapping from dns server addresses to mappings. The inner mappings are from query two-tuples (name, type) to dictionaries suitable for use as **arguments to L{_respond}. See that method for details. """ roots = ["1.1.2.3"] resolver = Resolver(roots, maximumQueries) def query(query, serverAddresses, timeout, filter): msg(f"Query for QNAME {query.name} at {serverAddresses!r}") for addr in serverAddresses: try: server = serverResponses[addr] except KeyError: continue records = server[query.name.name, query.type] return succeed(self._respond(**records)) resolver._query = query return resolver def test_lookupAddress(self): """ L{root.Resolver.lookupAddress} looks up the I{A} records for the specified hostname by first querying one of the root servers the resolver was created with and then following the authority delegations until a result is received. """ servers = { ("1.1.2.3", 53): { (b"foo.example.com", A): { "authority": [(b"foo.example.com", Record_NS(b"ns1.example.com"))], "additional": [(b"ns1.example.com", Record_A("34.55.89.144"))], }, }, ("34.55.89.144", 53): { (b"foo.example.com", A): { "answers": [(b"foo.example.com", Record_A("10.0.0.1"))], } }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"foo.example.com") d.addCallback(getOneAddress) d.addCallback(self.assertEqual, "10.0.0.1") return d def test_lookupChecksClass(self): """ If a response includes a record with a class different from the one in the query, it is ignored and lookup continues until a record with the right class is found. """ badClass = Record_A("10.0.0.1") badClass.CLASS = HS servers = { ("1.1.2.3", 53): { (b"foo.example.com", A): { "answers": [(b"foo.example.com", badClass)], "authority": [(b"foo.example.com", Record_NS(b"ns1.example.com"))], "additional": [(b"ns1.example.com", Record_A("10.0.0.2"))], }, }, ("10.0.0.2", 53): { (b"foo.example.com", A): { "answers": [(b"foo.example.com", Record_A("10.0.0.3"))], }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"foo.example.com") d.addCallback(getOnePayload) d.addCallback(self.assertEqual, Record_A("10.0.0.3")) return d def test_missingGlue(self): """ If an intermediate response includes no glue records for the authorities, separate queries are made to find those addresses. """ servers = { ("1.1.2.3", 53): { (b"foo.example.com", A): { "authority": [(b"foo.example.com", Record_NS(b"ns1.example.org"))], # Conspicuous lack of an additional section naming ns1.example.com }, (b"ns1.example.org", A): { "answers": [(b"ns1.example.org", Record_A("10.0.0.1"))], }, }, ("10.0.0.1", 53): { (b"foo.example.com", A): { "answers": [(b"foo.example.com", Record_A("10.0.0.2"))], }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"foo.example.com") d.addCallback(getOneAddress) d.addCallback(self.assertEqual, "10.0.0.2") return d def test_missingName(self): """ If a name is missing, L{Resolver.lookupAddress} returns a L{Deferred} which fails with L{DNSNameError}. """ servers = { ("1.1.2.3", 53): { (b"foo.example.com", A): { "rCode": ENAME, }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"foo.example.com") return self.assertFailure(d, DNSNameError) def test_answerless(self): """ If a query is responded to with no answers or nameserver records, the L{Deferred} returned by L{Resolver.lookupAddress} fires with L{ResolverError}. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): {}, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") return self.assertFailure(d, ResolverError) def test_delegationLookupError(self): """ If there is an error resolving the nameserver in a delegation response, the L{Deferred} returned by L{Resolver.lookupAddress} fires with that error. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "authority": [(b"example.com", Record_NS(b"ns1.example.com"))], }, (b"ns1.example.com", A): { "rCode": ENAME, }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") return self.assertFailure(d, DNSNameError) def test_delegationLookupEmpty(self): """ If there are no records in the response to a lookup of a delegation nameserver, the L{Deferred} returned by L{Resolver.lookupAddress} fires with L{ResolverError}. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "authority": [(b"example.com", Record_NS(b"ns1.example.com"))], }, (b"ns1.example.com", A): {}, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") return self.assertFailure(d, ResolverError) def test_lookupNameservers(self): """ L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except it queries for I{NS} records instead of I{A} records. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "rCode": ENAME, }, (b"example.com", NS): { "answers": [(b"example.com", Record_NS(b"ns1.example.com"))], }, }, } resolver = self._getResolver(servers) d = resolver.lookupNameservers(b"example.com") def getOneName(results): ans, auth, add = results return ans[0].payload.name d.addCallback(getOneName) d.addCallback(self.assertEqual, Name(b"ns1.example.com")) return d def test_returnCanonicalName(self): """ If a I{CNAME} record is encountered as the answer to a query for another record type, that record is returned as the answer. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "answers": [ (b"example.com", Record_CNAME(b"example.net")), (b"example.net", Record_A("10.0.0.7")), ], }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") d.addCallback(lambda results: results[0]) # Get the answer section d.addCallback( self.assertEqual, [ RRHeader(b"example.com", CNAME, payload=Record_CNAME(b"example.net")), RRHeader(b"example.net", A, payload=Record_A("10.0.0.7")), ], ) return d def test_followCanonicalName(self): """ If no record of the requested type is included in a response, but a I{CNAME} record for the query name is included, queries are made to resolve the value of the I{CNAME}. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "answers": [(b"example.com", Record_CNAME(b"example.net"))], }, (b"example.net", A): { "answers": [(b"example.net", Record_A("10.0.0.5"))], }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") d.addCallback(lambda results: results[0]) # Get the answer section d.addCallback( self.assertEqual, [ RRHeader(b"example.com", CNAME, payload=Record_CNAME(b"example.net")), RRHeader(b"example.net", A, payload=Record_A("10.0.0.5")), ], ) return d def test_detectCanonicalNameLoop(self): """ If there is a cycle between I{CNAME} records in a response, this is detected and the L{Deferred} returned by the lookup method fails with L{ResolverError}. """ servers = { ("1.1.2.3", 53): { (b"example.com", A): { "answers": [ (b"example.com", Record_CNAME(b"example.net")), (b"example.net", Record_CNAME(b"example.com")), ], }, }, } resolver = self._getResolver(servers) d = resolver.lookupAddress(b"example.com") return self.assertFailure(d, ResolverError) def test_boundedQueries(self): """ L{Resolver.lookupAddress} won't issue more queries following delegations than the limit passed to its initializer. """ servers = { ("1.1.2.3", 53): { # First query - force it to start over with a name lookup of # ns1.example.com (b"example.com", A): { "authority": [(b"example.com", Record_NS(b"ns1.example.com"))], }, # Second query - let it resume the original lookup with the # address of the nameserver handling the delegation. (b"ns1.example.com", A): { "answers": [(b"ns1.example.com", Record_A("10.0.0.2"))], }, }, ("10.0.0.2", 53): { # Third query - let it jump straight to asking the # delegation server by including its address here (different # case from the first query). (b"example.com", A): { "authority": [(b"example.com", Record_NS(b"ns2.example.com"))], "additional": [(b"ns2.example.com", Record_A("10.0.0.3"))], }, }, ("10.0.0.3", 53): { # Fourth query - give it the answer, we're done. (b"example.com", A): { "answers": [(b"example.com", Record_A("10.0.0.4"))], }, }, } # Make two resolvers. One which is allowed to make 3 queries # maximum, and so will fail, and on which may make 4, and so should # succeed. failer = self._getResolver(servers, 3) failD = self.assertFailure(failer.lookupAddress(b"example.com"), ResolverError) succeeder = self._getResolver(servers, 4) succeedD = succeeder.lookupAddress(b"example.com") succeedD.addCallback(getOnePayload) succeedD.addCallback(self.assertEqual, Record_A("10.0.0.4")) return gatherResults([failD, succeedD]) class ResolverFactoryArguments(Exception): """ Raised by L{raisingResolverFactory} with the *args and **kwargs passed to that function. """ def __init__(self, args, kwargs): """ Store the supplied args and kwargs as attributes. @param args: Positional arguments. @param kwargs: Keyword arguments. """ self.args = args self.kwargs = kwargs def raisingResolverFactory(*args, **kwargs): """ Raise a L{ResolverFactoryArguments} exception containing the positional and keyword arguments passed to resolverFactory. @param args: A L{list} of all the positional arguments supplied by the caller. @param kwargs: A L{list} of all the keyword arguments supplied by the caller. """ raise ResolverFactoryArguments(args, kwargs) class RootResolverResolverFactoryTests(TestCase): """ Tests for L{root.Resolver._resolverFactory}. """ def test_resolverFactoryArgumentPresent(self): """ L{root.Resolver.__init__} accepts a C{resolverFactory} argument and assigns it to C{self._resolverFactory}. """ r = Resolver(hints=[None], resolverFactory=raisingResolverFactory) self.assertIs(r._resolverFactory, raisingResolverFactory) def test_resolverFactoryArgumentAbsent(self): """ L{root.Resolver.__init__} sets L{client.Resolver} as the C{_resolverFactory} if a C{resolverFactory} argument is not supplied. """ r = Resolver(hints=[None]) self.assertIs(r._resolverFactory, client.Resolver) def test_resolverFactoryOnlyExpectedArguments(self): """ L{root.Resolver._resolverFactory} is supplied with C{reactor} and C{servers} keyword arguments. """ dummyReactor = object() r = Resolver( hints=["192.0.2.101"], resolverFactory=raisingResolverFactory, reactor=dummyReactor, ) e = self.assertRaises(ResolverFactoryArguments, r.lookupAddress, "example.com") self.assertEqual( ((), {"reactor": dummyReactor, "servers": [("192.0.2.101", 53)]}), (e.args, e.kwargs), ) ROOT_SERVERS = [ "a.root-servers.net", "b.root-servers.net", "c.root-servers.net", "d.root-servers.net", "e.root-servers.net", "f.root-servers.net", "g.root-servers.net", "h.root-servers.net", "i.root-servers.net", "j.root-servers.net", "k.root-servers.net", "l.root-servers.net", "m.root-servers.net", ] @implementer(IResolverSimple) class StubResolver: """ An L{IResolverSimple} implementer which traces all getHostByName calls and their deferred results. The deferred results can be accessed and fired synchronously. """ def __init__(self): """ @type calls: L{list} of L{tuple} containing C{args} and C{kwargs} supplied to C{getHostByName} calls. @type pendingResults: L{list} of L{Deferred} returned by C{getHostByName}. """ self.calls = [] self.pendingResults = [] def getHostByName(self, *args, **kwargs): """ A fake implementation of L{IResolverSimple.getHostByName} @param args: A L{list} of all the positional arguments supplied by the caller. @param kwargs: A L{list} of all the keyword arguments supplied by the caller. @return: A L{Deferred} which may be fired later from the test fixture. """ self.calls.append((args, kwargs)) d = Deferred() self.pendingResults.append(d) return d verifyClass(IResolverSimple, StubResolver) class BootstrapTests(SynchronousTestCase): """ Tests for L{root.bootstrap} """ def test_returnsDeferredResolver(self): """ L{root.bootstrap} returns an object which is initially a L{root.DeferredResolver}. """ deferredResolver = root.bootstrap(StubResolver()) self.assertIsInstance(deferredResolver, root.DeferredResolver) def test_resolves13RootServers(self): """ The L{IResolverSimple} supplied to L{root.bootstrap} is used to lookup the IP addresses of the 13 root name servers. """ stubResolver = StubResolver() root.bootstrap(stubResolver) self.assertEqual(stubResolver.calls, [((s,), {}) for s in ROOT_SERVERS]) def test_becomesResolver(self): """ The L{root.DeferredResolver} initially returned by L{root.bootstrap} becomes a L{root.Resolver} when the supplied resolver has successfully looked up all root hints. """ stubResolver = StubResolver() deferredResolver = root.bootstrap(stubResolver) for d in stubResolver.pendingResults: d.callback("192.0.2.101") self.assertIsInstance(deferredResolver, Resolver) def test_resolverReceivesRootHints(self): """ The L{root.Resolver} which eventually replaces L{root.DeferredResolver} is supplied with the IP addresses of the 13 root servers. """ stubResolver = StubResolver() deferredResolver = root.bootstrap(stubResolver) for d in stubResolver.pendingResults: d.callback("192.0.2.101") self.assertEqual(deferredResolver.hints, ["192.0.2.101"] * 13) def test_continuesWhenSomeRootHintsFail(self): """ The L{root.Resolver} is eventually created, even if some of the root hint lookups fail. Only the working root hint IP addresses are supplied to the L{root.Resolver}. """ stubResolver = StubResolver() deferredResolver = root.bootstrap(stubResolver) results = iter(stubResolver.pendingResults) d1 = next(results) for d in results: d.callback("192.0.2.101") d1.errback(TimeoutError()) def checkHints(res): self.assertEqual(deferredResolver.hints, ["192.0.2.101"] * 12) d1.addBoth(checkHints) def test_continuesWhenAllRootHintsFail(self): """ The L{root.Resolver} is eventually created, even if all of the root hint lookups fail. Pending and new lookups will then fail with AttributeError. """ stubResolver = StubResolver() deferredResolver = root.bootstrap(stubResolver) results = iter(stubResolver.pendingResults) d1 = next(results) for d in results: d.errback(TimeoutError()) d1.errback(TimeoutError()) def checkHints(res): self.assertEqual(deferredResolver.hints, []) d1.addBoth(checkHints) self.addCleanup(self.flushLoggedErrors, TimeoutError) def test_passesResolverFactory(self): """ L{root.bootstrap} accepts a C{resolverFactory} argument which is passed as an argument to L{root.Resolver} when it has successfully looked up root hints. """ stubResolver = StubResolver() deferredResolver = root.bootstrap( stubResolver, resolverFactory=raisingResolverFactory ) for d in stubResolver.pendingResults: d.callback("192.0.2.101") self.assertIs(deferredResolver._resolverFactory, raisingResolverFactory) class StubDNSDatagramProtocol: """ A do-nothing stand-in for L{DNSDatagramProtocol} which can be used to avoid network traffic in tests where that kind of thing doesn't matter. """ def query(self, *a, **kw): return Deferred() _retrySuppression = util.suppress( category=DeprecationWarning, message=( "twisted.names.root.retry is deprecated since Twisted 10.0. Use a " "Resolver object for retry logic." ), ) PK Mb�Z��4B^� ^� names/test/test_names.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for twisted.names. """ import copy import operator import socket from functools import partial, reduce from io import BytesIO from struct import pack from twisted.internet import defer, error, reactor from twisted.internet.defer import succeed from twisted.names import authority, client, common, dns, server from twisted.names.client import Resolver from twisted.names.dns import SOA, Message, Query, Record_A, Record_SOA, RRHeader from twisted.names.error import DomainError from twisted.names.secondary import SecondaryAuthority, SecondaryAuthorityService from twisted.python.compat import nativeString from twisted.python.filepath import FilePath from twisted.test.proto_helpers import ( MemoryReactorClock, StringTransport, waitUntilAllDisconnected, ) from twisted.trial import unittest def justPayload(results): return [r.payload for r in results[0]] class NoFileAuthority(authority.FileAuthority): def __init__(self, soa, records): # Yes, skip FileAuthority common.ResolverBase.__init__(self) self.soa, self.records = soa, records soa_record = dns.Record_SOA( mname=b"test-domain.com", rname="root.test-domain.com", serial=100, refresh=1234, minimum=7654, expire=19283784, retry=15, ttl=1, ) reverse_soa = dns.Record_SOA( mname=b"93.84.28.in-addr.arpa", rname=b"93.84.28.in-addr.arpa", serial=120, refresh=54321, minimum=382, expire=11193983, retry=30, ttl=3, ) my_soa = dns.Record_SOA( mname="my-domain.com", rname=b"postmaster.test-domain.com", serial=130, refresh=12345, minimum=1, expire=999999, retry=100, ) test_domain_com = NoFileAuthority( soa=(b"test-domain.com", soa_record), records={ b"test-domain.com": [ soa_record, dns.Record_A(b"127.0.0.1"), dns.Record_NS(b"39.28.189.39"), dns.Record_SPF(b"v=spf1 mx/30 mx:example.org/30 -all"), dns.Record_SPF(b"v=spf1 +mx a:\0colo", b".example.com/28 -all not valid"), dns.Record_MX(10, "host.test-domain.com"), dns.Record_HINFO(os=b"Linux", cpu=b"A Fast One, Dontcha know"), dns.Record_CNAME(b"canonical.name.com"), dns.Record_MB(b"mailbox.test-domain.com"), dns.Record_MG(b"mail.group.someplace"), dns.Record_TXT(b"A First piece of Text", b"a SecoNd piece"), dns.Record_A6(0, b"ABCD::4321", b""), dns.Record_A6(12, b"0:0069::0", b"some.network.tld"), dns.Record_A6(8, b"0:5634:1294:AFCB:56AC:48EF:34C3:01FF", b"tra.la.la.net"), dns.Record_TXT(b"Some more text, haha! Yes. \0 Still here?"), dns.Record_MR(b"mail.redirect.or.whatever"), dns.Record_MINFO(rmailbx=b"r mail box", emailbx=b"e mail box"), dns.Record_AFSDB(subtype=1, hostname=b"afsdb.test-domain.com"), dns.Record_RP(mbox=b"whatever.i.dunno", txt=b"some.more.text"), dns.Record_WKS( b"12.54.78.12", socket.IPPROTO_TCP, b"\x12\x01\x16\xfe\xc1\x00\x01" ), dns.Record_NAPTR( 100, 10, b"u", b"sip+E2U", b"!^.*$!sip:information@domain.tld!" ), dns.Record_AAAA(b"AF43:5634:1294:AFCB:56AC:48EF:34C3:01FF"), ], b"http.tcp.test-domain.com": [ dns.Record_SRV(257, 16383, 43690, b"some.other.place.fool") ], b"host.test-domain.com": [ dns.Record_A(b"123.242.1.5"), dns.Record_A(b"0.255.0.255"), ], b"host-two.test-domain.com": [ # # Python bug # dns.Record_A('255.255.255.255'), # dns.Record_A(b"255.255.255.254"), dns.Record_A(b"0.0.0.0"), ], b"cname.test-domain.com": [dns.Record_CNAME(b"test-domain.com")], b"anothertest-domain.com": [dns.Record_A(b"1.2.3.4")], }, ) reverse_domain = NoFileAuthority( soa=(b"93.84.28.in-addr.arpa", reverse_soa), records={ b"123.93.84.28.in-addr.arpa": [ dns.Record_PTR(b"test.host-reverse.lookup.com"), reverse_soa, ] }, ) my_domain_com = NoFileAuthority( soa=(b"my-domain.com", my_soa), records={ b"my-domain.com": [ my_soa, dns.Record_A(b"1.2.3.4", ttl="1S"), dns.Record_NS(b"ns1.domain", ttl=b"2M"), dns.Record_NS(b"ns2.domain", ttl="3H"), dns.Record_SRV(257, 16383, 43690, b"some.other.place.fool", ttl="4D"), ] }, ) class ServerDNSTests(unittest.TestCase): """ Test cases for DNS server and client. """ def setUp(self): self.factory = server.DNSServerFactory( [test_domain_com, reverse_domain, my_domain_com], verbose=2 ) p = dns.DNSDatagramProtocol(self.factory) while 1: listenerTCP = reactor.listenTCP(0, self.factory, interface="127.0.0.1") # It's simpler to do the stop listening with addCleanup, # even though we might not end up using this TCP port in # the test (if the listenUDP below fails). Cleaning up # this TCP port sooner than "cleanup time" would mean # adding more code to keep track of the Deferred returned # by stopListening. self.addCleanup(listenerTCP.stopListening) port = listenerTCP.getHost().port try: listenerUDP = reactor.listenUDP(port, p, interface="127.0.0.1") except error.CannotListenError: pass else: self.addCleanup(listenerUDP.stopListening) break self.listenerTCP = listenerTCP self.listenerUDP = listenerUDP self.resolver = client.Resolver(servers=[("127.0.0.1", port)]) def tearDown(self): """ Clean up any server connections associated with the L{DNSServerFactory} created in L{setUp} """ # It'd be great if DNSServerFactory had a method that # encapsulated this task. At least the necessary data is # available, though. for conn in self.factory.connections[:]: conn.transport.loseConnection() return waitUntilAllDisconnected(reactor, self.factory.connections[:]) def namesTest(self, querying, expectedRecords): """ Assert that the DNS response C{querying} will eventually fire with contains exactly a certain collection of records. @param querying: A L{Deferred} returned from one of the DNS client I{lookup} methods. @param expectedRecords: A L{list} of L{IRecord} providers which must be in the response or the test will be failed. @return: A L{Deferred} that fires when the assertion has been made. It fires with a success result if the assertion succeeds and with a L{Failure} if it fails. """ def checkResults(response): receivedRecords = justPayload(response) self.assertEqual(set(expectedRecords), set(receivedRecords)) querying.addCallback(checkResults) return querying def test_addressRecord1(self): """Test simple DNS 'A' record queries""" return self.namesTest( self.resolver.lookupAddress("test-domain.com"), [dns.Record_A("127.0.0.1", ttl=19283784)], ) def test_addressRecord2(self): """Test DNS 'A' record queries with multiple answers""" return self.namesTest( self.resolver.lookupAddress("host.test-domain.com"), [ dns.Record_A("123.242.1.5", ttl=19283784), dns.Record_A("0.255.0.255", ttl=19283784), ], ) def test_addressRecord3(self): """Test DNS 'A' record queries with edge cases""" return self.namesTest( self.resolver.lookupAddress("host-two.test-domain.com"), [ dns.Record_A("255.255.255.254", ttl=19283784), dns.Record_A("0.0.0.0", ttl=19283784), ], ) def test_authority(self): """Test DNS 'SOA' record queries""" return self.namesTest( self.resolver.lookupAuthority("test-domain.com"), [soa_record] ) def test_mailExchangeRecord(self): """ The DNS client can issue an MX query and receive a response including an MX record as well as any A record hints. """ return self.namesTest( self.resolver.lookupMailExchange(b"test-domain.com"), [ dns.Record_MX(10, b"host.test-domain.com", ttl=19283784), dns.Record_A(b"123.242.1.5", ttl=19283784), dns.Record_A(b"0.255.0.255", ttl=19283784), ], ) def test_nameserver(self): """Test DNS 'NS' record queries""" return self.namesTest( self.resolver.lookupNameservers("test-domain.com"), [dns.Record_NS("39.28.189.39", ttl=19283784)], ) def test_HINFO(self): """Test DNS 'HINFO' record queries""" return self.namesTest( self.resolver.lookupHostInfo("test-domain.com"), [ dns.Record_HINFO( os=b"Linux", cpu=b"A Fast One, Dontcha know", ttl=19283784 ) ], ) def test_PTR(self): """Test DNS 'PTR' record queries""" return self.namesTest( self.resolver.lookupPointer("123.93.84.28.in-addr.arpa"), [dns.Record_PTR("test.host-reverse.lookup.com", ttl=11193983)], ) def test_CNAME(self): """Test DNS 'CNAME' record queries""" return self.namesTest( self.resolver.lookupCanonicalName("test-domain.com"), [dns.Record_CNAME("canonical.name.com", ttl=19283784)], ) def test_MB(self): """Test DNS 'MB' record queries""" return self.namesTest( self.resolver.lookupMailBox("test-domain.com"), [dns.Record_MB("mailbox.test-domain.com", ttl=19283784)], ) def test_MG(self): """Test DNS 'MG' record queries""" return self.namesTest( self.resolver.lookupMailGroup("test-domain.com"), [dns.Record_MG("mail.group.someplace", ttl=19283784)], ) def test_MR(self): """Test DNS 'MR' record queries""" return self.namesTest( self.resolver.lookupMailRename("test-domain.com"), [dns.Record_MR("mail.redirect.or.whatever", ttl=19283784)], ) def test_MINFO(self): """Test DNS 'MINFO' record queries""" return self.namesTest( self.resolver.lookupMailboxInfo("test-domain.com"), [ dns.Record_MINFO( rmailbx="r mail box", emailbx="e mail box", ttl=19283784 ) ], ) def test_SRV(self): """Test DNS 'SRV' record queries""" return self.namesTest( self.resolver.lookupService("http.tcp.test-domain.com"), [dns.Record_SRV(257, 16383, 43690, "some.other.place.fool", ttl=19283784)], ) def test_AFSDB(self): """Test DNS 'AFSDB' record queries""" return self.namesTest( self.resolver.lookupAFSDatabase("test-domain.com"), [ dns.Record_AFSDB( subtype=1, hostname="afsdb.test-domain.com", ttl=19283784 ) ], ) def test_RP(self): """Test DNS 'RP' record queries""" return self.namesTest( self.resolver.lookupResponsibility("test-domain.com"), [ dns.Record_RP( mbox="whatever.i.dunno", txt="some.more.text", ttl=19283784 ) ], ) def test_TXT(self): """Test DNS 'TXT' record queries""" return self.namesTest( self.resolver.lookupText("test-domain.com"), [ dns.Record_TXT( b"A First piece of Text", b"a SecoNd piece", ttl=19283784 ), dns.Record_TXT( b"Some more text, haha! Yes. \0 Still here?", ttl=19283784 ), ], ) def test_spf(self): """ L{DNSServerFactory} can serve I{SPF} resource records. """ return self.namesTest( self.resolver.lookupSenderPolicy("test-domain.com"), [ dns.Record_SPF(b"v=spf1 mx/30 mx:example.org/30 -all", ttl=19283784), dns.Record_SPF( b"v=spf1 +mx a:\0colo", b".example.com/28 -all not valid", ttl=19283784, ), ], ) def test_WKS(self): """Test DNS 'WKS' record queries""" return self.namesTest( self.resolver.lookupWellKnownServices("test-domain.com"), [ dns.Record_WKS( "12.54.78.12", socket.IPPROTO_TCP, b"\x12\x01\x16\xfe\xc1\x00\x01", ttl=19283784, ) ], ) def test_someRecordsWithTTLs(self): result_soa = copy.copy(my_soa) result_soa.ttl = my_soa.expire return self.namesTest( self.resolver.lookupAllRecords("my-domain.com"), [ result_soa, dns.Record_A("1.2.3.4", ttl="1S"), dns.Record_NS("ns1.domain", ttl="2M"), dns.Record_NS("ns2.domain", ttl="3H"), dns.Record_SRV(257, 16383, 43690, "some.other.place.fool", ttl="4D"), ], ) def test_AAAA(self): """Test DNS 'AAAA' record queries (IPv6)""" return self.namesTest( self.resolver.lookupIPV6Address("test-domain.com"), [dns.Record_AAAA("AF43:5634:1294:AFCB:56AC:48EF:34C3:01FF", ttl=19283784)], ) def test_A6(self): """Test DNS 'A6' record queries (IPv6)""" return self.namesTest( self.resolver.lookupAddress6("test-domain.com"), [ dns.Record_A6(0, "ABCD::4321", "", ttl=19283784), dns.Record_A6(12, "0:0069::0", "some.network.tld", ttl=19283784), dns.Record_A6( 8, "0:5634:1294:AFCB:56AC:48EF:34C3:01FF", "tra.la.la.net", ttl=19283784, ), ], ) def test_zoneTransfer(self): """ Test DNS 'AXFR' queries (Zone transfer) """ default_ttl = soa_record.expire results = [ copy.copy(r) for r in reduce(operator.add, test_domain_com.records.values()) ] for r in results: if r.ttl is None: r.ttl = default_ttl return self.namesTest( self.resolver.lookupZone("test-domain.com").addCallback( lambda r: (r[0][:-1],) ), results, ) def test_zoneTransferConnectionFails(self): """ A failed AXFR TCP connection errbacks the L{Deferred} returned from L{Resolver.lookupZone}. """ resolver = Resolver(servers=[("nameserver.invalid", 53)]) return self.assertFailure( resolver.lookupZone("impossible.invalid"), error.DNSLookupError ) def test_similarZonesDontInterfere(self): """Tests that unrelated zones don't mess with each other.""" return self.namesTest( self.resolver.lookupAddress("anothertest-domain.com"), [dns.Record_A("1.2.3.4", ttl=19283784)], ) def test_NAPTR(self): """ Test DNS 'NAPTR' record queries. """ return self.namesTest( self.resolver.lookupNamingAuthorityPointer("test-domain.com"), [ dns.Record_NAPTR( 100, 10, b"u", b"sip+E2U", b"!^.*$!sip:information@domain.tld!", ttl=19283784, ) ], ) class HelperTests(unittest.TestCase): def test_serialGenerator(self): f = self.mktemp() a = authority.getSerial(f) for i in range(20): b = authority.getSerial(f) self.assertTrue(a < b) a = b class AXFRTests(unittest.TestCase): def setUp(self): self.results = None self.d = defer.Deferred() self.d.addCallback(self._gotResults) self.controller = client.AXFRController("fooby.com", self.d) self.soa = dns.RRHeader( name="fooby.com", type=dns.SOA, cls=dns.IN, ttl=86400, auth=False, payload=dns.Record_SOA( mname="fooby.com", rname="hooj.fooby.com", serial=100, refresh=200, retry=300, expire=400, minimum=500, ttl=600, ), ) self.records = [ self.soa, dns.RRHeader( name="fooby.com", type=dns.NS, cls=dns.IN, ttl=700, auth=False, payload=dns.Record_NS(name="ns.twistedmatrix.com", ttl=700), ), dns.RRHeader( name="fooby.com", type=dns.MX, cls=dns.IN, ttl=700, auth=False, payload=dns.Record_MX(preference=10, exchange="mail.mv3d.com", ttl=700), ), dns.RRHeader( name="fooby.com", type=dns.A, cls=dns.IN, ttl=700, auth=False, payload=dns.Record_A(address="64.123.27.105", ttl=700), ), self.soa, ] def _makeMessage(self): # hooray they all have the same message format return dns.Message( id=999, answer=1, opCode=0, recDes=0, recAv=1, auth=1, rCode=0, trunc=0, maxSize=0, ) def test_bindAndTNamesStyle(self): # Bind style = One big single message m = self._makeMessage() m.queries = [dns.Query("fooby.com", dns.AXFR, dns.IN)] m.answers = self.records self.controller.messageReceived(m, None) self.assertEqual(self.results, self.records) def _gotResults(self, result): self.results = result def test_DJBStyle(self): # DJB style = message per record records = self.records[:] while records: m = self._makeMessage() m.queries = [] # DJB *doesn't* specify any queries.. hmm.. m.answers = [records.pop(0)] self.controller.messageReceived(m, None) self.assertEqual(self.results, self.records) class ResolvConfHandlingTests(unittest.TestCase): def test_missing(self): resolvConf = self.mktemp() r = client.Resolver(resolv=resolvConf) self.assertEqual(r.dynServers, [("127.0.0.1", 53)]) r._parseCall.cancel() def test_empty(self): resolvConf = self.mktemp() open(resolvConf, "w").close() r = client.Resolver(resolv=resolvConf) self.assertEqual(r.dynServers, [("127.0.0.1", 53)]) r._parseCall.cancel() class AuthorityTests(unittest.TestCase): """ Tests for the basic response record selection code in L{FileAuthority} (independent of its fileness). """ def test_domainErrorForNameWithCommonSuffix(self): """ L{FileAuthority} lookup methods errback with L{DomainError} if the requested C{name} shares a common suffix with its zone but is not actually a descendant of its zone, in terms of its sequence of DNS name labels. eg www.the-example.com has nothing to do with the zone example.com. """ testDomain = test_domain_com testDomainName = b"nonexistent.prefix-" + testDomain.soa[0] f = self.failureResultOf(testDomain.lookupAddress(testDomainName)) self.assertIsInstance(f.value, DomainError) def test_recordMissing(self): """ If a L{FileAuthority} has a zone which includes an I{NS} record for a particular name and that authority is asked for another record for the same name which does not exist, the I{NS} record is not included in the authority section of the response. """ authority = NoFileAuthority( soa=(soa_record.mname.name, soa_record), records={ soa_record.mname.name: [ soa_record, dns.Record_NS("1.2.3.4"), ] }, ) answer, authority, additional = self.successResultOf( authority.lookupAddress(soa_record.mname.name) ) self.assertEqual(answer, []) self.assertEqual( authority, [ dns.RRHeader( soa_record.mname.name, soa_record.TYPE, ttl=soa_record.expire, payload=soa_record, auth=True, ) ], ) self.assertEqual(additional, []) def test_unknownTypeNXDOMAIN(self): """ Requesting a record of unknown type where no records exist for the name in question results in L{DomainError}. """ testDomain = test_domain_com testDomainName = b"nonexistent.prefix-" + testDomain.soa[0] unknownType = max(common.typeToMethod) + 1 f = self.failureResultOf( testDomain.query(Query(name=testDomainName, type=unknownType)) ) self.assertIsInstance(f.value, DomainError) def test_unknownTypeMissing(self): """ Requesting a record of unknown type where other records exist for the name in question results in an empty answer set. """ unknownType = max(common.typeToMethod) + 1 answer, authority, additional = self.successResultOf( my_domain_com.query(Query(name="my-domain.com", type=unknownType)) ) self.assertEqual(answer, []) def _referralTest(self, method): """ Create an authority and make a request against it. Then verify that the result is a referral, including no records in the answers or additional sections, but with an I{NS} record in the authority section. """ subdomain = b"example." + soa_record.mname.name nameserver = dns.Record_NS("1.2.3.4") authority = NoFileAuthority( soa=(soa_record.mname.name, soa_record), records={ subdomain: [ nameserver, ] }, ) d = getattr(authority, method)(subdomain) answer, authority, additional = self.successResultOf(d) self.assertEqual(answer, []) self.assertEqual( authority, [ dns.RRHeader( subdomain, dns.NS, ttl=soa_record.expire, payload=nameserver, auth=False, ) ], ) self.assertEqual(additional, []) def test_referral(self): """ When an I{NS} record is found for a child zone, it is included in the authority section of the response. It is marked as non-authoritative if the authority is not also authoritative for the child zone (RFC 2181, section 6.1). """ self._referralTest("lookupAddress") def test_allRecordsReferral(self): """ A referral is also generated for a request of type C{ALL_RECORDS}. """ self._referralTest("lookupAllRecords") class AdditionalProcessingTests(unittest.TestCase): """ Tests for L{FileAuthority}'s additional processing for those record types which require it (MX, CNAME, etc). """ _A = dns.Record_A(b"10.0.0.1") _AAAA = dns.Record_AAAA(b"f080::1") def _lookupSomeRecords(self, method, soa, makeRecord, target, addresses): """ Perform a DNS lookup against a L{FileAuthority} configured with records as defined by C{makeRecord} and C{addresses}. @param method: The name of the lookup method to use; for example, C{"lookupNameservers"}. @type method: L{str} @param soa: A L{Record_SOA} for the zone for which the L{FileAuthority} is authoritative. @param makeRecord: A one-argument callable which accepts a name and returns an L{IRecord} provider. L{FileAuthority} is constructed with this record. The L{FileAuthority} is queried for a record of the resulting type with the given name. @param target: The extra name which the record returned by C{makeRecord} will be pointed at; this is the name which might require extra processing by the server so that all the available, useful information is returned. For example, this is the target of a CNAME record or the mail exchange host pointed to by an MX record. @type target: L{bytes} @param addresses: A L{list} of records giving addresses of C{target}. @return: A L{Deferred} that fires with the result of the resolver method give by C{method}. """ authority = NoFileAuthority( soa=(soa.mname.name, soa), records={ soa.mname.name: [makeRecord(target)], target: addresses, }, ) return getattr(authority, method)(soa_record.mname.name) def assertRecordsMatch(self, expected, computed): """ Assert that the L{RRHeader} instances given by C{expected} and C{computed} carry all the same information but without requiring the records appear in the same order. @param expected: A L{list} of L{RRHeader} instances giving the expected records. @param computed: A L{list} of L{RRHeader} instances giving the records computed by the scenario under test. @raise self.failureException: If the two collections of records disagree. """ # RRHeader instances aren't inherently ordered. Impose an ordering # that's good enough for the purposes of these tests - in which we # never have more than one record of a particular type. key = lambda rr: rr.type self.assertEqual(sorted(expected, key=key), sorted(computed, key=key)) def _additionalTest(self, method, makeRecord, addresses): """ Verify that certain address records are included in the I{additional} section of a response generated by L{FileAuthority}. @param method: See L{_lookupSomeRecords} @param makeRecord: See L{_lookupSomeRecords} @param addresses: A L{list} of L{IRecord} providers which the I{additional} section of the response is required to match (ignoring order). @raise self.failureException: If the I{additional} section of the response consists of different records than those given by C{addresses}. """ target = b"mail." + soa_record.mname.name d = self._lookupSomeRecords(method, soa_record, makeRecord, target, addresses) answer, authority, additional = self.successResultOf(d) self.assertRecordsMatch( [ dns.RRHeader( target, address.TYPE, ttl=soa_record.expire, payload=address, auth=True, ) for address in addresses ], additional, ) def _additionalMXTest(self, addresses): """ Verify that a response to an MX query has certain records in the I{additional} section. @param addresses: See C{_additionalTest} """ self._additionalTest( "lookupMailExchange", partial(dns.Record_MX, 10), addresses ) def test_mailExchangeAdditionalA(self): """ If the name of the MX response has A records, they are included in the additional section of the response. """ self._additionalMXTest([self._A]) def test_mailExchangeAdditionalAAAA(self): """ If the name of the MX response has AAAA records, they are included in the additional section of the response. """ self._additionalMXTest([self._AAAA]) def test_mailExchangeAdditionalBoth(self): """ If the name of the MX response has both A and AAAA records, they are all included in the additional section of the response. """ self._additionalMXTest([self._A, self._AAAA]) def _additionalNSTest(self, addresses): """ Verify that a response to an NS query has certain records in the I{additional} section. @param addresses: See C{_additionalTest} """ self._additionalTest("lookupNameservers", dns.Record_NS, addresses) def test_nameserverAdditionalA(self): """ If the name of the NS response has A records, they are included in the additional section of the response. """ self._additionalNSTest([self._A]) def test_nameserverAdditionalAAAA(self): """ If the name of the NS response has AAAA records, they are included in the additional section of the response. """ self._additionalNSTest([self._AAAA]) def test_nameserverAdditionalBoth(self): """ If the name of the NS response has both A and AAAA records, they are all included in the additional section of the response. """ self._additionalNSTest([self._A, self._AAAA]) def _answerCNAMETest(self, addresses): """ Verify that a response to a CNAME query has certain records in the I{answer} section. @param addresses: See C{_additionalTest} """ target = b"www." + soa_record.mname.name d = self._lookupSomeRecords( "lookupCanonicalName", soa_record, dns.Record_CNAME, target, addresses ) answer, authority, additional = self.successResultOf(d) alias = dns.RRHeader( soa_record.mname.name, dns.CNAME, ttl=soa_record.expire, payload=dns.Record_CNAME(target), auth=True, ) self.assertRecordsMatch( [ dns.RRHeader( target, address.TYPE, ttl=soa_record.expire, payload=address, auth=True, ) for address in addresses ] + [alias], answer, ) def test_canonicalNameAnswerA(self): """ If the name of the CNAME response has A records, they are included in the answer section of the response. """ self._answerCNAMETest([self._A]) def test_canonicalNameAnswerAAAA(self): """ If the name of the CNAME response has AAAA records, they are included in the answer section of the response. """ self._answerCNAMETest([self._AAAA]) def test_canonicalNameAnswerBoth(self): """ If the name of the CNAME response has both A and AAAA records, they are all included in the answer section of the response. """ self._answerCNAMETest([self._A, self._AAAA]) class NoInitialResponseTests(unittest.TestCase): def test_noAnswer(self): """ If a request returns a L{dns.NS} response, but we can't connect to the given server, the request fails with the error returned at connection. """ def query(self, *args): # Pop from the message list, so that it blows up if more queries # are run than expected. return succeed(messages.pop(0)) def queryProtocol(self, *args, **kwargs): return defer.fail(socket.gaierror("Couldn't connect")) resolver = Resolver(servers=[("0.0.0.0", 0)]) resolver._query = query messages = [] # Let's patch dns.DNSDatagramProtocol.query, as there is no easy way to # customize it. self.patch(dns.DNSDatagramProtocol, "query", queryProtocol) records = [ dns.RRHeader( name="fooba.com", type=dns.NS, cls=dns.IN, ttl=700, auth=False, payload=dns.Record_NS(name="ns.twistedmatrix.com", ttl=700), ) ] m = dns.Message( id=999, answer=1, opCode=0, recDes=0, recAv=1, auth=1, rCode=0, trunc=0, maxSize=0, ) m.answers = records messages.append(m) return self.assertFailure(resolver.getHostByName("fooby.com"), socket.gaierror) class SecondaryAuthorityServiceTests(unittest.TestCase): """ Tests for L{SecondaryAuthorityService}, a service which keeps one or more authorities up to date by doing zone transfers from a master. """ def test_constructAuthorityFromHost(self): """ L{SecondaryAuthorityService} can be constructed with a C{str} giving a master server address and several domains, causing the creation of a secondary authority for each domain and that master server address and the default DNS port. """ primary = "192.168.1.2" service = SecondaryAuthorityService(primary, [b"example.com", "example.org"]) self.assertEqual(service.primary, primary) self.assertEqual(service._port, 53) self.assertEqual(service.domains[0].primary, primary) self.assertEqual(service.domains[0]._port, 53) self.assertEqual(service.domains[0].domain, b"example.com") self.assertEqual(service.domains[1].primary, primary) self.assertEqual(service.domains[1]._port, 53) self.assertEqual(service.domains[1].domain, b"example.org") def test_constructAuthorityFromHostAndPort(self): """ L{SecondaryAuthorityService.fromServerAddressAndDomains} constructs a new L{SecondaryAuthorityService} from a C{str} giving a master server address and DNS port and several domains, causing the creation of a secondary authority for each domain and that master server address and the given DNS port. """ primary = "192.168.1.3" port = 5335 service = SecondaryAuthorityService.fromServerAddressAndDomains( (primary, port), ["example.net", b"example.edu"] ) self.assertEqual(service.primary, primary) self.assertEqual(service._port, 5335) self.assertEqual(service.domains[0].primary, primary) self.assertEqual(service.domains[0]._port, port) self.assertEqual(service.domains[0].domain, b"example.net") self.assertEqual(service.domains[1].primary, primary) self.assertEqual(service.domains[1]._port, port) self.assertEqual(service.domains[1].domain, b"example.edu") def test_constructAuthorityFromBytes(self): """ L{SecondaryAuthorityService.fromServerAddressAndDomains} constructs a new L{SecondaryAuthorityService} from a C{bytes} giving a master server address and several domains, causing the creation of a secondary authority for each domain and that master server address and the given DNS port. """ primary = "192.168.1.3" service = SecondaryAuthorityService( primary.encode(), [b"example.net", "example.edu"], # Coerced to bytes. ) self.assertEqual(service.primary, primary) self.assertEqual(service.domains[0].primary, primary) self.assertEqual(service.domains[0].domain, b"example.net") self.assertEqual(service.domains[1].primary, primary) self.assertEqual(service.domains[1].domain, b"example.edu") class SecondaryAuthorityTests(unittest.TestCase): """ L{twisted.names.secondary.SecondaryAuthority} correctly constructs objects with a specified IP address and optionally specified DNS port. """ def test_defaultPort(self): """ When constructed using L{SecondaryAuthority.__init__}, the default port of 53 is used. """ secondary = SecondaryAuthority("192.168.1.1", "inside.com") self.assertEqual(secondary.primary, "192.168.1.1") self.assertEqual(secondary._port, 53) self.assertEqual(secondary.domain, b"inside.com") def test_explicitPort(self): """ When constructed using L{SecondaryAuthority.fromServerAddressAndDomain}, the specified port is used. """ secondary = SecondaryAuthority.fromServerAddressAndDomain( ("192.168.1.1", 5353), "inside.com" ) self.assertEqual(secondary.primary, "192.168.1.1") self.assertEqual(secondary._port, 5353) self.assertEqual(secondary.domain, b"inside.com") def test_transfer(self): """ An attempt is made to transfer the zone for the domain the L{SecondaryAuthority} was constructed with from the server address it was constructed with when L{SecondaryAuthority.transfer} is called. """ secondary = SecondaryAuthority.fromServerAddressAndDomain( ("192.168.1.2", 1234), "example.com" ) secondary._reactor = reactor = MemoryReactorClock() secondary.transfer() # Verify a connection attempt to the server address above host, port, factory, timeout, bindAddress = reactor.tcpClients.pop(0) self.assertEqual(host, "192.168.1.2") self.assertEqual(port, 1234) # See if a zone transfer query is issued. proto = factory.buildProtocol((host, port)) transport = StringTransport() proto.makeConnection(transport) msg = Message() # DNSProtocol.writeMessage length encodes the message by prepending a # 2 byte message length to the buffered value. msg.decode(BytesIO(transport.value()[2:])) self.assertEqual([dns.Query("example.com", dns.AXFR, dns.IN)], msg.queries) def test_lookupAddress(self): """ L{SecondaryAuthority.lookupAddress} returns a L{Deferred} that fires with the I{A} records the authority has cached from the primary. """ secondary = SecondaryAuthority.fromServerAddressAndDomain( ("192.168.1.2", 1234), b"example.com" ) secondary._reactor = reactor = MemoryReactorClock() secondary.transfer() host, port, factory, timeout, bindAddress = reactor.tcpClients.pop(0) proto = factory.buildProtocol((host, port)) transport = StringTransport() proto.makeConnection(transport) query = Message(answer=1, auth=1) query.decode(BytesIO(transport.value()[2:])) # Generate a response with some data we can check. soa = Record_SOA( mname=b"ns1.example.com", rname="admin.example.com", serial=123456, refresh=3600, minimum=4800, expire=7200, retry=9600, ttl=12000, ) a = Record_A(b"192.168.1.2", ttl=0) answer = Message(id=query.id, answer=1, auth=1) answer.answers.extend( [ RRHeader(b"example.com", type=SOA, payload=soa), RRHeader(b"example.com", payload=a), RRHeader(b"example.com", type=SOA, payload=soa), ] ) data = answer.toStr() proto.dataReceived(pack("!H", len(data)) + data) result = self.successResultOf(secondary.lookupAddress("example.com")) self.assertEqual( ([RRHeader(b"example.com", payload=a, auth=True)], [], []), result ) sampleBindZone = b"""\ $ORIGIN example.com. $TTL 1w example.com. IN SOA dns.example.com ( 2013120201 ; serial number of this zone file 1d ; slave refresh 2h ; slave retry time in case of a problem 4w ; slave expiration time 1h ; maximum caching time in case of failed lookups ) ; A comment. @ IN AAAA 2001:db8:10::1 example.com. IN A 10.0.0.1 no-in.example.com. A 10.0.0.2 ; technically wrong but used to work not-fqdn IN MX 10 mx.example.com www IN CNAME example.com""" class BindAuthorityTests(unittest.TestCase): """ Tests for L{twisted.names.authority.BindAuthority}. """ def loadBindString(self, s): """ Create a new L{twisted.names.authority.BindAuthority} from C{s}. @param s: A string with BIND zone data. @type s: bytes @return: a new bind authority @rtype: L{twisted.names.authority.BindAuthority} """ fp = FilePath(self.mktemp().encode("ascii")) fp.setContent(s) return authority.BindAuthority(fp.path) def setUp(self): self.auth = self.loadBindString(sampleBindZone) def test_ttl(self): """ Loads the default $TTL and applies it to all records. """ for dom in self.auth.records.keys(): for rec in self.auth.records[dom]: self.assertTrue(604800 == rec.ttl) def test_originFromFile(self): """ Loads the default $ORIGIN. """ self.assertEqual( b"example.com.", self.auth.origin, ) self.assertIn( b"not-fqdn.example.com", self.auth.records, ) def test_aRecords(self): """ A records are loaded. """ for dom, ip in [ (b"example.com", "10.0.0.1"), (b"no-in.example.com", "10.0.0.2"), ]: [[rr], [], []] = self.successResultOf(self.auth.lookupAddress(dom)) self.assertEqual( dns.Record_A( ip, 604800, ), rr.payload, ) def test_aaaaRecords(self): """ AAAA records are loaded. """ [[rr], [], []] = self.successResultOf( self.auth.lookupIPV6Address(b"example.com") ) self.assertEqual( dns.Record_AAAA( "2001:db8:10::1", 604800, ), rr.payload, ) def test_mxRecords(self): """ MX records are loaded. """ [[rr], [], []] = self.successResultOf( self.auth.lookupMailExchange(b"not-fqdn.example.com") ) self.assertEqual( dns.Record_MX( preference=10, name="mx.example.com", ttl=604800, ), rr.payload, ) def test_cnameRecords(self): """ CNAME records are loaded. """ [answers, [], []] = self.successResultOf( self.auth.lookupIPV6Address(b"www.example.com") ) rr = answers[0] self.assertEqual( dns.Record_CNAME( name="example.com", ttl=604800, ), rr.payload, ) def test_invalidRecordClass(self): """ loadBindString raises NotImplementedError on invalid records. """ with self.assertRaises(NotImplementedError) as e: self.loadBindString(b"example.com. IN LOL 192.168.0.1") self.assertEqual("Record type 'LOL' not supported", e.exception.args[0]) def test_invalidDirectives(self): """ $INCLUDE and $GENERATE raise NotImplementedError. """ for directive in (b"$INCLUDE", b"$GENERATE"): with self.assertRaises(NotImplementedError) as e: self.loadBindString(directive + b" doesNotMatter") self.assertEqual( nativeString(directive + b" directive not implemented"), e.exception.args[0], ) samplePySource = """\ zone = [ SOA( # For whom we are the authority 'example.com', # This nameserver's name mname = "dns.example.com", # Mailbox of individual who handles this rname = "root.example.com", # Unique serial identifying this SOA data serial = 86400, # Time interval before zone should be refreshed refresh = "2H", # Interval before failed refresh should be retried retry = "1H", # Upper limit on time interval before expiry expire = "1H", # Minimum TTL minimum = "3H" ), AAAA('example.com', '2001:db8:10::1'), A('example.com', '10.0.0.1'), NS('example.com', 'dns.example.com'), A('no-in.example.com', '10.0.0.2'), PTR('2.0.0.10.in-addr.arpa', 'no-in.example.com'), CNAME('www.example.com', 'example.com'), CNAME('ftp.example.com', 'example.com'), MX('not-fqdn.example.com', 10, 'mail.example.com'), ] """ class PySourceAuthorityTests(unittest.TestCase): """ Tests for L{twisted.names.authority.PySourceAuthority}. """ def loadPySourceString(self, s): """ Create a new L{twisted.names.authority.PySourceAuthority} from C{s}. @param s: A string with BIND zone data in a Python source file. @type s: L{str} @return: a new bind authority @rtype: L{twisted.names.authority.PySourceAuthority} """ fp = FilePath(self.mktemp()) with open(fp.path, "w") as f: f.write(s) return authority.PySourceAuthority(fp.path) def setUp(self): self.auth = self.loadPySourceString(samplePySource) def test_aRecords(self): """ A records are loaded. """ for dom, ip in [ (b"example.com", "10.0.0.1"), (b"no-in.example.com", "10.0.0.2"), ]: [[rr], [], []] = self.successResultOf(self.auth.lookupAddress(dom)) self.assertEqual( dns.Record_A(ip), rr.payload, ) def test_aaaaRecords(self): """ AAAA records are loaded. """ [[rr], [], []] = self.successResultOf( self.auth.lookupIPV6Address(b"example.com") ) self.assertEqual( dns.Record_AAAA("2001:db8:10::1"), rr.payload, ) def test_mxRecords(self): """ MX records are loaded. """ [[rr], [], []] = self.successResultOf( self.auth.lookupMailExchange(b"not-fqdn.example.com") ) self.assertEqual( dns.Record_MX( preference=10, name="mail.example.com", ), rr.payload, ) def test_cnameRecords(self): """ CNAME records are loaded. """ [answers, [], []] = self.successResultOf( self.auth.lookupIPV6Address(b"www.example.com") ) rr = answers[0] self.assertEqual( dns.Record_CNAME( name="example.com", ), rr.payload, ) def test_PTR(self): """ PTR records are loaded. """ [answers, [], []] = self.successResultOf( self.auth.lookupPointer(b"2.0.0.10.in-addr.arpa") ) rr = answers[0] self.assertEqual( dns.Record_PTR( name=b"no-in.example.com", ), rr.payload, ) def test_badInputNoZone(self): """ Input file has no zone variable """ badPySource = "nothing = []" self.assertRaises(ValueError, self.loadPySourceString, badPySource) PK Mb�ZG�O�� � names/test/test_util.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Utilities for Twisted.names tests. """ from random import randrange from zope.interface import implementer from zope.interface.verify import verifyClass from twisted.internet.address import IPv4Address from twisted.internet.defer import succeed from twisted.internet.interfaces import IReactorUDP, IUDPTransport from twisted.internet.task import Clock @implementer(IUDPTransport) class MemoryDatagramTransport: """ This L{IUDPTransport} implementation enforces the usual connection rules and captures sent traffic in a list for later inspection. @ivar _host: The host address to which this transport is bound. @ivar _protocol: The protocol connected to this transport. @ivar _sentPackets: A C{list} of two-tuples of the datagrams passed to C{write} and the addresses to which they are destined. @ivar _connectedTo: L{None} if this transport is unconnected, otherwise an address to which all traffic is supposedly sent. @ivar _maxPacketSize: An C{int} giving the maximum length of a datagram which will be successfully handled by C{write}. """ def __init__(self, host, protocol, maxPacketSize): self._host = host self._protocol = protocol self._sentPackets = [] self._connectedTo = None self._maxPacketSize = maxPacketSize def getHost(self): """ Return the address which this transport is pretending to be bound to. """ return IPv4Address("UDP", *self._host) def connect(self, host, port): """ Connect this transport to the given address. """ if self._connectedTo is not None: raise ValueError("Already connected") self._connectedTo = (host, port) def write(self, datagram, addr=None): """ Send the given datagram. """ if addr is None: addr = self._connectedTo if addr is None: raise ValueError("Need an address") if len(datagram) > self._maxPacketSize: raise ValueError("Packet too big") self._sentPackets.append((datagram, addr)) def stopListening(self): """ Shut down this transport. """ self._protocol.stopProtocol() return succeed(None) def setBroadcastAllowed(self, enabled): """ Dummy implementation to satisfy L{IUDPTransport}. """ pass def getBroadcastAllowed(self): """ Dummy implementation to satisfy L{IUDPTransport}. """ pass verifyClass(IUDPTransport, MemoryDatagramTransport) @implementer(IReactorUDP) class MemoryReactor(Clock): """ An L{IReactorTime} and L{IReactorUDP} provider. Time is controlled deterministically via the base class, L{Clock}. UDP is handled in-memory by connecting protocols to instances of L{MemoryDatagramTransport}. @ivar udpPorts: A C{dict} mapping port numbers to instances of L{MemoryDatagramTransport}. """ def __init__(self): Clock.__init__(self) self.udpPorts = {} def listenUDP(self, port, protocol, interface="", maxPacketSize=8192): """ Pretend to bind a UDP port and connect the given protocol to it. """ if port == 0: while True: port = randrange(1, 2 ** 16) if port not in self.udpPorts: break if port in self.udpPorts: raise ValueError("Address in use") transport = MemoryDatagramTransport((interface, port), protocol, maxPacketSize) self.udpPorts[port] = transport protocol.makeConnection(transport) return transport verifyClass(IReactorUDP, MemoryReactor) PK Mb�Z�l�� � names/test/test_tap.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.names.tap}. """ from twisted.internet.base import ThreadedResolver from twisted.names.client import Resolver from twisted.names.dns import PORT from twisted.names.resolve import ResolverChain from twisted.names.secondary import SecondaryAuthorityService from twisted.names.tap import Options, _buildResolvers from twisted.python.runtime import platform from twisted.python.usage import UsageError from twisted.trial.unittest import SynchronousTestCase class OptionsTests(SynchronousTestCase): """ Tests for L{Options}, defining how command line arguments for the DNS server are parsed. """ def test_malformedSecondary(self): """ If the value supplied for an I{--secondary} option does not provide a server IP address, optional port number, and domain name, L{Options.parseOptions} raises L{UsageError}. """ options = Options() self.assertRaises(UsageError, options.parseOptions, ["--secondary", ""]) self.assertRaises(UsageError, options.parseOptions, ["--secondary", "1.2.3.4"]) self.assertRaises( UsageError, options.parseOptions, ["--secondary", "1.2.3.4:hello"] ) self.assertRaises( UsageError, options.parseOptions, ["--secondary", "1.2.3.4:hello/example.com"], ) def test_secondary(self): """ An argument of the form C{"ip/domain"} is parsed by L{Options} for the I{--secondary} option and added to its list of secondaries, using the default DNS port number. """ options = Options() options.parseOptions(["--secondary", "1.2.3.4/example.com"]) self.assertEqual([(("1.2.3.4", PORT), ["example.com"])], options.secondaries) def test_secondaryExplicitPort(self): """ An argument of the form C{"ip:port/domain"} can be used to specify an alternate port number for which to act as a secondary. """ options = Options() options.parseOptions(["--secondary", "1.2.3.4:5353/example.com"]) self.assertEqual([(("1.2.3.4", 5353), ["example.com"])], options.secondaries) def test_secondaryAuthorityServices(self): """ After parsing I{--secondary} options, L{Options} constructs a L{SecondaryAuthorityService} instance for each configured secondary. """ options = Options() options.parseOptions( [ "--secondary", "1.2.3.4:5353/example.com", "--secondary", "1.2.3.5:5354/example.com", ] ) self.assertEqual(len(options.svcs), 2) secondary = options.svcs[0] self.assertIsInstance(options.svcs[0], SecondaryAuthorityService) self.assertEqual(secondary.primary, "1.2.3.4") self.assertEqual(secondary._port, 5353) secondary = options.svcs[1] self.assertIsInstance(options.svcs[1], SecondaryAuthorityService) self.assertEqual(secondary.primary, "1.2.3.5") self.assertEqual(secondary._port, 5354) def test_recursiveConfiguration(self): """ Recursive DNS lookups, if enabled, should be a last-resort option. Any other lookup method (cache, local lookup, etc.) should take precedence over recursive lookups """ options = Options() options.parseOptions(["--hosts-file", "hosts.txt", "--recursive"]) ca, cl = _buildResolvers(options) # Extra cleanup, necessary on POSIX because client.Resolver doesn't know # when to stop parsing resolv.conf. See #NNN for improving this. for x in cl: if isinstance(x, ResolverChain): recurser = x.resolvers[-1] if isinstance(recurser, Resolver): recurser._parseCall.cancel() # On Windows, we need to use a threaded resolver, which leaves trash # lying about that we can't easily clean up without reaching into the # reactor and cancelling them. We only cancel the cleanup functions, as # there should be no others (and it leaving a callLater lying about # should rightly cause the test to fail). if platform.getType() != "posix": # We want the delayed calls on the reactor, which should be all of # ours from the threaded resolver cleanup from twisted.internet import reactor for x in reactor._newTimedCalls: self.assertEqual(x.func.__func__, ThreadedResolver._cleanup) x.cancel() self.assertIsInstance(cl[-1], ResolverChain) PK Mb�ZT=y� names/test/test_common.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.names.common}. """ from zope.interface.verify import verifyClass from twisted.internet.interfaces import IResolver from twisted.names.common import ResolverBase from twisted.names.dns import EFORMAT, ENAME, ENOTIMP, EREFUSED, ESERVER, Query from twisted.names.error import ( DNSFormatError, DNSNameError, DNSNotImplementedError, DNSQueryRefusedError, DNSServerError, DNSUnknownError, ) from twisted.python.failure import Failure from twisted.trial.unittest import SynchronousTestCase class ExceptionForCodeTests(SynchronousTestCase): """ Tests for L{ResolverBase.exceptionForCode}. """ def setUp(self): self.exceptionForCode = ResolverBase().exceptionForCode def test_eformat(self): """ L{ResolverBase.exceptionForCode} converts L{EFORMAT} to L{DNSFormatError}. """ self.assertIs(self.exceptionForCode(EFORMAT), DNSFormatError) def test_eserver(self): """ L{ResolverBase.exceptionForCode} converts L{ESERVER} to L{DNSServerError}. """ self.assertIs(self.exceptionForCode(ESERVER), DNSServerError) def test_ename(self): """ L{ResolverBase.exceptionForCode} converts L{ENAME} to L{DNSNameError}. """ self.assertIs(self.exceptionForCode(ENAME), DNSNameError) def test_enotimp(self): """ L{ResolverBase.exceptionForCode} converts L{ENOTIMP} to L{DNSNotImplementedError}. """ self.assertIs(self.exceptionForCode(ENOTIMP), DNSNotImplementedError) def test_erefused(self): """ L{ResolverBase.exceptionForCode} converts L{EREFUSED} to L{DNSQueryRefusedError}. """ self.assertIs(self.exceptionForCode(EREFUSED), DNSQueryRefusedError) def test_other(self): """ L{ResolverBase.exceptionForCode} converts any other response code to L{DNSUnknownError}. """ self.assertIs(self.exceptionForCode(object()), DNSUnknownError) class QueryTests(SynchronousTestCase): """ Tests for L{ResolverBase.query}. """ def test_resolverBaseProvidesIResolver(self): """ L{ResolverBase} provides the L{IResolver} interface. """ verifyClass(IResolver, ResolverBase) def test_typeToMethodDispatch(self): """ L{ResolverBase.query} looks up a method to invoke using the type of the query passed to it and the C{typeToMethod} mapping on itself. """ results = [] resolver = ResolverBase() resolver.typeToMethod = { 12345: lambda query, timeout: results.append((query, timeout)) } query = Query(name=b"example.com", type=12345) resolver.query(query, 123) self.assertEqual([(b"example.com", 123)], results) def test_typeToMethodResult(self): """ L{ResolverBase.query} returns a L{Deferred} which fires with the result of the method found in the C{typeToMethod} mapping for the type of the query passed to it. """ expected = object() resolver = ResolverBase() resolver.typeToMethod = {54321: lambda query, timeout: expected} query = Query(name=b"example.com", type=54321) queryDeferred = resolver.query(query, 123) result = [] queryDeferred.addBoth(result.append) self.assertEqual(expected, result[0]) def test_unknownQueryType(self): """ L{ResolverBase.query} returns a L{Deferred} which fails with L{NotImplementedError} when called with a query of a type not present in its C{typeToMethod} dictionary. """ resolver = ResolverBase() resolver.typeToMethod = {} query = Query(name=b"example.com", type=12345) queryDeferred = resolver.query(query, 123) result = [] queryDeferred.addBoth(result.append) self.assertIsInstance(result[0], Failure) result[0].trap(NotImplementedError) PK Mb�ZD!F�� � names/test/test_examples.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.names} example scripts. """ import os import sys from io import StringIO from twisted.python.filepath import FilePath from twisted.trial.unittest import SkipTest, TestCase class ExampleTestBase: """ This is a mixin which adds an example to the path, tests it, and then removes it from the path and unimports the modules which the test loaded. Test cases which test example code and documentation listings should use this. This is done this way so that examples can live in isolated path entries, next to the documentation, replete with their own plugin packages and whatever other metadata they need. Also, example code is a rare instance of it being valid to have multiple versions of the same code in the repository at once, rather than relying on version control, because documentation will often show the progression of a single piece of code as features are added to it, and we want to test each one. """ def setUp(self): """ Add our example directory to the path and record which modules are currently loaded. """ self.originalPath = sys.path[:] self.originalModules = sys.modules.copy() # Python usually expects native strs to be written to sys.stdout/stderr self.fakeErr = StringIO() self.patch(sys, "stderr", self.fakeErr) self.fakeOut = StringIO() self.patch(sys, "stdout", self.fakeOut) # Get documentation root try: here = FilePath(os.environ["TOX_INI_DIR"]).child("docs") except KeyError: raise SkipTest( "Examples not found ($TOX_INI_DIR unset) - cannot test", ) # Find the example script within this branch for childName in self.exampleRelativePath.split("/"): here = here.child(childName) if not here.exists(): raise SkipTest(f"Examples ({here.path}) not found - cannot test") self.examplePath = here # Add the example parent folder to the Python path sys.path.append(self.examplePath.parent().path) # Import the example as a module moduleName = self.examplePath.basename().split(".")[0] self.example = __import__(moduleName) def tearDown(self): """ Remove the example directory from the path and remove all modules loaded by the test from sys.modules. """ sys.modules.clear() sys.modules.update(self.originalModules) sys.path[:] = self.originalPath def test_shebang(self): """ The example scripts start with the standard shebang line. """ with self.examplePath.open() as f: self.assertEqual(f.readline().rstrip(), b"#!/usr/bin/env python") def test_usageConsistency(self): """ The example script prints a usage message to stdout if it is passed a --help option and then exits. The first line should contain a USAGE summary, explaining the accepted command arguments. """ # Pass None as first parameter - the reactor - it shouldn't # get as far as calling it. self.assertRaises(SystemExit, self.example.main, None, "--help") out = self.fakeOut.getvalue().splitlines() self.assertTrue( out[0].startswith("Usage:"), 'Usage message first line should start with "Usage:". ' "Actual: %r" % (out[0],), ) def test_usageConsistencyOnError(self): """ The example script prints a usage message to stderr if it is passed unrecognized command line arguments. The first line should contain a USAGE summary, explaining the accepted command arguments. The last line should contain an ERROR summary, explaining that incorrect arguments were supplied. """ # Pass None as first parameter - the reactor - it shouldn't # get as far as calling it. self.assertRaises(SystemExit, self.example.main, None, "--unexpected_argument") err = self.fakeErr.getvalue().splitlines() self.assertTrue( err[0].startswith("Usage:"), 'Usage message first line should start with "Usage:". ' "Actual: %r" % (err[0],), ) self.assertTrue( err[-1].startswith("ERROR:"), 'Usage message last line should start with "ERROR:" ' "Actual: %r" % (err[-1],), ) class TestDnsTests(ExampleTestBase, TestCase): """ Test the testdns.py example script. """ exampleRelativePath = "names/examples/testdns.py" class GetHostByNameTests(ExampleTestBase, TestCase): """ Test the gethostbyname.py example script. """ exampleRelativePath = "names/examples/gethostbyname.py" class DnsServiceTests(ExampleTestBase, TestCase): """ Test the dns-service.py example script. """ exampleRelativePath = "names/examples/dns-service.py" class MultiReverseLookupTests(ExampleTestBase, TestCase): """ Test the multi_reverse_lookup.py example script. """ exampleRelativePath = "names/examples/multi_reverse_lookup.py" PK Mb�Z�U#u�$ �$ names/test/test_srvconnect.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.names.srvconnect}. """ import random from zope.interface.verify import verifyObject from twisted.internet import defer, protocol from twisted.internet.error import DNSLookupError, ServiceNameUnknownError from twisted.internet.interfaces import IConnector from twisted.names import client, dns, srvconnect from twisted.names.common import ResolverBase from twisted.names.error import DNSNameError from twisted.test.proto_helpers import MemoryReactor from twisted.trial import unittest class FakeResolver(ResolverBase): """ Resolver that only gives out one given result. Either L{results} or L{failure} must be set and will be used for the return value of L{_lookup} @ivar results: List of L{dns.RRHeader} for the desired result. @type results: C{list} @ivar failure: Failure with an exception from L{twisted.names.error}. @type failure: L{Failure<twisted.python.failure.Failure>} """ def __init__(self, results=None, failure=None): self.results = results self.failure = failure self.lookups = [] def _lookup(self, name, cls, qtype, timeout): """ Return the result or failure on lookup. """ self.lookups.append((name, cls, qtype, timeout)) if self.results is not None: return defer.succeed((self.results, [], [])) else: return defer.fail(self.failure) class DummyFactory(protocol.ClientFactory): """ Dummy client factory that stores the reason of connection failure. """ def __init__(self): self.reason = None def clientConnectionFailed(self, connector, reason): self.reason = reason class SRVConnectorTests(unittest.TestCase): """ Tests for L{srvconnect.SRVConnector}. """ def setUp(self): self.patch(client, "theResolver", FakeResolver()) self.reactor = MemoryReactor() self.factory = DummyFactory() self.connector = srvconnect.SRVConnector( self.reactor, "xmpp-server", "example.org", self.factory ) self.randIntArgs = [] self.randIntResults = [] def _randint(self, min, max): """ Fake randint. Returns the first element of L{randIntResults} and records the arguments passed to it in L{randIntArgs}. @param min: Lower bound of the random number. @type min: L{int} @param max: Higher bound of the random number. @type max: L{int} @return: Fake random number from L{randIntResults}. @rtype: L{int} """ self.randIntArgs.append((min, max)) return self.randIntResults.pop(0) def test_interface(self): """ L{srvconnect.SRVConnector} implements L{IConnector}. """ verifyObject(IConnector, self.connector) def test_SRVPresent(self): """ Test connectTCP gets called with the address from the SRV record. """ payload = dns.Record_SRV(port=6269, target="host.example.org", ttl=60) client.theResolver.results = [ dns.RRHeader( name="example.org", type=dns.SRV, cls=dns.IN, ttl=60, payload=payload ) ] self.connector.connect() self.assertIsNone(self.factory.reason) self.assertEqual(self.reactor.tcpClients.pop()[:2], ("host.example.org", 6269)) def test_SRVNotPresent(self): """ Test connectTCP gets called with fallback parameters on NXDOMAIN. """ client.theResolver.failure = DNSNameError(b"example.org") self.connector.connect() self.assertIsNone(self.factory.reason) self.assertEqual( self.reactor.tcpClients.pop()[:2], ("example.org", "xmpp-server") ) def test_SRVNoResult(self): """ Test connectTCP gets called with fallback parameters on empty result. """ client.theResolver.results = [] self.connector.connect() self.assertIsNone(self.factory.reason) self.assertEqual( self.reactor.tcpClients.pop()[:2], ("example.org", "xmpp-server") ) def test_SRVNoResultUnknownServiceDefaultPort(self): """ connectTCP gets called with default port if the service is not defined. """ self.connector = srvconnect.SRVConnector( self.reactor, "thisbetternotexist", "example.org", self.factory, defaultPort=5222, ) client.theResolver.failure = ServiceNameUnknownError() self.connector.connect() self.assertIsNone(self.factory.reason) self.assertEqual(self.reactor.tcpClients.pop()[:2], ("example.org", 5222)) def test_SRVNoResultUnknownServiceNoDefaultPort(self): """ Connect fails on no result, unknown service and no default port. """ self.connector = srvconnect.SRVConnector( self.reactor, "thisbetternotexist", "example.org", self.factory ) client.theResolver.failure = ServiceNameUnknownError() self.connector.connect() self.assertTrue(self.factory.reason.check(ServiceNameUnknownError)) def test_SRVBadResult(self): """ Test connectTCP gets called with fallback parameters on bad result. """ client.theResolver.results = [ dns.RRHeader( name="example.org", type=dns.CNAME, cls=dns.IN, ttl=60, payload=None ) ] self.connector.connect() self.assertIsNone(self.factory.reason) self.assertEqual( self.reactor.tcpClients.pop()[:2], ("example.org", "xmpp-server") ) def test_SRVNoService(self): """ Test that connecting fails when no service is present. """ payload = dns.Record_SRV(port=5269, target=b".", ttl=60) client.theResolver.results = [ dns.RRHeader( name="example.org", type=dns.SRV, cls=dns.IN, ttl=60, payload=payload ) ] self.connector.connect() self.assertIsNotNone(self.factory.reason) self.factory.reason.trap(DNSLookupError) self.assertEqual(self.reactor.tcpClients, []) def test_SRVLookupName(self): """ The lookup name is a native string from service, protocol and domain. """ client.theResolver.results = [] self.connector.connect() name = client.theResolver.lookups[-1][0] self.assertEqual(b"_xmpp-server._tcp.example.org", name) def test_unicodeDomain(self): """ L{srvconnect.SRVConnector} automatically encodes unicode domain using C{idna} encoding. """ self.connector = srvconnect.SRVConnector( self.reactor, "xmpp-client", "\u00e9chec.example.org", self.factory ) self.assertEqual(b"xn--chec-9oa.example.org", self.connector.domain) def test_pickServerWeights(self): """ pickServer calculates running sum of weights and calls randint. This exercises the server selection algorithm specified in RFC 2782 by preparing fake L{random.randint} results and checking the values it was called with. """ record1 = dns.Record_SRV(10, 10, 5222, "host1.example.org") record2 = dns.Record_SRV(10, 20, 5222, "host2.example.org") self.connector.orderedServers = [record1, record2] self.connector.servers = [] self.patch(random, "randint", self._randint) # 1st round self.randIntResults = [11, 0] self.connector.pickServer() self.assertEqual(self.randIntArgs[0], (0, 30)) self.connector.pickServer() self.assertEqual(self.randIntArgs[1], (0, 10)) # 2nd round self.randIntResults = [10, 0] self.connector.pickServer() self.assertEqual(self.randIntArgs[2], (0, 30)) self.connector.pickServer() self.assertEqual(self.randIntArgs[3], (0, 20)) def test_pickServerSamePriorities(self): """ Two records with equal priorities compare on weight (ascending). """ record1 = dns.Record_SRV(10, 10, 5222, "host1.example.org") record2 = dns.Record_SRV(10, 20, 5222, "host2.example.org") self.connector.orderedServers = [record2, record1] self.connector.servers = [] self.patch(random, "randint", self._randint) self.randIntResults = [0, 0] self.assertEqual(("host1.example.org", 5222), self.connector.pickServer()) self.assertEqual(("host2.example.org", 5222), self.connector.pickServer()) def test_srvDifferentPriorities(self): """ Two records with differing priorities compare on priority (ascending). """ record1 = dns.Record_SRV(10, 0, 5222, "host1.example.org") record2 = dns.Record_SRV(20, 0, 5222, "host2.example.org") self.connector.orderedServers = [record2, record1] self.connector.servers = [] self.patch(random, "randint", self._randint) self.randIntResults = [0, 0] self.assertEqual(("host1.example.org", 5222), self.connector.pickServer()) self.assertEqual(("host2.example.org", 5222), self.connector.pickServer()) PK Mb�Z��C� names/test/__init__.pynu �[��� "Tests for twisted.names" PK Mb�Z��Ք � � names/test/test_client.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{twisted.names.client}. """ import errno from zope.interface.verify import verifyClass, verifyObject from twisted.internet import defer from twisted.internet.error import CannotListenError, ConnectionRefusedError from twisted.internet.interfaces import IResolver from twisted.internet.task import Clock from twisted.internet.test.modulehelpers import AlternateReactor from twisted.names import cache, client, dns, error, hosts from twisted.names.common import ResolverBase from twisted.names.error import DNSQueryTimeoutError from twisted.names.test import test_util from twisted.names.test.test_hosts import GoodTempPathMixin from twisted.python import failure from twisted.python.filepath import FilePath from twisted.python.runtime import platform from twisted.test import proto_helpers from twisted.trial import unittest if not platform.isWindows(): windowsSkip = None else: windowsSkip = "These tests need more work before they'll work on Windows." class FakeResolver(ResolverBase): def _lookup(self, name, cls, qtype, timeout): """ The getHostByNameTest does a different type of query that requires it return an A record from an ALL_RECORDS lookup, so we accommodate that here. """ if name == b"getHostByNameTest": rr = dns.RRHeader( name=name, type=dns.A, cls=cls, ttl=60, payload=dns.Record_A(address="127.0.0.1", ttl=60), ) else: rr = dns.RRHeader(name=name, type=qtype, cls=cls, ttl=60) results = [rr] authority = [] additional = [] return defer.succeed((results, authority, additional)) class StubPort: """ A partial implementation of L{IListeningPort} which only keeps track of whether it has been stopped. @ivar disconnected: A C{bool} which is C{False} until C{stopListening} is called, C{True} afterwards. """ disconnected = False def stopListening(self): self.disconnected = True class StubDNSDatagramProtocol: """ L{dns.DNSDatagramProtocol}-alike. @ivar queries: A C{list} of tuples giving the arguments passed to C{query} along with the L{defer.Deferred} which was returned from the call. """ def __init__(self): self.queries = [] self.transport = StubPort() def query(self, address, queries, timeout=10, id=None): """ Record the given arguments and return a Deferred which will not be called back by this code. """ result = defer.Deferred() self.queries.append((address, queries, timeout, id, result)) return result class GetResolverTests(unittest.TestCase): """ Tests for L{client.getResolver}. """ skip = windowsSkip def test_interface(self): """ L{client.getResolver} returns an object providing L{IResolver}. """ with AlternateReactor(Clock()): resolver = client.getResolver() self.assertTrue(verifyObject(IResolver, resolver)) def test_idempotent(self): """ Multiple calls to L{client.getResolver} return the same L{IResolver} implementation. """ with AlternateReactor(Clock()): a = client.getResolver() b = client.getResolver() self.assertIs(a, b) class CreateResolverTests(unittest.TestCase, GoodTempPathMixin): """ Tests for L{client.createResolver}. """ skip = windowsSkip def _hostsTest(self, resolver, filename): res = [r for r in resolver.resolvers if isinstance(r, hosts.Resolver)] self.assertEqual(1, len(res)) self.assertEqual(res[0].file, filename) def test_defaultHosts(self): """ L{client.createResolver} returns a L{resolve.ResolverChain} including a L{hosts.Resolver} using I{/etc/hosts} if no alternate hosts file is specified. """ with AlternateReactor(Clock()): resolver = client.createResolver() self._hostsTest(resolver, b"/etc/hosts") def test_overrideHosts(self): """ The I{hosts} parameter to L{client.createResolver} overrides the hosts file used by the L{hosts.Resolver} in the L{resolve.ResolverChain} it returns. """ with AlternateReactor(Clock()): resolver = client.createResolver(hosts=b"/foo/bar") self._hostsTest(resolver, b"/foo/bar") def _resolvConfTest(self, resolver, filename): """ Verify that C{resolver} has a L{client.Resolver} with a configuration filename set to C{filename}. """ res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertEqual(res[0].resolv, filename) def test_reactor(self): """ The L{client.Resolver} included in the L{resolve.ResolverChain} returned by L{client.createResolver} uses the global reactor. """ reactor = Clock() with AlternateReactor(reactor): resolver = client.createResolver() res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertIs(reactor, res[0]._reactor) def test_defaultResolvConf(self): """ L{client.createResolver} returns a L{resolve.ResolverChain} including a L{client.Resolver} using I{/etc/resolv.conf} if no alternate resolver configuration file is specified. """ with AlternateReactor(Clock()): resolver = client.createResolver() self._resolvConfTest(resolver, b"/etc/resolv.conf") def test_overrideResolvConf(self): """ The I{resolvconf} parameter to L{client.createResolver} overrides the resolver configuration file used by the L{client.Resolver} in the L{resolve.ResolverChain} it returns. """ with AlternateReactor(Clock()): resolver = client.createResolver(resolvconf=b"/foo/bar") self._resolvConfTest(resolver, b"/foo/bar") def test_defaultServers(self): """ If no servers are given, addresses are taken from the file given by the I{resolvconf} parameter to L{client.createResolver}. """ resolvconf = self.path() resolvconf.setContent(b"nameserver 127.1.2.3\n") with AlternateReactor(Clock()): resolver = client.createResolver(resolvconf=resolvconf.path) res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertEqual([], res[0].servers) self.assertEqual([("127.1.2.3", 53)], res[0].dynServers) def test_overrideServers(self): """ Servers passed to L{client.createResolver} are used in addition to any found in the file given by the I{resolvconf} parameter. """ resolvconf = self.path() resolvconf.setContent(b"nameserver 127.1.2.3\n") with AlternateReactor(Clock()): resolver = client.createResolver( servers=[("127.3.2.1", 53)], resolvconf=resolvconf.path ) res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertEqual([("127.3.2.1", 53)], res[0].servers) self.assertEqual([("127.1.2.3", 53)], res[0].dynServers) def test_cache(self): """ L{client.createResolver} returns a L{resolve.ResolverChain} including a L{cache.CacheResolver}. """ with AlternateReactor(Clock()): resolver = client.createResolver() res = [r for r in resolver.resolvers if isinstance(r, cache.CacheResolver)] self.assertEqual(1, len(res)) class ResolverTests(unittest.TestCase): """ Tests for L{client.Resolver}. """ def test_clientProvidesIResolver(self): """ L{client} provides L{IResolver} through a series of free functions. """ verifyObject(IResolver, client) def test_clientResolverProvidesIResolver(self): """ L{client.Resolver} provides L{IResolver}. """ verifyClass(IResolver, client.Resolver) def test_noServers(self): """ L{client.Resolver} raises L{ValueError} if constructed with neither servers nor a nameserver configuration file. """ self.assertRaises(ValueError, client.Resolver) def test_missingConfiguration(self): """ A missing nameserver configuration file results in no server information being loaded from it (ie, not an exception) and a default server being provided. """ resolver = client.Resolver(resolv=self.mktemp(), reactor=Clock()) self.assertEqual([("127.0.0.1", 53)], resolver.dynServers) def test_closesResolvConf(self): """ As part of its constructor, C{StubResolver} opens C{/etc/resolv.conf}; then, explicitly closes it and does not count on the GC to do so for it. """ handle = FilePath(self.mktemp()) resolvConf = handle.open(mode="w+") class StubResolver(client.Resolver): def _openFile(self, name): return resolvConf StubResolver( servers=["example.com", 53], resolv="/etc/resolv.conf", reactor=Clock() ) self.assertTrue(resolvConf.closed) def test_domainEmptyArgument(self): """ L{client.Resolver.parseConfig} treats a I{domain} line without an argument as indicating a domain of C{b""}. """ resolver = client.Resolver(servers=[("127.0.0.1", 53)]) resolver.parseConfig([b"domain\n"]) self.assertEqual(b"", resolver.domain) def test_searchEmptyArgument(self): """ L{client.Resolver.parseConfig} treats a I{search} line without an argument as indicating an empty search suffix. """ resolver = client.Resolver(servers=[("127.0.0.1", 53)]) resolver.parseConfig([b"search\n"]) self.assertEqual([], resolver.search) def test_datagramQueryServerOrder(self): """ L{client.Resolver.queryUDP} should issue queries to its L{dns.DNSDatagramProtocol} with server addresses taken from its own C{servers} and C{dynServers} lists, proceeding through them in order as L{DNSQueryTimeoutError}s occur. """ protocol = StubDNSDatagramProtocol() servers = [("::1", 53), ("::2", 53)] dynServers = [("::3", 53), ("::4", 53)] resolver = client.Resolver(servers=servers) resolver.dynServers = dynServers resolver._connectedProtocol = lambda interface: protocol expectedResult = object() queryResult = resolver.queryUDP(None) queryResult.addCallback(self.assertEqual, expectedResult) self.assertEqual(len(protocol.queries), 1) self.assertIs(protocol.queries[0][0], servers[0]) protocol.queries[0][-1].errback(DNSQueryTimeoutError(0)) self.assertEqual(len(protocol.queries), 2) self.assertIs(protocol.queries[1][0], servers[1]) protocol.queries[1][-1].errback(DNSQueryTimeoutError(1)) self.assertEqual(len(protocol.queries), 3) self.assertIs(protocol.queries[2][0], dynServers[0]) protocol.queries[2][-1].errback(DNSQueryTimeoutError(2)) self.assertEqual(len(protocol.queries), 4) self.assertIs(protocol.queries[3][0], dynServers[1]) protocol.queries[3][-1].callback(expectedResult) return queryResult def test_singleConcurrentRequest(self): """ L{client.Resolver.query} only issues one request at a time per query. Subsequent requests made before responses to prior ones are received are queued and given the same response as is given to the first one. """ protocol = StubDNSDatagramProtocol() resolver = client.Resolver(servers=[("example.com", 53)]) resolver._connectedProtocol = lambda: protocol queries = protocol.queries query = dns.Query(b"foo.example.com", dns.A, dns.IN) # The first query should be passed to the underlying protocol. firstResult = resolver.query(query) self.assertEqual(len(queries), 1) # The same query again should not be passed to the underlying protocol. secondResult = resolver.query(query) self.assertEqual(len(queries), 1) # The response to the first query should be sent in response to both # queries. answer = object() response = dns.Message() response.answers.append(answer) queries.pop()[-1].callback(response) d = defer.gatherResults([firstResult, secondResult]) def cbFinished(responses): firstResponse, secondResponse = responses self.assertEqual(firstResponse, ([answer], [], [])) self.assertEqual(secondResponse, ([answer], [], [])) d.addCallback(cbFinished) return d def test_multipleConcurrentRequests(self): """ L{client.Resolver.query} issues a request for each different concurrent query. """ protocol = StubDNSDatagramProtocol() resolver = client.Resolver(servers=[("example.com", 53)]) resolver._connectedProtocol = lambda: protocol queries = protocol.queries # The first query should be passed to the underlying protocol. firstQuery = dns.Query(b"foo.example.com", dns.A) resolver.query(firstQuery) self.assertEqual(len(queries), 1) # A query for a different name is also passed to the underlying # protocol. secondQuery = dns.Query(b"bar.example.com", dns.A) resolver.query(secondQuery) self.assertEqual(len(queries), 2) # A query for a different type is also passed to the underlying # protocol. thirdQuery = dns.Query(b"foo.example.com", dns.A6) resolver.query(thirdQuery) self.assertEqual(len(queries), 3) def test_multipleSequentialRequests(self): """ After a response is received to a query issued with L{client.Resolver.query}, another query with the same parameters results in a new network request. """ protocol = StubDNSDatagramProtocol() resolver = client.Resolver(servers=[("example.com", 53)]) resolver._connectedProtocol = lambda: protocol queries = protocol.queries query = dns.Query(b"foo.example.com", dns.A) # The first query should be passed to the underlying protocol. resolver.query(query) self.assertEqual(len(queries), 1) # Deliver the response. queries.pop()[-1].callback(dns.Message()) # Repeating the first query should touch the protocol again. resolver.query(query) self.assertEqual(len(queries), 1) def test_multipleConcurrentFailure(self): """ If the result of a request is an error response, the Deferreds for all concurrently issued requests associated with that result fire with the L{Failure}. """ protocol = StubDNSDatagramProtocol() resolver = client.Resolver(servers=[("example.com", 53)]) resolver._connectedProtocol = lambda: protocol queries = protocol.queries query = dns.Query(b"foo.example.com", dns.A) firstResult = resolver.query(query) secondResult = resolver.query(query) class ExpectedException(Exception): pass queries.pop()[-1].errback(failure.Failure(ExpectedException())) return defer.gatherResults( [ self.assertFailure(firstResult, ExpectedException), self.assertFailure(secondResult, ExpectedException), ] ) def test_connectedProtocol(self): """ L{client.Resolver._connectedProtocol} returns a new L{DNSDatagramProtocol} connected to a new address with a cryptographically secure random port number. """ resolver = client.Resolver(servers=[("example.com", 53)]) firstProto = resolver._connectedProtocol() secondProto = resolver._connectedProtocol() self.assertIsNotNone(firstProto.transport) self.assertIsNotNone(secondProto.transport) self.assertNotEqual( firstProto.transport.getHost().port, secondProto.transport.getHost().port ) return defer.gatherResults( [ defer.maybeDeferred(firstProto.transport.stopListening), defer.maybeDeferred(secondProto.transport.stopListening), ] ) def test_resolverUsesOnlyParameterizedReactor(self): """ If a reactor instance is supplied to L{client.Resolver} L{client.Resolver._connectedProtocol} should pass that reactor to L{twisted.names.dns.DNSDatagramProtocol}. """ reactor = test_util.MemoryReactor() resolver = client.Resolver(resolv=self.mktemp(), reactor=reactor) proto = resolver._connectedProtocol() self.assertIs(proto._reactor, reactor) def test_differentProtocol(self): """ L{client.Resolver._connectedProtocol} is called once each time a UDP request needs to be issued and the resulting protocol instance is used for that request. """ resolver = client.Resolver(servers=[("example.com", 53)]) protocols = [] class FakeProtocol: def __init__(self): self.transport = StubPort() def query(self, address, query, timeout=10, id=None): protocols.append(self) return defer.succeed(dns.Message()) resolver._connectedProtocol = FakeProtocol resolver.query(dns.Query(b"foo.example.com")) resolver.query(dns.Query(b"bar.example.com")) self.assertEqual(len(set(protocols)), 2) def test_ipv6Resolver(self): """ If the resolver is ipv6, open a ipv6 port. """ fake = test_util.MemoryReactor() resolver = client.Resolver(servers=[("::1", 53)], reactor=fake) resolver.query(dns.Query(b"foo.example.com")) [(proto, transport)] = fake.udpPorts.items() interface = transport.getHost().host self.assertEqual("::", interface) def test_disallowedPort(self): """ If a port number is initially selected which cannot be bound, the L{CannotListenError} is handled and another port number is attempted. """ ports = [] class FakeReactor: def listenUDP(self, port, *args, **kwargs): ports.append(port) if len(ports) == 1: raise CannotListenError(None, port, None) resolver = client.Resolver(servers=[("example.com", 53)]) resolver._reactor = FakeReactor() resolver._connectedProtocol() self.assertEqual(len(set(ports)), 2) def test_disallowedPortRepeatedly(self): """ If port numbers that cannot be bound are repeatedly selected, L{resolver._connectedProtocol} will give up eventually. """ ports = [] class FakeReactor: def listenUDP(self, port, *args, **kwargs): ports.append(port) raise CannotListenError(None, port, None) resolver = client.Resolver(servers=[("example.com", 53)]) resolver._reactor = FakeReactor() self.assertRaises(CannotListenError, resolver._connectedProtocol) # 1000 is a good round number. I like it. self.assertEqual(len(ports), 1000) def test_runOutOfFiles(self): """ If the process is out of files, L{Resolver._connectedProtocol} will give up. """ ports = [] class FakeReactor: def listenUDP(self, port, *args, **kwargs): ports.append(port) err = OSError(errno.EMFILE, "Out of files :(") raise CannotListenError(None, port, err) resolver = client.Resolver(servers=[("example.com", 53)]) resolver._reactor = FakeReactor() exc = self.assertRaises(CannotListenError, resolver._connectedProtocol) # The EMFILE-containing exception was raised, and it did not try # multiple times. self.assertEqual(exc.socketError.errno, errno.EMFILE) self.assertEqual(len(ports), 1) def test_differentProtocolAfterTimeout(self): """ When a query issued by L{client.Resolver.query} times out, the retry uses a new protocol instance. """ resolver = client.Resolver(servers=[("example.com", 53)]) protocols = [] results = [ defer.fail(failure.Failure(DNSQueryTimeoutError(None))), defer.succeed(dns.Message()), ] class FakeProtocol: def __init__(self): self.transport = StubPort() def query(self, address, query, timeout=10, id=None): protocols.append(self) return results.pop(0) resolver._connectedProtocol = FakeProtocol resolver.query(dns.Query(b"foo.example.com")) self.assertEqual(len(set(protocols)), 2) def test_protocolShutDown(self): """ After the L{Deferred} returned by L{DNSDatagramProtocol.query} is called back, the L{DNSDatagramProtocol} is disconnected from its transport. """ resolver = client.Resolver(servers=[("example.com", 53)]) protocols = [] result = defer.Deferred() class FakeProtocol: def __init__(self): self.transport = StubPort() def query(self, address, query, timeout=10, id=None): protocols.append(self) return result resolver._connectedProtocol = FakeProtocol resolver.query(dns.Query(b"foo.example.com")) self.assertFalse(protocols[0].transport.disconnected) result.callback(dns.Message()) self.assertTrue(protocols[0].transport.disconnected) def test_protocolShutDownAfterTimeout(self): """ The L{DNSDatagramProtocol} created when an interim timeout occurs is also disconnected from its transport after the Deferred returned by its query method completes. """ resolver = client.Resolver(servers=[("example.com", 53)]) protocols = [] result = defer.Deferred() results = [defer.fail(failure.Failure(DNSQueryTimeoutError(None))), result] class FakeProtocol: def __init__(self): self.transport = StubPort() def query(self, address, query, timeout=10, id=None): protocols.append(self) return results.pop(0) resolver._connectedProtocol = FakeProtocol resolver.query(dns.Query(b"foo.example.com")) self.assertFalse(protocols[1].transport.disconnected) result.callback(dns.Message()) self.assertTrue(protocols[1].transport.disconnected) def test_protocolShutDownAfterFailure(self): """ If the L{Deferred} returned by L{DNSDatagramProtocol.query} fires with a failure, the L{DNSDatagramProtocol} is still disconnected from its transport. """ class ExpectedException(Exception): pass resolver = client.Resolver(servers=[("example.com", 53)]) protocols = [] result = defer.Deferred() class FakeProtocol: def __init__(self): self.transport = StubPort() def query(self, address, query, timeout=10, id=None): protocols.append(self) return result resolver._connectedProtocol = FakeProtocol queryResult = resolver.query(dns.Query(b"foo.example.com")) self.assertFalse(protocols[0].transport.disconnected) result.errback(failure.Failure(ExpectedException())) self.assertTrue(protocols[0].transport.disconnected) return self.assertFailure(queryResult, ExpectedException) def test_tcpDisconnectRemovesFromConnections(self): """ When a TCP DNS protocol associated with a Resolver disconnects, it is removed from the Resolver's connection list. """ resolver = client.Resolver(servers=[("example.com", 53)]) protocol = resolver.factory.buildProtocol(None) protocol.makeConnection(None) self.assertIn(protocol, resolver.connections) # Disconnecting should remove the protocol from the connection list: protocol.connectionLost(None) self.assertNotIn(protocol, resolver.connections) def test_singleTCPQueryErrbackOnConnectionFailure(self): """ The deferred returned by L{client.Resolver.queryTCP} will errback when the TCP connection attempt fails. The reason for the connection failure is passed as the argument to errback. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor) d = resolver.queryTCP(dns.Query("example.com")) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] class SentinelException(Exception): pass factory.clientConnectionFailed( reactor.connectors[0], failure.Failure(SentinelException()) ) self.failureResultOf(d, SentinelException) def test_multipleTCPQueryErrbackOnConnectionFailure(self): """ All pending L{resolver.queryTCP} C{deferred}s will C{errback} with the same C{Failure} if the connection attempt fails. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor) d1 = resolver.queryTCP(dns.Query("example.com")) d2 = resolver.queryTCP(dns.Query("example.net")) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] class SentinelException(Exception): pass factory.clientConnectionFailed( reactor.connectors[0], failure.Failure(SentinelException()) ) f1 = self.failureResultOf(d1, SentinelException) f2 = self.failureResultOf(d2, SentinelException) self.assertIs(f1, f2) def test_reentrantTCPQueryErrbackOnConnectionFailure(self): """ An errback on the deferred returned by L{client.Resolver.queryTCP} may trigger another TCP query. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("127.0.0.1", 10053)], reactor=reactor) q = dns.Query("example.com") # First query sent d = resolver.queryTCP(q) # Repeat the query when the first query fails def reissue(e): e.trap(ConnectionRefusedError) return resolver.queryTCP(q) d.addErrback(reissue) self.assertEqual(len(reactor.tcpClients), 1) self.assertEqual(len(reactor.connectors), 1) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] # First query fails f1 = failure.Failure(ConnectionRefusedError()) factory.clientConnectionFailed(reactor.connectors[0], f1) # A second TCP connection is immediately attempted self.assertEqual(len(reactor.tcpClients), 2) self.assertEqual(len(reactor.connectors), 2) # No result expected until the second chained query returns self.assertNoResult(d) # Second query fails f2 = failure.Failure(ConnectionRefusedError()) factory.clientConnectionFailed(reactor.connectors[1], f2) # Original deferred now fires with the second failure f = self.failureResultOf(d, ConnectionRefusedError) self.assertIs(f, f2) def test_pendingEmptiedInPlaceOnError(self): """ When the TCP connection attempt fails, the L{client.Resolver.pending} list is emptied in place. It is not replaced with a new empty list. """ reactor = proto_helpers.MemoryReactor() resolver = client.Resolver(servers=[("192.0.2.100", 53)], reactor=reactor) d = resolver.queryTCP(dns.Query("example.com")) host, port, factory, timeout, bindAddress = reactor.tcpClients[0] prePending = resolver.pending self.assertEqual(len(prePending), 1) class SentinelException(Exception): pass factory.clientConnectionFailed( reactor.connectors[0], failure.Failure(SentinelException()) ) self.failureResultOf(d, SentinelException) self.assertIs(resolver.pending, prePending) self.assertEqual(len(prePending), 0) class ClientTests(unittest.TestCase): def setUp(self): """ Replace the resolver with a FakeResolver """ client.theResolver = FakeResolver() self.hostname = b"example.com" self.hostnameForGetHostByName = b"getHostByNameTest" def tearDown(self): """ By setting the resolver to None, it will be recreated next time a name lookup is done. """ client.theResolver = None def checkResult(self, results, qtype): """ Verify that the result is the same query type as what is expected. """ answers, authority, additional = results result = answers[0] self.assertEqual(result.name.name, self.hostname) self.assertEqual(result.type, qtype) def checkGetHostByName(self, result): """ Test that the getHostByName query returns the 127.0.0.1 address. """ self.assertEqual(result, "127.0.0.1") def test_getHostByName(self): """ do a getHostByName of a value that should return 127.0.0.1. """ d = client.getHostByName(self.hostnameForGetHostByName) d.addCallback(self.checkGetHostByName) return d def test_lookupAddress(self): """ Do a lookup and test that the resolver will issue the correct type of query type. We do this by checking that FakeResolver returns a result record with the same query type as what we issued. """ d = client.lookupAddress(self.hostname) d.addCallback(self.checkResult, dns.A) return d def test_lookupIPV6Address(self): """ See L{test_lookupAddress} """ d = client.lookupIPV6Address(self.hostname) d.addCallback(self.checkResult, dns.AAAA) return d def test_lookupAddress6(self): """ See L{test_lookupAddress} """ d = client.lookupAddress6(self.hostname) d.addCallback(self.checkResult, dns.A6) return d def test_lookupNameservers(self): """ See L{test_lookupAddress} """ d = client.lookupNameservers(self.hostname) d.addCallback(self.checkResult, dns.NS) return d def test_lookupCanonicalName(self): """ See L{test_lookupAddress} """ d = client.lookupCanonicalName(self.hostname) d.addCallback(self.checkResult, dns.CNAME) return d def test_lookupAuthority(self): """ See L{test_lookupAddress} """ d = client.lookupAuthority(self.hostname) d.addCallback(self.checkResult, dns.SOA) return d def test_lookupMailBox(self): """ See L{test_lookupAddress} """ d = client.lookupMailBox(self.hostname) d.addCallback(self.checkResult, dns.MB) return d def test_lookupMailGroup(self): """ See L{test_lookupAddress} """ d = client.lookupMailGroup(self.hostname) d.addCallback(self.checkResult, dns.MG) return d def test_lookupMailRename(self): """ See L{test_lookupAddress} """ d = client.lookupMailRename(self.hostname) d.addCallback(self.checkResult, dns.MR) return d def test_lookupNull(self): """ See L{test_lookupAddress} """ d = client.lookupNull(self.hostname) d.addCallback(self.checkResult, dns.NULL) return d def test_lookupWellKnownServices(self): """ See L{test_lookupAddress} """ d = client.lookupWellKnownServices(self.hostname) d.addCallback(self.checkResult, dns.WKS) return d def test_lookupPointer(self): """ See L{test_lookupAddress} """ d = client.lookupPointer(self.hostname) d.addCallback(self.checkResult, dns.PTR) return d def test_lookupHostInfo(self): """ See L{test_lookupAddress} """ d = client.lookupHostInfo(self.hostname) d.addCallback(self.checkResult, dns.HINFO) return d def test_lookupMailboxInfo(self): """ See L{test_lookupAddress} """ d = client.lookupMailboxInfo(self.hostname) d.addCallback(self.checkResult, dns.MINFO) return d def test_lookupMailExchange(self): """ See L{test_lookupAddress} """ d = client.lookupMailExchange(self.hostname) d.addCallback(self.checkResult, dns.MX) return d def test_lookupText(self): """ See L{test_lookupAddress} """ d = client.lookupText(self.hostname) d.addCallback(self.checkResult, dns.TXT) return d def test_lookupSenderPolicy(self): """ See L{test_lookupAddress} """ d = client.lookupSenderPolicy(self.hostname) d.addCallback(self.checkResult, dns.SPF) return d def test_lookupResponsibility(self): """ See L{test_lookupAddress} """ d = client.lookupResponsibility(self.hostname) d.addCallback(self.checkResult, dns.RP) return d def test_lookupAFSDatabase(self): """ See L{test_lookupAddress} """ d = client.lookupAFSDatabase(self.hostname) d.addCallback(self.checkResult, dns.AFSDB) return d def test_lookupService(self): """ See L{test_lookupAddress} """ d = client.lookupService(self.hostname) d.addCallback(self.checkResult, dns.SRV) return d def test_lookupZone(self): """ See L{test_lookupAddress} """ d = client.lookupZone(self.hostname) d.addCallback(self.checkResult, dns.AXFR) return d def test_lookupAllRecords(self): """ See L{test_lookupAddress} """ d = client.lookupAllRecords(self.hostname) d.addCallback(self.checkResult, dns.ALL_RECORDS) return d def test_lookupNamingAuthorityPointer(self): """ See L{test_lookupAddress} """ d = client.lookupNamingAuthorityPointer(self.hostname) d.addCallback(self.checkResult, dns.NAPTR) return d def test_query(self): """ L{client.query} accepts a L{dns.Query} instance and dispatches it to L{client.theResolver}.C{query}, which in turn dispatches to an appropriate C{lookup*} method of L{client.theResolver}, based on the L{dns.Query} type. """ q = dns.Query(self.hostname, dns.A) d = client.query(q) d.addCallback(self.checkResult, dns.A) return d class FilterAnswersTests(unittest.TestCase): """ Test L{twisted.names.client.Resolver.filterAnswers}'s handling of various error conditions it might encounter. """ def setUp(self): # Create a resolver pointed at an invalid server - we won't be hitting # the network in any of these tests. self.resolver = client.Resolver(servers=[("0.0.0.0", 0)]) def test_truncatedMessage(self): """ Test that a truncated message results in an equivalent request made via TCP. """ m = dns.Message(trunc=True) m.addQuery(b"example.com") def queryTCP(queries): self.assertEqual(queries, m.queries) response = dns.Message() response.answers = ["answer"] response.authority = ["authority"] response.additional = ["additional"] return defer.succeed(response) self.resolver.queryTCP = queryTCP d = self.resolver.filterAnswers(m) d.addCallback(self.assertEqual, (["answer"], ["authority"], ["additional"])) return d def _rcodeTest(self, rcode, exc): m = dns.Message(rCode=rcode) err = self.resolver.filterAnswers(m) err.trap(exc) def test_formatError(self): """ Test that a message with a result code of C{EFORMAT} results in a failure wrapped around L{DNSFormatError}. """ return self._rcodeTest(dns.EFORMAT, error.DNSFormatError) def test_serverError(self): """ Like L{test_formatError} but for C{ESERVER}/L{DNSServerError}. """ return self._rcodeTest(dns.ESERVER, error.DNSServerError) def test_nameError(self): """ Like L{test_formatError} but for C{ENAME}/L{DNSNameError}. """ return self._rcodeTest(dns.ENAME, error.DNSNameError) def test_notImplementedError(self): """ Like L{test_formatError} but for C{ENOTIMP}/L{DNSNotImplementedError}. """ return self._rcodeTest(dns.ENOTIMP, error.DNSNotImplementedError) def test_refusedError(self): """ Like L{test_formatError} but for C{EREFUSED}/L{DNSQueryRefusedError}. """ return self._rcodeTest(dns.EREFUSED, error.DNSQueryRefusedError) def test_refusedErrorUnknown(self): """ Like L{test_formatError} but for an unrecognized error code and L{DNSUnknownError}. """ return self._rcodeTest(dns.EREFUSED + 1, error.DNSUnknownError) class FakeDNSDatagramProtocol: def __init__(self): self.queries = [] self.transport = StubPort() def query(self, address, queries, timeout=10, id=None): self.queries.append((address, queries, timeout, id)) return defer.fail(error.DNSQueryTimeoutError(queries)) def removeResend(self, id): # Ignore this for the time being. pass class RetryLogicTests(unittest.TestCase): """ Tests for query retrying implemented by L{client.Resolver}. """ testServers = ["1.2.3.4", "4.3.2.1", "a.b.c.d", "z.y.x.w"] def test_roundRobinBackoff(self): """ When timeouts occur waiting for responses to queries, the next configured server is issued the query. When the query has been issued to all configured servers, the timeout is increased and the process begins again at the beginning. """ addrs = [(x, 53) for x in self.testServers] r = client.Resolver(resolv=None, servers=addrs) proto = FakeDNSDatagramProtocol() r._connectedProtocol = lambda: proto return ( r.lookupAddress(b"foo.example.com") .addCallback(self._cbRoundRobinBackoff) .addErrback(self._ebRoundRobinBackoff, proto) ) def _cbRoundRobinBackoff(self, result): self.fail("Lookup address succeeded, should have timed out") def _ebRoundRobinBackoff(self, failure, fakeProto): failure.trap(defer.TimeoutError) # Assert that each server is tried with a particular timeout # before the timeout is increased and the attempts are repeated. for t in (1, 3, 11, 45): tries = fakeProto.queries[: len(self.testServers)] del fakeProto.queries[: len(self.testServers)] tries.sort() expected = list(self.testServers) expected.sort() for ((addr, query, timeout, id), expectedAddr) in zip(tries, expected): self.assertEqual(addr, (expectedAddr, 53)) self.assertEqual(timeout, t) self.assertFalse(fakeProto.queries) class ThreadedResolverTests(unittest.TestCase): """ Tests for L{client.ThreadedResolver}. """ def test_deprecated(self): """ L{client.ThreadedResolver} is deprecated. Instantiating it emits a deprecation warning pointing at the code that does the instantiation. """ client.ThreadedResolver() warnings = self.flushWarnings(offendingFunctions=[self.test_deprecated]) self.assertEqual( warnings[0]["message"], "twisted.names.client.ThreadedResolver is deprecated since " "Twisted 9.0, use twisted.internet.base.ThreadedResolver " "instead.", ) self.assertEqual(warnings[0]["category"], DeprecationWarning) self.assertEqual(len(warnings), 1) PK Mb�Z�l��� � names/secondary.pynu �[��� # -*- test-case-name: twisted.names.test.test_names -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. __all__ = ["SecondaryAuthority", "SecondaryAuthorityService"] from twisted.application import service from twisted.internet import defer, task from twisted.names import client, common, dns, resolve from twisted.names.authority import FileAuthority from twisted.python import failure, log from twisted.python.compat import nativeString class SecondaryAuthorityService(service.Service): """ A service that keeps one or more authorities up to date by doing hourly zone transfers from a master. @ivar primary: IP address of the master. @type primary: L{str} @ivar domains: An authority for each domain mirrored from the master. @type domains: L{list} of L{SecondaryAuthority} """ calls = None _port = 53 def __init__(self, primary, domains): """ @param primary: The IP address of the server from which to perform zone transfers. @type primary: L{str} @param domains: A sequence of domain names for which to perform zone transfers. @type domains: L{list} of L{bytes} """ self.primary = nativeString(primary) self.domains = [SecondaryAuthority(primary, d) for d in domains] @classmethod def fromServerAddressAndDomains(cls, serverAddress, domains): """ Construct a new L{SecondaryAuthorityService} from a tuple giving a server address and a C{str} giving the name of a domain for which this is an authority. @param serverAddress: A two-tuple, the first element of which is a C{str} giving an IP address and the second element of which is a C{int} giving a port number. Together, these define where zone transfers will be attempted from. @param domains: Domain names for which to perform zone transfers. @type domains: sequence of L{bytes} @return: A new instance of L{SecondaryAuthorityService}. """ primary, port = serverAddress service = cls(primary, []) service._port = port service.domains = [ SecondaryAuthority.fromServerAddressAndDomain(serverAddress, d) for d in domains ] return service def getAuthority(self): """ Get a resolver for the transferred domains. @rtype: L{ResolverChain} """ return resolve.ResolverChain(self.domains) def startService(self): service.Service.startService(self) self.calls = [task.LoopingCall(d.transfer) for d in self.domains] i = 0 from twisted.internet import reactor for c in self.calls: # XXX Add errbacks, respect proper timeouts reactor.callLater(i, c.start, 60 * 60) i += 1 def stopService(self): service.Service.stopService(self) for c in self.calls: c.stop() class SecondaryAuthority(FileAuthority): """ An Authority that keeps itself updated by performing zone transfers. @ivar primary: The IP address of the server from which zone transfers will be attempted. @type primary: L{str} @ivar _port: The port number of the server from which zone transfers will be attempted. @type _port: L{int} @ivar domain: The domain for which this is the secondary authority. @type domain: L{bytes} @ivar _reactor: The reactor to use to perform the zone transfers, or L{None} to use the global reactor. """ transferring = False soa = records = None _port = 53 _reactor = None def __init__(self, primaryIP, domain): """ @param domain: The domain for which this will be the secondary authority. @type domain: L{bytes} or L{str} """ # Yep. Skip over FileAuthority.__init__. This is a hack until we have # a good composition-based API for the complicated DNS record lookup # logic we want to share. common.ResolverBase.__init__(self) self.primary = nativeString(primaryIP) self.domain = dns.domainString(domain) @classmethod def fromServerAddressAndDomain(cls, serverAddress, domain): """ Construct a new L{SecondaryAuthority} from a tuple giving a server address and a C{bytes} giving the name of a domain for which this is an authority. @param serverAddress: A two-tuple, the first element of which is a C{str} giving an IP address and the second element of which is a C{int} giving a port number. Together, these define where zone transfers will be attempted from. @param domain: A C{bytes} giving the domain to transfer. @type domain: L{bytes} @return: A new instance of L{SecondaryAuthority}. """ primary, port = serverAddress secondary = cls(primary, domain) secondary._port = port return secondary def transfer(self): """ Attempt a zone transfer. @returns: A L{Deferred} that fires with L{None} when attempted zone transfer has completed. """ # FIXME: This logic doesn't avoid duplicate transfers # https://twistedmatrix.com/trac/ticket/9754 if self.transferring: # <-- never true return self.transfering = True # <-- speling reactor = self._reactor if reactor is None: from twisted.internet import reactor resolver = client.Resolver( servers=[(self.primary, self._port)], reactor=reactor ) return ( resolver.lookupZone(self.domain) .addCallback(self._cbZone) .addErrback(self._ebZone) ) def _lookup(self, name, cls, type, timeout=None): if not self.soa or not self.records: # No transfer has occurred yet. Fail non-authoritatively so that # the caller can try elsewhere. return defer.fail(failure.Failure(dns.DomainError(name))) return FileAuthority._lookup(self, name, cls, type, timeout) def _cbZone(self, zone): ans, _, _ = zone self.records = r = {} for rec in ans: if not self.soa and rec.type == dns.SOA: self.soa = (rec.name.name.lower(), rec.payload) else: r.setdefault(rec.name.name.lower(), []).append(rec.payload) def _ebZone(self, failure): log.msg( "Updating %s from %s failed during zone transfer" % (self.domain, self.primary) ) log.err(failure) def update(self): self.transfer().addCallbacks(self._cbTransferred, self._ebTransferred) def _cbTransferred(self, result): self.transferring = False def _ebTransferred(self, failure): self.transferred = False log.msg( "Transferring %s from %s failed after zone transfer" % (self.domain, self.primary) ) log.err(failure) PK Mb�Z���]� � names/resolve.pynu �[��� # -*- test-case-name: twisted.names.test.test_resolve -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Lookup a name using multiple resolvers. Future Plans: This needs someway to specify which resolver answered the query, or someway to specify (authority|ttl|cache behavior|more?) """ from zope.interface import implementer from twisted.internet import defer, interfaces from twisted.names import common, dns, error class FailureHandler: def __init__(self, resolver, query, timeout): self.resolver = resolver self.query = query self.timeout = timeout def __call__(self, failure): # AuthoritativeDomainErrors should halt resolution attempts failure.trap(dns.DomainError, defer.TimeoutError, NotImplementedError) return self.resolver(self.query, self.timeout) @implementer(interfaces.IResolver) class ResolverChain(common.ResolverBase): """ Lookup an address using multiple L{IResolver}s """ def __init__(self, resolvers): """ @type resolvers: L{list} @param resolvers: A L{list} of L{IResolver} providers. """ common.ResolverBase.__init__(self) self.resolvers = resolvers def _lookup(self, name, cls, type, timeout): """ Build a L{dns.Query} for the given parameters and dispatch it to each L{IResolver} in C{self.resolvers} until an answer or L{error.AuthoritativeDomainError} is returned. @type name: C{str} @param name: DNS name to resolve. @type type: C{int} @param type: DNS record type. @type cls: C{int} @param cls: DNS record class. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @rtype: L{Deferred} @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. """ if not self.resolvers: return defer.fail(error.DomainError()) q = dns.Query(name, type, cls) d = self.resolvers[0].query(q, timeout) for r in self.resolvers[1:]: d = d.addErrback(FailureHandler(r.query, q, timeout)) return d def lookupAllRecords(self, name, timeout=None): # XXX: Why is this necessary? dns.ALL_RECORDS queries should # be handled just the same as any other type by _lookup # above. If I remove this method all names tests still # pass. See #6604 -rwall if not self.resolvers: return defer.fail(error.DomainError()) d = self.resolvers[0].lookupAllRecords(name, timeout) for r in self.resolvers[1:]: d = d.addErrback(FailureHandler(r.lookupAllRecords, name, timeout)) return d PK Mb�Z�O��� � names/error.pynu �[��� # -*- test-case-name: twisted.names.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Exception class definitions for Twisted Names. """ from twisted.internet.defer import TimeoutError class DomainError(ValueError): """ Indicates a lookup failed because there were no records matching the given C{name, class, type} triple. """ class AuthoritativeDomainError(ValueError): """ Indicates a lookup failed for a name for which this server is authoritative because there were no records matching the given C{name, class, type} triple. """ class DNSQueryTimeoutError(TimeoutError): """ Indicates a lookup failed due to a timeout. @ivar id: The id of the message which timed out. """ def __init__(self, id): TimeoutError.__init__(self) self.id = id class DNSFormatError(DomainError): """ Indicates a query failed with a result of C{twisted.names.dns.EFORMAT}. """ class DNSServerError(DomainError): """ Indicates a query failed with a result of C{twisted.names.dns.ESERVER}. """ class DNSNameError(DomainError): """ Indicates a query failed with a result of C{twisted.names.dns.ENAME}. """ class DNSNotImplementedError(DomainError): """ Indicates a query failed with a result of C{twisted.names.dns.ENOTIMP}. """ class DNSQueryRefusedError(DomainError): """ Indicates a query failed with a result of C{twisted.names.dns.EREFUSED}. """ class DNSUnknownError(DomainError): """ Indicates a query failed with an unknown result. """ class ResolverError(Exception): """ Indicates a query failed because of a decision made by the local resolver object. """ __all__ = [ "DomainError", "AuthoritativeDomainError", "DNSQueryTimeoutError", "DNSFormatError", "DNSServerError", "DNSNameError", "DNSNotImplementedError", "DNSQueryRefusedError", "DNSUnknownError", "ResolverError", ] PK Mb�ZX��� � names/hosts.pynu �[��� # -*- test-case-name: twisted.names.test.test_hosts -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ hosts(5) support. """ from twisted.internet import defer from twisted.internet.abstract import isIPAddress, isIPv6Address from twisted.names import common, dns from twisted.python import failure from twisted.python.compat import nativeString from twisted.python.filepath import FilePath def searchFileForAll(hostsFile, name): """ Search the given file, which is in hosts(5) standard format, for addresses associated with a given name. @param hostsFile: The name of the hosts(5)-format file to search. @type hostsFile: L{FilePath} @param name: The name to search for. @type name: C{bytes} @return: L{None} if the name is not found in the file, otherwise a C{str} giving the address in the file associated with the name. """ results = [] try: lines = hostsFile.getContent().splitlines() except BaseException: return results name = name.lower() for line in lines: idx = line.find(b"#") if idx != -1: line = line[:idx] if not line: continue parts = line.split() if name.lower() in [s.lower() for s in parts[1:]]: try: maybeIP = nativeString(parts[0]) except ValueError: # Not ASCII. continue if isIPAddress(maybeIP) or isIPv6Address(maybeIP): results.append(maybeIP) return results def searchFileFor(file, name): """ Grep given file, which is in hosts(5) standard format, for an address entry with a given name. @param file: The name of the hosts(5)-format file to search. @type file: C{str} or C{bytes} @param name: The name to search for. @type name: C{bytes} @return: L{None} if the name is not found in the file, otherwise a C{str} giving the first address in the file associated with the name. """ addresses = searchFileForAll(FilePath(file), name) if addresses: return addresses[0] return None class Resolver(common.ResolverBase): """ A resolver that services hosts(5) format files. """ def __init__(self, file=b"/etc/hosts", ttl=60 * 60): common.ResolverBase.__init__(self) self.file = file self.ttl = ttl def _aRecords(self, name): """ Return a tuple of L{dns.RRHeader} instances for all of the IPv4 addresses in the hosts file. """ return tuple( dns.RRHeader(name, dns.A, dns.IN, self.ttl, dns.Record_A(addr, self.ttl)) for addr in searchFileForAll(FilePath(self.file), name) if isIPAddress(addr) ) def _aaaaRecords(self, name): """ Return a tuple of L{dns.RRHeader} instances for all of the IPv6 addresses in the hosts file. """ return tuple( dns.RRHeader( name, dns.AAAA, dns.IN, self.ttl, dns.Record_AAAA(addr, self.ttl) ) for addr in searchFileForAll(FilePath(self.file), name) if isIPv6Address(addr) ) def _respond(self, name, records): """ Generate a response for the given name containing the given result records, or a failure if there are no result records. @param name: The DNS name the response is for. @type name: C{str} @param records: A tuple of L{dns.RRHeader} instances giving the results that will go into the response. @return: A L{Deferred} which will fire with a three-tuple of result records, authority records, and additional records, or which will fail with L{dns.DomainError} if there are no result records. """ if records: return defer.succeed((records, (), ())) return defer.fail(failure.Failure(dns.DomainError(name))) def lookupAddress(self, name, timeout=None): """ Read any IPv4 addresses from C{self.file} and return them as L{Record_A} instances. """ name = dns.domainString(name) return self._respond(name, self._aRecords(name)) def lookupIPV6Address(self, name, timeout=None): """ Read any IPv6 addresses from C{self.file} and return them as L{Record_AAAA} instances. """ name = dns.domainString(name) return self._respond(name, self._aaaaRecords(name)) # Someday this should include IPv6 addresses too, but that will cause # problems if users of the API (mainly via getHostByName) aren't updated to # know about IPv6 first. # FIXME - getHostByName knows about IPv6 now. lookupAllRecords = lookupAddress PK Mb�Z.#,��� �� names/dns.pynu �[��� # -*- test-case-name: twisted.names.test.test_dns -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ DNS protocol implementation. Future Plans: - Get rid of some toplevels, maybe. """ # System imports import inspect import random import socket import struct from io import BytesIO from itertools import chain from typing import Optional, SupportsInt, Union from zope.interface import Attribute, Interface, implementer # Twisted imports from twisted.internet import defer, protocol from twisted.internet.error import CannotListenError from twisted.python import failure, log, randbytes, util as tputil from twisted.python.compat import cmp, comparable, nativeString __all__ = [ "IEncodable", "IRecord", "IEncodableRecord", "A", "A6", "AAAA", "AFSDB", "CNAME", "DNAME", "HINFO", "MAILA", "MAILB", "MB", "MD", "MF", "MG", "MINFO", "MR", "MX", "NAPTR", "NS", "NULL", "OPT", "PTR", "RP", "SOA", "SPF", "SRV", "TXT", "SSHFP", "TSIG", "WKS", "ANY", "CH", "CS", "HS", "IN", "ALL_RECORDS", "AXFR", "IXFR", "EFORMAT", "ENAME", "ENOTIMP", "EREFUSED", "ESERVER", "EBADVERSION", "EBADSIG", "EBADKEY", "EBADTIME", "Record_A", "Record_A6", "Record_AAAA", "Record_AFSDB", "Record_CNAME", "Record_DNAME", "Record_HINFO", "Record_MB", "Record_MD", "Record_MF", "Record_MG", "Record_MINFO", "Record_MR", "Record_MX", "Record_NAPTR", "Record_NS", "Record_NULL", "Record_PTR", "Record_RP", "Record_SOA", "Record_SPF", "Record_SRV", "Record_SSHFP", "Record_TSIG", "Record_TXT", "Record_WKS", "UnknownRecord", "QUERY_CLASSES", "QUERY_TYPES", "REV_CLASSES", "REV_TYPES", "EXT_QUERIES", "Charstr", "Message", "Name", "Query", "RRHeader", "SimpleRecord", "DNSDatagramProtocol", "DNSMixin", "DNSProtocol", "OK", "OP_INVERSE", "OP_NOTIFY", "OP_QUERY", "OP_STATUS", "OP_UPDATE", "PORT", "AuthoritativeDomainError", "DNSQueryTimeoutError", "DomainError", ] AF_INET6 = socket.AF_INET6 def _ord2bytes(ordinal): """ Construct a bytes object representing a single byte with the given ordinal value. @type ordinal: L{int} @rtype: L{bytes} """ return bytes([ordinal]) def _nicebytes(bytes): """ Represent a mostly textful bytes object in a way suitable for presentation to an end user. @param bytes: The bytes to represent. @rtype: L{str} """ return repr(bytes)[1:] def _nicebyteslist(list): """ Represent a list of mostly textful bytes objects in a way suitable for presentation to an end user. @param list: The list of bytes to represent. @rtype: L{str} """ return "[{}]".format(", ".join([_nicebytes(b) for b in list])) def randomSource(): """ Wrapper around L{twisted.python.randbytes.RandomFactory.secureRandom} to return 2 random bytes. @rtype: L{bytes} """ return struct.unpack("H", randbytes.secureRandom(2, fallback=True))[0] PORT = 53 ( A, NS, MD, MF, CNAME, SOA, MB, MG, MR, NULL, WKS, PTR, HINFO, MINFO, MX, TXT, RP, AFSDB, ) = range(1, 19) AAAA = 28 SRV = 33 NAPTR = 35 A6 = 38 DNAME = 39 OPT = 41 SSHFP = 44 SPF = 99 # These record types do not exist in zones, but are transferred in # messages the same way normal RRs are. TKEY = 249 TSIG = 250 QUERY_TYPES = { A: "A", NS: "NS", MD: "MD", MF: "MF", CNAME: "CNAME", SOA: "SOA", MB: "MB", MG: "MG", MR: "MR", NULL: "NULL", WKS: "WKS", PTR: "PTR", HINFO: "HINFO", MINFO: "MINFO", MX: "MX", TXT: "TXT", RP: "RP", AFSDB: "AFSDB", # 19 through 27? Eh, I'll get to 'em. AAAA: "AAAA", SRV: "SRV", NAPTR: "NAPTR", A6: "A6", DNAME: "DNAME", OPT: "OPT", SSHFP: "SSHFP", SPF: "SPF", TKEY: "TKEY", TSIG: "TSIG", } IXFR, AXFR, MAILB, MAILA, ALL_RECORDS = range(251, 256) # "Extended" queries (Hey, half of these are deprecated, good job) EXT_QUERIES = { IXFR: "IXFR", AXFR: "AXFR", MAILB: "MAILB", MAILA: "MAILA", ALL_RECORDS: "ALL_RECORDS", } REV_TYPES = {v: k for (k, v) in chain(QUERY_TYPES.items(), EXT_QUERIES.items())} IN, CS, CH, HS = range(1, 5) ANY = 255 QUERY_CLASSES = {IN: "IN", CS: "CS", CH: "CH", HS: "HS", ANY: "ANY"} REV_CLASSES = {v: k for (k, v) in QUERY_CLASSES.items()} # Opcodes OP_QUERY, OP_INVERSE, OP_STATUS = range(3) OP_NOTIFY = 4 # RFC 1996 OP_UPDATE = 5 # RFC 2136 # Response Codes OK, EFORMAT, ESERVER, ENAME, ENOTIMP, EREFUSED = range(6) # https://tools.ietf.org/html/rfc6891#section-9 EBADVERSION = 16 # RFC 2845 EBADSIG, EBADKEY, EBADTIME = range(16, 19) class IRecord(Interface): """ A single entry in a zone of authority. """ TYPE = Attribute("An indicator of what kind of record this is.") # Backwards compatibility aliases - these should be deprecated or something I # suppose. -exarkun from twisted.names.error import ( AuthoritativeDomainError, DNSQueryTimeoutError, DomainError, ) def _nameToLabels(name): """ Split a domain name into its constituent labels. @type name: L{bytes} @param name: A fully qualified domain name (with or without a trailing dot). @return: A L{list} of labels ending with an empty label representing the DNS root zone. @rtype: L{list} of L{bytes} """ if name in (b"", b"."): return [b""] labels = name.split(b".") if labels[-1] != b"": labels.append(b"") return labels def domainString(domain): """ Coerce a domain name string to bytes. L{twisted.names} represents domain names as L{bytes}, but many interfaces accept L{bytes} or a text string (L{unicode} on Python 2, L{str} on Python 3). This function coerces text strings using IDNA encoding --- see L{encodings.idna}. Note that DNS is I{case insensitive} but I{case preserving}. This function doesn't normalize case, so you'll still need to do that whenever comparing the strings it returns. @param domain: A domain name. If passed as a text string it will be C{idna} encoded. @type domain: L{bytes} or L{str} @returns: L{bytes} suitable for network transmission. @rtype: L{bytes} @since: Twisted 20.3.0 """ if isinstance(domain, str): domain = domain.encode("idna") if not isinstance(domain, bytes): raise TypeError( "Expected {} or {} but found {!r} of type {}".format( bytes.__name__, str.__name__, domain, type(domain) ) ) return domain def _isSubdomainOf(descendantName, ancestorName): """ Test whether C{descendantName} is equal to or is a I{subdomain} of C{ancestorName}. The names are compared case-insensitively. The names are treated as byte strings containing one or more DNS labels separated by B{.}. C{descendantName} is considered equal if its sequence of labels exactly matches the labels of C{ancestorName}. C{descendantName} is considered a I{subdomain} if its sequence of labels ends with the labels of C{ancestorName}. @type descendantName: L{bytes} @param descendantName: The DNS subdomain name. @type ancestorName: L{bytes} @param ancestorName: The DNS parent or ancestor domain name. @return: C{True} if C{descendantName} is equal to or if it is a subdomain of C{ancestorName}. Otherwise returns C{False}. """ descendantLabels = _nameToLabels(descendantName.lower()) ancestorLabels = _nameToLabels(ancestorName.lower()) return descendantLabels[-len(ancestorLabels) :] == ancestorLabels def str2time(s): """ Parse a string description of an interval into an integer number of seconds. @param s: An interval definition constructed as an interval duration followed by an interval unit. An interval duration is a base ten representation of an integer. An interval unit is one of the following letters: S (seconds), M (minutes), H (hours), D (days), W (weeks), or Y (years). For example: C{"3S"} indicates an interval of three seconds; C{"5D"} indicates an interval of five days. Alternatively, C{s} may be any non-string and it will be returned unmodified. @type s: text string (L{bytes} or L{str}) for parsing; anything else for passthrough. @return: an L{int} giving the interval represented by the string C{s}, or whatever C{s} is if it is not a string. """ suffixes = ( ("S", 1), ("M", 60), ("H", 60 * 60), ("D", 60 * 60 * 24), ("W", 60 * 60 * 24 * 7), ("Y", 60 * 60 * 24 * 365), ) if isinstance(s, bytes): s = s.decode("ascii") if isinstance(s, str): s = s.upper().strip() for (suff, mult) in suffixes: if s.endswith(suff): return int(float(s[:-1]) * mult) try: s = int(s) except ValueError: raise ValueError("Invalid time interval specifier: " + s) return s def readPrecisely(file, l): buff = file.read(l) if len(buff) < l: raise EOFError return buff class IEncodable(Interface): """ Interface for something which can be encoded to and decoded to the DNS wire format. A binary-mode file object (such as L{io.BytesIO}) is used as a buffer when encoding or decoding. """ def encode(strio, compDict=None): """ Write a representation of this object to the given file object. @type strio: File-like object @param strio: The buffer to write to. It must have a C{tell()} method. @type compDict: L{dict} of L{bytes} to L{int} r L{None} @param compDict: A mapping of names to byte offsets that have already been written to the buffer, which may be used for compression (see RFC 1035 section 4.1.4). When L{None}, encode without compression. """ def decode(strio, length=None): """ Reconstruct an object from data read from the given file object. @type strio: File-like object @param strio: A seekable buffer from which bytes may be read. @type length: L{int} or L{None} @param length: The number of bytes in this RDATA field. Most implementations can ignore this value. Only in the case of records similar to TXT where the total length is in no way encoded in the data is it necessary. """ class IEncodableRecord(IEncodable, IRecord): """ Interface for DNS records that can be encoded and decoded. @since: Twisted 21.2.0 """ @implementer(IEncodable) class Charstr: def __init__(self, string=b""): if not isinstance(string, bytes): raise ValueError(f"{string!r} is not a byte string") self.string = string def encode(self, strio, compDict=None): """ Encode this Character string into the appropriate byte format. @type strio: file @param strio: The byte representation of this Charstr will be written to this file. """ string = self.string ind = len(string) strio.write(_ord2bytes(ind)) strio.write(string) def decode(self, strio, length=None): """ Decode a byte string into this Charstr. @type strio: file @param strio: Bytes will be read from this file until the full string is decoded. @raise EOFError: Raised when there are not enough bytes available from C{strio}. """ self.string = b"" l = ord(readPrecisely(strio, 1)) self.string = readPrecisely(strio, l) def __eq__(self, other: object) -> bool: if isinstance(other, Charstr): return self.string == other.string return NotImplemented def __hash__(self): return hash(self.string) def __str__(self) -> str: """ Represent this L{Charstr} instance by its string value. """ return nativeString(self.string) @implementer(IEncodable) class Name: """ A name in the domain name system, made up of multiple labels. For example, I{twistedmatrix.com}. @ivar name: A byte string giving the name. @type name: L{bytes} """ def __init__(self, name=b""): """ @param name: A name. @type name: L{bytes} or L{str} """ self.name = domainString(name) def encode(self, strio, compDict=None): """ Encode this Name into the appropriate byte format. @type strio: file @param strio: The byte representation of this Name will be written to this file. @type compDict: dict @param compDict: dictionary of Names that have already been encoded and whose addresses may be backreferenced by this Name (for the purpose of reducing the message size). """ name = self.name while name: if compDict is not None: if name in compDict: strio.write(struct.pack("!H", 0xC000 | compDict[name])) return else: compDict[name] = strio.tell() + Message.headerSize ind = name.find(b".") if ind > 0: label, name = name[:ind], name[ind + 1 :] else: # This is the last label, end the loop after handling it. label = name name = None ind = len(label) strio.write(_ord2bytes(ind)) strio.write(label) strio.write(b"\x00") def decode(self, strio, length=None): """ Decode a byte string into this Name. @type strio: file @param strio: Bytes will be read from this file until the full Name is decoded. @raise EOFError: Raised when there are not enough bytes available from C{strio}. @raise ValueError: Raised when the name cannot be decoded (for example, because it contains a loop). """ visited = set() self.name = b"" off = 0 while 1: l = ord(readPrecisely(strio, 1)) if l == 0: if off > 0: strio.seek(off) return if (l >> 6) == 3: new_off = (l & 63) << 8 | ord(readPrecisely(strio, 1)) if new_off in visited: raise ValueError("Compression loop in encoded name") visited.add(new_off) if off == 0: off = strio.tell() strio.seek(new_off) continue label = readPrecisely(strio, l) if self.name == b"": self.name = label else: self.name = self.name + b"." + label def __eq__(self, other: object) -> bool: if isinstance(other, Name): return self.name.lower() == other.name.lower() return NotImplemented def __hash__(self): return hash(self.name) def __str__(self) -> str: """ Represent this L{Name} instance by its string name. """ return nativeString(self.name) @comparable @implementer(IEncodable) class Query: """ Represent a single DNS query. @ivar name: The name about which this query is requesting information. @type name: L{Name} @ivar type: The query type. @type type: L{int} @ivar cls: The query class. @type cls: L{int} """ def __init__(self, name: Union[bytes, str] = b"", type: int = A, cls: int = IN): """ @type name: L{bytes} or L{str} @param name: See L{Query.name} @type type: L{int} @param type: The query type. @type cls: L{int} @param cls: The query class. """ self.name = Name(name) self.type = type self.cls = cls def encode(self, strio, compDict=None): self.name.encode(strio, compDict) strio.write(struct.pack("!HH", self.type, self.cls)) def decode(self, strio, length=None): self.name.decode(strio) buff = readPrecisely(strio, 4) self.type, self.cls = struct.unpack("!HH", buff) def __hash__(self): return hash((self.name.name.lower(), self.type, self.cls)) def __cmp__(self, other): if isinstance(other, Query): return cmp( (self.name.name.lower(), self.type, self.cls), (other.name.name.lower(), other.type, other.cls), ) return NotImplemented def __str__(self) -> str: t = QUERY_TYPES.get( self.type, EXT_QUERIES.get(self.type, "UNKNOWN (%d)" % self.type) ) c = QUERY_CLASSES.get(self.cls, "UNKNOWN (%d)" % self.cls) return f"<Query {self.name} {t} {c}>" def __repr__(self) -> str: return f"Query({self.name.name!r}, {self.type!r}, {self.cls!r})" @implementer(IEncodable) class _OPTHeader(tputil.FancyStrMixin, tputil.FancyEqMixin): """ An OPT record header. @ivar name: The DNS name associated with this record. Since this is a pseudo record, the name is always an L{Name} instance with value b'', which represents the DNS root zone. This attribute is a readonly property. @ivar type: The DNS record type. This is a fixed value of 41 C{dns.OPT} for OPT Record. This attribute is a readonly property. @see: L{_OPTHeader.__init__} for documentation of other public instance attributes. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.2} @since: 13.2 """ showAttributes = ( ("name", lambda n: nativeString(n.name)), "type", "udpPayloadSize", "extendedRCODE", "version", "dnssecOK", "options", ) compareAttributes = ( "name", "type", "udpPayloadSize", "extendedRCODE", "version", "dnssecOK", "options", ) def __init__( self, udpPayloadSize=4096, extendedRCODE=0, version=0, dnssecOK=False, options=None, ): """ @type udpPayloadSize: L{int} @param udpPayloadSize: The number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type extendedRCODE: L{int} @param extendedRCODE: Forms the upper 8 bits of extended 12-bit RCODE (together with the 4 bits defined in [RFC1035]. Note that EXTENDED-RCODE value 0 indicates that an unextended RCODE is in use (values 0 through 15). @type version: L{int} @param version: Indicates the implementation level of the setter. Full conformance with this specification is indicated by version C{0}. @type dnssecOK: L{bool} @param dnssecOK: DNSSEC OK bit as defined by [RFC3225]. @type options: L{list} @param options: A L{list} of 0 or more L{_OPTVariableOption} instances. """ self.udpPayloadSize = udpPayloadSize self.extendedRCODE = extendedRCODE self.version = version self.dnssecOK = dnssecOK if options is None: options = [] self.options = options @property def name(self): """ A readonly property for accessing the C{name} attribute of this record. @return: The DNS name associated with this record. Since this is a pseudo record, the name is always an L{Name} instance with value b'', which represents the DNS root zone. """ return Name(b"") @property def type(self): """ A readonly property for accessing the C{type} attribute of this record. @return: The DNS record type. This is a fixed value of 41 (C{dns.OPT} for OPT Record. """ return OPT def encode(self, strio, compDict=None): """ Encode this L{_OPTHeader} instance to bytes. @type strio: file @param strio: the byte representation of this L{_OPTHeader} will be written to this file. @type compDict: L{dict} or L{None} @param compDict: A dictionary of backreference addresses that have already been written to this stream and that may be used for DNS name compression. """ b = BytesIO() for o in self.options: o.encode(b) optionBytes = b.getvalue() RRHeader( name=self.name.name, type=self.type, cls=self.udpPayloadSize, ttl=(self.extendedRCODE << 24 | self.version << 16 | self.dnssecOK << 15), payload=UnknownRecord(optionBytes), ).encode(strio, compDict) def decode(self, strio, length=None): """ Decode bytes into an L{_OPTHeader} instance. @type strio: file @param strio: Bytes will be read from this file until the full L{_OPTHeader} is decoded. @type length: L{int} or L{None} @param length: Not used. """ h = RRHeader() h.decode(strio, length) h.payload = UnknownRecord(readPrecisely(strio, h.rdlength)) newOptHeader = self.fromRRHeader(h) for attrName in self.compareAttributes: if attrName not in ("name", "type"): setattr(self, attrName, getattr(newOptHeader, attrName)) @classmethod def fromRRHeader(cls, rrHeader): """ A classmethod for constructing a new L{_OPTHeader} from the attributes and payload of an existing L{RRHeader} instance. @type rrHeader: L{RRHeader} @param rrHeader: An L{RRHeader} instance containing an L{UnknownRecord} payload. @return: An instance of L{_OPTHeader}. @rtype: L{_OPTHeader} """ options = None if rrHeader.payload is not None: options = [] optionsBytes = BytesIO(rrHeader.payload.data) optionsBytesLength = len(rrHeader.payload.data) while optionsBytes.tell() < optionsBytesLength: o = _OPTVariableOption() o.decode(optionsBytes) options.append(o) # Decode variable options if present return cls( udpPayloadSize=rrHeader.cls, extendedRCODE=rrHeader.ttl >> 24, version=rrHeader.ttl >> 16 & 0xFF, dnssecOK=(rrHeader.ttl & 0xFFFF) >> 15, options=options, ) @implementer(IEncodable) class _OPTVariableOption(tputil.FancyStrMixin, tputil.FancyEqMixin): """ A class to represent OPT record variable options. @see: L{_OPTVariableOption.__init__} for documentation of public instance attributes. @see: U{https://tools.ietf.org/html/rfc6891#section-6.1.2} @since: 13.2 """ showAttributes = ("code", ("data", nativeString)) compareAttributes = ("code", "data") _fmt = "!HH" def __init__(self, code=0, data=b""): """ @type code: L{int} @param code: The option code @type data: L{bytes} @param data: The option data """ self.code = code self.data = data def encode(self, strio, compDict=None): """ Encode this L{_OPTVariableOption} to bytes. @type strio: file @param strio: the byte representation of this L{_OPTVariableOption} will be written to this file. @type compDict: L{dict} or L{None} @param compDict: A dictionary of backreference addresses that have already been written to this stream and that may be used for DNS name compression. """ strio.write(struct.pack(self._fmt, self.code, len(self.data)) + self.data) def decode(self, strio, length=None): """ Decode bytes into an L{_OPTVariableOption} instance. @type strio: file @param strio: Bytes will be read from this file until the full L{_OPTVariableOption} is decoded. @type length: L{int} or L{None} @param length: Not used. """ l = struct.calcsize(self._fmt) buff = readPrecisely(strio, l) self.code, length = struct.unpack(self._fmt, buff) self.data = readPrecisely(strio, length) @implementer(IEncodable) class RRHeader(tputil.FancyEqMixin): """ A resource record header. @cvar fmt: L{str} specifying the byte format of an RR. @ivar name: The name about which this reply contains information. @type name: L{Name} @ivar type: The query type of the original request. @type type: L{int} @ivar cls: The query class of the original request. @ivar ttl: The time-to-live for this record. @type ttl: L{int} @ivar payload: The record described by this header. @type payload: L{IEncodableRecord} or L{None} @ivar auth: A L{bool} indicating whether this C{RRHeader} was parsed from an authoritative message. """ compareAttributes = ("name", "type", "cls", "ttl", "payload", "auth") fmt = "!HHIH" rdlength = None cachedResponse = None def __init__( self, name: Union[bytes, str] = b"", type: int = A, cls: int = IN, ttl: SupportsInt = 0, payload: Optional[IEncodableRecord] = None, auth: bool = False, ): """ @type name: L{bytes} or L{str} @param name: See L{RRHeader.name} @type type: L{int} @param type: The query type. @type cls: L{int} @param cls: The query class. @type ttl: L{int} @param ttl: Time to live for this record. This will be converted to an L{int}. @type payload: L{IEncodableRecord} or L{None} @param payload: An optional Query Type specific data object. @raises TypeError: if the ttl cannot be converted to an L{int}. @raises ValueError: if the ttl is negative. @raises ValueError: if the payload type is not equal to the C{type} argument. """ payloadType = None if payload is None else payload.TYPE if payloadType is not None and payloadType != type: raise ValueError( "Payload type (%s) does not match given type (%s)" % ( QUERY_TYPES.get(payloadType, payloadType), QUERY_TYPES.get(type, type), ) ) integralTTL = int(ttl) if integralTTL < 0: raise ValueError("TTL cannot be negative") self.name = Name(name) self.type = type self.cls = cls self.ttl = integralTTL self.payload = payload self.auth = auth def encode(self, strio, compDict=None): self.name.encode(strio, compDict) strio.write(struct.pack(self.fmt, self.type, self.cls, self.ttl, 0)) if self.payload: prefix = strio.tell() self.payload.encode(strio, compDict) aft = strio.tell() strio.seek(prefix - 2, 0) strio.write(struct.pack("!H", aft - prefix)) strio.seek(aft, 0) def decode(self, strio, length=None): self.name.decode(strio) l = struct.calcsize(self.fmt) buff = readPrecisely(strio, l) r = struct.unpack(self.fmt, buff) self.type, self.cls, self.ttl, self.rdlength = r def isAuthoritative(self): return self.auth def __str__(self) -> str: t = QUERY_TYPES.get( self.type, EXT_QUERIES.get(self.type, "UNKNOWN (%d)" % self.type) ) c = QUERY_CLASSES.get(self.cls, "UNKNOWN (%d)" % self.cls) return "<RR name=%s type=%s class=%s ttl=%ds auth=%s>" % ( self.name, t, c, self.ttl, self.auth and "True" or "False", ) __repr__ = __str__ @implementer(IEncodableRecord) class SimpleRecord(tputil.FancyStrMixin, tputil.FancyEqMixin): """ A Resource Record which consists of a single RFC 1035 domain-name. @type name: L{Name} @ivar name: The name associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ showAttributes = (("name", "name", "%s"), "ttl") compareAttributes = ("name", "ttl") TYPE: Optional[int] = None name = None def __init__(self, name=b"", ttl=None): """ @param name: See L{SimpleRecord.name} @type name: L{bytes} or L{str} """ self.name = Name(name) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): self.name.encode(strio, compDict) def decode(self, strio, length=None): self.name = Name() self.name.decode(strio) def __hash__(self): return hash(self.name) # Kinds of RRs - oh my! class Record_NS(SimpleRecord): """ An authoritative nameserver. """ TYPE = NS fancybasename = "NS" class Record_MD(SimpleRecord): """ A mail destination. This record type is obsolete. @see: L{Record_MX} """ TYPE = MD fancybasename = "MD" class Record_MF(SimpleRecord): """ A mail forwarder. This record type is obsolete. @see: L{Record_MX} """ TYPE = MF fancybasename = "MF" class Record_CNAME(SimpleRecord): """ The canonical name for an alias. """ TYPE = CNAME fancybasename = "CNAME" class Record_MB(SimpleRecord): """ A mailbox domain name. This is an experimental record type. """ TYPE = MB fancybasename = "MB" class Record_MG(SimpleRecord): """ A mail group member. This is an experimental record type. """ TYPE = MG fancybasename = "MG" class Record_MR(SimpleRecord): """ A mail rename domain name. This is an experimental record type. """ TYPE = MR fancybasename = "MR" class Record_PTR(SimpleRecord): """ A domain name pointer. """ TYPE = PTR fancybasename = "PTR" class Record_DNAME(SimpleRecord): """ A non-terminal DNS name redirection. This record type provides the capability to map an entire subtree of the DNS name space to another domain. It differs from the CNAME record which maps a single node of the name space. @see: U{http://www.faqs.org/rfcs/rfc2672.html} @see: U{http://www.faqs.org/rfcs/rfc3363.html} """ TYPE = DNAME fancybasename = "DNAME" @implementer(IEncodableRecord) class Record_A(tputil.FancyEqMixin): """ An IPv4 host address. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv4 address associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ compareAttributes = ("address", "ttl") TYPE = A address = None def __init__(self, address="0.0.0.0", ttl=None): """ @type address: L{bytes} or L{str} @param address: The IPv4 address associated with this record, in quad-dotted notation. """ if isinstance(address, bytes): address = address.decode("ascii") address = socket.inet_aton(address) self.address = address self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(self.address) def decode(self, strio, length=None): self.address = readPrecisely(strio, 4) def __hash__(self): return hash(self.address) def __str__(self) -> str: return f"<A address={self.dottedQuad()} ttl={self.ttl}>" __repr__ = __str__ def dottedQuad(self): return socket.inet_ntoa(self.address) @implementer(IEncodableRecord) class Record_SOA(tputil.FancyEqMixin, tputil.FancyStrMixin): """ Marks the start of a zone of authority. This record describes parameters which are shared by all records within a particular zone. @type mname: L{Name} @ivar mname: The domain-name of the name server that was the original or primary source of data for this zone. @type rname: L{Name} @ivar rname: A domain-name which specifies the mailbox of the person responsible for this zone. @type serial: L{int} @ivar serial: The unsigned 32 bit version number of the original copy of the zone. Zone transfers preserve this value. This value wraps and should be compared using sequence space arithmetic. @type refresh: L{int} @ivar refresh: A 32 bit time interval before the zone should be refreshed. @type minimum: L{int} @ivar minimum: The unsigned 32 bit minimum TTL field that should be exported with any RR from this zone. @type expire: L{int} @ivar expire: A 32 bit time value that specifies the upper limit on the time interval that can elapse before the zone is no longer authoritative. @type retry: L{int} @ivar retry: A 32 bit time interval that should elapse before a failed refresh should be retried. @type ttl: L{int} @ivar ttl: The default TTL to use for records served from this zone. """ fancybasename = "SOA" compareAttributes = ( "serial", "mname", "rname", "refresh", "expire", "retry", "minimum", "ttl", ) showAttributes = ( ("mname", "mname", "%s"), ("rname", "rname", "%s"), "serial", "refresh", "retry", "expire", "minimum", "ttl", ) TYPE = SOA def __init__( self, mname=b"", rname=b"", serial=0, refresh=0, retry=0, expire=0, minimum=0, ttl=None, ): """ @param mname: See L{Record_SOA.mname} @type mname: L{bytes} or L{str} @param rname: See L{Record_SOA.rname} @type rname: L{bytes} or L{str} """ self.mname, self.rname = Name(mname), Name(rname) self.serial, self.refresh = str2time(serial), str2time(refresh) self.minimum, self.expire = str2time(minimum), str2time(expire) self.retry = str2time(retry) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): self.mname.encode(strio, compDict) self.rname.encode(strio, compDict) strio.write( struct.pack( "!LlllL", self.serial, self.refresh, self.retry, self.expire, self.minimum, ) ) def decode(self, strio, length=None): self.mname, self.rname = Name(), Name() self.mname.decode(strio) self.rname.decode(strio) r = struct.unpack("!LlllL", readPrecisely(strio, 20)) self.serial, self.refresh, self.retry, self.expire, self.minimum = r def __hash__(self): return hash( (self.serial, self.mname, self.rname, self.refresh, self.expire, self.retry) ) @implementer(IEncodableRecord) class Record_NULL(tputil.FancyStrMixin, tputil.FancyEqMixin): """ A null record. This is an experimental record type. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ fancybasename = "NULL" showAttributes = (("payload", _nicebytes), "ttl") compareAttributes = ("payload", "ttl") TYPE = NULL def __init__(self, payload=None, ttl=None): self.payload = payload self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(self.payload) def decode(self, strio, length=None): self.payload = readPrecisely(strio, length) def __hash__(self): return hash(self.payload) @implementer(IEncodableRecord) class Record_WKS(tputil.FancyEqMixin, tputil.FancyStrMixin): """ A well known service description. This record type is obsolete. See L{Record_SRV}. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv4 address associated with this record. @type protocol: L{int} @ivar protocol: The 8 bit IP protocol number for which this service map is relevant. @type map: L{bytes} @ivar map: A bitvector indicating the services available at the specified address. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ fancybasename = "WKS" compareAttributes = ("address", "protocol", "map", "ttl") showAttributes = [("_address", "address", "%s"), "protocol", "ttl"] TYPE = WKS @property def _address(self): return socket.inet_ntoa(self.address) def __init__(self, address="0.0.0.0", protocol=0, map=b"", ttl=None): """ @type address: L{bytes} or L{str} @param address: The IPv4 address associated with this record, in quad-dotted notation. """ if isinstance(address, bytes): address = address.decode("idna") self.address = socket.inet_aton(address) self.protocol, self.map = protocol, map self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(self.address) strio.write(struct.pack("!B", self.protocol)) strio.write(self.map) def decode(self, strio, length=None): self.address = readPrecisely(strio, 4) self.protocol = struct.unpack("!B", readPrecisely(strio, 1))[0] self.map = readPrecisely(strio, length - 5) def __hash__(self): return hash((self.address, self.protocol, self.map)) @implementer(IEncodableRecord) class Record_AAAA(tputil.FancyEqMixin, tputil.FancyStrMixin): """ An IPv6 host address. @type address: L{bytes} @ivar address: The packed network-order representation of the IPv6 address associated with this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1886.html} """ TYPE = AAAA fancybasename = "AAAA" showAttributes = (("_address", "address", "%s"), "ttl") compareAttributes = ("address", "ttl") @property def _address(self): return socket.inet_ntop(AF_INET6, self.address) def __init__(self, address="::", ttl=None): """ @type address: L{bytes} or L{str} @param address: The IPv6 address for this host, in RFC 2373 format. """ if isinstance(address, bytes): address = address.decode("idna") self.address = socket.inet_pton(AF_INET6, address) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(self.address) def decode(self, strio, length=None): self.address = readPrecisely(strio, 16) def __hash__(self): return hash(self.address) @implementer(IEncodableRecord) class Record_A6(tputil.FancyStrMixin, tputil.FancyEqMixin): """ An IPv6 address. This is an experimental record type. @type prefixLen: L{int} @ivar prefixLen: The length of the suffix. @type suffix: L{bytes} @ivar suffix: An IPv6 address suffix in network order. @type prefix: L{Name} @ivar prefix: If specified, a name which will be used as a prefix for other A6 records. @type bytes: L{int} @ivar bytes: The length of the prefix. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2874.html} @see: U{http://www.faqs.org/rfcs/rfc3363.html} @see: U{http://www.faqs.org/rfcs/rfc3364.html} """ TYPE = A6 fancybasename = "A6" showAttributes = (("_suffix", "suffix", "%s"), ("prefix", "prefix", "%s"), "ttl") compareAttributes = ("prefixLen", "prefix", "suffix", "ttl") @property def _suffix(self): return socket.inet_ntop(AF_INET6, self.suffix) def __init__(self, prefixLen=0, suffix="::", prefix=b"", ttl=None): """ @param suffix: An IPv6 address suffix in in RFC 2373 format. @type suffix: L{bytes} or L{str} @param prefix: An IPv6 address prefix for other A6 records. @type prefix: L{bytes} or L{str} """ if isinstance(suffix, bytes): suffix = suffix.decode("idna") self.prefixLen = prefixLen self.suffix = socket.inet_pton(AF_INET6, suffix) self.prefix = Name(prefix) self.bytes = int((128 - self.prefixLen) / 8.0) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!B", self.prefixLen)) if self.bytes: strio.write(self.suffix[-self.bytes :]) if self.prefixLen: # This may not be compressed self.prefix.encode(strio, None) def decode(self, strio, length=None): self.prefixLen = struct.unpack("!B", readPrecisely(strio, 1))[0] self.bytes = int((128 - self.prefixLen) / 8.0) if self.bytes: self.suffix = b"\x00" * (16 - self.bytes) + readPrecisely(strio, self.bytes) if self.prefixLen: self.prefix.decode(strio) def __eq__(self, other: object) -> bool: if isinstance(other, Record_A6): return ( self.prefixLen == other.prefixLen and self.suffix[-self.bytes :] == other.suffix[-self.bytes :] and self.prefix == other.prefix and self.ttl == other.ttl ) return NotImplemented def __hash__(self): return hash((self.prefixLen, self.suffix[-self.bytes :], self.prefix)) def __str__(self) -> str: return "<A6 %s %s (%d) ttl=%s>" % ( self.prefix, socket.inet_ntop(AF_INET6, self.suffix), self.prefixLen, self.ttl, ) @implementer(IEncodableRecord) class Record_SRV(tputil.FancyEqMixin, tputil.FancyStrMixin): """ The location of the server(s) for a specific protocol and domain. This is an experimental record type. @type priority: L{int} @ivar priority: The priority of this target host. A client MUST attempt to contact the target host with the lowest-numbered priority it can reach; target hosts with the same priority SHOULD be tried in an order defined by the weight field. @type weight: L{int} @ivar weight: Specifies a relative weight for entries with the same priority. Larger weights SHOULD be given a proportionately higher probability of being selected. @type port: L{int} @ivar port: The port on this target host of this service. @type target: L{Name} @ivar target: The domain name of the target host. There MUST be one or more address records for this name, the name MUST NOT be an alias (in the sense of RFC 1034 or RFC 2181). Implementors are urged, but not required, to return the address record(s) in the Additional Data section. Unless and until permitted by future standards action, name compression is not to be used for this field. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2782.html} """ TYPE = SRV fancybasename = "SRV" compareAttributes = ("priority", "weight", "target", "port", "ttl") showAttributes = ("priority", "weight", ("target", "target", "%s"), "port", "ttl") def __init__(self, priority=0, weight=0, port=0, target=b"", ttl=None): """ @param target: See L{Record_SRV.target} @type target: L{bytes} or L{str} """ self.priority = int(priority) self.weight = int(weight) self.port = int(port) self.target = Name(target) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!HHH", self.priority, self.weight, self.port)) # This can't be compressed self.target.encode(strio, None) def decode(self, strio, length=None): r = struct.unpack("!HHH", readPrecisely(strio, struct.calcsize("!HHH"))) self.priority, self.weight, self.port = r self.target = Name() self.target.decode(strio) def __hash__(self): return hash((self.priority, self.weight, self.port, self.target)) @implementer(IEncodableRecord) class Record_NAPTR(tputil.FancyEqMixin, tputil.FancyStrMixin): """ The location of the server(s) for a specific protocol and domain. @type order: L{int} @ivar order: An integer specifying the order in which the NAPTR records MUST be processed to ensure the correct ordering of rules. Low numbers are processed before high numbers. @type preference: L{int} @ivar preference: An integer that specifies the order in which NAPTR records with equal "order" values SHOULD be processed, low numbers being processed before high numbers. @type flag: L{Charstr} @ivar flag: A <character-string> containing flags to control aspects of the rewriting and interpretation of the fields in the record. Flags are single characters from the set [A-Z0-9]. The case of the alphabetic characters is not significant. At this time only four flags, "S", "A", "U", and "P", are defined. @type service: L{Charstr} @ivar service: Specifies the service(s) available down this rewrite path. It may also specify the particular protocol that is used to talk with a service. A protocol MUST be specified if the flags field states that the NAPTR is terminal. @type regexp: L{Charstr} @ivar regexp: A STRING containing a substitution expression that is applied to the original string held by the client in order to construct the next domain name to lookup. @type replacement: L{Name} @ivar replacement: The next NAME to query for NAPTR, SRV, or address records depending on the value of the flags field. This MUST be a fully qualified domain-name. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc2915.html} """ TYPE = NAPTR compareAttributes = ( "order", "preference", "flags", "service", "regexp", "replacement", ) fancybasename = "NAPTR" showAttributes = ( "order", "preference", ("flags", "flags", "%s"), ("service", "service", "%s"), ("regexp", "regexp", "%s"), ("replacement", "replacement", "%s"), "ttl", ) def __init__( self, order=0, preference=0, flags=b"", service=b"", regexp=b"", replacement=b"", ttl=None, ): """ @param replacement: See L{Record_NAPTR.replacement} @type replacement: L{bytes} or L{str} """ self.order = int(order) self.preference = int(preference) self.flags = Charstr(flags) self.service = Charstr(service) self.regexp = Charstr(regexp) self.replacement = Name(replacement) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!HH", self.order, self.preference)) # This can't be compressed self.flags.encode(strio, None) self.service.encode(strio, None) self.regexp.encode(strio, None) self.replacement.encode(strio, None) def decode(self, strio, length=None): r = struct.unpack("!HH", readPrecisely(strio, struct.calcsize("!HH"))) self.order, self.preference = r self.flags = Charstr() self.service = Charstr() self.regexp = Charstr() self.replacement = Name() self.flags.decode(strio) self.service.decode(strio) self.regexp.decode(strio) self.replacement.decode(strio) def __hash__(self): return hash( ( self.order, self.preference, self.flags, self.service, self.regexp, self.replacement, ) ) @implementer(IEncodableRecord) class Record_AFSDB(tputil.FancyStrMixin, tputil.FancyEqMixin): """ Map from a domain name to the name of an AFS cell database server. @type subtype: L{int} @ivar subtype: In the case of subtype 1, the host has an AFS version 3.0 Volume Location Server for the named AFS cell. In the case of subtype 2, the host has an authenticated name server holding the cell-root directory node for the named DCE/NCA cell. @type hostname: L{Name} @ivar hostname: The domain name of a host that has a server for the cell named by this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1183.html} """ TYPE = AFSDB fancybasename = "AFSDB" compareAttributes = ("subtype", "hostname", "ttl") showAttributes = ("subtype", ("hostname", "hostname", "%s"), "ttl") def __init__(self, subtype=0, hostname=b"", ttl=None): """ @param hostname: See L{Record_AFSDB.hostname} @type hostname: L{bytes} or L{str} """ self.subtype = int(subtype) self.hostname = Name(hostname) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!H", self.subtype)) self.hostname.encode(strio, compDict) def decode(self, strio, length=None): r = struct.unpack("!H", readPrecisely(strio, struct.calcsize("!H"))) (self.subtype,) = r self.hostname.decode(strio) def __hash__(self): return hash((self.subtype, self.hostname)) @implementer(IEncodableRecord) class Record_RP(tputil.FancyEqMixin, tputil.FancyStrMixin): """ The responsible person for a domain. @type mbox: L{Name} @ivar mbox: A domain name that specifies the mailbox for the responsible person. @type txt: L{Name} @ivar txt: A domain name for which TXT RR's exist (indirection through which allows information sharing about the contents of this RP record). @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @see: U{http://www.faqs.org/rfcs/rfc1183.html} """ TYPE = RP fancybasename = "RP" compareAttributes = ("mbox", "txt", "ttl") showAttributes = (("mbox", "mbox", "%s"), ("txt", "txt", "%s"), "ttl") def __init__(self, mbox=b"", txt=b"", ttl=None): """ @param mbox: See L{Record_RP.mbox}. @type mbox: L{bytes} or L{str} @param txt: See L{Record_RP.txt} @type txt: L{bytes} or L{str} """ self.mbox = Name(mbox) self.txt = Name(txt) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): self.mbox.encode(strio, compDict) self.txt.encode(strio, compDict) def decode(self, strio, length=None): self.mbox = Name() self.txt = Name() self.mbox.decode(strio) self.txt.decode(strio) def __hash__(self): return hash((self.mbox, self.txt)) @implementer(IEncodableRecord) class Record_HINFO(tputil.FancyStrMixin, tputil.FancyEqMixin): """ Host information. @type cpu: L{bytes} @ivar cpu: Specifies the CPU type. @type os: L{bytes} @ivar os: Specifies the OS. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ TYPE = HINFO fancybasename = "HINFO" showAttributes = (("cpu", _nicebytes), ("os", _nicebytes), "ttl") compareAttributes = ("cpu", "os", "ttl") def __init__(self, cpu=b"", os=b"", ttl=None): self.cpu, self.os = cpu, os self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!B", len(self.cpu)) + self.cpu) strio.write(struct.pack("!B", len(self.os)) + self.os) def decode(self, strio, length=None): cpu = struct.unpack("!B", readPrecisely(strio, 1))[0] self.cpu = readPrecisely(strio, cpu) os = struct.unpack("!B", readPrecisely(strio, 1))[0] self.os = readPrecisely(strio, os) def __eq__(self, other: object) -> bool: if isinstance(other, Record_HINFO): return ( self.os.lower() == other.os.lower() and self.cpu.lower() == other.cpu.lower() and self.ttl == other.ttl ) return NotImplemented def __hash__(self): return hash((self.os.lower(), self.cpu.lower())) @implementer(IEncodableRecord) class Record_MINFO(tputil.FancyEqMixin, tputil.FancyStrMixin): """ Mailbox or mail list information. This is an experimental record type. @type rmailbx: L{Name} @ivar rmailbx: A domain-name which specifies a mailbox which is responsible for the mailing list or mailbox. If this domain name names the root, the owner of the MINFO RR is responsible for itself. @type emailbx: L{Name} @ivar emailbx: A domain-name which specifies a mailbox which is to receive error messages related to the mailing list or mailbox specified by the owner of the MINFO record. If this domain name names the root, errors should be returned to the sender of the message. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ TYPE = MINFO rmailbx = None emailbx = None fancybasename = "MINFO" compareAttributes = ("rmailbx", "emailbx", "ttl") showAttributes = ( ("rmailbx", "responsibility", "%s"), ("emailbx", "errors", "%s"), "ttl", ) def __init__(self, rmailbx=b"", emailbx=b"", ttl=None): """ @param rmailbx: See L{Record_MINFO.rmailbx}. @type rmailbx: L{bytes} or L{str} @param emailbx: See L{Record_MINFO.rmailbx}. @type emailbx: L{bytes} or L{str} """ self.rmailbx, self.emailbx = Name(rmailbx), Name(emailbx) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): self.rmailbx.encode(strio, compDict) self.emailbx.encode(strio, compDict) def decode(self, strio, length=None): self.rmailbx, self.emailbx = Name(), Name() self.rmailbx.decode(strio) self.emailbx.decode(strio) def __hash__(self): return hash((self.rmailbx, self.emailbx)) @implementer(IEncodableRecord) class Record_MX(tputil.FancyStrMixin, tputil.FancyEqMixin): """ Mail exchange. @type preference: L{int} @ivar preference: Specifies the preference given to this RR among others at the same owner. Lower values are preferred. @type name: L{Name} @ivar name: A domain-name which specifies a host willing to act as a mail exchange. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ TYPE = MX fancybasename = "MX" compareAttributes = ("preference", "name", "ttl") showAttributes = ("preference", ("name", "name", "%s"), "ttl") def __init__(self, preference=0, name=b"", ttl=None, **kwargs): """ @param name: See L{Record_MX.name}. @type name: L{bytes} or L{str} """ self.preference = int(preference) self.name = Name(kwargs.get("exchange", name)) self.ttl = str2time(ttl) def encode(self, strio, compDict=None): strio.write(struct.pack("!H", self.preference)) self.name.encode(strio, compDict) def decode(self, strio, length=None): self.preference = struct.unpack("!H", readPrecisely(strio, 2))[0] self.name = Name() self.name.decode(strio) def __hash__(self): return hash((self.preference, self.name)) @implementer(IEncodableRecord) class Record_SSHFP(tputil.FancyEqMixin, tputil.FancyStrMixin): """ A record containing the fingerprint of an SSH key. @type algorithm: L{int} @ivar algorithm: The SSH key's algorithm, such as L{ALGORITHM_RSA}. Note that the numbering used for SSH key algorithms is specific to the SSHFP record, and is not the same as the numbering used for KEY or SIG records. @type fingerprintType: L{int} @ivar fingerprintType: The fingerprint type, such as L{FINGERPRINT_TYPE_SHA256}. @type fingerprint: L{bytes} @ivar fingerprint: The key's fingerprint, e.g. a 32-byte SHA-256 digest. @cvar ALGORITHM_RSA: The algorithm value for C{ssh-rsa} keys. @cvar ALGORITHM_DSS: The algorithm value for C{ssh-dss} keys. @cvar ALGORITHM_ECDSA: The algorithm value for C{ecdsa-sha2-*} keys. @cvar ALGORITHM_Ed25519: The algorithm value for C{ed25519} keys. @cvar FINGERPRINT_TYPE_SHA1: The type for SHA-1 fingerprints. @cvar FINGERPRINT_TYPE_SHA256: The type for SHA-256 fingerprints. @see: U{RFC 4255 <https://tools.ietf.org/html/rfc4255>} and U{RFC 6594 <https://tools.ietf.org/html/rfc6594>} """ fancybasename = "SSHFP" compareAttributes = ("algorithm", "fingerprintType", "fingerprint", "ttl") showAttributes = ("algorithm", "fingerprintType", "fingerprint") TYPE = SSHFP ALGORITHM_RSA = 1 ALGORITHM_DSS = 2 ALGORITHM_ECDSA = 3 ALGORITHM_Ed25519 = 4 FINGERPRINT_TYPE_SHA1 = 1 FINGERPRINT_TYPE_SHA256 = 2 def __init__(self, algorithm=0, fingerprintType=0, fingerprint=b"", ttl=0): self.algorithm = algorithm self.fingerprintType = fingerprintType self.fingerprint = fingerprint self.ttl = ttl def encode(self, strio, compDict=None): strio.write(struct.pack("!BB", self.algorithm, self.fingerprintType)) strio.write(self.fingerprint) def decode(self, strio, length=None): r = struct.unpack("!BB", readPrecisely(strio, 2)) (self.algorithm, self.fingerprintType) = r self.fingerprint = readPrecisely(strio, length - 2) def __hash__(self): return hash((self.algorithm, self.fingerprintType, self.fingerprint)) @implementer(IEncodableRecord) class Record_TXT(tputil.FancyEqMixin, tputil.FancyStrMixin): """ Freeform text. @type data: L{list} of L{bytes} @ivar data: Freeform text which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ TYPE = TXT fancybasename = "TXT" showAttributes = (("data", _nicebyteslist), "ttl") compareAttributes = ("data", "ttl") def __init__(self, *data, **kw): self.data = list(data) # arg man python sucks so bad self.ttl = str2time(kw.get("ttl", None)) def encode(self, strio, compDict=None): for d in self.data: strio.write(struct.pack("!B", len(d)) + d) def decode(self, strio, length=None): soFar = 0 self.data = [] while soFar < length: L = struct.unpack("!B", readPrecisely(strio, 1))[0] self.data.append(readPrecisely(strio, L)) soFar += L + 1 if soFar != length: log.msg( "Decoded %d bytes in %s record, but rdlength is %d" % (soFar, self.fancybasename, length) ) def __hash__(self): return hash(tuple(self.data)) @implementer(IEncodableRecord) class UnknownRecord(tputil.FancyEqMixin, tputil.FancyStrMixin): """ Encapsulate the wire data for unknown record types so that they can pass through the system unchanged. @type data: L{bytes} @ivar data: Wire data which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. @since: 11.1 """ TYPE = None fancybasename = "UNKNOWN" compareAttributes = ("data", "ttl") showAttributes = (("data", _nicebytes), "ttl") def __init__(self, data=b"", ttl=None): self.data = data self.ttl = str2time(ttl) def encode(self, strio, compDict=None): """ Write the raw bytes corresponding to this record's payload to the stream. """ strio.write(self.data) def decode(self, strio, length=None): """ Load the bytes which are part of this record from the stream and store them unparsed and unmodified. """ if length is None: raise Exception("must know length for unknown record types") self.data = readPrecisely(strio, length) def __hash__(self): return hash((self.data, self.ttl)) class Record_SPF(Record_TXT): """ Structurally, freeform text. Semantically, a policy definition, formatted as defined in U{rfc 4408<http://www.faqs.org/rfcs/rfc4408.html>}. @type data: L{list} of L{bytes} @ivar data: Freeform text which makes up this record. @type ttl: L{int} @ivar ttl: The maximum number of seconds which this record should be cached. """ TYPE = SPF fancybasename = "SPF" @implementer(IEncodableRecord) class Record_TSIG(tputil.FancyEqMixin, tputil.FancyStrMixin): """ A transaction signature, encapsulated in a RR, as described in U{RFC 2845 <https://tools.ietf.org/html/rfc2845>}. @type algorithm: L{Name} @ivar algorithm: The name of the signature or MAC algorithm. @type timeSigned: L{int} @ivar timeSigned: Signing time, as seconds from the POSIX epoch. @type fudge: L{int} @ivar fudge: Allowable time skew, in seconds. @type MAC: L{bytes} @ivar MAC: The message digest or signature. @type originalID: L{int} @ivar originalID: A message ID. @type error: L{int} @ivar error: An error code (extended C{RCODE}) carried in exceptional cases. @type otherData: L{bytes} @ivar otherData: Other data carried in exceptional cases. """ fancybasename = "TSIG" compareAttributes = ( "algorithm", "timeSigned", "fudge", "MAC", "originalID", "error", "otherData", "ttl", ) showAttributes = ["algorithm", "timeSigned", "MAC", "error", "otherData"] TYPE = TSIG def __init__( self, algorithm=None, timeSigned=None, fudge=5, MAC=None, originalID=0, error=OK, otherData=b"", ttl=0, ): # All of our init arguments have to have defaults, because of # the way IEncodable and Message.parseRecords() work, but for # some of our arguments there is no reasonable default; we use # invalid values here to prevent a user of this class from # relying on what's really an internal implementation detail. self.algorithm = None if algorithm is None else Name(algorithm) self.timeSigned = timeSigned self.fudge = str2time(fudge) self.MAC = MAC self.originalID = originalID self.error = error self.otherData = otherData self.ttl = ttl def encode(self, strio, compDict=None): self.algorithm.encode(strio, compDict) strio.write(struct.pack("!Q", self.timeSigned)[2:]) # 48-bit number strio.write(struct.pack("!HH", self.fudge, len(self.MAC))) strio.write(self.MAC) strio.write( struct.pack("!HHH", self.originalID, self.error, len(self.otherData)) ) strio.write(self.otherData) def decode(self, strio, length=None): algorithm = Name() algorithm.decode(strio) self.algorithm = algorithm fields = struct.unpack("!QHH", b"\x00\x00" + readPrecisely(strio, 10)) self.timeSigned, self.fudge, macLength = fields self.MAC = readPrecisely(strio, macLength) fields = struct.unpack("!HHH", readPrecisely(strio, 6)) self.originalID, self.error, otherLength = fields self.otherData = readPrecisely(strio, otherLength) def __hash__(self): return hash((self.algorithm, self.timeSigned, self.MAC, self.originalID)) def _responseFromMessage(responseConstructor, message, **kwargs): """ Generate a L{Message} like instance suitable for use as the response to C{message}. The C{queries}, C{id} attributes will be copied from C{message} and the C{answer} flag will be set to L{True}. @param responseConstructor: A response message constructor with an initializer signature matching L{dns.Message.__init__}. @type responseConstructor: C{callable} @param message: A request message. @type message: L{Message} @param kwargs: Keyword arguments which will be passed to the initialiser of the response message. @type kwargs: L{dict} @return: A L{Message} like response instance. @rtype: C{responseConstructor} """ response = responseConstructor(id=message.id, answer=True, **kwargs) response.queries = message.queries[:] return response def _getDisplayableArguments(obj, alwaysShow, fieldNames): """ Inspect the function signature of C{obj}'s constructor, and get a list of which arguments should be displayed. This is a helper function for C{_compactRepr}. @param obj: The instance whose repr is being generated. @param alwaysShow: A L{list} of field names which should always be shown. @param fieldNames: A L{list} of field attribute names which should be shown if they have non-default values. @return: A L{list} of displayable arguments. """ displayableArgs = [] # Get the argument names and values from the constructor. signature = inspect.signature(obj.__class__.__init__) for name in fieldNames: defaultValue = signature.parameters[name].default fieldValue = getattr(obj, name, defaultValue) if (name in alwaysShow) or (fieldValue != defaultValue): displayableArgs.append(f" {name}={fieldValue!r}") return displayableArgs def _compactRepr( obj, alwaysShow=None, flagNames=None, fieldNames=None, sectionNames=None ): """ Return a L{str} representation of C{obj} which only shows fields with non-default values, flags which are True and sections which have been explicitly set. @param obj: The instance whose repr is being generated. @param alwaysShow: A L{list} of field names which should always be shown. @param flagNames: A L{list} of flag attribute names which should be shown if they are L{True}. @param fieldNames: A L{list} of field attribute names which should be shown if they have non-default values. @param sectionNames: A L{list} of section attribute names which should be shown if they have been assigned a value. @return: A L{str} representation of C{obj}. """ if alwaysShow is None: alwaysShow = [] if flagNames is None: flagNames = [] if fieldNames is None: fieldNames = [] if sectionNames is None: sectionNames = [] setFlags = [] for name in flagNames: if name in alwaysShow or getattr(obj, name, False) == True: setFlags.append(name) displayableArgs = _getDisplayableArguments(obj, alwaysShow, fieldNames) out = ["<", obj.__class__.__name__] + displayableArgs if setFlags: out.append(" flags={}".format(",".join(setFlags))) for name in sectionNames: section = getattr(obj, name, []) if section: out.append(f" {name}={section!r}") out.append(">") return "".join(out) class Message(tputil.FancyEqMixin): """ L{Message} contains all the information represented by a single DNS request or response. @ivar id: See L{__init__} @ivar answer: See L{__init__} @ivar opCode: See L{__init__} @ivar recDes: See L{__init__} @ivar recAv: See L{__init__} @ivar auth: See L{__init__} @ivar rCode: See L{__init__} @ivar trunc: See L{__init__} @ivar maxSize: See L{__init__} @ivar authenticData: See L{__init__} @ivar checkingDisabled: See L{__init__} @ivar queries: The queries which are being asked of or answered by DNS server. @type queries: L{list} of L{Query} @ivar answers: Records containing the answers to C{queries} if this is a response message. @type answers: L{list} of L{RRHeader} @ivar authority: Records containing information about the authoritative DNS servers for the names in C{queries}. @type authority: L{list} of L{RRHeader} @ivar additional: Records containing IP addresses of host names in C{answers} and C{authority}. @type additional: L{list} of L{RRHeader} @ivar _flagNames: The names of attributes representing the flag header fields. @ivar _fieldNames: The names of attributes representing non-flag fixed header fields. @ivar _sectionNames: The names of attributes representing the record sections of this message. """ compareAttributes = ( "id", "answer", "opCode", "recDes", "recAv", "auth", "rCode", "trunc", "maxSize", "authenticData", "checkingDisabled", "queries", "answers", "authority", "additional", ) headerFmt = "!H2B4H" headerSize = struct.calcsize(headerFmt) # Question, answer, additional, and nameserver lists queries = answers = add = ns = None def __init__( self, id=0, answer=0, opCode=0, recDes=0, recAv=0, auth=0, rCode=OK, trunc=0, maxSize=512, authenticData=0, checkingDisabled=0, ): """ @param id: A 16 bit identifier assigned by the program that generates any kind of query. This identifier is copied to the corresponding reply and can be used by the requester to match up replies to outstanding queries. @type id: L{int} @param answer: A one bit field that specifies whether this message is a query (0), or a response (1). @type answer: L{int} @param opCode: A four bit field that specifies kind of query in this message. This value is set by the originator of a query and copied into the response. @type opCode: L{int} @param recDes: Recursion Desired - this bit may be set in a query and is copied into the response. If RD is set, it directs the name server to pursue the query recursively. Recursive query support is optional. @type recDes: L{int} @param recAv: Recursion Available - this bit is set or cleared in a response and denotes whether recursive query support is available in the name server. @type recAv: L{int} @param auth: Authoritative Answer - this bit is valid in responses and specifies that the responding name server is an authority for the domain name in question section. @type auth: L{int} @ivar rCode: A response code, used to indicate success or failure in a message which is a response from a server to a client request. @type rCode: C{0 <= int < 16} @param trunc: A flag indicating that this message was truncated due to length greater than that permitted on the transmission channel. @type trunc: L{int} @param maxSize: The requestor's UDP payload size is the number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type maxSize: L{int} @param authenticData: A flag indicating in a response that all the data included in the answer and authority portion of the response has been authenticated by the server according to the policies of that server. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{int} @param checkingDisabled: A flag indicating in a query that pending (non-authenticated) data is acceptable to the resolver sending the query. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{int} """ self.maxSize = maxSize self.id = id self.answer = answer self.opCode = opCode self.auth = auth self.trunc = trunc self.recDes = recDes self.recAv = recAv self.rCode = rCode self.authenticData = authenticData self.checkingDisabled = checkingDisabled self.queries = [] self.answers = [] self.authority = [] self.additional = [] def __repr__(self) -> str: """ Generate a repr of this L{Message}. Only includes the non-default fields and sections and only includes flags which are set. The C{id} is always shown. @return: The native string repr. """ return _compactRepr( self, flagNames=( "answer", "auth", "trunc", "recDes", "recAv", "authenticData", "checkingDisabled", ), fieldNames=("id", "opCode", "rCode", "maxSize"), sectionNames=("queries", "answers", "authority", "additional"), alwaysShow=("id",), ) def addQuery(self, name, type=ALL_RECORDS, cls=IN): """ Add another query to this Message. @type name: L{bytes} @param name: The name to query. @type type: L{int} @param type: Query type @type cls: L{int} @param cls: Query class """ self.queries.append(Query(name, type, cls)) def encode(self, strio): compDict = {} body_tmp = BytesIO() for q in self.queries: q.encode(body_tmp, compDict) for q in self.answers: q.encode(body_tmp, compDict) for q in self.authority: q.encode(body_tmp, compDict) for q in self.additional: q.encode(body_tmp, compDict) body = body_tmp.getvalue() size = len(body) + self.headerSize if self.maxSize and size > self.maxSize: self.trunc = 1 body = body[: self.maxSize - self.headerSize] byte3 = ( ((self.answer & 1) << 7) | ((self.opCode & 0xF) << 3) | ((self.auth & 1) << 2) | ((self.trunc & 1) << 1) | (self.recDes & 1) ) byte4 = ( ((self.recAv & 1) << 7) | ((self.authenticData & 1) << 5) | ((self.checkingDisabled & 1) << 4) | (self.rCode & 0xF) ) strio.write( struct.pack( self.headerFmt, self.id, byte3, byte4, len(self.queries), len(self.answers), len(self.authority), len(self.additional), ) ) strio.write(body) def decode(self, strio, length=None): self.maxSize = 0 header = readPrecisely(strio, self.headerSize) r = struct.unpack(self.headerFmt, header) self.id, byte3, byte4, nqueries, nans, nns, nadd = r self.answer = (byte3 >> 7) & 1 self.opCode = (byte3 >> 3) & 0xF self.auth = (byte3 >> 2) & 1 self.trunc = (byte3 >> 1) & 1 self.recDes = byte3 & 1 self.recAv = (byte4 >> 7) & 1 self.authenticData = (byte4 >> 5) & 1 self.checkingDisabled = (byte4 >> 4) & 1 self.rCode = byte4 & 0xF self.queries = [] for i in range(nqueries): q = Query() try: q.decode(strio) except EOFError: return self.queries.append(q) items = ((self.answers, nans), (self.authority, nns), (self.additional, nadd)) for (l, n) in items: self.parseRecords(l, n, strio) def parseRecords(self, list, num, strio): for i in range(num): header = RRHeader(auth=self.auth) try: header.decode(strio) except EOFError: return t = self.lookupRecordType(header.type) if not t: continue header.payload = t(ttl=header.ttl) try: header.payload.decode(strio, header.rdlength) except EOFError: return list.append(header) # Create a mapping from record types to their corresponding Record_* # classes. This relies on the global state which has been created so # far in initializing this module (so don't define Record classes after # this). _recordTypes = {} for name in globals(): if name.startswith("Record_"): _recordTypes[globals()[name].TYPE] = globals()[name] # Clear the iteration variable out of the class namespace so it # doesn't become an attribute. del name def lookupRecordType(self, type): """ Retrieve the L{IRecord} implementation for the given record type. @param type: A record type, such as C{A} or L{NS}. @type type: L{int} @return: An object which implements L{IRecord} or L{None} if none can be found for the given type. @rtype: C{Type[IRecord]} """ return self._recordTypes.get(type, UnknownRecord) def toStr(self): """ Encode this L{Message} into a byte string in the format described by RFC 1035. @rtype: L{bytes} """ strio = BytesIO() self.encode(strio) return strio.getvalue() def fromStr(self, str): """ Decode a byte string in the format described by RFC 1035 into this L{Message}. @param str: L{bytes} """ strio = BytesIO(str) self.decode(strio) class _EDNSMessage(tputil.FancyEqMixin): """ An I{EDNS} message. Designed for compatibility with L{Message} but with a narrower public interface. Most importantly, L{_EDNSMessage.fromStr} will interpret and remove I{OPT} records that are present in the additional records section. The I{OPT} records are used to populate certain I{EDNS} specific attributes. L{_EDNSMessage.toStr} will add suitable I{OPT} records to the additional section to represent the extended EDNS information. @see: U{https://tools.ietf.org/html/rfc6891} @ivar id: See L{__init__} @ivar answer: See L{__init__} @ivar opCode: See L{__init__} @ivar auth: See L{__init__} @ivar trunc: See L{__init__} @ivar recDes: See L{__init__} @ivar recAv: See L{__init__} @ivar rCode: See L{__init__} @ivar ednsVersion: See L{__init__} @ivar dnssecOK: See L{__init__} @ivar authenticData: See L{__init__} @ivar checkingDisabled: See L{__init__} @ivar maxSize: See L{__init__} @ivar queries: See L{__init__} @ivar answers: See L{__init__} @ivar authority: See L{__init__} @ivar additional: See L{__init__} @ivar _messageFactory: A constructor of L{Message} instances. Called by C{_toMessage} and C{_fromMessage}. """ compareAttributes = ( "id", "answer", "opCode", "auth", "trunc", "recDes", "recAv", "rCode", "ednsVersion", "dnssecOK", "authenticData", "checkingDisabled", "maxSize", "queries", "answers", "authority", "additional", ) _messageFactory = Message def __init__( self, id=0, answer=False, opCode=OP_QUERY, auth=False, trunc=False, recDes=False, recAv=False, rCode=0, ednsVersion=0, dnssecOK=False, authenticData=False, checkingDisabled=False, maxSize=512, queries=None, answers=None, authority=None, additional=None, ): """ Construct a new L{_EDNSMessage} @see: U{RFC1035 section-4.1.1<https://tools.ietf.org/html/rfc1035#section-4.1.1>} @see: U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>} @see: U{RFC3225 section-3<https://tools.ietf.org/html/rfc3225#section-3>} @see: U{RFC6891 section-6.1.3<https://tools.ietf.org/html/rfc6891#section-6.1.3>} @param id: A 16 bit identifier assigned by the program that generates any kind of query. This identifier is copied the corresponding reply and can be used by the requester to match up replies to outstanding queries. @type id: L{int} @param answer: A one bit field that specifies whether this message is a query (0), or a response (1). @type answer: L{bool} @param opCode: A four bit field that specifies kind of query in this message. This value is set by the originator of a query and copied into the response. @type opCode: L{int} @param auth: Authoritative Answer - this bit is valid in responses, and specifies that the responding name server is an authority for the domain name in question section. @type auth: L{bool} @param trunc: Truncation - specifies that this message was truncated due to length greater than that permitted on the transmission channel. @type trunc: L{bool} @param recDes: Recursion Desired - this bit may be set in a query and is copied into the response. If set, it directs the name server to pursue the query recursively. Recursive query support is optional. @type recDes: L{bool} @param recAv: Recursion Available - this bit is set or cleared in a response, and denotes whether recursive query support is available in the name server. @type recAv: L{bool} @param rCode: Extended 12-bit RCODE. Derived from the 4 bits defined in U{RFC1035 4.1.1<https://tools.ietf.org/html/rfc1035#section-4.1.1>} and the upper 8bits defined in U{RFC6891 6.1.3<https://tools.ietf.org/html/rfc6891#section-6.1.3>}. @type rCode: L{int} @param ednsVersion: Indicates the EDNS implementation level. Set to L{None} to prevent any EDNS attributes and options being added to the encoded byte string. @type ednsVersion: L{int} or L{None} @param dnssecOK: DNSSEC OK bit as defined by U{RFC3225 3<https://tools.ietf.org/html/rfc3225#section-3>}. @type dnssecOK: L{bool} @param authenticData: A flag indicating in a response that all the data included in the answer and authority portion of the response has been authenticated by the server according to the policies of that server. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{bool} @param checkingDisabled: A flag indicating in a query that pending (non-authenticated) data is acceptable to the resolver sending the query. See U{RFC2535 section-6.1<https://tools.ietf.org/html/rfc2535#section-6.1>}. @type authenticData: L{bool} @param maxSize: The requestor's UDP payload size is the number of octets of the largest UDP payload that can be reassembled and delivered in the requestor's network stack. @type maxSize: L{int} @param queries: The L{list} of L{Query} associated with this message. @type queries: L{list} of L{Query} @param answers: The L{list} of answers associated with this message. @type answers: L{list} of L{RRHeader} @param authority: The L{list} of authority records associated with this message. @type authority: L{list} of L{RRHeader} @param additional: The L{list} of additional records associated with this message. @type additional: L{list} of L{RRHeader} """ self.id = id self.answer = answer self.opCode = opCode self.auth = auth self.trunc = trunc self.recDes = recDes self.recAv = recAv self.rCode = rCode self.ednsVersion = ednsVersion self.dnssecOK = dnssecOK self.authenticData = authenticData self.checkingDisabled = checkingDisabled self.maxSize = maxSize if queries is None: queries = [] self.queries = queries if answers is None: answers = [] self.answers = answers if authority is None: authority = [] self.authority = authority if additional is None: additional = [] self.additional = additional def __repr__(self) -> str: return _compactRepr( self, flagNames=( "answer", "auth", "trunc", "recDes", "recAv", "authenticData", "checkingDisabled", "dnssecOK", ), fieldNames=("id", "opCode", "rCode", "maxSize", "ednsVersion"), sectionNames=("queries", "answers", "authority", "additional"), alwaysShow=("id",), ) def _toMessage(self): """ Convert to a standard L{dns.Message}. If C{ednsVersion} is not None, an L{_OPTHeader} instance containing all the I{EDNS} specific attributes and options will be appended to the list of C{additional} records. @return: A L{dns.Message} @rtype: L{dns.Message} """ m = self._messageFactory( id=self.id, answer=self.answer, opCode=self.opCode, auth=self.auth, trunc=self.trunc, recDes=self.recDes, recAv=self.recAv, # Assign the lower 4 bits to the message rCode=self.rCode & 0xF, authenticData=self.authenticData, checkingDisabled=self.checkingDisabled, ) m.queries = self.queries[:] m.answers = self.answers[:] m.authority = self.authority[:] m.additional = self.additional[:] if self.ednsVersion is not None: o = _OPTHeader( version=self.ednsVersion, dnssecOK=self.dnssecOK, udpPayloadSize=self.maxSize, # Assign the upper 8 bits to the OPT record extendedRCODE=self.rCode >> 4, ) m.additional.append(o) return m def toStr(self): """ Encode to wire format by first converting to a standard L{dns.Message}. @return: A L{bytes} string. """ return self._toMessage().toStr() @classmethod def _fromMessage(cls, message): """ Construct and return a new L{_EDNSMessage} whose attributes and records are derived from the attributes and records of C{message} (a L{Message} instance). If present, an C{OPT} record will be extracted from the C{additional} section and its attributes and options will be used to set the EDNS specific attributes C{extendedRCODE}, C{ednsVersion}, C{dnssecOK}, C{ednsOptions}. The C{extendedRCODE} will be combined with C{message.rCode} and assigned to C{self.rCode}. @param message: The source L{Message}. @type message: L{Message} @return: A new L{_EDNSMessage} @rtype: L{_EDNSMessage} """ additional = [] optRecords = [] for r in message.additional: if r.type == OPT: optRecords.append(_OPTHeader.fromRRHeader(r)) else: additional.append(r) newMessage = cls( id=message.id, answer=message.answer, opCode=message.opCode, auth=message.auth, trunc=message.trunc, recDes=message.recDes, recAv=message.recAv, rCode=message.rCode, authenticData=message.authenticData, checkingDisabled=message.checkingDisabled, # Default to None, it will be updated later when the OPT records are # parsed. ednsVersion=None, dnssecOK=False, queries=message.queries[:], answers=message.answers[:], authority=message.authority[:], additional=additional, ) if len(optRecords) == 1: # XXX: If multiple OPT records are received, an EDNS server should # respond with FORMERR. See ticket:5669#comment:1. opt = optRecords[0] newMessage.ednsVersion = opt.version newMessage.dnssecOK = opt.dnssecOK newMessage.maxSize = opt.udpPayloadSize newMessage.rCode = opt.extendedRCODE << 4 | message.rCode return newMessage def fromStr(self, bytes): """ Decode from wire format, saving flags, values and records to this L{_EDNSMessage} instance in place. @param bytes: The full byte string to be decoded. @type bytes: L{bytes} """ m = self._messageFactory() m.fromStr(bytes) ednsMessage = self._fromMessage(m) for attrName in self.compareAttributes: setattr(self, attrName, getattr(ednsMessage, attrName)) class DNSMixin: """ DNS protocol mixin shared by UDP and TCP implementations. @ivar _reactor: A L{IReactorTime} and L{IReactorUDP} provider which will be used to issue DNS queries and manage request timeouts. """ id = None liveMessages = None def __init__(self, controller, reactor=None): self.controller = controller self.id = random.randrange(2 ** 10, 2 ** 15) if reactor is None: from twisted.internet import reactor self._reactor = reactor def pickID(self): """ Return a unique ID for queries. """ while True: id = randomSource() if id not in self.liveMessages: return id def callLater(self, period, func, *args): """ Wrapper around reactor.callLater, mainly for test purpose. """ return self._reactor.callLater(period, func, *args) def _query(self, queries, timeout, id, writeMessage): """ Send out a message with the given queries. @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @type timeout: L{int} or C{float} @param timeout: How long to wait before giving up @type id: L{int} @param id: Unique key for this request @type writeMessage: C{callable} @param writeMessage: One-parameter callback which writes the message @rtype: C{Deferred} @return: a C{Deferred} which will be fired with the result of the query, or errbacked with any errors that could happen (exceptions during writing of the query, timeout errors, ...). """ m = Message(id, recDes=1) m.queries = queries try: writeMessage(m) except BaseException: return defer.fail() resultDeferred = defer.Deferred() cancelCall = self.callLater(timeout, self._clearFailed, resultDeferred, id) self.liveMessages[id] = (resultDeferred, cancelCall) return resultDeferred def _clearFailed(self, deferred, id): """ Clean the Deferred after a timeout. """ try: del self.liveMessages[id] except KeyError: pass deferred.errback(failure.Failure(DNSQueryTimeoutError(id))) class DNSDatagramProtocol(DNSMixin, protocol.DatagramProtocol): """ DNS protocol over UDP. """ resends = None def stopProtocol(self): """ Stop protocol: reset state variables. """ self.liveMessages = {} self.resends = {} self.transport = None def startProtocol(self): """ Upon start, reset internal state. """ self.liveMessages = {} self.resends = {} def writeMessage(self, message, address): """ Send a message holding DNS queries. @type message: L{Message} """ self.transport.write(message.toStr(), address) def startListening(self): self._reactor.listenUDP(0, self, maxPacketSize=512) def datagramReceived(self, data, addr): """ Read a datagram, extract the message in it and trigger the associated Deferred. """ m = Message() try: m.fromStr(data) except EOFError: log.msg("Truncated packet (%d bytes) from %s" % (len(data), addr)) return except BaseException: # Nothing should trigger this, but since we're potentially # invoking a lot of different decoding methods, we might as well # be extra cautious. Anything that triggers this is itself # buggy. log.err(failure.Failure(), "Unexpected decoding error") return if m.id in self.liveMessages: d, canceller = self.liveMessages[m.id] del self.liveMessages[m.id] canceller.cancel() # XXX we shouldn't need this hack of catching exception on callback() try: d.callback(m) except BaseException: log.err() else: if m.id not in self.resends: self.controller.messageReceived(m, self, addr) def removeResend(self, id): """ Mark message ID as no longer having duplication suppression. """ try: del self.resends[id] except KeyError: pass def query(self, address, queries, timeout=10, id=None): """ Send out a message with the given queries. @type address: L{tuple} of L{str} and L{int} @param address: The address to which to send the query @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @rtype: C{Deferred} """ if not self.transport: # XXX transport might not get created automatically, use callLater? try: self.startListening() except CannotListenError: return defer.fail() if id is None: id = self.pickID() else: self.resends[id] = 1 def writeMessage(m): self.writeMessage(m, address) return self._query(queries, timeout, id, writeMessage) class DNSProtocol(DNSMixin, protocol.Protocol): """ DNS protocol over TCP. """ length = None buffer = b"" def writeMessage(self, message): """ Send a message holding DNS queries. @type message: L{Message} """ s = message.toStr() self.transport.write(struct.pack("!H", len(s)) + s) def connectionMade(self): """ Connection is made: reset internal state, and notify the controller. """ self.liveMessages = {} self.controller.connectionMade(self) def connectionLost(self, reason): """ Notify the controller that this protocol is no longer connected. """ self.controller.connectionLost(self) def dataReceived(self, data): self.buffer += data while self.buffer: if self.length is None and len(self.buffer) >= 2: self.length = struct.unpack("!H", self.buffer[:2])[0] self.buffer = self.buffer[2:] if len(self.buffer) >= self.length: myChunk = self.buffer[: self.length] m = Message() m.fromStr(myChunk) try: d, canceller = self.liveMessages[m.id] except KeyError: self.controller.messageReceived(m, self) else: del self.liveMessages[m.id] canceller.cancel() # XXX we shouldn't need this hack try: d.callback(m) except BaseException: log.err() self.buffer = self.buffer[self.length :] self.length = None else: break def query(self, queries, timeout=60): """ Send out a message with the given queries. @type queries: L{list} of C{Query} instances @param queries: The queries to transmit @rtype: C{Deferred} """ id = self.pickID() return self._query(queries, timeout, id, self.writeMessage) PK Mb�Z�!��+A +A names/authority.pynu �[��� # -*- test-case-name: twisted.names.test.test_names -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Authoritative resolvers. """ import os import time from twisted.internet import defer from twisted.names import common, dns, error from twisted.python import failure from twisted.python.compat import execfile, nativeString from twisted.python.filepath import FilePath def getSerial(filename="/tmp/twisted-names.serial"): """ Return a monotonically increasing (across program runs) integer. State is stored in the given file. If it does not exist, it is created with rw-/---/--- permissions. This manipulates process-global state by calling C{os.umask()}, so it isn't thread-safe. @param filename: Path to a file that is used to store the state across program runs. @type filename: L{str} @return: a monotonically increasing number @rtype: L{str} """ serial = time.strftime("%Y%m%d") o = os.umask(0o177) try: if not os.path.exists(filename): with open(filename, "w") as f: f.write(serial + " 0") finally: os.umask(o) with open(filename) as serialFile: lastSerial, zoneID = serialFile.readline().split() zoneID = (lastSerial == serial) and (int(zoneID) + 1) or 0 with open(filename, "w") as serialFile: serialFile.write("%s %d" % (serial, zoneID)) serial = serial + ("%02d" % (zoneID,)) return serial class FileAuthority(common.ResolverBase): """ An Authority that is loaded from a file. This is an abstract class that implements record search logic. To create a functional resolver, subclass it and override the L{loadFile} method. @ivar _ADDITIONAL_PROCESSING_TYPES: Record types for which additional processing will be done. @ivar _ADDRESS_TYPES: Record types which are useful for inclusion in the additional section generated during additional processing. @ivar soa: A 2-tuple containing the SOA domain name as a L{bytes} and a L{dns.Record_SOA}. @ivar records: A mapping of domains (as lowercased L{bytes}) to records. @type records: L{dict} with L{bytes} keys """ # See https://twistedmatrix.com/trac/ticket/6650 _ADDITIONAL_PROCESSING_TYPES = (dns.CNAME, dns.MX, dns.NS) _ADDRESS_TYPES = (dns.A, dns.AAAA) soa = None records = None def __init__(self, filename): common.ResolverBase.__init__(self) self.loadFile(filename) self._cache = {} def __setstate__(self, state): self.__dict__ = state def loadFile(self, filename): """ Load DNS records from a file. This method populates the I{soa} and I{records} attributes. It must be overridden in a subclass. It is called once from the initializer. @param filename: The I{filename} parameter that was passed to the initilizer. @returns: L{None} -- the return value is ignored """ def _additionalRecords(self, answer, authority, ttl): """ Find locally known information that could be useful to the consumer of the response and construct appropriate records to include in the I{additional} section of that response. Essentially, implement RFC 1034 section 4.3.2 step 6. @param answer: A L{list} of the records which will be included in the I{answer} section of the response. @param authority: A L{list} of the records which will be included in the I{authority} section of the response. @param ttl: The default TTL for records for which this is not otherwise specified. @return: A generator of L{dns.RRHeader} instances for inclusion in the I{additional} section. These instances represent extra information about the records in C{answer} and C{authority}. """ for record in answer + authority: if record.type in self._ADDITIONAL_PROCESSING_TYPES: name = record.payload.name.name for rec in self.records.get(name.lower(), ()): if rec.TYPE in self._ADDRESS_TYPES: yield dns.RRHeader( name, rec.TYPE, dns.IN, rec.ttl or ttl, rec, auth=True ) def _lookup(self, name, cls, type, timeout=None): """ Determine a response to a particular DNS query. @param name: The name which is being queried and for which to lookup a response. @type name: L{bytes} @param cls: The class which is being queried. Only I{IN} is implemented here and this value is presently disregarded. @type cls: L{int} @param type: The type of records being queried. See the types defined in L{twisted.names.dns}. @type type: L{int} @param timeout: All processing is done locally and a result is available immediately, so the timeout value is ignored. @return: A L{Deferred} that fires with a L{tuple} of three sets of response records (to comprise the I{answer}, I{authority}, and I{additional} sections of a DNS response) or with a L{Failure} if there is a problem processing the query. """ cnames = [] results = [] authority = [] additional = [] default_ttl = max(self.soa[1].minimum, self.soa[1].expire) domain_records = self.records.get(name.lower()) if domain_records: for record in domain_records: if record.ttl is not None: ttl = record.ttl else: ttl = default_ttl if record.TYPE == dns.NS and name.lower() != self.soa[0].lower(): # NS record belong to a child zone: this is a referral. As # NS records are authoritative in the child zone, ours here # are not. RFC 2181, section 6.1. authority.append( dns.RRHeader(name, record.TYPE, dns.IN, ttl, record, auth=False) ) elif record.TYPE == type or type == dns.ALL_RECORDS: results.append( dns.RRHeader(name, record.TYPE, dns.IN, ttl, record, auth=True) ) if record.TYPE == dns.CNAME: cnames.append( dns.RRHeader(name, record.TYPE, dns.IN, ttl, record, auth=True) ) if not results: results = cnames # Sort of https://tools.ietf.org/html/rfc1034#section-4.3.2 . # See https://twistedmatrix.com/trac/ticket/6732 additionalInformation = self._additionalRecords( results, authority, default_ttl ) if cnames: results.extend(additionalInformation) else: additional.extend(additionalInformation) if not results and not authority: # Empty response. Include SOA record to allow clients to cache # this response. RFC 1034, sections 3.7 and 4.3.4, and RFC 2181 # section 7.1. authority.append( dns.RRHeader( self.soa[0], dns.SOA, dns.IN, ttl, self.soa[1], auth=True ) ) return defer.succeed((results, authority, additional)) else: if dns._isSubdomainOf(name, self.soa[0]): # We may be the authority and we didn't find it. # XXX: The QNAME may also be in a delegated child zone. See # #6581 and #6580 return defer.fail(failure.Failure(dns.AuthoritativeDomainError(name))) else: # The QNAME is not a descendant of this zone. Fail with # DomainError so that the next chained authority or # resolver will be queried. return defer.fail(failure.Failure(error.DomainError(name))) def lookupZone(self, name, timeout=10): name = dns.domainString(name) if self.soa[0].lower() == name.lower(): # Wee hee hee hooo yea default_ttl = max(self.soa[1].minimum, self.soa[1].expire) if self.soa[1].ttl is not None: soa_ttl = self.soa[1].ttl else: soa_ttl = default_ttl results = [ dns.RRHeader( self.soa[0], dns.SOA, dns.IN, soa_ttl, self.soa[1], auth=True ) ] for (k, r) in self.records.items(): for rec in r: if rec.ttl is not None: ttl = rec.ttl else: ttl = default_ttl if rec.TYPE != dns.SOA: results.append( dns.RRHeader(k, rec.TYPE, dns.IN, ttl, rec, auth=True) ) results.append(results[0]) return defer.succeed((results, (), ())) return defer.fail(failure.Failure(dns.DomainError(name))) def _cbAllRecords(self, results): ans, auth, add = [], [], [] for res in results: if res[0]: ans.extend(res[1][0]) auth.extend(res[1][1]) add.extend(res[1][2]) return ans, auth, add class PySourceAuthority(FileAuthority): """ A FileAuthority that is built up from Python source code. """ def loadFile(self, filename): g, l = self.setupConfigNamespace(), {} execfile(filename, g, l) if "zone" not in l: raise ValueError("No zone defined in " + filename) self.records = {} for rr in l["zone"]: if isinstance(rr[1], dns.Record_SOA): self.soa = rr self.records.setdefault(rr[0].lower(), []).append(rr[1]) def wrapRecord(self, type): def wrapRecordFunc(name, *arg, **kw): return (dns.domainString(name), type(*arg, **kw)) return wrapRecordFunc def setupConfigNamespace(self): r = {} items = dns.__dict__.keys() for record in [x for x in items if x.startswith("Record_")]: type = getattr(dns, record) f = self.wrapRecord(type) r[record[len("Record_") :]] = f return r class BindAuthority(FileAuthority): """ An Authority that loads U{BIND zone files <https://en.wikipedia.org/wiki/Zone_file>}. Supports only C{$ORIGIN} and C{$TTL} directives. """ def loadFile(self, filename): """ Load records from C{filename}. @param filename: file to read from @type filename: L{bytes} """ fp = FilePath(filename) # Not the best way to set an origin. It can be set using $ORIGIN # though. self.origin = nativeString(fp.basename() + b".") lines = fp.getContent().splitlines(True) lines = self.stripComments(lines) lines = self.collapseContinuations(lines) self.parseLines(lines) def stripComments(self, lines): """ Strip comments from C{lines}. @param lines: lines to work on @type lines: iterable of L{bytes} @return: C{lines} sans comments. """ return ( a.find(b";") == -1 and a or a[: a.find(b";")] for a in [b.strip() for b in lines] ) def collapseContinuations(self, lines): """ Transform multiline statements into single lines. @param lines: lines to work on @type lines: iterable of L{bytes} @return: iterable of continuous lines """ l = [] state = 0 for line in lines: if state == 0: if line.find(b"(") == -1: l.append(line) else: l.append(line[: line.find(b"(")]) state = 1 else: if line.find(b")") != -1: l[-1] += b" " + line[: line.find(b")")] state = 0 else: l[-1] += b" " + line return filter(None, (line.split() for line in l)) def parseLines(self, lines): """ Parse C{lines}. @param lines: lines to work on @type lines: iterable of L{bytes} """ ttl = 60 * 60 * 3 origin = self.origin self.records = {} for line in lines: if line[0] == b"$TTL": ttl = dns.str2time(line[1]) elif line[0] == b"$ORIGIN": origin = line[1] elif line[0] == b"$INCLUDE": raise NotImplementedError("$INCLUDE directive not implemented") elif line[0] == b"$GENERATE": raise NotImplementedError("$GENERATE directive not implemented") else: self.parseRecordLine(origin, ttl, line) # If the origin changed, reflect that within the instance. self.origin = origin def addRecord(self, owner, ttl, type, domain, cls, rdata): """ Add a record to our authority. Expand domain with origin if necessary. @param owner: origin? @type owner: L{bytes} @param ttl: time to live for the record @type ttl: L{int} @param domain: the domain for which the record is to be added @type domain: L{bytes} @param type: record type @type type: L{str} @param cls: record class @type cls: L{str} @param rdata: record data @type rdata: L{list} of L{bytes} """ if not domain.endswith(b"."): domain = domain + b"." + owner[:-1] else: domain = domain[:-1] f = getattr(self, f"class_{cls}", None) if f: f(ttl, type, domain, rdata) else: raise NotImplementedError(f"Record class {cls!r} not supported") def class_IN(self, ttl, type, domain, rdata): """ Simulate a class IN and recurse into the actual class. @param ttl: time to live for the record @type ttl: L{int} @param type: record type @type type: str @param domain: the domain @type domain: bytes @param rdata: @type rdata: bytes """ record = getattr(dns, f"Record_{nativeString(type)}", None) if record: r = record(*rdata) r.ttl = ttl self.records.setdefault(domain.lower(), []).append(r) if type == "SOA": self.soa = (domain, r) else: raise NotImplementedError( f"Record type {nativeString(type)!r} not supported" ) def parseRecordLine(self, origin, ttl, line): """ Parse a C{line} from a zone file respecting C{origin} and C{ttl}. Add resulting records to authority. @param origin: starting point for the zone @type origin: L{bytes} @param ttl: time to live for the record @type ttl: L{int} @param line: zone file line to parse; split by word @type line: L{list} of L{bytes} """ queryClasses = {qc.encode("ascii") for qc in dns.QUERY_CLASSES.values()} queryTypes = {qt.encode("ascii") for qt in dns.QUERY_TYPES.values()} markers = queryClasses | queryTypes cls = b"IN" owner = origin if line[0] == b"@": line = line[1:] owner = origin elif not line[0].isdigit() and line[0] not in markers: owner = line[0] line = line[1:] if line[0].isdigit() or line[0] in markers: domain = owner owner = origin else: domain = line[0] line = line[1:] if line[0] in queryClasses: cls = line[0] line = line[1:] if line[0].isdigit(): ttl = int(line[0]) line = line[1:] elif line[0].isdigit(): ttl = int(line[0]) line = line[1:] if line[0] in queryClasses: cls = line[0] line = line[1:] type = line[0] rdata = line[1:] self.addRecord(owner, ttl, nativeString(type), domain, nativeString(cls), rdata) PK Mb�ZR0-�� � names/cache.pynu �[��� # -*- test-case-name: twisted.names.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ An in-memory caching resolver. """ from twisted.internet import defer from twisted.names import common, dns from twisted.python import failure, log class CacheResolver(common.ResolverBase): """ A resolver that serves records from a local, memory cache. @ivar _reactor: A provider of L{interfaces.IReactorTime}. """ cache = None def __init__(self, cache=None, verbose=0, reactor=None): common.ResolverBase.__init__(self) self.cache = {} self.verbose = verbose self.cancel = {} if reactor is None: from twisted.internet import reactor self._reactor = reactor if cache: for query, (seconds, payload) in cache.items(): self.cacheResult(query, payload, seconds) def __setstate__(self, state): self.__dict__ = state now = self._reactor.seconds() for (k, (when, (ans, add, ns))) in self.cache.items(): diff = now - when for rec in ans + add + ns: if rec.ttl < diff: del self.cache[k] break def __getstate__(self): for c in self.cancel.values(): c.cancel() self.cancel.clear() return self.__dict__ def _lookup(self, name, cls, type, timeout): now = self._reactor.seconds() q = dns.Query(name, type, cls) try: when, (ans, auth, add) = self.cache[q] except KeyError: if self.verbose > 1: log.msg("Cache miss for " + repr(name)) return defer.fail(failure.Failure(dns.DomainError(name))) else: if self.verbose: log.msg("Cache hit for " + repr(name)) diff = now - when try: result = ( [ dns.RRHeader( r.name.name, r.type, r.cls, r.ttl - diff, r.payload ) for r in ans ], [ dns.RRHeader( r.name.name, r.type, r.cls, r.ttl - diff, r.payload ) for r in auth ], [ dns.RRHeader( r.name.name, r.type, r.cls, r.ttl - diff, r.payload ) for r in add ], ) except ValueError: return defer.fail(failure.Failure(dns.DomainError(name))) else: return defer.succeed(result) def lookupAllRecords(self, name, timeout=None): return defer.fail(failure.Failure(dns.DomainError(name))) def cacheResult(self, query, payload, cacheTime=None): """ Cache a DNS entry. @param query: a L{dns.Query} instance. @param payload: a 3-tuple of lists of L{dns.RRHeader} records, the matching result of the query (answers, authority and additional). @param cacheTime: The time (seconds since epoch) at which the entry is considered to have been added to the cache. If L{None} is given, the current time is used. """ if self.verbose > 1: log.msg("Adding %r to cache" % query) self.cache[query] = (cacheTime or self._reactor.seconds(), payload) if query in self.cancel: self.cancel[query].cancel() s = list(payload[0]) + list(payload[1]) + list(payload[2]) if s: m = s[0].ttl for r in s: m = min(m, r.ttl) else: m = 0 self.cancel[query] = self._reactor.callLater(m, self.clearEntry, query) def clearEntry(self, query): del self.cache[query] del self.cancel[query] PK Mb�ZOK�_ �_ names/client.pynu �[��� # -*- test-case-name: twisted.names.test.test_names -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Asynchronous client DNS The functions exposed in this module can be used for asynchronous name resolution and dns queries. If you need to create a resolver with specific requirements, such as needing to do queries against a particular host, the L{createResolver} function will return an C{IResolver}. Future plans: Proper nameserver acquisition on Windows/MacOS, better caching, respect timeouts """ import errno import os import warnings from zope.interface import moduleProvides from twisted.internet import defer, error, interfaces, protocol from twisted.internet.abstract import isIPv6Address from twisted.names import cache, common, dns, hosts as hostsModule, resolve, root from twisted.python import failure, log # Twisted imports from twisted.python.compat import nativeString from twisted.python.filepath import FilePath from twisted.python.runtime import platform moduleProvides(interfaces.IResolver) class Resolver(common.ResolverBase): """ @ivar _waiting: A C{dict} mapping tuple keys of query name/type/class to Deferreds which will be called back with the result of those queries. This is used to avoid issuing the same query more than once in parallel. This is more efficient on the network and helps avoid a "birthday paradox" attack by keeping the number of outstanding requests for a particular query fixed at one instead of allowing the attacker to raise it to an arbitrary number. @ivar _reactor: A provider of L{IReactorTCP}, L{IReactorUDP}, and L{IReactorTime} which will be used to set up network resources and track timeouts. """ index = 0 timeout = None factory = None servers = None dynServers = () pending = None connections = None resolv = None _lastResolvTime = None _resolvReadInterval = 60 def __init__(self, resolv=None, servers=None, timeout=(1, 3, 11, 45), reactor=None): """ Construct a resolver which will query domain name servers listed in the C{resolv.conf(5)}-format file given by C{resolv} as well as those in the given C{servers} list. Servers are queried in a round-robin fashion. If given, C{resolv} is periodically checked for modification and re-parsed if it is noticed to have changed. @type servers: C{list} of C{(str, int)} or L{None} @param servers: If not None, interpreted as a list of (host, port) pairs specifying addresses of domain name servers to attempt to use for this lookup. Host addresses should be in IPv4 dotted-quad form. If specified, overrides C{resolv}. @type resolv: C{str} @param resolv: Filename to read and parse as a resolver(5) configuration file. @type timeout: Sequence of C{int} @param timeout: Default number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @param reactor: A provider of L{IReactorTime}, L{IReactorUDP}, and L{IReactorTCP} which will be used to establish connections, listen for DNS datagrams, and enforce timeouts. If not provided, the global reactor will be used. @raise ValueError: Raised if no nameserver addresses can be found. """ common.ResolverBase.__init__(self) if reactor is None: from twisted.internet import reactor self._reactor = reactor self.timeout = timeout if servers is None: self.servers = [] else: self.servers = servers self.resolv = resolv if not len(self.servers) and not resolv: raise ValueError("No nameservers specified") self.factory = DNSClientFactory(self, timeout) self.factory.noisy = 0 # Be quiet by default self.connections = [] self.pending = [] self._waiting = {} self.maybeParseConfig() def __getstate__(self): d = self.__dict__.copy() d["connections"] = [] d["_parseCall"] = None return d def __setstate__(self, state): self.__dict__.update(state) self.maybeParseConfig() def _openFile(self, path): """ Wrapper used for opening files in the class, exists primarily for unit testing purposes. """ return FilePath(path).open() def maybeParseConfig(self): if self.resolv is None: # Don't try to parse it, don't set up a call loop return try: resolvConf = self._openFile(self.resolv) except OSError as e: if e.errno == errno.ENOENT: # Missing resolv.conf is treated the same as an empty resolv.conf self.parseConfig(()) else: raise else: with resolvConf: mtime = os.fstat(resolvConf.fileno()).st_mtime if mtime != self._lastResolvTime: log.msg(f"{self.resolv} changed, reparsing") self._lastResolvTime = mtime self.parseConfig(resolvConf) # Check again in a little while self._parseCall = self._reactor.callLater( self._resolvReadInterval, self.maybeParseConfig ) def parseConfig(self, resolvConf): servers = [] for L in resolvConf: L = L.strip() if L.startswith(b"nameserver"): resolver = (nativeString(L.split()[1]), dns.PORT) servers.append(resolver) log.msg(f"Resolver added {resolver!r} to server list") elif L.startswith(b"domain"): try: self.domain = L.split()[1] except IndexError: self.domain = b"" self.search = None elif L.startswith(b"search"): self.search = L.split()[1:] self.domain = None if not servers: servers.append(("127.0.0.1", dns.PORT)) self.dynServers = servers def pickServer(self): """ Return the address of a nameserver. TODO: Weight servers for response time so faster ones can be preferred. """ if not self.servers and not self.dynServers: return None serverL = len(self.servers) dynL = len(self.dynServers) self.index += 1 self.index %= serverL + dynL if self.index < serverL: return self.servers[self.index] else: return self.dynServers[self.index - serverL] def _connectedProtocol(self, interface=""): """ Return a new L{DNSDatagramProtocol} bound to a randomly selected port number. """ failures = 0 proto = dns.DNSDatagramProtocol(self, reactor=self._reactor) while True: try: self._reactor.listenUDP(dns.randomSource(), proto, interface=interface) except error.CannotListenError as e: failures += 1 if ( hasattr(e.socketError, "errno") and e.socketError.errno == errno.EMFILE ): # We've run out of file descriptors. Stop trying. raise if failures >= 1000: # We've tried a thousand times and haven't found a port. # This is almost impossible, and likely means something # else weird is going on. Raise, as to not infinite loop. raise else: return proto def connectionMade(self, protocol): """ Called by associated L{dns.DNSProtocol} instances when they connect. """ self.connections.append(protocol) for (d, q, t) in self.pending: self.queryTCP(q, t).chainDeferred(d) del self.pending[:] def connectionLost(self, protocol): """ Called by associated L{dns.DNSProtocol} instances when they disconnect. """ if protocol in self.connections: self.connections.remove(protocol) def messageReceived(self, message, protocol, address=None): log.msg("Unexpected message (%d) received from %r" % (message.id, address)) def _query(self, *args): """ Get a new L{DNSDatagramProtocol} instance from L{_connectedProtocol}, issue a query to it using C{*args}, and arrange for it to be disconnected from its transport after the query completes. @param args: Positional arguments to be passed to L{DNSDatagramProtocol.query}. @return: A L{Deferred} which will be called back with the result of the query. """ if isIPv6Address(args[0][0]): protocol = self._connectedProtocol(interface="::") else: protocol = self._connectedProtocol() d = protocol.query(*args) def cbQueried(result): protocol.transport.stopListening() return result d.addBoth(cbQueried) return d def queryUDP(self, queries, timeout=None): """ Make a number of DNS queries via UDP. @type queries: A C{list} of C{dns.Query} instances @param queries: The queries to make. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @rtype: C{Deferred} @raise C{twisted.internet.defer.TimeoutError}: When the query times out. """ if timeout is None: timeout = self.timeout addresses = self.servers + list(self.dynServers) if not addresses: return defer.fail(IOError("No domain name servers available")) # Make sure we go through servers in the list in the order they were # specified. addresses.reverse() used = addresses.pop() d = self._query(used, queries, timeout[0]) d.addErrback(self._reissue, addresses, [used], queries, timeout) return d def _reissue(self, reason, addressesLeft, addressesUsed, query, timeout): reason.trap(dns.DNSQueryTimeoutError) # If there are no servers left to be tried, adjust the timeout # to the next longest timeout period and move all the # "used" addresses back to the list of addresses to try. if not addressesLeft: addressesLeft = addressesUsed addressesLeft.reverse() addressesUsed = [] timeout = timeout[1:] # If all timeout values have been used this query has failed. Tell the # protocol we're giving up on it and return a terminal timeout failure # to our caller. if not timeout: return failure.Failure(defer.TimeoutError(query)) # Get an address to try. Take it out of the list of addresses # to try and put it ino the list of already tried addresses. address = addressesLeft.pop() addressesUsed.append(address) # Issue a query to a server. Use the current timeout. Add this # function as a timeout errback in case another retry is required. d = self._query(address, query, timeout[0], reason.value.id) d.addErrback(self._reissue, addressesLeft, addressesUsed, query, timeout) return d def queryTCP(self, queries, timeout=10): """ Make a number of DNS queries via TCP. @type queries: Any non-zero number of C{dns.Query} instances @param queries: The queries to make. @type timeout: C{int} @param timeout: The number of seconds after which to fail. @rtype: C{Deferred} """ if not len(self.connections): address = self.pickServer() if address is None: return defer.fail(IOError("No domain name servers available")) host, port = address self._reactor.connectTCP(host, port, self.factory) self.pending.append((defer.Deferred(), queries, timeout)) return self.pending[-1][0] else: return self.connections[0].query(queries, timeout) def filterAnswers(self, message): """ Extract results from the given message. If the message was truncated, re-attempt the query over TCP and return a Deferred which will fire with the results of that query. If the message's result code is not C{twisted.names.dns.OK}, return a Failure indicating the type of error which occurred. Otherwise, return a three-tuple of lists containing the results from the answers section, the authority section, and the additional section. """ if message.trunc: return self.queryTCP(message.queries).addCallback(self.filterAnswers) if message.rCode != dns.OK: return failure.Failure(self.exceptionForCode(message.rCode)(message)) return (message.answers, message.authority, message.additional) def _lookup(self, name, cls, type, timeout): """ Build a L{dns.Query} for the given parameters and dispatch it via UDP. If this query is already outstanding, it will not be re-issued. Instead, when the outstanding query receives a response, that response will be re-used for this query as well. @type name: C{str} @type type: C{int} @type cls: C{int} @return: A L{Deferred} which fires with a three-tuple giving the answer, authority, and additional sections of the response or with a L{Failure} if the response code is anything other than C{dns.OK}. """ key = (name, type, cls) waiting = self._waiting.get(key) if waiting is None: self._waiting[key] = [] d = self.queryUDP([dns.Query(name, type, cls)], timeout) def cbResult(result): for d in self._waiting.pop(key): d.callback(result) return result d.addCallback(self.filterAnswers) d.addBoth(cbResult) else: d = defer.Deferred() waiting.append(d) return d # This one doesn't ever belong on UDP def lookupZone(self, name, timeout=10): address = self.pickServer() if address is None: return defer.fail(IOError("No domain name servers available")) host, port = address d = defer.Deferred() controller = AXFRController(name, d) factory = DNSClientFactory(controller, timeout) factory.noisy = False # stfu connector = self._reactor.connectTCP(host, port, factory) controller.timeoutCall = self._reactor.callLater( timeout or 10, self._timeoutZone, d, controller, connector, timeout or 10 ) def eliminateTimeout(failure): controller.timeoutCall.cancel() controller.timeoutCall = None return failure return d.addCallbacks( self._cbLookupZone, eliminateTimeout, callbackArgs=(connector,) ) def _timeoutZone(self, d, controller, connector, seconds): connector.disconnect() controller.timeoutCall = None controller.deferred = None d.errback( error.TimeoutError("Zone lookup timed out after %d seconds" % (seconds,)) ) def _cbLookupZone(self, result, connector): connector.disconnect() return (result, [], []) class AXFRController: timeoutCall = None def __init__(self, name, deferred): self.name = name self.deferred = deferred self.soa = None self.records = [] self.pending = [(deferred,)] def connectionMade(self, protocol): # dig saids recursion-desired to 0, so I will too message = dns.Message(protocol.pickID(), recDes=0) message.queries = [dns.Query(self.name, dns.AXFR, dns.IN)] protocol.writeMessage(message) def connectionLost(self, protocol): # XXX Do something here - see #3428 pass def messageReceived(self, message, protocol): # Caveat: We have to handle two cases: All records are in 1 # message, or all records are in N messages. # According to http://cr.yp.to/djbdns/axfr-notes.html, # 'authority' and 'additional' are always empty, and only # 'answers' is present. self.records.extend(message.answers) if not self.records: return if not self.soa: if self.records[0].type == dns.SOA: # print "first SOA!" self.soa = self.records[0] if len(self.records) > 1 and self.records[-1].type == dns.SOA: # print "It's the second SOA! We're done." if self.timeoutCall is not None: self.timeoutCall.cancel() self.timeoutCall = None if self.deferred is not None: self.deferred.callback(self.records) self.deferred = None from twisted.internet.base import ThreadedResolver as _ThreadedResolverImpl class ThreadedResolver(_ThreadedResolverImpl): def __init__(self, reactor=None): if reactor is None: from twisted.internet import reactor _ThreadedResolverImpl.__init__(self, reactor) warnings.warn( "twisted.names.client.ThreadedResolver is deprecated since " "Twisted 9.0, use twisted.internet.base.ThreadedResolver " "instead.", category=DeprecationWarning, stacklevel=2, ) class DNSClientFactory(protocol.ClientFactory): def __init__(self, controller, timeout=10): self.controller = controller self.timeout = timeout def clientConnectionLost(self, connector, reason): pass def clientConnectionFailed(self, connector, reason): """ Fail all pending TCP DNS queries if the TCP connection attempt fails. @see: L{twisted.internet.protocol.ClientFactory} @param connector: Not used. @type connector: L{twisted.internet.interfaces.IConnector} @param reason: A C{Failure} containing information about the cause of the connection failure. This will be passed as the argument to C{errback} on every pending TCP query C{deferred}. @type reason: L{twisted.python.failure.Failure} """ # Copy the current pending deferreds then reset the master # pending list. This prevents triggering new deferreds which # may be added by callback or errback functions on the current # deferreds. pending = self.controller.pending[:] del self.controller.pending[:] for pendingState in pending: d = pendingState[0] d.errback(reason) def buildProtocol(self, addr): p = dns.DNSProtocol(self.controller) p.factory = self return p def createResolver(servers=None, resolvconf=None, hosts=None): r""" Create and return a Resolver. @type servers: C{list} of C{(str, int)} or L{None} @param servers: If not L{None}, interpreted as a list of domain name servers to attempt to use. Each server is a tuple of address in C{str} dotted-quad form and C{int} port number. @type resolvconf: C{str} or L{None} @param resolvconf: If not L{None}, on posix systems will be interpreted as an alternate resolv.conf to use. Will do nothing on windows systems. If L{None}, /etc/resolv.conf will be used. @type hosts: C{str} or L{None} @param hosts: If not L{None}, an alternate hosts file to use. If L{None} on posix systems, /etc/hosts will be used. On windows, C:\windows\hosts will be used. @rtype: C{IResolver} """ if platform.getType() == "posix": if resolvconf is None: resolvconf = b"/etc/resolv.conf" if hosts is None: hosts = b"/etc/hosts" theResolver = Resolver(resolvconf, servers) hostResolver = hostsModule.Resolver(hosts) else: if hosts is None: hosts = r"c:\windows\hosts" from twisted.internet import reactor bootstrap = _ThreadedResolverImpl(reactor) hostResolver = hostsModule.Resolver(hosts) theResolver = root.bootstrap(bootstrap, resolverFactory=Resolver) L = [hostResolver, cache.CacheResolver(), theResolver] return resolve.ResolverChain(L) theResolver = None def getResolver(): """ Get a Resolver instance. Create twisted.names.client.theResolver if it is L{None}, and then return that value. @rtype: C{IResolver} """ global theResolver if theResolver is None: try: theResolver = createResolver() except ValueError: theResolver = createResolver(servers=[("127.0.0.1", 53)]) return theResolver def getHostByName(name, timeout=None, effort=10): """ Resolve a name to a valid ipv4 or ipv6 address. Will errback with C{DNSQueryTimeoutError} on a timeout, C{DomainError} or C{AuthoritativeDomainError} (or subclasses) on other errors. @type name: C{str} @param name: DNS name to resolve. @type timeout: Sequence of C{int} @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @type effort: C{int} @param effort: How many times CNAME and NS records to follow while resolving this name. @rtype: C{Deferred} """ return getResolver().getHostByName(name, timeout, effort) def query(query, timeout=None): return getResolver().query(query, timeout) def lookupAddress(name, timeout=None): return getResolver().lookupAddress(name, timeout) def lookupIPV6Address(name, timeout=None): return getResolver().lookupIPV6Address(name, timeout) def lookupAddress6(name, timeout=None): return getResolver().lookupAddress6(name, timeout) def lookupMailExchange(name, timeout=None): return getResolver().lookupMailExchange(name, timeout) def lookupNameservers(name, timeout=None): return getResolver().lookupNameservers(name, timeout) def lookupCanonicalName(name, timeout=None): return getResolver().lookupCanonicalName(name, timeout) def lookupMailBox(name, timeout=None): return getResolver().lookupMailBox(name, timeout) def lookupMailGroup(name, timeout=None): return getResolver().lookupMailGroup(name, timeout) def lookupMailRename(name, timeout=None): return getResolver().lookupMailRename(name, timeout) def lookupPointer(name, timeout=None): return getResolver().lookupPointer(name, timeout) def lookupAuthority(name, timeout=None): return getResolver().lookupAuthority(name, timeout) def lookupNull(name, timeout=None): return getResolver().lookupNull(name, timeout) def lookupWellKnownServices(name, timeout=None): return getResolver().lookupWellKnownServices(name, timeout) def lookupService(name, timeout=None): return getResolver().lookupService(name, timeout) def lookupHostInfo(name, timeout=None): return getResolver().lookupHostInfo(name, timeout) def lookupMailboxInfo(name, timeout=None): return getResolver().lookupMailboxInfo(name, timeout) def lookupText(name, timeout=None): return getResolver().lookupText(name, timeout) def lookupSenderPolicy(name, timeout=None): return getResolver().lookupSenderPolicy(name, timeout) def lookupResponsibility(name, timeout=None): return getResolver().lookupResponsibility(name, timeout) def lookupAFSDatabase(name, timeout=None): return getResolver().lookupAFSDatabase(name, timeout) def lookupZone(name, timeout=None): return getResolver().lookupZone(name, timeout) def lookupAllRecords(name, timeout=None): return getResolver().lookupAllRecords(name, timeout) def lookupNamingAuthorityPointer(name, timeout=None): return getResolver().lookupNamingAuthorityPointer(name, timeout) PK Mb�Z�����$ �$ names/common.pynu �[��� # -*- test-case-name: twisted.names.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Base functionality useful to various parts of Twisted Names. """ import socket from zope.interface import implementer from twisted.internet import defer, error, interfaces from twisted.logger import Logger from twisted.names import dns from twisted.names.error import ( DNSFormatError, DNSNameError, DNSNotImplementedError, DNSQueryRefusedError, DNSServerError, DNSUnknownError, ) # Helpers for indexing the three-tuples that get thrown around by this code a # lot. _ANS, _AUTH, _ADD = range(3) EMPTY_RESULT = (), (), () @implementer(interfaces.IResolver) class ResolverBase: """ L{ResolverBase} is a base class for implementations of L{interfaces.IResolver} which deals with a lot of the boilerplate of implementing all of the lookup methods. @cvar _errormap: A C{dict} mapping DNS protocol failure response codes to exception classes which will be used to represent those failures. """ _log = Logger() _errormap = { dns.EFORMAT: DNSFormatError, dns.ESERVER: DNSServerError, dns.ENAME: DNSNameError, dns.ENOTIMP: DNSNotImplementedError, dns.EREFUSED: DNSQueryRefusedError, } typeToMethod = None def __init__(self): self.typeToMethod = {} for (k, v) in typeToMethod.items(): self.typeToMethod[k] = getattr(self, v) def exceptionForCode(self, responseCode): """ Convert a response code (one of the possible values of L{dns.Message.rCode} to an exception instance representing it. @since: 10.0 """ return self._errormap.get(responseCode, DNSUnknownError) def query(self, query, timeout=None): try: method = self.typeToMethod[query.type] except KeyError: self._log.debug( "Query of unknown type {query.type} for {query.name.name!r}", query=query, ) return defer.maybeDeferred( self._lookup, query.name.name, dns.IN, query.type, timeout ) else: return defer.maybeDeferred(method, query.name.name, timeout) def _lookup(self, name, cls, type, timeout): return defer.fail(NotImplementedError("ResolverBase._lookup")) def lookupAddress(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.A, timeout) def lookupIPV6Address(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.AAAA, timeout) def lookupAddress6(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.A6, timeout) def lookupMailExchange(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.MX, timeout) def lookupNameservers(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.NS, timeout) def lookupCanonicalName(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.CNAME, timeout) def lookupMailBox(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.MB, timeout) def lookupMailGroup(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.MG, timeout) def lookupMailRename(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.MR, timeout) def lookupPointer(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.PTR, timeout) def lookupAuthority(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.SOA, timeout) def lookupNull(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.NULL, timeout) def lookupWellKnownServices(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.WKS, timeout) def lookupService(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.SRV, timeout) def lookupHostInfo(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.HINFO, timeout) def lookupMailboxInfo(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.MINFO, timeout) def lookupText(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.TXT, timeout) def lookupSenderPolicy(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.SPF, timeout) def lookupResponsibility(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.RP, timeout) def lookupAFSDatabase(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.AFSDB, timeout) def lookupZone(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.AXFR, timeout) def lookupNamingAuthorityPointer(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.NAPTR, timeout) def lookupAllRecords(self, name, timeout=None): return self._lookup(dns.domainString(name), dns.IN, dns.ALL_RECORDS, timeout) # IResolverSimple def getHostByName(self, name, timeout=None, effort=10): name = dns.domainString(name) # XXX - respect timeout # XXX - this should do A and AAAA lookups, not ANY (see RFC 8482). # https://twistedmatrix.com/trac/ticket/9691 d = self.lookupAllRecords(name, timeout) d.addCallback(self._cbRecords, name, effort) return d def _cbRecords(self, records, name, effort): (ans, auth, add) = records result = extractRecord(self, dns.Name(name), ans + auth + add, effort) if not result: raise error.DNSLookupError(name) return result def extractRecord(resolver, name, answers, level=10): """ Resolve a name to an IP address, following I{CNAME} records and I{NS} referrals recursively. This is an implementation detail of L{ResolverBase.getHostByName}. @param resolver: The resolver to use for the next query (unless handling an I{NS} referral). @type resolver: L{IResolver} @param name: The name being looked up. @type name: L{dns.Name} @param answers: All of the records returned by the previous query (answers, authority, and additional concatenated). @type answers: L{list} of L{dns.RRHeader} @param level: Remaining recursion budget. This is decremented at each recursion. The query returns L{None} when it reaches 0. @type level: L{int} @returns: The first IPv4 or IPv6 address (as a dotted quad or colon quibbles), or L{None} when no result is found. @rtype: native L{str} or L{None} """ if not level: return None # FIXME: twisted.python.compat monkeypatches this if missing, so this # condition is always true. https://twistedmatrix.com/trac/ticket/9753 if hasattr(socket, "inet_ntop"): for r in answers: if r.name == name and r.type == dns.A6: return socket.inet_ntop(socket.AF_INET6, r.payload.address) for r in answers: if r.name == name and r.type == dns.AAAA: return socket.inet_ntop(socket.AF_INET6, r.payload.address) for r in answers: if r.name == name and r.type == dns.A: return socket.inet_ntop(socket.AF_INET, r.payload.address) for r in answers: if r.name == name and r.type == dns.CNAME: result = extractRecord(resolver, r.payload.name, answers, level - 1) if not result: return resolver.getHostByName(r.payload.name.name, effort=level - 1) return result # No answers, but maybe there's a hint at who we should be asking about # this for r in answers: if r.type != dns.NS: continue from twisted.names import client nsResolver = client.Resolver( servers=[ (r.payload.name.name.decode("ascii"), dns.PORT), ] ) def queryAgain(records): (ans, auth, add) = records return extractRecord(nsResolver, name, ans + auth + add, level - 1) return nsResolver.lookupAddress(name.name).addCallback(queryAgain) typeToMethod = { dns.A: "lookupAddress", dns.AAAA: "lookupIPV6Address", dns.A6: "lookupAddress6", dns.NS: "lookupNameservers", dns.CNAME: "lookupCanonicalName", dns.SOA: "lookupAuthority", dns.MB: "lookupMailBox", dns.MG: "lookupMailGroup", dns.MR: "lookupMailRename", dns.NULL: "lookupNull", dns.WKS: "lookupWellKnownServices", dns.PTR: "lookupPointer", dns.HINFO: "lookupHostInfo", dns.MINFO: "lookupMailboxInfo", dns.MX: "lookupMailExchange", dns.TXT: "lookupText", dns.SPF: "lookupSenderPolicy", dns.RP: "lookupResponsibility", dns.AFSDB: "lookupAFSDatabase", dns.SRV: "lookupService", dns.NAPTR: "lookupNamingAuthorityPointer", dns.AXFR: "lookupZone", dns.ALL_RECORDS: "lookupAllRecords", } PK Mb�Z)�5̈0 �0 names/root.pynu �[��� # -*- test-case-name: twisted.names.test.test_rootresolve -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Resolver implementation for querying successive authoritative servers to lookup a record, starting from the root nameservers. @author: Jp Calderone todo:: robustify it documentation """ from twisted.internet import defer from twisted.names import common, dns, error from twisted.python.failure import Failure class _DummyController: """ A do-nothing DNS controller. This is useful when all messages received will be responses to previously issued queries. Anything else received will be ignored. """ def messageReceived(self, *args): pass class Resolver(common.ResolverBase): """ L{Resolver} implements recursive lookup starting from a specified list of root servers. @ivar hints: See C{hints} parameter of L{__init__} @ivar _maximumQueries: See C{maximumQueries} parameter of L{__init__} @ivar _reactor: See C{reactor} parameter of L{__init__} @ivar _resolverFactory: See C{resolverFactory} parameter of L{__init__} """ def __init__(self, hints, maximumQueries=10, reactor=None, resolverFactory=None): """ @param hints: A L{list} of L{str} giving the dotted quad representation of IP addresses of root servers at which to begin resolving names. @type hints: L{list} of L{str} @param maximumQueries: An optional L{int} giving the maximum number of queries which will be attempted to resolve a single name. @type maximumQueries: L{int} @param reactor: An optional L{IReactorTime} and L{IReactorUDP} provider to use to bind UDP ports and manage timeouts. @type reactor: L{IReactorTime} and L{IReactorUDP} provider @param resolverFactory: An optional callable which accepts C{reactor} and C{servers} arguments and returns an instance that provides a C{queryUDP} method. Defaults to L{twisted.names.client.Resolver}. @type resolverFactory: callable """ common.ResolverBase.__init__(self) self.hints = hints self._maximumQueries = maximumQueries self._reactor = reactor if resolverFactory is None: from twisted.names.client import Resolver as resolverFactory self._resolverFactory = resolverFactory def _roots(self): """ Return a list of two-tuples representing the addresses of the root servers, as defined by C{self.hints}. """ return [(ip, dns.PORT) for ip in self.hints] def _query(self, query, servers, timeout, filter): """ Issue one query and return a L{Deferred} which fires with its response. @param query: The query to issue. @type query: L{dns.Query} @param servers: The servers which might have an answer for this query. @type servers: L{list} of L{tuple} of L{str} and L{int} @param timeout: A timeout on how long to wait for the response. @type timeout: L{tuple} of L{int} @param filter: A flag indicating whether to filter the results. If C{True}, the returned L{Deferred} will fire with a three-tuple of lists of L{twisted.names.dns.RRHeader} (like the return value of the I{lookup*} methods of L{IResolver}. IF C{False}, the result will be a L{Message} instance. @type filter: L{bool} @return: A L{Deferred} which fires with the response or a timeout error. @rtype: L{Deferred} """ r = self._resolverFactory(servers=servers, reactor=self._reactor) d = r.queryUDP([query], timeout) if filter: d.addCallback(r.filterAnswers) return d def _lookup(self, name, cls, type, timeout): """ Implement name lookup by recursively discovering the authoritative server for the name and then asking it, starting at one of the servers in C{self.hints}. """ if timeout is None: # A series of timeouts for semi-exponential backoff, summing to an # arbitrary total of 60 seconds. timeout = (1, 3, 11, 45) return self._discoverAuthority( dns.Query(name, type, cls), self._roots(), timeout, self._maximumQueries ) def _discoverAuthority(self, query, servers, timeout, queriesLeft): """ Issue a query to a server and follow a delegation if necessary. @param query: The query to issue. @type query: L{dns.Query} @param servers: The servers which might have an answer for this query. @type servers: L{list} of L{tuple} of L{str} and L{int} @param timeout: A C{tuple} of C{int} giving the timeout to use for this query. @param queriesLeft: A C{int} giving the number of queries which may yet be attempted to answer this query before the attempt will be abandoned. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} giving the response, or with a L{Failure} if there is a timeout or response error. """ # Stop now if we've hit the query limit. if queriesLeft <= 0: return Failure(error.ResolverError("Query limit reached without result")) d = self._query(query, servers, timeout, False) d.addCallback(self._discoveredAuthority, query, timeout, queriesLeft - 1) return d def _discoveredAuthority(self, response, query, timeout, queriesLeft): """ Interpret the response to a query, checking for error codes and following delegations if necessary. @param response: The L{Message} received in response to issuing C{query}. @type response: L{Message} @param query: The L{dns.Query} which was issued. @type query: L{dns.Query}. @param timeout: The timeout to use if another query is indicated by this response. @type timeout: L{tuple} of L{int} @param queriesLeft: A C{int} giving the number of queries which may yet be attempted to answer this query before the attempt will be abandoned. @return: A L{Failure} indicating a response error, a three-tuple of lists of L{twisted.names.dns.RRHeader} giving the response to C{query} or a L{Deferred} which will fire with one of those. """ if response.rCode != dns.OK: return Failure(self.exceptionForCode(response.rCode)(response)) # Turn the answers into a structure that's a little easier to work with. records = {} for answer in response.answers: records.setdefault(answer.name, []).append(answer) def findAnswerOrCName(name, type, cls): cname = None for record in records.get(name, []): if record.cls == cls: if record.type == type: return record elif record.type == dns.CNAME: cname = record # If there were any CNAME records, return the last one. There's # only supposed to be zero or one, though. return cname seen = set() name = query.name record = None while True: seen.add(name) previous = record record = findAnswerOrCName(name, query.type, query.cls) if record is None: if name == query.name: # If there's no answer for the original name, then this may # be a delegation. Code below handles it. break else: # Try to resolve the CNAME with another query. d = self._discoverAuthority( dns.Query(str(name), query.type, query.cls), self._roots(), timeout, queriesLeft, ) # We also want to include the CNAME in the ultimate result, # otherwise this will be pretty confusing. def cbResolved(results): answers, authority, additional = results answers.insert(0, previous) return (answers, authority, additional) d.addCallback(cbResolved) return d elif record.type == query.type: return (response.answers, response.authority, response.additional) else: # It's a CNAME record. Try to resolve it from the records # in this response with another iteration around the loop. if record.payload.name in seen: raise error.ResolverError("Cycle in CNAME processing") name = record.payload.name # Build a map to use to convert NS names into IP addresses. addresses = {} for rr in response.additional: if rr.type == dns.A: addresses[rr.name.name] = rr.payload.dottedQuad() hints = [] traps = [] for rr in response.authority: if rr.type == dns.NS: ns = rr.payload.name.name if ns in addresses: hints.append((addresses[ns], dns.PORT)) else: traps.append(ns) if hints: return self._discoverAuthority(query, hints, timeout, queriesLeft) elif traps: d = self.lookupAddress(traps[0], timeout) def getOneAddress(results): answers, authority, additional = results return answers[0].payload.dottedQuad() d.addCallback(getOneAddress) d.addCallback( lambda hint: self._discoverAuthority( query, [(hint, dns.PORT)], timeout, queriesLeft - 1 ) ) return d else: return Failure( error.ResolverError("Stuck at response without answers or delegation") ) def makePlaceholder(deferred, name): def placeholder(*args, **kw): deferred.addCallback(lambda r: getattr(r, name)(*args, **kw)) return deferred return placeholder class DeferredResolver: def __init__(self, resolverDeferred): self.waiting = [] resolverDeferred.addCallback(self.gotRealResolver) def gotRealResolver(self, resolver): w = self.waiting self.__dict__ = resolver.__dict__ self.__class__ = resolver.__class__ for d in w: d.callback(resolver) def __getattr__(self, name): if name.startswith("lookup") or name in ("getHostByName", "query"): self.waiting.append(defer.Deferred()) return makePlaceholder(self.waiting[-1], name) raise AttributeError(name) def bootstrap(resolver, resolverFactory=None): """ Lookup the root nameserver addresses using the given resolver Return a Resolver which will eventually become a C{root.Resolver} instance that has references to all the root servers that we were able to look up. @param resolver: The resolver instance which will be used to lookup the root nameserver addresses. @type resolver: L{twisted.internet.interfaces.IResolverSimple} @param resolverFactory: An optional callable which returns a resolver instance. It will passed as the C{resolverFactory} argument to L{Resolver.__init__}. @type resolverFactory: callable @return: A L{DeferredResolver} which will be dynamically replaced with L{Resolver} when the root nameservers have been looked up. """ domains = [chr(ord("a") + i) for i in range(13)] L = [resolver.getHostByName("%s.root-servers.net" % d) for d in domains] d = defer.DeferredList(L, consumeErrors=True) def buildResolver(res): return Resolver( hints=[e[1] for e in res if e[0]], resolverFactory=resolverFactory ) d.addCallback(buildResolver) return DeferredResolver(d) PK Mb�ZXV �V names/server.pynu �[��� # -*- test-case-name: twisted.names.test.test_names,twisted.names.test.test_server -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Async DNS server Future plans: - Better config file format maybe - Make sure to differentiate between different classes - notice truncation bit Important: No additional processing is done on some of the record types. This violates the most basic RFC and is just plain annoying for resolvers to deal with. Fix it. @author: Jp Calderone """ import time from twisted.internet import protocol from twisted.names import dns, resolve from twisted.python import log class DNSServerFactory(protocol.ServerFactory): """ Server factory and tracker for L{DNSProtocol} connections. This class also provides records for responses to DNS queries. @ivar cache: A L{Cache<twisted.names.cache.CacheResolver>} instance whose C{cacheResult} method is called when a response is received from one of C{clients}. Defaults to L{None} if no caches are specified. See C{caches} of L{__init__} for more details. @type cache: L{Cache<twisted.names.cache.CacheResolver>} or L{None} @ivar canRecurse: A flag indicating whether this server is capable of performing recursive DNS resolution. @type canRecurse: L{bool} @ivar resolver: A L{resolve.ResolverChain} containing an ordered list of C{authorities}, C{caches} and C{clients} to which queries will be dispatched. @type resolver: L{resolve.ResolverChain} @ivar verbose: See L{__init__} @ivar connections: A list of all the connected L{DNSProtocol} instances using this object as their controller. @type connections: C{list} of L{DNSProtocol} instances @ivar protocol: A callable used for building a DNS stream protocol. Called by L{DNSServerFactory.buildProtocol} and passed the L{DNSServerFactory} instance as the one and only positional argument. Defaults to L{dns.DNSProtocol}. @type protocol: L{IProtocolFactory} constructor @ivar _messageFactory: A response message constructor with an initializer signature matching L{dns.Message.__init__}. @type _messageFactory: C{callable} """ # Type is wrong. See: https://twistedmatrix.com/trac/ticket/10004#ticket protocol = dns.DNSProtocol # type: ignore[assignment] cache = None _messageFactory = dns.Message def __init__(self, authorities=None, caches=None, clients=None, verbose=0): """ @param authorities: Resolvers which provide authoritative answers. @type authorities: L{list} of L{IResolver} providers @param caches: Resolvers which provide cached non-authoritative answers. The first cache instance is assigned to C{DNSServerFactory.cache} and its C{cacheResult} method will be called when a response is received from one of C{clients}. @type caches: L{list} of L{Cache<twisted.names.cache.CacheResolver>} instances @param clients: Resolvers which are capable of performing recursive DNS lookups. @type clients: L{list} of L{IResolver} providers @param verbose: An integer controlling the verbosity of logging of queries and responses. Default is C{0} which means no logging. Set to C{2} to enable logging of full query and response messages. @type verbose: L{int} """ resolvers = [] if authorities is not None: resolvers.extend(authorities) if caches is not None: resolvers.extend(caches) if clients is not None: resolvers.extend(clients) self.canRecurse = not not clients self.resolver = resolve.ResolverChain(resolvers) self.verbose = verbose if caches: self.cache = caches[-1] self.connections = [] def _verboseLog(self, *args, **kwargs): """ Log a message only if verbose logging is enabled. @param args: Positional arguments which will be passed to C{log.msg} @param kwargs: Keyword arguments which will be passed to C{log.msg} """ if self.verbose > 0: log.msg(*args, **kwargs) def buildProtocol(self, addr): p = self.protocol(self) p.factory = self return p def connectionMade(self, protocol): """ Track a newly connected L{DNSProtocol}. @param protocol: The protocol instance to be tracked. @type protocol: L{dns.DNSProtocol} """ self.connections.append(protocol) def connectionLost(self, protocol): """ Stop tracking a no-longer connected L{DNSProtocol}. @param protocol: The tracked protocol instance to be which has been lost. @type protocol: L{dns.DNSProtocol} """ self.connections.remove(protocol) def sendReply(self, protocol, message, address): """ Send a response C{message} to a given C{address} via the supplied C{protocol}. Message payload will be logged if C{DNSServerFactory.verbose} is C{>1}. @param protocol: The DNS protocol instance to which to send the message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The DNS message to be sent. @type message: L{dns.Message} @param address: The address to which the message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ if self.verbose > 1: s = " ".join([str(a.payload) for a in message.answers]) auth = " ".join([str(a.payload) for a in message.authority]) add = " ".join([str(a.payload) for a in message.additional]) if not s: log.msg("Replying with no answers") else: log.msg("Answers are " + s) log.msg("Authority is " + auth) log.msg("Additional is " + add) if address is None: protocol.writeMessage(message) else: protocol.writeMessage(message, address) self._verboseLog( "Processed query in %0.3f seconds" % (time.time() - message.timeReceived) ) def _responseFromMessage( self, message, rCode=dns.OK, answers=None, authority=None, additional=None ): """ Generate a L{Message} instance suitable for use as the response to C{message}. C{queries} will be copied from the request to the response. C{rCode}, C{answers}, C{authority} and C{additional} will be assigned to the response, if supplied. The C{recAv} flag will be set on the response if the C{canRecurse} flag on this L{DNSServerFactory} is set to L{True}. The C{auth} flag will be set on the response if *any* of the supplied C{answers} have their C{auth} flag set to L{True}. The response will have the same C{maxSize} as the request. Additionally, the response will have a C{timeReceived} attribute whose value is that of the original request and the @see: L{dns._responseFromMessage} @param message: The request message @type message: L{Message} @param rCode: The response code which will be assigned to the response. @type message: L{int} @param answers: An optional list of answer records which will be assigned to the response. @type answers: L{list} of L{dns.RRHeader} @param authority: An optional list of authority records which will be assigned to the response. @type authority: L{list} of L{dns.RRHeader} @param additional: An optional list of additional records which will be assigned to the response. @type additional: L{list} of L{dns.RRHeader} @return: A response L{Message} instance. @rtype: L{Message} """ if answers is None: answers = [] if authority is None: authority = [] if additional is None: additional = [] authoritativeAnswer = False for x in answers: if x.isAuthoritative(): authoritativeAnswer = True break response = dns._responseFromMessage( responseConstructor=self._messageFactory, message=message, recAv=self.canRecurse, rCode=rCode, auth=authoritativeAnswer, ) # XXX: Timereceived is a hack which probably shouldn't be tacked onto # the message. Use getattr here so that we don't have to set the # timereceived on every message in the tests. See #6957. response.timeReceived = getattr(message, "timeReceived", None) # XXX: This is another hack. dns.Message.decode sets maxSize=0 which # means that responses are never truncated. I'll maintain that behaviour # here until #6949 is resolved. response.maxSize = message.maxSize response.answers = answers response.authority = authority response.additional = additional return response def gotResolverResponse(self, response, protocol, message, address): """ A callback used by L{DNSServerFactory.handleQuery} for handling the deferred response from C{self.resolver.query}. Constructs a response message by combining the original query message with the resolved answer, authority and additional records. Marks the response message as authoritative if any of the resolved answers are found to be authoritative. The resolved answers count will be logged if C{DNSServerFactory.verbose} is C{>1}. @param response: Answer records, authority records and additional records @type response: L{tuple} of L{list} of L{dns.RRHeader} instances @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ ans, auth, add = response response = self._responseFromMessage( message=message, rCode=dns.OK, answers=ans, authority=auth, additional=add ) self.sendReply(protocol, response, address) l = len(ans) + len(auth) + len(add) self._verboseLog("Lookup found %d record%s" % (l, l != 1 and "s" or "")) if self.cache and l: self.cache.cacheResult(message.queries[0], (ans, auth, add)) def gotResolverError(self, failure, protocol, message, address): """ A callback used by L{DNSServerFactory.handleQuery} for handling deferred errors from C{self.resolver.query}. Constructs a response message from the original query message by assigning a suitable error code to C{rCode}. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. @param failure: The reason for the failed resolution (as reported by C{self.resolver.query}). @type failure: L{Failure<twisted.python.failure.Failure>} @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ if failure.check(dns.DomainError, dns.AuthoritativeDomainError): rCode = dns.ENAME else: rCode = dns.ESERVER log.err(failure) response = self._responseFromMessage(message=message, rCode=rCode) self.sendReply(protocol, response, address) self._verboseLog("Lookup failed") def handleQuery(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} when a query message is received. Takes the first query from the received message and dispatches it to C{self.resolver.query}. Adds callbacks L{DNSServerFactory.gotResolverResponse} and L{DNSServerFactory.gotResolverError} to the resulting deferred. Note: Multiple queries in a single message are not supported because there is no standard way to respond with multiple rCodes, auth, etc. This is consistent with other DNS server implementations. See U{http://tools.ietf.org/html/draft-ietf-dnsext-edns1-03} for a proposed solution. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} @return: A C{deferred} which fires with the resolved result or error of the first query in C{message}. @rtype: L{Deferred<twisted.internet.defer.Deferred>} """ query = message.queries[0] return ( self.resolver.query(query) .addCallback(self.gotResolverResponse, protocol, message, address) .addErrback(self.gotResolverError, protocol, message, address) ) def handleInverseQuery(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} when an inverse query message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ message.rCode = dns.ENOTIMP self.sendReply(protocol, message, address) self._verboseLog(f"Inverse query from {address!r}") def handleStatus(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} when a status message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ message.rCode = dns.ENOTIMP self.sendReply(protocol, message, address) self._verboseLog(f"Status request from {address!r}") def handleNotify(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} when a notify message is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ message.rCode = dns.ENOTIMP self.sendReply(protocol, message, address) self._verboseLog(f"Notify message from {address!r}") def handleOther(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} when a message with unrecognised I{OPCODE} is received. Replies with a I{Not Implemented} error by default. An error message will be logged if C{DNSServerFactory.verbose} is C{>1}. Override in a subclass. @param protocol: The DNS protocol instance to which to send a response message. @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param message: The original DNS query message for which a response message will be constructed. @type message: L{dns.Message} @param address: The address to which the response message will be sent or L{None} if C{protocol} is a stream protocol. @type address: L{tuple} or L{None} """ message.rCode = dns.ENOTIMP self.sendReply(protocol, message, address) self._verboseLog("Unknown op code (%d) from %r" % (message.opCode, address)) def messageReceived(self, message, proto, address=None): """ L{DNSServerFactory.messageReceived} is called by protocols which are under the control of this L{DNSServerFactory} whenever they receive a DNS query message or an unexpected / duplicate / late DNS response message. L{DNSServerFactory.allowQuery} is called with the received message, protocol and origin address. If it returns L{False}, a C{dns.EREFUSED} response is sent back to the client. Otherwise the received message is dispatched to one of L{DNSServerFactory.handleQuery}, L{DNSServerFactory.handleInverseQuery}, L{DNSServerFactory.handleStatus}, L{DNSServerFactory.handleNotify}, or L{DNSServerFactory.handleOther} depending on the I{OPCODE} of the received message. If C{DNSServerFactory.verbose} is C{>0} all received messages will be logged in more or less detail depending on the value of C{verbose}. @param message: The DNS message that was received. @type message: L{dns.Message} @param proto: The DNS protocol instance which received the message @type proto: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param address: The address from which the message was received. Only provided for messages received by datagram protocols. The origin of Messages received from stream protocols can be gleaned from the protocol C{transport} attribute. @type address: L{tuple} or L{None} """ message.timeReceived = time.time() if self.verbose: if self.verbose > 1: s = " ".join([str(q) for q in message.queries]) else: s = " ".join( [dns.QUERY_TYPES.get(q.type, "UNKNOWN") for q in message.queries] ) if not len(s): log.msg(f"Empty query from {address or proto.transport.getPeer()!r}") else: log.msg(f"{s} query from {address or proto.transport.getPeer()!r}") if not self.allowQuery(message, proto, address): message.rCode = dns.EREFUSED self.sendReply(proto, message, address) elif message.opCode == dns.OP_QUERY: self.handleQuery(message, proto, address) elif message.opCode == dns.OP_INVERSE: self.handleInverseQuery(message, proto, address) elif message.opCode == dns.OP_STATUS: self.handleStatus(message, proto, address) elif message.opCode == dns.OP_NOTIFY: self.handleNotify(message, proto, address) else: self.handleOther(message, proto, address) def allowQuery(self, message, protocol, address): """ Called by L{DNSServerFactory.messageReceived} to decide whether to process a received message or to reply with C{dns.EREFUSED}. This default implementation permits anything but empty queries. Override in a subclass to implement alternative policies. @param message: The DNS message that was received. @type message: L{dns.Message} @param protocol: The DNS protocol instance which received the message @type protocol: L{dns.DNSDatagramProtocol} or L{dns.DNSProtocol} @param address: The address from which the message was received. Only provided for messages received by datagram protocols. The origin of Messages received from stream protocols can be gleaned from the protocol C{transport} attribute. @type address: L{tuple} or L{None} @return: L{True} if the received message contained one or more queries, else L{False}. @rtype: L{bool} """ return len(message.queries) PK Mb�Z�G�G� � names/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted Names: DNS server and client implementations. """ PK Mb�Z��̪�. �. , trial/__pycache__/_asynctest.cpython-310.pycnu �[��� o �b@7 � @ s� U d Z ddlZddlZddlmZ ddlmZ ddlmZm Z ddl m Z ddl m Z mZ ddlmZmZmZ g Zed ed < ee j�G d d � d e��ZdS ) zP Things likely to be used by writers of unit tests. Maintainer: Jonathan Lange � N)�List)� implementer)�defer�utils)�failure)�itrial�util)�FailTest�SkipTest�SynchronousTestCase�_wait_is_runningc s� e Zd ZdZd/� fdd� Zdd� ZeZdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zejdd� �Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Z� fd'd(�Zd)d*� Zd+d,� Ze fd-d.�Z � Z S )0�TestCasea= A unit test. The atom of the unit testing universe. This class extends L{SynchronousTestCase} which extends C{unittest.TestCase} from the standard library. The main feature is the ability to return C{Deferred}s from tests and fixture methods and to have the suite wait for those C{Deferred}s to fire. Also provides new assertions such as L{assertFailure}. @ivar timeout: A real number of seconds. If set, the test will raise an error if it takes longer than C{timeout} seconds. If not set, util.DEFAULT_TIMEOUT_DURATION is used. �runTestc s t � �|� dS )a� Construct an asynchronous test case for C{methodName}. @param methodName: The name of a method on C{self}. This method should be a unit test. That is, it should be a short method that calls some of the assert* methods. If C{methodName} is unspecified, L{SynchronousTestCase.runTest} will be used as the test method. This is mostly useful for testing Trial. N)�super�__init__)�self� methodName�� __class__� �:/usr/lib/python3/dist-packages/twisted/trial/_asynctest.pyr - s zTestCase.__init__c s& �fdd�}� �fdd�}|� ||�S )z� Fail if C{deferred} does not errback with one of C{expectedFailures}. Returns the original Deferred with callbacks added. You will need to return this Deferred from your test case. c s � � d| ����)Nz$did not catch an error, instead got )�failureException)�ignore�r r r �_cb@ s �z#TestCase.assertFailure.<locals>._cbc s* | j � � r| jS d�� t| ��}��|��)Nz Expected: {!r} Got: {})�check�value�format�strr )r �output��expectedFailuresr r r �_ebE s � z#TestCase.assertFailure.<locals>._eb)� addCallbacks)r �deferredr! r r" r r r � assertFailure9 s zTestCase.assertFailurec s� ddl m� ��� ������fdd�}t�|tjtd��}t���}t � |�r4t d� |��}t �|�S t �tj��� |�}���||�� |�� fdd�� |S ) Nr ��reactorc s� t ���d� � d�� d��}t�|�}z| �|� W d S t jyJ ��� d�_��� }|d urA|� |�rA�� �||� Y d S �� �|� Y d S w )Nz (z) still running at z secsT) r � TimeoutErrorr �Failure�errback�AlreadyCalledError�crash� _timedOut�getTodo�expected�addExpectedFailure�addError)�d�e�f�todo)r r' �resultr �timeoutr r � onTimeoutW s � �z TestCase._run.<locals>.onTimeout��categoryz9{!r} is a generator function and therefore will never runc s � � � r� �� p | S �N)�active�cancel)�x)�callr r �<lambda>| s z TestCase._run.<locals>.<lambda>)�twisted.internetr' � getTimeoutr �suppressWarningsr �suppress�DeprecationWarning�getattr�inspect�isgeneratorfunction� TypeErrorr r �fail� maybeDeferred�runWithWarningsSuppressed� _getSuppress� callLater�addBoth)r r r6 r8 �method�excr2 r )r? r r' r6 r r7 r �_runR s( � �� �z TestCase._runc O s | j |i |��S r; )�run)r �args�kwargsr r r �__call__ s zTestCase.__call__c C s* | � d|�}|j| j| j|f|fd� |S )N�setUp�� callbackArgs� errbackArgs)rR r# �deferTestMethod� _ebDeferSetUp�r �ignoredr6 r2 r r r � deferSetUp� s �zTestCase.deferSetUpc C sN |� t�r|�| | �| j|j�� n|�| |� |� t�r!|�� | � d |�S r; ) r r �addSkip�_getSkipReasonrW r r1 �KeyboardInterrupt�stop�deferRunCleanups�r r r6 r r r r\ � s zTestCase._ebDeferSetUpc C sH | � | j|�}|j| j| j|f|fd� |�| j|� |�| j|� |S )NrX )rR �_testMethodNamer# �_cbDeferTestMethod�_ebDeferTestMethodrO rd � deferTearDownr] r r r r[ � s �zTestCase.deferTestMethodc C s* | � � d ur|�| | � � � |S d| _|S )NT)r. �addUnexpectedSuccess�_passed)r r^ r6 r r r rg � s �zTestCase._cbDeferTestMethodc C s� | � � }|d ur|�|�r|�| ||� d S |�| jt�r%|�| |� d S |�t�r6|�| |� |� � d S |�t �rL|� | | � t | | j�|j�� d S |�| |� d S r; )r. r/ r0 r r r � addFailurerb r1 rc r r` ra rF rf r )r r4 r6 r5 r r r rh � s �zTestCase._ebDeferTestMethodc C s | � d|�}|�| j|� |S )N�tearDown)rR � addErrback�_ebDeferTearDownr] r r r ri � s zTestCase.deferTearDownc C s( |� | |� |�t�r|�� d| _d S �NF)r1 r rb rc rk re r r r ro � s zTestCase._ebDeferTearDownc c sv � g }| j ddd� D ] \}}}z ||i |��V W q ty* |�t�� � Y q w |D ] }|�| |� d| _q-dS )zf Run any scheduled cleanups and report errors (if any) to the result. object. N���F)� _cleanups� Exception�appendr r) r1 rk )r r^ r6 �failures�funcrT rU r4 r r r rd � s � � �zTestCase.deferRunCleanupsc C s� zt �| |��� }|sd| _W n ty# |�| t�� � d| _Y nw | j� � D ] }|�| |� d| _q)| � � | � � | jrG|� | � d S d S rp ) r �_Janitor�postCaseCleanuprk � BaseExceptionr1 r r) � _observer� getErrors�flushLoggedErrors�_removeObserver� addSuccess)r r6 �clean�errorr r r �_cleanUp� s" � � �zTestCase._cleanUpc C s< z t �| |��� W d S ty |�| t�� � Y d S w r; )r rw �postClassCleanupry r1 r r) )r r6 r r r � _classCleanUp� s �zTestCase._classCleanUpc s � �fdd�}|S )z� Create a method which wraps the reactor method C{name}. The new method issues a deprecation warning and calls the original. c s, t jd� � f dtd� �j� | i |��S )Nz{reactor.%s cannot be used inside unit tests. In the future, using %s will fail the test and may crash or hang the test run.� )� stacklevelr: )�warnings�warnrE �_reactorMethods)�a�kw��namer r r �_� s ��z&TestCase._makeReactorMethod.<locals>._r )r r� r� r r� r �_makeReactorMethod� s zTestCase._makeReactorMethodc C s6 i | _ dD ]}t||�| j |< t||| �|�� qdS )z� Deprecate C{iterate}, C{crash} and C{stop} on C{reactor}. That is, each method is wrapped in a function that issues a deprecation warning, then calls the original. @param reactor: The Twisted reactor. )r, �iteraterc N)r� rF �setattrr� )r r' r� r r r �_deprecateReactor� s �zTestCase._deprecateReactorc C s* | j �� D ] \}}t|||� qi | _ dS )z� Restore the deprecated reactor methods. Undoes what L{_deprecateReactor} did. @param reactor: The Twisted reactor. N)r� �itemsr� )r r' r� rP r r r �_undeprecateReactor s z TestCase._undeprecateReactorc C s� ddl m} | �|� d| _z+| �d|�}z| �|� W | �|� | �|� n | �|� | �|� w W | �|� dS | �|� w )z� Really run C{setUp}, the test method, and C{tearDown}. Any of these may return L{defer.Deferred}s. After they complete, do some reactor cleanup. @param result: A L{TestResult} object. r r& FN) rA r' r� r- r_ �_waitr� r� r� )r r6 r' r2 r r r �_runFixturesAndTest s �z TestCase._runFixturesAndTestc s t � j|g|�R i |��S )a Extend the base cleanup feature with support for cleanup functions which return Deferreds. If the function C{f} returns a Deferred, C{TestCase} will wait until the Deferred has fired before proceeding to the next function. )r � addCleanup)r r4 rT rU r r r r� ) s zTestCase.addCleanupc C s | � � S r; )rM r r r r � getSuppress3 s zTestCase.getSuppressc C sH t �| jdt j�}zt|�W S ttfy# tjdt d� t j Y S w )ae Returns the timeout value set on this test. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{timeout} attribute, returns that. Returns L{util.DEFAULT_TIMEOUT_DURATION} if it cannot find anything. See L{TestCase} docstring for more details. r7 z)'timeout' attribute needs to be a number.r9 ) r �acquireAttribute�_parents�DEFAULT_TIMEOUT_DURATION�float� ValueErrorrI r� r� rE )r r7 r r r rB 6 s � � �zTestCase.getTimeoutc s� |rt d��ddlm� g ��fdd�}� �fdd�}t�|tjdtd ��}� fd d �}t�|tjdtd ��}|�d � z5|� |� �rMW d �|� � d S |� |� |� _ z� � � W � ` n� ` w �sf| j roW d �|� � d S t� �d �|� � w ) zATake a Deferred that only ever callbacks. Block until it happens.z_wait is not reentrantr r& c s � d ur � � | � d S d S r; )rt )�any)�resultsr r rt V s �z TestCase._wait.<locals>.appendc s �d ur � � � d S d S r; �r, )�ign�r' r� r r r, Z s �z TestCase._wait.<locals>.crashz reactor\.crash cannot be used.*)�messager: c s � � � d S r; r� r r& r r rc e s z TestCase._wait.<locals>.stopN)� RuntimeErrorrA r' r rC r rD rE rt rO �poprc rS r- rb )r r2 �runningrt r, rc r r� r r� M sL �� �� � � zTestCase._wait)r ) �__name__� __module__� __qualname__�__doc__r r% �failUnlessFailurerR rV r_ r\ r[ rg rh ri ro r �inlineCallbacksrd r� r� r� r� r� r� r� r� rB r r� � __classcell__r r r r r s4 - r )r� rG r� �typingr �zope.interfacer rA r r �twisted.pythonr � twisted.trialr r �twisted.trial._synctestr r r r �__annotations__� ITestCaser r r r r �<module> s PK Mb�Z�h�� ( trial/__pycache__/itrial.cpython-310.pycnu �[��� o �b6 � @ s8 d Z ddlmZ G dd� dej�ZG dd� dej�ZdS )z3 Interfaces for Trial. Maintainer: Jonathan Lange � Nc @ sB e Zd ZdZe�d�Zdd� Zdd� Zdd� Z d d � Z d d � Z d S )� ITestCasezU The interface that a test case must implement in order to be used in Trial. z7The exception class that is raised by failed assertionsc C � dS )zQ Run the test. Should always do exactly the same thing as run(). N� ��resultr r �6/usr/lib/python3/dist-packages/twisted/trial/itrial.py�__call__ � zITestCase.__call__c C r )zJ Return the number of tests in this test case. Usually 1. Nr r r r r �countTestCases r zITestCase.countTestCasesc C r )zk Return a unique identifier for the test, usually the fully-qualified Python name. Nr r r r r �id! r z ITestCase.idc C r )zj Run the test, storing the results in C{result}. @param result: A L{TestResult}. Nr r r r r �run' r z ITestCase.runc C r )z9 Return a short description of the test. Nr r r r r �shortDescription. r zITestCase.shortDescriptionN) �__name__� __module__� __qualname__�__doc__�zi� Attribute�failureExceptionr r r r r r r r r r s � r c @ sx e Zd ZdZe�d�Ze�d�Zdd� Zdd� Z dd � Z d d � Z d d � Z ddd�Z ddd�Zdd� Zdd� Zdd� ZdS )� IReporterz6 I report results from a run of a test suite. zHA boolean indicating that this reporter would like the test run to stop.zd The number of tests that seem to have been run according to this reporter. c C r )z� Report the beginning of a run of a single test method. @param method: an object that is adaptable to ITestMethod Nr ��methodr r r � startTestC r zIReporter.startTestc C r )z~ Report the status of a single test method @param method: an object that is adaptable to ITestMethod Nr r r r r �stopTestJ r zIReporter.stopTestc C r )z* Record that test passed. Nr )�testr r r � addSuccessQ r zIReporter.addSuccessc C r )aI Record that a test has raised an unexpected exception. @param test: The test that has raised an error. @param error: The error that the test raised. It will either be a three-tuple in the style of C{sys.exc_info()} or a L{Failure<twisted.python.failure.Failure>} object. Nr )r �errorr r r �addErrorV r zIReporter.addErrorc C r )aH Record that a test has failed with the given failure. @param test: The test that has failed. @param failure: The failure that the test failed with. It will either be a three-tuple in the style of C{sys.exc_info()} or a L{Failure<twisted.python.failure.Failure>} object. Nr )r �failurer r r � addFailure` r zIReporter.addFailureNc C r )a� Record that the given test failed, and was expected to do so. In Twisted 15.5 and prior, C{todo} was a mandatory parameter. @type test: L{unittest.TestCase} @param test: The test which this is about. @type failure: L{failure.Failure} @param failure: The error which this test failed with. @type todo: L{unittest.Todo} @param todo: The reason for the test's TODO status. If L{None}, a generic reason is used. Nr )r r �todor r r �addExpectedFailurej r z IReporter.addExpectedFailurec C r )a� Record that the given test failed, and was expected to do so. In Twisted 15.5 and prior, C{todo} was a mandatory parameter. @type test: L{unittest.TestCase} @param test: The test which this is about. @type todo: L{unittest.Todo} @param todo: The reason for the test's TODO status. If L{None}, a generic reason is used. Nr )r r r r r �addUnexpectedSuccessy r z IReporter.addUnexpectedSuccessc C r )z� Record that a test has been skipped for the given reason. @param test: The test that has been skipped. @param reason: An object that the test case has specified as the reason for skipping the test. Nr )r �reasonr r r �addSkip� r zIReporter.addSkipc C r )z� Return a boolean indicating whether all test results that were reported to this reporter were successful or not. Nr r r r r � wasSuccessful� r zIReporter.wasSuccessfulc C r )a1 Called when the test run is complete. This gives the result object an opportunity to display a summary of information to the user. Once you have called C{done} on an L{IReporter} object, you should assume that the L{IReporter} object is no longer usable. Nr r r r r �done� r zIReporter.done)N)r r r r r r � shouldStop�testsRunr r r r r r! r" r$ r% r& r r r r r 4 s$ �� r )r �zope.interface� interfacer � Interfacer r r r r r �<module> s &PK Mb�Z$��- �- & trial/__pycache__/util.cpython-310.pycnu �[��� o �b�0 � @ s� d Z ddlmZ ddlmZmZ ddlmZ ddlm Z ddl m Z g d�Z e � ZdZG d d � d e�ZG d d � d �Ze � Zefd d�Zdd� Zd"dd�Zdd� ZG dd� de�Zdd� ZG dd� de�Zd d � Zd#d d �Z d!S )$a A collection of utility functions and classes, used internally by Trial. This code is for Trial's internal use. Do NOT use this code if you are writing tests. It is subject to change at the Trial maintainer's whim. There is nothing here in this module for you to use unless you are maintaining Trial. Any non-Trial Twisted code that uses this module will be shot. Maintainer: Jonathan Lange @var DEFAULT_TIMEOUT_DURATION: The default timeout which will be applied to asynchronous (ie, Deferred-returning) test methods, in seconds. � )� randrange)� interfaces�utils)�Failure)�FilePath)�FilesystemLock)�DEFAULT_TIMEOUT_DURATION�excInfoOrFailureToExcInfo�suppress�acquireAttributeg ^@c @ s( e Zd ZdZddd�Zdefdd�ZdS ) �DirtyReactorAggregateErrora7 Passed to L{twisted.trial.itrial.IReporter.addError} when the reactor is left in an unclean state after a test. @ivar delayedCalls: The L{DelayedCall<twisted.internet.base.DelayedCall>} objects which weren't cleaned up. @ivar selectables: The selectables which weren't cleaned up. Nc C s || _ || _d S �N)� delayedCalls� selectables)�selfr r � r �4/usr/lib/python3/dist-packages/twisted/trial/util.py�__init__2 s z#DirtyReactorAggregateError.__init__�returnc C sP d}| j r|d7 }|d�tt| j ��7 }| jr&|d7 }|d�tt| j��7 }|S )zR Return a multi-line message describing all of the unclean state. zReactor was unclean.zM DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug) � z Selectables: )r �join�map�strr )r �msgr r r �__str__6 s �z"DirtyReactorAggregateError.__str__r )�__name__� __module__� __qualname__�__doc__r r r r r r r r ( s r c @ s` e Zd ZdZddd�Zdd� Zdd� Zd d � Zd d � Ze � ed e dd�f�Zdd� Z dd� Z dS )�_Janitorz� The guy that cleans up after you. @ivar test: The L{TestCase} to report errors about. @ivar result: The L{IReporter} to report errors to. @ivar reactor: The reactor to use. If None, the global reactor will be used. Nc C s || _ || _|| _dS )z� @param test: See L{_Janitor.test}. @param result: See L{_Janitor.result}. @param reactor: See L{_Janitor.reactor}. N)�test�result�reactor)r r r! r" r r r r R s z_Janitor.__init__c C s0 | � � }|rt|�}| j�| jt|�� dS dS )z� Called by L{unittest.TestCase} after a test to catch any logged errors or pending L{DelayedCall<twisted.internet.base.DelayedCall>}s. FT)� _cleanPendingr r! �addErrorr r )r �calls� aggregater r r �postCaseCleanup\ s z_Janitor.postCaseCleanupc C sB | � � }| �� }|s |rt||�}| j�| jt|�� | �� dS )a Called by L{unittest.TestCase} after the last test in a C{TestCase} subclass. Ensures the reactor is clean by murdering the threadpool, catching any pending L{DelayedCall<twisted.internet.base.DelayedCall>}s, open sockets etc. N)� _cleanReactorr# r r! r$ r r � _cleanThreads)r r r% r& r r r �postClassCleanuph s z_Janitor.postClassCleanupc C s$ | j dur | j }|S ddlm } |S )zI Get either the passed-in reactor or the global reactor. Nr )r" )r" �twisted.internet�r r" r r r � _getReactorv s �z_Janitor._getReactorc C s^ | � � }|�d� |�d� g }|�� D ]}|�� r#t|�}|�� ntd� |�|� q|S )zS Cancel all pending calls and return their string representations. r z)WEIRDNESS! pending timed call not active!)r- �iterate�getDelayedCalls�activer �cancel�print�append)r r" �delayedCallStrings�p� delayedStringr r r r# � s z_Janitor._cleanPending��ignorez!reactor\.iterate cannot be used.*)�category�messagec C s2 | � � }tj�|�r|jd ur|�� d S d S d S r )r- r �IReactorThreads� providedBy� threadpool�_stopThreadPoolr, r r r r) � s �z_Janitor._cleanThreadsc C sB | � � }g }|�� D ]}tj�|�r|�d� |�t|�� q |S )z� Remove all selectables from the reactor, kill any of them that were processes, and return their string representation. �KILL)r- � removeAllr �IProcessTransportr< � signalProcessr3 �repr)r r" �selectableStrings�selr r r r( � s z_Janitor._cleanReactorr )r r r r r r' r* r- r# r �suppressWarnings�DeprecationWarningr) r( r r r r r H s" ��� r c C sB | D ]}t ||�rt||� S q|tur|S td|�d| ����)z� Go through the list 'objects' sequentially until we find one which has attribute 'attr', then return the value of that attribute. If not found, return 'default' if set, otherwise, raise AttributeError. z attribute z not found in )�hasattr�getattr�_DEFAULT�AttributeError)�objects�attr�default�objr r r r � s �r c C s t | t�r| j| j| �� f} | S )a' Coerce a Failure to an _exc_info, if err is a Failure. @param err: Either a tuple such as returned by L{sys.exc_info} or a L{Failure} object. @return: A tuple like the one returned by L{sys.exc_info}. e.g. C{exception_type, exception_object, traceback_object}. )� isinstancer �type�value�getTracebackObject)�errr r r r � s r r8 c K s | f|fS )a: Sets up the .suppress tuple properly, pass options to this method as you would the stdlib warnings.filterwarnings() So, to use this with a .suppress magic attribute you would do the following: >>> from twisted.trial import unittest, util >>> import warnings >>> >>> class TestFoo(unittest.TestCase): ... def testFooBar(self): ... warnings.warn("i am deprecated", DeprecationWarning) ... testFooBar.suppress = [util.suppress(message='i am deprecated')] ... >>> Note that as with the todo and timeout attributes: the module level attribute acts as a default for the class attribute which acts as a default for the method attribute. The suppress attribute can be overridden at any level by specifying C{.suppress = []} r )�action�kwargr r r r � s r c s � �fdd�}|S )Nc sV dd l }|�� }z|j� g| �R i |��}|��� W n ty$ Y nw |�� |S )Nr )�profile�Profile�runcall� dump_stats� SystemExit� print_stats)�args�kwargsrW �profr! ��f� outputFiler r �_� s �zprofiled.<locals>._r )ra rb rc r r` r �profiled� s rd c @ � e Zd ZdZdS )�_NoTrialMarkerz� No trial marker file could be found. Raised when trial attempts to remove a trial temporary working directory that does not contain a marker file. N�r r r r r r r r rf � rf c C s� | � d��� st| �d���z| �� W dS ty_ } z>td| |j|jf � ztdt t d��� d� �}| � |� W n tyS } z td|j|jf � � d}~ww W Y d}~dS d}~ww ) z� Safely remove a path, recursively. If C{path} does not contain a node named C{_trial_marker}, a L{_NoTrialMarker} exception is raised and the path is not removed. � _trial_markerz5 is not a trial temporary path, refusing to remove itz2could not remove %r, caught OSError [Errno %s]: %ss _trial_temp_oldi��� zutf-8z4could not rename path, caught OSError [Errno %s]: %sN) �child�existsrf �remove�OSErrorr2 �errno�strerrorr r r �encode�moveTo)�path�e�newPathr r r � _removeSafely s: � ��� �������ru c @ re )�_WorkingDirectoryBusyzv A working directory was specified to the runner, but another test run is currently using that directory. Nrg r r r r rv + rh rv c C s� d} |r| � d| �� |f �}n| }t|jd �}|�� r6|�� r&t|� |�� |�d�� d� ||fS | �� dkrA|d7 }nt � �q) a0 Find an unused directory named similarly to C{base}. Once a directory is found, it will be locked and a marker dropped into it to identify it as a trial temporary directory. @param base: A template path for the discovery process. If this path exactly cannot be used, a path which varies only in a suffix of the basename will be used instead. @type base: L{FilePath} @return: A two-tuple. The first element is a L{FilePath} representing the directory which was found and created. The second element is a locked L{FilesystemLock<twisted.python.lockfile.FilesystemLock>}. Another call to C{_unusedTestDirectory} will not be able to reused the same name until the lock is released, either explicitly or by this process exiting. r Tz%s-%dz.lockri � � _trial_temp� ) �sibling�basenamer rr �lockrk ru �makedirsrj � setContentrv )�base�counter�testdir� testDirLockr r r �_unusedTestDirectory2 s �r� �, c C s� t | ttf�s td��| sdS t| �dkrt| d �S t| �dkr3t| d �� d|� dt| d �� �S g }| D ] }|�t|�� q7d�|�|dd � �|||d �S ) ad Produce a string containing each thing in C{things}, separated by a C{delimiter}, with the last couple being separated by C{finalDelimiter} @param things: The elements of the resulting phrase @type things: L{list} or L{tuple} @param finalDelimiter: What to put between the last two things (typically 'and' or 'or') @type finalDelimiter: L{str} @param delimiter: The separator to use between each thing, not including the last two. Should typically include a trailing space. @type delimiter: L{str} @return: The resulting phrase @rtype: L{str} z Things must be a list or a tuple� ry r � � z {}{}{} {}N���) rP �list�tuple� TypeError�lenr r3 �formatr )�things�finalDelimiter� delimiter� strThings�thingr r r � _listToPhrase` s" $�r� Nr7 )r� ) r �randomr r+ r r �twisted.python.failurer �twisted.python.filepathr �twisted.python.lockfiler �__all__�object�DEFAULT_TIMEOUTr � Exceptionr r rJ r r r rd rf ru rv r� r� r r r r �<module> s* o .PK Mb�Z=���- - * trial/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )a� Twisted Trial: Asynchronous unit testing framework. Trial extends Python's builtin C{unittest} to provide support for asynchronous tests. Trial strives to be compatible with other Python xUnit testing frameworks. "Compatibility" is a difficult things to define. In practice, it means that: - L{twisted.trial.unittest.TestCase} objects should be able to be used by other test runners without those runners requiring special support for Trial tests. - Tests that subclass the standard library C{TestCase} and don't do anything "too weird" should be able to be discoverable and runnable by the Trial test runner without the authors of those tests having to jump through hoops. - Tests that implement the interface provided by the standard library C{TestCase} should be runnable by the Trial runner. - The Trial test runner and Trial L{unittest.TestCase} objects ought to be able to use standard library C{TestResult} objects, and third party C{TestResult} objects based on the standard library. This list is not necessarily exhaustive -- compatibility is hard to define. Contributors who discover more helpful ways of defining compatibility are encouraged to update this document. Examples: B{Timeouts} for tests should be implemented in the runner. If this is done, then timeouts could work for third-party TestCase objects as well as for L{twisted.trial.unittest.TestCase} objects. Further, Twisted C{TestCase} objects will run in other runners without timing out. See U{http://twistedmatrix.com/trac/ticket/2675}. Running tests in a temporary directory should be a feature of the test case, because often tests themselves rely on this behaviour. If the feature is implemented in the runner, then tests will change behaviour (possibly breaking) when run in a different test runner. Further, many tests don't even care about the filesystem. See U{http://twistedmatrix.com/trac/ticket/2916}. N)�__doc__� r r �8/usr/lib/python3/dist-packages/twisted/trial/__init__.py�<module> s PK Mb�Z4���� � * trial/__pycache__/reporter.cpython-310.pycnu �[��� o �b�� � @ s d Z ddlZddlZddlZddlZddlZddlmZ ddl m Z ddl m Z m Z ddlmZ ddlmZ ddlmZ dd lmZmZ zdd lmZ W n eyW dZY nw d d � ZG d d� de�Z G dd� d�Z e ej �G dd� dej ��Z e ej �G dd� deej d���Z e ej �G dd� de ��Z!e ej �G dd� de ��Z"G dd� de �Z#e ej �G d d � d e ��Z$G d d � d e$�Z%G d d!� d!e$�Z&G d"d#� d#e$�Z'G d$d%� d%e'�Z(G d&d'� d'�Z)G d(d)� d)�Z*G d*d+� d+�Z+e ej �G d,d-� d-��Z,G d.d/� d/e$�Z-dS )0z3 Defines classes that handle the results of tests. � N)� OrderedDict)� implementer)�log�reflect)�proxyForInterface)�Failure)�untilConcludes)�itrial�util)�TestProtocolClientc C s ddl m} || �S )ad Return a L{Todo} object built from C{value}. This is a synonym for L{twisted.trial.unittest.makeTodo}, but imported locally to avoid circular imports. @param value: A string or a tuple of C{(errors, reason)}, where C{errors} is either a single exception class or an iterable of exception classes. @return: A L{Todo} object. r )�makeTodo)�twisted.trial.unittestr )�valuer � r �8/usr/lib/python3/dist-packages/twisted/trial/reporter.py� _makeTodo! s r c @ � e Zd ZdZdS )�BrokenTestCaseWarningzT Emitted as a warning when an exception occurs in one of setUp or tearDown. N��__name__� __module__� __qualname__�__doc__r r r r r 2 s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � SafeStreamz� Wraps a stream object so that all C{write} calls are wrapped in L{untilConcludes<twisted.python.util.untilConcludes>}. c C � || _ d S �N)�original)�selfr r r r �__init__> � zSafeStream.__init__c C s t | j|�S r )�getattrr )r �namer r r � __getattr__A s zSafeStream.__getattr__c O s t | jjg|�R i |��S r )r r �write)r �a�kwr r r r# D s zSafeStream.writeN)r r r r r r" r# r r r r r 8 s r c s� e Zd ZdZdZ� fdd�Zdefdd�Zdd � Zd d � Z � fd d �Z � fdd�Z dd� Z dd� Z dd� Zd!dd�Zd!dd�Zdd � Zd d � Zd d � Z� ZS )"� TestResultz� Accumulates the results of several L{twisted.trial.unittest.TestCase}s. @ivar successes: count the number of successes achieved by the test run. @type successes: C{int} zTest expected to failc s, t � �� g | _g | _g | _d| _g | _d S )Nr )�superr �skips�expectedFailures�unexpectedSuccesses� successes�_timings�r �� __class__r r r T s zTestResult.__init__�returnc C s> dt �| j�| jt| j�t| j�t| j�t| j�t| j �f S )Nz<<%s run=%d errors=%d failures=%d todos=%d dones=%d skips=%d>) r �qualr/ �testsRun�len�errors�failuresr) r( r* r- r r r �__repr__\ s �zTestResult.__repr__c C s t � � S r )�timer- r r r �_getTimeg s zTestResult._getTimec C s& t |t�rt|d |d |d �S |S )zX Convert a C{sys.exc_info()}-style tuple to a L{Failure}, if necessary. � r � )� isinstance�tupler )r �errorr r r � _getFailurej s zTestResult._getFailurec s t � �|� | �� | _dS )zq This must be called before the given test is commenced. @type test: L{pyunit.TestCase} N)r' � startTestr8 � _testStarted�r �testr. r r r? r s zTestResult.startTestc s t � �|� | �� | j | _dS )zp This must be called after the given test is completed. @type test: L{pyunit.TestCase} N)r' �stopTestr8 r@ � _lastTimerA r. r r rC { s zTestResult.stopTestc C � | j �|| �|�f� dS )z� Report a failed assertion for the given test. @type test: L{pyunit.TestCase} @type fail: L{Failure} or L{tuple} N)r5 �appendr> �r rB �failr r r � addFailure� � zTestResult.addFailurec C rE )z� Report an error that occurred while running the given test. @type test: L{pyunit.TestCase} @type error: L{Failure} or L{tuple} N)r4 rF r> �r rB r= r r r �addError� rJ zTestResult.addErrorc C s | j �||f� dS )a5 Report that the given test was skipped. In Trial, tests can be 'skipped'. Tests are skipped mostly because there is some platform or configuration issue that prevents them from being run correctly. @type test: L{pyunit.TestCase} @type reason: L{str} N)r( rF )r rB �reasonr r r �addSkip� s zTestResult.addSkipNc C s& |du r t | j�}| j�||f� dS )a� Report that the given test succeeded against expectations. In Trial, tests can be marked 'todo'. That is, they are expected to fail. When a test that is expected to fail instead succeeds, it should call this method to report the unexpected success. @type test: L{pyunit.TestCase} @type todo: L{unittest.Todo}, or L{None}, in which case a default todo message is provided. N)r � _DEFAULT_TODOr* rF �r rB �todor r r �addUnexpectedSuccess� s z TestResult.addUnexpectedSuccessc C s( |du r t | j�}| j�|||f� dS )ab Report that the given test failed, and was expected to do so. In Trial, tests can be marked 'todo'. That is, they are expected to fail. @type test: L{pyunit.TestCase} @type error: L{Failure} @type todo: L{unittest.Todo}, or L{None}, in which case a default todo message is provided. N)r rO r) rF )r rB r= rQ r r r �addExpectedFailure� s z TestResult.addExpectedFailurec C s | j d7 _ dS )z_ Report that the given test succeeded. @type test: L{pyunit.TestCase} r9 N)r+ rA r r r � addSuccess� s zTestResult.addSuccessc C s$ t | j�t | j� kodkS S )a� Report whether or not this test suite was successful or not. The behaviour of this method changed in L{pyunit} in Python 3.4 to fail if there are any errors, failures, or unexpected successes. Previous to 3.4, it was only if there were errors or failures. This method implements the old behaviour for backwards compatibility reasons, checking just for errors and failures. @rtype: L{bool} r )r3 r5 r4 r- r r r � wasSuccessful� s $ zTestResult.wasSuccessfulc C � dS )z6 The test suite has finished running. Nr r- r r r �done� � zTestResult.doner )r r r r rO r �strr6 r8 r> r? rC rI rL rN rR rS rT rU rW � __classcell__r r r. r r& H s" r& c @ r )�TestResultDecoratorz� Base class for TestResult decorators. @ivar _originalReporter: The wrapped instance of reporter. @type _originalReporter: A provider of L{itrial.IReporter} Nr r r r r r[ � s r[ �_originalReporterc @ s e Zd ZdZdd� ZdS )� UncleanWarningsReporterWrapperze A wrapper for a reporter that converts L{util.DirtyReactorAggregateError}s to warnings. c C s: t |t�r|�tj�rt�|�� � dS | j� ||� dS )z� If the error is a L{util.DirtyReactorAggregateError}, instead of reporting it as a normal error, throw a warning. N) r; r �checkr �DirtyReactorAggregateError�warnings�warn�getErrorMessager\ rL rK r r r rL � s z'UncleanWarningsReporterWrapper.addErrorN)r r r r rL r r r r r] � s r] c @ � e Zd ZdZdd� Zdd� ZdS )� _ExitWrapperza A wrapper for a reporter that causes the reporter to stop after unsuccessful tests. c O � d| _ | jj|i |��S �NT)� shouldStopr\ rL �r �args�kwargsr r r rL � z_ExitWrapper.addErrorc O re rf )rg r\ rI rh r r r rI rk z_ExitWrapper.addFailureN)r r r r rL rI r r r r rd � s rd c @ sT e Zd ZdZdd� Zdd� Zddd�Zd d � Zd d � Zdd d�Z dd� Z dd� Z dS )�_AdaptedReporterz� TestResult decorator that makes sure that addError only gets tests that have been adapted with a particular test adapter. c C s t �| |� || _dS )z� Construct an L{_AdaptedReporter}. @param original: An {itrial.IReporter}. @param testAdapter: A callable that returns an L{itrial.ITestCase}. N)r[ r � testAdapter)r r rm r r r r s z_AdaptedReporter.__init__c C � | � |�}| j�||�S �z* See L{itrial.IReporter}. )rm r\ rL rK r r r rL � z_AdaptedReporter.addErrorNc C s | j �| �|�||�S )at See L{itrial.IReporter}. @type test: A L{pyunit.TestCase}. @type failure: A L{failure.Failure} or L{AssertionError} @type todo: A L{unittest.Todo} or None When C{todo} is L{None} a generic C{unittest.Todo} is built. L{pyunit.TestCase}'s C{run()} calls this with 3 positional arguments (without C{todo}). )r\ rS rm )r rB �failurerQ r r r rS % s �z#_AdaptedReporter.addExpectedFailurec C rn ro )rm r\ rI )r rB rq r r r rI 6 rp z_AdaptedReporter.addFailurec C rn ro )rm r\ rN )r rB �skipr r r rN = rp z_AdaptedReporter.addSkipc C rn )a3 See L{itrial.IReporter}. @type test: A L{pyunit.TestCase}. @type todo: A L{unittest.Todo} or None When C{todo} is L{None} a generic C{unittest.Todo} is built. L{pyunit.TestCase}'s C{run()} calls this with 2 positional arguments (without C{todo}). )rm r\ rR rP r r r rR D s z%_AdaptedReporter.addUnexpectedSuccessc C � | j �| �|��S ro )r\ r? rm rA r r r r? S � z_AdaptedReporter.startTestc C rs ro )r\ rC rm rA r r r rC Y rt z_AdaptedReporter.stopTestr ) r r r r r rL rS rI rN rR r? rC r r r r rl s rl c s� e Zd ZdZdZdZejdddf� fdd� Zd d � Z � fd d �Z � fd d�Z � fdd�Z dd� Z dd� Zd.� fdd� Z� fdd�Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Z� ZS )/�Reportera� A basic L{TestResult} with support for writing to a stream. @ivar _startTime: The time when the first test was started. It defaults to L{None}, which means that no test was actually launched. @type _startTime: C{float} or L{None} @ivar _warningCache: A C{set} of tuples of warning message (file, line, text, category) which have already been written to the output stream during the currently executing test. This is used to avoid writing duplicates of the same warning to the output stream. @type _warningCache: C{set} @ivar _publisher: The log publisher which will be observed for warning events. @type _publisher: L{twisted.python.log.LogPublisher} zO-------------------------------------------------------------------------------zO===============================================================================�defaultFNc sP t � �� t|�| _|| _|| _d | _t� | _|| _ |d ur&|� | j � d S d S r ) r' r r �_stream�tbformat�realtime� _startTime�set� _warningCache� _publisher� addObserver�_observeWarnings�r �streamrx ry � publisherr. r r r w s �zReporter.__init__c C sd d|v r.|d |d |d � d�d t|d �f}|| jvr0| j�|� | j�d| � dS dS dS ) a| Observe warning events and write them to C{self._stream}. This method is a log observer which will be registered with C{self._publisher.addObserver}. @param event: A C{dict} from the logging system. If it has a C{'warning'} key, a logged warning will be extracted from it and possibly written to C{self.stream}. �warning�filename�lineno�category�.���z%s:%s: %s: %s N)�splitrY r| �addrw r# )r �event�keyr r r r � s � �zReporter._observeWarningsc s, t � �|� | jdu r| �� | _t� | _dS )z� Called when a test begins to run. Records the time when it was first called and resets the warning cache. @param test: L{ITestCase} N)r' r? rz r8 r{ r| rA r. r r r? � s zReporter.startTestc s: t � �||� | jr| jd d }| �| �|�� dS dS )z� Called when a test fails. If C{realtime} is set, then it prints the error to the stream. @param test: L{ITestCase} that failed. @param fail: L{failure.Failure} containing the error. r� r9 N)r' rI ry r5 �_write�_formatFailureTracebackrG r. r r rI � s �zReporter.addFailurec sD | � |�}t� �||� | jr | jd d }| �| �|�� dS dS )z� Called when a test raises an error. If C{realtime} is set, then it prints the error to the stream. @param test: L{ITestCase} that raised the error. @param error: L{failure.Failure} containing the error. r� r9 N)r> r' rL ry r4 r� r� rK r. r r rL � s �zReporter.addErrorc G sH t |�}t|t �s J �|r| j�|| � n| j�|� t| jj� dS )z� Safely write to the reporter's stream. @param format: A format string to write. @param args: The arguments for the format string. N)rY r; rw r# r �flush)r �formatri �sr r r r� � s zReporter._writec G s | j |g|�R � | � d� dS )z� Safely write a line to the reporter's stream. Newline is appended to the format string. @param format: A format string to write. @param args: The arguments for the format string. � N)r� �r r� ri r r r �_writeln� s zReporter._writelnTc sN t � �||||� |r%| �|�}t�|� d�||�}tj|tdd� d S d S )Nz3caught exception in {}, your TestCase is broken {}r: )� stacklevel) r' � upDownErrorr� r �msgr� r` ra r )r �methodr= ra � printStatus�tbStrr� r. r r r� � s ��zReporter.upDownErrorc s* t � �|� t�dd| �|�f t� d S )Nz%s %sz&REACTOR UNCLEAN! traceback(s) follow: )r' � cleanupErrorsr` ra r� r �r �errsr. r r r� � s ���zReporter.cleanupErrorsc C sd t |�}t|�dk r |S |d d }tj�tj�|d d ��d }|d d }tj�tj�|d d ��d }d}d}||f||ff} |D ]"} tj�tj�| d ��d } | dkrh| d dkrh|�|�| �� qF| |krt|dd� }n| |kr|d d� }n ||fd kr�|dd� }|s�|S |d } | d �d �r�tj�tj�| d ��d d kr�|dd � }|S )a) Trim frames to remove internal paths. When a C{SynchronousTestCase} method fails synchronously, the stack looks like this: - [0]: C{SynchronousTestCase._run} - [1]: C{util.runWithWarningsSuppressed} - [2:-2]: code in the test method which failed - [-1]: C{_synctest.fail} When a C{TestCase} method fails synchronously, the stack looks like this: - [0]: C{defer.maybeDeferred} - [1]: C{utils.runWithWarningsSuppressed} - [2]: C{utils.runWithWarningsSuppressed} - [3:-2]: code in the test method which failed - [-1]: C{_synctest.fail} When a method fails inside a C{Deferred} (i.e., when the test method returns a C{Deferred}, and that C{Deferred}'s errback fires), the stack captured inside the resulting C{Failure} looks like this: - [0]: C{defer.Deferred._runCallbacks} - [1:-2]: code in the testmethod which failed - [-1]: C{_synctest.fail} As a result, we want to trim either [maybeDeferred, runWWS, runWWS] or [Deferred._runCallbacks] or [SynchronousTestCase._run, runWWS] from the front, and trim the [unittest.fail] from the end. There is also another case, when the test method is badly defined and contains extra arguments. If it doesn't recognize one of these cases, it just returns the original frames. @param frames: The C{list} of frames from the test failure. @return: The C{list} of frames to display. r: r r9 ))�_run� _synctest)�runWithWarningsSuppressedr ))� maybeDeferred�defer)r� �utils�compat�reraiseN� )� _runCallbacksr� r� rH r� ) �listr3 �os�path�splitext�basename�pop�index� startswith) r �frames� newFrames� firstMethod� firstFile� secondMethod� secondFile�syncCase� asyncCase� twoFrames�frame� frameFile�lastr r r � _trimFrames� s: ( � � zReporter._trimFramesc C sF t |t�r |�� d S | �|j�|j|_}|j| jdd�}||_|S )Nr� T)�detail�elideFrameworkCode)r; rY �rstripr� r� � getTracebackrx )r rH r� �resultr r r r� G s z Reporter._formatFailureTracebackc C sJ t � }|D ]}|d }|dd� }||� }|�|g ��|� qt|�� �S )a Group tests together based on their results. @param results: An iterable of tuples of two or more elements. The first element of each tuple is a test case. The remaining elements describe the outcome of that test case. @param formatter: A callable which turns a test case result into a string. The elements after the first of the tuples in C{results} will be passed as positional arguments to C{formatter}. @return: A C{list} of two-tuples. The first element of each tuple is a unique string describing one result from at least one of the test cases in C{results}. The second element is a list of the test cases which had that result. r r9 N)r � setdefaultrF r� �items)r �results� formatter�groups�content�case�outcomer� r r r � _groupResultsO s zReporter._groupResultsc C s\ | � ||�D ]%\}}| �| j� | �|� | �|� | �d� |D ] }| �|�� � q!qdS )a< Print a group of errors to the stream. @param flavor: A string indicating the kind of error (e.g. 'TODO'). @param errors: A list of errors, often L{failure.Failure}s, but sometimes 'todo' errors. @param formatter: A callable that knows how to format the errors. � N)r� r� �_doubleSeparatorr� �id)r �flavorr4 r� rM �casesr� r r r � _printResultsi s ��zReporter._printResultsc C s d� |j| �|��S )NzReason: {!r} {})r� rM r� )r r= rQ r r r �_printExpectedFailurez s �z Reporter._printExpectedFailurec C s. d|j �d�}|jr|d�d�|j��7 }|S )NzReason: r� zExpected errors: {} �, )rM r4 r� �join)r rQ �retr r r �_printUnexpectedSuccess s z Reporter._printUnexpectedSuccessc C sj | � d� | �d| jdd� � | �d| j| j� | �d| j| j� | �d| j| j� | �d| j| j � d S ) zM Print all of the non-success results to the stream in full. r� � [SKIPPED]c S s d| S )N�%s r )�xr r r �<lambda>� s z'Reporter._printErrors.<locals>.<lambda>�[TODO]�[FAIL]�[ERROR]� [SUCCESS!?!]N) r� r� r( r) r� r5 r� r4 r* r� r- r r r � _printErrors� s �zReporter._printErrorsc C sh g }dD ]}t t| |��}|r|�d||f � q| jr%|�d| jf � |r0dd�|� d p1d}|S )zC Return a formatted count of tests status results. )r( r) r5 r4 r* z%s=%dz successes=%dz (r� �)r� )r3 r rF r+ r� )r � summaries�stat�num�summaryr r r � _getSummary� s �zReporter._getSummaryc C s, | � � }| �� r d}nd}| �d||� dS )zJ Print a line summarising the test results to the stream. �PASSED�FAILEDz%s%s N)r� rU r� )r r� �statusr r r � _printSummary� s zReporter._printSummaryc C sf | j dur | j �| j� | �� | �| j� | jdur(| �d| jt�� | j � | � d� | � � dS )a� Summarize the result of the test run. The summary includes a report of all of the errors, todos, skips and so forth that occurred during the run. It also includes the number of tests that were run and how long it took to run them (not including load time). Expects that C{_printErrors}, C{_writeln}, C{_write}, C{_printSummary} and C{_separator} are all implemented. NzRan %d tests in %.3fsr� ) r} �removeObserverr r� r� � _separatorrz r2 r7 r� r� r- r r r rW � s � z Reporter.done)TT) r r r r r� r� �sys�stdoutr r r? rI rL r� r� r� r� r� r� r� r� r� r� r� r� r� rW rZ r r r. r ru ` s0 � T ru c @ rc )�MinimalReporterz� A minimalist reporter that prints only a summary of the test result, in the form of (timeTaken, #tests, #tests, #errors, #failures, #skips). c C rV )zb Don't print a detailed summary of errors. We only care about the counts. Nr r- r r r r� � rX z MinimalReporter._printErrorsc C s` | j }| jdur| �� | j }nd}|||t| j�t| j�t| j�f}| �d�t t |��� dS )z� Print out a one-line summary of the form: '%(runtime) %(number_of_tests) %(number_of_tests) %(num_errors) %(num_failures) %(num_skips)' Nr � ) r2 rz r8 r3 r4 r5 r( r� r� �maprY )r �numTests�timing�tr r r r� � s �z MinimalReporter._printSummaryN)r r r r r� r� r r r r r� � s r� c s\ e Zd ZdZ� fdd�Z� fdd�Z� fdd�Z� fdd �Z� fd d �Z� fd d �Z � Z S )� TextReporterz� Simple reporter that prints a single character for each test as it runs, along with the standard Trial summary text. c � t � �|� | �d� d S )Nr� �r' rT r� rA r. r r rT � � zTextReporter.addSuccessc � t � j|� | �d� d S )N�E�r' rL r� �r ri r. r r rL � r� zTextReporter.addErrorc r� )N�F�r' rI r� r� r. r r rI � r� zTextReporter.addFailurec r� )N�S�r' rN r� r� r. r r rN � r� zTextReporter.addSkipc r� )N�T�r' rS r� r� r. r r rS r� z TextReporter.addExpectedFailurec r� )N�!�r' rR r� r� r. r r rR r� z!TextReporter.addUnexpectedSuccess) r r r r rT rL rI rN rS rR rZ r r r. r r� � s r� c st e Zd ZdZ� fdd�Z� fdd�Z� fdd�Z� fdd �Z� fd d �Z� fd d �Z � fdd�Z � fdd�Z � Z S )�VerboseTextReporterz� A verbose reporter that prints the name of each test as it is running. Each line is printed with the name of the test, followed by the result of that test. c s | � d|�� � t� �|� d S )Nz%s ... )r� r� r' r? )r �tmr. r r r? s z VerboseTextReporter.startTestc r� �Nz[OK]r� rA r. r r rT r� z VerboseTextReporter.addSuccessc r� �Nr� r� r� r. r r rL r� z VerboseTextReporter.addErrorc r� )Nz [FAILURE]r� r� r. r r rI r� z VerboseTextReporter.addFailurec r� �Nr� r� r� r. r r rN $ r� zVerboseTextReporter.addSkipc r� �Nr� r r� r. r r rS ( r� z&VerboseTextReporter.addExpectedFailurec r� �Nr� r r� r. r r rR , r� z(VerboseTextReporter.addUnexpectedSuccessc r� )Nr� )r' rC r� rA r. r r rC 0 r� z VerboseTextReporter.stopTest) r r r r r? rT rL rI rN rS rR rC rZ r r r. r r s r c s e Zd ZdZ� fdd�Z� ZS )�TimingTextReporterze Prints out each test as it is running, followed by the time taken for each test to run. c s t � �|� | �d| j � dS )zm Mark the test as stopped, and write the time it took to run the test to the stream. z (%.03f secs) N)r' rC r� rD )r r� r. r r rC ; s zTimingTextReporter.stopTest)r r r r rC rZ r r r. r r 5 s r c @ sJ e Zd ZdZedddddddd d �Zd d � Zeej fd d��Z dd� Z dS )�_AnsiColorizerz� A colorizer is an object that loosely wraps around a stream, allowing callers to write text to the stream in a particular color. Colorizer classes must implement C{supported()} and C{write(text, color)}. � � � �! �" �# �$ �% )�black�red�green�yellow�blue�magenta�cyan�whitec C r r �r� �r r� r r r r P r z_AnsiColorizer.__init__c C s� |� � sdS zddl}W n ty Y dS w z z |�d�dkW W S |jy7 |�� |�d�dk Y W S w tyA Y dS w )z� A class method that returns True if the current platform supports coloring terminal output using this method. Returns False otherwise. Fr N�colorsr: )�isatty�curses� ImportError�tigetnumr= � setupterm� BaseException)�clsr� r r r r � supportedS s" �� �z_AnsiColorizer.supportedc C s( | j | }| j�d|� d|� d�� dS )z� Write the given text to the stream in the given color. @param text: Text to be written to the stream. @param color: A string label for a color. e.g. 'red', 'white'. z[z;1mz[0mN)�_colorsr� r# �r �text�colorr r r r# j s z_AnsiColorizer.writeN) r r r r �dictr' r � classmethodr� r� r& r# r r r r r D s � r c @ �2 e Zd ZdZdd� Zeejfdd��Zdd� Z dS ) �_Win32Colorizer�' See _AnsiColorizer docstring. c C s� ddl m}m}m}m}m}m} ||||f\}} } } || _||�| _|| B | B || B | | B | | B || B | B || B | B | | B | B || B | B | B d�| _ d S )Nr )�FOREGROUND_BLUE�FOREGROUND_GREEN�FOREGROUND_INTENSITY�FOREGROUND_RED�STD_OUTPUT_HANDLE� GetStdHandle)�normalr r r r r r r ) � win32consoler0 r1 r2 r3 r4 r5 r� � screenBufferr' ) r r� r0 r1 r2 r3 r4 r5 r r r �boldr r r r { s" � �z_Win32Colorizer.__init__c C sl z dd l }|�|j�}W n ty Y dS w dd l}z|�|j|jB |jB � W dS |j y5 Y dS w )Nr FT) r7 r5 r4 r! � pywintypes�SetConsoleTextAttributer3 r1 r0 r= )r% r� r7 r8 r: r r r r& � s& ������z_Win32Colorizer.supportedc C s8 | j | }| j�|� | j�|� | j�| j d � d S )Nr6 )r' r8 r; r� r# r( r r r r# � s z_Win32Colorizer.writeN� r r r r r r, r� r� r& r# r r r r r. v s r. c @ r- ) �_NullColorizerr/ c C r r r r r r r r � r z_NullColorizer.__init__c C rV rf r )r% r� r r r r& � s z_NullColorizer.supportedc C s | j �|� d S r )r� r# r( r r r r# � s z_NullColorizer.writeNr< r r r r r= � s r= c @ s� e Zd ZdZdZejdddfdd�Zdd� Ze d d � �Z d d � Z d d� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zd dd �Zd d d �ZdS ) �SubunitReporterz� Reports test output via Subunit. @ivar _subunit: The subunit protocol client that we are wrapping. @ivar _successful: An internal variable, used to track whether we have received only successful results. @since: 10.0 Nrv Fc C s$ t du rtd��t |�| _d| _dS )aI Construct a L{SubunitReporter}. @param stream: A file-like object representing the stream to print output to. Defaults to stdout. @param tbformat: The format for tracebacks. Ignored, since subunit always uses Python's standard format. @param realtime: Whether or not to print exceptions in the middle of the test results. Ignored, since subunit always does this. @param publisher: The log publisher which will be preserved for reporting events. Ignored, as it's not relevant to subunit. NzSubunit not availableT)r � Exception�_subunit� _successfulr� r r r r � s zSubunitReporter.__init__c C rV )z� Record that the entire test suite run is finished. We do nothing, since a summary clause is irrelevant to the subunit protocol. Nr r- r r r rW � s zSubunitReporter.donec C s | j jS )zK Whether or not the test runner should stop running tests. )r@ rg r- r r r rg � s zSubunitReporter.shouldStopc C s | j �� S )zH Signal that the test runner should stop running tests. )r@ �stopr- r r r rB � s zSubunitReporter.stopc C s | j S )z� Has the test run been successful so far? @return: C{True} if we have received no reports of errors or failures, C{False} otherwise. )rA r- r r r rU � s z SubunitReporter.wasSuccessfulc C � | j �|�S )z2 Record that C{test} has started. )r@ r? rA r r r r? � zSubunitReporter.startTestc C rC )z4 Record that C{test} has completed. )r@ rC rA r r r rC rD zSubunitReporter.stopTestc C rC )z5 Record that C{test} was successful. )r@ rT rA r r r rT rD zSubunitReporter.addSuccessc C s6 t | jdd�}|du r| �|� dS | j�||� dS )a� Record that C{test} was skipped for C{reason}. Some versions of subunit don't have support for addSkip. In those cases, the skip is reported as a success. @param test: A unittest-compatible C{TestCase}. @param reason: The reason for it being skipped. The C{str()} of this object will be included in the subunit output stream. rN N)r r@ rT rN )r rB rM rN r r r rN s zSubunitReporter.addSkipc C � d| _ | j�|t�|��S )z� Record that C{test} failed with an unexpected error C{err}. Also marks the run as being unsuccessful, causing L{SubunitReporter.wasSuccessful} to return C{False}. F)rA r@ rL r �excInfoOrFailureToExcInfo�r rB �errr r r rL , � zSubunitReporter.addErrorc C rE )z� Record that C{test} failed an assertion with the error C{err}. Also marks the run as being unsuccessful, causing L{SubunitReporter.wasSuccessful} to return C{False}. F)rA r@ rI r rF rG r r r rI 6 rI zSubunitReporter.addFailurec C s< t �|�}t| jdd�}|du r| �|� dS |||� dS )z� Record an expected failure from a test. Some versions of subunit do not implement this. For those versions, we record a success. rS N)r rF r r@ rT )r rB rq rQ rS r r r rS @ s z"SubunitReporter.addExpectedFailurec C s | � |� dS )z� Record an unexpected success. Since subunit has no way of expressing this concept, we record a success on the subunit stream. N)rT rP r r r rR N s z$SubunitReporter.addUnexpectedSuccessr )r r r r r2 r� r� r rW �propertyrg rB rU r? rC rT rN rL rI rS rR r r r r r> � s$ � r> c s� e Zd ZdZdZdZdZdZdZdZ dZ dZ dZ e jf� fdd � Zd d � Z� fd d �Z� fdd�Z� fdd�Z� fdd�Z� fdd�Z� fdd�Z� fdd�Zdd� Zd d � Z� fd d �Z� fd d!�Z� fd"d#�Z � fd$d%�Z d&d'� Z � Z S )(� TreeReporterz� Print out the tests in the form a tree. Tests are indented according to which class and module they belong. Results are printed in ANSI color. r� z �O r r r c sN t � j|g|�R i |�� g | _tttfD ]}|�|�r$||�| _ d S qd S r )r' r � _lastTestr. r r= r& � _colorizer)r r� ri rj � colorizerr. r r r l s ��zTreeReporter.__init__c C s |� � �d�d S )z� Return the name of the method which 'test' represents. This is what gets displayed in the leaves of the tree. e.g. getDescription(TestCase('test_foo')) ==> test_foo r� r� )r� r� rA r r r �getDescriptiont s zTreeReporter.getDescriptionc s t � �|� | �d| j� d S r )r' rT �endLine�SUCCESSrA r. r r rT } � zTreeReporter.addSuccessc � t � j|� | �d| j� d S r )r' rL rQ �ERRORr� r. r r rL � rS zTreeReporter.addErrorc rT )Nr� )r' rI rQ �FAILUREr� r. r r rI � rS zTreeReporter.addFailurec rT r )r' rN rQ �SKIPr� r. r r rN � rS zTreeReporter.addSkipc rT r )r' rS rQ �TODOr� r. r r rS � rS z TreeReporter.addExpectedFailurec rT r )r' rR rQ �TODONEr� r. r r rR � rS z!TreeReporter.addUnexpectedSuccessc s$ |r|| }|| _ t� �| j � d S r )� currentLiner' r� r� r. r r r� � s zTreeReporter._writec C sJ |� d�dd� }t|�dkr|S dd� d�|dd� �|d fD �}|S )z� Return a list of all non-leaf segments to display in the tree. Normally this is the module and class name. r� Nr� r c S s g | ] }t |�d kr|�qS )r )r3 )�.0�segr r r � <listcomp>� s z4TreeReporter._getPreludeSegments.<locals>.<listcomp>)r� r3 r� )r �testID�segmentsr r r �_getPreludeSegments� s �z TreeReporter._getPreludeSegmentsc C s| | � |�}d}|D ]/}|t| j�k r'|| j| kr&| �| j| � |� d�� n | �| j| � |� d�� |d7 }q || _dS )z� Write the name of the test to the stream, indenting it appropriately. If the test is the first test in a new 'branch' of the tree, also write all of the parents in that branch. r r� r9 N)r` r3 rM r� �indent)r r^ r_ � indentLevelr\ r r r � _testPrelude� s � zTreeReporter._testPreludec s. | j �d| j� | �d| j� t� �|� d S )Nz cleanup errorsr� )rN r# rU rQ r' r� r� r. r r r� � s zTreeReporter.cleanupErrorsc s< | j �d| | j� |r| �d| j� t� �||||� d S )Nz %sr� )rN r# rU rQ r' r� )r r� r= ra r� r. r r r� � s zTreeReporter.upDownErrorc sB | � |�� � | �d| jt| j� | �|�f � t� �|� dS )zn Called when C{test} starts. Writes the tests name to the stream using a tree format. z %s%s ... N) rc r� r� ra r3 rM rP r' r? rA r. r r r? � s ��zTreeReporter.startTestc sF d| j t| j� t|� }t� �|� | j�||� t� �d� dS )z� Print 'message' in the given color. @param message: A string message, usually '[OK]' or something similar. @param color: A string color, 'red', 'green' and so forth. r� r� N)�columnsr3 rZ r' r� rN r# )r �messager* �spacesr. r r rQ � s zTreeReporter.endLinec C sD | � � }| �� rd}| j}nd}| j}| j�||� | �d|� dS )zo Print a line summarising the test results to the stream, and color the status result. r� r� r� N)r� rU rR rV rN r# r� )r r� r� r* r r r r� � s zTreeReporter._printSummary) r r r r rZ ra rd rV rU rX rW rY rR r� r� r rP rT rL rI rN rS rR r� r` rc r� r� r? rQ r� rZ r r r. r rK Y s6 rK ).r r� r� r7 �unittest�pyunitr` � collectionsr �zope.interfacer �twisted.pythonr r �twisted.python.componentsr �twisted.python.failurer �twisted.python.utilr � twisted.trialr r �subunitr r! r �Warningr r � IReporterr& r[ r] rd rl ru r� r� r r r r. r= r> rK r r r r �<module> s` � � R j" +2> PK Mb�Z��,i ,i ( trial/__pycache__/runner.cpython-310.pycnu �[��� o �b�| � @ s� d Z g d�ZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z ddlmZ ddlmZmZmZmZmZ ddlmZmZ dd lmZmZ dd l m Z dd l m Z dd l m!Z!m"Z" dd l#m$Z$ e%d�Z&dd� Z'dd� Z(dd� Z)dd� Z*dd� Z+dd� Z,dd � Z-G d d � d e$�Z.d Z/G d d!� d!e$�Z0G d"d#� d#e$�Z1d$d%� Z2d&d'� Z3e e �G d(d)� d)��Z4G d*d+� d+e4�Z5G d,d-� d-�Z6d.d/� Z7G d0d1� d1�Z8dS )2zK A miscellany of code used to run Trial tests. Maintainer: Jonathan Lange )� TestSuite�DestructiveTestSuite� ErrorHolder� LoggedSuite� TestHolder� TestLoader� TrialRunner� TrialSuite�filenameToModule� isPackage�isPackageDirectory� isTestCase�name�samefile� NOT_IN_TEST� N)�SourceFileLoader)� implementer)�defer)�failure�filepath�log�modules�reflect)�unittest�util)� _ForceGarbageCollectionDecorator� _iterateTests)� _logObserver)� ITestCase)� UncleanWarningsReporterWrapper� _ExitWrapper)r r c C s2 t | tj�sdS tj�tj�| j��d }|dkS )z>Given an object return True if the object looks like a packageFr �__init__)� isinstance�types� ModuleType�os�path�splitext�basename�__file__)�moduler( � r+ �6/usr/lib/python3/dist-packages/twisted/trial/runner.pyr 8 s r c C s> dd� }|� D ]}d| }t j�t j�| |��r | S qdS )z� Is the directory at path 'dirname' a Python package directory? Returns the name of the __init__ file (it may have a weird extension) if dirname is a package directory. Otherwise, returns False c S s t j�� S �N)� importlib� machinery� all_suffixesr+ r+ r+ r, � _getSuffixesG � z(isPackageDirectory.<locals>._getSuffixesr! F)r% r& �exists�join)�dirnamer1 �ext�initFiler+ r+ r, r @ s �r c C s t j�| �t j�|�kS )z� A hacky implementation of C{os.path.samefile}. Used by L{filenameToModule} when the platform doesn't provide C{os.path.samefile}. Do not use this. )r% r& �abspath)� filename1� filename2r+ r+ r, r Q s r c C s | }dt j kr dk r n ntj�| �s tj�t�� | �} tj�| �s+t|�d���t � | �}zt � |�}W n tt fyH t | |d� Y S w t|dd�du rWt | |d�S tj�|j�d d }ttjd t�}tj�| �r|| |�st j|j= t | |d�}|S ) aV Given a filename, do whatever possible to return a module object matching that file. If the file in question is a module in Python path, properly import and return that module. Otherwise, load the source manually. @param fn: A filename. @return: A module object. @raise ValueError: If C{fn} does not exist. )� � )r; � z doesn't exist)� moduleNamer) Nr z.pyr )�sys� version_infor% r& �isabsr4 �getcwdr3 � ValueErrorr �filenameToModuleName�namedAny�AttributeError�_importFromFile�getattrr' r) r �isfiler �__name__)�fn�oldFnr> �ret�retFile�samer+ r+ r, r Y s& & � r c C s| t | �} |stj�tj�| �d �d }|tjv r tj| S tj� || �}|s+t | ��tj� |�}|j � |� |tj|< |S )N���r )�_resolveDirectoryr% r& r' �splitr? r r. r �spec_from_file_location� SyntaxError�module_from_spec�loader� exec_module)rK r> �specr* r+ r+ r, rG � s rG c C s< t j�| �r t| �}|rt j�| |�} | S t| �d���| S )Nz is not a package directory)r% r& �isdirr r4 rC )rK r7 r+ r+ r, rQ � s �rQ c C sH t | j| jt� �| kr!t| j�D ]}t | j|t� �| kr | S q| jS )z� Find the attribute name on the method's class which refers to the method. For some methods, notably decorators which have not had __name__ set correctly: getattr(method.im_class, method.__name__) != method )rH �im_classrJ �object�dir)�method�aliasr+ r+ r, �_getMethodNameInClass� s �r_ c @ s e Zd ZdZdd� ZdS )r zQ A test suite which remove the tests once run, to minimize memory usage. c C s0 | j r|jr |S | j �d�}||� | j s|S )zn Almost the same as L{TestSuite.run}, but with C{self._tests} being empty at the end. r )�_tests� shouldStop�pop)�self�result�testr+ r+ r, �run� s ��zDestructiveTestSuite.runN)rJ � __module__� __qualname__�__doc__rf r+ r+ r+ r, r � s r z <not in test>c s e Zd ZdZ� fdd�Z� ZS )r z[ Any errors logged in this suite will be reported to the L{TestResult} object. c sJ t }|�� t� �|� |�� |�� D ] }|�tt�|� q|� � dS )z� Run the suite, storing all errors in C{result}. If an error is logged while no tests are running, then it will be added as an error to C{result}. @param result: A L{TestResult} object. N) r �_add�superrf �_remove� getErrors�addErrorr r � flushErrors)rc rd �observer�error�� __class__r+ r, rf � s zLoggedSuite.run)rJ rg rh ri rf � __classcell__r+ r+ rr r, r � s r c s2 e Zd ZdZd � fdd� Zdd� Zdd � Z� ZS ) r z� Suite to wrap around every single test in a C{trial} run. Used internally by Trial to set up things necessary for Trial tests to work, regardless of what context they are run in. r+ Fc sF |rg }|D ] }t �|t�}|�|� q|}t|�}t� �|g� d S r- )r �decorater �appendr rk r! )rc �tests�forceGarbageCollection�newTestsre �suiterr r+ r, r! � s zTrialSuite.__init__c sH ddl m} t�� � |�dd� fdd�� |�d� t�d��� � d S )Nr )�reactor�after�shutdownc s � � d �S r- )�callbackr+ ��dr+ r, �<lambda>� � z"TrialSuite._bail.<locals>.<lambda>�mktemp) �twisted.internetr{ r �Deferred�addSystemEventTrigger�fireSystemEventr �TestCase�_wait)rc r{ r+ r r, �_bail� s zTrialSuite._bailc C s& z t �| |� W | �� d S | �� w r- )r rf r� �rc rd r+ r+ r, rf � s zTrialSuite.run)r+ F)rJ rg rh ri r! r� rf rt r+ r+ rr r, r � s r c C s@ t | �r t�| �}|S z| �� }W |S ty | j}Y |S w )z� @param thing: an object from modules (instance of PythonModule, PythonAttribute), a TestCase subclass, or an instance of a TestCase. )r r �qual�idrF r )�thing�theNamer+ r+ r, r s � ��r c C s$ zt | tj�W S ty Y dS w )z� @return: C{True} if C{obj} is a class that contains test cases, C{False} otherwise. Used to find all the tests in a module. F)� issubclass�pyunitr� � TypeError)�objr+ r+ r, r s �r c @ sD e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dS )r z� Placeholder for a L{TestCase} inside a reporter. As far as a L{TestResult} is concerned, this looks exactly like a unit test. Nc C s || _ dS )zM @param description: A string to be displayed L{TestResult}. N�� description)rc r� r+ r+ r, r! , s zTestHolder.__init__c C s | � |�S r- �rf r� r+ r+ r, �__call__2 r2 zTestHolder.__call__c C � | j S r- r� �rc r+ r+ r, r� 5 � z TestHolder.idc C s dS )Nr r+ r� r+ r+ r, �countTestCases8 s zTestHolder.countTestCasesc C s" |� | � |�| � |�| � dS )z� This test is just a placeholder. Run the test successfully. @param result: The C{TestResult} to store the results in. @type result: L{twisted.trial.itrial.IReporter}. N)� startTest� addSuccess�stopTestr� r+ r+ r, rf ; s zTestHolder.runc C r� r- r� r� r+ r+ r, �shortDescriptionF r� zTestHolder.shortDescription) rJ rg rh ri �failureExceptionr! r� r� r� rf r� r+ r+ r+ r, r # s r c s6 e Zd ZdZ� fdd�Zdefdd�Zdd� Z� ZS ) r a Used to insert arbitrary errors into a test suite run. Provides enough methods to look like a C{TestCase}, however, when it is run, it simply adds an error to the C{TestResult}. The most common use-case is for when a module fails to import. c s t � �|� t�|�| _dS )a+ @param description: A string used by C{TestResult}s to identify this error. Generally, this is the name of a module that failed to import. @param error: The error to be added to the result. Can be an `exc_info` tuple or a L{twisted.python.failure.Failure}. N)rk r! r �excInfoOrFailureToExcInforq )rc r� rq rr r+ r, r! R s zErrorHolder.__init__�returnc C s d� | j| jd �S )Nz)<ErrorHolder description={!r} error={!r}>� )�formatr� rq r� r+ r+ r, �__repr__] s �zErrorHolder.__repr__c C s& |� | � |�| | j� |�| � dS )z� Run the test, reporting the error. @param result: The C{TestResult} to store the results in. @type result: L{twisted.trial.itrial.IReporter}. N)r� rn rq r� r� r+ r+ r, rf c s zErrorHolder.run) rJ rg rh ri r! �strr� rf rt r+ r+ rr r, r J s r c @ s� e Zd ZdZdZdZdd� Zdd� Zdd � Zd&d d �Z d d� Z e Z dd� Z e Z dd� Zdd� Zdd� Zd&dd�Zdd� Zd'd d �Zd&d d �ZeZd&d d!�Zd"d#� Zd&d$d%�ZdS )(r a4 I find tests inside function, modules, files -- whatever -- then return them wrapped inside a Test (either a L{TestSuite} or a L{TestCase}). @ivar methodPrefix: A string prefix. C{TestLoader} will assume that all the methods in a class that begin with C{methodPrefix} are test cases. @ivar modulePrefix: A string prefix. Every module in a package that begins with C{modulePrefix} is considered a module full of tests. @ivar forceGarbageCollection: A flag applied to each C{TestCase} loaded. See L{unittest.TestCase} for more information. @ivar sorter: A key function used to sort C{TestCase}s, test classes, modules and packages. @ivar suiteFactory: A callable which is passed a list of tests (which themselves may be suites of tests). Must return a test suite. re �test_c C s t | _t| _g | _d S r- )r � suiteFactoryr �sorter� _importErrorsr� r+ r+ r, r! � s zTestLoader.__init__c C s t || jd�S )zt Sort the given things using L{sorter}. @param xs: A list of test cases, class or modules. )�key)�sortedr� )rc �xsr+ r+ r, �sort� s zTestLoader.sortc C s4 g }t �|�D ] \}}t|�r|�|� q| �|�S )z-Given a module, return all Trial test classes)�inspect� getmembersr rv r� )rc r* �classesr �valr+ r+ r, �findTestClasses� s � zTestLoader.findTestClassesFc C sb t j|v r!t�|�}zt|� W n ty | j||d� Y S w |}d } }}t|�D ]B\}}z t�|�}|}W n4 tyo t � � d } | j durU| j } | j dusM| j j j} | tjkr`� |dkrmt�d|� d���Y q-w |du r�t�|�}|�d�td�|j��d d� }z|D ] } |t|| �}}q�W n ty� t|� d���w | j||||d �S ) a� Find and load tests, given C{name}. @param _name: The qualified name of the thing to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @return: If C{name} is a filename, return the module. If C{name} is a fully-qualified Python name, return the object it refers to. ��recurseN� � z The module z does not exist.�.r� )�parent�qualNamer� )r% �sepr rD � __import__� ImportError�loadFile�_qualNameWalker� namedModuler? �exc_info�tb_next�tb_frame�f_code� co_filenamer) �ModuleNotFoundrE rR �lenrJ rH rF � loadAnything) rc �_namer� r r� r� � remaining� searchName� remainingName�tb�filenameWhereHappened�partr+ r+ r, � findByName� sN � � �� "� ��zTestLoader.findByNamec C s� t |tj�s t|�d���t|d�r|�� S t|d�r |�� S | �� }| �|�D ] }|� | � |�� q(t|d�s:|S | �� }|j D ] }|� | � |�� qA| �||g�S )a� Return a test suite with all the tests from a module. Included are TestCase subclasses and doctests listed in the module's __doctests__ module. If that's not good for you, put a function named either C{testSuite} or C{test_suite} in your module that returns a TestSuite, and I'll use the results of that instead. If C{testSuite} and C{test_suite} are both present, then I'll use C{testSuite}. z is not a module� testSuite� test_suite� __doctests__) r" r# r$ r� �hasattrr� r� r� r� �addTest� loadClassr� � loadDoctests)rc r* rz � testClass�docSuite�docTestr+ r+ r, � loadModule� s zTestLoader.loadModulec s\ t � t�s t� �d���t� �st� �d������ �}��� �fdd�|D ��}��|�S )z� Given a class which contains test cases, return a list of L{TestCase}s. @param klass: The class to load tests from. z is not a classz is not a test casec s g | ] }�� � �j| ��qS r+ )� _makeCase� methodPrefix)�.0r ��klassrc r+ r, � <listcomp> s z(TestLoader.loadClass.<locals>.<listcomp>)r" �typer� r rC �getTestCaseNamesr� r� )rc r� �namesrw r+ r� r, r� s � zTestLoader.loadClassc C s t �|| j�S )z� Given a class that contains C{TestCase}s, return a list of names of methods that probably contain tests. )r �prefixedMethodNamesr� )rc r� r+ r+ r, r� % s zTestLoader.getTestCaseNamesc C s t d��)NzCan't happen on Py3)�NotImplementedError)rc r] r+ r+ r, � loadMethod, � zTestLoader.loadMethodc C s ||�S r- r+ )rc r� � methodNamer+ r+ r, r� / r� zTestLoader._makeCasec C s� t |�s t|�d���t�|j�}|r|�� }n|�� }g }|D ]}|j�d�d � | j �r3|� |� q | � � }| � |�D ]$}z|�� } W n tyV t|jt�� �} Y nw | �| �} |�| � q=|S )a� Load tests from a module object representing a package, and return a TestSuite containing those tests. Tests are only loaded from modules whose name begins with 'test_' (or whatever C{modulePrefix} is set to). @param package: a types.ModuleType object (or reasonable facsimile obtained by importing) which may contain tests. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @raise TypeError: If C{package} is not a package. @return: a TestSuite created with my suiteFactory, containing all the tests. z is not a packager� rP )r r� r � getModulerJ � walkModules� iterModulesr rR � startswith� modulePrefixrv r� r� �load� BaseExceptionr r �Failurer� r� ) rc �packager� �pkgobj� discovery� discovered�discorz �modinfor* � thingToAddr+ r+ r, � loadPackage2 s* � � zTestLoader.loadPackagec C sx t |t�r zt�|�}W n ty t|t�� � Y S w t� |�s)t � d� dS i }dd� }||d< t j |fi |��S )z� Return a suite of tests for all the doctests defined in C{module}. @param module: A module object or a module name. z&trial only supports doctesting modulesNc S s t | d| j�| _| j�� | _dS )z� Save C{test.globs} and replace it with a copy so that if necessary, the original will be available for the next test run. � _savedGlobalsN)rH �globsr� �copy)re r+ r+ r, � saveGlobalsm s z,TestLoader.loadDoctests.<locals>.saveGlobals�setUp)r" r� r rE r� r r r� r� �ismodule�warnings�warn�doctest� DocTestSuite)rc r* � extraArgsr� r+ r+ r, r� \ s � zTestLoader.loadDoctestsNc C s� t |tj�rt|�r| j||d�S | �|�S t |t�r&t|tj �r&| � |�S t |tj �rLt |t�rLt|tj �rL|d }||�}t ||j �j|ksJJ �|S t |t�rS|S td|� ���)a� Load absolutely anything (as long as that anything is a module, package, class, or method (with associated parent class and qualname). @param obj: The object to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @param parent: If C{obj} is a method, this is the parent class of the method. C{qualName} is also required. @param qualName: If C{obj} is a method, this a list containing is the qualified name of the method. C{parent} is also required. @return: A C{TestCase} or C{TestSuite}. r� rP z"don't know how to make test from: )r" r# r$ r r� �loadTestsFromModuler� r� r� r� �loadTestsFromTestCase� FunctionTyperH �_testMethodName�__func__r r� )rc r� r� r� r� r �instr+ r+ r, r� y s& �� � zTestLoader.loadAnythingc C sB z | � | j||d�g�W S ty | � t|t�� �g� Y S w )a* Load some tests by name. @param name: The qualified name for the test to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. r� )r� r� r� r r r� )rc r r� r+ r+ r, � loadByName� s �zTestLoader.loadByNamec C sj g }g }|D ]!}z |� | j||d�� W q ty' |� t|t�� �� Y qw |�|� | �| �|��S )a+ Load some tests by a list of names. @param names: A L{list} of qualified names. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. r� ) rv r r� r r r� �extendr� � _uniqueTests)rc r� r� �things�errorsr r+ r+ r, � loadByNames� s � zTestLoader.loadByNamesc c sF � t � }|D ]}|j}|D ]}t|�|vr |V |�t|�� q qdS )a Gather unique suite objects from loaded things. This will guarantee uniqueness of inherited methods on TestCases which would otherwise hash to same value and collapse to one test unexpectedly if using simpler means: e.g. set(). N)�setr` r� �add)rc r �seen� testthing� testthingsr� r+ r+ r, r � s � ���zTestLoader._uniqueTestsc C sF t �|�}zt||��� }| j||d�W S ty" t|� d���w )a1 Load a file, and then the tests in that file. @param fileName: The file name to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. r� z is not a Python file.)r rD r � load_moduler� �OSErrorrC )rc �fileNamer� r r* r+ r+ r, r� � s �zTestLoader.loadFile�F)FNN)rJ rg rh ri r� r� r! r� r� r� r� r r� r r� r� r� r� r� r� r �loadTestsFromNamer r r� r+ r+ r+ r, r o s. V * 0 r c c sR � | g fV | � d�}tdt|��D ]}d�|d| � �|| d� fV qdS )a3 Given a Python qualified name, this function yields a 2-tuple of the most specific qualified name first, followed by the next-most-specific qualified name, and so on, paired with the remainder of the qualified name. @param qualName: A Python qualified name. @type qualName: L{str} r� r� N)rR �ranger� r4 )r� � qualParts�indexr+ r+ r, r� � s � &�r� c @ s� e Zd ZdZdZdZdd� Zdd� ZeZ dd � Z d d e j d d d d d d d d f dd�Z dd� Zdd� Zdd� Zddd�Zdd� Zd S )r z= A specialised runner that the trial front end uses. �debugzdry-runc C s< | � � t�� }t�| j�}t�|�\}| _t� |j � |S r- ) �_tearDownLogFiler% rB r �FilePath�workingDirectoryr �_unusedTestDirectory� _testDirLock�chdirr& )rc � currentDir�base�testdirr+ r+ r, � _setUpTestdir s zTrialRunner._setUpTestdirc C s t �|� | j�� d S r- )r% r$ r# �unlock)rc �oldDirr+ r+ r, �_tearDownTestdir s z TrialRunner._tearDownTestdirc C s8 | � | j| j| j| j�}| jrt|�}| jrt|�}|S r- ) �reporterFactory�stream�tbformat�rterrors�_log� _exitFirstr �uncleanWarningsr )rc �reporterr+ r+ r, � _makeResult s �zTrialRunner._makeResultNztest.logF�defaultc C st || _ || _|| _|| _|| _|| _|| _d | _| pd| _d | _ d | _ | | _ | | _ | | _ |r8t�| jd�| _d S d S )N� _trial_tempz profile.data)r, �logfile�moder- r. r/ r2 �_resultr! �_logFileObserver�_logFileObject�_forceGarbageCollection�debuggerr1 r �profiledrf ) rc r, r8 r7 r- �profile�tracebackFormat�realTimeErrorsr2 r! rx r= � exitFirstr+ r+ r, r! # s" �zTrialRunner.__init__c C s@ | j d urt�| j j� d | _ | jd ur | j�� d | _d S d S r- )r: r �removeObserver�emitr; �closer� r+ r+ r, r C s �z TrialRunner._tearDownLogFilec C sL | � � | jdkr tj}nt| jd�}|| _t�|�| _t� | jj d� d S )N�-�ar ) r r7 r? �stdout�openr; r �FileLogObserverr: �startLoggingWithObserverrD )rc �logFiler+ r+ r, � _setUpLogFileK s zTrialRunner._setUpLogFilec C s t �|t�}| �|| j�S )zC Run the test or suite and return a result object. )r ru r �_runWithoutDecorationr< )rc re r+ r+ r, rf U s zTrialRunner.runc sF �� � � t|g|��t�� }�j�jkr+t��D ]}� �|� � �|� � �|� qn7�j�j kr:� ��fdd�}n� �fdd�}�� � }z�� � |� W �� � �� |� n �� � �� |� w t�� }t� dd�}|du r�tjdt�� j� tdd� � �� � �� j� � �d � j|| � � �d � � �� � S � �� � S ) zR Private helper that runs the given test but doesn't decorate it. c s �j ��j� �S r- )r= �runcallrf r+ �rd rc rz r+ r, r� m s z3TrialRunner._runWithoutDecoration.<locals>.<lambda>c s �� � �S r- r� r+ )rd rz r+ r, r� o r� �doneNzR%s should implement done() but doesn't. Falling back to printErrors() and friends.r; )�category� stacklevelzRan %d tests in %.3fs� ) r4 r �timer8 �DRY_RUNr r� r� r� �DEBUGr( rM r r+ rH r r r r� rs �DeprecationWarning� printErrors�writeln� separator�testsRun�write� printSummaryrQ ) rc re rx � startTime�singlerf r* �endTimerQ r+ rP r, rN \ sP � � �� � �z!TrialRunner._runWithoutDecorationc C s^ d} |d7 }| j �d|f � |dkr| �|�}n| �|�}|jdkr' |S |�� s. |S q)z8 Repeatedly run C{test} until it fails. r Tr� z Test Pass %d )r- r] rf rN r\ � wasSuccessful)rc re �countrd r+ r+ r, �runUntilFailure� s ��zTrialRunner.runUntilFailurer )rJ rg rh ri rW rV r( r+ r r0 r4 r? rH r! r rM rf rN rd r+ r+ r+ r, r s2 � 1r )9ri �__all__r r. r� r% r? rU r# r �importlib.machineryr �zope.interfacer r� r �twisted.pythonr r r r r � twisted.trialr r �twisted.trial._asyncrunnerr r �twisted.trial._synctestr �twisted.trial.itrialr �twisted.trial.reporterr r �twisted.trial.unittestr r� r� r r r r rG rQ r_ r r r r r r r r r r� r r+ r+ r+ r, �<module> sV 1 $ &% PK Mb�Z���� � * trial/__pycache__/unittest.cpython-310.pycnu �[��� o �b� � @ s\ d Z ddlmZmZmZ ddlmZ ddlmZm Z m Z m Z m Z m Z e e_e _g d�ZdS )z4 Things likely to be used by writers of unit tests. � )� TestDecorator� TestSuite�decorate)�TestCase)�FailTest�PyUnitResultAdapter�SkipTest�SynchronousTestCase�Todo�makeTodo) r r r r r r r r r r N)�__doc__�twisted.trial._asyncrunnerr r r �twisted.trial._asynctestr �twisted.trial._synctestr r r r r r �__name__� __module__�__all__� r r �8/usr/lib/python3/dist-packages/twisted/trial/unittest.py�<module> s PK Mb�Z^�1ͳ � . trial/__pycache__/_asyncrunner.cpython-310.pycnu �[��� o �b, � @ s d Z ddlZddlZddlZddlmZ ddlmZ ddl m Z m Z ddl m Z G dd� dej�Zee j�G d d � d e�e jd ���Zd d � Zdd� ZG dd� de�ZG dd� de�ZG dd� de�Ze�eeje j� e�eeje j� eedd�Zer�e�eee j� dd� Z dS )z- Infrastructure for test running and suites. � N)� implementer)� components)�itrial�reporter)� _logObserverc @ � e Zd ZdZdd� ZdS )� TestSuitezh Extend the standard library's C{TestSuite} with a consistently overrideable C{run} method. c C s$ | j D ] }|jr |S ||� q|S )z; Call C{run} on every member of the suite. )�_tests� shouldStop)�self�result�test� r �</usr/lib/python3/dist-packages/twisted/trial/_asyncrunner.py�run s �z TestSuite.runN��__name__� __module__� __qualname__�__doc__r r r r r r � r c @ s e Zd ZdZdd� Zdd� ZdS )� TestDecoratorz� Decorator for test cases. @param _originalTest: The wrapped instance of test. @type _originalTest: A provider of L{itrial.ITestCase} c C s | � |�S �zQ Run the unit test. @param result: A TestResult object. )r �r r r r r �__call__3 s zTestDecorator.__call__c C s | j �t�|| j��S r )� _originalTestr r �_AdaptedReporter� __class__r r r r r ; s zTestDecorator.runN)r r r r r r r r r r r & s r r c C s g | _ dS )z� Clear all tests from C{suite}. This messes with the internals of C{suite}. In particular, it assumes that the suite keeps all of its tests in a list in an instance variable called C{_tests}. N)r )�suiter r r � _clearSuiteD s r c C sN zt | �}W n ty || � Y S w t| � |D ] }| �t||�� q| S )a2 Decorate all test cases in C{test} with C{decorator}. C{test} can be a test case or a test suite. If it is a test suite, then the structure of the suite is preserved. L{decorate} tries to preserve the class of the test suites it finds, but assumes the presence of the C{_tests} attribute on the suite. @param test: The C{TestCase} or C{TestSuite} to decorate. @param decorator: A unary callable used to decorate C{TestCase}s. @return: A decorated C{TestCase} or a C{TestSuite} containing decorated C{TestCase}s. )�iter� TypeErrorr �addTest�decorate)r � decorator�tests�caser r r r# O s �r# c @ s e Zd ZdZdS )�_PyUnitTestCaseAdapterz2 Adapt from pyunit.TestCase to ITestCase. N)r r r r r r r r r' n s r' c @ r )�_BrokenIDTestCaseAdapterz� Adapter for pyunit-style C{TestCase} subclasses that have undesirable id() methods. That is C{unittest.FunctionTestCase} and C{unittest.DocTestCase}. c C s | j �� }|dur |S | j �� S )zH Return the fully-qualified Python name of the doctest. N)r �shortDescription�id)r �testIDr r r r* z s z_BrokenIDTestCaseAdapter.idN)r r r r r* r r r r r( t r r( c @ r )� _ForceGarbageCollectionDecoratorz� Forces garbage collection to be run before and after the test. Any errors logged during the post-test collection are added to the test result as errors. c C sR t �� t�| |� t�� t �� t�� D ]}|�| |� qt�� t� � d S )N) �gc�collectr r r �_add� getErrors�addError� flushErrors�_remove)r r �errorr r r r � s z$_ForceGarbageCollectionDecorator.runNr r r r r r, � s r, � DocTestCasec c sF � zt | �}W n ty | V Y dS w |D ] }t|�E dH qdS )zF Iterate through all of the test cases in C{testSuiteOrCase}. N)r r! � _iterateTests)�testSuiteOrCaser r r r r r6 � s � ��r6 ) r �doctestr- �unittest�pyunit�zope.interfacer �twisted.pythonr � twisted.trialr r �twisted.trial._synctestr r � ITestCase�proxyForInterfacer r r# r' r( r, �registerAdapter�TestCase�FunctionTestCase�getattr� _docTestCaser6 r r r r �<module> s8 �� � PK Mb�Z����; ; * trial/__pycache__/__main__.cpython-310.pycnu �[��� o �b� � @ s8 e d krddlZddlmZ e�eddd�� � dS dS )�__main__� N)�load_entry_point�Twisted�console_scripts�trial)�__name__�sys� pkg_resourcesr �exit� r r �8/usr/lib/python3/dist-packages/twisted/trial/__main__.py�<module> s �PK Mb�Z�Q� R� R� + trial/__pycache__/_synctest.cpython-310.pycnu �[��� o �b� � @ sn d Z ddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z mZ ddlmZ ddlmZ ddlmZmZmZ ddlmZmZmZmZ dd lm Z dd l m Z dd l m Z m!Z! G d d � d e"�Z#G dd� d�Z$dd� Z%G dd� d�Z&dd� Z'dd� Z(G dd� de)�Z*G dd� d�Z+G d d � d �Z,G d d � d ej-�Z.G d d!� d!�Z/e/� Z0G d"d#� d#e.�Z1dS )$zP Things likely to be used by writers of unit tests. Maintainer: Jonathan Lange � N)�findlinestarts)�Optional�Tuple)�SkipTest)�ensureDeferred)�failure�log�monkey)�DEPRECATION_WARNING_FORMAT�getDeprecationWarningString�getVersionString�warnAboutFunction)�fullyQualifiedName)�runWithWarningsSuppressed)�itrial�utilc @ � e Zd ZdZdS )�FailTestzA Raised to indicate the current test has failed to pass. N��__name__� __module__� __qualname__�__doc__� r r �9/usr/lib/python3/dist-packages/twisted/trial/_synctest.pyr & � r c @ s0 e Zd ZdZd dd�Zdefdd�Zdd � ZdS ) �TodoaK Internal object used to mark a L{TestCase} as 'todo'. Tests marked 'todo' are reported differently in Trial L{TestResult}s. If todo'd tests fail, they do not fail the suite and the errors are reported in a separate category. If todo'd tests succeed, Trial L{TestResult}s will report an unexpected success. Nc C s || _ || _dS )ar @param reason: A string explaining why the test is marked 'todo' @param errors: An iterable of exception types that the test is expected to raise. If one of these errors is raised by the test, it will be trapped. Raising any other kind of error will fail the test. If L{None} is passed, then all errors will be trapped. N��reason�errors)�selfr r r r r �__init__5 s z Todo.__init__�returnc C s d| j �d| j�d�S )Nz <Todo reason=z errors=�>r �r r r r �__repr__A s z Todo.__repr__c C s. | j du rdS | j D ] }|�|�r dS q dS )z� @param failure: A L{twisted.python.failure.Failure}. @return: C{True} if C{failure} is expected, C{False} otherwise. NTF)r �check)r r �errorr r r �expectedD s �z Todo.expected�N)r r r r r! �strr% r( r r r r r , s r c C s\ t | t�r t| d�S t | t�r,| \}}zt|�}W n ty% |g}Y nw t||d�S dS )a� Return a L{Todo} object built from C{value}. If C{value} is a string, return a Todo that expects any exception with C{value} as a reason. If C{value} is a tuple, the second element is used as the reason and the first element as the excepted error(s). @param value: A string or a tuple of C{(errors, reason)}, where C{errors} is either a single exception class or an iterable of exception classes. @return: A L{Todo} object. )r r N)� isinstancer* r �tuple�list� TypeError)�valuer r r r r �makeTodoR s � �r0 c @ s e Zd ZdZdd� ZdS )�_Warninga] A L{_Warning} instance represents one warning emitted through the Python warning system (L{warnings}). This is used to insulate callers of L{_collectWarnings} from changes to the Python warnings system which might otherwise require changes to the warning objects that function passes to the observer object it accepts. @ivar message: The string which was passed as the message parameter to L{warnings.warn}. @ivar category: The L{Warning} subclass which was passed as the category parameter to L{warnings.warn}. @ivar filename: The name of the file containing the definition of the code object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. @ivar lineno: The source line associated with the active instruction of the code object object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. c C s || _ || _|| _|| _d S r) ��message�category�filename�lineno)r r3 r4 r5 r6 r r r r! � s z_Warning.__init__N)r r r r r! r r r r r1 j s r1 c C s< t | �� �D ]}|durzd|_W q ty Y qw qdS )z� Disable the per-module cache for every module found in C{modules}, typically C{sys.modules}. @param modules: Dictionary of modules, typically sys.module dict N)r- �values�__warningregistry__� BaseException)�modules�vr r r �_setWarningRegistryToNone� s ���r< c s| d� fdd� }t tj� tjdd� }tj}t�d� z|t_||i |��}W |tjdd�< |t_|S |tjdd�< |t_w )aU Call C{f} with C{args} positional arguments and C{kwargs} keyword arguments and collect all warnings which are emitted as a result in a list. @param observeWarning: A callable which will be invoked with a L{_Warning} instance each time a warning is emitted. @return: The return value of C{f(*args, **kwargs)}. Nc s( t | t�sJ �� tt| �|||�� d S r) )r+ �Warningr1 r* )r3 r4 r5 r6 �file�line��observeWarningr r � showWarning� s z%_collectWarnings.<locals>.showWarning�always)NN)r< �sysr: �warnings�filters� showwarning� simplefilter)rA �f�args�kwargsrB � origFilters�origShow�resultr r@ r �_collectWarnings� s �rO c @ r )�UnsupportedTrialFeaturez?A feature of twisted.trial was used that pyunit cannot support.Nr r r r r rP � r rP c @ sr e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z ddd�Z dd� Z dd� Zdd� ZdS ) �PyUnitResultAdapterz� Wrap a C{TestResult} from the standard library's C{unittest} so that it supports the extended result types from Trial, and also supports L{twisted.python.failure.Failure}s being passed to L{addError} and L{addFailure}. c C s || _ dS )zM @param original: A C{TestResult} instance from C{unittest}. N)�original)r rR r r r r! � � z PyUnitResultAdapter.__init__c C s t �|�S r) )r �excInfoOrFailureToExcInfo)r �errr r r � _exc_info� s z PyUnitResultAdapter._exc_infoc C � | j �|� d S r) )rR � startTest�r �methodr r r rX � � z PyUnitResultAdapter.startTestc C rW r) )rR �stopTestrY r r r r\ � r[ z PyUnitResultAdapter.stopTestc C � | j �|| �|�� d S r) )rR � addFailurerV )r �test�failr r r r^ � � z PyUnitResultAdapter.addFailurec C r] r) )rR �addErrorrV �r r_ r' r r r rb � ra z PyUnitResultAdapter.addErrorc C s | j �|tt||�d f� d S r) )rR r^ rP )r r_ �feature�infor r r � _unsupported� s �z PyUnitResultAdapter._unsupportedc C s | j �||� dS )z/ Report the skip as a failure. N)rR �addSkip)r r_ r r r r rg � � zPyUnitResultAdapter.addSkipNc C � | � |d|� dS )z= Report the unexpected success as a failure. zunexpected successN�rf )r r_ �todor r r �addUnexpectedSuccess� rh z(PyUnitResultAdapter.addUnexpectedSuccessc C ri )zG Report the expected failure (i.e. todo) as a failure. zexpected failureNrj rc r r r �addExpectedFailure� rh z&PyUnitResultAdapter.addExpectedFailurec C rW r) )rR � addSuccess)r r_ r r r rn � r[ z PyUnitResultAdapter.addSuccessc C � d S r) r )r rZ r' �warn� printStatusr r r � upDownError� � z PyUnitResultAdapter.upDownErrorr) )r r r r r! rV rX r\ r^ rb rf rg rl rm rn rr r r r r rQ � s rQ c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �_AssertRaisesContexta� A helper for implementing C{assertRaises}. This is a context manager and a helper method to support the non-context manager version of C{assertRaises}. @ivar _testCase: See C{testCase} parameter of C{__init__} @ivar _expected: See C{expected} parameter of C{__init__} @ivar _returnValue: The value returned by the callable being tested (only when not being used as a context manager). @ivar _expectedName: A short string describing the expected exception (usually the name of the exception class). @ivar exception: The exception which was raised by the function being tested (if it raised one). c C sD || _ || _d| _z| jj| _W dS ty! t| j�| _Y dS w )z� @param testCase: The L{TestCase} instance which is used to raise a test-failing exception when that is necessary. @param expected: The exception type expected to be raised. N)� _testCase� _expected� _returnValuer � _expectedName�AttributeErrorr* )r �testCaser( r r r r! s �z _AssertRaisesContext.__init__c C s6 | �}|� | _ W d � |jS 1 sw Y |jS )a, Call the given object using this object as a context manager. @param obj: The object to call and which is expected to raise some exception. @type obj: L{object} @return: Whatever exception is raised by C{obj()}. @rtype: L{BaseException} N)rw � exception)r �obj�contextr r r �_handle s ��z _AssertRaisesContext._handlec C s | S r) r r$ r r r � __enter__. rs z _AssertRaisesContext.__enter__c C s� |du r| j �d�| j| j�� t||�s#t|t�r ||� }n||�}|| _t|| j �sCt � |||�}| j �d�t |�| j|� � �� dS )zB Check exit exception against expected exception. Nz{} not raised ({} returned)z {} raised instead of {}: {}T)ru r` �formatrx rw r+ r, r{ � issubclassrv r �Failurer � getTraceback)r � exceptionType�exceptionValue� tracebackr r r r �__exit__1 s* �� �� z _AssertRaisesContext.__exit__N)r r r r r! r~ r r� r r r r rt � s rt c s` e Zd ZdZd.dd�Zd.� fdd� ZeZeZeZd.� fdd� Z e Z e Z e Z d.d d �Z e Zd.� fd d � ZeZeZeZd.d d�ZeZeZd.dd�ZeZeZd.dd�ZeZeZeZ d.dd�Z e Z d.dd�Z e Z d/dd�Z!e!Z"e!Z#e!Z$d/dd�Z%e%Z&e%Z'd.d d �Z(e(Z)d.d d �Z*e*Z+d.d d!�Z,e,Z-d"d#� Z.e.Z/d.d$d%�Z0e0Z1d&d'� Z2e2Z3d(d)� Z4d*d+� Z5d,d-� Z6� Z7S )0� _Assertionsz� Replaces many of the built-in TestCase assertions. In general, these assertions provide better error messages and are easier to use in callbacks. Nc C s | � |��)z� Absolutely fail the test. Do not pass go, do not collect $200. @param msg: the message that will be displayed as the reason for the failure ��failureException)r �msgr r r r` ` s z_Assertions.failc � t � �||� |S )z� Fail the test if C{condition} evaluates to True. @param condition: any object that defines __nonzero__ )�super� assertFalse�r � conditionr� �� __class__r r r� i � z_Assertions.assertFalsec r� )z� Fail the test if C{condition} evaluates to False. @param condition: any object that defines __nonzero__ )r� � assertTruer� r� r r r� v r� z_Assertions.assertTruec s, t | |�}�du r |S |�� ��fdd��S )a� Fail the test unless calling the function C{f} with the given C{args} and C{kwargs} raises C{exception}. The failure will report the traceback and call stack of the unexpected exception. @param exception: exception type that is to be expected @param f: the function to call @return: If C{f} is L{None}, a context manager which will make an assertion about the exception raised from the suite it manages. If C{f} is not L{None}, the exception raised by C{f}. @raise self.failureException: Raised if the function call does not raise an exception or if it raises an exception of a different type. Nc s �� i ���S r) r r �rJ rI rK r r �<lambda>� s z*_Assertions.assertRaises.<locals>.<lambda>)rt r~ )r r{ rI rJ rK r} r r� r � assertRaises� s z_Assertions.assertRaisesc s t � �|||� |S )z� Fail the test if C{first} and C{second} are not equal. @param msg: A string describing the failure that's included in the exception. )r� � assertEqual�r �first�secondr� r� r r r� � s z_Assertions.assertEqualc C s$ ||ur| � |p|�d|����|S )a Fail the test if C{first} is not C{second}. This is an obect-identity-equality test, not an object equality (i.e. C{__eq__}) test. @param msg: if msg is None, then the failure message will be '%r is not %r' % (first, second) z is not r� r� r r r �assertIs� � z_Assertions.assertIsc C s$ ||u r| � |p|�d|����|S )a Fail the test if C{first} is C{second}. This is an obect-identity-equality test, not an object equality (i.e. C{__eq__}) test. @param msg: if msg is None, then the failure message will be '%r is %r' % (first, second) z is r� r� r r r � assertIsNot� r� z_Assertions.assertIsNotc C s$ ||ks| � |p|�d|����|S )z� Fail the test if C{first} == C{second}. @param msg: if msg is None, then the failure message will be '%r == %r' % (first, second) � == r� r� r r r �assertNotEqual� s z_Assertions.assertNotEqualc C s$ ||vr| � |p|�d|����|S )a� Fail the test if C{containee} is not found in C{container}. @param containee: the value that should be in C{container} @param container: a sequence type, or in the case of a mapping type, will follow semantics of 'if key in dict.keys()' @param msg: if msg is None, then the failure message will be '%r not in %r' % (first, second) z not in r� �r � containee� containerr� r r r �assertIn� � z_Assertions.assertInc C s$ ||v r| � |p|�d|����|S )a� Fail the test if C{containee} is found in C{container}. @param containee: the value that should not be in C{container} @param container: a sequence type, or in the case of a mapping type, will follow semantics of 'if key in dict.keys()' @param msg: if msg is None, then the failure message will be '%r in %r' % (first, second) z in r� r� r r r � assertNotIn� r� z_Assertions.assertNotIn� c C s6 t || |�dkr| �|p|�d|�d|�d���|S )a� Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero. @note: decimal places (from zero) is usually not the same as significant digits (measured from the most significant digit). @note: included for compatibility with PyUnit test cases r r� � within � places��roundr� �r r� r� �placesr� �deltar r r �assertNotAlmostEqual� � �z _Assertions.assertNotAlmostEqualc C s6 t || |�dkr| �|p|�d|�d|�d���|S )a� Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero. @note: decimal places (from zero) is usually not the same as significant digits (measured from the most significant digit). @note: included for compatibility with PyUnit test cases r z != r� r� r� r� r r r �assertAlmostEqual r� z _Assertions.assertAlmostEqualc C s, t || �|kr| �|p|� d|� ���|S )z� Fail if C{first} - C{second} > C{tolerance} @param msg: if msg is None, then the failure message will be '%r ~== %r' % (first, second) z ~== )�absr� )r r� r� � tolerancer� r r r �assertApproximates' s z _Assertions.assertApproximatesc C � | � |||�S )zH Fail if C{substring} does not exist within C{astring}. )� failUnlessIn�r � substring�astringr� r r r �assertSubstring4 � z_Assertions.assertSubstringc C r� )z; Fail if C{astring} contains C{substring}. )�failIfInr� r r r �assertNotSubstring< r� z _Assertions.assertNotSubstringc O s� g }t |j|g|�R i |��}|s| �d� |d } |dd� D ]} | j| jf| j| jfkr3| �d� q | �| j|� | �| j|� | �|�| j �d| j �d|��� |S )a� Fail if the given function doesn't generate the specified warning when called. It calls the function, checks the warning, and forwards the result of the function if everything is fine. @param category: the category of the warning to check. @param message: the output message of the warning to check. @param filename: the filename where the warning should come from. @param f: the function which is supposed to generate the warning. @type f: any callable. @param args: the arguments to C{f}. @param kwargs: the keywords arguments to C{f}. @return: the result of the original function C{f}. zNo warnings emittedr � Nz Can't handle different warningsz Warning in z , expected ) rO �appendr` r3 r4 r� �assertIdenticalr� � startswithr5 ) r r4 r3 r5 rI rJ rK � warningsShownrN r� �otherr r r � assertWarnsD s � � z_Assertions.assertWarnsc C s@ t ||�s |du r d}nd| }| �|�d|� |� �� dS dS )a Fail if C{instance} is not an instance of the given class or of one of the given classes. @param instance: the object to test the type (first argument of the C{isinstance} call). @type instance: any. @param classOrTuple: the class or classes to test against (second argument of the C{isinstance} call). @type classOrTuple: class, type, or tuple. @param message: Custom text to include in the exception text if the assertion fails. N� �: z is not an instance of �r+ r` )r �instance� classOrTupler3 �suffixr r r �assertIsInstancep s �z _Assertions.assertIsInstancec C s& t ||�r| �|�d|� �� dS dS )a� Fail if C{instance} is an instance of the given class or of one of the given classes. @param instance: the object to test the type (first argument of the C{isinstance} call). @type instance: any. @param classOrTuple: the class or classes to test against (second argument of the C{isinstance} call). @type classOrTuple: class, type, or tuple. z is an instance of Nr� )r r� r� r r r �assertNotIsInstance� s �z _Assertions.assertNotIsInstancec C sZ t |�}g }|�|j� |s| �d�|�� |d }t|tj�r+| �d�||�� �� |S )a? Return the current success result of C{deferred} or raise C{self.failureException}. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} which has a success result. This means L{Deferred.callback<twisted.internet.defer.Deferred.callback>} or L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called on it and it has reached the end of its callback chain and the last callback or errback returned a non-L{failure.Failure}. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has no result or has a failure result. @return: The result of C{deferred}. z8Success result expected on {!r}, found no result insteadr zASuccess result expected on {!r}, found failure result instead: {}) r �addBothr� r` r� r+ r r� r� )r �deferredrN r r r �successResultOf� s$ �� ��z_Assertions.successResultOfc G s� t |�}g }|�|j� |s| �d�|�� |d }t|tj�s)| �d�||�� |rH|j|� sHd� dd� |D ��}| �d�|||j |� � �� |S )a� Return the current failure result of C{deferred} or raise C{self.failureException}. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} which has a failure result. This means L{Deferred.callback<twisted.internet.defer.Deferred.callback>} or L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called on it and it has reached the end of its callback chain and the last callback or errback raised an exception or returned a L{failure.Failure}. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @param expectedExceptionTypes: Exception types to expect - if provided, and the exception wrapped by the failure result is not one of the types provided, then this test will fail. @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has no result, has a success result, or has an unexpected failure result. @return: The failure result of C{deferred}. @rtype: L{failure.Failure} z8Failure result expected on {!r}, found no result insteadr zDFailure result expected on {!r}, found success result ({!r}) insteadz or c S s g | ] }d � |j|jf��qS )�.)�joinr r )�.0�tr r r � <listcomp>� s z/_Assertions.failureResultOf.<locals>.<listcomp>zBFailure of type ({}) expected on {!r}, found type {!r} instead: {}) r r� r� r` r� r+ r r� r& r� �typer� )r r� �expectedExceptionTypesrN �expectedStringr r r �failureResultOf� s4 �� � ���z_Assertions.failureResultOfc sR t |�}g � � fdd�}|�|� � r'|�dd� � | �d�|� d �� dS dS )a� Assert that C{deferred} does not have a result at this point. If the assertion succeeds, then the result of C{deferred} is left unchanged. Otherwise, any L{failure.Failure} result is swallowed. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} without a result. This means that neither L{Deferred.callback<twisted.internet.defer.Deferred.callback>} nor L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called, or that the L{Deferred<twisted.internet.defer.Deferred>} is waiting on another L{Deferred<twisted.internet.defer.Deferred>} for a result. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has a result. c s � � | � | S r) )r� )�res�rN r r �cb s z&_Assertions.assertNoResult.<locals>.cbc S ro r) r )�_r r r r� � z,_Assertions.assertNoResult.<locals>.<lambda>z.No result expected on {!r}, found {!r} insteadr N)r r� � addErrbackr` r� )r r� r� r r� r �assertNoResult� s ���z_Assertions.assertNoResultr) )r� NN)8r r r r r` r� � assertNot�failUnlessFalse�failIfr� �assert_�failUnlessTrue� failUnlessr� �failUnlessRaisesr� �failUnlessEqual�failUnlessEquals� assertEqualsr� �failUnlessIdenticalr� r� �failIfIdentical�assertNotIdenticalr� �assertNotEquals� failIfEquals� failIfEqualr� r� r� r� r� �assertNotAlmostEquals�failIfAlmostEqual�failIfAlmostEqualsr� �assertAlmostEquals�failUnlessAlmostEqualr� �failUnlessApproximatesr� �failUnlessSubstringr� �failIfSubstringr� �failUnlessWarnsr� �failUnlessIsInstancer� �failIfIsInstancer� r� r� � __classcell__r r r� r r� Y sj * *:r� c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )� _LogObservera Observes the Twisted logs and catches any errors. @ivar _errors: A C{list} of L{Failure} instances which were received as error events from the Twisted logging system. @ivar _added: A C{int} giving the number of times C{_add} has been called less the number of times C{_remove} has been called; used to only add this observer to the Twisted logging since once, regardless of the number of calls to the add method. @ivar _ignored: A C{list} of exception types which will not be recorded. c C s g | _ d| _g | _d S )Nr )�_errors�_added�_ignoredr$ r r r r! 3 s z_LogObserver.__init__c C s( | j dkr t�| j� | j d7 _ d S )Nr r� )r� r � addObserver�gotEventr$ r r r �_add8 s z_LogObserver._addc C s, | j d8 _ | j dkrt�| j� d S d S )Nr� r )r� r �removeObserverr r$ r r r �_remove= s �z_LogObserver._removec G s | j �|� dS )zF Do not store any errors with any of the given types. N)r� �extend�r � errorTypesr r r � _ignoreErrorsB s z_LogObserver._ignoreErrorsc C s g | _ dS )zJ Stop ignoring any errors we might currently be ignoring. N)r� r$ r r r � _clearIgnoresH rS z_LogObserver._clearIgnoresc G sR |r!g }g }| j D ]}|j|� r|�|� q |�|� q || _ |S | j }g | _ |S )z� Flush errors from the list of caught errors. If no arguments are specified, remove all errors. If arguments are specified, only remove errors of those types from the stored list. )r� r& r� )r r �flushed� remainderrI r r r � flushErrorsN s �z_LogObserver.flushErrorsc C s | j S )zB Return a list of errors caught by this observer. )r� r$ r r r � getErrorsb s z_LogObserver.getErrorsc C sR |� dd�r#d|v r%|d }t| j�dks|j| j� s'| j�|� dS dS dS dS )z� The actual observer method. Called whenever a message is logged. @param event: A dictionary containing the log message. Actual structure undocumented (see source for L{twisted.python.log}). �isErrorFr r N)�get�lenr� r& r� r� )r �eventrI r r r r h s �z_LogObserver.gotEventN) r r r r r! r r r r r r r r r r r r� $ s r� c s� e Zd ZdZeZd2� fdd� Zdedefdd�Z d d � Z � fd d �Z de ee e f fd d�Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd3d d �Zd3d d �Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Z d*d+� Z d,d-� Z d.d/� Z d0d1� Z � Z!S )4�SynchronousTestCasea A unit test. The atom of the unit testing universe. This class extends C{unittest.TestCase} from the standard library. A number of convenient testing helpers are added, including logging and warning integration, monkey-patching support, and more. To write a unit test, subclass C{SynchronousTestCase} and define a method (say, 'test_foo') on the subclass. To run the test, instantiate your subclass with the name of the method, and call L{run} on the instance, passing a L{TestResult} object. The C{trial} script will automatically find any C{SynchronousTestCase} subclasses defined in modules beginning with 'test_' and construct test cases for all methods beginning with 'test'. If an error is logged during the test run, the test will fail with an error. See L{log.err}. @ivar failureException: An exception class, defaulting to C{FailTest}. If the test method raises this exception, it will be reported as a failure, rather than an exception. All of the assertion methods raise this if the assertion fails. @ivar skip: L{None} or a string explaining why this test is to be skipped. If defined, the test will not be run. Instead, it will be reported to the result object as 'skipped' (if the C{TestResult} supports skipping). @ivar todo: L{None}, a string or a tuple of C{(errors, reason)} where C{errors} is either an exception class or an iterable of exception classes, and C{reason} is a string. See L{Todo} or L{makeTodo} for more information. @ivar suppress: L{None} or a list of tuples of C{(args, kwargs)} to be passed to C{warnings.filterwarnings}. Use these to suppress warnings raised in a test. Useful for testing deprecated code. See also L{util.suppress}. �runTestc sD t � �|� d| _g | _|| _t| |�}|| tj�| j j �g| _ d S )NF) r� r! �_passed� _cleanups�_testMethodName�getattrrD r: r r� r �_parents)r � methodName� testMethodr� r r r! � s z SynchronousTestCase.__init__r� r" c C s t |t�r | |u S tS )a� Override the comparison defined by the base TestCase which considers instances of the same class with the same _testMethodName to be equal. Since trial puts TestCase instances into a set, that definition of comparison makes it impossible to run the same test method twice. Most likely, trial should stop using a set to hold tests, but until it does, this is necessary on Python 2.6. -exarkun )r+ r �NotImplemented)r r� r r r �__eq__� s zSynchronousTestCase.__eq__c C s t | j| jf�S r) )�hashr� r r$ r r r �__hash__� r[ z SynchronousTestCase.__hash__c s t � �� }|d u r | jS |S r) )r� �shortDescriptionr )r �descr� r r r � s z$SynchronousTestCase.shortDescriptionc C sD t �| jdd�}|du}|du r t| dd�}|r t| dd�}||fS )aN Return the skip reason set on this test, if any is set. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{skip} attribute, returns that in a tuple (L{True}, L{str}). If the C{skip} attribute does not exist, look for C{__unittest_skip__} and C{__unittest_skip_why__} attributes which are set by the standard library L{unittest.skip} function. Returns (L{False}, L{None}) if it cannot find anything. See L{TestCase} docstring for more details. �skipN�__unittest_skip__F�__unittest_skip_why__r� )r �acquireAttributer r )r � skipReason�doSkipr r r �getSkip� s zSynchronousTestCase.getSkipc C s$ t �| jdd�}|du rdS t|�S )aQ Return a L{Todo} object if the test is marked todo. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{todo} attribute, returns that. Returns L{None} if it cannot find anything. See L{TestCase} docstring for more details. rk N)r r$ r r0 )r rk r r r �getTodo� s zSynchronousTestCase.getTodoc C s dS )z� If no C{methodName} argument is passed to the constructor, L{run} will treat this method as the thing with the actual test inside. Nr r$ r r r r � r� zSynchronousTestCase.runTestc C s� t �d| �� � t�|d�}|du rt|�}n|}|�| � | �� \}}|r4|�| |� |� | � dS d| _ g | _ | � � t | j j| j|� | �� D ] }z tjdi |�� W qK tyh |�| t�� � Y qKw |� | � dS )a� Run the test case, storing the results in C{result}. First runs C{setUp} on self, then runs the test method (defined in the constructor), then runs C{tearDown}. As with the standard library L{unittest.TestCase}, the return value of these methods is disregarded. In particular, returning a L{Deferred<twisted.internet.defer.Deferred>} has no special additional consequences. @param result: A L{TestResult} object. z --> %s <--NFr )r r� �idr � IReporterrQ rX r' rg r\ r � _warnings�_installObserverrO r� �_runFixturesAndTest� flushWarningsrE � warn_explicitr9 rb r r� )r rN � new_resultr& r% �wr r r �run� s, �zSynchronousTestCase.runc O s | j �|||f� dS )as Add the given function to a list of functions to be called after the test has run, but before C{tearDown}. Functions will be run in reverse order of being added. This helps ensure that tear down complements set up. As with all aspects of L{SynchronousTestCase}, Deferreds are not supported in cleanup functions. N)r r� )r rI rJ rK r r r � addCleanup s z SynchronousTestCase.addCleanupc C s( t �|||f�}|�� | �|j� |S )a Monkey patch an object for the duration of the test. The monkey patch will be reverted at the end of the test using the L{addCleanup} mechanism. The L{monkey.MonkeyPatcher} is returned so that users can restore and re-apply the monkey patch within their tests. @param obj: The object to monkey patch. @param attribute: The name of the attribute to change. @param value: The value to set the attribute to. @return: A L{monkey.MonkeyPatcher} object. )r � MonkeyPatcher�patchr3 �restore)r r| � attributer/ � monkeyPatchr r r r5 ! s zSynchronousTestCase.patchc G s | j j|� S )a� Remove stored errors received from the log. C{TestCase} stores each error logged during the run of the test and reports them as errors during the cleanup phase (after C{tearDown}). @param errorTypes: If unspecified, flush all errors. Otherwise, only flush errors that match the given types. @return: A list of failures that have been removed. )� _observerr r r r r �flushLoggedErrors5 s z%SynchronousTestCase.flushLoggedErrorsNc C s� |du r| j dd� }g | j dd�< n[g }| j D ]L}|D ]G}t|tjtjf�s.t|�d���tj|j }t � |�}|t j � |j�krCq dd� t|j�D �}t|�|j kr\t|�ks^n q |�|� qtt| j j|�� dd� |D �S )a� Remove stored warnings from the list of captured warnings and return them. @param offendingFunctions: If L{None}, all warnings issued during the currently running test will be flushed. Otherwise, only warnings which I{point} to a function included in this list will be flushed. All warnings include a filename and source line number; if these parts of a warning point to a source line which is part of a function, then the warning I{points} to that function. @type offendingFunctions: L{None} or L{list} of functions or methods. @raise ValueError: If C{offendingFunctions} is not L{None} and includes an object which is not a L{types.FunctionType} or L{types.MethodType} instance. @return: A C{list}, each element of which is a C{dict} giving information about one warning which was flushed by this call. The keys of each C{dict} are: - C{'message'}: The string which was passed as the I{message} parameter to L{warnings.warn}. - C{'category'}: The warning subclass which was passed as the I{category} parameter to L{warnings.warn}. - C{'filename'}: The name of the file containing the definition of the code object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. - C{'lineno'}: The source line associated with the active instruction of the code object object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. Nz is not a function or methodc S s g | ]\}}|�qS r r )r� r� � lineNumberr r r r� � s ��z5SynchronousTestCase.flushWarnings.<locals>.<listcomp>c S s" g | ] }|j |j|j|jd ��qS )r2 r2 )r� r1 r r r r� � s ���)r+ r+ �types� FunctionType� MethodType� ValueErrorrD r: r �inspect� getabsfile�os�path�normcaser5 �_findlinestarts�__code__�minr6 �maxr� r- �map�remove)r �offendingFunctions�toFlush�aWarning� aFunction�aModuler5 � lineNumbersr r r r. C s4 & � � ��z!SynchronousTestCase.flushWarningsc C s� |d | }t j| }t||�}| �| jg�}t|�dkr%| �|� d�� |d d } t|t|�d� } |dur>| d | } | � | � | �d| �d | ��� |S ) a� Retrieve a module attribute which should have been deprecated, and assert that we saw the appropriate deprecation warning. @type moduleName: C{str} @param moduleName: Fully-qualified Python name of the module containing the deprecated attribute; if called from the same module as the attributes are being deprecated in, using the C{__name__} global can be helpful @type name: C{str} @param name: Attribute name which we expect to be deprecated @param version: The first L{version<twisted.python.versions.Version>} that the module attribute was deprecated. @type message: C{str} @param message: (optional) The expected deprecation message for the module attribute @return: The given attribute from the named module @raise FailTest: if no warnings were emitted on getattr, or if the L{DeprecationWarning} emitted did not produce the canonical please-use-something-else message that is standard for Twisted deprecations according to the given version and replacement. @since: Twisted 21.2.0 r� r � is not deprecated.r3 )�fqpn�versionNr� z Expected z to start with ) rD r: r r. � getDeprecatedModuleAttributer r` r r r� r� ) r � moduleName�namerS r3 rR �module�attrr� �observedWarning�expectedWarningr r r rT � s$ � �z0SynchronousTestCase.getDeprecatedModuleAttributec O s� ||i |��}| � | jg�}zt|�}W n ty! |}d} Y nw |\}} t|�dkr4| �|�d�� |d d } t||| d�} | �| | � |S )aM Call a function that should have been deprecated at a specific version and in favor of a specific alternative, and assert that it was thusly deprecated. @param version: A 2-sequence of (since, replacement), where C{since} is a the first L{version<incremental.Version>} that C{f} should have been deprecated since, and C{replacement} is a suggested replacement for the deprecated functionality, as described by L{twisted.python.deprecate.deprecated}. If there is no suggested replacement, this parameter may also be simply a L{version<incremental.Version>} by itself. @param f: The deprecated function to call. @param args: The arguments to pass to C{f}. @param kwargs: The keyword arguments to pass to C{f}. @return: Whatever C{f} returns. @raise Exception: Whatever C{f} raises. If any exception is raised by C{f}, though, no assertions will be made about emitted deprecations. @raise FailTest: if no warnings were emitted by C{f}, or if the L{DeprecationWarning} emitted did not produce the canonical please-use-something-else message that is standard for Twisted deprecations according to the given version and replacement. Nr rQ r3 )� replacement)r. �callDeprecatedr- r. r r` r r� ) r rS rI rJ rK rN r� re �sincer[ rY rZ r r r r\ � s � z"SynchronousTestCase.callDeprecatedc C sh d}t j�| jjd|� | jjd|� | jd|� �}t j�|�s&t �|� t � dd|�}t j�|d�S )a Create a new path name which can be used for a new file or directory. The result is a relative path that is guaranteed to be unique within the current working directory. The parent of the path will exist, but the path will not. For a temporary directory call os.mkdir on the path. For a temporary file just create the file (e.g. by opening the path for writing and then closing it). @return: The newly created path @rtype: C{str} � Nr� �temp) rB rC r� r� r r r �exists�makedirs�tempfile�mkdtemp)r � MAX_FILENAME�base�dirnamer r r �mktemp� s � zSynchronousTestCase.mktempc C s t �| jdg �S )ax Returns any warning suppressions set for this test. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{suppress} attribute, returns that. Returns any empty list (i.e. suppress no warnings) if it cannot find anything. See L{TestCase} docstring for more details. �suppress)r r$ r r$ r r r � _getSuppress s z SynchronousTestCase._getSuppressc C s& t |j�dkr |jd S t|d� |S )z� Return the reason to use for skipping a test method. @param method: The method which produced the skip. @param skip: A L{unittest.SkipTest} instance raised by C{method}. r zSDo not raise unittest.SkipTest with no arguments! Give a reason for skipping tests!)r rJ r )r rZ r! r r r �_getSkipReason" s �z"SynchronousTestCase._getSkipReasonc C s� t �|�rtd�|��}|�| t�|�� dS zt||� W dS ty< } z|� | | � ||�� W Y d}~dS d}~w t yn t�� }|du sO|� |�sd|� | j�rY|j}n|j}|| |� Y dS |�| ||� Y dS w )a� Run a single method, either a test method or fixture. @param suppress: Any warnings to suppress, as defined by the C{suppress} attribute on this method, test case, or the module it is defined in. @param todo: Any expected failure or failures, as defined by the C{todo} attribute on this method, test case, or the module it is defined in. @param method: The method to run. @param result: The TestResult instance to which to report results. @return: C{True} if the method fails and no further method/fixture calls should be made, C{False} otherwise. z9{!r} is a generator function and therefore will never runTNF)r@ �isgeneratorfunctionr. r� rb r r� r r rg rj r9 r( r& r� r^ rm ) r rh rk rZ rN �exc�er � addResultr r r �_run3 s4 �� � � � ��zSynchronousTestCase._runc C s� | � � }z*| �|d| j|�rW | �|� dS | �� }t| | j�}| �||||�}W | �|� n| �|� w |r?|s?|�| |� | �|d| j|�rJd}| j � � D ] }|� | |� d}qO| j � � | � � |sn|sp|�| � dS dS dS )z� Run C{setUp}, a test method, test cleanups, and C{tearDown}. @param result: The TestResult instance to which to report results. NT)ri ro �setUp� _runCleanupsr( r r rl �tearDownr9 r rb r �_removeObserverrn )r rN rh rk rZ �failedr' r r r r- ^ s* � �z'SynchronousTestCase._runFixturesAndTestc C sn t | j�dkr5| j�� \}}}z ||i |�� W n ty+ t�� }|�| |� Y nw t | j�dksdS dS )zG Synchronously run any cleanups which have been added. r N)r r �popr9 r r� rb )r rN rI rJ rK r r r rq ~ s ��z SynchronousTestCase._runCleanupsc C s t | _| j�� d S r) )� _logObserverr9 r r$ r r r r, � s z$SynchronousTestCase._installObserverc C s | j �� d S r) )r9 r r$ r r r rs � s z#SynchronousTestCase._removeObserver)r r) )"r r r r r r� r! �object�boolr r r r r r* r' r( r r2 r3 r5 r: r. rT r\ rg ri rj ro r- rq r, rs r� r r r� r r x s2 ( + W22 + r )2r r@ rB rD rb r< �unittest�pyunitrE �disr rE �typingr r r �twisted.internet.deferr �twisted.pythonr r r �twisted.python.deprecater r r r �twisted.python.reflectr �twisted.python.utilr � twisted.trialr r �AssertionErrorr r r0 r1 r< rO � ExceptionrP rQ rt �TestCaser� r� rv r r r r r �<module> sB & <] NQPK Mb�Z0X��6 6 trial/itrial.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Interfaces for Trial. Maintainer: Jonathan Lange """ import zope.interface as zi class ITestCase(zi.Interface): """ The interface that a test case must implement in order to be used in Trial. """ failureException = zi.Attribute( "The exception class that is raised by failed assertions" ) def __call__(result): """ Run the test. Should always do exactly the same thing as run(). """ def countTestCases(): """ Return the number of tests in this test case. Usually 1. """ def id(): """ Return a unique identifier for the test, usually the fully-qualified Python name. """ def run(result): """ Run the test, storing the results in C{result}. @param result: A L{TestResult}. """ def shortDescription(): """ Return a short description of the test. """ class IReporter(zi.Interface): """ I report results from a run of a test suite. """ shouldStop = zi.Attribute( "A boolean indicating that this reporter would like the " "test run to stop." ) testsRun = zi.Attribute( """ The number of tests that seem to have been run according to this reporter. """ ) def startTest(method): """ Report the beginning of a run of a single test method. @param method: an object that is adaptable to ITestMethod """ def stopTest(method): """ Report the status of a single test method @param method: an object that is adaptable to ITestMethod """ def addSuccess(test): """ Record that test passed. """ def addError(test, error): """ Record that a test has raised an unexpected exception. @param test: The test that has raised an error. @param error: The error that the test raised. It will either be a three-tuple in the style of C{sys.exc_info()} or a L{Failure<twisted.python.failure.Failure>} object. """ def addFailure(test, failure): """ Record that a test has failed with the given failure. @param test: The test that has failed. @param failure: The failure that the test failed with. It will either be a three-tuple in the style of C{sys.exc_info()} or a L{Failure<twisted.python.failure.Failure>} object. """ def addExpectedFailure(test, failure, todo=None): """ Record that the given test failed, and was expected to do so. In Twisted 15.5 and prior, C{todo} was a mandatory parameter. @type test: L{unittest.TestCase} @param test: The test which this is about. @type failure: L{failure.Failure} @param failure: The error which this test failed with. @type todo: L{unittest.Todo} @param todo: The reason for the test's TODO status. If L{None}, a generic reason is used. """ def addUnexpectedSuccess(test, todo=None): """ Record that the given test failed, and was expected to do so. In Twisted 15.5 and prior, C{todo} was a mandatory parameter. @type test: L{unittest.TestCase} @param test: The test which this is about. @type todo: L{unittest.Todo} @param todo: The reason for the test's TODO status. If L{None}, a generic reason is used. """ def addSkip(test, reason): """ Record that a test has been skipped for the given reason. @param test: The test that has been skipped. @param reason: An object that the test case has specified as the reason for skipping the test. """ def wasSuccessful(): """ Return a boolean indicating whether all test results that were reported to this reporter were successful or not. """ def done(): """ Called when the test run is complete. This gives the result object an opportunity to display a summary of information to the user. Once you have called C{done} on an L{IReporter} object, you should assume that the L{IReporter} object is no longer usable. """ PK Mb�Z*4G/�� �� trial/test/test_assertions.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for assertions provided by C{SynchronousTestCase} and C{TestCase}, provided by L{twisted.trial.unittest}. L{TestFailureTests} demonstrates that L{SynchronousTestCase.fail} works, so that is the only method on C{twisted.trial.unittest.SynchronousTestCase} that is initially assumed to work. The test classes are arranged so that the methods demonstrated to work earlier in the file are used by those later in the file (even though the runner will probably not run the tests in this order). """ import unittest as pyunit import warnings from incremental import Version, getVersionString from twisted.internet.defer import Deferred, fail, succeed from twisted.python.deprecate import deprecated, deprecatedModuleAttribute from twisted.python.failure import Failure from twisted.python.reflect import ( accumulateMethods, fullyQualifiedName, prefixedMethods, ) from twisted.python.util import FancyEqMixin from twisted.trial import unittest class MockEquality(FancyEqMixin): compareAttributes = ("name",) def __init__(self, name): self.name = name def __repr__(self) -> str: return f"MockEquality({self.name})" class ComparisonError: """ An object which raises exceptions from its comparison methods. """ def _error(self, other): raise ValueError("Comparison is broken") __eq__ = _error __ne__ = _error class TestFailureTests(pyunit.TestCase): """ Tests for the most basic functionality of L{SynchronousTestCase}, for failing tests. This class contains tests to demonstrate that L{SynchronousTestCase.fail} can be used to fail a test, and that that failure is reflected in the test result object. This should be sufficient functionality so that further tests can be built on L{SynchronousTestCase} instead of L{unittest.TestCase}. This depends on L{unittest.TestCase} working. """ class FailingTest(unittest.SynchronousTestCase): def test_fails(self): self.fail("This test fails.") def setUp(self): """ Load a suite of one test which can be used to exercise the failure handling behavior. """ components = [__name__, self.__class__.__name__, self.FailingTest.__name__] self.loader = pyunit.TestLoader() self.suite = self.loader.loadTestsFromName(".".join(components)) self.test = list(self.suite)[0] def test_fail(self): """ L{SynchronousTestCase.fail} raises L{SynchronousTestCase.failureException} with the given argument. """ try: self.test.fail("failed") except self.test.failureException as result: self.assertEqual("failed", str(result)) else: self.fail( "SynchronousTestCase.fail method did not raise " "SynchronousTestCase.failureException" ) def test_failingExceptionFails(self): """ When a test method raises L{SynchronousTestCase.failureException}, the test is marked as having failed on the L{TestResult}. """ result = pyunit.TestResult() self.suite.run(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(result.errors, []) self.assertEqual(len(result.failures), 1) self.assertEqual(result.failures[0][0], self.test) class AssertFalseTests(unittest.SynchronousTestCase): """ Tests for L{SynchronousTestCase}'s C{assertFalse} and C{failIf} assertion methods. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. @note: As of 11.2, C{assertFalse} is preferred over C{failIf}. """ def _assertFalseFalse(self, method): """ Perform the positive case test for C{failIf} or C{assertFalse}. @param method: The test method to test. """ for notTrue in [0, 0.0, False, None, (), []]: result = method(notTrue, f"failed on {notTrue!r}") if result != notTrue: self.fail(f"Did not return argument {notTrue!r}") def _assertFalseTrue(self, method): """ Perform the negative case test for C{failIf} or C{assertFalse}. @param method: The test method to test. """ for true in [1, True, "cat", [1, 2], (3, 4)]: try: method(true, f"failed on {true!r}") except self.failureException as e: self.assertIn( f"failed on {true!r}", str(e), f"Raised incorrect exception on {true!r}: {e!r}", ) else: self.fail( "Call to %s(%r) didn't fail" % ( method.__name__, true, ) ) def test_failIfFalse(self): """ L{SynchronousTestCase.failIf} returns its argument if its argument is not considered true. """ self._assertFalseFalse(self.failIf) def test_assertFalseFalse(self): """ L{SynchronousTestCase.assertFalse} returns its argument if its argument is not considered true. """ self._assertFalseFalse(self.assertFalse) def test_failIfTrue(self): """ L{SynchronousTestCase.failIf} raises L{SynchronousTestCase.failureException} if its argument is considered true. """ self._assertFalseTrue(self.failIf) def test_assertFalseTrue(self): """ L{SynchronousTestCase.assertFalse} raises L{SynchronousTestCase.failureException} if its argument is considered true. """ self._assertFalseTrue(self.assertFalse) class AssertTrueTests(unittest.SynchronousTestCase): """ Tests for L{SynchronousTestCase}'s C{assertTrue} and C{failUnless} assertion methods. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. @note: As of 11.2, C{assertTrue} is preferred over C{failUnless}. """ def _assertTrueFalse(self, method): """ Perform the negative case test for C{assertTrue} and C{failUnless}. @param method: The test method to test. """ for notTrue in [0, 0.0, False, None, (), []]: try: method(notTrue, f"failed on {notTrue!r}") except self.failureException as e: self.assertIn( f"failed on {notTrue!r}", str(e), f"Raised incorrect exception on {notTrue!r}: {e!r}", ) else: self.fail( "Call to %s(%r) didn't fail" % ( method.__name__, notTrue, ) ) def _assertTrueTrue(self, method): """ Perform the positive case test for C{assertTrue} and C{failUnless}. @param method: The test method to test. """ for true in [1, True, "cat", [1, 2], (3, 4)]: result = method(true, f"failed on {true!r}") if result != true: self.fail(f"Did not return argument {true!r}") def test_assertTrueFalse(self): """ L{SynchronousTestCase.assertTrue} raises L{SynchronousTestCase.failureException} if its argument is not considered true. """ self._assertTrueFalse(self.assertTrue) def test_failUnlessFalse(self): """ L{SynchronousTestCase.failUnless} raises L{SynchronousTestCase.failureException} if its argument is not considered true. """ self._assertTrueFalse(self.failUnless) def test_assertTrueTrue(self): """ L{SynchronousTestCase.assertTrue} returns its argument if its argument is considered true. """ self._assertTrueTrue(self.assertTrue) def test_failUnlessTrue(self): """ L{SynchronousTestCase.failUnless} returns its argument if its argument is considered true. """ self._assertTrueTrue(self.failUnless) class SynchronousAssertionsTests(unittest.SynchronousTestCase): """ Tests for L{SynchronousTestCase}'s assertion methods. That is, failUnless*, failIf*, assert* (not covered by other more specific test classes). Note: As of 11.2, assertEqual is preferred over the failUnlessEqual(s) variants. Tests have been modified to reflect this preference. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. """ def _testEqualPair(self, first, second): x = self.assertEqual(first, second) if x != first: self.fail("assertEqual should return first parameter") def _testUnequalPair(self, first, second): """ Assert that when called with unequal arguments, C{assertEqual} raises a failure exception with the same message as the standard library C{assertEqual} would have raised. """ raised = False try: self.assertEqual(first, second) except self.failureException as ourFailure: case = pyunit.TestCase("setUp") try: case.assertEqual(first, second) except case.failureException as theirFailure: raised = True got = str(ourFailure) expected = str(theirFailure) if expected != got: self.fail(f"Expected: {expected!r}; Got: {got!r}") if not raised: self.fail(f"Call to assertEqual({first!r}, {second!r}) didn't fail") def test_assertEqual_basic(self): self._testEqualPair("cat", "cat") self._testUnequalPair("cat", "dog") self._testEqualPair([1], [1]) self._testUnequalPair([1], "orange") def test_assertEqual_custom(self): x = MockEquality("first") y = MockEquality("second") z = MockEquality("first") self._testEqualPair(x, x) self._testEqualPair(x, z) self._testUnequalPair(x, y) self._testUnequalPair(y, z) def test_assertEqualMessage(self): """ When a message is passed to L{assertEqual} it is included in the error message. """ message = "message" exception = self.assertRaises( self.failureException, self.assertEqual, "foo", "bar", message ) self.assertIn(message, str(exception)) def test_assertEqualNoneMessage(self): """ If a message is specified as L{None}, it is not included in the error message of L{assertEqual}. """ exceptionForNone = self.assertRaises( self.failureException, self.assertEqual, "foo", "bar", None ) exceptionWithout = self.assertRaises( self.failureException, self.assertEqual, "foo", "bar" ) self.assertEqual(str(exceptionWithout), str(exceptionForNone)) def test_assertEqual_incomparable(self): apple = ComparisonError() orange = ["orange"] try: self.assertEqual(apple, orange) except self.failureException: self.fail("Fail raised when ValueError ought to have been raised.") except ValueError: # good. error not swallowed pass else: self.fail( "Comparing {!r} and {!r} should have raised an exception".format( apple, orange ) ) def _raiseError(self, error): raise error def test_failUnlessRaises_expected(self): x = self.failUnlessRaises(ValueError, self._raiseError, ValueError) self.assertTrue( isinstance(x, ValueError), "Expect failUnlessRaises to return instance of raised " "exception.", ) def test_failUnlessRaises_unexpected(self): try: self.failUnlessRaises(ValueError, self._raiseError, TypeError) except TypeError: self.fail("failUnlessRaises shouldn't re-raise unexpected " "exceptions") except self.failureException: # what we expect pass else: self.fail("Expected exception wasn't raised. Should have failed") def test_failUnlessRaises_noException(self): returnValue = 3 try: self.failUnlessRaises(ValueError, lambda: returnValue) except self.failureException as e: self.assertEqual(str(e), "ValueError not raised (3 returned)") else: self.fail("Exception not raised. Should have failed") def test_failUnlessRaises_failureException(self): x = self.failUnlessRaises( self.failureException, self._raiseError, self.failureException ) self.assertTrue( isinstance(x, self.failureException), f"Expected {self.failureException!r} instance to be returned", ) try: x = self.failUnlessRaises( self.failureException, self._raiseError, ValueError ) except self.failureException: # what we expect pass else: self.fail("Should have raised exception") def test_assertRaisesContextExpected(self): """ If C{assertRaises} is used to create a context manager and an exception is raised from the body of the C{with} statement then the context manager's C{exception} attribute is set to the exception that was raised. """ exception = ValueError("marker") with self.assertRaises(ValueError) as context: raise exception self.assertIs(exception, context.exception) def test_assertRaisesContextUnexpected(self): """ If C{assertRaises} is used to create a context manager and the wrong exception type is raised from the body of the C{with} statement then the C{with} statement raises C{failureException} describing the mismatch. """ try: with self.assertRaises(ValueError): raise TypeError("marker") except self.failureException as exception: message = str(exception) expected = ("{type} raised instead of ValueError:\n" " Traceback").format( type=fullyQualifiedName(TypeError) ) self.assertTrue( message.startswith(expected), "Exception message did not begin with expected information: " "{}".format(message), ) else: self.fail("Mismatched exception type should have caused test failure.") def test_assertRaisesContextNoException(self): """ If C{assertRaises} is used to create a context manager and no exception is raised from the body of the C{with} statement then the C{with} statement raises C{failureException} describing the lack of exception. """ try: with self.assertRaises(ValueError): # No exception is raised. pass except self.failureException as exception: message = str(exception) # `(None returned)` text is here for backward compatibility and should # be ignored for context manager use case. self.assertEqual(message, "ValueError not raised (None returned)") else: self.fail("Non-exception result should have caused test failure.") def test_brokenName(self): """ If the exception type passed to C{assertRaises} does not have a C{__name__} then the context manager still manages to construct a descriptive string for it. """ try: with self.assertRaises((ValueError, TypeError)): # Just some other kind of exception raise AttributeError() except self.failureException as exception: message = str(exception) valueError = "ValueError" not in message typeError = "TypeError" not in message errors = [] if valueError: errors.append("expected ValueError in exception message") if typeError: errors.append("expected TypeError in exception message") if errors: self.fail("; ".join(errors), f"message = {message}") else: self.fail("Mismatched exception type should have caused test failure.") def test_failIfEqual_basic(self): x, y, z = [1], [2], [1] ret = self.failIfEqual(x, y) self.assertEqual(ret, x, "failIfEqual should return first parameter") self.failUnlessRaises(self.failureException, self.failIfEqual, x, x) self.failUnlessRaises(self.failureException, self.failIfEqual, x, z) def test_failIfEqual_customEq(self): x = MockEquality("first") y = MockEquality("second") z = MockEquality("fecund") ret = self.failIfEqual(x, y) self.assertEqual(ret, x, "failIfEqual should return first parameter") self.failUnlessRaises(self.failureException, self.failIfEqual, x, x) self.failIfEqual(x, z, "__ne__ should make these not equal") def test_failIfIdenticalPositive(self): """ C{failIfIdentical} returns its first argument if its first and second arguments are not the same object. """ x = object() y = object() result = self.failIfIdentical(x, y) self.assertEqual(x, result) def test_failIfIdenticalNegative(self): """ C{failIfIdentical} raises C{failureException} if its first and second arguments are the same object. """ x = object() self.failUnlessRaises(self.failureException, self.failIfIdentical, x, x) def test_failUnlessIdentical(self): x, y, z = [1], [1], [2] ret = self.failUnlessIdentical(x, x) self.assertEqual(ret, x, "failUnlessIdentical should return first " "parameter") self.failUnlessRaises(self.failureException, self.failUnlessIdentical, x, y) self.failUnlessRaises(self.failureException, self.failUnlessIdentical, x, z) def test_failUnlessApproximates(self): x, y, z = 1.0, 1.1, 1.2 self.failUnlessApproximates(x, x, 0.2) ret = self.failUnlessApproximates(x, y, 0.2) self.assertEqual( ret, x, "failUnlessApproximates should return " "first parameter" ) self.failUnlessRaises( self.failureException, self.failUnlessApproximates, x, z, 0.1 ) self.failUnlessRaises( self.failureException, self.failUnlessApproximates, x, y, 0.1 ) def test_failUnlessAlmostEqual(self): precision = 5 x = 8.000001 y = 8.00001 z = 8.000002 self.failUnlessAlmostEqual(x, x, precision) ret = self.failUnlessAlmostEqual(x, z, precision) self.assertEqual( ret, x, "failUnlessAlmostEqual should return " "first parameter (%r, %r)" % (ret, x), ) self.failUnlessRaises( self.failureException, self.failUnlessAlmostEqual, x, y, precision ) def test_failIfAlmostEqual(self): precision = 5 x = 8.000001 y = 8.00001 z = 8.000002 ret = self.failIfAlmostEqual(x, y, precision) self.assertEqual( ret, x, "failIfAlmostEqual should return " "first parameter (%r, %r)" % (ret, x), ) self.failUnlessRaises( self.failureException, self.failIfAlmostEqual, x, x, precision ) self.failUnlessRaises( self.failureException, self.failIfAlmostEqual, x, z, precision ) def test_failUnlessSubstring(self): x = "cat" y = "the dog sat" z = "the cat sat" self.failUnlessSubstring(x, x) ret = self.failUnlessSubstring(x, z) self.assertEqual(ret, x, "should return first parameter") self.failUnlessRaises(self.failureException, self.failUnlessSubstring, x, y) self.failUnlessRaises(self.failureException, self.failUnlessSubstring, z, x) def test_failIfSubstring(self): x = "cat" y = "the dog sat" z = "the cat sat" self.failIfSubstring(z, x) ret = self.failIfSubstring(x, y) self.assertEqual(ret, x, "should return first parameter") self.failUnlessRaises(self.failureException, self.failIfSubstring, x, x) self.failUnlessRaises(self.failureException, self.failIfSubstring, x, z) def test_assertIs(self): """ L{assertIs} passes if two objects are identical. """ a = MockEquality("first") self.assertIs(a, a) def test_assertIsError(self): """ L{assertIs} fails if two objects are not identical. """ a, b = MockEquality("first"), MockEquality("first") self.assertEqual(a, b) self.assertRaises(self.failureException, self.assertIs, a, b) def test_assertIsNot(self): """ L{assertIsNot} passes if two objects are not identical. """ a, b = MockEquality("first"), MockEquality("first") self.assertEqual(a, b) self.assertIsNot(a, b) def test_assertIsNotError(self): """ L{assertIsNot} fails if two objects are identical. """ a = MockEquality("first") self.assertRaises(self.failureException, self.assertIsNot, a, a) def test_assertIsInstance(self): """ Test a true condition of assertIsInstance. """ A = type("A", (object,), {}) a = A() self.assertIsInstance(a, A) def test_assertIsInstanceMultipleClasses(self): """ Test a true condition of assertIsInstance with multiple classes. """ A = type("A", (object,), {}) B = type("B", (object,), {}) a = A() self.assertIsInstance(a, (A, B)) def test_assertIsInstanceError(self): """ Test an error with assertIsInstance. """ A = type("A", (object,), {}) B = type("B", (object,), {}) a = A() self.assertRaises(self.failureException, self.assertIsInstance, a, B) def test_assertIsInstanceErrorMultipleClasses(self): """ Test an error with assertIsInstance and multiple classes. """ A = type("A", (object,), {}) B = type("B", (object,), {}) C = type("C", (object,), {}) a = A() self.assertRaises(self.failureException, self.assertIsInstance, a, (B, C)) def test_assertIsInstanceCustomMessage(self): """ If L{TestCase.assertIsInstance} is passed a custom message as its 3rd argument, the message is included in the failure exception raised when the assertion fails. """ exc = self.assertRaises( self.failureException, self.assertIsInstance, 3, str, "Silly assertion" ) self.assertIn("Silly assertion", str(exc)) def test_assertNotIsInstance(self): """ Test a true condition of assertNotIsInstance. """ A = type("A", (object,), {}) B = type("B", (object,), {}) a = A() self.assertNotIsInstance(a, B) def test_assertNotIsInstanceMultipleClasses(self): """ Test a true condition of assertNotIsInstance and multiple classes. """ A = type("A", (object,), {}) B = type("B", (object,), {}) C = type("C", (object,), {}) a = A() self.assertNotIsInstance(a, (B, C)) def test_assertNotIsInstanceError(self): """ Test an error with assertNotIsInstance. """ A = type("A", (object,), {}) a = A() error = self.assertRaises(self.failureException, self.assertNotIsInstance, a, A) self.assertEqual(str(error), f"{a!r} is an instance of {A}") def test_assertNotIsInstanceErrorMultipleClasses(self): """ Test an error with assertNotIsInstance and multiple classes. """ A = type("A", (object,), {}) B = type("B", (object,), {}) a = A() self.assertRaises(self.failureException, self.assertNotIsInstance, a, (A, B)) def test_assertDictEqual(self): """ L{twisted.trial.unittest.TestCase} supports the C{assertDictEqual} method inherited from the standard library in Python 2.7. """ self.assertDictEqual({"a": 1}, {"a": 1}) if getattr(unittest.SynchronousTestCase, "assertDictEqual", None) is None: test_assertDictEqual.skip = ( # type: ignore[attr-defined] "assertDictEqual is not available on this version of Python" ) class WarningAssertionTests(unittest.SynchronousTestCase): def test_assertWarns(self): """ Test basic assertWarns report. """ def deprecated(a): warnings.warn("Woo deprecated", category=DeprecationWarning) return a r = self.assertWarns( DeprecationWarning, "Woo deprecated", __file__, deprecated, 123 ) self.assertEqual(r, 123) def test_assertWarnsRegistryClean(self): """ Test that assertWarns cleans the warning registry, so the warning is not swallowed the second time. """ def deprecated(a): warnings.warn("Woo deprecated", category=DeprecationWarning) return a r1 = self.assertWarns( DeprecationWarning, "Woo deprecated", __file__, deprecated, 123 ) self.assertEqual(r1, 123) # The warning should be raised again r2 = self.assertWarns( DeprecationWarning, "Woo deprecated", __file__, deprecated, 321 ) self.assertEqual(r2, 321) def test_assertWarnsError(self): """ Test assertWarns failure when no warning is generated. """ def normal(a): return a self.assertRaises( self.failureException, self.assertWarns, DeprecationWarning, "Woo deprecated", __file__, normal, 123, ) def test_assertWarnsWrongCategory(self): """ Test assertWarns failure when the category is wrong. """ def deprecated(a): warnings.warn("Foo deprecated", category=DeprecationWarning) return a self.assertRaises( self.failureException, self.assertWarns, UserWarning, "Foo deprecated", __file__, deprecated, 123, ) def test_assertWarnsWrongMessage(self): """ Test assertWarns failure when the message is wrong. """ def deprecated(a): warnings.warn("Foo deprecated", category=DeprecationWarning) return a self.assertRaises( self.failureException, self.assertWarns, DeprecationWarning, "Bar deprecated", __file__, deprecated, 123, ) def test_assertWarnsWrongFile(self): """ If the warning emitted by a function refers to a different file than is passed to C{assertWarns}, C{failureException} is raised. """ def deprecated(a): # stacklevel=2 points at the direct caller of the function. The # way assertRaises is invoked below, the direct caller will be # something somewhere in trial, not something in this file. In # Python 2.5 and earlier, stacklevel of 0 resulted in a warning # pointing to the warnings module itself. Starting in Python 2.6, # stacklevel of 0 and 1 both result in a warning pointing to *this* # file, presumably due to the fact that the warn function is # implemented in C and has no convenient Python # filename/linenumber. warnings.warn("Foo deprecated", category=DeprecationWarning, stacklevel=2) self.assertRaises( self.failureException, # Since the direct caller isn't in this file, try to assert that # the warning *does* point to this file, so that assertWarns raises # an exception. self.assertWarns, DeprecationWarning, "Foo deprecated", __file__, deprecated, 123, ) def test_assertWarnsOnClass(self): """ Test assertWarns works when creating a class instance. """ class Warn: def __init__(self): warnings.warn("Do not call me", category=RuntimeWarning) r = self.assertWarns(RuntimeWarning, "Do not call me", __file__, Warn) self.assertTrue(isinstance(r, Warn)) r = self.assertWarns(RuntimeWarning, "Do not call me", __file__, Warn) self.assertTrue(isinstance(r, Warn)) def test_assertWarnsOnMethod(self): """ Test assertWarns works when used on an instance method. """ class Warn: def deprecated(self, a): warnings.warn("Bar deprecated", category=DeprecationWarning) return a w = Warn() r = self.assertWarns( DeprecationWarning, "Bar deprecated", __file__, w.deprecated, 321 ) self.assertEqual(r, 321) r = self.assertWarns( DeprecationWarning, "Bar deprecated", __file__, w.deprecated, 321 ) self.assertEqual(r, 321) def test_assertWarnsOnCall(self): """ Test assertWarns works on instance with C{__call__} method. """ class Warn: def __call__(self, a): warnings.warn("Egg deprecated", category=DeprecationWarning) return a w = Warn() r = self.assertWarns(DeprecationWarning, "Egg deprecated", __file__, w, 321) self.assertEqual(r, 321) r = self.assertWarns(DeprecationWarning, "Egg deprecated", __file__, w, 321) self.assertEqual(r, 321) def test_assertWarnsFilter(self): """ Test assertWarns on a warning filtered by default. """ def deprecated(a): warnings.warn("Woo deprecated", category=PendingDeprecationWarning) return a r = self.assertWarns( PendingDeprecationWarning, "Woo deprecated", __file__, deprecated, 123 ) self.assertEqual(r, 123) def test_assertWarnsMultipleWarnings(self): """ C{assertWarns} does not raise an exception if the function it is passed triggers the same warning more than once. """ def deprecated(): warnings.warn("Woo deprecated", category=PendingDeprecationWarning) def f(): deprecated() deprecated() self.assertWarns(PendingDeprecationWarning, "Woo deprecated", __file__, f) def test_assertWarnsDifferentWarnings(self): """ For now, assertWarns is unable to handle multiple different warnings, so it should raise an exception if it's the case. """ def deprecated(a): warnings.warn("Woo deprecated", category=DeprecationWarning) warnings.warn("Another one", category=PendingDeprecationWarning) e = self.assertRaises( self.failureException, self.assertWarns, DeprecationWarning, "Woo deprecated", __file__, deprecated, 123, ) self.assertEqual(str(e), "Can't handle different warnings") def test_assertWarnsAfterUnassertedWarning(self): """ Warnings emitted before L{TestCase.assertWarns} is called do not get flushed and do not alter the behavior of L{TestCase.assertWarns}. """ class TheWarning(Warning): pass def f(message): warnings.warn(message, category=TheWarning) f("foo") self.assertWarns(TheWarning, "bar", __file__, f, "bar") [warning] = self.flushWarnings([f]) self.assertEqual(warning["message"], "foo") class ResultOfAssertionsTests(unittest.SynchronousTestCase): """ Tests for L{SynchronousTestCase.successResultOf}, L{SynchronousTestCase.failureResultOf}, and L{SynchronousTestCase.assertNoResult}. """ result = object() failure = Failure(Exception("Bad times")) def test_withoutResult(self): """ L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with no current result. """ self.assertRaises(self.failureException, self.successResultOf, Deferred()) def test_successResultOfWithFailure(self): """ L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with a failure result. """ self.assertRaises( self.failureException, self.successResultOf, fail(self.failure) ) def test_successResultOfWithFailureHasTraceback(self): """ L{SynchronousTestCase.successResultOf} raises a L{SynchronousTestCase.failureException} that has the original failure traceback when called with a L{Deferred} with a failure result. """ try: self.successResultOf(fail(self.failure)) except self.failureException as e: self.assertIn(self.failure.getTraceback(), str(e)) def test_failureResultOfWithoutResult(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with no current result. """ self.assertRaises(self.failureException, self.failureResultOf, Deferred()) def test_failureResultOfWithSuccess(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with a success result. """ self.assertRaises( self.failureException, self.failureResultOf, succeed(self.result) ) def test_failureResultOfWithWrongFailure(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected. """ self.assertRaises( self.failureException, self.failureResultOf, fail(self.failure), KeyError ) def test_failureResultOfWithWrongFailureOneExpectedFailure(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception type. """ try: self.failureResultOf(fail(self.failure), KeyError) except self.failureException as e: self.assertIn( "Failure of type ({}.{}) expected on".format( KeyError.__module__, KeyError.__name__ ), str(e), ) def test_failureResultOfWithWrongFailureOneExpectedFailureHasTB(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original failure traceback. """ try: self.failureResultOf(fail(self.failure), KeyError) except self.failureException as e: self.assertIn(self.failure.getTraceback(), str(e)) def test_failureResultOfWithWrongFailureMultiExpectedFailures(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception types in the error message. """ try: self.failureResultOf(fail(self.failure), KeyError, IOError) except self.failureException as e: self.assertIn( "Failure of type ({}.{} or {}.{}) expected on".format( KeyError.__module__, KeyError.__name__, IOError.__module__, IOError.__name__, ), str(e), ) def test_failureResultOfWithWrongFailureMultiExpectedFailuresHasTB(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original failure traceback in the error message. """ try: self.failureResultOf(fail(self.failure), KeyError, IOError) except self.failureException as e: self.assertIn(self.failure.getTraceback(), str(e)) def test_successResultOfWithSuccessResult(self): """ When passed a L{Deferred} which currently has a result (ie, L{Deferred.addCallback} would cause the added callback to be called before C{addCallback} returns), L{SynchronousTestCase.successResultOf} returns that result. """ self.assertIdentical(self.result, self.successResultOf(succeed(self.result))) def test_failureResultOfWithExpectedFailureResult(self): """ When passed a L{Deferred} which currently has a L{Failure} result (ie, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns that L{Failure} if its contained exception type is expected. """ self.assertIdentical( self.failure, self.failureResultOf(fail(self.failure), self.failure.type, KeyError), ) def test_failureResultOfWithFailureResult(self): """ When passed a L{Deferred} which currently has a L{Failure} result (ie, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns that L{Failure}. """ self.assertIdentical(self.failure, self.failureResultOf(fail(self.failure))) def test_assertNoResultSuccess(self): """ When passed a L{Deferred} which currently has a success result (see L{test_withSuccessResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. """ self.assertRaises( self.failureException, self.assertNoResult, succeed(self.result) ) def test_assertNoResultFailure(self): """ When passed a L{Deferred} which currently has a failure result (see L{test_withFailureResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. """ self.assertRaises( self.failureException, self.assertNoResult, fail(self.failure) ) def test_assertNoResult(self): """ When passed a L{Deferred} with no current result, L{SynchronousTestCase.assertNoResult} does not raise an exception. """ self.assertNoResult(Deferred()) def test_assertNoResultPropagatesSuccess(self): """ When passed a L{Deferred} with no current result, which is then fired with a success result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. """ d = Deferred() self.assertNoResult(d) d.callback(self.result) self.assertEqual(self.result, self.successResultOf(d)) def test_assertNoResultPropagatesLaterFailure(self): """ When passed a L{Deferred} with no current result, which is then fired with a L{Failure} result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. """ d = Deferred() self.assertNoResult(d) d.errback(self.failure) self.assertEqual(self.failure, self.failureResultOf(d)) def test_assertNoResultSwallowsImmediateFailure(self): """ When passed a L{Deferred} which currently has a L{Failure} result, L{SynchronousTestCase.assertNoResult} changes the result of the L{Deferred} to a success. """ d = fail(self.failure) try: self.assertNoResult(d) except self.failureException: pass self.assertEqual(None, self.successResultOf(d)) class ResultOfCoroutineAssertionsTests(unittest.SynchronousTestCase): """ Tests for L{SynchronousTestCase.successResultOf}, L{SynchronousTestCase.failureResultOf}, and L{SynchronousTestCase.assertNoResult} when given a coroutine. """ result = object() exception = Exception("Bad times") failure = Failure(exception) async def successResult(self): return self.result async def noCurrentResult(self): await Deferred() async def raisesException(self, exception=None): if exception is None: exception = self.exception raise exception def test_withoutResult(self): """ L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with no current result. """ self.assertRaises( self.failureException, self.successResultOf, self.noCurrentResult() ) def test_successResultOfWithException(self): """ L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception. """ self.assertRaises( self.failureException, self.successResultOf, self.raisesException() ) def test_successResultOfWithFailureHasTraceback(self): """ L{SynchronousTestCase.successResultOf} raises a L{SynchronousTestCase.failureException} that has the original failure traceback when called with a coroutine with a failure result. """ exception = Exception("Bad times") try: self.successResultOf(self.raisesException(exception)) except self.failureException as e: self.assertIn("Success result expected on", str(e)) self.assertIn("builtins.Exception: Bad times", str(e)) def test_failureResultOfWithoutResult(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with no current result. """ self.assertRaises( self.failureException, self.failureResultOf, self.noCurrentResult() ) def test_failureResultOfWithSuccess(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with a success result. """ self.assertRaises( self.failureException, self.failureResultOf, self.successResult() ) def test_failureResultOfWithWrongFailure(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception that was not expected. """ self.assertRaises( self.failureException, self.failureResultOf, self.raisesException(), KeyError, ) def test_failureResultOfWithWrongExceptionOneExpectedException(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception with a failure type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception type. """ try: self.failureResultOf(self.raisesException(), KeyError) except self.failureException as e: self.assertIn( "Failure of type ({}.{}) expected on".format( KeyError.__module__, KeyError.__name__ ), str(e), ) def test_failureResultOfWithWrongExceptionOneExpectedExceptionHasTB(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception with a failure type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original exception traceback. """ exception = Exception("Bad times") try: self.failureResultOf(self.raisesException(exception), KeyError) except self.failureException as e: self.assertIn("Failure of type (builtins.KeyError) expected on", str(e)) self.assertIn("builtins.Exception: Bad times", str(e)) def test_failureResultOfWithWrongExceptionMultiExpectedExceptions(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception of a type that was not expected, and the L{SynchronousTestCase.failureException} message contains expected exception types in the error message. """ try: self.failureResultOf(self.raisesException(), KeyError, IOError) except self.failureException as e: self.assertIn( "Failure of type ({}.{} or {}.{}) expected on".format( KeyError.__module__, KeyError.__name__, IOError.__module__, IOError.__name__, ), str(e), ) def test_failureResultOfWithWrongExceptionMultiExpectedExceptionsHasTB(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception of a type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original exception traceback in the error message. """ exception = Exception("Bad times") try: self.failureResultOf(self.raisesException(exception), KeyError, IOError) except self.failureException as e: self.assertIn( "Failure of type (builtins.KeyError or builtins.OSError) expected on", str(e), ) self.assertIn("builtins.Exception: Bad times", str(e)) def test_successResultOfWithSuccessResult(self): """ When passed a coroutine which currently has a result (ie, if converted into a L{Deferred}, L{Deferred.addCallback} would cause the added callback to be called before C{addCallback} returns), L{SynchronousTestCase.successResultOf} returns that result. """ self.assertIdentical(self.result, self.successResultOf(self.successResult())) def test_failureResultOfWithExpectedException(self): """ When passed a coroutine which currently has an exception result (ie, if converted into a L{Deferred}, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns a L{Failure} containing that exception, if the exception type is expected. """ self.assertEqual( self.failure.value, self.failureResultOf( self.raisesException(), self.failure.type, KeyError ).value, ) def test_failureResultOfWithException(self): """ When passed a coroutine which currently has an exception result (ie, if converted into a L{Deferred}, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns returns a L{Failure} containing that exception. """ self.assertEqual( self.failure.value, self.failureResultOf(self.raisesException()).value ) def test_assertNoResultSuccess(self): """ When passed a coroutine which currently has a success result (see L{test_withSuccessResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. """ self.assertRaises( self.failureException, self.assertNoResult, self.successResult() ) def test_assertNoResultFailure(self): """ When passed a coroutine which currently has an exception result (see L{test_withFailureResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. """ self.assertRaises( self.failureException, self.assertNoResult, self.raisesException() ) def test_assertNoResult(self): """ When passed a coroutine with no current result, L{SynchronousTestCase.assertNoResult} does not raise an exception. """ self.assertNoResult(self.noCurrentResult()) def test_assertNoResultPropagatesSuccess(self): """ When passed a coroutine awaiting a L{Deferred} with no current result, which is then fired with a success result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. """ d = Deferred() async def noCurrentResult(): return await d c = noCurrentResult() self.assertNoResult(d) d.callback(self.result) self.assertEqual(self.result, self.successResultOf(c)) def test_assertNoResultPropagatesLaterFailure(self): """ When passed a coroutine awaiting a L{Deferred} with no current result, which is then fired with a L{Failure} result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. """ f = Failure(self.exception) d = Deferred() async def noCurrentResult(): return await d c = noCurrentResult() self.assertNoResult(d) d.errback(f) self.assertEqual(f.value, self.failureResultOf(c).value) def test_assertNoResultSwallowsImmediateFailure(self): """ When passed a L{Deferred} which currently has a L{Failure} result, L{SynchronousTestCase.assertNoResult} changes the result of the L{Deferred} to a success. """ d = fail(self.failure) async def raisesException(): return await d c = raisesException() try: self.assertNoResult(d) except self.failureException: pass self.assertEqual(None, self.successResultOf(c)) class AssertionNamesTests(unittest.SynchronousTestCase): """ Tests for consistency of naming within TestCase assertion methods """ def _getAsserts(self): dct = {} accumulateMethods(self, dct, "assert") return [dct[k] for k in dct if not k.startswith("Not") and k != "_"] def _name(self, x): return x.__name__ def test_failUnlessMatchesAssert(self): """ The C{failUnless*} test methods are a subset of the C{assert*} test methods. This is intended to ensure that methods using the I{failUnless} naming scheme are not added without corresponding methods using the I{assert} naming scheme. The I{assert} naming scheme is preferred, and new I{assert}-prefixed methods may be added without corresponding I{failUnless}-prefixed methods. """ asserts = set(self._getAsserts()) failUnlesses = set(prefixedMethods(self, "failUnless")) self.assertEqual(failUnlesses, asserts.intersection(failUnlesses)) def test_failIf_matches_assertNot(self): asserts = prefixedMethods(unittest.SynchronousTestCase, "assertNot") failIfs = prefixedMethods(unittest.SynchronousTestCase, "failIf") self.assertEqual( sorted(asserts, key=self._name), sorted(failIfs, key=self._name) ) def test_equalSpelling(self): for name, value in vars(self).items(): if not callable(value): continue if name.endswith("Equal"): self.assertTrue(hasattr(self, name + "s"), f"{name} but no {name}s") self.assertEqual(value, getattr(self, name + "s")) if name.endswith("Equals"): self.assertTrue(hasattr(self, name[:-1]), f"{name} but no {name[:-1]}") self.assertEqual(value, getattr(self, name[:-1])) class CallDeprecatedTests(unittest.SynchronousTestCase): """ Test use of the L{SynchronousTestCase.callDeprecated} method with version objects. """ version = Version("Twisted", 8, 0, 0) def test_callDeprecatedSuppressesWarning(self): """ callDeprecated calls a deprecated callable, suppressing the deprecation warning. """ self.callDeprecated(self.version, oldMethod, "foo") self.assertEqual(self.flushWarnings(), [], "No warnings should be shown") def test_callDeprecatedCallsFunction(self): """ L{callDeprecated} actually calls the callable passed to it, and forwards the result. """ result = self.callDeprecated(self.version, oldMethod, "foo") self.assertEqual("foo", result) def test_failsWithoutDeprecation(self): """ L{callDeprecated} raises a test failure if the callable is not deprecated. """ def notDeprecated(): pass exception = self.assertRaises( self.failureException, self.callDeprecated, self.version, notDeprecated ) self.assertEqual("%r is not deprecated." % notDeprecated, str(exception)) def test_failsWithIncorrectDeprecation(self): """ callDeprecated raises a test failure if the callable was deprecated at a different version to the one expected. """ differentVersion = Version("Foo", 1, 2, 3) exception = self.assertRaises( self.failureException, self.callDeprecated, differentVersion, oldMethod, "foo", ) self.assertIn(getVersionString(self.version), str(exception)) self.assertIn(getVersionString(differentVersion), str(exception)) def test_nestedDeprecation(self): """ L{callDeprecated} ignores all deprecations apart from the first. Multiple warnings are generated when a deprecated function calls another deprecated function. The first warning is the one generated by the explicitly called function. That's the warning that we care about. """ differentVersion = Version("Foo", 1, 2, 3) def nestedDeprecation(*args): return oldMethod(*args) nestedDeprecation = deprecated(differentVersion)(nestedDeprecation) self.callDeprecated(differentVersion, nestedDeprecation, 24) # The oldMethod deprecation should have been emitted too, not captured # by callDeprecated. Flush it now to make sure it did happen and to # prevent it from showing up on stdout. warningsShown = self.flushWarnings() self.assertEqual(len(warningsShown), 1, f"Unexpected warnings: {warningsShown}") def test_callDeprecationWithMessage(self): """ L{callDeprecated} can take a message argument used to check the warning emitted. """ self.callDeprecated((self.version, "newMethod"), oldMethodReplaced, 1) def test_callDeprecationWithWrongMessage(self): """ If the message passed to L{callDeprecated} doesn't match, L{callDeprecated} raises a test failure. """ exception = self.assertRaises( self.failureException, self.callDeprecated, (self.version, "something.wrong"), oldMethodReplaced, 1, ) self.assertIn(getVersionString(self.version), str(exception)) self.assertIn("please use newMethod instead", str(exception)) @deprecated(CallDeprecatedTests.version) def oldMethod(x): """ Deprecated method for testing. """ return x @deprecated(CallDeprecatedTests.version, replacement="newMethod") def oldMethodReplaced(x): """ Another deprecated method, which has been deprecated in favor of the mythical 'newMethod'. """ return 2 * x class GetDeprecatedModuleAttributeTests(unittest.SynchronousTestCase): """ Test L{SynchronousTestCase.getDeprecatedModuleAttribute} @ivar version: The version at which L{test_assertions.somethingOld} is marked deprecated. @type version: L{incremental.Version} """ version = Version("Bar", 1, 2, 3) def test_deprecated(self): """ L{getDeprecatedModuleAttribute} returns the specified attribute and consumes the deprecation warning that generates. """ self.assertIs( _somethingOld, self.getDeprecatedModuleAttribute( __name__, "somethingOld", self.version, ), ) self.assertEqual([], self.flushWarnings()) def test_message(self): """ The I{message} argument to L{getDeprecatedModuleAttribute} matches the prefix of the deprecation message. """ self.assertIs( _somethingOld, self.getDeprecatedModuleAttribute( __name__, "somethingOld", self.version, message="It's old", ), ) self.assertEqual([], self.flushWarnings()) def test_messageMismatch(self): """ L{getDeprecatedModuleAttribute} fails the test if the I{message} isn't part of the deprecation message prefix. """ self.assertRaises( self.failureException, self.getDeprecatedModuleAttribute, __name__, "somethingOld", self.version, "It's shiny and new", # Doesn't match. ) self.assertEqual([], self.flushWarnings()) def test_notDeprecated(self): """ L{getDeprecatedModuleAttribute} fails the test when used to get an attribute that isn't actually deprecated. """ self.assertRaises( self.failureException, self.getDeprecatedModuleAttribute, __name__, "somethingNew", self.version, ) def somethingOld(): """ A deprecated module attribute. Used by L{GetDeprecatedModuleAttributeTests.test_deprecated}. """ # A non-deprecated alias of _somethingOld. _somethingOld = somethingOld deprecatedModuleAttribute( GetDeprecatedModuleAttributeTests.version, "It's old and clunky", __name__, "somethingOld", ) def somethingNew(): """ A module attribute that is not deprecated. Used by L{GetDeprecatedModuleAttributeTests.test_notDeprecated}. """ PK Mb�Z���:� � trial/test/weird.pynu �[��� import unittest from twisted.internet import defer # Used in test_tests.UnhandledDeferredTests class TestBleeding(unittest.TestCase): """This test creates an unhandled Deferred and leaves it in a cycle. The Deferred is left in a cycle so that the garbage collector won't pick it up immediately. We were having some problems where unhandled Deferreds in one test were failing random other tests. (See #1507, #1213) """ def test_unhandledDeferred(self): try: 1 / 0 except ZeroDivisionError: f = defer.fail() # these two lines create the cycle. don't remove them l = [f] l.append(l) PK Mb�Zy�� trial/test/mockcustomsuite.pynu �[��� # Copyright (c) 2006 Twisted Matrix Laboratories. See LICENSE for details """ Mock test module that contains a C{test_suite} method. L{runner.TestLoader} should load the tests from the C{test_suite}, not from the C{Foo} C{TestCase}. See {twisted.trial.test.test_loader.LoaderTest.test_loadModuleWith_test_suite}. """ from twisted.trial import runner, unittest class Foo(unittest.SynchronousTestCase): def test_foo(self): pass def test_suite(): ts = runner.TestSuite() ts.name = "MyCustomSuite" return ts PK Mb�Zg�kZ# # trial/test/detests.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for Deferred handling by L{twisted.trial.unittest.TestCase}. """ from twisted.internet import defer, reactor, threads from twisted.python.util import runWithWarningsSuppressed from twisted.trial import unittest from twisted.trial.util import suppress as SUPPRESS class DeferredSetUpOK(unittest.TestCase): def setUp(self): d = defer.succeed("value") d.addCallback(self._cb_setUpCalled) return d def _cb_setUpCalled(self, ignored): self._setUpCalled = True def test_ok(self): self.assertTrue(self._setUpCalled) class DeferredSetUpFail(unittest.TestCase): testCalled = False def setUp(self): return defer.fail(unittest.FailTest("i fail")) def test_ok(self): DeferredSetUpFail.testCalled = True self.fail("I should not get called") class DeferredSetUpCallbackFail(unittest.TestCase): testCalled = False def setUp(self): d = defer.succeed("value") d.addCallback(self._cb_setUpCalled) return d def _cb_setUpCalled(self, ignored): self.fail("deliberate failure") def test_ok(self): DeferredSetUpCallbackFail.testCalled = True class DeferredSetUpError(unittest.TestCase): testCalled = False def setUp(self): return defer.fail(RuntimeError("deliberate error")) def test_ok(self): DeferredSetUpError.testCalled = True class DeferredSetUpNeverFire(unittest.TestCase): testCalled = False def setUp(self): return defer.Deferred() def test_ok(self): DeferredSetUpNeverFire.testCalled = True class DeferredSetUpSkip(unittest.TestCase): testCalled = False def setUp(self): d = defer.succeed("value") d.addCallback(self._cb1) return d def _cb1(self, ignored): raise unittest.SkipTest("skip me") def test_ok(self): DeferredSetUpSkip.testCalled = True class DeferredTests(unittest.TestCase): touched = False def _cb_fail(self, reason): self.fail(reason) def _cb_error(self, reason): raise RuntimeError(reason) def _cb_skip(self, reason): raise unittest.SkipTest(reason) def _touchClass(self, ignored): self.__class__.touched = True def setUp(self): self.__class__.touched = False def test_pass(self): return defer.succeed("success") def test_passGenerated(self): self._touchClass(None) yield None test_passGenerated = runWithWarningsSuppressed( [ SUPPRESS( message="twisted.internet.defer.deferredGenerator was " "deprecated" ) ], defer.deferredGenerator, test_passGenerated, ) @defer.inlineCallbacks def test_passInlineCallbacks(self): """ Test case that is decorated with L{defer.inlineCallbacks}. """ self._touchClass(None) yield None def test_fail(self): return defer.fail(self.failureException("I fail")) def test_failureInCallback(self): d = defer.succeed("fail") d.addCallback(self._cb_fail) return d def test_errorInCallback(self): d = defer.succeed("error") d.addCallback(self._cb_error) return d def test_skip(self): d = defer.succeed("skip") d.addCallback(self._cb_skip) d.addCallback(self._touchClass) return d def test_thread(self): return threads.deferToThread(lambda: None) def test_expectedFailure(self): d = defer.succeed("todo") d.addCallback(self._cb_error) return d test_expectedFailure.todo = "Expected failure" # type: ignore[attr-defined] class TimeoutTests(unittest.TestCase): timedOut = None def test_pass(self): d = defer.Deferred() reactor.callLater(0, d.callback, "hoorj!") return d test_pass.timeout = 2 # type: ignore[attr-defined] def test_passDefault(self): # test default timeout d = defer.Deferred() reactor.callLater(0, d.callback, "hoorj!") return d def test_timeout(self): return defer.Deferred() test_timeout.timeout = 0.1 # type: ignore[attr-defined] def test_timeoutZero(self): return defer.Deferred() test_timeoutZero.timeout = 0 # type: ignore[attr-defined] def test_expectedFailure(self): return defer.Deferred() test_expectedFailure.timeout = 0.1 # type: ignore[attr-defined] test_expectedFailure.todo = "i will get it right, eventually" # type: ignore[attr-defined] def test_skip(self): return defer.Deferred() test_skip.timeout = 0.1 # type: ignore[attr-defined] test_skip.skip = "i will get it right, eventually" # type: ignore[attr-defined] def test_errorPropagation(self): def timedOut(err): self.__class__.timedOut = err return err d = defer.Deferred() d.addErrback(timedOut) return d test_errorPropagation.timeout = 0.1 # type: ignore[attr-defined] def test_calledButNeverCallback(self): d = defer.Deferred() def neverFire(r): return defer.Deferred() d.addCallback(neverFire) d.callback(1) return d test_calledButNeverCallback.timeout = 0.1 # type: ignore[attr-defined] class TestClassTimeoutAttribute(unittest.TestCase): timeout = 0.2 def setUp(self): self.d = defer.Deferred() def testMethod(self): self.methodCalled = True return self.d PK Mb�Z��ȁ� � trial/test/scripttest.pynu ȯ�� #! /usr/bin/python3 # -*- test-case-name: twisted.trial.test.test_log,twisted.trial.test.test_runner -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # fodder for test_script, which parses files for emacs local variable # declarations. This one is supposed to have: # test-case-name: twisted.trial.test.test_log,twisted.trial.test.test_runner # in the second line # The class declaration is irrelevant class Foo: pass PK Mb�Z���XW XW trial/test/test_loader.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for loading tests by name. """ import os import sys import unittest as pyunit from hashlib import md5 from twisted.python import filepath, util from twisted.python.modules import getModule from twisted.python.reflect import ModuleNotFound from twisted.trial import reporter, runner, unittest from twisted.trial._asyncrunner import _iterateTests from twisted.trial.itrial import ITestCase from twisted.trial.test import packages def testNames(tests): """ Return the id of each test within the given test suite or case. """ names = [] for test in _iterateTests(tests): names.append(test.id()) return names class FinderPy3Tests(packages.SysPathManglingTest): def setUp(self): super().setUp() self.loader = runner.TestLoader() def test_findNonModule(self): """ findByName, if given something findable up until the last entry, will raise AttributeError (as it cannot tell if 'nonexistent' here is supposed to be a module or a class). """ self.assertRaises( AttributeError, self.loader.findByName, "twisted.trial.test.nonexistent" ) def test_findNonPackage(self): self.assertRaises(ModuleNotFound, self.loader.findByName, "nonextant") def test_findNonFile(self): """ findByName, given a file path that doesn't exist, will raise a ValueError saying that it is not a Python file. """ path = util.sibpath(__file__, "nonexistent.py") self.assertRaises(ValueError, self.loader.findByName, path) def test_findFileWithImportError(self): """ findByName will re-raise ImportErrors inside modules that it has found and imported. """ self.assertRaises( ImportError, self.loader.findByName, "unimportablepackage.test_module" ) class FileTests(packages.SysPathManglingTest): """ Tests for L{runner.filenameToModule}. """ def test_notFile(self): """ L{runner.filenameToModule} raises a C{ValueError} when a non-existing file is passed. """ err = self.assertRaises(ValueError, runner.filenameToModule, "it") self.assertEqual(str(err), "'it' doesn't exist") def test_moduleInPath(self): """ If the file in question is a module on the Python path, then it should properly import and return that module. """ sample1 = runner.filenameToModule(util.sibpath(__file__, "sample.py")) from twisted.trial.test import sample as sample2 self.assertEqual(sample2, sample1) def test_moduleNotInPath(self): """ If passed the path to a file containing the implementation of a module within a package which is not on the import path, L{runner.filenameToModule} returns a module object loosely resembling the module defined by that file anyway. """ self.mangleSysPath(self.oldPath) sample1 = runner.filenameToModule( os.path.join(self.parent, "goodpackage", "test_sample.py") ) self.assertEqual(sample1.__name__, "goodpackage.test_sample") self.cleanUpModules() self.mangleSysPath(self.newPath) from goodpackage import test_sample as sample2 # type: ignore[import] self.assertIsNot(sample1, sample2) self.assertEqual(sample1.__spec__, sample2.__spec__) def test_packageInPath(self): """ If the file in question is a package on the Python path, then it should properly import and return that package. """ package1 = runner.filenameToModule(os.path.join(self.parent, "goodpackage")) self.assertIs(package1, sys.modules["goodpackage"]) def test_packageNotInPath(self): """ If passed the path to a directory which represents a package which is not on the import path, L{runner.filenameToModule} returns a module object loosely resembling the package defined by that directory anyway. """ self.mangleSysPath(self.oldPath) package1 = runner.filenameToModule(os.path.join(self.parent, "goodpackage")) self.assertEqual(package1.__name__, "goodpackage") self.cleanUpModules() self.mangleSysPath(self.newPath) import goodpackage self.assertIsNot(package1, goodpackage) self.assertEqual(package1.__spec__, goodpackage.__spec__) def test_directoryNotPackage(self): """ L{runner.filenameToModule} raises a C{ValueError} when the name of an empty directory is passed that isn't considered a valid Python package because it doesn't contain a C{__init__.py} file. """ emptyDir = filepath.FilePath(self.parent).child("emptyDirectory") emptyDir.createDirectory() err = self.assertRaises(ValueError, runner.filenameToModule, emptyDir.path) self.assertEqual(str(err), f"{emptyDir.path!r} is not a package directory") def test_filenameNotPython(self): """ L{runner.filenameToModule} raises a C{SyntaxError} when a non-Python file is passed. """ filename = filepath.FilePath(self.parent).child("notpython") filename.setContent(b"This isn't python") self.assertRaises(SyntaxError, runner.filenameToModule, filename.path) def test_filenameMatchesPackage(self): """ The C{__file__} attribute of the module should match the package name. """ filename = filepath.FilePath(self.parent).child("goodpackage.py") filename.setContent(packages.testModule.encode("utf8")) try: module = runner.filenameToModule(filename.path) self.assertEqual(filename.path, module.__file__) finally: filename.remove() def test_directory(self): """ Test loader against a filesystem directory containing an empty C{__init__.py} file. It should handle 'path' and 'path/' the same way. """ goodDir = filepath.FilePath(self.parent).child("goodDirectory") goodDir.createDirectory() goodDir.child("__init__.py").setContent(b"") try: module = runner.filenameToModule(goodDir.path) self.assertTrue(module.__name__.endswith("goodDirectory")) module = runner.filenameToModule(goodDir.path + os.path.sep) self.assertTrue(module.__name__.endswith("goodDirectory")) finally: goodDir.remove() class LoaderTests(packages.SysPathManglingTest): """ Tests for L{trial.TestLoader}. """ def setUp(self): self.loader = runner.TestLoader() packages.SysPathManglingTest.setUp(self) def test_sortCases(self): from twisted.trial.test import sample suite = self.loader.loadClass(sample.AlphabetTest) self.assertEqual( ["test_a", "test_b", "test_c"], [test._testMethodName for test in suite._tests], ) newOrder = ["test_b", "test_c", "test_a"] sortDict = dict(zip(newOrder, range(3))) self.loader.sorter = lambda x: sortDict.get(x.shortDescription(), -1) suite = self.loader.loadClass(sample.AlphabetTest) self.assertEqual(newOrder, [test._testMethodName for test in suite._tests]) def test_loadFailure(self): """ Loading a test that fails and getting the result of it ends up with one test ran and one failure. """ suite = self.loader.loadByName( "twisted.trial.test.erroneous.TestRegularFail.test_fail" ) result = reporter.TestResult() suite.run(result) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 1) def test_loadBadDecorator(self): """ A decorated test method for which the decorator has failed to set the method's __name__ correctly is loaded and its name in the class scope discovered. """ from twisted.trial.test import sample suite = self.loader.loadAnything( sample.DecorationTest.test_badDecorator, parent=sample.DecorationTest, qualName=["sample", "DecorationTest", "test_badDecorator"], ) self.assertEqual(1, suite.countTestCases()) self.assertEqual("test_badDecorator", suite._testMethodName) def test_loadGoodDecorator(self): """ A decorated test method for which the decorator has set the method's __name__ correctly is loaded and the only name by which it goes is used. """ from twisted.trial.test import sample suite = self.loader.loadAnything( sample.DecorationTest.test_goodDecorator, parent=sample.DecorationTest, qualName=["sample", "DecorationTest", "test_goodDecorator"], ) self.assertEqual(1, suite.countTestCases()) self.assertEqual("test_goodDecorator", suite._testMethodName) def test_loadRenamedDecorator(self): """ Load a decorated method which has been copied to a new name inside the class. Thus its __name__ and its key in the class's __dict__ no longer match. """ from twisted.trial.test import sample suite = self.loader.loadAnything( sample.DecorationTest.test_renamedDecorator, parent=sample.DecorationTest, qualName=["sample", "DecorationTest", "test_renamedDecorator"], ) self.assertEqual(1, suite.countTestCases()) self.assertEqual("test_renamedDecorator", suite._testMethodName) def test_loadClass(self): from twisted.trial.test import sample suite = self.loader.loadClass(sample.FooTest) self.assertEqual(2, suite.countTestCases()) self.assertEqual( ["test_bar", "test_foo"], [test._testMethodName for test in suite._tests] ) def test_loadNonClass(self): from twisted.trial.test import sample self.assertRaises(TypeError, self.loader.loadClass, sample) self.assertRaises(TypeError, self.loader.loadClass, sample.FooTest.test_foo) self.assertRaises(TypeError, self.loader.loadClass, "string") self.assertRaises(TypeError, self.loader.loadClass, ("foo", "bar")) def test_loadNonTestCase(self): from twisted.trial.test import sample self.assertRaises(ValueError, self.loader.loadClass, sample.NotATest) def test_loadModule(self): from twisted.trial.test import sample suite = self.loader.loadModule(sample) self.assertEqual(10, suite.countTestCases()) def test_loadNonModule(self): from twisted.trial.test import sample self.assertRaises(TypeError, self.loader.loadModule, sample.FooTest) self.assertRaises(TypeError, self.loader.loadModule, sample.FooTest.test_foo) self.assertRaises(TypeError, self.loader.loadModule, "string") self.assertRaises(TypeError, self.loader.loadModule, ("foo", "bar")) def test_loadPackage(self): import goodpackage suite = self.loader.loadPackage(goodpackage) self.assertEqual(7, suite.countTestCases()) def test_loadNonPackage(self): from twisted.trial.test import sample self.assertRaises(TypeError, self.loader.loadPackage, sample.FooTest) self.assertRaises(TypeError, self.loader.loadPackage, sample.FooTest.test_foo) self.assertRaises(TypeError, self.loader.loadPackage, "string") self.assertRaises(TypeError, self.loader.loadPackage, ("foo", "bar")) def test_loadModuleAsPackage(self): from twisted.trial.test import sample ## XXX -- should this instead raise a ValueError? -- jml self.assertRaises(TypeError, self.loader.loadPackage, sample) def test_loadPackageRecursive(self): import goodpackage suite = self.loader.loadPackage(goodpackage, recurse=True) self.assertEqual(14, suite.countTestCases()) def test_loadAnythingOnModule(self): from twisted.trial.test import sample suite = self.loader.loadAnything(sample) self.assertEqual( sample.__name__, suite._tests[0]._tests[0].__class__.__module__ ) def test_loadAnythingOnClass(self): from twisted.trial.test import sample suite = self.loader.loadAnything(sample.FooTest) self.assertEqual(2, suite.countTestCases()) def test_loadAnythingOnPackage(self): import goodpackage suite = self.loader.loadAnything(goodpackage) self.assertTrue(isinstance(suite, self.loader.suiteFactory)) self.assertEqual(7, suite.countTestCases()) def test_loadAnythingOnPackageRecursive(self): import goodpackage suite = self.loader.loadAnything(goodpackage, recurse=True) self.assertTrue(isinstance(suite, self.loader.suiteFactory)) self.assertEqual(14, suite.countTestCases()) def test_loadAnythingOnString(self): # the important thing about this test is not the string-iness # but the non-handledness. self.assertRaises(TypeError, self.loader.loadAnything, "goodpackage") def test_importErrors(self): import package # type: ignore[import] suite = self.loader.loadPackage(package, recurse=True) result = reporter.Reporter() suite.run(result) self.assertEqual(False, result.wasSuccessful()) self.assertEqual(2, len(result.errors)) errors = [test.id() for test, error in result.errors] errors.sort() self.assertEqual( errors, ["package.test_bad_module", "package.test_import_module"] ) def test_differentInstances(self): """ L{TestLoader.loadClass} returns a suite with each test method represented by a different instances of the L{TestCase} they are defined on. """ class DistinctInstances(pyunit.TestCase): def test_1(self): self.first = "test1Run" def test_2(self): self.assertFalse(hasattr(self, "first")) suite = self.loader.loadClass(DistinctInstances) result = reporter.Reporter() suite.run(result) self.assertTrue(result.wasSuccessful()) def test_loadModuleWith_test_suite(self): """ Check that C{test_suite} is used when present and other L{TestCase}s are not included. """ from twisted.trial.test import mockcustomsuite suite = self.loader.loadModule(mockcustomsuite) self.assertEqual(0, suite.countTestCases()) self.assertEqual("MyCustomSuite", getattr(suite, "name", None)) def test_loadModuleWith_testSuite(self): """ Check that C{testSuite} is used when present and other L{TestCase}s are not included. """ from twisted.trial.test import mockcustomsuite2 suite = self.loader.loadModule(mockcustomsuite2) self.assertEqual(0, suite.countTestCases()) self.assertEqual("MyCustomSuite", getattr(suite, "name", None)) def test_loadModuleWithBothCustom(self): """ Check that if C{testSuite} and C{test_suite} are both present in a module then C{testSuite} gets priority. """ from twisted.trial.test import mockcustomsuite3 suite = self.loader.loadModule(mockcustomsuite3) self.assertEqual("testSuite", getattr(suite, "name", None)) def test_customLoadRaisesAttributeError(self): """ Make sure that any C{AttributeError}s raised by C{testSuite} are not swallowed by L{TestLoader}. """ def testSuite(): raise AttributeError("should be reraised") from twisted.trial.test import mockcustomsuite2 mockcustomsuite2.testSuite, original = (testSuite, mockcustomsuite2.testSuite) try: self.assertRaises(AttributeError, self.loader.loadModule, mockcustomsuite2) finally: mockcustomsuite2.testSuite = original # XXX - duplicated and modified from test_script def assertSuitesEqual(self, test1, test2): names1 = testNames(test1) names2 = testNames(test2) names1.sort() names2.sort() self.assertEqual(names1, names2) def test_loadByNamesDuplicate(self): """ Check that loadByNames ignores duplicate names """ module = "twisted.trial.test.test_log" suite1 = self.loader.loadByNames([module, module], True) suite2 = self.loader.loadByName(module, True) self.assertSuitesEqual(suite1, suite2) def test_loadByNamesPreservesOrder(self): """ L{TestLoader.loadByNames} preserves the order of tests provided to it. """ modules = [ "inheritancepackage.test_x.A.test_foo", "twisted.trial.test.sample", "goodpackage", "twisted.trial.test.test_log", "twisted.trial.test.sample.FooTest", "package.test_module", ] suite1 = self.loader.loadByNames(modules) suite2 = runner.TestSuite(map(self.loader.loadByName, modules)) self.assertEqual(testNames(suite1), testNames(suite2)) def test_loadDifferentNames(self): """ Check that loadByNames loads all the names that it is given """ modules = ["goodpackage", "package.test_module"] suite1 = self.loader.loadByNames(modules) suite2 = runner.TestSuite(map(self.loader.loadByName, modules)) self.assertSuitesEqual(suite1, suite2) def test_loadInheritedMethods(self): """ Check that test methods names which are inherited from are all loaded rather than just one. """ methods = [ "inheritancepackage.test_x.A.test_foo", "inheritancepackage.test_x.B.test_foo", ] suite1 = self.loader.loadByNames(methods) suite2 = runner.TestSuite(map(self.loader.loadByName, methods)) self.assertSuitesEqual(suite1, suite2) class ZipLoadingTests(LoaderTests): def setUp(self): from twisted.python.test.test_zippath import zipit LoaderTests.setUp(self) zipit(self.parent, self.parent + ".zip") self.parent += ".zip" self.mangleSysPath(self.oldPath + [self.parent]) class PackageOrderingTests(packages.SysPathManglingTest): def setUp(self): self.loader = runner.TestLoader() self.topDir = self.mktemp() parent = os.path.join(self.topDir, "uberpackage") os.makedirs(parent) open(os.path.join(parent, "__init__.py"), "wb").close() packages.SysPathManglingTest.setUp(self, parent) self.mangleSysPath(self.oldPath + [self.topDir]) def _trialSortAlgorithm(self, sorter): """ Right now, halfway by accident, trial sorts like this: 1. all modules are grouped together in one list and sorted. 2. within each module, the classes are grouped together in one list and sorted. 3. finally within each class, each test method is grouped together in a list and sorted. This attempts to return a sorted list of testable thingies following those rules, so that we can compare the behavior of loadPackage. The things that show as 'cases' are errors from modules which failed to import, and test methods. Let's gather all those together. """ pkg = getModule("uberpackage") testModules = [] for testModule in pkg.walkModules(): if testModule.name.split(".")[-1].startswith("test_"): testModules.append(testModule) sortedModules = sorted(testModules, key=sorter) # ONE for modinfo in sortedModules: # Now let's find all the classes. module = modinfo.load(None) if module is None: yield modinfo else: testClasses = [] for attrib in modinfo.iterAttributes(): if runner.isTestCase(attrib.load()): testClasses.append(attrib) sortedClasses = sorted(testClasses, key=sorter) # TWO for clsinfo in sortedClasses: testMethods = [] for attr in clsinfo.iterAttributes(): if attr.name.split(".")[-1].startswith("test"): testMethods.append(attr) sortedMethods = sorted(testMethods, key=sorter) # THREE yield from sortedMethods def loadSortedPackages(self, sorter=runner.name): """ Verify that packages are loaded in the correct order. """ import uberpackage # type: ignore[import] self.loader.sorter = sorter suite = self.loader.loadPackage(uberpackage, recurse=True) # XXX: Work around strange, unexplained Zope crap. # jml, 2007-11-15. suite = unittest.decorate(suite, ITestCase) resultingTests = list(_iterateTests(suite)) manifest = list(self._trialSortAlgorithm(sorter)) for number, (manifestTest, actualTest) in enumerate( zip(manifest, resultingTests) ): self.assertEqual( manifestTest.name, actualTest.id(), "#%d: %s != %s" % (number, manifestTest.name, actualTest.id()), ) self.assertEqual(len(manifest), len(resultingTests)) def test_sortPackagesDefaultOrder(self): self.loadSortedPackages() def test_sortPackagesSillyOrder(self): def sillySorter(s): # This has to work on fully-qualified class names and class # objects, which is silly, but it's the "spec", such as it is. # if isinstance(s, type): # return s.__module__+'.'+s.__name__ n = runner.name(s) d = md5(n.encode("utf8")).hexdigest() return d self.loadSortedPackages(sillySorter) PK Mb�ZP�QI� � trial/test/mockcustomsuite3.pynu �[��� # Copyright (c) 2006 Twisted Matrix Laboratories. See LICENSE for details """ Mock test module that contains both a C{test_suite} and a C{testSuite} method. L{runner.TestLoader} should load the tests from the C{testSuite}, not from the C{Foo} C{TestCase} nor from the C{test_suite} method. See {twisted.trial.test.test_loader.LoaderTest.test_loadModuleWithBothCustom}. """ from twisted.trial import runner, unittest class Foo(unittest.SynchronousTestCase): def test_foo(self): pass def test_suite(): ts = runner.TestSuite() ts.name = "test_suite" return ts def testSuite(): ts = runner.TestSuite() ts.name = "testSuite" return ts PK Mb�ZV�Ҹ � trial/test/erroneous.pynu �[��� # -*- test-case-name: twisted.trial.test.test_tests -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Definitions of test cases with various interesting error-related behaviors, to be used by test modules to exercise different features of trial's test runner. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. """ from unittest import skipIf from twisted.internet import defer, protocol, reactor from twisted.trial import unittest, util class FoolishError(Exception): pass class FailureInSetUpMixin: def setUp(self): raise FoolishError("I am a broken setUp method") def test_noop(self): pass class SynchronousTestFailureInSetUp(FailureInSetUpMixin, unittest.SynchronousTestCase): pass class AsynchronousTestFailureInSetUp(FailureInSetUpMixin, unittest.TestCase): pass class FailureInTearDownMixin: def tearDown(self): raise FoolishError("I am a broken tearDown method") def test_noop(self): pass class SynchronousTestFailureInTearDown( FailureInTearDownMixin, unittest.SynchronousTestCase ): pass class AsynchronousTestFailureInTearDown(FailureInTearDownMixin, unittest.TestCase): pass class FailureButTearDownRunsMixin: """ A test fails, but its L{tearDown} still runs. """ tornDown = False def tearDown(self): self.tornDown = True def test_fails(self): """ A test that fails. """ raise FoolishError("I am a broken test") class SynchronousTestFailureButTearDownRuns( FailureButTearDownRunsMixin, unittest.SynchronousTestCase ): pass class AsynchronousTestFailureButTearDownRuns( FailureButTearDownRunsMixin, unittest.TestCase ): pass class TestRegularFail(unittest.SynchronousTestCase): def test_fail(self): self.fail("I fail") def test_subfail(self): self.subroutine() def subroutine(self): self.fail("I fail inside") class TestAsynchronousFail(unittest.TestCase): """ Test failures for L{unittest.TestCase} based classes. """ def test_fail(self): """ A test which fails in the callback of the returned L{defer.Deferred}. """ d = defer.Deferred() d.addCallback(self._later) reactor.callLater(0, d.callback, None) return d def _later(self, res): self.fail("I fail later") def test_exception(self): """ A test which raises an exception synchronously. """ raise Exception("I fail") class ErrorTest(unittest.SynchronousTestCase): """ A test case which has a L{test_foo} which will raise an error. @ivar ran: boolean indicating whether L{test_foo} has been run. """ ran = False def test_foo(self): """ Set C{self.ran} to True and raise a C{ZeroDivisionError} """ self.ran = True 1 / 0 @skipIf(True, "skipping this test") class TestSkipTestCase(unittest.SynchronousTestCase): pass class DelayedCall(unittest.TestCase): hiddenExceptionMsg = "something blew up" def go(self): raise RuntimeError(self.hiddenExceptionMsg) def testHiddenException(self): """ What happens if an error is raised in a DelayedCall and an error is also raised in the test? L{test_reporter.ErrorReportingTests.testHiddenException} checks that both errors get reported. Note that this behaviour is deprecated. A B{real} test would return a Deferred that got triggered by the callLater. This would guarantee the delayed call error gets reported. """ reactor.callLater(0, self.go) reactor.iterate(0.01) self.fail("Deliberate failure to mask the hidden exception") testHiddenException.suppress = [ # type: ignore[attr-defined] util.suppress( message=r"reactor\.iterate cannot be used.*", category=DeprecationWarning ) ] class ReactorCleanupTests(unittest.TestCase): def test_leftoverPendingCalls(self): def _(): print("foo!") reactor.callLater(10000.0, _) class SocketOpenTest(unittest.TestCase): def test_socketsLeftOpen(self): f = protocol.Factory() f.protocol = protocol.Protocol reactor.listenTCP(0, f) class TimingOutDeferred(unittest.TestCase): def test_alpha(self): pass def test_deferredThatNeverFires(self): self.methodCalled = True d = defer.Deferred() return d def test_omega(self): pass def unexpectedException(self): """i will raise an unexpected exception... ... *CAUSE THAT'S THE KINDA GUY I AM* >>> 1/0 """ PK Mb�Z����7 7 0 trial/test/__pycache__/erroneous.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZmZmZ ddlmZmZ G dd� de �Z G dd� d�Z G d d � d e ej �Z G d d � d e ej�ZG d d� d�ZG dd� deej �ZG dd� deej�ZG dd� d�ZG dd� deej �ZG dd� deej�ZG dd� dej �ZG dd � d ej�ZG d d � d ej �Zed d �G d!d"� d"ej ��ZG d#d$� d$ej�ZG d%d&� d&ej�ZG d'd(� d(ej�Z G d)d*� d*ej�Z d+d,� Z d-S ).a Definitions of test cases with various interesting error-related behaviors, to be used by test modules to exercise different features of trial's test runner. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. � )�skipIf)�defer�protocol�reactor)�unittest�utilc @ � e Zd ZdS )� FoolishErrorN��__name__� __module__� __qualname__� r r �>/usr/lib/python3/dist-packages/twisted/trial/test/erroneous.pyr � r c @ � e Zd Zdd� Zdd� ZdS )�FailureInSetUpMixinc C � t d��)NzI am a broken setUp method�r ��selfr r r �setUp � zFailureInSetUpMixin.setUpc C � d S �Nr r r r r � test_noop � z FailureInSetUpMixin.test_noopN)r r r r r r r r r r � r c @ r )� SynchronousTestFailureInSetUpNr r r r r r r r c @ r )� AsynchronousTestFailureInSetUpNr r r r r r $ r r c @ r )�FailureInTearDownMixinc C r )Nz I am a broken tearDown methodr r r r r �tearDown) r z FailureInTearDownMixin.tearDownc C r r r r r r r r , r z FailureInTearDownMixin.test_noopN)r r r r! r r r r r r ( r r c @ r )� SynchronousTestFailureInTearDownNr r r r r r" 0 � r" c @ r )�!AsynchronousTestFailureInTearDownNr r r r r r$ 6 r r$ c @ s$ e Zd ZdZdZdd� Zdd� ZdS )�FailureButTearDownRunsMixinz7 A test fails, but its L{tearDown} still runs. Fc C s d| _ d S �NT)�tornDownr r r r r! A � z$FailureButTearDownRunsMixin.tearDownc C r )z$ A test that fails. zI am a broken testr r r r r � test_failsD � z&FailureButTearDownRunsMixin.test_failsN)r r r �__doc__r' r! r) r r r r r% : s r% c @ r )�%SynchronousTestFailureButTearDownRunsNr r r r r r, K r# r, c @ r )�&AsynchronousTestFailureButTearDownRunsNr r r r r r- Q r# r- c @ �$ e Zd Zdd� Zdd� Zdd� ZdS )�TestRegularFailc C � | � d� d S )N�I fail��failr r r r � test_failX � zTestRegularFail.test_failc C s | � � d S r )� subroutiner r r r � test_subfail[ � z TestRegularFail.test_subfailc C r0 )Nz I fail insider2 r r r r r6 ^ r5 zTestRegularFail.subroutineN)r r r r4 r7 r6 r r r r r/ W s r/ c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �TestAsynchronousFailz? Test failures for L{unittest.TestCase} based classes. c C s( t �� }|�| j� t�d|jd� |S )zW A test which fails in the callback of the returned L{defer.Deferred}. r N)r �Deferred� addCallback�_laterr � callLater�callback�r �dr r r r4 g s z TestAsynchronousFail.test_failc C r0 )Nz I fail laterr2 )r �resr r r r< p r5 zTestAsynchronousFail._laterc C r )zA A test which raises an exception synchronously. r1 )� Exceptionr r r r �test_exceptions r* z#TestAsynchronousFail.test_exceptionN)r r r r+ r4 r< rC r r r r r9 b s r9 c @ s e Zd ZdZdZdd� ZdS )� ErrorTestz� A test case which has a L{test_foo} which will raise an error. @ivar ran: boolean indicating whether L{test_foo} has been run. Fc C s d| _ dd dS )zJ Set C{self.ran} to True and raise a C{ZeroDivisionError} T� r N)�ranr r r r �test_foo� s zErrorTest.test_fooN)r r r r+ rF rG r r r r rD z s rD Tzskipping this testc @ r )�TestSkipTestCaseNr r r r r rH � s rH c @ s2 e Zd ZdZdd� Zdd� Zejded�ge_dS ) � DelayedCallzsomething blew upc C s t | j��r )� RuntimeError�hiddenExceptionMsgr r r r �go� r( zDelayedCall.goc C s& t �d| j� t �d� | �d� dS )a� What happens if an error is raised in a DelayedCall and an error is also raised in the test? L{test_reporter.ErrorReportingTests.testHiddenException} checks that both errors get reported. Note that this behaviour is deprecated. A B{real} test would return a Deferred that got triggered by the callLater. This would guarantee the delayed call error gets reported. r g{�G�z�?z/Deliberate failure to mask the hidden exceptionN)r r= rL �iterater3 r r r r �testHiddenException� s z DelayedCall.testHiddenExceptionz!reactor\.iterate cannot be used.*)�message�categoryN) r r r rK rL rN r �suppress�DeprecationWarningr r r r rI � s � �rI c @ � e Zd Zdd� ZdS )�ReactorCleanupTestsc C s dd� }t �d|� d S )Nc S s t d� d S )Nzfoo!)�printr r r r �_� r8 z8ReactorCleanupTests.test_leftoverPendingCalls.<locals>._g ��@)r r= )r rV r r r �test_leftoverPendingCalls� s z-ReactorCleanupTests.test_leftoverPendingCallsN)r r r rW r r r r rT � � rT c @ rS )�SocketOpenTestc C s t �� }t j|_ t�d|� d S )Nr )r �Factory�Protocolr � listenTCP)r �fr r r �test_socketsLeftOpen� s z#SocketOpenTest.test_socketsLeftOpenN)r r r r^ r r r r rY � rX rY c @ r. )�TimingOutDeferredc C r r r r r r r � test_alpha� r z TimingOutDeferred.test_alphac C s d| _ t�� }|S r& )� methodCalledr r: r? r r r �test_deferredThatNeverFires� s z-TimingOutDeferred.test_deferredThatNeverFiresc C r r r r r r r � test_omega� r z TimingOutDeferred.test_omegaN)r r r r` rb rc r r r r r_ � s r_ c C s dS )zci will raise an unexpected exception... ... *CAUSE THAT'S THE KINDA GUY I AM* >>> 1/0 Nr r r r r �unexpectedException� s rd N) r+ r r �twisted.internetr r r � twisted.trialr rB r r �SynchronousTestCaser �TestCaser r r" r$ r% r, r- r/ r9 rD rH rI rT rY r_ rd r r r r �<module> s< � � � PK Mb�Z"�!O� � 7 trial/test/__pycache__/test_suppression.cpython-310.pycnu �[��� o �b � @ sV d Z ddlZddlmZ ddlmZ ddlmZ G dd� d�ZG dd � d eej �Z dS ) z2 Tests for warning suppression features of Trial. � N)�namedAny)�unittest)� suppressionc @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�SuppressionMixinzj Tests for the warning suppression features of L{twisted.trial.unittest.SynchronousTestCase}. c C s |� t�� � d S )N)�run�pyunit� TestResult)�self�suite� r �E/usr/lib/python3/dist-packages/twisted/trial/test/test_suppression.py�runTests s zSuppressionMixin.runTestsc C s t �||�g�S )z� Return a new L{unittest.TestSuite} with a single test method in it. @param cls: A L{TestCase} subclass defining a test method. @param methodName: The name of the test method from C{cls}. )r � TestSuite)r �cls� methodNamer r r �_load s zSuppressionMixin._loadc C s | � dd� |D �|� dS )a& Assert that a certain number of warnings with certain messages were emitted in a certain order. @param warnings: A list of emitted warnings, as returned by C{flushWarnings}. @param which: A list of strings giving warning messages that should appear in C{warnings}. @raise self.failureException: If the warning messages given by C{which} do not match the messages in the warning information in C{warnings}, or if they do not appear in the same order. c S s g | ]}|d �qS )�messager )�.0�warningr r r � <listcomp>2 s z4SuppressionMixin._assertWarnings.<locals>.<listcomp>N)� assertEqual)r �warnings�whichr r r �_assertWarnings# s z SuppressionMixin._assertWarningsc C �D | � | �| jd�� | �| jjg�}| �|tjtjtjtjg� dS )z� Suppressions defined by the test method being run are applied to any warnings emitted while running the C{setUp} fixture. �testSuppressMethodN) r r �TestSetUpSuppression� flushWarnings�_emitr r �CLASS_WARNING_MSG�MODULE_WARNING_MSG�r � warningsShownr r r �test_setUpSuppression4 � ��z&SuppressionMixin.test_setUpSuppressionc C r )z� Suppressions defined by the test method being run are applied to any warnings emitted while running the C{tearDown} fixture. r N) r r �TestTearDownSuppressionr r r r r r r! r r r �test_tearDownSuppressionE r$ z)SuppressionMixin.test_tearDownSuppressionc C s< | � | �| jd�� | �| jjg�}| �|tjtjg� dS )z� A suppression set on a test method prevents warnings emitted by that test method which the suppression matches from being emitted. r N) r r �TestSuppressionr r r r r r r! r r r �test_suppressMethodV s �z$SuppressionMixin.test_suppressMethodc C sd | � | �| jd�� | �| jjg�}| �|d d tj� | �|d d tj� | �t |�d� dS )z� A suppression set on a L{SynchronousTestCase} subclass prevents warnings emitted by any test methods defined on that class which match the suppression from being emitted. �testSuppressClassr r � � N) r r r' r r r r �METHOD_WARNING_MSGr �lenr! r r r �test_suppressClassb � z#SuppressionMixin.test_suppressClassc C sd | � | �| jd�� | �| jjg�}| �|d d tj� | �|d d tj � | �t |�d� dS )z� A suppression set on a module prevents warnings emitted by any test mewthods defined in that module which match the suppression from being emitted. �testSuppressModuler r r* r+ N) r r �TestSuppression2r r' r r r r, r r- r! r r r �test_suppressModulen r/ z$SuppressionMixin.test_suppressModulec C sz | � | �| jd�� | �| jjg�}| �|d d tj� | �|d d tj� | �|d d tj � | �t |�d� dS )z� The suppression set on a test method completely overrides a suppression with wider scope; if it does not match a warning emitted by that test method, the warning is emitted, even if a wider suppression matches. �testOverrideSuppressClassr r r* r+ � N) r r r' r r r r r, r r r- r! r r r �test_overrideSuppressClassz s z+SuppressionMixin.test_overrideSuppressClassN) �__name__� __module__� __qualname__�__doc__r r r r# r& r( r. r2 r5 r r r r r s r c @ s0 e Zd ZdZed�Zed�Zed�Zed�ZdS )�SynchronousSuppressionTestsz0 @see: L{twisted.trial.test.test_tests} z>twisted.trial.test.suppression.SynchronousTestSetUpSuppressionzAtwisted.trial.test.suppression.SynchronousTestTearDownSuppressionz9twisted.trial.test.suppression.SynchronousTestSuppressionz:twisted.trial.test.suppression.SynchronousTestSuppression2N) r6 r7 r8 r9 r r r% r' r1 r r r r r: � s ����r: ) r9 r r �twisted.python.reflectr � twisted.trial�twisted.trial.testr r �SynchronousTestCaser: r r r r �<module> s xPK Mb�Z �ſ7 7 7 trial/test/__pycache__/mockcustomsuite3.cpython-310.pycnu �[��� o �b� � @ s: d Z ddlmZmZ G dd� dej�Zdd� Zdd� Zd S ) a% Mock test module that contains both a C{test_suite} and a C{testSuite} method. L{runner.TestLoader} should load the tests from the C{testSuite}, not from the C{Foo} C{TestCase} nor from the C{test_suite} method. See {twisted.trial.test.test_loader.LoaderTest.test_loadModuleWithBothCustom}. � )�runner�unittestc @ s e Zd Zdd� ZdS )�Fooc C s d S )N� )�selfr r �E/usr/lib/python3/dist-packages/twisted/trial/test/mockcustomsuite3.py�test_foo s z Foo.test_fooN)�__name__� __module__� __qualname__r r r r r r s r c C � t �� } d| _| S )N� test_suite�r � TestSuite�name��tsr r r r � r c C r )N� testSuiter r r r r r r r N)�__doc__� twisted.trialr r �SynchronousTestCaser r r r r r r �<module> s PK Mb�Zy{�� � 3 trial/test/__pycache__/test_doctest.cpython-310.pycnu �[��� o �b� � @ s> d Z ddlmZmZmZmZ ddlmZ G dd� dej�Z dS )z! Test Twisted's doctest support. � )�itrial�reporter�runner�unittest)� mockdoctestc @ s: e Zd ZdZdd� Zdd� Zdd� Zdd d �Zd d � Zd S )� RunnersTestsz. Tests for Twisted's doctest support. c C s< t �� }|�t�}d}|jD ] }| �|t�|��� � qdS )zq Check that the id() of the doctests' case object contains the FQPN of the actual tests. z&twisted.trial.test.mockdoctest.CounterN) r � TestLoader� loadDoctestsr �_tests�assertInr � ITestCase�id)�self�loader�suite�idPrefix�test� r �A/usr/lib/python3/dist-packages/twisted/trial/test/test_doctest.py�test_id s �zRunnersTests.test_idc C s& t �� }|�t�}| �d|�� � dS )zP L{loadDoctests} loads all of the doctests in the given module. � N)r r r r � assertEqual�countTestCases)r r r r r r �test_basicTrialIntegration s z'RunnersTests.test_basicTrialIntegrationc C s6 t �� }|�|� | �d|j� | �dt|j�� dS )z4 Run C{suite} and check the result. � � N)r � TestResult�runr � successes�len�failures)r r �resultr r r �_testRun% s zRunnersTests._testRun� c C s t �� �t�}| �|� dS )zL Trial can correctly run doctests with its xUnit test APIs. N�r r r r r" )r �countr r r r �test_expectedResults. s z!RunnersTests.test_expectedResultsc C s& t �� �t�}| �|� | �|� dS )z9 Doctests should be runnable repeatably. Nr$ )r r r r r �test_repeatable5 s z RunnersTests.test_repeatableN)r# ) �__name__� __module__� __qualname__�__doc__r r r" r& r' r r r r r s r N) r+ � twisted.trialr r r r �twisted.trial.testr �SynchronousTestCaser r r r r �<module> s PK Mb�ZwLk{+ + - trial/test/__pycache__/novars.cpython-310.pycnu �[��� o �b� � @ s G d d� d�Z dS )c @ s e Zd ZdS )�BarN)�__name__� __module__� __qualname__� r r �;/usr/lib/python3/dist-packages/twisted/trial/test/novars.pyr s r N)r r r r r �<module> s PK Mb�Z����� � - trial/test/__pycache__/sample.cpython-310.pycnu �[��� o �b$ � @ s� d Z ddlZddlmZ ddlmZ G dd� dej�Zdd� Zd d � Z G d d � d ej�Z G d d� dej �Z G dd� d�Z G dd� dej�ZdS )z�This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. � N��mergeFunctionMetadata)�unittestc @ � e Zd Zdd� Zdd� ZdS )�FooTestc C � d S �N� ��selfr r �;/usr/lib/python3/dist-packages/twisted/trial/test/sample.py�test_foo � zFooTest.test_fooc C r r r r r r r �test_bar r zFooTest.test_barN��__name__� __module__� __qualname__r r r r r r r � r c s � fdd�}|S )z� Decorate a function without preserving the name of the original function. Always return a function with the same name. c � � | i |��S r r ��args�kwargs��fnr r � nameCollision � z#badDecorator.<locals>.nameCollisionr �r r r r r � badDecorator s r c s � fdd�}t � |�S )z= Decorate a function and preserve the original name. c r r r r r r r r & r z$goodDecorator.<locals>.nameCollisionr r r r r � goodDecorator! s r c @ sD e Zd Zdd� Zee�Zdd� Zee�Zdd� Zee�Zdd� Z d S ) �DecorationTestc C � dS )z� This test method is decorated in a way that gives it a confusing name that collides with another method. Nr r r r r �test_badDecorator- � z DecorationTest.test_badDecoratorc C r! )zQ This test method is decorated in a way that preserves its name. Nr r r r r �test_goodDecorator5 r# z!DecorationTest.test_goodDecoratorc C r! )z~ This is secretly a test method and will be decorated and then renamed so test discovery can find it. Nr r r r r �renamedDecorator< r# z DecorationTest.renamedDecoratorc C r! )zJ This isn't a test, it's just here to collide with tests. Nr r r r r r D r# z DecorationTest.nameCollisionN) r r r r" r r$ r r% �test_renamedDecoratorr r r r r r , s r c @ r )� PyunitTestc C r r r r r r r r K r zPyunitTest.test_fooc C r r r r r r r r N r zPyunitTest.test_barNr r r r r r' J r r' c @ s e Zd Zdd� ZdS )�NotATestc C r r r r r r r r S r zNotATest.test_fooN)r r r r r r r r r( R s r( c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )� AlphabetTestc C r r r r r r r �test_aX r zAlphabetTest.test_ac C r r r r r r r �test_b[ r zAlphabetTest.test_bc C r r r r r r r �test_c^ r zAlphabetTest.test_cN)r r r r* r+ r, r r r r r) W s r) )�__doc__r �pyunit�twisted.python.utilr � twisted.trial�SynchronousTestCaser r r r �TestCaser' r( r) r r r r �<module> s PK Mb�Z�_:]! ]! 4 trial/test/__pycache__/test_deferred.cpython-310.pycnu �[��� o �bv" � @ s� d Z ddlZddlmZ ddlmZmZmZ ddlm Z G dd� dej �Z G dd � d ej �Z G d d � d ej �Z G d d � d e �ZG dd� de �Z[ dS )z0 Tests for returning Deferreds from a TestCase. � N)�defer)�reporter�unittest�util)�detestsc @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd S )� SetUpTestsc C �" t �� }t�� }|�|�}||fS �N��pyunit� TestLoaderr � TestResult�loadTestsFromTestCase��self�klass�loader�r�s� r �B/usr/lib/python3/dist-packages/twisted/trial/test/test_deferred.py� _loadSuite � zSetUpTests._loadSuitec C s8 | � tj�\}}||� | �|�� � | �|jd� d S )N� )r r �DeferredSetUpOK� assertTrue� wasSuccessful� assertEqual�testsRun�r �result�suiter r r � test_success s zSetUpTests.test_successc C �x | � tjj� | �tj�\}}||� | � |�� � | �|jd� | �t|j �d� | �t|j �d� | � tjj� d S �Nr r ) � assertFalser �DeferredSetUpFail� testCalledr r r r �len�failures�errorsr r r r � test_fail � zSetUpTests.test_failc C r# r$ ) r% r �DeferredSetUpCallbackFailr' r r r r r( r) r* r r r r �test_callbackFail' r, z SetUpTests.test_callbackFailc C r# r$ ) r% r �DeferredSetUpErrorr' r r r r r( r) r* r r r r � test_error1 r, zSetUpTests.test_errorc C s� | � tjj� | �tj�\}}||� | �|�� � | �|jd� | �t |j �d� | �t |j �d� | �t |j �d� | � tjj� d S r$ ) r% r �DeferredSetUpSkipr' r r r r r r( r) r* �skipsr r r r � test_skip; s zSetUpTests.test_skipN) �__name__� __module__� __qualname__r r" r+ r. r0 r3 r r r r r s r c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �NeverFireTestsc C s t j| _dt _d S )Ng�������?)r �DEFAULT_TIMEOUT_DURATION� _oldTimeout�r r r r �setUpH s zNeverFireTests.setUpc C s | j t_d S r )r9 r r8 r: r r r �tearDownL s zNeverFireTests.tearDownc C r r r r r r r r O r zNeverFireTests._loadSuitec C s� | � tjj� | �tj�\}}||� | � |�� � | �|jd� | �t|j �d� | �t|j �d� | � tjj� | � |j d d � t j�� d S r$ )r% r �DeferredSetUpNeverFirer' r r r r r( r) r* r �checkr � TimeoutErrorr r r r � test_setUpU s zNeverFireTests.test_setUpN)r4 r5 r6 r; r< r r@ r r r r r7 G s r7 c @ s e Zd Zdd� Zdd� ZdS )� TestTesterc C s t d��)Nzmust override me)�NotImplementedError�r �namer r r �getTestb s zTestTester.getTestc C s t �� }| �|��|� |S r )r r rE �run)r rD r r r r �runTeste s zTestTester.runTestN)r4 r5 r6 rE rG r r r r rA a s rA c @ sl e Zd Zdd� Zdd� Zdd� Zejdd�ge_d d � Z d d � Z d d� Z dd� Z dd� Z dd� Zdd� ZdS )� DeferredTestsc C � t �|�S r )r rH rC r r r rE l � zDeferredTests.getTestc C �* | � d�}| �|�� � | �|jd� d S �N� test_passr �rG r r r r �r r r r r rM o � zDeferredTests.test_passc C s8 | � d�}| �|�� � | �|jd� | �tjj� d S )N�test_passGeneratedr �rG r r r r r rH �touchedrO r r r rQ t � z DeferredTests.test_passGeneratedz6twisted.internet.defer.deferredGenerator is deprecated)�messagec C s8 | � d�}| �|�� � | �|jd� | �tjj� dS )zQ The body of a L{defer.inlineCallbacks} decorated test gets run. �test_passInlineCallbacksr NrR rO r r r rV ~ s z&DeferredTests.test_passInlineCallbacksc C �< | � d�}| �|�� � | �|jd� | �t|j�d� d S )Nr+ r �rG r% r r r r( r) rO r r r r+ � � zDeferredTests.test_failc C rW )N�test_failureInCallbackr rX rO r r r rZ � rY z$DeferredTests.test_failureInCallbackc C rW )N�test_errorInCallbackr )rG r% r r r r( r* rO r r r r[ � rY z"DeferredTests.test_errorInCallbackc C sJ | � d�}| �|�� � | �|jd� | �t|j�d� | �tj j � d S �Nr3 r ) rG r r r r r( r2 r% r rH rS rO r r r r3 � s zDeferredTests.test_skipc C s` | � d�}| �|�� � | �|jd� | �t|j�d� | �t|j�d� | �t|j�d� d S �N�test_expectedFailurer r ) rG r r r r r( r* r) �expectedFailuresrO r r r � test_todo� s zDeferredTests.test_todoc C s. | � d�}| �|jd� | �|�� |j� d S )N� test_threadr )rG r r r r r* rO r r r ra � s zDeferredTests.test_threadN)r4 r5 r6 rE rM rQ r �suppress�supressrV r+ rZ r[ r3 r` ra r r r r rH k s � rH c @ sd e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dS )� TimeoutTestsc C rI r )r rd rC r r r rE � rJ zTimeoutTests.getTestc C s | � |�tj�tj� d S r )r r> r r? )r �errorr r r � _wasTimeout� s zTimeoutTests._wasTimeoutc C rK rL rN rO r r r rM � rP zTimeoutTests.test_passc C rK )N�test_passDefaultr rN rO r r r rg � rP z TimeoutTests.test_passDefaultc C �P | � d�}| �|�� � | �|jd� | �t|j�d� | �|jd d � d S )N� test_timeoutr r �rG r% r r r r( r* rf rO r r r ri � � zTimeoutTests.test_timeoutc C rh )N�test_timeoutZeror r rj rO r r r rl � rk z TimeoutTests.test_timeoutZeroc C rW r\ )rG r r r r r( r2 rO r r r r3 � rY zTimeoutTests.test_skipc C rh r] )rG r r r r r( r_ rf rO r r r r` � rk zTimeoutTests.test_todoc C s8 | � d�}| �|�� � | �|jd� | �tjj� d S )N�test_errorPropagationr ) rG r% r r r rf r rd �timedOutrO r r r rm � rT z"TimeoutTests.test_errorPropagationc C sP t �� }|�tj�}t�� }|�|� | �t |j �d� | � |j d d � d S r$ ) r r r r �TestClassTimeoutAttributer r rF r r( r* rf )r r r! r r r r �test_classTimeout� s z TimeoutTests.test_classTimeoutc C sZ ddl m} |�d|j�}| �d�}|�� r|�� | �|�� � | � |j d d � d S )Nr )�reactor� �test_calledButNeverCallbackr ) �twisted.internetrq � callLater�crashrG �active�cancelr% r rf r* )r rq �callr r r r �&test_callbackReturnsNonCallingDeferred� s z3TimeoutTests.test_callbackReturnsNonCallingDeferredN)r4 r5 r6 rE rf rM rg ri rl r3 r` rm rp rz r r r r rd � s rd )�__doc__r r rt r � twisted.trialr r �twisted.trial.testr �TestCaser r7 rA rH rd r r r r �<module> s 7 CHPK Mb�Zr;)�� � / trial/test/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z2 Unit tests for the Trial unit-testing framework. N)�__doc__� r r �=/usr/lib/python3/dist-packages/twisted/trial/test/__init__.py�<module> s PK Mb�Z^��� � 4 trial/test/__pycache__/test_keyboard.cpython-310.pycnu �[��� o �b� � @ sj d Z ddlmZ ddlmZmZmZ G dd� dej�ZG dd� de�Z G dd � d e�Z G d d � d e�Z d S ) z. Tests for interrupting tests with Control-C. � )�StringIO)�reporter�runner�unittestc @ s e Zd Zdd� ZdS )� TrialTestc C s t � | _t�� | _t�� | _d S �N)r �outputr � TestResultr � TestLoader�loader��self� r �B/usr/lib/python3/dist-packages/twisted/trial/test/test_keyboard.py�setUp s zTrialTest.setUpN)�__name__� __module__� __qualname__r r r r r r s r c s> e Zd ZG dd� dej�Z� fdd�Zdd� Zdd� Z� Z S ) �InterruptInTestTestsc @ �$ e Zd Zdd� Zdd� Zdd� ZdS )z$InterruptInTestTests.InterruptedTestc C s t �r )�KeyboardInterruptr r r r �test_02_raiseInterrupt � z;InterruptInTestTests.InterruptedTest.test_02_raiseInterruptc C s d S r r r r r r �test_01_doNothing r z6InterruptInTestTests.InterruptedTest.test_01_doNothingc C s dt _d S )NT)r �test_03_doNothing_runr r r r �test_03_doNothing s z6InterruptInTestTests.InterruptedTest.test_03_doNothingN)r r r r r r r r r r �InterruptedTest s r c s$ t � �� | j�tj�| _d t_d S r )�superr r � loadClassr r �suiter r �� __class__r r r s zInterruptInTestTests.setUpc C s4 | � d| j�� � | � d| jj� | �| jj� d S )N� r )� assertEqualr �countTestCasesr �testsRun� assertFalse� shouldStopr r r r � test_setUpOK% s z!InterruptInTestTests.test_setUpOKc C �F t �| jg��| j� | �| jj� | �d| jj� | � t j d� d S )N� ztest_03_doNothing ran.) r � TrialSuiter �runr � assertTruer' r# r% r& r r r r r r �test_interruptInTest* s �z)InterruptInTestTests.test_interruptInTest) r r r r �TestCaser r r( r. � __classcell__r r r r r s r c �B e Zd ZdZG dd� dej�Z� fdd�Zdd� Zdd � Z � Z S ) �InterruptInSetUpTestsr c @ r )z%InterruptInSetUpTests.InterruptedTestc C � t jdkrt�d S �Nr )r2 r% r r r r r r 7 � �z+InterruptInSetUpTests.InterruptedTest.setUpc C � t jd7 _d S �N� )r2 r% r r r r �test_01; � z-InterruptInSetUpTests.InterruptedTest.test_01c C � t jd7 _dt _d S �Nr8 T)r2 r% � test_02_runr r r r �test_02> � z-InterruptInSetUpTests.InterruptedTest.test_02N)r r r r r9 r> r r r r r 6 � r c �* t � �� | j�tj�| _dt_dt_d S )NFr ) r r r r r2 r r r= r% r r r r r B � zInterruptInSetUpTests.setUpc C �B | � dtj� | � d| j�� � | � d| jj� | �| jj� d S �Nr r* )r# r2 r% r r$ r r& r' r r r r r( H � z"InterruptInSetUpTests.test_setUpOKc C r) )Nr* � test_02 ran) r r+ r r, r r- r' r# r% r& r2 r= r r r r �test_interruptInSetUpN s z+InterruptInSetUpTests.test_interruptInSetUp) r r r r% r r/ r r r( rG r0 r r r r r2 3 � r2 c r1 ) �InterruptInTearDownTestsr c @ r )z(InterruptInTearDownTests.InterruptedTestc C r3 r4 )rI r% r r r r r �tearDownY r5 z1InterruptInTearDownTests.InterruptedTest.tearDownc C r6 r7 )rI r% r r r r r9 ] r: z0InterruptInTearDownTests.InterruptedTest.test_01c C r; r< )rI r% r= r r r r r> ` r? z0InterruptInTearDownTests.InterruptedTest.test_02N)r r r rJ r9 r> r r r r r X r@ r c rA )Nr F) r r r r rI r r r% r= r r r r r d rB z InterruptInTearDownTests.setUpc C rC rD )r# rI r% r r$ r r& r' r r r r r( j rE z%InterruptInTearDownTests.test_setUpOKc C sF t �| jg��| j� | �d| jj� | �| jj� | � t j d� d S )Nr8 rF ) r r+ r r, r r# r% r- r' r& rI r= r r r r �test_interruptInTearDownp s z1InterruptInTearDownTests.test_interruptInTearDown) r r r r% r r/ r r r( rK r0 r r r r rI U rH rI N) �__doc__�ior � twisted.trialr r r �SynchronousTestCaser r r2 rI r r r r �<module> s "PK Mb�Z C��� � , trial/test/__pycache__/weird.cpython-310.pycnu �[��� o �b� � @ s* d dl Z d dlmZ G dd� de j�ZdS )� N)�deferc @ s e Zd ZdZdd� ZdS )� TestBleedinga' This test creates an unhandled Deferred and leaves it in a cycle. The Deferred is left in a cycle so that the garbage collector won't pick it up immediately. We were having some problems where unhandled Deferreds in one test were failing random other tests. (See #1507, #1213) c C s< zdd W n t y t�� }Y nw |g}|�|� d S )N� r )�ZeroDivisionErrorr �fail�append)�self�f�l� r �:/usr/lib/python3/dist-packages/twisted/trial/test/weird.py�test_unhandledDeferred s �z#TestBleeding.test_unhandledDeferredN)�__name__� __module__� __qualname__�__doc__r r r r r r s r )�unittest�twisted.internetr �TestCaser r r r r �<module> s PK Mb�Z�[� (� (� 4 trial/test/__pycache__/test_reporter.cpython-310.pycnu �[��� o �b�� � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZm Z ddl m Z ddl m ZmZ ddlmZmZ ddlmZ dd lmZ dd lmZmZmZm Z mZ dd l m Z m Z dd l m Z m!Z! dd l"m#Z#m$Z$m%Z% G dd� d�Z&G dd� de j'�Z(G dd� de j'�Z)G dd� de)�Z*G dd� de(�Z+G dd� de+�Z,G dd� de j'�Z-G d d � d e(�Z.G d d � d e j'�Z/G d d!� d!e j'�Z0G d"d#� d#e j'�Z1G d$d%� d%e j'�Z2G d&d'� d'e2�Z3G d(d)� d)e j'�Z4G d*d+� d+e4�Z5G d,d-� d-�Z6G d.d/� d/e j'�Z7G d0d1� d1e j'�Z8G d2d3� d3e8�Z9G d4d5� d5e j'�Z:G d6d7� d7e8�Z;G d8d9� d9e j'�Z<G d:d;� d;e9�Z=G d<d=� d=ej>�Z?G d>d?� d?e j'�Z@G d@dA� dA�ZAG dBdC� dCe j'�ZBG dDdE� dEe j'�ZCdS )Fz& Tests for L{twisted.trial.reporter}. � N)�getmro)�BytesIO�StringIO)�Type)�TestCase�expectedFailure)�log�reflect)�Failure)�qual)�itrial�reporter�runner�unittest�util)� UncleanWarningsReporterWrapper� _ExitWrapper)� erroneous�sample)�SkipTest�Todo�makeTodoc @ s0 e Zd ZdZdZdZdd� Zdd� Zdd� Zd S ) � BrokenStreamz� Stream-ish object that raises a signal interrupt error. We use this to make sure that Trial still manages to write what it needs to write. Fc C � || _ d S �N)�fObj)�selfr � r �B/usr/lib/python3/dist-packages/twisted/trial/test/test_reporter.py�__init__% � zBrokenStream.__init__c C s$ | j r | j�|�S d| _ ttjd��)NTzInterrupted write)�writtenr �write�OSError�errno�EINTR)r �sr r r r" ( s zBrokenStream.writec C s" | j r| j�� S d| _ ttjd��)NTzInterrupted flush)�flushedr �flushr# r$ r% �r r r r r( . s zBrokenStream.flushN) �__name__� __module__� __qualname__�__doc__r! r' r r" r( r r r r r s r c @ � e Zd Zdd� ZdS )� StringTestc C s� t td |��}| �t|�t|�kdt|�t|�f � tt�d��}tt||��D ]8\}\}}|d u r4q)t |t �rF| � ||d|||f � q)t ||�r[| �|� |�d||j |f � q)td|����d S )Nz2Must have more observed than expectedlines %d < %d� zLine %d: %r not in %rz#Line %d: %r did not match string %rz"don't know what to do with object )�list�filter� assertTrue�len�type�re�compile� enumerate�zip� isinstance�str�assertSubstring�match�pattern� TypeError)r �expect�output�REGEX_PATTERN_TYPE� line_number�exp�outr r r �stringComparison6 s0 �� � ���zStringTest.stringComparisonN)r* r+ r, rF r r r r r/ 5 � r/ c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�TestResultTestsc C s t �� | _d S r )r � TestResult�resultr) r r r �setUpP � zTestResultTests.setUpc C st zt d�� t y! } z|}| j�| t�� � W Y d }~nd }~ww | jjd d }| �||j� | �t |j� d S �N�foor � ) � RuntimeErrorrJ �addError�sys�exc_info�errors� assertEqual�valuer5 �r �e�excValue�failurer r r �test_pyunitAddErrorS s ��z#TestResultTests.test_pyunitAddErrorc C sz z| � d�� | j y# } z|}| j�| t�� � W Y d }~nd }~ww | jjd d }| �||j� | �| j |j� d S rM ) �failureExceptionrJ � addFailurerR rS �failuresrU rV r5 rW r r r �test_pyunitAddFailure^ s ��z%TestResultTests.test_pyunitAddFailureN)r* r+ r, rK r[ r_ r r r r rH O s rH c @ r. )�ReporterRealtimeTestsc C s t � }tj|dd�| _d S )NT)�realtime)r r �ReporterrJ �r rA r r r rK k s zReporterRealtimeTests.setUpN)r* r+ r, rK r r r r r` j rG r` c @ sN e Zd Ze�d�Zdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dS )�ErrorReportingTestsz^=+$c C s$ t �� | _t� | _t�| j�| _d S r )r � TestLoader�loaderr rA r rb rJ r) r r r rK s s zErrorReportingTests.setUpc C s | � |�}|�� | j�� S r )� getResult�donerA �getvalue)r �suiterJ r r r � getOutputx s z ErrorReportingTests.getOutputc C s |� | j� | jS r )�runrJ )r rj r r r rg } s z ErrorReportingTests.getResultc C s` t j}| j�|�}| �|��� }| jddt�d�t�d�d|j � d|j � d�g}| � ||� dS ) z� A test method which runs and has an error recorded against it is reported in the output stream with the I{ERROR} tag along with a summary of what error was reported and the ID of the test. �[ERROR]�"Traceback (most recent call last):z.^\s+File .*erroneous\.py., line \d+, in setUp$z5^\s+raise FoolishError..I am a broken setUp method..$zEtwisted.trial.test.erroneous.FoolishError: I am a broken setUp method�.z .test_noopN) r � SynchronousTestFailureInSetUprf � loadClassrk � splitlines�doubleSeparatorr6 r7 r+ r* rF )r �clsrj rA r= r r r �test_formatErroredMethod� s � z,ErrorReportingTests.test_formatErroredMethodc C sJ | j �d�}| �|��� }| jddt�d�t�d�ddg}| �||� dS )z� A test method which runs and has a failure recorded against it is reported in the output stream with the I{FAIL} tag along with a summary of what failure was reported and the ID of the test. z6twisted.trial.test.erroneous.TestRegularFail.test_fail�[FAIL]rn z2^\s+File .*erroneous\.py., line \d+, in test_fail$z^\s+self\.fail\("I fail"\)$z'twisted.trial.unittest.FailTest: I failN)rf � loadByNamerk rr rs r6 r7 rF )r rj rA r= r r r �test_formatFailedMethod� s �� z+ErrorReportingTests.test_formatFailedMethodc C s� ddl m} t�| j�|�tj�}| �|�}d}ddd|fD ]}| � ||� q | � t � d|�d� | j t �d �g}| �||�� � d S ) z� A problem encountered while running a doctest is reported in the output stream with a I{FAIL} or I{ERROR} tag along with a summary of what problem was encountered and the ID of the test. r )r z0twisted.trial.test.erroneous.unexpectedExceptionz1/0�ZeroDivisionErrorzException raised:zFail(ed|ure in) example:z;Couldn't match 'Failure in example: ' or 'Failed example: 'z\[(ERROR|FAIL)\]N)�twisted.trial.testr r �decoraterf � loadDoctestsr � ITestCaserk r< r3 r6 �searchrs r7 rF rr )r r rj rA �path� substringr@ r r r �test_doctestError� s �z%ErrorReportingTests.test_doctestErrorc C s� ddl m} t�|��d�r| �d��t�d�}| �|�� � }tt �}| j ddt � d�t � d �d d | j d dt � d �t � d�t � d�t � d�|d d g}| �||� dS )a- Check that errors in C{DelayedCall}s get reported, even if the test already has a failure. Only really necessary for testing the deprecated style of tests that use iterate() directly. See L{erroneous.DelayedCall.testHiddenException} for more details. r )�reactorz twisted.internet.asyncioreactorzhThis test does not work on the asyncio reactor, as the traceback comes from inside asyncio, not Twisted.�testHiddenExceptionrv rn z<^\s+File .*erroneous\.py., line \d+, in testHiddenException$zD^\s+self\.fail\("Deliberate failure to mask the hidden exception"\)$zPtwisted.trial.unittest.FailTest: Deliberate failure to mask the hidden exceptionz<twisted.trial.test.erroneous.DelayedCall.testHiddenExceptionrm z ^\s+File .* in runUntilCurrentz^\s+.*z*^\s+File .*erroneous\.py", line \d+, in goz1^\s+raise RuntimeError\(self.hiddenExceptionMsg\)z: something blew upN)�twisted.internetr� r r � startswith�skipTestr � DelayedCallrk rr rP rs r6 r7 rF )r r� �testrA � errorQualr= r r r �test_hiddenException� s< � ���z(ErrorReportingTests.test_hiddenExceptionN) r* r+ r, r6 r7 rs rK rk rg ru rx r� r� r r r r rd p s rd c @ � e Zd ZdZdd� ZdS )�(UncleanWarningWrapperErrorReportingTestsz� Tests that the L{UncleanWarningsReporterWrapper} can sufficiently proxy IReporter failure and error reporting methods to a L{reporter.Reporter}. c C s( t �� | _t� | _tt�| j��| _d S r ) r re rf r rA r r rb rJ r) r r r rK � s z.UncleanWarningWrapperErrorReportingTests.setUpN)r* r+ r, r- rK r r r r r� � s r� c @ sL e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dS )�TracebackHandlingTestsc C s^ t � }t�|�}|�|� |j|j }| �t|�d� | �|d d |� |�|d d j �S )z� Run the given C{test}, make sure it fails and return the trimmed frames. @param test: The test case to run. @return: The C{list} of frames trimmed. rO r ) r r rb rl r^ rT rU r4 � _trimFrames�frames)r r� �streamrJ �badsr r r �getErrorFrames� s z%TracebackHandlingTests.getErrorFramesc C s� t ||�D ]0\}}| �|d |d � tj�|d �d �tj�}|d �d�}| �|t|� d � |� q| �t|�t|�� d S )Nr rO �/)r9 rU �osr �splitext�split�sepr4 )r �observedFrames�expectedFrames�observed�expected� observedSegs� expectedSegsr r r � checkFrames s z"TracebackHandlingTests.checkFramesc C s& t �d�}| �|�}| �|dg� d S )N� test_fail)r� � twisted/trial/test/erroneous�r �TestRegularFailr� r� �r r� r� r r r � test_basic s z!TracebackHandlingTests.test_basicc C s( t �d�}| �|�}| �|ddg� d S )N� test_subfail)r� r� )� subroutiner� r� r� r r r �test_subroutine s ��z&TracebackHandlingTests.test_subroutinec C �& t �d�}| �|�}| �|dg� dS )z� C{_trimFrames} removes traces of C{_runCallbacks} when getting an error in a callback returned by a C{TestCase} based test. r� )�_laterr� N�r �TestAsynchronousFailr� r� r� r r r � test_deferred& s z$TracebackHandlingTests.test_deferredc C s t �d �}| �g |�g �� d S r �r rb rU r� �r rJ r r r � test_noFrames/ s z$TracebackHandlingTests.test_noFramesc C s$ t �d �}| �dg|�dg�� d S )Nz fake framer� r� r r r � test_oneFrame3 s z$TracebackHandlingTests.test_oneFramec C r� )z� C{_trimFrames} removes traces of C{runWithWarningsSuppressed} from C{utils} when a synchronous exception happens in a C{TestCase} based test. �test_exception)r� r� Nr� r� r r r r� 7 s z%TracebackHandlingTests.test_exceptionN) r* r+ r, r� r� r� r� r� r� r� r� r r r r r� � s r� c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �FormatFailuresTestsc C sf zt d�� t y t� | _Y nw ddddgdggddddgd ggg| j_t� | _t�| j�| _d S ) NrN z foo/bar.py� )�xr� )�y�orange�qux� )�a�two)�b�MCMXCIX) rP r �fr� r r� r rb rJ r) r r r rK C s ��zFormatFailuresTests.setUpc C s: | j �| j�}| �ddt�d�dt�d�dg|�� � d S )Nrn z# File "foo/bar.py", line 5, in fooz^\s*$z$ File "foo/bar.py", line 10, in quxzRuntimeError: foo)rJ �_formatFailureTracebackr� rF r6 r7 rr )r �tbr r r �test_formatDefaultO s ��z&FormatFailuresTests.test_formatDefaultc C s$ d}d}| j �|�}| �||� d S )Nz� File "twisted/trial/unittest.py", line 256, in failUnlessSubstring return self.failUnlessIn(substring, astring, msg) exceptions.TypeError: iterable argument required z� File "twisted/trial/unittest.py", line 256, in failUnlessSubstring return self.failUnlessIn(substring, astring, msg) exceptions.TypeError: iterable argument required )rJ r� rU )r r� r� � formattedr r r �test_formatString] s z%FormatFailuresTests.test_formatStringc C s2 | j jd d � }| j�| j � | �| j j|� d S r )r� r� rJ r� rU )r r� r r r � test_mutationl s z!FormatFailuresTests.test_mutationN)r* r+ r, rK r� r� r� r r r r r� B s r� c @ �D e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dS )�PyunitNamesTestsc C � t � | _t�d�| _d S �N�test_foo)r r� r � PyunitTestr� r) r r r rK t � zPyunitNamesTests.setUpc C s2 t �| j�}|�| j� | j�� }| �|d� d S )Nz2twisted.trial.test.sample.PyunitTest.test_foo ... )r �VerboseTextReporterr� � startTestr� ri rU �r rJ rA r r r �test_verboseReporterx s z%PyunitNamesTests.test_verboseReporterc C �N t �| j�}|�| j� | j�� }|�� d �� }| �||� | j�d � d S �N���z ...� r � TreeReporterr� r� r� ri rr �striprU �getDescriptionr� r r r �test_treeReporter~ � z"PyunitNamesTests.test_treeReporterc C �( t �| j�}|�| j�}| �|d� d S r� �r r� r� r� r� rU r� r r r �test_getDescription� � z$PyunitNamesTests.test_getDescriptionc C sP t �| j�}| j�|� |�� | j�� �� �d�}| � |dd� g d�� dS )a� The summary of L{reporter.MinimalReporter} is a simple list of numbers, indicating how many tests ran, how many failed etc. The numbers represents: * the run time of the tests * the number of tests run, printed 2 times for legacy reasons * the number of errors * the number of failures * the number of skips � rO N)�1r� �0r� r� ) r �MinimalReporterr� r� rl � _printSummaryri r� r� rU r� r r r �test_minimalReporter� s z%PyunitNamesTests.test_minimalReporterc sb g d�� t �| j�}� fdd�|_| j�|� |�� | j�� �� � d�}|d }| � |d� dS )zt L{reporter.MinimalReporter} reports the time to run the tests as first data in its output. )g �?g333333�?g �?gffffff�?c s � � d�S �Nr )�popr ��timesr r �<lambda>� s z;PyunitNamesTests.test_minimalReporterTime.<locals>.<lambda>r� r z0.7N) r r� r� �_getTimer� rl r� ri r� r� rU )r rJ rA �timerr r� r �test_minimalReporterTime� s z)PyunitNamesTests.test_minimalReporterTimec C s< t �| j�}|�� | j�� �� �d�}| �|g d�� dS )zv The summary of L{reporter.MinimalReporter} is a list of zeroes when no test is actually run. r� )r� r� r� r� r� r� N)r r� r� r� ri r� r� rU r� r r r �test_emptyMinimalReporter� s z*PyunitNamesTests.test_emptyMinimalReporterN) r* r+ r, rK r� r� r� r� r� r� r r r r r� s s r� c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �DirtyReactorTestsz� The trial script has an option to treat L{DirtyReactorAggregateError}s as warnings, as a migration tool for test authors. It causes a wrapper to be placed around reporters that replaces L{DirtyReactorAggregatErrors} with warnings. c C s, t t�dgdg��| _t� | _td�| _d S )NrN �bar�test_errorByDefault)r r �DirtyReactorAggregateError� dirtyErrorr rA r� r� r) r r r rK � s zDirtyReactorTests.setUpc C sL t j| jd�}|�| j| j� | �t|j�d� | �|jd d | j� dS )zj L{DirtyReactorAggregateError}s are reported as errors with the default Reporter. �r� rO r N) r rb rA rQ r� r� rU r4 rT r� r r r r� � s z%DirtyReactorTests.test_errorByDefaultc C s8 t tj| jd��}| �t| j�� tj|j | j | j� dS )z� L{DirtyReactorAggregateError}s are reported as warnings when using the L{UncleanWarningsReporterWrapper}. r� N) r r rb rA � assertWarns� UserWarningr� �getErrorMessage�__file__rQ r� r� r r r �test_warningsEnabled� s �z&DirtyReactorTests.test_warningsEnabledc C sH t tj| jd��}| �t| j�� tj|j | j | j� | � |j j g � dS )z� L{DirtyReactorAggregateError}s are I{not} reported as errors if the L{UncleanWarningsReporterWrapper} is used. r� N)r r rb rA r� r� r� r� r� rQ r� rU �_originalReporterrT r� r r r �test_warningsMaskErrors� s �z)DirtyReactorTests.test_warningsMaskErrorsc C s� t tj| jd��}|�| j| jj| jjdf� | � t |j j �d� | � |j j d d j| jj� | � |j j d d j| jj� dS )a� Some annoying stuff can pass three-tuples to addError instead of Failures (like PyUnit). The wrapper, of course, handles this case, since it is a part of L{twisted.trial.itrial.IReporter}! But it does not convert L{DirtyReactorAggregateError} to warnings in this case, because nobody should be passing those in the form of three-tuples. r� NrO r ) r r rb rA rQ r� r� r5 rV rU r4 r� rT r� r r r �test_dealsWithThreeTuples� s ��z+DirtyReactorTests.test_dealsWithThreeTuplesN) r* r+ r, r- rK r� r� r� r� r r r r r� � s r� c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �TrialNamesTestsc C r� r� )r r� r �FooTestr� r) r r r rK � r� zTrialNamesTests.setUpc C s< t �| j�}|�| j� | j�� }| �|| j�� d � d S )Nz ... )r r� r� r� r� ri rU �idr� r r r r� s z$TrialNamesTests.test_verboseReporterc C r� r� r� r� r r r r� r� z!TrialNamesTests.test_treeReporterc C s" t �| j�}| �|�| �d� dS )z A docstring� test_treeReporterWithDocstringsN)r r� r� rU r� r� r r r r� s z/TrialNamesTests.test_treeReporterWithDocstringsc C r� r� r� r� r r r r� r� z#TrialNamesTests.test_getDescriptionN)r* r+ r, rK r� r� r� r� r r r r r� � s r� c @ �P e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )� SkipTestsz= Tests for L{reporter.Reporter}'s handling of skips. c C �& t � | _t�| j�| _t�d�| _d S r� �r r� r rb rJ r r� r� r) r r r rK � zSkipTests.setUpc C s t |j�S )zF Get the number of skips that happened to a reporter. )r4 �skipsr� r r r � _getSkips% s zSkipTests._getSkipsc C s( | j �| jd� | �| �| j �d� d S )N� some reasonrO )rJ �addSkipr� rU r r) r r r �test_accumulation+ s zSkipTests.test_accumulationc C s& | j �| jd� | �d| j �� � d S )Nr T)rJ r r� rU � wasSuccessfulr) r r r � test_success/ s zSkipTests.test_successc C s` | j �| jd� | j �� | j�� �� d }d}| �|�|�� | � |t |�d� � � d� dS )z� The summary of a successful run with skips indicates that the test suite passed and includes the number of skips. r r� �PASSED Nz (skips=1)) rJ r r� rh r� ri rr r3 r� rU r4 r� �r rA �prefixr r r � test_summary3 s zSkipTests.test_summaryc C s@ | j �| jd� | j �� | j�� �� d }| �|�� d� dS )zw The output at the end of a test run with skips includes the reasons for skipping those tests. r � N) rJ r r� rh r� ri rr rU r� rc r r r �test_basicErrors? s zSkipTests.test_basicErrorsc C s< | j �| jd� | j �� | j�� �� d }| �|d� dS )z� Tests can be skipped without specifying a reason by setting the 'skip' attribute to True. When this happens, the test output includes 'True' as the reason. Tr �TrueN)rJ r r� rh r� ri rr rU rc r r r �test_booleanSkipI s zSkipTests.test_booleanSkipc C s� zdd W n t y } z|}W Y d}~nd}~ww | j�| j|� | j�� d�| j�� �� dd� �� � }| � |t |�� dS )z� Skips can be raised as errors. When this happens, the error is included in the summary at the end of the test suite. rO r N� r r� ) � ExceptionrJ r r� rh �joinr� ri rr r� rU r; �r rX �errorrA r r r �test_exceptionSkipT s �� z SkipTests.test_exceptionSkipN) r* r+ r, r- rK r r r r r r r r r r r r� s r� c @ � e Zd ZdZdd� Zdd� ZdS )�UncleanWarningSkipTestszh Tests for skips on a L{reporter.Reporter} wrapped by an L{UncleanWarningsReporterWrapper}. c C � t �| � t| j�| _d S r )r� rK r rJ r) r r r rK i � z UncleanWarningSkipTests.setUpc C s t |jj�S )z} Get the number of skips that happened to a reporter inside of an unclean warnings reporter wrapper. )r4 r� r r� r r r r m s z!UncleanWarningSkipTests._getSkipsN)r* r+ r, r- rK r r r r r r c s r c @ � e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd S ) � TodoTestsz= Tests for L{reporter.Reporter}'s handling of todos. c C r� r� r r) r r r rK z r zTodoTests.setUpc C � |j S )zH Get the expected failures that happened to a reporter. )�expectedFailuresr� r r r � _getTodos � zTodoTests._getTodosc C r )zK Get the unexpected successes that happened to a reporter. )�unexpectedSuccessesr� r r r �_getUnexpectedSuccesses� r z!TodoTests._getUnexpectedSuccessesc C s8 | j �| jtt� �td�� | �t| �| j ��d� dS )zh L{reporter.Reporter} accumulates the expected failures that it is notified of. �todo!rO N) rJ �addExpectedFailurer� r r r rU r4 r r) r r r r � s � zTodoTests.test_accumulationc C sd t t� �}| j�| j|� | �| j�\\}}}| �|| j� | �||� | �t|�ttd��� dS )z� If no C{Todo} is provided to C{addExpectedFailure}, then L{reporter.Reporter} makes up a sensible default. This allows standard Python unittests to use Twisted reporters. �Test expected to failN) r r rJ r$ r� r rU �reprr )r rZ r� r �todor r r �test_noTodoProvided� s z TodoTests.test_noTodoProvidedc C s2 | j �| jtt� �td�� | �d| j �� � dS )zU A test run is still successful even if there are expected failures. r# TN)rJ r$ r� r r r rU r r) r r r r � s �zTodoTests.test_successc C sB | j �| jtd�� | �d| j �� � | �t| �| j ��d� dS )z� A test which is marked as todo but succeeds will have an unexpected success reported to its result. A test run is still successful even when this happens. zHeya!TrO N)rJ �addUnexpectedSuccessr� r rU r r4 r" r) r r r �test_unexpectedSuccess� s z TodoTests.test_unexpectedSuccessc C sJ | j �| j� | �| j �\\}}| �|| j� | �t|�ttd��� dS )aL A test which is marked as todo but succeeds will have an unexpected success reported to its result. A test run is still successful even when this happens. If no C{Todo} is provided, then we make up a sensible default. This allows standard Python unittests to use Twisted reporters. r% N)rJ r) r� r" rU r& r �r r� r' r r r � test_unexpectedSuccessNoTodo� s z&TodoTests.test_unexpectedSuccessNoTodoc C sl | j �| jtt� �td�� | j �� | j�� � � d }d}| � |� |�� | � |t |�d� �� d� dS )z{ The reporter's C{printSummary} method should print the number of expected failures that occurred. r r� r Nz(expectedFailures=1))rJ r$ r� r r r rh r� ri rr r3 r� rU r4 r� r r r r r � s � zTodoTests.test_summaryc C sL | j �| jtt� �td�� | j �� | j�� � � d � � }| � |d� dS )zd The reporter's L{printErrors} method should include the value of the Todo. r r zReason: 'some reason'N) rJ r$ r� r r r rh r� ri rr r� rU rc r r r r � s � zTodoTests.test_basicErrorsc C s, | j �| jtt� �d� | �t| j j� dS )z� Booleans CAN'T be used as the value of a todo. Maybe this sucks. This is a test for current behavior, not a requirement. TN)rJ r$ r� r r � assertRaisesrh r) r r r �test_booleanTodo� s zTodoTests.test_booleanTodoc C s� zdd W n t y } z|}W Y d}~nd}~ww | j�| jt|�td�� | j�� d�| j� � � � dd� �� � }| � t |�|v � dS )zk The exception for expected failures should be shown in the C{printErrors} output. rO r Nr# r r )r rJ r$ r� r r rh r r� ri rr r� r3 r; r r r r �test_exceptionTodo� s �� z TodoTests.test_exceptionTodoc C �@ G dd� dt �}|d�}|�| j� | �t| �| j��d� dS )�t Tests that use the standard library C{expectedFailure} feature worth with Trial reporters. c @ � e Zd Zedd� �ZdS )z@TodoTests.test_standardLibraryCompatibilityFailure.<locals>.Testc S s | � d� d S )NrZ )�failr) r r r r� � s zJTodoTests.test_standardLibraryCompatibilityFailure.<locals>.Test.test_failN)r* r+ r, r r� r r r r �Test� � r4 r� rO N)�StdlibTestCaserl rJ rU r4 r �r r4 r� r r r �(test_standardLibraryCompatibilityFailure� � z2TodoTests.test_standardLibraryCompatibilityFailurec C r0 )r1 c @ r2 )z@TodoTests.test_standardLibraryCompatibilitySuccess.<locals>.Testc S s d S r r r) r r r r s zMTodoTests.test_standardLibraryCompatibilitySuccess.<locals>.Test.test_successN)r* r+ r, r r r r r r r4 r5 r4 r rO N)r6 rl rJ rU r4 r" r7 r r r �(test_standardLibraryCompatibilitySuccess r9 z2TodoTests.test_standardLibraryCompatibilitySuccessN)r* r+ r, r- rK r r" r r( r r* r, r r r. r/ r8 r: r r r r r u s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �UncleanWarningTodoTestszJ Tests for L{UncleanWarningsReporterWrapper}'s handling of todos. c C r r )r rK r rJ r) r r r rK r z UncleanWarningTodoTests.setUpc C � |j jS )zt Get the todos that happened to a reporter inside of an unclean warnings reporter wrapper. )r� r r� r r r r � z!UncleanWarningTodoTests._getTodosc C r< )z� Get the number of unexpected successes that happened to a reporter inside of an unclean warnings reporter wrapper. )r� r! r� r r r r" # r= z/UncleanWarningTodoTests._getUnexpectedSuccessesN)r* r+ r, r- rK r r" r r r r r; s r; c @ r )� MockColorizerzR Used by TreeReporterTests to make sure that output is colored correctly. c C s g | _ d S r )r )r r� r r r r 0 r zMockColorizer.__init__c C s | j �||f� d S r )r �append)r �text�colorr r r r" 3 s zMockColorizer.writeN)r* r+ r, r- r r" r r r r r> + s r> c @ r� )�TreeReporterTestsc C s@ t �d�| _t� | _t�| j�| _t| j�| j_ | jj j | _ d S r� ) r r� r� r r� r r� rJ r> � _colorizerr r) r r r rK 8 s zTreeReporterTests.setUpc C s* zdd W |S t y t� }Y |S w )NrO r )ry r )r r� r r r � makeError? s ��zTreeReporterTests.makeErrorc C sT | j �| j� | j �� | �| jd | j jdf� | �| j�� � � d � � d� dS )zw The summary in case of success should have a good count of successes and be colored properly. rO �PASSEDr� z (successes=1)N) rJ � addSuccessr� rh rU r �SUCCESSr� ri rr r� r) r r r �test_summaryColoredSuccessF s �z,TreeReporterTests.test_summaryColoredSuccessc C st zt d�� t y | j�| t�� � Y nw | j�� | �| jd | jjdf� | �| j � � � � d � � d� dS )zt The summary in case of failure should have a good count of errors and be colored properly. rN rO �FAILEDr� z (errors=1)N) rP rJ rQ rR rS rh rU r �FAILUREr� ri rr r� r) r r r �test_summaryColoredFailureR s � "z,TreeReporterTests.test_summaryColoredFailurec C s^ | � ddg| j�d�� | � ddg| j�d�� | � dg| j�d�� | � g | j�d�� dS )z� The tree needs to get the segments of the test ID that correspond to the module and class that it belongs to. zfoo.bar�bazzfoo.bar.baz.quxrN r� z foo.bar.bazN)rU rJ �_getPreludeSegmentsr) r r r �test_getPrelude_ s �z!TreeReporterTests.test_getPreludec C s� zt d�� t y | j�| t�� � | j�| jt�� � Y nw zt d�� t y< t�d�}| j�|t�� � Y nw | j�� | j� | jj | jj �}| � |d d | | jg� | � |d d |g� dS )z� If two different tests have the same error, L{Reporter._groupResults} includes them together in one of the tuples in the list it returns. rN r� �test_barr rO N) rP rJ rQ rR rS r� r r� rh � _groupResultsrT r� rU )r �extra�groupedr r r �test_groupResultsk s$ � � �z#TreeReporterTests.test_groupResultsc C s| dd� }t �d�}t �d�}t �d�}| j�d|df|df|dfg|� | �| j�� d| jj|� � |� � |� � d � � d S ) z� L{Reporter._printResults} uses the results list and formatter callable passed to it to produce groups of results to write to its output stream. c S s t | �d S )Nr )r; )�nr r r � formatter� s z6TreeReporterTests.test_printResults.<locals>.formatterr� rO �FOOrO � zW%(double separator)s FOO 1 %(first)s %(second)s %(double separator)s FOO 2 %(third)s )zdouble separator�first�second�thirdN) r r� r� rJ � _printResultsrU r� ri �_doubleSeparatorr� )r rU rX rY rZ r r r �test_printResults� s" � ���z#TreeReporterTests.test_printResultsN) r* r+ r, rK rD rH rK rN rS r] r r r r rB 7 s rB c @ s^ e Zd ZU dZejZeej e d< dd� Z dd� Z dd� Z d d � Zd d � Zd d� Zdd� ZdS )�ReporterInterfaceTestsas Tests for the bare interface of a trial reporter. Subclass this test case and provide a different 'resultFactory' to test that a particular reporter implementation will work with the rest of Trial. @cvar resultFactory: A callable that returns a reporter to be tested. The callable must take the same parameters as L{reporter.Reporter}. � resultFactoryc C s6 t �d�| _t� | _t�� | _| j| j| jd�| _ d S )Nr� �� publisher) r r� r� r r� r � LogPublisherra r_ rJ r) r r r rK � s z ReporterInterfaceTests.setUpc C s | � d| jj� dS )z4 shouldStop is False to begin with. FN)rU rJ � shouldStopr) r r r � test_shouldStopInitiallyFalse� s z4ReporterInterfaceTests.test_shouldStopInitiallyFalsec C s | j �� | �d| j j� dS )zG shouldStop becomes True soon as someone calls stop(). TN)rJ �stoprU rc r) r r r � test_shouldStopTrueAfterStop� s z3ReporterInterfaceTests.test_shouldStopTrueAfterStopc C s | � d| j�� � dS )zS wasSuccessful() is True when there have been no results reported. TN)rU rJ r r) r r r � test_wasSuccessfulInitiallyTrue� s z6ReporterInterfaceTests.test_wasSuccessfulInitiallyTruec C s$ | j �| j� | �d| j �� � dS )zg wasSuccessful() is True when there have been only successes, False otherwise. TN)rJ rF r� rU r r) r r r �$test_wasSuccessfulTrueAfterSuccesses� s z;ReporterInterfaceTests.test_wasSuccessfulTrueAfterSuccessesc C sJ zdd W n t y | j�| jt�� � Y nw | �d| j�� � dS )zP wasSuccessful() becomes False after errors have been reported. rO r FN)ry rJ rQ r� rR rS rU r r) r r r �"test_wasSuccessfulFalseAfterErrors� s �z9ReporterInterfaceTests.test_wasSuccessfulFalseAfterErrorsc C sN z| � d� W n | jy | j�| jt�� � Y nw | �d| j�� � dS )zR wasSuccessful() becomes False after failures have been reported. rN FN) r3 r\ rJ r] r� rR rS rU r r) r r r �$test_wasSuccessfulFalseAfterFailures� s �z;ReporterInterfaceTests.test_wasSuccessfulFalseAfterFailuresN)r* r+ r, r- r rb r_ r r � IReporter�__annotations__rK rd rf rg rh ri rj r r r r r^ � s r^ c @ r� )� ReporterTestsz8 Tests for the base L{reporter.Reporter} class. c C s t �| � d| _| j| j_d S r� )r^ rK �_timerr� rJ r) r r r rK � s zReporterTests.setUpc C s | j d7 _ | j S �NrO )rn r) r r r r� � s zReporterTests._getTimec C sT | j �| j� | j �| j� | �| j jdk� | �| j jd� | �| j �� d� d S )Nr rO T) rJ r� r� �stopTestr3 � _lastTimerU �testsRunr r) r r r �test_startStop� s z ReporterTests.test_startStopc C sh | j t| j�d�}|�d� | �| j�� d� | j�d� | j�d� |�dd� | �| j�� d� dS ) zE Test that the reporter safely writes to its stream. r� �HellozHello r z Hello %s!�Worldz Hello World! N)r_ r r� �_writelnrU ri �truncate�seekr� r r r �test_brokenStream s z ReporterTests.test_brokenStreamc C sT t d�}d}d}d}| jj||||d� | �| j�� d|||�d�d |f � d S ) z� L{reporter.Reporter} observes warnings emitted by the Twisted log system and writes them to its output stream. zsome warning text�exceptions.RuntimeWarningzpath/to/some/file.py�G ��warning�category�filename�linenoz%s:%d: %s: %s ro r� N)�RuntimeWarningra �msgrU r� ri r� )r �messager~ r r� r r r � test_warning s ��zReporterTests.test_warningc C s | � � | � � dS )zj A warning emitted twice within a single test is only written to the stream once. N)r� r) r r r � test_duplicateWarningSuppressed s z-ReporterTests.test_duplicateWarningSuppressedc C s� | � d�}| j�|� | j�d� | j�� | �� | j�d� | j�� | j�|� | j�|� | j�d� | j�� | �� dS )zn A warning emitted again after a new test has started is written to the stream again. � test_warningEmittedForNewTestr N)� __class__rJ r� r� rx rw r� rp �r r� r r r r� ( s z+ReporterTests.test_warningEmittedForNewTestc C sN | j �� | j�d� | j�� | jjtd�dddd� | �| j� � d� dS ) zl L{reporter.Reporter} stops observing log events when its C{done} method is called. r z some messagerz z file/name.py� r| r0 N) rJ rh r� rx rw ra r� r� rU ri r) r r r �test_stopObservingH s �z ReporterTests.test_stopObservingN) r* r+ r, r- rK r� rs ry r� r� r� r� r r r r rm � s rm c @ r. )�SafeStreamTestsc C s6 t � }t|�}t�|�}|�d� | �|�� d� dS )z� Test that L{reporter.SafeStream} successfully write to its original stream even if an interrupt happens during the write. rt N)r r r � SafeStreamr" rU ri )r r� �broken�safer r r � test_safeZ s zSafeStreamTests.test_safeN)r* r+ r, r� r r r r r� Y rG r� c @ s� e Zd ZU dZejZeej e d< dd� Z dd� Z dd� Z d d � Zd d � Zd d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!S )"�SubunitReporterTestszx Tests for the subunit reporter. This just tests that the subunit reporter implements the basic interface. r_ c C sH t jd u r td��t�d�| _t� | _t� � | _ | j | j| j d�| _ d S )Nz2Subunit not installed, cannot test SubunitReporterr� r` ) r �TestProtocolClientr r r� r� r r� r rb ra r_ rJ r) r r r rK o s zSubunitReporterTests.setUpc O sd t � }t�|�}t||�|i |��}|�� }t| j|�|i |��}| �||� | �|| j�� � dS )a� Assert that 'methodName' on L{SubunitReporter} forwards to the equivalent method on subunit. Checks that the return value from subunit is returned from the L{SubunitReporter} and that the reporter writes the same data to its stream as subunit does to its own. Assumes that the method on subunit has the same name as the method on L{SubunitReporter}. N)r r r� �getattrri rJ rU r� ) r � methodName�args�kwargsr� � subunitClient� subunitReturn� subunitOutput�reporterReturnr r r �assertForwardsToSubunitx s z,SubunitReporterTests.assertForwardsToSubunitc C sd t ||d�}|du r dS t|�D ] }zt||� W n ttfy& Y dS w | �t|||� qdS )a� Remove 'methodName' from 'klass'. If 'klass' does not have a method named 'methodName', then 'removeMethod' succeeds silently. If 'klass' does have a method named 'methodName', then it is removed using delattr. Also, methods of the same name are removed from all base classes of 'klass', thus removing the method entirely. @param klass: The class to remove the method from. @param methodName: The name of the method to remove. N)r� r �delattr�AttributeErrorr? � addCleanup�setattr)r �klassr� �method�baser r r � removeMethod� s ��z!SubunitReporterTests.removeMethodc C s� | � tjd� zdd W n ty! | j�| jt�� d� Y nw | j � � }| j � d� | j � d� | j� | j� | j � � }| �||� dS )z� Some versions of subunit don't have "addExpectedFailure". For these versions, we report expected failures as successes. r$ rO r r' N)r� r r� ry rJ r$ r� rR rS r� ri rw rx rF rU )r �expectedFailureOutput� successOutputr r r �.test_subunitWithoutAddExpectedFailureInstalled� s � zCSubunitReporterTests.test_subunitWithoutAddExpectedFailureInstalledc C sh | � tjd� | j�| jd� | j�� }| j�d� | j� d� | j� | j� | j�� }| � ||� dS )zz Some versions of subunit don't have "addSkip". For these versions, we report skips as successes. r �reasonr N) r� r r� rJ r r� r� ri rw rx rF rU )r � skipOutputr� r r r �#test_subunitWithoutAddSkipInstalled� s z8SubunitReporterTests.test_subunitWithoutAddSkipInstalledc sl g � � fdd�}|| j j_zdd W n ty) t�� }| j �| j|d� Y nw | �� | j|fg� dS )z� Some versions of subunit have "addExpectedFailure". For these versions, when we call 'addExpectedFailure' on the test result, we pass the error and test through to the subunit client. c � � � | |f� d S r �r? )r� r ��addExpectedFailureCallsr r r$ � � zUSubunitReporterTests.test_addExpectedFailurePassedThrough.<locals>.addExpectedFailurerO r r' N)rJ �_subunitr$ ry rR rS r� rU )r r$ rS r r� r �$test_addExpectedFailurePassedThrough� s �z9SubunitReporterTests.test_addExpectedFailurePassedThroughc sB g � � fdd�}|| j j_| j �| jd� | �� | jdfg� dS )z� Some versions of subunit have "addSkip". For these versions, when we call 'addSkip' on the test result, we pass the test and reason through to the subunit client. c r� r r� )r� r� �� addSkipCallsr r r � r� zESubunitReporterTests.test_addSkipSendsSubunitAddSkip.<locals>.addSkipr� N)rJ r� r r� rU )r r r r� r � test_addSkipSendsSubunitAddSkip� s z4SubunitReporterTests.test_addSkipSendsSubunitAddSkipc C s | j �� | �d| j�� � dS )z� The subunit reporter doesn't need to print out a summary -- the stream of results is everything. Thus, done() does nothing. � N)rJ rh rU r� ri r) r r r �test_doneDoesNothing� s z)SubunitReporterTests.test_doneDoesNothingc C � | � d| j� dS )zT SubunitReporter.startTest() sends the subunit 'startTest' message. r� N�r� r� r) r r r �#test_startTestSendsSubunitStartTest� � z8SubunitReporterTests.test_startTestSendsSubunitStartTestc C r� )zR SubunitReporter.stopTest() sends the subunit 'stopTest' message. rp Nr� r) r r r �!test_stopTestSendsSubunitStopTest� r� z6SubunitReporterTests.test_stopTestSendsSubunitStopTestc C r� )zV SubunitReporter.addSuccess() sends the subunit 'addSuccess' message. rF Nr� r) r r r �%test_addSuccessSendsSubunitAddSuccess� r� z:SubunitReporterTests.test_addSuccessSendsSubunitAddSuccessc C s< zdd W n t y t�� }Y nw | �d| j|� dS )zR SubunitReporter.addError() sends the subunit 'addError' message. rO r rQ N)ry rR rS r� r� )r r r r r �!test_addErrorSendsSubunitAddError s �z6SubunitReporterTests.test_addErrorSendsSubunitAddErrorc C s@ z| � d� W n | jy t�� }Y nw | �d| j|� dS )zV SubunitReporter.addFailure() sends the subunit 'addFailure' message. �hellor] N)r3 r\ rR rS r� r� )r rZ r r r �%test_addFailureSendsSubunitAddFailure s �z:SubunitReporterTests.test_addFailureSendsSubunitAddFailurec C sH t � }t�|�}|�| j� |�� }| j�| j� | �|| j �� � dS )z� SubunitReporter.addFailure() sends the subunit 'addSuccess' message, since subunit doesn't model unexpected success. N) r r r� rF r� ri rJ r) rU r� )r r� r� r� r r r �/test_addUnexpectedSuccessSendsSubunitAddSuccess s zDSubunitReporterTests.test_addUnexpectedSuccessSendsSubunitAddSuccessc C s4 t �� �d�}|�| j� | j�� }| �d|� dS )zC Load-time errors are reported like normal errors. � doesntexists doesntexistN)r re rw rl rJ r� ri �assertIn)r r� rA r r r �test_loadTimeErrors% s z(SubunitReporterTests.test_loadTimeErrorsN)r* r+ r, r- r �SubunitReporterr_ r r rk rl rK r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� f s$ r� c @ r� )� SubunitReporterNotInstalledTestszD Test behaviour when the subunit reporter is not installed. c C s8 t � }| �tdd� | �ttj|�}| �dt|�� dS )z� If subunit is not installed, TestProtocolClient will be None, and SubunitReporter will raise an error when you try to construct it. r� NzSubunit not available)r �patchr r- r r� rU r; )r r� rX r r r �test_subunitNotInstalled6 s z9SubunitReporterNotInstalledTests.test_subunitNotInstalledN)r* r+ r, r- r� r r r r r� 1 s r� c @ s" e Zd ZU ejZeej e d< dS )�TimingReporterTestsr_ N) r* r+ r, r �TimingTextReporterr_ r r rk rl r r r r r� A s r� c @ sT e Zd ZdZdd� Zdd� Zddd�Zd d � Zd d � Zdd d�Z dd� Z dd� Z dS )�LoggingReporterzJ Simple reporter that stores the last test that was passed to it. c O s$ t jj| g|�R i |�� d | _d S r )r rb r r� )r r� r� r r r r J s zLoggingReporter.__init__c C r r �r� )r r� r r r r rQ N r zLoggingReporter.addErrorNc C r r r� )r r� rZ r' r r r r$ Q r z"LoggingReporter.addExpectedFailurec C r r r� )r r� rZ r r r r] T r zLoggingReporter.addFailurec C r r r� )r r� �skipr r r r W r zLoggingReporter.addSkipc C r r r� r+ r r r r) Z r z$LoggingReporter.addUnexpectedSuccessc C r r r� r� r r r r� ] r zLoggingReporter.startTestc C r r r� r� r r r rp ` r zLoggingReporter.stopTestr ) r* r+ r, r- r rQ r$ r] r r) r� rp r r r r r� E s r� c @ r ) �AdaptedReporterTestsz� L{reporter._AdaptedReporter} is a reporter wrapper that wraps all of the tests it receives before passing them on to the original reporter. c C s | � � | _d S r )�getWrappedResult� wrappedResultr) r r r rK j rL zAdaptedReporterTests.setUpc C s |� � S r )r� r� r r r � _testAdapterm � z!AdaptedReporterTests._testAdapterc C s | � |jj| �|�� d S r )rU r� r� r� )r r� r� r r r � assertWrappedp s z"AdaptedReporterTests.assertWrappedc C s z|� t y t� Y S w )z� Return a L{Failure} from raising the given exception. @param exceptionInstance: The exception to raise. @return: L{Failure} )� BaseExceptionr )r �exceptionInstancer r r � getFailures s �z AdaptedReporterTests.getFailurec C s t � }t�|| j�S r )r� r �_AdaptedReporterr� r� r r r r� s z%AdaptedReporterTests.getWrappedResultc C �( | j �| | �t� �� | �| j | � dS )zG C{addError} wraps its test with the provided adapter. N)r� rQ r� rP r� r) r r r � test_addError� � z"AdaptedReporterTests.test_addErrorc C r� )zI C{addFailure} wraps its test with the provided adapter. N)r� r] r� �AssertionErrorr� r) r r r �test_addFailure� r� z$AdaptedReporterTests.test_addFailurec C s* | j �| | �td��� | �| j | � dS )zF C{addSkip} wraps its test with the provided adapter. � no reasonN)r� r r� r r� r) r r r � test_addSkip� s z!AdaptedReporterTests.test_addSkipc C � | j �| � | �| j | � dS )zH C{startTest} wraps its test with the provided adapter. N)r� r� r� r) r r r �test_startTest� � z#AdaptedReporterTests.test_startTestc C r� )zG C{stopTest} wraps its test with the provided adapter. N)r� rp r� r) r r r � test_stopTest� r� z"AdaptedReporterTests.test_stopTestc C s. | j �| | �t� �td�� | �| j | � dS )zQ C{addExpectedFailure} wraps its test with the provided adapter. r� N)r� r$ r� rP r r� r) r r r �test_addExpectedFailure� s �z,AdaptedReporterTests.test_addExpectedFailurec C r� )z@ C{addExpectedFailure} works without a C{Todo}. N)r� r$ r� rP r� r) r r r � test_expectedFailureWithoutTodo� r� z4AdaptedReporterTests.test_expectedFailureWithoutTodoc C s$ | j �| td�� | �| j | � dS )zS C{addUnexpectedSuccess} wraps its test with the provided adapter. r� N)r� r) r r� r) r r r �test_addUnexpectedSuccess� s z.AdaptedReporterTests.test_addUnexpectedSuccessc C r� )zB C{addUnexpectedSuccess} works without a C{Todo}. N)r� r) r� r) r r r �!test_unexpectedSuccessWithoutTodo� r� z6AdaptedReporterTests.test_unexpectedSuccessWithoutTodoN)r* r+ r, r- rK r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� d s r� c @ s" e Zd ZdZddd�Zdd� ZdS ) � FakeStreamz� A fake stream which C{isatty} method returns some predictable. @ivar tty: returned value of C{isatty}. @type tty: C{bool} Tc C r r ��tty)r r� r r r r � r zFakeStream.__init__c C s | j S r r� r) r r r �isatty� � zFakeStream.isattyN)T)r* r+ r, r- r r� r r r r r� � s r� c @ r� )�AnsiColorizerTestsz/ Tests for L{reporter._AnsiColorizer}. c C s t j�� | _d S r )rR �modules�copy� savedModulesr) r r r rK � s zAnsiColorizerTests.setUpc C s t j�� t j�| j� d S r )rR r� �clear�updater� r) r r r �tearDown� s zAnsiColorizerTests.tearDownc C s | � tj�td��� dS )zq L{reporter._AnsiColorizer.supported} returns C{False} if the given stream is not a TTY. FN)� assertFalser �_AnsiColorizer� supportedr� r) r r r �test_supportedStdOutTTY� s z*AnsiColorizerTests.test_supportedStdOutTTYc C s" dt jd< | �tj�t� �� dS )zw L{reporter._AnsiColorizer.supported} returns C{False} if the curses module can't be imported. N�curses�rR r� r� r r� r� r� r) r r r �test_supportedNoCurses� s z)AnsiColorizerTests.test_supportedNoCursesc C sZ G dd� d�}|� t jd< | �tj�t� �� | �tj�t� �� | �t jd jd� dS )a L{reporter._AnsiColorizer.supported} returns C{True} if C{curses.tigetnum} returns more than 2 supported colors. It only tries to call C{curses.setupterm} if C{curses.tigetnum} previously failed with a C{curses.error}. c @ �$ e Zd ZeZdZdd� Zdd� ZdS )z>AnsiColorizerTests.test_supportedSetupTerm.<locals>.fakecursesr c S � | j d7 _ d S ro �rK r) r r r � setupterm� r� zHAnsiColorizerTests.test_supportedSetupTerm.<locals>.fakecurses.setuptermc S s | j rdS | �� �)Nr )rK r �r rV r r r �tigetnum� s zGAnsiColorizerTests.test_supportedSetupTerm.<locals>.fakecurses.tigetnumN�r* r+ r, rP r rK r� r� r r r r � fakecurses� � r� r� rO N) rR r� r3 r r� r� r� rU rK �r r� r r r �test_supportedSetupTerm� s z*AnsiColorizerTests.test_supportedSetupTermc C �2 G dd� d�}|� t jd< | �tj�t� �� dS )z� L{reporter._AnsiColorizer.supported} returns C{False} and doesn't try to call C{curses.setupterm} if C{curses.tigetnum} returns something different than C{curses.error}. c @ � e Zd ZeZdd� ZdS )zGAnsiColorizerTests.test_supportedTigetNumWrongError.<locals>.fakecursesc S s t � �r )� ValueErrorr� r r r r� r� zPAnsiColorizerTests.test_supportedTigetNumWrongError.<locals>.fakecurses.tigetnumN�r* r+ r, rP r r� r r r r r� � r� r� Nr� r r r r � test_supportedTigetNumWrongError s z3AnsiColorizerTests.test_supportedTigetNumWrongErrorc C r )z� L{reporter._AnsiColorizer.supported} returns C{False} if C{curses.tigetnum} returns less than 2 supported colors. c @ r )zKAnsiColorizerTests.test_supportedTigetNumNotEnoughColor.<locals>.fakecursesc S s dS ro r r� r r r r� # s zTAnsiColorizerTests.test_supportedTigetNumNotEnoughColor.<locals>.fakecurses.tigetnumNr r r r r r� r r� r� Nr� r r r r �$test_supportedTigetNumNotEnoughColor s z7AnsiColorizerTests.test_supportedTigetNumNotEnoughColorc C sF G dd� d�}|� t jd< | �tj�t� �� | �t jd jd� dS )z� L{reporter._AnsiColorizer.supported} returns C{False} if C{curses.tigetnum} raises an error, and calls C{curses.setupterm} once. c @ r� )zCAnsiColorizerTests.test_supportedTigetNumErrors.<locals>.fakecursesr c S r� ro r� r) r r r r� 3 r� zMAnsiColorizerTests.test_supportedTigetNumErrors.<locals>.fakecurses.setuptermc S s | � � �r )r r� r r r r� 6 r� zLAnsiColorizerTests.test_supportedTigetNumErrors.<locals>.fakecurses.tigetnumNr� r r r r r� / r� r� r� rO N) rR r� r� r r� r� r� rU rK r r r r � test_supportedTigetNumErrors) s z/AnsiColorizerTests.test_supportedTigetNumErrorsN) r* r+ r, r- rK r� r� r� r r r r r r r r r� � s r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �ExitWrapperTestsz- Tests for L{reporter._ExitWrapper}. c C sB t td��| _t�d�| _t�� | _t | j�| _ | � | j j � d S )NzI am a Failurer� ) r r rZ r r� r� r rI rJ r �wrappedr� rc r) r r r rK C s zExitWrapperTests.setUpc C �> | j �| j| j� | �| j j� | �| jj| j| jfg� dS )zm L{reporter._ExitWrapper} causes a wrapped reporter to stop after its first failure. N) r r] r� rZ r3 rc rU rJ r^ r) r r r �test_stopOnFailureJ � z#ExitWrapperTests.test_stopOnFailurec C r )zk L{reporter._ExitWrapper} causes a wrapped reporter to stop after its first error. N) r rQ r� rZ r3 rc rU rJ rT r) r r r �test_stopOnErrorS r z!ExitWrapperTests.test_stopOnErrorc C r )zy L{reporter._ExitWrapper} does not cause a wrapped reporter to stop after an unexpected success. N) r r) r� rZ r� rc rU rJ r! r) r r r �#test_doesNotStopOnUnexpectedSuccess\ r z4ExitWrapperTests.test_doesNotStopOnUnexpectedSuccessN)r* r+ r, r- rK r r r r r r r r > s r )Dr- r$ r� r6 rR �inspectr �ior r �typingr r r r6 r �twisted.pythonr r �twisted.python.failurer �twisted.python.reflectr � twisted.trialr r r r �twisted.trial.reporterr r rz r r �twisted.trial.unittestr r r r �SynchronousTestCaser/ rH r` rd r� r� r� r� r� r� r� r r r; r> rB r^ rm r� r� r� r� rb r� r� r� r� r r r r r �<module> s^ F1BI H pDn L ajPK Mb�Z��jS S 2 trial/test/__pycache__/mockdoctest.cpython-310.pycnu �[��� o �bu � @ s G d d� d�Z dS )c @ sb e Zd ZdZdZddd�Zdd� Zded efd d �Z ded efd d �Z dd� Z dd� Z dd� Z dS )�Counterz�a simple counter object for testing trial's doctest support >>> c = Counter() >>> c.value() 0 >>> c += 3 >>> c.value() 3 >>> c.incr() >>> c.value() == 4 True >>> c == 4 True >>> c != 9 True � Nc C s || _ || _d S )N)�_count�maxval)�self� initialValuer � r �@/usr/lib/python3/dist-packages/twisted/trial/test/mockdoctest.py�__init__ s zCounter.__init__c C s4 | j dur| j| | j krtd��| j|7 _| S )z�add other to my value and return self >>> c = Counter(100) >>> c += 333 >>> c == 433 True Nzsorry, counter got too big)r r � ValueError�r �otherr r r �__iadd__! s zCounter.__iadd__r �returnc C s | j |kS )z�equality operator, compare other to my value() >>> c = Counter() >>> c == 0 True >>> c += 10 >>> c.incr() >>> c == 10 # fail this test on purpose True �r r r r r �__eq__/ s zCounter.__eq__c C s | � |� S )zXinequality operator >>> c = Counter() >>> c != 10 True )r r r r r �__ne__= s zCounter.__ne__c C s | � d� dS )a: increment my value by 1 >>> from twisted.trial.test.mockdoctest import Counter >>> c = Counter(10, 11) >>> c.incr() >>> c.value() == 11 True >>> c.incr() Traceback (most recent call last): File "<stdin>", line 1, in ? File "twisted/trial/test/mockdoctest.py", line 51, in incr self.__iadd__(1) File "twisted/trial/test/mockdoctest.py", line 39, in __iadd__ raise ValueError, "sorry, counter got too big" ValueError: sorry, counter got too big � N)r �r r r r �incrF s z Counter.incrc C s | j S )zlreturn this counter's value >>> c = Counter(555) >>> c.value() == 555 True r r r r r �valueY s z Counter.valuec C s dS )zui will raise an unexpected exception... ... *CAUSE THAT'S THE KINDA GUY I AM* >>> 1/0 Nr r r r r �unexpectedExceptionb s zCounter.unexpectedException)r N)�__name__� __module__� __qualname__�__doc__r r r �object�boolr r r r r r r r r r s r N)r r r r r �<module> s PK Mb�Z�2d�\� \� 1 trial/test/__pycache__/test_tests.cpython-310.pycnu �[��� o �b\� � @ s� d Z ddlZddlZddlZddlZddlmZ ddlm Z m Z ddl m Z ddl mZ ddlmZmZmZmZ ddlmZmZmZ dd lmZ dd lmZ G d d � d �ZG d d� d�Z G dd� de ej �Z G dd� de ej �Z G dd� de�Z!G dd� de!ej �Z"G dd� de!ej �Z#G dd� de�Z$G dd � d e$ej �Z%G d d � d e$ej �Z&G d d � d e�Z'G d!d"� d"e'ej �Z(G d#d$� d$e'ej �Z)G d%d&� d&e�Z*G d'd(� d(e*ej �Z+G d)d*� d*e*ej �Z,G d+d,� d,e�Z-G d-d.� d.e-ej �Z.G d/d0� d0e-ej �Z/G d1d2� d2ej �Z0G d3d4� d4�Z1G d5d6� d6e1ej �Z2G d7d8� d8e1ej �Z3G d9d:� d:eej �Z4G d;d<� d<�Z5G d=d>� d>e5ej �Z6G d?d@� d@e5ej �Z7G dAdB� dBej �Z8G dCdD� dD�Z9G dEdF� dFe9ej �Z:G dGdH� dHe9ej �Z;G dIdJ� dJ�Z<G dKdL� dLe<ej �Z=G dMdN� dNe<ej �Z>G dOdP� dP�Z?G dQdR� dRe?ej �Z@G dSdT� dTe?ej �ZAG dUdV� dV�ZBG dWdX� dXeBej �ZCG dYdZ� dZeBej �ZDG d[d\� d\�ZEG d]d^� d^eEej �ZFG d_d`� d`eEej �ZGG dadb� dbej �ZHdS )ca� Tests for the behaviour of unit tests. Many tests in this module follow a simple pattern. A mixin is defined which includes test methods for a certain feature. The mixin is inherited from twice, once by a class also inheriting from SynchronousTestCase and once from a class inheriting from TestCase. These two subclasses are named like I{SynchronousFooTests} and I{AsynchronousFooTests}, where I{Foo} is related to the name of the mixin. Sometimes the mixin is defined in another module, along with the synchronous subclass. The mixin is imported into this module to define the asynchronous subclass. This pattern allows the same tests to be applied to the two base test case classes trial provides, ensuring their behavior is the same. Most new tests should be added in this pattern. Tests for functionality which is intentionally only provided by TestCase, not SynchronousTestCase, is excepted of course. � N)�StringIO)�defer�reactor)�_PYPY)�namedAny)�reporter�runner�unittest�util)� _clearSuite� _ForceGarbageCollectionDecorator� _iterateTests)� erroneous)�SuppressionMixinc @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �ResultsTestMixinzG Provide useful APIs for test cases that are about test cases. c C s& t �� | _| j�|�| _t�� | _dS )zt Load tests from the given test case class and create a new reporter to use for running it. N)�pyunit� TestLoader�loader�loadTestsFromTestCase�suiter � TestResult��selfr � r �?/usr/lib/python3/dist-packages/twisted/trial/test/test_tests.py� loadSuite1 s zResultsTestMixin.loadSuitec C sD | � | j�� � | �| jjg � | �| jjg � | �| jjg � dS )z test the setup N)� assertTruer � wasSuccessful� assertEqual�errors�failures�skips�r r r r � test_setUp: s zResultsTestMixin.test_setUpc C s2 | � | j�� |� | �| j� | � | jj|� dS )z: Asserts that the test count is plausible N)r r �countTestCasesr �testsRun)r �numTestsr r r � assertCountC s z ResultsTestMixin.assertCountN)�__name__� __module__� __qualname__�__doc__r r$ r( r r r r r , s r c @ �@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� SuccessMixinz\ Tests for the reporting of successful tests in L{twisted.trial.unittest.TestCase}. c C s t �� | _dS ��% Setup our test case N)r r �resultr# r r r �setUpQ � zSuccessMixin.setUpc C s dS )z9 A successful test, used by other tests. Nr r# r r r �test_successfulW s z SuccessMixin.test_successfulc C sX | � |jd� | � |jg � | � |jg � | � |jg � | � |jg � | � |jg � dS )zd Utility function -- assert there is one success and the state is plausible � N)r � successesr! r �expectedFailures�unexpectedSuccessesr" �r �testr1 r r r �assertSuccessful\ s z SuccessMixin.assertSuccessfulc C s( | � d�}|�| j� | �|| j� dS )z� Test that when a successful test is run, it is reported as a success, and not as any other kind of result. r4 N�� __class__�runr1 r; �r r: r r r �test_successfulIsReportedh s z&SuccessMixin.test_successfulIsReportedc C s& | � � }|�| j� | �|| j� dS )zz The test case type can be instantiated with no arguments, run, and reported as being successful. Nr< r? r r r �test_defaultIsSuccessfulq s z%SuccessMixin.test_defaultIsSuccessfulc C sJ | � d�}t�|�}|�| j� | �|| j� ~t�� | �|� d� dS )zF Test that no reference is kept on a successful test. r4 N) r= �weakref�refr> r1 r; �gc�collect�assertIdentical)r r: rC r r r �test_noReferencez s z SuccessMixin.test_noReferenceN) r) r* r+ r, r2 r4 r; r@ rA rG r r r r r. L s r. c @ � e Zd ZdZdS )�SynchronousSuccessTests�N Tests for the reporting of successful tests in the synchronous case. N�r) r* r+ r, r r r r rI � � rI c @ rH )�AsynchronousSuccessTestsrJ NrK r r r r rM � rL rM c @ r- )�SkipMethodsMixinzZ Tests for the reporting of skipping tests in L{twisted.trial.unittest.TestCase}. c C � | � | j� dS r/ )r �Skippingr# r r r r2 � � zSkipMethodsMixin.setUpc C � | � d� dS )z4 Assert that there are three tests. � N�r( r# r r r � test_counting� r3 z SkipMethodsMixin.test_countingc C �d | � | j� | �| j�� � | �| jjg � | �| jjg � | �t| jj�d� | �| jj d� dS )z� Running a suite in which all methods are individually set to skip produces a successful result with no recorded errors or failures, all the skipped methods recorded as skips, and no methods recorded as successes. rS r N� r r r r r r r! �lenr" r6 r# r r r � test_results� � z SkipMethodsMixin.test_resultsc C sp | � | j� | �| j� | �| j�� � | �| jjg � | �| jjg � | �t | jj �d� | �| jj d� dS )a Running a suite in which all methods are skipped by C{setUp} raising L{SkipTest} produces a successful result with no recorded errors or failures, all skipped methods recorded as skips, and no methods recorded as successes. � r N) r � SkippingSetUpr r r r r r r! rX r" r6 r# r r r r$ � s zSkipMethodsMixin.test_setUpc C sF | � | j� d}| jjD ]\}}| �|�� t|�d� t|�� q dS )z( Test that reasons work �test_N)r r r" r �shortDescriptionrX �str)r �prefixr: �reasonr r r � test_reasons� s "�z SkipMethodsMixin.test_reasonsc C sd | � | j� | �| j� | �| jjg�}| �dt|�� | �t|d d � | �d|d d � dS )zo If a test method raises L{SkipTest} with no reason, a deprecation warning is emitted. r5 r �categoryzSDo not raise unittest.SkipTest with no arguments! Give a reason for skipping tests!�messageN) r �DeprecatedReasonlessSkipr r � flushWarnings�test_1r rX �DeprecationWarning)r �warningsr r r � test_deprecatedSkipWithoutReason� s �z1SkipMethodsMixin.test_deprecatedSkipWithoutReasonN) r) r* r+ r, r2 rU rY r$ rb rj r r r r rN � s rN c @ �( e Zd ZdZed�Zed�Zed�ZdS )�SynchronousSkipMethodTestsz� Tests for the reporting of skipping tests in the synchronous case. See: L{twisted.trial.test.test_tests.SkipMethodsMixin} z/twisted.trial.test.skipping.SynchronousSkippingz4twisted.trial.test.skipping.SynchronousSkippingSetUpz?twisted.trial.test.skipping.SynchronousDeprecatedReasonlessSkipN�r) r* r+ r, r rP r\ re r r r r rl � � �rl c @ rk )�AsynchronousSkipMethodTestsz� Tests for the reporting of skipping tests in the asynchronous case. See: L{twisted.trial.test.test_tests.SkipMethodsMixin} z0twisted.trial.test.skipping.AsynchronousSkippingz5twisted.trial.test.skipping.AsynchronousSkippingSetUpz@twisted.trial.test.skipping.AsynchronousDeprecatedReasonlessSkipNrm r r r r ro � rn ro c @ �8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �SkipClassesMixinzQ Test the class skipping features of L{twisted.trial.unittest.TestCase}. c C s | � | j� d| j_dS )r0 FN)r � SkippedClass� _setUpRanr# r r r r2 � s zSkipClassesMixin.setUpc C rR )zP Skipped test methods still contribute to the total test count. � NrT r# r r r rU r3 z SkipClassesMixin.test_countingc C s | � | j� | �| jj� dS )zP The C{setUp} method is not called if the class is set to skip. N)r r � assertFalserr rs r# r r r � test_setUpRan s z SkipClassesMixin.test_setUpRanc C rV )a Skipped test methods don't cause C{wasSuccessful} to return C{False}, nor do they contribute to the C{errors} or C{failures} of the reporter, or to the count of successes. They do, however, add elements to the reporter's C{skips} list. rt r NrW r# r r r rY rZ z SkipClassesMixin.test_resultsc C �6 | � | j� g d�}dd� | jjD �}| �||� dS )z� Test methods which raise L{unittest.SkipTest} or have their C{skip} attribute set to something are skipped. )�class�skip2rx rx c S s g | ]\}}|�qS r r )�.0r: ra r r r � <listcomp>' s z1SkipClassesMixin.test_reasons.<locals>.<listcomp>N)r r r" r �r �expectedReasons� reasonsGivenr r r rb s z SkipClassesMixin.test_reasonsN) r) r* r+ r, r2 rU rv rY rb r r r r rq � s rq c @ � e Zd ZdZed�ZdS )�SynchronousSkipClassTestsz Test the class skipping features in the synchronous case. See: L{twisted.trial.test.test_tests.SkipClassesMixin} z3twisted.trial.test.skipping.SynchronousSkippedClassN�r) r* r+ r, r rr r r r r r� + � r� c @ r )�AsynchronousSkipClassTestsz� Test the class skipping features in the asynchronous case. See: L{twisted.trial.test.test_tests.SkipClassesMixin} z4twisted.trial.test.skipping.AsynchronousSkippedClassNr� r r r r r� 5 r� r� c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )� TodoMixinzv Tests for the individual test method I{expected failure} features of L{twisted.trial.unittest.TestCase}. c C rO r/ )r �Todor# r r r r2 E rQ zTodoMixin.setUpc C rR )z9 Ensure that we've got three test cases. rS NrT r# r r r rU K r3 zTodoMixin.test_countingc C s� | � | j� | �| j�� � | �| jjg � | �| jjg � | �| jjg � | �t| jj �d� | �t| jj �d� | �| jj d� dS )a� Running a suite in which all methods are individually marked as expected to fail produces a successful result with no recorded errors, failures, or skips, all methods which fail and were expected to fail recorded as C{expectedFailures}, and all methods which pass but which were expected to fail recorded as C{unexpectedSuccesses}. Additionally, no tests are recorded as successes. r[ r5 r N� r r r r r r r! r" rX r7 r8 r6 r# r r r rY Q � zTodoMixin.test_resultsc C �6 | � | j� ddg}dd� | jjD �}| �||� dS )�E Ensure that expected failures are handled properly. �todo1�todo2c S � g | ]\}}}|j �qS r �ra �rz �t�e�rr r r r{ i � z3TodoMixin.test_expectedFailures.<locals>.<listcomp>N�r r r7 r r| r r r �test_expectedFailuresc � z TodoMixin.test_expectedFailuresc C s4 | � | j� dg}dd� | jjD �}| �||� dS )�> Ensure that unexpected successes are caught. �todo3c S � g | ]\}}|j �qS r r� �rz r� r� r r r r{ r � z6TodoMixin.test_unexpectedSuccesses.<locals>.<listcomp>N�r r r8 r r| r r r �test_unexpectedSuccessesl s z"TodoMixin.test_unexpectedSuccessesc C s� | � | j� | �| j� | �| j�� � | �t| jj�d� | �| jj g � | �| jj g � | �t| jj �d� | �t| jj �d� | �| jj d� dS )z| C{setUp} is excluded from the failure expectation defined by a C{todo} attribute on a test method. r5 r N)r � SetUpTodor r ru r r rX r r! r" r7 r8 r6 r# r r r �test_expectedSetUpFailureu s z#TodoMixin.test_expectedSetUpFailurec C s� | � | j� | �| j� | �| j�� � | �t| jj�d� | �| jj g � | �| jj g � | �t| jj �d� | �t| jj �d� | �| jj d� dS )z C{tearDown} is excluded from the failure expectation defined by a C{todo} attribute on a test method. r5 r N)r � TearDownTodor r ru r r rX r r! r" r7 r8 r6 r# r r r � test_expectedTearDownFailure� s z&TodoMixin.test_expectedTearDownFailureN) r) r* r+ r, r2 rU rY r� r� r� r� r r r r r� ? s r� c @ rk )�SynchronousTodoTestszx Test the class skipping features in the synchronous case. See: L{twisted.trial.test.test_tests.TodoMixin} z+twisted.trial.test.skipping.SynchronousTodoz0twisted.trial.test.skipping.SynchronousSetUpTodoz3twisted.trial.test.skipping.SynchronousTearDownTodoN�r) r* r+ r, r r� r� r� r r r r r� � � r� c @ rk )�AsynchronousTodoTestszy Test the class skipping features in the asynchronous case. See: L{twisted.trial.test.test_tests.TodoMixin} z,twisted.trial.test.skipping.AsynchronousTodoz1twisted.trial.test.skipping.AsynchronousSetUpTodoz4twisted.trial.test.skipping.AsynchronousTearDownTodoNr� r r r r r� � r� r� c @ rp ) �ClassTodoMixinzj Tests for the class-wide I{expected failure} features of L{twisted.trial.unittest.TestCase}. c C rO r/ )r � TodoClassr# r r r r2 � rQ zClassTodoMixin.setUpc C rR )z8 Ensure that we've got four test cases. rt NrT r# r r r rU � r3 z ClassTodoMixin.test_countingc C s� | � | j� | �| j�� � | �| jjg � | �| jjg � | �| jjg � | �t| jj �d� | �t| jj �d� | �| jj d� dS )a� Running a suite in which an entire class is marked as expected to fail produces a successful result with no recorded errors, failures, or skips, all methods which fail and were expected to fail recorded as C{expectedFailures}, and all methods which pass but which were expected to fail recorded as C{unexpectedSuccesses}. Additionally, no tests are recorded as successes. r[ r Nr� r# r r r rY � r� zClassTodoMixin.test_resultsc C r� )r� �methodrx c S r� r r� r� r r r r{ � r� z8ClassTodoMixin.test_expectedFailures.<locals>.<listcomp>Nr� r| r r r r� � r� z$ClassTodoMixin.test_expectedFailuresc C r� )r� r� rx c S r� r r� r� r r r r{ � r� z;ClassTodoMixin.test_unexpectedSuccesses.<locals>.<listcomp>Nr� r| r r r r� � r� z'ClassTodoMixin.test_unexpectedSuccessesN� r) r* r+ r, r2 rU rY r� r� r r r r r� � s r� c @ r )�SynchronousClassTodoTestsz� Tests for the class-wide I{expected failure} features in the synchronous case. See: L{twisted.trial.test.test_tests.ClassTodoMixin} z0twisted.trial.test.skipping.SynchronousTodoClassN�r) r* r+ r, r r� r r r r r� � r� r� c @ r )�AsynchronousClassTodoTestsz� Tests for the class-wide I{expected failure} features in the asynchronous case. See: L{twisted.trial.test.test_tests.ClassTodoMixin} z1twisted.trial.test.skipping.AsynchronousTodoClassNr� r r r r r� � r� r� c @ rp ) �StrictTodoMixinz� Tests for the I{expected failure} features of L{twisted.trial.unittest.TestCase} in which the exact failure which is expected is indicated. c C rO r/ )r � StrictTodor# r r r r2 rQ zStrictTodoMixin.setUpc C rR )z3 Assert there are seven test cases � NrT r# r r r rU r3 z StrictTodoMixin.test_countingc C s� | � | j� | �| j�� � | �t| jj�d� | �t| jj�d� | �t| jj�d� | �t| jj �d� | �| jj d� | �| jj g � dS )z� A test method which is marked as expected to fail with a particular exception is only counted as an expected failure if it does fail with that exception, not if it fails with some other exception. r[ r5 rS r N) r r ru r r rX r r! r7 r8 r6 r" r# r r r rY s z StrictTodoMixin.test_resultsc C rw )r� )r� r� �todo5c S r� r r� r� r r r r{ " r� z9StrictTodoMixin.test_expectedFailures.<locals>.<listcomp>Nr� �r r} � reasonsGottenr r r r� r� z%StrictTodoMixin.test_expectedFailuresc C s: | � | j� tgdfg}dd� | jjD �}| �||� dS )r� �todo7c S s g | ] \}}|j |jf�qS r )r ra r� r r r r{ + s �z<StrictTodoMixin.test_unexpectedSuccesses.<locals>.<listcomp>N)r r � RuntimeErrorr8 r r� r r r r� % s �z(StrictTodoMixin.test_unexpectedSuccessesNr� r r r r r� � s r� c @ r )�SynchronousStrictTodoTestsz� Tests for the expected failure case when the exact failure that is expected is indicated in the synchronous case See: L{twisted.trial.test.test_tests.StrictTodoMixin} z1twisted.trial.test.skipping.SynchronousStrictTodoN�r) r* r+ r, r r� r r r r r� 1 � r� c @ r )�AsynchronousStrictTodoTestsz� Tests for the expected failure case when the exact failure that is expected is indicated in the asynchronous case See: L{twisted.trial.test.test_tests.StrictTodoMixin} z2twisted.trial.test.skipping.AsynchronousStrictTodoNr� r r r r r� < r� r� c @ r ) �ReactorCleanupTestszc Tests for cleanup and reporting of reactor event sources left behind by test methods. c C s t �t� �| _t�� | _dS r/ )r �Reporterr r1 r r r r# r r r r2 M s zReactorCleanupTests.setUpc C s^ | j �d�}|�| j� | �| j�� � | �| jjd� | jjd d }| � |� t j �� dS )zm Trial reports a L{util.DirtyReactorAggregateError} if a test leaves sockets behind. z@twisted.trial.test.erroneous.SocketOpenTest.test_socketsLeftOpenr5 r N) r � loadByNamer> r1 ru r r r6 r r �checkr �DirtyReactorAggregateError�r r �failurer r r �test_leftoverSocketsT s � z(ReactorCleanupTests.test_leftoverSocketsc C s\ t �d�}|�| j� | �| j�� � | jjd d }| �| jjd� | � |� t j �� dS )z� Trial reports a L{util.DirtyReactorAggregateError} and fails the test if a test leaves a L{DelayedCall} hanging. �test_leftoverPendingCallsr r5 N) r r� r> r1 ru r r r r6 r r� r r� r� r r r r� e s z-ReactorCleanupTests.test_leftoverPendingCallsN)r) r* r+ r, r2 r� r� r r r r r� G s r� c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � FixtureMixinzB Tests for fixture helper methods (e.g. setUp, tearDown). c C s t �� | _ t�� | _dS r/ )r r� r r r r# r r r r2 w s zFixtureMixin.setUpc C s` | j �| j�}|�| j� | �t| jj�dk� | �| jjd d j t j � | � d| jj � dS )zO When setUp fails, the error is recorded in the result object. r r5 N)r r �TestFailureInSetUpr> r r rX r �assertIsInstance�valuer � FoolishErrorr r6 r r r r �test_brokenSetUp~ s z FixtureMixin.test_brokenSetUpc C s` | j �| j�}|�| j� | jj}| �t|�dk� | �|d d j t j � | � d| jj � dS )zR When tearDown fails, the error is recorded in the result object. r r5 N)r r �TestFailureInTearDownr> r r r rX r� r� r r� r r6 )r r r r r r �test_brokenTearDown� s z FixtureMixin.test_brokenTearDownc C s� | j �| j�}t|�d }| �|j� |�| j� | jj}| � t |�dk� | � |d d j t j� | �d| jj� | � |j� dS )zP L{SynchronousTestCase.tearDown} runs when a test method fails. r r5 N)r r �TestFailureButTearDownRuns�listru �tornDownr> r r r rX r� r� r r� r r6 )r r �caser r r r � test_tearDownRunsOnTestFailure� s z+FixtureMixin.test_tearDownRunsOnTestFailureN)r) r* r+ r, r2 r� r� r� r r r r r� r s r� c @ rk )�SynchronousFixtureTestsz� Tests for broken fixture helper methods in the synchronous case See: L{twisted.trial.test.test_tests.FixtureMixin} z:twisted.trial.test.erroneous.SynchronousTestFailureInSetUpz=twisted.trial.test.erroneous.SynchronousTestFailureInTearDownzBtwisted.trial.test.erroneous.SynchronousTestFailureButTearDownRunsN�r) r* r+ r, r r� r� r� r r r r r� � � ���r� c @ rk )�AsynchronousFixtureTestsz� Tests for broken fixture helper methods in the asynchronous case See: L{twisted.trial.test.test_tests.FixtureMixin} z;twisted.trial.test.erroneous.AsynchronousTestFailureInSetUpz>twisted.trial.test.erroneous.AsynchronousTestFailureInTearDownzCtwisted.trial.test.erroneous.AsynchronousTestFailureButTearDownRunsNr� r r r r r� � r� r� c @ s0 e Zd ZdZed�Zed�Zed�Zed�ZdS )� AsynchronousSuppressionTestsz� Tests for the warning suppression features of L{twisted.trial.unittest.TestCase} See L{twisted.trial.test.test_suppression.SuppressionMixin} z?twisted.trial.test.suppression.AsynchronousTestSetUpSuppressionzBtwisted.trial.test.suppression.AsynchronousTestTearDownSuppressionz:twisted.trial.test.suppression.AsynchronousTestSuppressionz;twisted.trial.test.suppression.AsynchronousTestSuppression2N) r) r* r+ r, r �TestSetUpSuppression�TestTearDownSuppression�TestSuppression�TestSuppression2r r r r r� � s ����r� c @ sB e Zd ZdZG dd� dej�Zdd� Zdd� Zdd � Z d d � Z d S ) �GCMixinz� I provide a few mock tests that log setUp, tearDown, test execution and garbage collection. I'm used to test whether gc.collect gets called. c @ r ) zGCMixin.BasicTestz# Mock test to run. c C rR )z$ Mock setUp r2 N��_logr# r r r r2 � r3 zGCMixin.BasicTest.setUpc C rR )z( Mock test case r: Nr� r# r r r �test_foo� r3 zGCMixin.BasicTest.test_fooc C rR )z, Mock tear tearDown �tearDownNr� r# r r r r� � r3 zGCMixin.BasicTest.tearDownN)r) r* r+ r, r2 r� r� r r r r � BasicTest� s r� c C s | j �|� dS )z Log function N)�_collectCalled�append)r �msgr r r r� � rQ z GCMixin._logc C rR )zFake gc.collectrE Nr� r# r r r rE s zGCMixin.collectc C s$ g | _ | j| j_tj| _| jt_dS r/ )r� r� r� rD rE � _oldCollectr# r r r r2 s z GCMixin.setUpc C s | j t_dS �z$ Tear down the test N)r� rD rE r# r r r r� s zGCMixin.tearDownN) r) r* r+ r, r �SynchronousTestCaser� r� rE r2 r� r r r r r� � s r� c @ � e Zd ZdZdd� ZdS )� GarbageCollectionDefaultTestsz@ By default, tests should not force garbage collection. c C s2 | � d�}t�� }|�|� | �| jg d�� dS )zH By default, tests should not force garbage collection. r� )r2 r: r� N)r� r r r> r r� r9 r r r �test_collectNotDefault s z4GarbageCollectionDefaultTests.test_collectNotDefaultN)r) r* r+ r, r� r r r r r� � r� c @ r� )�GarbageCollectionTestsz- Test that, when force GC, it works. c C s: t �d�}t|�}t�� }|�|� | �| jg d�� dS )zG test gc.collect is called before and after each test. r� )rE r2 r: r� rE N)r� r� r r r r> r r� r9 r r r �test_collectCalled* s �z)GarbageCollectionTests.test_collectCalledN)r) r* r+ r, r� r r r r r� % r� r� c @ s< e Zd ZdZdd� Zdd� Ze�ed�dd� �Z d d � Z d S ) �UnhandledDeferredTestsz\ Test what happens when we have an unhandled deferred left around after a test. c C s( ddl m} t�� t|�d��| _dS )r0 r )�weird�test_unhandledDeferredN)�twisted.trial.testr� rD �disabler � TestBleeding�test1)r r� r r r r2 = s �z UnhandledDeferredTests.setUpc C s* t �� }| �|� | �t|j�dd� dS )zo Forcing garbage collection should cause unhandled Deferreds to be reported as errors. r5 z(Unhandled deferred passed without noticeN)r r r� r rX r )r r1 r r r �test_isReportedI s �z&UnhandledDeferredTests.test_isReportedz GC works differently on PyPy.c C sP t �� }| �|� | �� ttj�}| �|dd� | �� }| �t|�dd� dS )z� Forcing garbage collection in the test should mean that there are no unreachable cycles immediately after the test completes. r z unreachable cycle still existedz Errors logged after gc.collectN)r r r� �flushLoggedErrorsrX rD �garbager )r r1 �n�xr r r �test_doesntBleedT s z'UnhandledDeferredTests.test_doesntBleedc C s t �� t �� | �� dS r� )rD rE �enabler� r# r r r r� e s z UnhandledDeferredTests.tearDownN) r) r* r+ r, r2 r� r �skipIfr r� r� r r r r r� 7 s r� c sP e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z � Z S )�AddCleanupMixinz1 Test the addCleanup method of TestCase. c s" t � �� t�� | _| �� | _dS r/ )�superr2 r r r1 � AddCleanupr: r# �r= r r r2 s s zAddCleanupMixin.setUpc C �D | j j| j _| j �| j jd� | j �| j� | �ddg| j j� dS )zQ Callables added with C{addCleanup} are run even if setUp fails. �foor2 N) r: � brokenSetUpr2 � addCleanupr� r> r1 r �logr# r r r �!test_addCleanupCalledIfSetUpFails{ s z1AddCleanupMixin.test_addCleanupCalledIfSetUpFailsc C r� )z� Callables added with C{addCleanup} are run even if setUp raises L{SkipTest}. This allows test authors to reliably provide clean up code using C{addCleanup}. r� r2 N) r: � skippingSetUpr2 r r� r> r1 r r r# r r r �!test_addCleanupCalledIfSetUpSkips� s z1AddCleanupMixin.test_addCleanupCalledIfSetUpSkipsc C sJ | j �| j jd� | j �| j jd� | j �| j� | �g d�| j j� dS )z~ Callables added with C{addCleanup} should be called before C{tearDown} in reverse order of addition. r� �bar�r2 �runTestr r� r� N�r: r r� r> r1 r r r# r r r �#test_addCleanupCalledInReverseOrder� s z3AddCleanupMixin.test_addCleanupCalledInReverseOrderc C st | j �| j jd� | j �| j� | �| j�� � | �dt| jj �� | jj \\}}| �|| j � | �|� � d� dS )z� Errors raised in cleanup functions should be treated like errors in C{tearDown}. They should be added as errors and fail the test. Skips, todos and failures are all treated as errors. r� r5 N) r: r �failr> r1 ru r r rX r �getErrorMessage�r r: �errorr r r � test_errorInCleanupIsCaptured� s z-AddCleanupMixin.test_errorInCleanupIsCapturedc C s� | j �| j jd� | j �| j jd� | j �| j� | �g d�| j j� | �dt| jj �� | jj \\}}| �|| j � | �|� � d� dS )zq If a cleanup raises an error then that does not stop the other cleanups from being run. r� r )r2 r r� r� r5 N) r: r r� r r> r1 r r rX r r r r r r �&test_cleanupsContinueRunningAfterError� s z6AddCleanupMixin.test_cleanupsContinueRunningAfterErrorc C s� | j �| j jd� | j �| j jd� | j �| j� | �g d�| j j� | �dt| jj�� | jj\\}}\}}| �|| j � | �|| j � | �|� � d� | �|� � d� dS )zm If more than one cleanup fails, then the test should fail with more than one error. r� r )r2 r r� r[ N) r: r r r> r1 r r rX r r )r r� �error1�test2�error2r r r �test_multipleErrorsReported� s z+AddCleanupMixin.test_multipleErrorsReported) r) r* r+ r, r2 r r r r r r � __classcell__r r r� r r� n s r� c @ r )�SynchronousAddCleanupTestsz� Test the addCleanup method of TestCase in the synchronous case See: L{twisted.trial.test.test_tests.AddCleanupMixin} z1twisted.trial.test.skipping.SynchronousAddCleanupN)r) r* r+ r, r r� r r r r r � r� r c @ s e Zd ZdZed�Zdd� ZdS )�AsynchronousAddCleanupTestsz� Test the addCleanup method of TestCase in the asynchronous case See: L{twisted.trial.test.test_tests.AddCleanupMixin} z2twisted.trial.test.skipping.AsynchronousAddCleanupc sR � fdd�}� j �� j jd� � j �|d� � j �� j� � �g d�� j j� dS )z� If an added callable returns a L{Deferred}, then the test should wait until that L{Deferred} has fired before running the next cleanup method. c s& t �� }t�d|j| � |�� jj�S )Nr )r �Deferredr � callLater�callback� addCallbackr: r� )rd �dr# r r �cleanup� s zMAsynchronousAddCleanupTests.test_addCleanupWaitsForDeferreds.<locals>.cleanupr� r r Nr )r r r r# r � test_addCleanupWaitsForDeferreds� s z<AsynchronousAddCleanupTests.test_addCleanupWaitsForDeferredsN)r) r* r+ r, r r� r r r r r r � s r c @ � e Zd ZdZdd� Zdd� ZdS )�SuiteClearingMixinzM Tests for our extension that allows us to clear out a L{TestSuite}. c C �B t �� }|�| �� � | �d|�� � t|� | �d|�� � dS )z_ Calling L{_clearSuite} on a populated L{TestSuite} removes all tests. r5 r N)r � TestSuite�addTest�TestCaser r% r r r r r �test_clearSuite� s z"SuiteClearingMixin.test_clearSuitec C r )z� Calling L{_clearSuite} on a populated standard library L{TestSuite} removes all tests. This test is important since C{_clearSuite} operates by mutating internal variables. r5 r N)r r! r" r# r r% r r r r r �test_clearPyunitSuite� s z(SuiteClearingMixin.test_clearPyunitSuiteN)r) r* r+ r, r$ r% r r r r r � s r c @ � e Zd ZdZejZdS )� SynchronousSuiteClearingTestsz� Tests for our extension that allows us to clear out a L{TestSuite} in the synchronous case. See L{twisted.trial.test.test_tests.SuiteClearingMixin} N�r) r* r+ r, r r� r# r r r r r' � r' c @ � e Zd ZdZejZdS )� AsynchronousSuiteClearingTestsz� Tests for our extension that allows us to clear out a L{TestSuite} in the asynchronous case. See L{twisted.trial.test.test_tests.SuiteClearingMixin} N�r) r* r+ r, r r# r r r r r+ r) r+ c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�TestDecoratorMixinz1 Tests for our test decoration features. c C sd | � |j|jd� t|dd�}t|dd�}| �||� || u r%du r0n dS | �||� dS dS )zB Assert that the given decorated tests are equal. �Different class� _originalTestN)r r= �getattrrF )r �observed�expected�observedOriginal�expectedOriginalr r r �assertTestsEqual' s �z#TestDecoratorMixin.assertTestsEqualc C sr | � |j|jd� | � t|j�t|j�d� t|j|j�D ]\}}t|dd�dur0| �||� q | �||� q dS )zS Assert that the given test suites with decorated tests are equal. r. zDifferent number of tests.�_testsN)r r= rX r6 �zipr0 �assertSuitesEqualr5 )r r1 r2 � observedTest� expectedTestr r r r8 2 s ��z$TestDecoratorMixin.assertSuitesEqualc C s@ | � � }t�|�}ddlm} |� }|�|� | �|j|� dS )z� For decorated tests, C{run} uses a result adapter that preserves the test decoration for calls to C{addError}, C{startTest} and the like. See L{reporter._AdaptedReporter}. r ��LoggingReporterN)r# r � TestDecorator� twisted.trial.test.test_reporterr< r> r5 r: �r r: � decoratedTestr< r1 r r r � test_usesAdaptedReporterWithRun@ s z2TestDecoratorMixin.test_usesAdaptedReporterWithRunc C s> | � � }t�|�}ddlm} |� }||� | �|j|� dS )z� For decorated tests, C{__call__} uses a result adapter that preserves the test decoration for calls to C{addError}, C{startTest} and the like. See L{reporter._AdaptedReporter}. r r; N)r# r r= r> r< r5 r: r? r r r � test_usesAdaptedReporterWithCallP s z3TestDecoratorMixin.test_usesAdaptedReporterWithCallc C s, | � � }t�|tj�}| �t�|�|� dS )z� Calling L{decorate} on a single test case returns the test case decorated with the provided decorator. N�r# r �decorater= r5 )r r: r@ r r r �test_decorateSingleTesta s z*TestDecoratorMixin.test_decorateSingleTestc C s@ | � � }t�|g�}t�|tj�}| �|t�t�|�g�� dS )z� Calling L{decorate} on a test suite will return a test suite with each test decorated with the provided decorator. N�r# r r! rD r= r8 �r r: r r@ r r r �test_decorateTestSuitej � �z)TestDecoratorMixin.test_decorateTestSuitec C sZ | � � }t�|g�}t�|tj�}| �|t�t�|�g�� | �|t�t�|�g�� dS )zU Calling L{decorate} on a test suite will mutate the original suite. NrF rG r r r �#test_decorateInPlaceMutatesOriginalv s ��z6TestDecoratorMixin.test_decorateInPlaceMutatesOriginalc C s` t tdd�}|du rt�d��| �� }t�|g�}||�}t�|tj� ||�}| �||� dS )ac When decorating a test suite in-place, the number of references to the test objects in that test suite should stay the same. Previously, L{unittest.decorate} recreated a test suite, so the original suite kept references to the test objects. This test is here to ensure the problem doesn't reappear again. � getrefcountNz*getrefcount not supported on this platform) r0 �sysr �SkipTestr# r! rD r= r )r rK r: r �count1�count2r r r � test_decorateTestSuiteReferences� s z3TestDecoratorMixin.test_decorateTestSuiteReferencesc C sT | � � }t�t�|g�g�}t�|tj�}t�t�t�|�g�g�}| �||� dS )z� Calling L{decorate} on a test suite with nested suites will return a test suite that maintains the same structure, but with all tests decorated. NrF )r r: r r@ r2 r r r � test_decorateNestedTestSuite� s �z/TestDecoratorMixin.test_decorateNestedTestSuitec C s: | � � }t�|tj�}t�|tj�}| �|t�|�� dS )z� Calling L{decorate} on a test suite with already-decorated tests decorates all of the tests in the suite again. NrC )r r: r@ �redecoratedTestr r r �test_decorateDecoratedSuite� s z.TestDecoratorMixin.test_decorateDecoratedSuitec C s@ | � � }t�|g�}t�|tj�}| �|t�t�|�g�� dS )z� Tests can be in non-standard suites. L{decorate} preserves the non-standard suites when it decorates the tests. N)r# r �DestructiveTestSuiter rD r= r8 )r r: r � decoratedr r r �test_decoratePreservesSuite� rI z.TestDecoratorMixin.test_decoratePreservesSuiteN)r) r* r+ r, r5 r8 rA rB rE rH rJ rP rQ rS rV r r r r r- " s r- c @ r& )� SynchronousTestDecoratorTestsz� Tests for our test decoration features in the synchronous case. See L{twisted.trial.test.test_tests.TestDecoratorMixin} Nr( r r r r rW � � rW c @ r* )� AsynchronousTestDecoratorTestsz� Tests for our test decoration features in the asynchronous case. See L{twisted.trial.test.test_tests.TestDecoratorMixin} Nr, r r r r rY � rX rY c @ r- )�MonkeyPatchMixinzF Tests for the patch() helper method in L{unittest.TestCase}. c C s" d| _ d| _| j | _| �� | _dS )r0 �original�patchedN)� originalValue� patchedValue� objectToPatchr# r: r# r r r r2 � s zMonkeyPatchMixin.setUpc C s& | j �| d| j� | �| j| j� dS )zi Calling C{patch()} on a test monkey patches the specified object and attribute. r_ N)r: �patchr^ r r_ r# r r r � test_patch� s zMonkeyPatchMixin.test_patchc C s6 | j �| d| j� | j �t�� � | �| j| j� dS )zw Any monkey patches introduced by a test using C{patch()} are reverted after the test has run. r_ N) r: r` r^ r> r r� r r_ r] r# r r r �test_patchRestoredAfterRun� s z+MonkeyPatchMixin.test_patchRestoredAfterRunc C s. | j �| d| j�}|�� | �| j| j� dS )z� C{patch()} return a L{monkey.MonkeyPatcher} object that can be used to restore the original values before the end of the test. r_ N)r: r` r^ �restorer r_ r] �r r` r r r �test_revertDuringTest� s z&MonkeyPatchMixin.test_revertDuringTestc C s6 | j �| d| j�}|�� |�� | �| j| j� dS )zq The returned L{monkey.MonkeyPatcher} object can re-apply the patch during the test run. r_ N)r: r` r^ rc r r_ rd r r r �test_revertAndRepatch� s z&MonkeyPatchMixin.test_revertAndRepatchc C sd | j �| d| j� | �| j| j� | j �| dd� | �| jd� | j �t�� � | �| j| j� dS )zW Successive patches are applied and reverted just like a single patch. r_ z second valueN) r: r` r^ r r_ r> r r� r] r# r r r �test_successivePatches s z'MonkeyPatchMixin.test_successivePatchesN) r) r* r+ r, r2 ra rb re rf rg r r r r rZ � s rZ c @ r& )�SynchronousMonkeyPatchTestsz� Tests for the patch() helper method in the synchronous case. See L{twisted.trial.test.test_tests.MonkeyPatchMixin} Nr( r r r r rh rX rh c @ r* )� AsynchronousMonkeyPatchTestsz� Tests for the patch() helper method in the asynchronous case. See L{twisted.trial.test.test_tests.MonkeyPatchMixin} Nr, r r r r ri rX ri c @ r� ) �IterateTestsMixinz] L{_iterateTests} returns a list of all test cases in a test suite or test case. c C s" | � � }| �|gtt|��� dS )zj L{_iterateTests} on a single test case returns a list containing that test case. N)r# r r� r r? r r r �test_iterateTestCase) s z&IterateTestsMixin.test_iterateTestCasec C s. | � � }t�|g�}| �|gtt|��� dS )z� L{_iterateTests} on a test suite that contains a single test case returns a list containing that test case. N�r# r r! r r� r �r r: r r r r � test_iterateSingletonTestSuite1 s z0IterateTestsMixin.test_iterateSingletonTestSuitec C s6 | � � }t�t�|g�g�}| �|gtt|��� dS )zP L{_iterateTests} returns tests that are in nested test suites. Nrl rm r r r �test_iterateNestedTestSuite: s z-IterateTestsMixin.test_iterateNestedTestSuitec C s: | � � }t�t�|g�| g�}| �|| gtt|��� dS )zU L{_iterateTests} returns tests in left-to-right, depth-first order. Nrl rm r r r �#test_iterateIsLeftToRightDepthFirstB s z5IterateTestsMixin.test_iterateIsLeftToRightDepthFirstN)r) r* r+ r, rk rn ro rp r r r r rj # s rj c @ r& )� SynchronousIterateTestsTestsz� Check that L{_iterateTests} returns a list of all test cases in a test suite or test case for synchronous tests. See L{twisted.trial.test.test_tests.IterateTestsMixin} Nr( r r r r rq K r) rq c @ r* )� AsynchronousIterateTestsTestsz� Check that L{_iterateTests} returns a list of all test cases in a test suite or test case for asynchronous tests. See L{twisted.trial.test.test_tests.IterateTestsMixin} Nr, r r r r rr V r) rr c @ r )�TrialGeneratorFunctionTestsz= Tests for generator function methods in test cases. c C � G dd� dt j�}|d�}t�� }|�|� | �t|j�d� | �t|j�d� | � d|jd d j j d � | � d|jd d j j d � | � d|jd d j j d � d S ) z� In a TestCase, a test method which is a generator function is reported as an error, as such a method will never run assertions. c @ r� )zTTrialGeneratorFunctionTests.test_errorOnGeneratorFunction.<locals>.GeneratorTestCasez? A fake TestCase for testing purposes. c s � � | � d� dV dS �zt A method which is also a generator function, for testing purposes. z this should never be reachedN�r r# r r r �test_generatorq � � zcTrialGeneratorFunctionTests.test_errorOnGeneratorFunction.<locals>.GeneratorTestCase.test_generatorN�r) r* r+ r, rx r r r r �GeneratorTestCasel r� r{ rx r r5 z GeneratorTestCase.test_generatorz+GeneratorTestCase testMethod=test_generator�4is a generator function and therefore will never runN) r r# r r r> r rX r! r �assertInr� �args)r r{ �testCaser1 r r r � test_errorOnGeneratorFunctionf s" ���z9TrialGeneratorFunctionTests.test_errorOnGeneratorFunctionc C rt ) z� In a SynchronousTestCase, a test method which is a generator function is reported as an error, as such a method will never run assertions. c @ r� )zrTrialGeneratorFunctionTests.test_synchronousTestCaseErrorOnGeneratorFunction.<locals>.GeneratorSynchronousTestCasezJ A fake SynchronousTestCase for testing purposes. c s ru rv rw r# r r r rx � ry z�TrialGeneratorFunctionTests.test_synchronousTestCaseErrorOnGeneratorFunction.<locals>.GeneratorSynchronousTestCase.test_generatorNrz r r r r � GeneratorSynchronousTestCase� r� r� rx r r5 z+GeneratorSynchronousTestCase.test_generatorz6GeneratorSynchronousTestCase testMethod=test_generatorr| N) r r� r r r> r rX r! r r} r� r~ )r r� r r1 r r r �0test_synchronousTestCaseErrorOnGeneratorFunction� s$ ���zLTrialGeneratorFunctionTests.test_synchronousTestCaseErrorOnGeneratorFunctionN)r) r* r+ r, r� r� r r r r rs a s $rs )Ir, rD rL r r rB �ior �twisted.internetr r �twisted.python.compatr �twisted.python.reflectr � twisted.trialr r r �twisted.trial._asyncrunnerr r r r� r �#twisted.trial.test.test_suppressionr r r. r� rI r# rM rN rl ro rq r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r' r+ r- rW rY rZ rh ri rj rq rr rs r r r r �<module> st ;I3 X 7 7 +377X ! > ( PK Mb�ZPn�,Y ,Y 2 trial/test/__pycache__/test_loader.cpython-310.pycnu �[��� o �bXW � @ s� d Z ddlZddlZddlZddlmZ ddlmZm Z ddl m Z ddl m Z ddlmZmZmZ ddlmZ dd lmZ dd lmZ d d � ZG d d� dej�ZG dd� dej�ZG dd� dej�ZG dd� de�Z G dd� dej�Z dS )z" Tests for loading tests by name. � N)�md5)�filepath�util)� getModule)�ModuleNotFound)�reporter�runner�unittest)� _iterateTests)� ITestCase)�packagesc C s$ g }t | �D ] }|�|�� � q|S )zI Return the id of each test within the given test suite or case. )r �append�id)�tests�names�test� r �@/usr/lib/python3/dist-packages/twisted/trial/test/test_loader.py� testNames s r c s< e Zd Z� fdd�Zdd� Zdd� Zdd� Zd d � Z� ZS ) �FinderPy3Testsc s t � �� t�� | _d S �N)�super�setUpr � TestLoader�loader��self�� __class__r r r " s zFinderPy3Tests.setUpc C � | � t| jjd� dS )z� findByName, if given something findable up until the last entry, will raise AttributeError (as it cannot tell if 'nonexistent' here is supposed to be a module or a class). z twisted.trial.test.nonexistentN)� assertRaises�AttributeErrorr � findByNamer r r r �test_findNonModule& s �z!FinderPy3Tests.test_findNonModulec C � | � t| jjd� d S )N� nonextant)r r r r" r r r r �test_findNonPackage0 s z"FinderPy3Tests.test_findNonPackagec C s" t �td�}| �t| jj|� dS )z� findByName, given a file path that doesn't exist, will raise a ValueError saying that it is not a Python file. znonexistent.pyN)r �sibpath�__file__r � ValueErrorr r" )r �pathr r r �test_findNonFile3 s z FinderPy3Tests.test_findNonFilec C r )zn findByName will re-raise ImportErrors inside modules that it has found and imported. z unimportablepackage.test_moduleN)r � ImportErrorr r" r r r r � test_findFileWithImportError; s �z+FinderPy3Tests.test_findFileWithImportError) �__name__� __module__� __qualname__r r# r& r+ r- � __classcell__r r r r r ! s r c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )� FileTestsz/ Tests for L{runner.filenameToModule}. c C s$ | � ttjd�}| �t|�d� dS )zo L{runner.filenameToModule} raises a C{ValueError} when a non-existing file is passed. �itz'it' doesn't existN)r r) r �filenameToModule� assertEqual�str)r �errr r r � test_notFileJ s zFileTests.test_notFilec C s. t �t�td��}ddlm} | �||� dS )z� If the file in question is a module on the Python path, then it should properly import and return that module. z sample.pyr ��sampleN)r r4 r r' r( �twisted.trial.testr: r5 �r �sample1�sample2r r r �test_moduleInPathR s zFileTests.test_moduleInPathc C sr | � | j� t�tj�| jdd��}| �|j d� | � � | � | j � ddl m } | �||� | �|j|j� dS )a If passed the path to a file containing the implementation of a module within a package which is not on the import path, L{runner.filenameToModule} returns a module object loosely resembling the module defined by that file anyway. � goodpackageztest_sample.pyzgoodpackage.test_sampler )� test_sampleN)� mangleSysPath�oldPathr r4 �osr* �join�parentr5 r. �cleanUpModules�newPathr@ rA � assertIsNot�__spec__r< r r r �test_moduleNotInPath\ s � z FileTests.test_moduleNotInPathc C s, t �tj�| jd��}| �|tjd � dS )z� If the file in question is a package on the Python path, then it should properly import and return that package. r@ N) r r4 rD r* rE rF �assertIs�sys�modules)r �package1r r r �test_packageInPathq s z FileTests.test_packageInPathc C sl | � | j� t�tj�| jd��}| �|j d� | � � | � | j � ddl }| � ||� | �|j|j� dS )z� If passed the path to a directory which represents a package which is not on the import path, L{runner.filenameToModule} returns a module object loosely resembling the package defined by that directory anyway. r@ r N)rB rC r r4 rD r* rE rF r5 r. rG rH r@ rI rJ )r rO r@ r r r �test_packageNotInPathz s z FileTests.test_packageNotInPathc C sH t �| j��d�}|�� | �ttj|j �}| � t |�|j �d�� dS )z� L{runner.filenameToModule} raises a C{ValueError} when the name of an empty directory is passed that isn't considered a valid Python package because it doesn't contain a C{__init__.py} file. �emptyDirectoryz is not a package directoryN) r �FilePathrF �child�createDirectoryr r) r r4 r* r5 r6 )r �emptyDirr7 r r r �test_directoryNotPackage� s z"FileTests.test_directoryNotPackagec C s2 t �| j��d�}|�d� | �ttj|j � dS )zn L{runner.filenameToModule} raises a C{SyntaxError} when a non-Python file is passed. � notpythons This isn't pythonN) r rS rF rT � setContentr � SyntaxErrorr r4 r* )r �filenamer r r �test_filenameNotPython� s z FileTests.test_filenameNotPythonc C sZ t �| j��d�}|�tj�d�� zt� |j �}| � |j |j � W |� � dS |� � w )zX The C{__file__} attribute of the module should match the package name. zgoodpackage.py�utf8N)r rS rF rT rY r � testModule�encoder r4 r* r5 r( �remove)r r[ �moduler r r �test_filenameMatchesPackage� s z%FileTests.test_filenameMatchesPackagec C s� t �| j��d�}|�� |�d��d� z)t�|j�}| � |j � d�� t�|jt jj �}| � |j � d�� W |�� dS |�� w )z� Test loader against a filesystem directory containing an empty C{__init__.py} file. It should handle 'path' and 'path/' the same way. � goodDirectory� __init__.py� N)r rS rF rT rU rY r r4 r* � assertTruer. �endswithrD �sepr` )r �goodDirra r r r �test_directory� s zFileTests.test_directoryN) r. r/ r0 �__doc__r8 r? rK rP rQ rW r\ rb rj r r r r r2 E s r2 c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@S )A� LoaderTestsz( Tests for L{trial.TestLoader}. c C s t �� | _tj�| � d S r )r r r r �SysPathManglingTestr r r r r r � s zLoaderTests.setUpc s� ddl m} | j�|j�}| �g d�dd� |jD �� g d�}tt|t d���� � fdd �| j_ | j�|j�}| �|d d� |jD �� d S ) Nr r9 )�test_a�test_b�test_cc S � g | ]}|j �qS r ��_testMethodName��.0r r r r � <listcomp>� � z.LoaderTests.test_sortCases.<locals>.<listcomp>)ro rp rn � c s � � | �� d�S )N���)�get�shortDescription)�x��sortDictr r �<lambda>� s z,LoaderTests.test_sortCases.<locals>.<lambda>c S rq r rr rt r r r rv � rw ) r; r: r � loadClass� AlphabetTestr5 �_tests�dict�zip�range�sorter)r r: �suite�newOrderr r} r �test_sortCases� s � zLoaderTests.test_sortCasesc C sB | j �d�}t�� }|�|� | �|jd� | �t|j�d� dS )z{ Loading a test that fails and getting the result of it ends up with one test ran and one failure. z6twisted.trial.test.erroneous.TestRegularFail.test_fail� N) r � loadByNamer � TestResult�runr5 �testsRun�len�failures)r r� �resultr r r �test_loadFailure� s � z LoaderTests.test_loadFailurec C �J ddl m} | jj|jj|jg d�d�}| �d|�� � | �d|j� dS )z� A decorated test method for which the decorator has failed to set the method's __name__ correctly is loaded and its name in the class scope discovered. r r9 )r: �DecorationTest�test_badDecorator�rF �qualNamer� r� N) r; r: r � loadAnythingr� r� r5 �countTestCasesrs �r r: r� r r r �test_loadBadDecorator� � �z!LoaderTests.test_loadBadDecoratorc C r� )z� A decorated test method for which the decorator has set the method's __name__ correctly is loaded and the only name by which it goes is used. r r9 )r: r� �test_goodDecoratorr� r� r� N) r; r: r r� r� r� r5 r� rs r� r r r �test_loadGoodDecorator� s �z"LoaderTests.test_loadGoodDecoratorc C r� )z� Load a decorated method which has been copied to a new name inside the class. Thus its __name__ and its key in the class's __dict__ no longer match. r r9 )r: r� �test_renamedDecoratorr� r� r� N) r; r: r r� r� r� r5 r� rs r� r r r �test_loadRenamedDecorator r� z%LoaderTests.test_loadRenamedDecoratorc C sJ ddl m} | j�|j�}| �d|�� � | �ddgdd� |jD �� d S )Nr r9 � �test_bar�test_fooc S rq r rr rt r r r rv rw z.LoaderTests.test_loadClass.<locals>.<listcomp>)r; r: r r� �FooTestr5 r� r� r� r r r �test_loadClass s �zLoaderTests.test_loadClassc C s\ ddl m} | �t| jj|� | �t| jj|jj� | �t| jjd� | �t| jjd� d S �Nr r9 �string)�foo�bar)r; r: r � TypeErrorr r� r� r� �r r: r r r �test_loadNonClass s z LoaderTests.test_loadNonClassc C s$ ddl m} | �t| jj|j� d S �Nr r9 )r; r: r r) r r� �NotATestr� r r r �test_loadNonTestCase$ s z LoaderTests.test_loadNonTestCasec C s, ddl m} | j�|�}| �d|�� � d S )Nr r9 � )r; r: r � loadModuler5 r� r� r r r �test_loadModule) s zLoaderTests.test_loadModulec C �^ ddl m} | �t| jj|j� | �t| jj|jj� | �t| jjd� | �t| jjd� d S r� )r; r: r r� r r� r� r� r� r r r �test_loadNonModule/ � z LoaderTests.test_loadNonModulec C s( dd l }| j�|�}| �d|�� � d S �Nr � �r@ r � loadPackager5 r� �r r@ r� r r r �test_loadPackage7 s z LoaderTests.test_loadPackagec C r� r� )r; r: r r� r r� r� r� r� r r r �test_loadNonPackage= r� z LoaderTests.test_loadNonPackagec C s" ddl m} | �t| jj|� d S r� )r; r: r r� r r� r� r r r �test_loadModuleAsPackageE s z$LoaderTests.test_loadModuleAsPackagec C s, dd l }| jj|dd�}| �d|�� � d S �Nr T��recurse� r� r� r r r �test_loadPackageRecursiveK s z%LoaderTests.test_loadPackageRecursivec C s: ddl m} | j�|�}| �|j|jd jd jj� d S r� ) r; r: r r� r5 r. r� r r/ r� r r r �test_loadAnythingOnModuleQ s �z%LoaderTests.test_loadAnythingOnModulec C s. ddl m} | j�|j�}| �d|�� � d S )Nr r9 r� )r; r: r r� r� r5 r� r� r r r �test_loadAnythingOnClassY s z$LoaderTests.test_loadAnythingOnClassc C s< dd l }| j�|�}| �t|| jj�� | �d|�� � d S r� �r@ r r� rf � isinstance� suiteFactoryr5 r� r� r r r �test_loadAnythingOnPackage_ s z&LoaderTests.test_loadAnythingOnPackagec C s@ dd l }| jj|dd�}| �t|| jj�� | �d|�� � d S r� r� r� r r r �#test_loadAnythingOnPackageRecursivef s z/LoaderTests.test_loadAnythingOnPackageRecursivec C r$ )Nr@ )r r� r r� r r r r �test_loadAnythingOnStringm s z%LoaderTests.test_loadAnythingOnStringc C sx dd l }| jj|dd�}t�� }|�|� | �d|�� � | �dt|j �� dd� |j D �}|� � | �|dd g� d S ) Nr Tr� Fr� c S s g | ]\}}|� � �qS r )r )ru r �errorr r r rv z s z1LoaderTests.test_importErrors.<locals>.<listcomp>zpackage.test_bad_modulezpackage.test_import_module) �packager r� r �Reporterr� r5 � wasSuccessfulr� �errors�sort)r r� r� r� r� r r r �test_importErrorsr s �z LoaderTests.test_importErrorsc C sB G dd� dt j�}| j�|�}t�� }|�|� | �|�� � dS )z� L{TestLoader.loadClass} returns a suite with each test method represented by a different instances of the L{TestCase} they are defined on. c @ s e Zd Zdd� Zdd� ZdS )z>LoaderTests.test_differentInstances.<locals>.DistinctInstancesc S s d| _ d S )N�test1Run)�firstr r r r �test_1� s zELoaderTests.test_differentInstances.<locals>.DistinctInstances.test_1c S s | � t| d�� d S )Nr� )� assertFalse�hasattrr r r r �test_2� s zELoaderTests.test_differentInstances.<locals>.DistinctInstances.test_2N)r. r/ r0 r� r� r r r r �DistinctInstances� s r� N) �pyunit�TestCaser r� r r� r� rf r� )r r� r� r� r r r �test_differentInstances� s z#LoaderTests.test_differentInstancesc C �@ ddl m} | j�|�}| �d|�� � | �dt|dd�� dS )zp Check that C{test_suite} is used when present and other L{TestCase}s are not included. r )�mockcustomsuite� MyCustomSuite�nameN)r; r� r r� r5 r� �getattr)r r� r� r r r � test_loadModuleWith_test_suite� � z*LoaderTests.test_loadModuleWith_test_suitec C r� )zo Check that C{testSuite} is used when present and other L{TestCase}s are not included. r ��mockcustomsuite2r� r� N)r; r� r r� r5 r� r� )r r� r� r r r � test_loadModuleWith_testSuite� r� z)LoaderTests.test_loadModuleWith_testSuitec C s0 ddl m} | j�|�}| �dt|dd�� dS )z� Check that if C{testSuite} and C{test_suite} are both present in a module then C{testSuite} gets priority. r )�mockcustomsuite3� testSuiter� N)r; r� r r� r5 r� )r r� r� r r r � test_loadModuleWithBothCustom� s z)LoaderTests.test_loadModuleWithBothCustomc C sJ dd� }ddl m} ||j|_}z| �t| jj|� W ||_dS ||_w )zz Make sure that any C{AttributeError}s raised by C{testSuite} are not swallowed by L{TestLoader}. c S s t d��)Nzshould be reraised)r! r r r r r� � s zBLoaderTests.test_customLoadRaisesAttributeError.<locals>.testSuiter r� N)r; r� r� r r! r r� )r r� r� �originalr r r �#test_customLoadRaisesAttributeError� s z/LoaderTests.test_customLoadRaisesAttributeErrorc C s0 t |�}t |�}|�� |�� | �||� d S r )r r� r5 )r �test1�test2�names1�names2r r r �assertSuitesEqual� s z LoaderTests.assertSuitesEqualc C s4 d}| j �||gd�}| j �|d�}| �||� dS )z@ Check that loadByNames ignores duplicate names �twisted.trial.test.test_logTN)r � loadByNamesr� r� )r ra �suite1�suite2r r r �test_loadByNamesDuplicate� s z%LoaderTests.test_loadByNamesDuplicatec C s@ g d�}| j �|�}t�t| j j|��}| �t|�t|�� dS )zX L{TestLoader.loadByNames} preserves the order of tests provided to it. )�$inheritancepackage.test_x.A.test_fooztwisted.trial.test.sampler@ r� z!twisted.trial.test.sample.FooTest�package.test_moduleN)r r� r � TestSuite�mapr� r5 r �r rN r� r� r r r � test_loadByNamesPreservesOrder� s z*LoaderTests.test_loadByNamesPreservesOrderc C �8 ddg}| j �|�}t�t| j j|��}| �||� dS )zM Check that loadByNames loads all the names that it is given r@ r� N�r r� r r� r� r� r� r� r r r �test_loadDifferentNames� s z#LoaderTests.test_loadDifferentNamesc C r� )zu Check that test methods names which are inherited from are all loaded rather than just one. r� z$inheritancepackage.test_x.B.test_fooNr� )r �methodsr� r� r r r �test_loadInheritedMethods� s � z%LoaderTests.test_loadInheritedMethodsN)#r. r/ r0 rk r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r rl � sB rl c @ s e Zd Zdd� ZdS )�ZipLoadingTestsc C sN ddl m} t�| � || j| jd � | jd7 _| �| j| jg � d S )Nr )�zipitz.zip)� twisted.python.test.test_zippathr rl r rF rB rC )r r r r r r � s zZipLoadingTests.setUpN)r. r/ r0 r r r r r r � s r c @ s: e Zd Zdd� Zdd� Zejfdd�Zdd� Zd d � Z d S ) �PackageOrderingTestsc C sl t �� | _| �� | _tj�| jd�}t�|� t tj�|d�d�� � t j � | |� | �| j| jg � d S )N� uberpackagerd �wb)r r r �mktemp�topDirrD r* rE �makedirs�open�closer rm r rB rC )r rF r r r r s zPackageOrderingTests.setUpc c s� � t d�}g }|�� D ]}|j�d�d �d�r |�|� q t||d�}|D ]S}|�d�}|du r5|V q&g }|�� D ]} t � | �� �rI|�| � q;t||d�} | D ]&} g } | �� D ]} | j�d�d �d�rl| �| � qZt| |d�}|E dH qRq&dS )a� Right now, halfway by accident, trial sorts like this: 1. all modules are grouped together in one list and sorted. 2. within each module, the classes are grouped together in one list and sorted. 3. finally within each class, each test method is grouped together in a list and sorted. This attempts to return a sorted list of testable thingies following those rules, so that we can compare the behavior of loadPackage. The things that show as 'cases' are errors from modules which failed to import, and test methods. Let's gather all those together. r �.ry �test_)�keyNr ) r � walkModulesr� �split� startswithr �sorted�load�iterAttributesr � isTestCase)r r� �pkg� testModulesr^ � sortedModules�modinfora � testClasses�attrib� sortedClasses�clsinfo� testMethods�attr� sortedMethodsr r r �_trialSortAlgorithm s8 � � � � ��z(PackageOrderingTests._trialSortAlgorithmc C s� ddl }|| j_| jj|dd�}t�|t�}tt|��}t| � |��}t t ||��D ]\}\}}| � |j |�� d||j |�� f � q*| � t|�t|�� dS )zG Verify that packages are loaded in the correct order. r NTr� z #%d: %s != %s)r r r� r� r �decorater �listr r � enumerater� r5 r� r r� ) r r� r r� �resultingTests�manifest�number� manifestTest� actualTestr r r �loadSortedPackages; s ��z'PackageOrderingTests.loadSortedPackagesc C s | � � d S r �r) r r r r � test_sortPackagesDefaultOrderR s z2PackageOrderingTests.test_sortPackagesDefaultOrderc C s dd� }| � |� d S )Nc S s t �| �}t|�d���� }|S )Nr] )r r� r r_ � hexdigest)�s�n�dr r r � sillySorterV s zEPackageOrderingTests.test_sortPackagesSillyOrder.<locals>.sillySorterr* )r r0 r r r �test_sortPackagesSillyOrderU s z0PackageOrderingTests.test_sortPackagesSillyOrderN) r. r/ r0 r r r r� r) r+ r1 r r r r r s + r ) rk rD rM r r� �hashlibr �twisted.pythonr r �twisted.python.modulesr �twisted.python.reflectr � twisted.trialr r �twisted.trial._asyncrunnerr �twisted.trial.itrialr r; r r rm r r2 rl r r r r r r �<module> s( ${ > PK Mb�Z��J6�# �# / trial/test/__pycache__/test_log.cpython-310.pycnu �[��� o �bh � @ s� d Z ddlZddlmZmZ ddlmZmZ ddlm Z m Z m Z dd� Z G dd � d �Z G d d � d e j�ZG d d � d �ZG dd� dee j�ZG dd� dee j�ZdS )zG Test the interaction between trial and errors logged during test run. � N)�reactor�task)�failure�log)� _synctest�reporter�unittestc C s, zdd W | S t y t�� } Y | S w )z* Return a new, realistic failure. � r )�ZeroDivisionErrorr �Failure)�f� r �=/usr/lib/python3/dist-packages/twisted/trial/test/test_log.py� makeFailure s � �r c @ sF e Zd ZdZG dd� d�ZG dd� deej�ZG dd� deej�Z dS ) �Maskz? Hide C{MockTest}s from Trial's automatic test finder. c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) zMask.FailureLoggingMixinc C s dS )z/ Don't log any errors. Nr ��selfr r r � test_silent s z$Mask.FailureLoggingMixin.test_silentc C s t �t� � dS )z- Log a single error. N�r �errr r r r r � test_single% s z$Mask.FailureLoggingMixin.test_singlec C s t �t� � t �t� � dS )z) Log two errors. Nr r r r r � test_double+ s z$Mask.FailureLoggingMixin.test_doublec C s t �t� � dd dS )z8 Log a single error, then fail. r Nr r r r r �test_singleThenFail2 s z,Mask.FailureLoggingMixin.test_singleThenFailN)�__name__� __module__� __qualname__r r r r r r r r �FailureLoggingMixin s r c @ s e Zd ZdS )z Mask.SynchronousFailureLoggingN)r r r r r r r �SynchronousFailureLogging9 s r c @ s e Zd Zdd� ZdS )z Mask.AsynchronousFailureLoggingc C s t �tddd� �S )zC Log an error in an asynchronous callback. r c S s t �t� �S �Nr r r r r �<lambda>A s zAMask.AsynchronousFailureLogging.test_inCallback.<locals>.<lambda>)r � deferLaterr r r r r �test_inCallback= s z/Mask.AsynchronousFailureLogging.test_inCallbackN)r r r r! r r r r �AsynchronousFailureLogging< s r" N) r r r �__doc__r r �SynchronousTestCaser �TestCaser" r r r r r s r c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )� ObserverTestsz Tests for L{_synctest._LogObserver}, a helper for the implementation of L{SynchronousTestCase.flushLoggedErrors}. c C s t �� | _t�� | _d S r )r � TestResult�resultr � _LogObserver�observerr r r r �setUpJ s zObserverTests.setUpc C s0 | j �dt�� ddd�� | �| j �� g � dS )zW Test that a standard log message doesn't go anywhere near the result. )z some messager �-)�message�time�isError�systemN)r* �gotEventr. � assertEqual� getErrorsr r r r �test_msgN s ��zObserverTests.test_msgc C s< t � }| j�dt�� dd|dd�� | �| j�� |g� dS )zF Test that an observed error gets added to the result r r r, N�r- r. r/ r0 r �why)r r* r1 r. r2 r3 �r r r r r � test_error\ s �� zObserverTests.test_errorc C sL | � � | j�� }| �| j�� g � | �t|�d� | �|d �t�� dS )zS Check that flushing the observer with no args removes all errors. r r N) r8 r* � flushErrorsr2 r3 �len� assertTrue�checkr )r �flushedr r r � test_flushm s zObserverTests.test_flushc C s t �td��S )Nz test error)r r � RuntimeErrorr r r r �_makeRuntimeFailurew � z!ObserverTests._makeRuntimeFailurec C sx | � � | �� }| j�tdt�� dd|dd�� | j�t�}| �| j� � |g� | �t |�d� | � |d � t�� dS )zY Check that flushing the observer remove all failures of the given type. r r r, Nr5 r ) r8 r@ r* r1 �dictr. r9 r r2 r3 r: r; r< )r r r= r r r �test_flushByTypez s �� z ObserverTests.test_flushByTypec C sF | j �t� t� }| j �dt�� dd|dd�� | �| j �� g � dS )zS Check that C{_ignoreErrors} actually causes errors to be ignored. r r r, Nr5 )r* � _ignoreErrorsr r r1 r. r2 r3 r7 r r r �test_ignoreErrors� s �� z ObserverTests.test_ignoreErrorsc C sR | j �t� | j �� t� }| j �dt�� dd|dd�� | �| j �� |g� dS )zj Check that C{_clearIgnores} ensures that previously ignored errors get captured. r r r, Nr5 ) r* rD r � _clearIgnoresr r1 r. r2 r3 r7 r r r �test_clearIgnores� s �� z ObserverTests.test_clearIgnoresN) r r r r# r+ r4 r8 r> r@ rC rE rG r r r r r& D s r& c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�LogErrorsMixinzb High-level tests demonstrating the expected behaviour of logged errors during tests. c C s t �� | _d S r )r r' r( r r r r r+ � rA zLogErrorsMixin.setUpc C s | � t� d S r )�flushLoggedErrorsr r r r r �tearDown� rA zLogErrorsMixin.tearDownc C sf | � d�}|| j� | �t| jj�d� | �| jjd d �t�| jjd d � | �d| jj� dS )zI Test that a logged error gets reported as a test error. r r r N) �MockTestr( r2 r: �errorsr; r< r � successes�r �testr r r �test_singleError� s "�z LogErrorsMixin.test_singleErrorc C s< | � d�}|| j� | �t| jj�d� | �d| jj� dS )zf Test that when two errors get logged, they both get reported as test errors. r � r N�rK r( r2 r: rL rM rN r r r �test_twoErrors� s z LogErrorsMixin.test_twoErrorsc C sh | � d�}| � d�}|| j� || j� | �t| jj�d� | �| jjd d |� | �d| jj� dS )zT Check that an error logged in one test doesn't fail the next test. r r r r NrR �r �t1�t2r r r �test_errorsIsolated� s z"LogErrorsMixin.test_errorsIsolatedc C s� | � d�}| � d�}|| j� || j� | �t| jj�d� | �| jjd d |� | jjd d �t� | �| jjd d |� | jjd d �t� | �d| jj� dS )zN An error logged in a failed test doesn't fail the next test. r r rQ r r N) rK r( r2 r: rL �trap� TypeErrorr rM rT r r r � test_errorsIsolatedWhenTestFails� s z/LogErrorsMixin.test_errorsIsolatedWhenTestFailsc C sL t �� }| �t d|� tjjdd� }| �� }|| j� | �|tjj� dS )zE There are no extra log observers after a test runs. � _logObserverN) r r) �patchr �theLogPublisher� observersrK r( r2 )r r* r^ rO r r r �test_boundedObservers� s z$LogErrorsMixin.test_boundedObserversN) r r r r# r+ rJ rP rS rW rZ r_ r r r r rH � s rH c @ s e Zd ZejZdS )�SynchronousLogErrorsTestsN)r r r r r rK r r r r r` � s r` c @ s e Zd ZejZdd� ZdS )�AsynchronousLogErrorsTestsc C sV | � d�}|| j� | �t| jj�d� | �| jjd d �t�| jjd d � dS )zS Test that errors logged in callbacks get reported as test errors. r! r r N)rK r( r2 r: rL r; r< r rN r r r r! s "�z*AsynchronousLogErrorsTests.test_inCallbackN)r r r r r" rK r! r r r r ra s ra )r# r. �twisted.internetr r �twisted.pythonr r � twisted.trialr r r r r r$ r& rH r` r% ra r r r r �<module> s *mMPK Mb�Z|��ع � 2 trial/test/__pycache__/suppression.cpython-310.pycnu �[��� o �b� � @ sL d Z ddlZddlmZmZ dZdZdZG dd� de�Z G d d � d e�Z G d d � d e�Z G d d� d�Z G dd� de �Z G dd� d�ZG dd� d�ZG dd� de �Zejed�gZG dd� de ej�ZG dd� dee�ZG d d � d ee�ZG d d � d eej�ZG d d!� d!e ej�ZG d"d#� d#ee�ZG d$d%� d%ee�ZG d&d'� d'eej�ZdS )(z� Test cases used to make sure that warning suppression works at the module, method, and class levels. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. � N)�unittest�utilzmethod warning messagezclass warning messagezmodule warning messagec @ � e Zd ZdS )� MethodWarningN��__name__� __module__� __qualname__� r r �@/usr/lib/python3/dist-packages/twisted/trial/test/suppression.pyr � r c @ r )� ClassWarningNr r r r r r r r c @ r )� ModuleWarningNr r r r r r r r c @ s e Zd ZdZdd� ZdS )� EmitMixinz2 Mixin for emiting a variety of warnings. c C s( t �tt� t �tt� t �tt� d S �N)�warnings�warn�METHOD_WARNING_MSGr �CLASS_WARNING_MSGr �MODULE_WARNING_MSGr ��selfr r r �_emit( s zEmitMixin._emitN)r r r �__doc__r r r r r r # s r c @ sH e Zd Zejed�gZdd� Zejed�ge_dd� Zdd� Z g e _dS ) �SuppressionMixin��messagec C � | � � d S r �r r r r r �testSuppressMethod1 � z#SuppressionMixin.testSuppressMethodc C r r r r r r r �testSuppressClass6 r z"SuppressionMixin.testSuppressClassc C r r r r r r r �testOverrideSuppressClass9 r z*SuppressionMixin.testOverrideSuppressClassN) r r r r �suppressr r r r! r" r r r r r . s r c @ � e Zd Zdd� ZdS )�SetUpSuppressionMixinc C r r r r r r r �setUp@ r zSetUpSuppressionMixin.setUpN)r r r r& r r r r r% ? � r% c @ r$ )�TearDownSuppressionMixinc C r r r r r r r �tearDownE r z!TearDownSuppressionMixin.tearDownN)r r r r) r r r r r( D r' r( c @ r$ )�TestSuppression2Mixinc C r r r r r r r �testSuppressModuleJ r z(TestSuppression2Mixin.testSuppressModuleN)r r r r+ r r r r r* I r' r* r c @ r )�SynchronousTestSuppressionNr r r r r r, Q r r, c @ r )� SynchronousTestSetUpSuppressionNr r r r r r- U � r- c @ r )�"SynchronousTestTearDownSuppressionNr r r r r r/ [ r. r/ c @ r )�SynchronousTestSuppression2Nr r r r r r0 a r r0 c @ r )�AsynchronousTestSuppressionNr r r r r r1 e r r1 c @ r )� AsynchronousTestSetUpSuppressionNr r r r r r2 i r. r2 c @ r )�#AsynchronousTestTearDownSuppressionNr r r r r r3 o r. r3 c @ r )� AsynchronousTestSuppression2Nr r r r r r4 u r r4 ) r r � twisted.trialr r r r r �Warningr r r r r r% r( r* r# �SynchronousTestCaser, r- r/ r0 �TestCaser1 r2 r3 r4 r r r r �<module> s> � � � �PK Mb�Z�a1�Z �Z 0 trial/test/__pycache__/test_util.cpython-310.pycnu �[��� o �b�L � @ s d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZ dd lmZ dd lmZ dd lmZmZmZmZ G d d � d e�ZG dd� de�ZG dd� d�ZG dd� d�ZG dd� de�Z G dd� de�Z G dd� de�Z G dd� de�Z G d d � d e�Z dS ) z! Tests for L{twisted.trial.util} � N)�StringIO)� implementer)� DelayedCall)�IProcessTransport)�filepath)�Failure)�util)�SynchronousTestCase)�DirtyReactorAggregateError�_Janitor�acquireAttribute�excInfoOrFailureToExcInfoc @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � MktempTestszm Tests for L{TestCase.mktemp}, a helper function for creating temporary file or directory names. c C s8 | � � }tj�|��tj�dd� }| �|g d�� dS )z� The path name returned by C{mktemp} is directly beneath a directory which identifies the test method which created the name. N���)z twisted.trial.test.test_utilr � test_name)�mktemp�os�path�dirname�split�sep� assertEqual)�self�name�dirs� r �>/usr/lib/python3/dist-packages/twisted/trial/test/test_util.pyr $ s �zMktempTests.test_namec C s | � � }| �|| � � � dS )zF Repeated calls to C{mktemp} return different values. N)r �assertNotEqual)r r r r r � test_unique/ s zMktempTests.test_uniquec C s< | � � }tj�|�}| �tj�|�� | �tj�|�� dS )zS The directory part of the path name returned by C{mktemp} exists. N)r r r r � assertTrue�exists� assertFalse)r r r r r r � test_created6 s zMktempTests.test_createdc C s( t j�| �� �}| �|�t �� �� dS )zZ The path returned by C{mktemp} is beneath the current working directory. N)r r �abspathr r � startswith�getcwd)r r r r r � test_location? s zMktempTests.test_locationN)�__name__� __module__� __qualname__�__doc__r r r# r' r r r r r s r c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) � DirtyReactorAggregateErrorTestsz6 Tests for the L{DirtyReactorAggregateError}. c C s t ddg�}| �t|�d� dS )z5 Delayed calls are formatted nicely. �Foo�barzhReactor was unclean. DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug) Foo barN�r r �str�r �errorr r r �test_formatDelayedCallL s �z6DirtyReactorAggregateErrorTests.test_formatDelayedCallc C s" t g ddg�}| �t|�d� dS )z3 Selectables are formatted nicely. z selectable 1z selectable 2z;Reactor was unclean. Selectables: selectable 1 selectable 2Nr0 r2 r r r �test_formatSelectablesZ s �z6DirtyReactorAggregateErrorTests.test_formatSelectablesc C s& t ddgddg�}| �t|�d� dS )zR Both delayed calls and selectables can appear in the same error. �bleck�Boozo�Sel1�Sel2z�Reactor was unclean. DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug) bleck Boozo Selectables: Sel1 Sel2Nr0 r2 r r r �%test_formatDelayedCallsAndSelectablesh s �zEDirtyReactorAggregateErrorTests.test_formatDelayedCallsAndSelectablesN)r( r) r* r+ r4 r5 r: r r r r r- G s r- c @ s4 e Zd ZdZd dd�Zd dd�Zdd� Zd d � ZdS ) � StubReactora~ A reactor stub which contains enough functionality to be used with the L{_Janitor}. @ivar iterations: A list of the arguments passed to L{iterate}. @ivar removeAllCalled: Number of times that L{removeAll} was called. @ivar selectables: The value that will be returned from L{removeAll}. @ivar delayedCalls: The value to return from L{getDelayedCalls}. Nc C s$ || _ g | _d| _|s g }|| _dS )z� @param delayedCalls: See L{StubReactor.delayedCalls}. @param selectables: See L{StubReactor.selectables}. r N)� delayedCalls� iterations�removeAllCalled� selectables)r r< r? r r r �__init__� s zStubReactor.__init__c C � | j �|� dS )z/ Increment C{self.iterations}. N)r= �append)r �timeoutr r r �iterate� � zStubReactor.iteratec C s | j S )z. Return C{self.delayedCalls}. )r< �r r r r �getDelayedCalls� s zStubReactor.getDelayedCallsc C s | j d7 _ | jS )zS Increment C{self.removeAllCalled} and return C{self.selectables}. � )r> r? rF r r r � removeAll� s zStubReactor.removeAll�N)r( r) r* r+ r@ rD rG rI r r r r r; z s r; c @ � e Zd ZdZdd� Zdd� ZdS )�StubErrorReporterz� A subset of L{twisted.trial.itrial.IReporter} which records L{addError} calls. @ivar errors: List of two-tuples of (test, error) which were passed to L{addError}. c C � g | _ d S rJ )�errorsrF r r r r@ � � zStubErrorReporter.__init__c C s | j �||f� dS )z6 Record parameters in C{self.errors}. N)rN rB )r �testr3 r r r �addError� s zStubErrorReporter.addErrorN)r( r) r* r+ r@ rQ r r r r rL � s rL c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )� JanitorTestsz Tests for L{_Janitor}! c C s4 t g �}tdd|d�}|�� | �|jddg� dS )a During pending-call cleanup, the reactor will be spun twice with an instant timeout. This is not a requirement, it is only a test for current behavior. Hopefully Trial will eventually not do this kind of reactor stuff. N��reactorr )r; r � _cleanPendingr r= �r rT �janr r r � test_cleanPendingSpinsReactor� s z*JanitorTests.test_cleanPendingSpinsReactorc C sV dd� }g }t d|di |jdd� �}t|g�}tdd|d�}|�� | �||g� dS ) zW During pending-call cleanup, the janitor cancels pending timed calls. c S � dS )N�Lulzr r r r r �func� � z8JanitorTests.test_cleanPendingCancelsCalls.<locals>.func�, r c S � d S rJ r ��xr r r �<lambda>� � z<JanitorTests.test_cleanPendingCancelsCalls.<locals>.<lambda>NrS )r rB r; r rU r )r r[ � cancelled� delayedCallrT rW r r r � test_cleanPendingCancelsCalls� s z*JanitorTests.test_cleanPendingCancelsCallsc C s` t ddd� di dd� dd� dd� d�}t|�}t|g�}tdd|d �}|�� }| �||g� dS ) aK The Janitor produces string representations of delayed calls from the delayed call cleanup method. It gets the string representations *before* cancelling the calls; this is important because cancelling the call removes critical debugging information from the string representation. r] c S r^ rJ r r r r r ra � rb zIJanitorTests.test_cleanPendingReturnsDelayedCallStrings.<locals>.<lambda>r c S r^ rJ r r_ r r r ra � rb c S rY �Nr r r r r r ra � rb ��secondsNrS )r r1 r; r rU r )r rd �delayedCallStringrT rW �stringsr r r �*test_cleanPendingReturnsDelayedCallStrings� s � z7JanitorTests.test_cleanPendingReturnsDelayedCallStringsc C s0 t g �}tdd|d�}|�� | �|jd� dS )zM The Janitor will remove selectables during reactor cleanup. NrS rH )r; r � _cleanReactorr r> rV r r r �#test_cleanReactorRemovesSelectables� s z0JanitorTests.test_cleanReactorRemovesSelectablesc C sR t t�G dd� d��}|� }tg |g�}tdd|d�}|�� | �|jdg� dS )zI The Janitor will kill processes during reactor cleanup. c @ rK )zJJanitorTests.test_cleanReactorKillsProcesses.<locals>.StubProcessTransportz� A stub L{IProcessTransport} provider which records signals. @ivar signals: The signals passed to L{signalProcess}. c S rM rJ )�signalsrF r r r r@ � rO zSJanitorTests.test_cleanReactorKillsProcesses.<locals>.StubProcessTransport.__init__c S rA )zF Append C{signal} to C{self.signals}. N)rn rB )r �signalr r r � signalProcess rE zXJanitorTests.test_cleanReactorKillsProcesses.<locals>.StubProcessTransport.signalProcessN)r( r) r* r+ r@ rp r r r r �StubProcessTransport� s rq NrS �KILL)r r r; r rl r rn )r rq �ptrT rW r r r � test_cleanReactorKillsProcesses� s z,JanitorTests.test_cleanReactorKillsProcessesc C s@ G dd� d�}t g |� g�}tdd|d�}| �|�� dg� dS )z� The Janitor returns string representations of the selectables that it cleaned up from the reactor cleanup method. c @ s e Zd ZdZdefdd�ZdS )zJJanitorTests.test_cleanReactorReturnsSelectableStrings.<locals>.Selectablezl A stub Selectable which only has an interesting string representation. �returnc S rY )N� (SELECTABLE!)r rF r r r �__repr__ r\ zSJanitorTests.test_cleanReactorReturnsSelectableStrings.<locals>.Selectable.__repr__N)r( r) r* r+ r1 rw r r r r � Selectable s rx NrS rv )r; r r rl )r rx rT rW r r r �)test_cleanReactorReturnsSelectableStrings s z6JanitorTests.test_cleanReactorReturnsSelectableStringsc C sB t g �}t� }t� }t|||d�}| �|�� � | �|jg � dS )z� The post-case cleanup method will return True and not call C{addError} on the result if there are no pending calls. rS N)r; �objectrL r r �postCaseCleanupr rN �r rT rP �reporterrW r r r � test_postCaseCleanupNoErrors s z)JanitorTests.test_postCaseCleanupNoErrorsc C s� t ddd� di dd� dd� dd� d�}t|�}t|gg �}t� }t� }t|||d�}| �|�� � | �t |j �d � | �|j d d j j |g� d S ) z� The post-case cleanup method will return False and call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are pending calls. r] c S r^ rJ r r r r r ra 3 rb z=JanitorTests.test_postCaseCleanupWithErrors.<locals>.<lambda>r c S r^ rJ r r_ r r r ra 3 rb c S rY rf r r r r r ra 3 rb rg rS rH r N) r r1 r; rz rL r r" r{ r �lenrN �valuer< �r rd ri rT rP r} rW r r r � test_postCaseCleanupWithErrors, s � z+JanitorTests.test_postCaseCleanupWithErrorsc C s< t g �}t� }t� }t|||d�}|�� | �|jg � dS )z� The post-class cleanup method will not call C{addError} on the result if there are no pending calls or selectables. rS N)r; rz rL r �postClassCleanupr rN r| r r r � test_postClassCleanupNoErrors> s z*JanitorTests.test_postClassCleanupNoErrorsc C s� t ddd� di dd� dd� dd� d�}t|�}t|gg �}t� }t� }t|||d�}|�� | �t|j �d � | �|j d d j j |g� d S ) z� The post-class cleanup method call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are pending calls. r] c S r^ rJ r r r r r ra P rb zIJanitorTests.test_postClassCleanupWithPendingCallErrors.<locals>.<lambda>r c S r^ rJ r r_ r r r ra P rb c S rY rf r r r r r ra P rb rg rS rH r N) r r1 r; rz rL r r� r r rN r� r< r� r r r �*test_postClassCleanupWithPendingCallErrorsJ s � z7JanitorTests.test_postClassCleanupWithPendingCallErrorsc C sh d}t g |g�}t� }t� }t|||d�}|�� | �t|j�d� | �|jd d jj t |�g� dS )z� The post-class cleanup method call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are selectables. zSELECTABLE HERErS rH r N) r; rz rL r r� r r rN r� r? �repr)r � selectablerT rP r} rW r r r �)test_postClassCleanupWithSelectableErrors[ s $z6JanitorTests.test_postClassCleanupWithSelectableErrorsN)r( r) r* r+ rX re rk rm rt ry r~ r� r� r� r� r r r r rR � s rR c @ r, ) �RemoveSafelyTestsz* Tests for L{util._removeSafely}. c C s8 | � � �d�}t�|� t�|�}| �tjtj |� dS )z� If a path doesn't contain a node named C{"_trial_marker"}, that path is not removed by L{util._removeSafely} and a L{util._NoTrialMarker} exception is raised instead. �utf-8N) r �encoder �mkdirr �FilePath� assertRaisesr �_NoTrialMarker� _removeSafely)r � directory�dirPathr r r � test_removeSafelyNoTrialMarkero s z0RemoveSafelyTests.test_removeSafelyNoTrialMarkerc C sp dd� }t � }| �td|� | �� �d�}t�|� t�|�}|� d�� � ||_ t � |� | �d|�� � dS )z� If an L{OSError} is raised while removing a path in L{util._removeSafely}, an attempt is made to move the path to a new name. c S s t � �)�� Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path removal fails. ��OSErrorr r r r � dummyRemove� s zORemoveSafelyTests.test_removeSafelyRemoveFailsMoveSucceeds.<locals>.dummyRemove�stdoutr� � _trial_marker�could not remove FilePathN)r �patch�sysr r� r r� r r� �child�touch�remover r� �assertIn�getvalue)r r� �outr� r� r r r �(test_removeSafelyRemoveFailsMoveSucceedsz s z:RemoveSafelyTests.test_removeSafelyRemoveFailsMoveSucceedsc C s� dd� }dd� }t � }| �td|� | �� �d�}t�|� t�|�}|� d�� � ||_ ||_ | � ttj|�}| �t|�d� | �d |�� � d S ) z� If an L{OSError} is raised while removing a path in L{util._removeSafely}, an attempt is made to move the path to a new name. If that attempt fails, the L{OSError} is re-raised. c S � t d��)r� zpath removal failedr� r r r r r� � � zLRemoveSafelyTests.test_removeSafelyRemoveFailsMoveFails.<locals>.dummyRemovec S r� )z� Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path movement fails. �path movement failedr� )r r r r � dummyMoveTo� r� zLRemoveSafelyTests.test_removeSafelyRemoveFailsMoveFails.<locals>.dummyMoveTor� r� r� r� r� N)r r� r� r r� r r� r r� r� r� r� �moveTor� r� r r� r r1 r� r� )r r� r� r� r� r� r3 r r r �%test_removeSafelyRemoveFailsMoveFails� s z7RemoveSafelyTests.test_removeSafelyRemoveFailsMoveFailsN)r( r) r* r+ r� r� r� r r r r r� j s r� c @ rK )� ExcInfoTestsz1 Tests for L{excInfoOrFailureToExcInfo}. c C s$ t t d�df}| �|t|�u � dS )z� L{excInfoOrFailureToExcInfo} returns exactly what it is passed, if it is passed a tuple like the one returned by L{sys.exc_info}. �fooN)� ValueErrorr r )r �infor r r � test_excInfo� s zExcInfoTests.test_excInfoc C sF zdd W n t y t� }Y nw | �|j|j|jft|�� dS )z� When called with a L{Failure} instance, L{excInfoOrFailureToExcInfo} returns a tuple like the one returned by L{sys.exc_info}, with the elements taken from the type, value, and traceback of the failure. rH r N)� BaseExceptionr r �typer� �tbr )r �fr r r � test_failure� s � zExcInfoTests.test_failureN)r( r) r* r+ r� r� r r r r r� � s r� c @ r ) �AcquireAttributeTestsz( Tests for L{acquireAttribute}. c C s* t � | _}| �|t| t � gd�u � dS )z� The value returned by L{acquireAttribute} is the value of the requested attribute on the first object in the list passed in which has that attribute. r� N�rz r� r r �r r� r r r �test_foundOnEarlierObject� s z/AcquireAttributeTests.test_foundOnEarlierObjectc C s* t � | _}| �|tt � | gd�u � dS )z� The same as L{test_foundOnEarlierObject}, but for the case where the 2nd element in the object list has the attribute and the first does not. r� Nr� r� r r r �test_foundOnLaterObject� s z-AcquireAttributeTests.test_foundOnLaterObjectc C s | � ttt� gd� dS )z� If none of the objects passed in the list to L{acquireAttribute} have the requested attribute, L{AttributeError} is raised. r� N)r� �AttributeErrorr rz rF r r r �test_notFoundException� s z,AcquireAttributeTests.test_notFoundExceptionc C s$ t � }| �|tt � gd|�u � dS )z� If none of the objects passed in the list to L{acquireAttribute} have the requested attribute and a default value is given, the default value is returned. r� N)rz r r )r �defaultr r r �test_notFoundDefault� s z*AcquireAttributeTests.test_notFoundDefaultN)r( r) r* r+ r� r� r� r� r r r r r� � s r� c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�ListToPhraseTestsz� Input is transformed into a string representation of the list, with each item separated by delimiter (defaulting to a comma) and the final two being separated by a final delimiter. c C s$ g }d}t �|d�}| �||� dS )zB If things is empty, an empty string is returned. � �andN�r � _listToPhraser �r �sample�expected�resultr r r � test_empty s z ListToPhraseTests.test_emptyc C s& dg}d}t �|d�}| �||� dS )z; With a single item, the item is returned. �Oner� Nr� r� r r r � test_oneWord s z ListToPhraseTests.test_oneWordc C s( ddg}d}t �|d�}| �||� dS )zA Two words are separated by the final delimiter. r� �Twoz One and Twor� Nr� r� r r r � test_twoWords � z ListToPhraseTests.test_twoWordsc C �( g d�}d}t �|d�}| �||� dS )zY With more than two words, the first two are separated by the delimiter. )r� r� �ThreezOne, Two, and Threer� Nr� r� r r r �test_threeWords" r� z!ListToPhraseTests.test_threeWordsc C s, g d�}d}t j|ddd�}| �||� dS )zW If a delimiter is specified, it is used instead of the default comma. )r� r� r� �FourzOne; Two; Three; or Four�orz; )� delimiterNr� r� r r r �test_fourWords+ s z ListToPhraseTests.test_fourWordsc C r� )zS If something in things is not a string, it is converted into one. )rH � �threez1, 2, and threer� Nr� r� r r r �test_notString4 r� z ListToPhraseTests.test_notStringc C s* d}| � ttj|d�}| �t|�d� dS )z? If things is a string, a TypeError is raised. zOne, two, threer� � Things must be a list or a tupleN�r� � TypeErrorr r� r r1 �r r� r3 r r r �test_stringTypeError= s z&ListToPhraseTests.test_stringTypeErrorc C s2 t g d��}| �ttj|d�}| �t|�d� dS )zB If things is an iterator, a TypeError is raised. )rH r� � r� r� N)�iterr� r� r r� r r1 r� r r r �test_iteratorTypeErrorE s z(ListToPhraseTests.test_iteratorTypeErrorc C s. dd� }| � ttj|d�}| �t|�d� dS )zB If things is a generator, a TypeError is raised. c s s � t d�E d H d S )Nr� )�ranger r r r r� R s �z9ListToPhraseTests.test_generatorTypeError.<locals>.sampler� r� Nr� r� r r r �test_generatorTypeErrorM s z)ListToPhraseTests.test_generatorTypeErrorN) r( r) r* r+ r� r� r� r� r� r� r� r� r� r r r r r� s r� )!r+ r r� �ior �zope.interfacer �twisted.internet.baser �twisted.internet.interfacesr �twisted.pythonr �twisted.python.failurer � twisted.trialr �twisted.trial.unittestr �twisted.trial.utilr r r r r r- r; rL rR r� r� r� r� r r r r �<module> s, )3+ 3U'PK Mb�Z�w��� � 6 trial/test/__pycache__/mockcustomsuite.cpython-310.pycnu �[��� o �b � @ s2 d Z ddlmZmZ G dd� dej�Zdd� ZdS )z� Mock test module that contains a C{test_suite} method. L{runner.TestLoader} should load the tests from the C{test_suite}, not from the C{Foo} C{TestCase}. See {twisted.trial.test.test_loader.LoaderTest.test_loadModuleWith_test_suite}. � )�runner�unittestc @ s e Zd Zdd� ZdS )�Fooc C s d S )N� )�selfr r �D/usr/lib/python3/dist-packages/twisted/trial/test/mockcustomsuite.py�test_foo s z Foo.test_fooN)�__name__� __module__� __qualname__r r r r r r s r c C s t �� } d| _| S )N� MyCustomSuite)r � TestSuite�name)�tsr r r � test_suite s r N)�__doc__� twisted.trialr r �SynchronousTestCaser r r r r r �<module> s PK Mb�Z� �e e 0 trial/test/__pycache__/test_skip.cpython-310.pycnu �[��� o �b[ � @ s� d Z ddlmZ ddlmZ edd�G dd� de��Zedd�G d d � d e��ZG d d � d e�ZG d d� de�ZG dd� de�Z dS )z! Tests for L{twisted.trial.util} � )�skipIf)�TestCaseTz.Skip all tests when @skipIf is used on a classc @ � e Zd ZdZdd� Zdd� ZdS )�SkipDecoratorUsedOnClasszZ All tests should be skipped because @skipIf decorator is used on this class. c C � t d���Nz%Test should skip and never reach here�� Exception��self� r �>/usr/lib/python3/dist-packages/twisted/trial/test/test_skip.py�test_shouldNeverRun_1 � z.SkipDecoratorUsedOnClass.test_shouldNeverRun_1c C r r r r r r r �test_shouldNeverRun_2 r z.SkipDecoratorUsedOnClass.test_shouldNeverRun_2N��__name__� __module__� __qualname__�__doc__r r r r r r r � r � c @ r )�'SkipDecoratorUsedOnClassWithEmptyReasonz� All tests should be skipped because @skipIf decorator is used on this class, even if the reason is an empty string c C r r r r r r r r # r z=SkipDecoratorUsedOnClassWithEmptyReason.test_shouldNeverRun_1c C r r r r r r r r & r z=SkipDecoratorUsedOnClassWithEmptyReason.test_shouldNeverRun_2Nr r r r r r r r c @ s` e Zd ZdZedd�dd� �Zedd�dd� �Zd d � Zed d �d d� �Zed d�dd� �Z dS )�SkipDecoratorUsedOnMethods�I Only methods where @skipIf decorator is used should be skipped. Tz"skipIf decorator used so skip testc C r r r r r r r �test_shouldNeverRun/ � z.SkipDecoratorUsedOnMethods.test_shouldNeverRunr c C r r r r r r r �"test_shouldNeverRunWithEmptyReason3 r z=SkipDecoratorUsedOnMethods.test_shouldNeverRunWithEmptyReasonc C � | � dd� d S �NTz"Test should run and not be skipped�� assertTruer r r r �test_shouldShouldRun7 � z/SkipDecoratorUsedOnMethods.test_shouldShouldRunFzshould not skipc C r r r r r r r �#test_shouldShouldRunWithSkipIfFalse: � z>SkipDecoratorUsedOnMethods.test_shouldShouldRunWithSkipIfFalsec C r r r r r r r �.test_shouldShouldRunWithSkipIfFalseEmptyReason> r% zISkipDecoratorUsedOnMethods.test_shouldShouldRunWithSkipIfFalseEmptyReasonN) r r r r r r r r" r$ r& r r r r r * s r c @ s$ e Zd ZdZdZdd� Zdd� ZdS )�SkipAttributeOnClasszV All tests should be skipped because skip attribute is set on this class. z5'skip' attribute set on this class, so skip all testsc C r r r r r r r �test_oneK r z SkipAttributeOnClass.test_onec C r r r r r r r �test_twoN r z SkipAttributeOnClass.test_twoN)r r r r �skipr( r) r r r r r' C s r' c @ s& e Zd ZdZdd� Zde_dd� ZdS )�SkipAttributeOnMethodsr c C r )NzShould never reach herer r r r r r( W r z SkipAttributeOnMethods.test_onez'skip test, skip attribute set on methodc C r r r r r r r �test_shouldNotSkip\ r# z)SkipAttributeOnMethods.test_shouldNotSkipN)r r r r r( r* r, r r r r r+ R s r+ N) r �unittestr �twisted.trial.unittestr r r r r' r+ r r r r �<module> s PK Mb�Zj���d! d! . trial/test/__pycache__/detests.cpython-310.pycnu �[��� o �b# � @ s� d Z ddlmZmZmZ ddlmZ ddlmZ ddl m Z G dd� dej �Z G dd � d ej �ZG d d � d ej �ZG d d � d ej �ZG dd� dej �ZG dd� dej �ZG dd� dej �ZG dd� dej �ZG dd� dej �ZdS )zD Tests for Deferred handling by L{twisted.trial.unittest.TestCase}. � )�defer�reactor�threads)�runWithWarningsSuppressed)�unittest)�suppressc @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�DeferredSetUpOKc C � t �d�}|�| j� |S �N�value�r �succeed� addCallback�_cb_setUpCalled��self�d� r �</usr/lib/python3/dist-packages/twisted/trial/test/detests.py�setUp � zDeferredSetUpOK.setUpc C s d| _ d S �NT)� _setUpCalled�r �ignoredr r r r � z DeferredSetUpOK._cb_setUpCalledc C s | � | j� d S �N)� assertTruer �r r r r �test_ok � zDeferredSetUpOK.test_okN)�__name__� __module__� __qualname__r r r r r r r r s r c @ � e Zd ZdZdd� Zdd� ZdS )�DeferredSetUpFailFc C s t �t�d��S )Nzi fail)r �failr �FailTestr r r r r r zDeferredSetUpFail.setUpc C s dt _| �d� d S )NTzI should not get called)r% � testCalledr& r r r r r " s zDeferredSetUpFail.test_okN�r! r" r# r( r r r r r r r% � r% c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �DeferredSetUpCallbackFailFc C r r r r r r r r * r z DeferredSetUpCallbackFail.setUpc C s | � d� d S )Nzdeliberate failure�r& r r r r r / � z)DeferredSetUpCallbackFail._cb_setUpCalledc C � dt _d S r )r, r( r r r r r 2 r z!DeferredSetUpCallbackFail.test_okN)r! r" r# r( r r r r r r r r, ' � r, c @ r$ )�DeferredSetUpErrorFc C s t �td��S )Nzdeliberate error)r r& � RuntimeErrorr r r r r 9 r. zDeferredSetUpError.setUpc C r/ r )r1 r( r r r r r < r zDeferredSetUpError.test_okNr) r r r r r1 6 r* r1 c @ r$ )�DeferredSetUpNeverFireFc C � t �� S r �r �Deferredr r r r r C � z DeferredSetUpNeverFire.setUpc C r/ r )r3 r( r r r r r F r z DeferredSetUpNeverFire.test_okNr) r r r r r3 @ r* r3 c @ r+ ) �DeferredSetUpSkipFc C r r )r r r �_cb1r r r r r M r zDeferredSetUpSkip.setUpc C s t �d��)Nzskip me�r �SkipTestr r r r r9 R r zDeferredSetUpSkip._cb1c C r/ r )r8 r( r r r r r U r zDeferredSetUpSkip.test_okN)r! r" r# r( r r9 r r r r r r8 J r0 r8 c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z e e dd�ge je �Z e jdd� �Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd e_d!S )"� DeferredTestsFc C s | � |� d S r r- �r �reasonr r r �_cb_fail\ r. zDeferredTests._cb_failc C s t |��r )r2 r= r r r � _cb_error_ r7 zDeferredTests._cb_errorc C s t �|��r r: r= r r r �_cb_skipb r zDeferredTests._cb_skipc C � d| j _d S r �� __class__�touchedr r r r � _touchClasse � zDeferredTests._touchClassc C rB )NFrC r r r r r h rG zDeferredTests.setUpc C s t �d�S )N�success)r r r r r r � test_passk r zDeferredTests.test_passc c s � | � d � d V d S r �rF r r r r �test_passGeneratedn s � z DeferredTests.test_passGeneratedz7twisted.internet.defer.deferredGenerator was deprecated)�messagec c s � | � d� dV dS )zL Test case that is decorated with L{defer.inlineCallbacks}. NrJ r r r r �test_passInlineCallbacks| s � z&DeferredTests.test_passInlineCallbacksc C s t �| �d��S )NzI fail)r r& �failureExceptionr r r r � test_fail� r zDeferredTests.test_failc C r )Nr& )r r r r? r r r r �test_failureInCallback� r z$DeferredTests.test_failureInCallbackc C r )N�error�r r r r@ r r r r �test_errorInCallback� r z"DeferredTests.test_errorInCallbackc C s& t �d�}|�| j� |�| j� |S )N�skip)r r r rA rF r r r r � test_skip� s zDeferredTests.test_skipc C s t �dd� �S )Nc S s d S r r r r r r �<lambda>� s z+DeferredTests.test_thread.<locals>.<lambda>)r � deferToThreadr r r r � test_thread� r. zDeferredTests.test_threadc C r )N�todorR r r r r �test_expectedFailure� r z"DeferredTests.test_expectedFailurezExpected failureN)r! r" r# rE r? r@ rA rF r rI rK r �SUPPRESSr �deferredGenerator�inlineCallbacksrM rO rP rS rU rX rZ rY r r r r r< Y s4 ��� r< c @ s� e Zd ZdZdd� Zde_dd� Zdd� Zd e_d d � Zd e_d d� Z d e _de _ dd� Z d e _de _ dd� Z d e _dd� Zd e_dS )� TimeoutTestsNc C � t �� }t�d|jd� |S �Nr zhoorj!�r r6 r � callLater�callbackr r r r rI � s zTimeoutTests.test_pass� c C r_ r` ra r r r r �test_passDefault� s z TimeoutTests.test_passDefaultc C r4 r r5 r r r r � test_timeout� r7 zTimeoutTests.test_timeoutg�������?c C r4 r r5 r r r r �test_timeoutZero� r7 z TimeoutTests.test_timeoutZeror c C r4 r r5 r r r r rZ � r7 z!TimeoutTests.test_expectedFailurez i will get it right, eventuallyc C r4 r r5 r r r r rU � r7 zTimeoutTests.test_skipc s" � fdd�}t �� }|�|� |S )Nc s | � j _| S r )rD �timedOut)�errr r r rh � s z4TimeoutTests.test_errorPropagation.<locals>.timedOut)r r6 � addErrback)r rh r r r r �test_errorPropagation� s z"TimeoutTests.test_errorPropagationc C s( t �� }dd� }|�|� |�d� |S )Nc S r4 r r5 )�rr r r � neverFire� r7 z;TimeoutTests.test_calledButNeverCallback.<locals>.neverFire� )r r6 r rc )r r rm r r r �test_calledButNeverCallback� s z(TimeoutTests.test_calledButNeverCallback)r! r" r# rh rI �timeoutre rf rg rZ rY rU rT rk ro r r r r r^ � s& r^ c @ r$ )�TestClassTimeoutAttributeg�������?c C s t �� | _d S r )r r6 r r r r r r � r. z TestClassTimeoutAttribute.setUpc C s d| _ | jS r )� methodCalledr r r r r � testMethod� s z$TestClassTimeoutAttribute.testMethodN)r! r" r# rp r rs r r r r rq � r* rq N)�__doc__�twisted.internetr r r �twisted.python.utilr � twisted.trialr �twisted.trial.utilr r[ �TestCaser r% r, r1 r3 r8 r< r^ rq r r r r �<module> s I>PK Mb�Z���� � 2 trial/test/__pycache__/test_output.cpython-310.pycnu �[��� o �b� � @ s^ d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z dZ dd � Z G d d � d e j �Z dS ) z* Tests for the output generated by trial. � N)�StringIO)�trial)�runner)�packageszNo module named 'frotz'c G sV ddl m} t�� }|�| � t� }tj|j||d d�}t� |�}|� |� |� � S )Nr )�reporterztemp-directory)�stream�workingDirectory) � twisted.trialr r �Options� parseOptionsr r � TrialRunner�VerboseTextReporter� _getSuite�run�getvalue)�argsr �config�output�myRunner�suite� r �@/usr/lib/python3/dist-packages/twisted/trial/test/test_output.py�runTrial s � r c s� e Zd ZdZdd� ZdZdd� Zdd� Z� fd d �Z� fd d �Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Z� ZS ))�ImportErrorsTestszbActually run trial as if on the command line and check that the output is what we expect. c C s d S �Nr ��selfr r r �debug( s zImportErrorsTests.debug�_testImportErrorsc G s t d| �� g|�R � S )Nz--temp-directory)r �mktemp)r r r r r r - s zImportErrorsTests.runTrialc C s t |� |S r )�print)r �stuffr r r �_print0 s zImportErrorsTests._printc � t � j||g|�R i |�� |S r )�super�assertIn�r � container� containeer �kwargs�� __class__r r r% 4 � zImportErrorsTests.assertInc r# r )r$ � assertNotInr& r* r r r- 9 r, z ImportErrorsTests.assertNotInc C s | � � d S r )r r r r r � test_trialRun> s z ImportErrorsTests.test_trialRunc C s& | � d�}| �|d� | �|d� |S )Nztwisted.doesntexist�[ERROR]�r r% �r �dr r r �test_nonexistentModuleA s z(ImportErrorsTests.test_nonexistentModulec C �2 | � d�}| �|d� | �|d� | �|d� |S )N� doesntexist�ModuleNotFoundr/ r0 r1 r r r �test_nonexistentPackageG � z)ImportErrorsTests.test_nonexistentPackagec C r4 )Nzdoesntexist.barney�ObjectNotFoundr/ r0 r1 r r r �!test_nonexistentPackageWithModuleN r8 z3ImportErrorsTests.test_nonexistentPackageWithModulec C �2 | � d�}| �|d� | �|d� | �|d� |S )N� badpackager/ �IOError�r r% r- r1 r r r �test_badpackageU r8 z!ImportErrorsTests.test_badpackagec C r; )Nzbadpackage.test_moduler/ r= r> r1 r r r �test_moduleInBadpackage\ r8 z)ImportErrorsTests.test_moduleInBadpackagec C �> | � d�}| �|d� | �|d� | �|d� | �|d� |S )Nzpackage.test_bad_moduler/ r= �<module r> r1 r r r �test_badmodulec � z ImportErrorsTests.test_badmodulec C rA )Nzpackage.test_import_moduler/ r= rB r> r1 r r r �test_badimportk rD z ImportErrorsTests.test_badimportc C sJ | � d�}| �|d� | �|d� | �|d� | �|d� | �|d� |S )N�packager/ �test_bad_module�test_import_modulerB r= r> r1 r r r �test_recurseImports s z$ImportErrorsTests.test_recurseImportc C sV | � d�}| �|d� | �|d� | �|d� | �|t� | �|d� | �|d� |S )N�package2r/ � test_modulerB r= �r r% �_noModuleErrorr- r1 r r r �test_recurseImportErrors| s z*ImportErrorsTests.test_recurseImportErrorsc C s4 | � dd�}| �|d� | �|t� | �|d� |S )Nz-NrJ r/ rB rL r1 r r r �test_nonRecurseImportErrors� s z-ImportErrorsTests.test_nonRecurseImportErrorsc C s> | � d�}| �|d� | �|d� | �|d� | �|d� |S )Nzpackage.test_moduler/ r= �OK�PASSED (successes=1))r r- r% r1 r r r �test_regularRun� rD z!ImportErrorsTests.test_regularRunc C �X | � | j� | �tj�| jdd��}| �|d� | �|d� | �|d� | �|d� |S )NrF ztest_module.pyr/ r= rP rQ � � mangleSysPath�oldPathr �os�path�join�parentr- r% r1 r r r � test_filename� s z ImportErrorsTests.test_filenamec C rS )NrF ztest_dos_module.pyr/ r= rP rQ rT r1 r r r � test_dosFile� s z ImportErrorsTests.test_dosFile)�__name__� __module__� __qualname__�__doc__r rZ r r" r% r- r. r3 r7 r: r? r@ rC rE rI rN rO rR r[ r\ � __classcell__r r r* r r # s, r )r` rW �ior �twisted.scriptsr r r �twisted.trial.testr rM r �SysPathManglingTestr r r r r �<module> s PK Mb�Z�Ḧ́� � 7 trial/test/__pycache__/mockcustomsuite2.cpython-310.pycnu �[��� o �b � @ s2 d Z ddlmZmZ G dd� dej�Zdd� ZdS )z� Mock test module that contains a C{testSuite} method. L{runner.TestLoader} should load the tests from the C{testSuite}, not from the C{Foo} C{TestCase}. See L{twisted.trial.test.test_loader.LoaderTest.test_loadModuleWith_testSuite}. � )�runner�unittestc @ s e Zd Zdd� ZdS )�Fooc C s d S )N� )�selfr r �E/usr/lib/python3/dist-packages/twisted/trial/test/mockcustomsuite2.py�test_foo s z Foo.test_fooN)�__name__� __module__� __qualname__r r r r r r s r c C s t �� } d| _| S )N� MyCustomSuite)r � TestSuite�name)�tsr r r � testSuite s r N)�__doc__� twisted.trialr r �SynchronousTestCaser r r r r r �<module> s PK Mb�Zz��X}E }E 3 trial/test/__pycache__/test_warning.cpython-310.pycnu �[��� o �b�D � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z m Z ddl m Z G dd � d �ZG d d � d e �ZG d d � d e�ZG dd� de �ZdS )z? Tests for Trial's interaction with the Python warning system. � N)�StringIO)� TestResult)�FilePath)�_collectWarnings�_setWarningRegistryToNone)�SynchronousTestCasec @ s e Zd ZdZG dd� de�ZdS )�MaskzQ Hide a test case definition from trial's automatic discovery mechanism. c @ s( e Zd ZdZdZeZdd� Zdd� ZdS )zMask.MockTestsz� A test case which is used by L{FlushWarningsTests} to verify behavior which cannot be verified by code inside a single test method. �some warning textc C s t �| j| j� dS )z@ Generate a warning and don't flush it. N)�warnings�warn�message�category��self� r �A/usr/lib/python3/dist-packages/twisted/trial/test/test_warning.py�test_unflushed! s z Mask.MockTests.test_unflushedc C s( t �| j| j� | �t| �� �d� dS )z: Generate a warning and flush it. � N)r r r r � assertEqual�len� flushWarningsr r r r � test_flushed' s zMask.MockTests.test_flushedN) �__name__� __module__� __qualname__�__doc__r � UserWarningr r r r r r r � MockTests s r N)r r r r r r r r r r r s r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$S )%�FlushWarningsTestsze Tests for C{flushWarnings}, an API for examining the warnings emitted so far in a test. c C s& |� � D ] \}}| �|| |� qdS )z� Assert that all the keys present in C{subset} are also present in C{set} and that the corresponding values are equal. N)�itemsr )r �set�subset�k�vr r r �assertDictSubset5 s �z#FlushWarningsTests.assertDictSubsetc C s8 | � t|�t|�� t||�D ] \}}| �||� qdS )z� For each pair of corresponding elements in C{sets} and C{subsets}, assert that the element from C{subsets} is a subset of the element from C{sets}. N)r r �zipr$ )r �sets�subsets�a�br r r �assertDictSubsets= s �z$FlushWarningsTests.assertDictSubsetsc C s | � | �� g � dS )zg If no warnings are emitted by a test, C{flushWarnings} returns an empty list. N)r r r r r r � test_noneG s z FlushWarningsTests.test_nonec C sP d}t }tj||d� d}t}tj||d� | �| �� ||d�||d�g� dS )z| If several warnings are emitted by a test, C{flushWarnings} returns a list containing all of them. zfirst warning message�r r zsecond warning message�r r N)r r r �RuntimeWarningr* r )r � firstMessage� firstCategory� secondMessage�secondCategoryr r r � test_severalN s ��z FlushWarningsTests.test_severalc C sD d}t }td�D ] }tj||d� q| �| �� ||d�gd � dS )z� The same warning triggered twice from the same place is included twice in the list returned by C{flushWarnings}. � the message� r, r- N)r. �ranger r r* r )r r r �ir r r � test_repeatedc s �z FlushWarningsTests.test_repeatedc C sB d}t }tj||d� | �| �� ||d�g� | �| �� g � dS )z� After a particular warning event has been returned by C{flushWarnings}, it is not returned by subsequent calls. r4 r, r- N)r. r r r* r r )r r r r r r � test_clearedq s �z FlushWarningsTests.test_clearedc C s� t � }t�d�}|�|� | �tjjg�}| �|d d d� | �|d d t� t |�jj }|j }|j d }| �|d d |� | �|d d |� | �t |�d � d S ) zx Any warnings emitted by a test which are not flushed are emitted to the Python warning system. r r r r r � �filename�linenor N)r r r �runr r r �assertIdenticalr �type�__code__� co_filename�co_firstlinenor )r �result�case� warningsShown�wherer; r< r r r r ~ s z!FlushWarningsTests.test_unflushedc C sJ t � }t�d�}t� }| �td|�}|�|� |�� | �|� � d� dS )zx Any warnings emitted by a test which are flushed are not emitted to the Python warning system. r �stdout� N) r r r r �patch�sysr= �restorer �getvalue)r rC rD �output�monkeyr r r r � s z FlushWarningsTests.test_flushedc C s� G dd� dt �}t� }t�d�}||_tjdd� }z9t�d� |�|� | � t |j �d� | � |j d d |� | � |j d d �� d �d �� W |tjdd�< dS |tjdd�< w ) z� If a warnings filter has been installed which turns warnings into exceptions, tests have an error added to the reporter for them for each unflushed warning. c @ � e Zd ZdS )zIFlushWarningsTests.test_warningsConfiguredAsErrors.<locals>.CustomWarningN�r r r r r r r � CustomWarning� � rQ r N�errorr r ���z CustomWarning: some warning text)�Warningr r r r r �filters� simplefilterr= r r �errorsr> � assertTrue� splitlines�endswith�r rQ rC rD �originalWarningsr r r � test_warningsConfiguredAsErrors� s" ��"z2FlushWarningsTests.test_warningsConfiguredAsErrorsc C s| G dd� dt �}t� }t�d�}||_tjdd� }zt�d� |�|� | � |j g � W |tjdd�< dS |tjdd�< w )z� If a warnings filter has been installed which turns warnings into exceptions, tests which emit those warnings but flush them do not have an error added to the reporter. c @ rO )zPFlushWarningsTests.test_flushedWarningsConfiguredAsErrors.<locals>.CustomWarningNrP r r r r rQ � rR rQ r NrS ) rU r r r r r rV rW r= r rX r\ r r r �&test_flushedWarningsConfiguredAsErrors� s "z9FlushWarningsTests.test_flushedWarningsConfiguredAsErrorsc C s@ t �d� | �t| �� �d� t �d� | �t| �� �d� dS )z� Any warnings emitted after a call to C{flushWarnings} can be flushed by another call to C{flushWarnings}. z first messager zsecond messageN)r r r r r r r r r �test_multipleFlushes� s z'FlushWarningsTests.test_multipleFlushesc sx d�t � � �fdd�}d�t���fdd�}|� |� | �| j|gd�� �d�g� | �| j|gd���d�g� d S ) z� The list returned by C{flushWarnings} includes only those warnings which refer to the source of the function passed as the value for C{offendingFunction}, if a value is passed for that parameter. zfirst warning textc � t j�� dd� d S �Nr )� stacklevel�r r r )r0 r/ r r �one� � z>FlushWarningsTests.test_filterOnOffendingFunction.<locals>.onez some textc ra rb rd r )r2 r1 r r �two� rf z>FlushWarningsTests.test_filterOnOffendingFunction.<locals>.two��offendingFunctionsr- N)r r. r* r )r re rg r )r0 r/ r2 r1 r � test_filterOnOffendingFunction� s � �z1FlushWarningsTests.test_filterOnOffendingFunctionc C s, dd� }|� | � t| j|gd��d� dS )z� Verify that warnings emitted at the very edges of a function are still determined to be emitted from that function. c S s" t �d� t �d� t �d� d S )Nzfirst line warningzinternal line warningzlast line warningrd r r r r �warner s z:FlushWarningsTests.test_functionBoundaries.<locals>.warnerrh � N�r r r )r rk r r r �test_functionBoundaries� s z*FlushWarningsTests.test_functionBoundariesc C s4 t �d� | �t| jdg� | �t| �� �d� dS )z� If an object which is neither a function nor a method is included in the C{offendingFunctions} list, C{flushWarnings} raises L{ValueError}. Such a call flushes no warnings. �oh noNr )r r � assertRaises� ValueErrorr r r r r r r �test_invalidFilter s z%FlushWarningsTests.test_invalidFilterc C s� t | �� �d���d�}|�� |�d��d� |�d��d� |�� j�d�}t j� d|� | � t jj |� ddl m} | � t jjd � | � t jj|j� |�d�� � |�� | �t| �|jg��d � d S ) zx Warnings emitted by a function the source code of which is not available can still be flushed. �utf-8� twisted_private_helper� __init__.py� s missingsourcefile.py�7 import warnings def foo(): warnings.warn("oh no") r )�missingsourcefile�twisted_private_helperr N)r �mktemp�encode�child�makedirs� setContent�parent�path�decoderJ �insert� addCleanup�removery rx �modules�popr �foor r r )r �package� pathEntryrx r r r �test_missingSource s" � � z%FlushWarningsTests.test_missingSourcec C s t | �� �d���d�}|�� |�d��d� |�d��d� |�� j�d�}t j� d|� | � t jj |� ddl m} t jd = t j|j= zdd lm} W n tyW Y nw |� |�|�d �� ddlm} | � t jjd � | � t jj|j� |�� | �t| �|jg��d � dS )a Warnings emitted by a function defined in a file which has been renamed since it was initially compiled can still be flushed. This is testing the code which specifically supports working around the unfortunate behavior of CPython to write a .py source file name into the .pyc files it generates and then trust that it is correct in various places. If source files are renamed, .pyc files may not be regenerated, but they will contain incorrect filenames. rs rt ru rv s module.pyrw r )�modulery )�invalidate_cachess twisted_renamed_helper�twisted_renamed_helperr N) r rz r{ r| r} r~ r r� r� rJ r� r� r� ry r� r� r � importlibr� � ImportError�moveTo�siblingr� r� r� r r r )r r� r� r� r� r r r �test_renamedSource3 s4 � � � z%FlushWarningsTests.test_renamedSourcec C s, ddd�}|� | � t| �|g��d� dS )a� In Python 3.6 the dis.findlinestarts documented behaviour was changed such that the reported lines might not be sorted ascending. In Python 3.10 PEP 626 introduced byte-code change such that the last line of a function wasn't always associated with the last byte-code. In the past flushWarning was not detecting that such a function was associated with any warnings. r c S s | r|r t �d� d S d S d S )Nro rd )r( r) r r r r� y s �zCFlushWarningsTests.test_offendingFunctions_deep_branch.<locals>.fooN)r r rm )r r� r r r �#test_offendingFunctions_deep_brancho s z6FlushWarningsTests.test_offendingFunctions_deep_branchN)r r r r r$ r* r+ r3 r8 r9 r r r^ r_ r` rj rn rr r� r� r� r r r r r / s& <r c @ rO )� FakeWarningNrP r r r r r� � rR r� c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�CollectWarningsTestsz( Tests for L{_collectWarnings}. c s� d��ddd� �t ddd��g � � ���fdd�}t� j|� | �� d d � | �� d j�� | �� d j�� | �� d jt��� | �� d d � | �t� �d � dS )zS L{_collectWarnings} calls the observer with each emitted warning. z dummy calls observer warningNrT r r5 rl c s6 � � d� t��� t��� t��� � � d� d S )N�call� returning)�appendr r r ��eventsr/ r1 � thirdMessager r �f� s z2CollectWarningsTests.test_callsObserver.<locals>.fr r� r: r� � )rU r r� r r �strr )r r� r r� r �test_callsObserver� s z'CollectWarningsTests.test_callsObserverc C s: t � }| �td|� tdd� tjd� | �|�� d� dS )z� Any warnings emitted by a call to a function passed to L{_collectWarnings} are not actually emitted to the warning system. rG c S � d S �Nr ��xr r r �<lambda>� � z6CollectWarningsTests.test_suppresses.<locals>.<lambda>�textrH N)r rI rJ r r r r rL )r rM r r r �test_suppresses� s z$CollectWarningsTests.test_suppressesc sX g � t � �� �fdd�}tdd� |ddddd �}| �� d ddd �fg� | �|�� d S ) z� L{_collectWarnings} returns the result of calling the callable passed to it with the parameters given. c s � � | |f� �S r� )r� )�args�kwargs�� arguments�valuer r r� � s z2CollectWarningsTests.test_callsFunction.<locals>.fc S r� r� r r� r r r r� � r� z9CollectWarningsTests.test_callsFunction.<locals>.<lambda>r r( r5 �d)r) �c)r r( N)�objectr r r> )r r� rC r r� r �test_callsFunction� s z'CollectWarningsTests.test_callsFunctionc C sd b dd� }t�d� |� g }t|j|� | �t|�d� | �|d jd� | �t| �� �d� dS )z� Subsequent emissions of a warning from a particular source site can be collected by L{_collectWarnings}. In particular, the per-module emitted-warning cache should be bypassed (I{__warningregistry__}). c S s t �d� d S )Nr� rd r r r r r� � � z>CollectWarningsTests.test_duplicateWarningCollected.<locals>.f�defaultr r r� N) �__warningregistry__r rW r r� r r r r )r r� r� r r r � test_duplicateWarningCollected� s z3CollectWarningsTests.test_duplicateWarningCollectedc C s, t � }|tj|< | �tjj|� | �� dS )z� L{_collectWarnings}'s behavior is not altered by the presence of an object which cannot have attributes set on it as a value in C{sys.modules}. N)r� rJ r� r� r� r� �r �keyr r r �test_immutableObject� s z)CollectWarningsTests.test_immutableObjectc sn i � G � fdd�d�}t � }t � }||�� |< t � }t � }||�� |< t� � | �||||ht� �� �� dS )a� If the dictionary passed to L{_setWarningRegistryToNone} changes size partway through the process, C{_setWarningRegistryToNone} continues to set C{__warningregistry__} to L{None} on the rest of the values anyway. This might be caused by C{sys.modules} containing something that's not really a module and imports things on setattr. py.test does this, as does L{twisted.python.deprecate.deprecatedModuleAttribute}. c s e Zd Zdd� Z� fdd�ZdS )zKCollectWarningsTests.test_setWarningRegistryChangeWhileIterating.<locals>.Ac S s || j d< d S )N�_key)�__dict__r� r r r �__init__� r� zTCollectWarningsTests.test_setWarningRegistryChangeWhileIterating.<locals>.A.__init__c s d � | j < d S r� )r� )r r� �item�r� r r � __setattr__� r� zWCollectWarningsTests.test_setWarningRegistryChangeWhileIterating.<locals>.A.__setattr__N)r r r r� r� r r� r r �A� s r� N)r� r r r �keys)r r� �key1�key2�key3�key4r r� r �+test_setWarningRegistryChangeWhileIterating� s z@CollectWarningsTests.test_setWarningRegistryChangeWhileIteratingN) r r r r r� r� r� r� r� r� r r r r r� � s r� )r rJ r �ior �unittestr �twisted.python.filepathr �twisted.trial._synctestr r �twisted.trial.unittestr r r rU r� r� r r r r �<module> s ZPK Mb�Z(��/ / 1 trial/test/__pycache__/scripttest.cpython-310.pycnu �[��� o 5�@g� � @ s G d d� d�Z dS )c @ s e Zd ZdS )�FooN)�__name__� __module__� __qualname__� r r �?/usr/lib/python3/dist-packages/twisted/trial/test/scripttest.pyr s r N)r r r r r �<module> s PK Mb�Z�$�� � 4 trial/test/__pycache__/test_testcase.cpython-310.pycnu �[��� o �b� � @ sJ d Z ddlmZmZ G dd� d�ZG dd� dee�ZG dd� dee�Zd S ) zm Direct unit tests for L{twisted.trial.unittest.SynchronousTestCase} and L{twisted.trial.unittest.TestCase}. � )�SynchronousTestCase�TestCasec @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � TestCaseMixinz L{TestCase} tests. c C s | � d�| _| � d�| _dS )z� Create a couple instances of C{MyTestCase}, each for the same test method, to be used in the test methods of this class. �test_1N)� MyTestCase�first�second��self� r �B/usr/lib/python3/dist-packages/twisted/trial/test/test_testcase.py�setUp s zTestCaseMixin.setUpc C s: | � | j| jk� | � | j| jk� | �| j| jk� dS )z� In order for one test method to be runnable twice, two TestCase instances with the same test method name must not compare as equal. N)� assertTruer r � assertFalser r r r � test_equality s zTestCaseMixin.test_equalityc C s, i }d|| j < d|| j< | �t|�d� dS )z� In order for one test method to be runnable twice, two TestCase instances with the same test method name should not have the same hash value. N� )r r � assertEqual�len)r � containerr r r �test_hashability# s z TestCaseMixin.test_hashabilityN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r c @ � e Zd ZG dd� de�ZdS )�SynchronousTestCaseTestsc @ � e Zd ZdZdd� ZdS )z#SynchronousTestCaseTests.MyTestCasezj Some test methods which can be used to test behaviors of L{SynchronousTestCase}. c C � d S �Nr r r r r r 6 � z*SynchronousTestCaseTests.MyTestCase.test_1N�r r r r r r r r r r 0 � r N)r r r r r r r r r r / � r c @ r )�AsynchronousTestCaseTestsc @ r )z$AsynchronousTestCaseTests.MyTestCasez_ Some test methods which can be used to test behaviors of L{TestCase}. c C r r r r r r r r C r z+AsynchronousTestCaseTests.MyTestCase.test_1Nr r r r r r = r! r N)r r r r r r r r r r# < r" r# N)r �twisted.trial.unittestr r r r r# r r r r �<module> s " PK Mb�Z],�� � ; trial/test/__pycache__/test_asyncassertions.cpython-310.pycnu �[��� o �b� � @ sF d Z ddlZddlmZ ddlmZ ddlmZ G dd� dej�Z dS )zL Tests for async assertions provided by C{twisted.trial.unittest.TestCase}. � N)�defer)�failure)�unittestc @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�AsynchronousAssertionsTestszp Tests for L{TestCase}'s asynchronous extensions to L{SynchronousTestCase}. That is, assertFailure. c C s t �dd� �}| �|t�S )Nc S � dd S �N� r � r r r �I/usr/lib/python3/dist-packages/twisted/trial/test/test_asyncassertions.py�<lambda> � z@AsynchronousAssertionsTests.test_assertFailure.<locals>.<lambda>)r � maybeDeferred� assertFailure�ZeroDivisionError��self�dr r r �test_assertFailure s z.AsynchronousAssertionsTests.test_assertFailurec s: t �dd� �}� �|t� |�� fdd�� fdd�� |S )Nc S r r r r r r r r r zOAsynchronousAssertionsTests.test_assertFailure_wrongException.<locals>.<lambda>c � � � d�S �NzShould have failed��fail��x�r r r r � c � | � � j�S �N��trap�failureExceptionr r r r r � )r r r � OverflowError� addCallbacksr r r r �!test_assertFailure_wrongException s �z=AsynchronousAssertionsTests.test_assertFailure_wrongExceptionc s6 t �d �}� �|t� |�� fdd�� fdd�� |S )Nc r r r r r r r r ' r zLAsynchronousAssertionsTests.test_assertFailure_noException.<locals>.<lambda>c r r r r r r r r ( r! )r �succeedr r r# r r r r � test_assertFailure_noException# s �z:AsynchronousAssertionsTests.test_assertFailure_noExceptionc C sP zdd W n t y t�� }t�|�}Y nw | �|t�}|�| j|� |S )z� In the case of assertFailure failing, check that we get lots of information about the exception that was raised. r r ) r r �Failurer r r � RuntimeError� addErrback� _checkInfo)r �fr r r r �test_assertFailure_moreInfo, s � z7AsynchronousAssertionsTests.test_assertFailure_moreInfoc C s< |� | j�sJ �|�� }| �|�� |� | �|�� |� d S r )�checkr �getErrorMessage�assertIn�getBriefTraceback)r �assertionFailurer+ �outputr r r r* : s z&AsynchronousAssertionsTests._checkInfoc sV G dd� dt �� G � fdd�dtj�}|d�}t�� }|�|� | �dt|j�� dS )zJ A single wrong assertFailure should fail the whole test. c @ s e Zd ZdS )zMAsynchronousAssertionsTests.test_assertFailure_masked.<locals>.ExampleFailureN)�__name__� __module__� __qualname__r r r r �ExampleFailureE s r6 c s e Zd Z� Zdd� ZdS )zAAsynchronousAssertionsTests.test_assertFailure_masked.<locals>.TCc S s* t �dd� �}| �|t� | �|t� |S )Nc S r r r r r r r r L r zfAsynchronousAssertionsTests.test_assertFailure_masked.<locals>.TC.test_assertFailure.<locals>.<lambda>)r r r r" r r r r r r K s zTAsynchronousAssertionsTests.test_assertFailure_masked.<locals>.TC.test_assertFailureN)r3 r4 r5 r r r �r6 r r �TCH s r8 r r N) � Exceptionr �TestCase�pyunit� TestResult�run� assertEqual�len�failures)r r8 �test�resultr r7 r �test_assertFailure_masked@ s z5AsynchronousAssertionsTests.test_assertFailure_maskedN) r3 r4 r5 �__doc__r r$ r& r, r* rC r r r r r s r ) rD r r; �twisted.internetr �twisted.pythonr � twisted.trialr: r r r r r �<module> s PK Mb�Z�+{� � / trial/test/__pycache__/packages.cpython-310.pycnu �[��� o �b+ � @ sj d Z ddlZddlZddlmZ ddlmZ dZe� dd�Z dZ d Z G d d � d ej �ZG d d � d e�ZdS )zf Classes and functions used by L{twisted.trial.test.test_util} and L{twisted.trial.test.test_loader}. � N)�invalidate_caches)�unittestzv from twisted.trial import unittest class FooTest(unittest.SynchronousTestCase): def testFoo(self): pass � z a� '''This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. ''' import unittest as pyunit from twisted.trial import unittest class FooTest(unittest.SynchronousTestCase): def test_foo(self): pass def test_bar(self): pass class PyunitTest(pyunit.TestCase): def test_foo(self): pass def test_bar(self): pass class NotATest: def test_foo(self): pass class AlphabetTest(unittest.SynchronousTestCase): def test_a(self): pass def test_b(self): pass def test_c(self): pass az '''This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. ''' from twisted.trial import unittest class X: def test_foo(self): pass class A(unittest.SynchronousTestCase, X): pass class B(unittest.SynchronousTestCase, X): pass c @ s� e Zd Zddddddddd d efd d efd defddefddefgZdd� Zdd� Z dd� Z d#dd�Z d d � Z d$d d �Z d!d"� Zd S )%� PackageTest)zbadpackage/__init__.py�frotz )zbadpackage/test_module.py� )z unimportablepackage/__init__.pyr )z"unimportablepackage/test_module.pyzimport notarealmoduleok )zpackage2/__init__.pyr )zpackage2/test_module.pyz import frotz )zpackage/__init__.pyr )zpackage/frotz.pyr )zpackage/test_bad_module.pyz%raise ZeroDivisionError("fake error")zpackage/test_dos_module.py)z package/test_import_module.pyz import frotzzpackage/test_module.py)zgoodpackage/__init__.pyr zgoodpackage/test_sample.py)zgoodpackage/sub/__init__.pyr z goodpackage/sub/test_sample.py)z inheritancepackage/__init__.pyr z inheritancepackage/test_x.pyc C s< t j�|�d }|�d�}|d dkr|d d� }d�|�S )Nr �/����__init__�.)�os�path�splitext�split�join)�self�filename�name�segs� r �=/usr/lib/python3/dist-packages/twisted/trial/test/packages.py� _toModuleNamet s zPackageTest._toModuleNamec s � fdd�� j D �S )zQ Return matching module names for files listed in C{self.files}. c s g | ] \}}� � |��qS r )r )�.0r �code�r r r � <listcomp> s z*PackageTest.getModules.<locals>.<listcomp>)�filesr r r r � getModules{ s zPackageTest.getModulesc C sD | � � }|�� |�� |D ]}ztj|= W q ty Y qw d S �N)r �sort�reverse�sys�modules�KeyError)r r" �moduler r r �cleanUpModules� s ��zPackageTest.cleanUpModulesr c C s` | j D ]*\}}tj�||�}| �|� t|d�� }|�|� W d � n1 s(w Y qd S )N�w)r r r r �_createDirectory�open�write)r r � parentDirr �contents�fdr r r � createFiles� s ���zPackageTest.createFilesc C s* t j�|�}t j�|�st �|� d S d S r )r r �dirname�exists�makedirs)r r � directoryr r r r' � s �z PackageTest._createDirectoryNc C s. t � |d u r | �� }|| _| �| j|� d S r )�invalidateImportCaches�mktemp�parentr- r )r r* r r r �setUp� s zPackageTest.setUpc C s | � � d S r )r% r r r r �tearDown� s zPackageTest.tearDown)r r )�__name__� __module__� __qualname__� dosModule� testModule� testSample�testInheritanceSampler r r r% r- r' r5 r6 r r r r r ^ s6 � r c @ s& e Zd Zddd�Zdd� Zdd� ZdS ) �SysPathManglingTestNc C s` t � tjd d � | _tjd d � | _|d u r| �� }t�| |� | j�| j � | � | j� d S r ) r2 r! r �oldPath�newPathr3 r r5 �appendr4 � mangleSysPath)r r4 r r r r5 � s zSysPathManglingTest.setUpc C s t �| � | �| j� d S r )r r6 rB r? r r r r r6 � s z SysPathManglingTest.tearDownc C s |t jd d �< d S r )r! r )r �pathVarr r r rB � s z!SysPathManglingTest.mangleSysPathr )r7 r8 r9 r5 r6 rB r r r r r> � s r> )�__doc__r r! � importlibr r2 � twisted.trialr r; �replacer: r< r= �SynchronousTestCaser r> r r r r �<module> s )DPK Mb�Z�Ӟ�r �r 2 trial/test/__pycache__/test_script.cpython-310.pycnu �[��� o �b�r � @ sz d dl Z d dlZd dlZd dlZd dlZd dlmZ d dlmZ d dl m Z d dl m Z d dl mZ d dlmZ d dlmZ d d lmZmZmZmZ d d lmZ ed �Zd d � Z G dd� dej �Z G dd� dej �Z G dd� dej �Z G dd� dej �Z!G dd� dej �Z"G dd� dej#�Z$G dd� dej#�Z%G d d � d ej#�Z&G d d � d ej#�Z'G d d!� d!ej#�Z(G d"d#� d#ej#�Z)dS )$� N)�StringIO)�util)�FilePath)� UsageError)�trial)�unittest)�DistTrialRunner)�DestructiveTestSuite� TestLoader� TestSuite� TrialRunner)� testNamesr c C s t �t| �S )z1 For finding files in twisted/trial/test )r �sibpath�__file__)�filename� r �@/usr/lib/python3/dist-packages/twisted/trial/test/test_script.pyr s r c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�ForceGarbageCollectionTestsz* Tests for the --force-gc option. c C s> t �� | _g | _| �td| j� t�| j �}t ||g�| _ d S )N�collect) r �Options�config�log�patch�gcr �pyunit�FunctionTestCase� simpleTestr �test)�selfr r r r �setUp) s z!ForceGarbageCollectionTests.setUpc C � | j �d� dS )zD A simple test method that records that it was run. r N�r �append�r r r r r 0 � z&ForceGarbageCollectionTests.simpleTestc C r )zI A replacement for gc.collect that logs calls to itself. r Nr! r# r r r r 6 r$ z#ForceGarbageCollectionTests.collectc C s t �| j�}t� |_|S )zN Return a L{TrialRunner} object that is safe to use in tests. )r � _makeRunnerr r �stream�r �runnerr r r � makeRunner< s z&ForceGarbageCollectionTests.makeRunnerc C s> d| j d< | j �� | �� }|�| j� | �| jg d�� dS )z� Passing the --force-gc option to the trial script forces the garbage collector to run before and after each test. Tzforce-gc)r r r r r r N�r � postOptionsr) �runr � assertEqualr r' r r r � test_forceGcD s �z(ForceGarbageCollectionTests.test_forceGcc C s4 | j �� | �� }|�| j� | �| jddg� dS )z> By default, no garbage collection is forced. r Nr* r' r r r �test_unforceGcQ s z*ForceGarbageCollectionTests.test_unforceGcN) �__name__� __module__� __qualname__�__doc__r r r r) r. r/ r r r r r $ s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �SuiteUsedTestsz? Check the category of tests suite used by the loader. c C � t �� | _dS )z6 Create a trial configuration object. N�r r r r# r r r r ` � zSuiteUsedTests.setUpc C s t �| j�}| �|jt� dS )zK By default, the loader should use L{DestructiveTestSuite} N)r � _getLoaderr r- � suiteFactoryr �r �loaderr r r �test_defaultSuitef s z SuiteUsedTests.test_defaultSuitec C s( d| j d< t�| j �}| �|jt� dS )zw The C{until-failure} configuration uses the L{TestSuite} to keep instances alive across runs. Tz until-failureN)r r r8 r- r9 r r: r r r �test_untilFailureSuitem s z%SuiteUsedTests.test_untilFailureSuiteN)r0 r1 r2 r3 r r< r= r r r r r4 [ s r4 c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Z d5S )6�TestModuleTestsc C � t �� | _d S �Nr6 r# r r r r x � zTestModuleTests.setUpc C s d | _ d S r@ )r r# r r r �tearDown{ � zTestModuleTests.tearDownc C s | � t| �| �� g� dS )zq Check that the testNames helper method accurately collects the names of tests in suite. N)r- r �idr# r r r �test_testNames~ s z TestModuleTests.test_testNamesc C sB t � }t|�}ttt|j|���}|�� |�� | �||� d S r@ )r r r �map� loadByName�sortr- )r �test1�namesr; �names1�names2r r r �assertSuitesEqual� s z!TestModuleTests.assertSuitesEqualc C s | � dt| jd �� d S )Nr �tests)r- �lenr r# r r r �test_baseState� s z TestModuleTests.test_baseStatec C �* | j �td�� | �t�| j �dg� dS )z� Check that --testmodule loads a suite which contains the tests referred to in test-case-name inside its parameter. � moduletest.py�twisted.trial.test.test_logN�r �opt_testmoduler rM r � _getSuiter# r r r �test_testmoduleOnModule� � �z'TestModuleTests.test_testmoduleOnModulec C s: | j �td�� | j �td�� | �t�| j �dg� dS )z� When the same module is specified with two --testmodule flags, it should only appear once in the suite. rR rS NrT r# r r r �test_testmoduleTwice� s �z$TestModuleTests.test_testmoduleTwicec C s: | j �td�� | j �td�� | �t�| j �dg� dS )z� If --testmodule is specified twice, once for module A and once for a module which refers to module A, then make sure module A is only added once. rR z test_log.pyrS NrT r# r r r � test_testmoduleOnSourceAndTarget� s �z0TestModuleTests.test_testmoduleOnSourceAndTargetc C rQ )z� When given a module that refers to *itself* in the test-case-name variable, check that --testmodule only adds the tests once. z moduleself.pyz twisted.trial.test.moduleselfNrT r# r r r �test_testmoduleOnSelfModule� rX z+TestModuleTests.test_testmoduleOnSelfModulec C s, | j �td�� | �t�| j �ddg� dS )zm Check that --testmodule loads tests referred to in test-case-name buffer variables. � scripttest.pyrS � twisted.trial.test.test_runnerNrT r# r r r �test_testmoduleOnScript� s �z'TestModuleTests.test_testmoduleOnScriptc C �h t � }tj|}t_d}z#| j�|� | �dt| jd �� | �d|�d�|�� � W |t_dS |t_w )zz Check that --testmodule displays a meaningful error message when passed a non-existent filename. z test_thisbetternoteverexist.pyr rN �File � doesn't exist N�r �sys�stderrr rU r- rO �getvalue)r �buffyrd r r r r � test_testmoduleOnNonexistentFile� � z0TestModuleTests.test_testmoduleOnNonexistentFilec C s* | j �td�� | �dt| j d �� dS )z� Check that --testmodule adds no tests to the suite for modules which lack test-case-name buffer variables. � novars.pyr rN N)r rU r r- rO r# r r r �test_testmoduleOnEmptyVars� s z*TestModuleTests.test_testmoduleOnEmptyVarsc C r_ )z� Check that --testmodule does *not* support module names as arguments and that it displays a meaningful error message. z twisted.trial.test.test_scriptr rN r` ra Nrb )r rf rd � moduleNamer r r �test_testmoduleOnModuleName� rh z+TestModuleTests.test_testmoduleOnModuleNamec C �" d}t �|�}| �ddi|� d S )Nz5-*- test-case-name: twisted.trial.test.test_tests -*-�test-case-name� twisted.trial.test.test_tests�r �_parseLocalVariablesr- �r � declaration� localVarsr r r �test_parseLocalVariable� � z'TestModuleTests.test_parseLocalVariablec C rm )Nz6-*- test-case-name: twisted.trial.test.test_tests; -*-rn ro rp rr r r r �test_trailingSemicolon� rv z&TestModuleTests.test_trailingSemicolonc C s$ d}t �|�}| �ddd�|� d S )Nz?-*- test-case-name: twisted.trial.test.test_tests; foo: bar -*-ro �bar)rn �foorp rr r r r �test_parseLocalVariables� s � �z(TestModuleTests.test_parseLocalVariablesc C rm )Nz:## -*- test-case-name: twisted.trial.test.test_tests -*- #rn ro rp rr r r r �test_surroundingGuff� rv z$TestModuleTests.test_surroundingGuffc C s | � ttjd� d S �Nry �� assertRaises� ValueErrorr rq r# r r r �test_invalidLine s z TestModuleTests.test_invalidLinec C s4 | � ttjd� | � ttjd� | � ttjd� d S )Nz -*- foo -*-z-*- foo: bar; qux -*-z -*- foo: bar: baz; qux: qax -*-r} r# r r r �test_invalidDeclaration s ��z'TestModuleTests.test_invalidDeclarationc C �" t �td��}| �ddi|� d S )NrR rn rS �r �loadLocalVariablesr r- �r rt r r r �test_variablesFromFile � z&TestModuleTests.test_variablesFromFilec C s t �td��}| �i |� d S )Nri r� r� r r r �test_noVariablesInFile s z&TestModuleTests.test_noVariablesInFilec C r� )Nr\ rn z:twisted.trial.test.test_log,twisted.trial.test.test_runnerr� r� r r r �test_variablesFromScript s ��z(TestModuleTests.test_variablesFromScriptc C s t �td��}| �|dg� d S )NrR rS )r �getTestModulesr r- �r �modulesr r r �test_getTestModules# s z#TestModuleTests.test_getTestModulesc C s" t �td��}| �t|�d� d S )Nri r )r r� r r- rO r� r r r �test_getTestModules_noVars' r� z*TestModuleTests.test_getTestModules_noVarsc C s& t �td��}| �t|�ddh� d S )Nr\ rS r] )r r� r r- �setr� r r r � test_getTestModules_multiple+ s �z,TestModuleTests.test_getTestModules_multiplec C sV dD ]}| � t�|�|�d�� qdtd�td�fD ]}| �t�|�|�d�� qd S )N)ztest_script.pyz!twisted/trial/test/test_script.pyz should be a test filez twisted/trial/test/moduletest.pyr\ z test_foo.batz should *not* be a test file)� assertTruer � isTestFiler � assertFalse)r r r r r �test_looksLikeTestModule2 s ����z(TestModuleTests.test_looksLikeTestModuleN) r0 r1 r2 r rB rE rM rP rW rY rZ r[ r^ rg rj rl ru rw rz r{ r� r� r� r� r� r� r� r� r� r r r r r> w s6 r> c @ �H e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�WithoutModuleTestsz* Test the C{without-module} flag. c C s t �� | _ttj�| _dS )zl Create a L{trial.Options} object to be used in the tests, and save C{sys.modules}. N)r r r �dictrc r� � savedModulesr# r r r r H s zWithoutModuleTests.setUpc C s8 dD ]}|| j v r| j | tj|< qtj�|d� qdS )z) Restore C{sys.modules}. )�imaplib�smtplibN)r� rc r� �pop)r �moduler r r rB P s �zWithoutModuleTests.tearDownc C � ddl }|S )zE Try to import the C{smtplib} module, and return it. r N)r� )r r� r r r � _checkSMTPZ � z WithoutModuleTests._checkSMTPc C r� )zE Try to import the C{imaplib} module, and return it. r N)r� )r r� r r r � _checkIMAPb r� z WithoutModuleTests._checkIMAPc C s< | j �ddg� | �t| j� tjd= | �| �� tj � dS )zT Check that after disabling a module, it can't be imported anymore. �--without-moduler� N) r � parseOptionsr~ � ImportErrorr� rc r� �assertIsInstance�types� ModuleTyper# r r r �test_disableOneModulej s z(WithoutModuleTests.test_disableOneModulec C sd | j �ddg� | �t| j� | �t| j� tjd= tjd= | �| �� t j � | �| �� t j � dS )zE Check that several modules can be disabled at once. r� zsmtplib,imaplibr� r� N) r r� r~ r� r� r� rc r� r� r� r� r# r r r �test_disableMultipleModulesu s z.WithoutModuleTests.test_disableMultipleModulesc C s@ | � | �� tj� | �tdtj| jj ddg� | � t | j� dS )zP Disabling an already imported module should produce a warning. z4Module 'smtplib' already imported, disabling anyway.r� r� N) r� r� r� r� � assertWarns�RuntimeWarningr r r r� r~ r� r# r r r �!test_disableAlreadyImportedModule� s �z4WithoutModuleTests.test_disableAlreadyImportedModuleN) r0 r1 r2 r3 r rB r� r� r� r� r� r r r r r� C s r� c @ sD e Zd ZdZeedd�du rdZdd� Zdd� Zd d � Z d d � Z dS ) � CoverageTestsz+ Tests for the I{coverage} option. �gettraceNz;Cannot test trace hook installation without inspection API.c C s | � tjt�� � dS )zf Arrange for the current trace hook to be restored when the test is complete. N)� addCleanuprc �settracer� r# r r r r � s zCoverageTests.setUpc C s, t �� }|�dg� | �t�� |jj� dS )z} L{trial.Options} handles C{"--coverage"} by installing a trace hook to record coverage information. z --coverageN)r r r� r- rc r� �tracer� globaltrace�r �optionsr r r �test_tracerInstalled� s z"CoverageTests.test_tracerInstalledc C s. t �� }| �|�� td��|d dg�� dS )z� L{trial.Options.coverdir} returns a L{FilePath} based on the default for the I{temp-directory} option if that option is not specified. �.ztemp-directory�coverageN)r r r- �coverdirr � descendantr� r r r �test_coverdirDefault� s �z"CoverageTests.test_coverdirDefaultc C s< | � � }t�� }|�d|g� | �|�� t|��d�� dS )z� If a value is specified for the I{temp-directory} option, L{trial.Options.coverdir} returns a child of that path. z--temp-directoryr� N)�mktempr r r� r- r� r �child)r �pathr� r r r �test_coverdirOverridden� s z%CoverageTests.test_coverdirOverridden) r0 r1 r2 r3 �getattrrc �skipr r� r� r� r r r r r� � s r� c @ r� )� OptionsTestsz% Tests for L{trial.Options}. c C r5 )zE Build an L{Options} object to be used in the tests. N�r r r� r# r r r r � r7 zOptionsTests.setUpc C sj | � tjt�� � t�� r| � tj� | j�g d�� | j� � }| � d|� |� d� | � ddg|� dS )z� C{_getWorkerArguments} discards options like C{random} as they only matter in the manager, and forwards options like C{recursionlimit} or C{disablegc}. )�--recursionlimit�2000�--random�4� --disablegcr� r� r� N) r� rc �setrecursionlimit�getrecursionlimitr � isenabled�enabler� r� �_getWorkerArguments�assertIn�remover- )r �argsr r r �test_getWorkerArguments� s � z$OptionsTests.test_getWorkerArgumentsc C �* | � t| jjg d��}| �dt|�� dS )z� C{parseOptions} raises a C{UsageError} when C{--debug} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5825} )�--jobsr� �--debugz+You can't specify --debug when using --jobsN�r~ r r� r� r- �str�r �errorr r r �test_jobsConflictWithDebug� � �z'OptionsTests.test_jobsConflictWithDebugc C r� )z� C{parseOptions} raises a C{UsageError} when C{--profile} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5827} )r� r� z --profilez-You can't specify --profile when using --jobsNr� r� r r r � test_jobsConflictWithProfile� r� z)OptionsTests.test_jobsConflictWithProfilec C r� )z� C{parseOptions} raises a C{UsageError} when C{--debug-stacktraces} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5826} )r� r� z--debug-stacktracesz7You can't specify --debug-stacktraces when using --jobsNr� r� r r r �%test_jobsConflictWithDebugStackTraces� s ��z2OptionsTests.test_jobsConflictWithDebugStackTracesc C r� )z� C{parseOptions} raises a C{UsageError} when C{--exitfirst} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/6436} )r� r� � --exitfirstz/You can't specify --exitfirst when using --jobsNr� r� r r r � test_jobsConflictWithExitFirst r� z+OptionsTests.test_jobsConflictWithExitFirstc C r� )zr C{parseOptions} raises a C{UsageError} when C{--order} is passed along with C{--random}. )�--order� alphabeticalr� �1234z-You can't specify --random when using --orderNr� r� r r r � test_orderConflictWithRandom s �z)OptionsTests.test_orderConflictWithRandomN) r0 r1 r2 r3 r r� r� r� r� r� r� r r r r r� � s r� c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �MakeRunnerTestsz. Tests for the L{_makeRunner} helper. c C r? r@ r� r# r r r r # rA zMakeRunnerTests.setUpc C sJ | j �g d�� t�| j �}| �|t� | �d|j� | �dg|j� dS )z� L{_makeRunner} returns a L{DistTrialRunner} instance when the C{--jobs} option is passed, and passes the C{workerNumber} and C{workerArguments} parameters to it. )r� r� � --force-gc� r� N) r� r� r r% r� r r- � _workerNumber�_workerArgumentsr' r r r � test_jobs& s zMakeRunnerTests.test_jobsc C s< | j �g d�� t�| j �}| �|t� | �tj|j� dS )z� L{_makeRunner} returns a L{TrialRunner} instance in C{DRY_RUN} mode when the C{--dry-run} option is passed, even if C{--jobs} is set. )r� r� z --dry-runN) r� r� r r% r� r r- �DRY_RUN�moder' r r r �test_dryRunWithJobs2 s z#MakeRunnerTests.test_dryRunWithJobsc sP t jj� � fdd�}| �t jd|� t �� }|�g d�� | �t jt j|� d S )Nc s | dkr t j�| ��� | �S )N� doNotFind)r �reflect�ModuleNotFound)�fqn��namedAnyr r �namedAnyExceptdoNotFind? s zFMakeRunnerTests.test_DebuggerNotFound.<locals>.namedAnyExceptdoNotFindr� )r� z --debuggerr� ) r r� r� r r r� r~ �_DebuggerNotFoundr% )r r� r� r r� r �test_DebuggerNotFound< s z%MakeRunnerTests.test_DebuggerNotFoundc C s* | j �dg� t�| j �}| �|j� dS )z� Passing C{--exitfirst} wraps the reporter with a L{reporter._ExitWrapper} that stops on any non-success. r� N)r� r� r r% r� � _exitFirstr' r r r �test_exitfirstK s z MakeRunnerTests.test_exitfirstN) r0 r1 r2 r3 r r� r� r� r� r r r r r� s r� c @ � e Zd ZdZdd� Zdd� ZdS )�RunTestsz( Tests for the L{run} function. c C s | � tjddd� � d S )Nr� c S s d S r@ r r# r r r �<lambda>] s z RunTests.setUp.<locals>.<lambda>)r r r r# r r r r Z s zRunTests.setUpc C sh dd� }| � td|� zt�� W n ty, } z| �dt|�� W Y d}~dS d}~ww | �d� dS )zY When a debugger is not found, an error message is printed to the user. c _ s t �d��r| )r r� )r� �kwargsr r r r% e rC z3RunTests.test_debuggerNotFound.<locals>._makeRunnerr% ry Nz0Should have exited due to non-existent debugger!)r r r, � SystemExitr� r� �fail)r r% �er r r �test_debuggerNotFound_ s ��z RunTests.test_debuggerNotFoundN)r0 r1 r2 r3 r r� r r r r r� U s r� c @ r� )�TestArgumentOrderTestszQ Tests for the order-preserving behavior on provided command-line tests. c C s t �� | _t� | _d S r@ )r r r r r; r# r r r r w s z TestArgumentOrderTests.setUpc C sR g d�}| j �|� t�| j �}t|�}tt| jj|��}t|�}| � ||� dS )zN Multiple tests passed on the command line are not reordered. )ro z"twisted.trial.test.test_assertionsz twisted.trial.test.test_deferredN) r r� r rV r r rF r; rG r- )r rN �suiterJ � expectedSuite� expectedNamesr r r �test_preserveArgumentOrder{ s z1TestArgumentOrderTests.test_preserveArgumentOrderN)r0 r1 r2 r3 r r r r r r r� r s r� c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )� OrderTestsz' Tests for the --order option. c C r? r@ r6 r# r r r r � rA zOrderTests.setUpc C �D | j �g d�� t�| j �}|�| j d �}| �t|�g d�� dS )zn --order=alphabetical causes trial to run tests alphabetically within each test case. )r� r� �%twisted.trial.test.ordertests.FooTestrN )�0twisted.trial.test.ordertests.FooTest.test_first�1twisted.trial.test.ordertests.FooTest.test_fourth�1twisted.trial.test.ordertests.FooTest.test_second�0twisted.trial.test.ordertests.FooTest.test_thirdN�r r� r r8 � loadByNamesr- r �r r; r� r r r �test_alphabetical� s � �z OrderTests.test_alphabeticalc C r )zu --order=alphabetical causes trial to run test classes within a given module alphabetically. )r� r� � twisted.trial.test.ordertestsrN )�.twisted.trial.test.ordertests.BarTest.test_bar�.twisted.trial.test.ordertests.BazTest.test_bazr r r r Nr r r r r �test_alphabeticalModule� � � �z"OrderTests.test_alphabeticalModulec C sV | j �g d�� t�| j �}|�| j d �}t|�}| j|dd� | �|t|�� dS )z� --order=alphabetical causes trial to run test modules within a given package alphabetically, with tests within each module alphabetized. )r� r� �twisted.trial.testrN zFailed to load any tests!��msgN) r r� r r8 r r r� r- �sorted�r r; r� rJ r r r �test_alphabeticalPackage� s z#OrderTests.test_alphabeticalPackagec C r )z� --order=toptobottom causes trial to run test methods within a given test case from top to bottom as they are defined in the body of the class. )r� � toptobottomr rN )r r r r Nr r r r r �test_toptobottom� s � �zOrderTests.test_toptobottomc C r )z� --order=toptobottom causes trial to run test classes within a given module from top to bottom as they are defined in the module's source. �r� r r rN )r r r r r r Nr r r r r �test_toptobottomModule� r z!OrderTests.test_toptobottomModulec C sP | j �g d�� t�| j �}|�| j d �}t|�}| �|t|dd� d�� dS )z� --order=toptobottom causes trial to run test modules within a given package alphabetically, with tests within each module run top to bottom. )r� r r rN c S s | � d�d d� S )Nr� r� )�split)�namer r r r� s z4OrderTests.test_toptobottomPackage.<locals>.<lambda>)�keyN)r r� r r8 r r r- r r r r r �test_toptobottomPackage� s �z"OrderTests.test_toptobottomPackagec C s� | � � }t|��d�}|�� |�d��d� |�d��t�d��d�� |�� j }t j � d|� | � t j j |� ddlm} | � t jjd� | � t jj|j� |�d�� � | j�g d �� t�| j�}|�|�}| �t|�g d �� d S ) z{ --order=toptobottom detects the source line of methods from modules whose source file is missing. �twisted_toptobottom_tempz __init__.py� ztest_missing.pya from twisted.trial.unittest import TestCase class TestMissing(TestCase): def test_second(self): pass def test_third(self): pass def test_fourth(self): pass def test_first(self): pass �utf8r )� test_missingr )z=twisted_toptobottom_temp.test_missing.TestMissing.test_secondz<twisted_toptobottom_temp.test_missing.TestMissing.test_thirdz=twisted_toptobottom_temp.test_missing.TestMissing.test_fourthz<twisted_toptobottom_temp.test_missing.TestMissing.test_firstN)r� r r� �makedirs� setContent�textwrap�dedent�encode�parentr� rc �insertr� r� r r# r� r� r0 r r� r r8 � loadModuler- r )r �tempdir�package� pathEntryr# r; r� r r r � test_toptobottomMissingSource s4 � � � �z(OrderTests.test_toptobottomMissingSourcec C s | � t| jjddg� dS )zL An unknown order passed to --order raises a L{UsageError}. r� z I don't existN)r~ r r r� r# r r r �test_unknownOrder? s �z OrderTests.test_unknownOrderN) r0 r1 r2 r3 r r r r r r r r/ r0 r r r r r � s .r c @ s e Zd ZdZdd� ZdS )�HelpOrderTestsz+ Tests for the --help-orders flag. c C s� | � tdt� � | �tt�� jdg�}| �|j d� tj � � }d}tj � � D ]"\}\}}t�t�|�� dt�|�� �|�}| j||||f d� q&dS )zS --help-orders prints each of the available orders and then exits. �stdoutz --help-ordersr z4%r with its description not properly described in %rz.*r N)r rc r r~ r� r r r� r- �coder2 re � _runOrders�items�re�search�escaper� )r �exc�outputr � orderName� orderDesc�_�matchr r r �&test_help_ordersPrintsSynopsisAndQuitsN s � ��z5HelpOrderTests.test_help_ordersPrintsSynopsisAndQuitsN)r0 r1 r2 r3 r? r r r r r1 I s r1 )*r r6 rc r& r� �ior �twisted.pythonr �twisted.python.filepathr �twisted.python.usager �twisted.scriptsr � twisted.trialr � twisted.trial._dist.disttrialr �twisted.trial.runnerr r r r � twisted.trial.test.test_loaderr � __import__r r �SynchronousTestCaser r4 r> r� r� �TestCaser� r� r� r� r r1 r r r r �<module> s: 7 MO.^7 ;PK Mb�Z Z� �' �' 8 trial/test/__pycache__/test_pyunitcompat.cpython-310.pycnu �[��� o �b� � @ s� d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZ d dl m Z m Z d dl m Z mZ G dd� de�ZG d d � d e�ZdS ) � N)�skipIf)� implementer)�Failure)� IReporter� ITestCase)�PyUnitResultAdapter�SynchronousTestCasec @ s. e Zd ZG dd� dej�Zdd� Zdd� ZdS )�PyUnitTestTestsc @ s e Zd Zdd� ZdS )zPyUnitTestTests.PyUnitTestc C s d S �N� ��selfr r �F/usr/lib/python3/dist-packages/twisted/trial/test/test_pyunitcompat.py� test_pass s z$PyUnitTestTests.PyUnitTest.test_passN)�__name__� __module__� __qualname__r r r r r � PyUnitTest s r c C s | � d�| _t| j�| _d S )Nr )r �originalr �testr r r r �setUp s zPyUnitTestTests.setUpc C s | � t| j�| j�d�� dS )zW Tests must be callable in order to be used with Python's unittest.py. z is not callable.N)� assertTrue�callabler r r r r � test_callable s z PyUnitTestTests.test_callableN)r r r �pyunit�TestCaser r r r r r r r s r c @ sp e Zd ZdZG dd� de�Zdd� Zdd� Zdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� ZdS )�PyUnitResultTestsz� Tests to show that PyUnitResultAdapter wraps TestResult objects from the standard library 'unittest' module in such a way as to make them usable and useful from Trial. c @ s e Zd ZdZdZdd� ZdS )zPyUnitResultTests.ErrorTestz� A test case which has a L{test_foo} which will raise an error. @ivar ran: boolean indicating whether L{test_foo} has been run. Fc C s d| _ dd dS )zR Set C{self.ran} to True and raise a C{ZeroDivisionError} T� r N��ranr r r r �test_foo3 s z$PyUnitResultTests.ErrorTest.test_fooN)r r r �__doc__r r r r r r � ErrorTest* s r" c C sF t t�G dd� d��}| �d�}|� }|�|� | �|jd t� dS )z� The L{PyUnitResultAdapter} is only used when the result passed to C{run} does *not* provide L{IReporter}. c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) zXPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporter.<locals>.StubReporterz� A reporter which records data about calls made to it. @ivar errors: Errors passed to L{addError}. @ivar failures: Failures passed to L{addFailure}. c S s g | _ g | _d S r )�errors�failuresr r r r �__init__I s zaPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporter.<locals>.StubReporter.__init__c S � dS �z- Do nothing. Nr �r r r r r � startTestM � zbPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporter.<locals>.StubReporter.startTestc S r& r' r r( r r r �stopTestR r* zaPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporter.<locals>.StubReporter.stopTestc S s | j �|� dS )z3 Record the error. N)r# �append)r r �errorr r r �addErrorW s zaPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporter.<locals>.StubReporter.addErrorN)r r r r! r% r) r+ r. r r r r � StubReporter@ s r/ r r N)r r r" �run�assertIsInstancer# r )r r/ r �resultr r r �0test_dontUseAdapterWhenReporterProvidesIReporter: s zBPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporterc C sV G dd� dt �}|d�}t�� }|�|� | �|j� | �d|j� | �|�� � d S )Nc @ � e Zd ZdZdd� ZdS )z3PyUnitResultTests.test_success.<locals>.SuccessTestFc S � d| _ d S �NTr ��sr r r r f � z<PyUnitResultTests.test_success.<locals>.SuccessTest.test_fooN�r r r r r r r r r � SuccessTestc � r; r r ) r r � TestResultr0 r r � assertEqual�testsRun� wasSuccessful)r r; r r2 r r r � test_successb s z PyUnitResultTests.test_successc C sh G dd� dt �}|d�}t�� }|�|� | �|j� | �d|j� | �dt|j �� | � |� � � d S )Nc @ r4 )z3PyUnitResultTests.test_failure.<locals>.FailureTestFc S s d| _ | �d� d S )NTzboom!)r �failr7 r r r r u s z<PyUnitResultTests.test_failure.<locals>.FailureTest.test_fooNr: r r r r � FailureTestr r< rC r r ) r r r= r0 r r r> r? �lenr$ � assertFalser@ )r rC r r2 r r r � test_failureq s z PyUnitResultTests.test_failurec C sZ | � d�}t�� }|�|� | �|j� | �d|j� | �dt|j �� | � |� � � d S )Nr r ) r" r r= r0 r r r> r? rD r# rE r@ )r r r2 r r r � test_error� s z PyUnitResultTests.test_errorc C sh G dd� dt �}|d�}t�� }|�|� | �|j� | �d|j� | �dt|j �� | �|� � � d S )Nc @ s e Zd ZdZdd� Zdd� ZdS )z4PyUnitResultTests.test_setUpError.<locals>.ErrorTestFc S � dd d S �Nr r r r r r r r � s z:PyUnitResultTests.test_setUpError.<locals>.ErrorTest.setUpc S r5 r6 r r7 r r r r � r9 z=PyUnitResultTests.test_setUpError.<locals>.ErrorTest.test_fooN)r r r r r r r r r r r" � s r" r r ) r r r= r0 rE r r> r? rD r# r@ )r r" r r2 r r r �test_setUpError� s z!PyUnitResultTests.test_setUpErrorc C sp zdd W n t y t�� }t� }Y nw t�� }t|�}|�| |� | �|j d d d� t j |� �� dS )z� Errors added through the L{PyUnitResultAdapter} have the same traceback information as if there were no adapter at all. r r � N) �ZeroDivisionError�sys�exc_infor r r= r r. r> r# �join� traceback�format_exception�r rN �f�pyresultr2 r r r �test_tracebackFromFailure� s � �z+PyUnitResultTests.test_tracebackFromFailurec C s� G dd� dt �}|d�}t�� }|�|� d�t�|jd ��}d�|jd d � � d d � �}| � |� � |t |� d � � � � d S ) zG As test_tracebackFromFailure, but covering more code. c @ s e Zd ZdZdd� ZdS )z3PyUnitResultTests.test_traceback.<locals>.ErrorTestNc S s* zdd W d S t y t�� | _� w rI )rL rM rN r r r r r � s �z<PyUnitResultTests.test_traceback.<locals>.ErrorTest.test_foo)r r r rN r r r r r r" � r< r" r rK � � r r N���) r r r= r0 rO rP � format_tbrN r# � splitlinesr> �striprD )r r" r r2 �expected_stack�observed_stackr r r �test_traceback� s �z PyUnitResultTests.test_tracebackc C sx zdd W n t y t�� }t� }Y nw |�� t�� }t|�}|�| |� | � |j d d d� t j |� �� dS )z� Errors added through the L{PyUnitResultAdapter} have the same traceback information as if there were no adapter at all, even if the Failure that held the information has been cleaned. r r rK N)rL rM rN r � cleanFailurer r= r r. r> r# rO rP rQ rR r r r � test_tracebackFromCleanFailure� s � �z0PyUnitResultTests.test_tracebackFromCleanFailurec C �B G dd� dt �}|d�}t�� }|�|� | �|j|dfg� dS )zw Skips using trial's skipping functionality are reported as skips in the L{pyunit.TestResult}. c @ s e Zd Zedd�dd� �ZdS )z2PyUnitResultTests.test_trialSkip.<locals>.SkipTestT� Let's skip!c S rH rI r r r r r � test_skip� � z<PyUnitResultTests.test_trialSkip.<locals>.SkipTest.test_skipN)r r r r rc r r r r �SkipTest� � re rc rb N�r r r= r0 r> �skipped�r re r r2 r r r �test_trialSkip� � z PyUnitResultTests.test_trialSkipc C ra )zx Skips using pyunit's skipping functionality are reported as skips in the L{pyunit.TestResult}. c @ s e Zd Ze�d�dd� �ZdS )z3PyUnitResultTests.test_pyunitSkip.<locals>.SkipTest�skippyc S rH rI r r r r r rc � rd z=PyUnitResultTests.test_pyunitSkip.<locals>.SkipTest.test_skipN)r r r r �skiprc r r r r re � rf re rc rl Nrg ri r r r �test_pyunitSkip� rk z!PyUnitResultTests.test_pyunitSkipN)r r r r! r r" r3 rA rF rG rJ rU r^ r` rj rn r r r r r ! s ( ! r )rM rP �unittestr r �zope.interfacer �twisted.python.failurer �twisted.trial.itrialr r �twisted.trial.unittestr r r r r r r r �<module> s PK Mb�ZK�a� � � 2 trial/test/__pycache__/test_runner.cpython-310.pycnu �[��� o �b� � @ s� d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dl m Z d dl m Z d dl mZ d dlmZ d dlmZ d d lmZmZmZ d d lmZ d d lmZ d d lm Z d d l m Z m Z mZm Z d dl!m"Z" d dl#m$Z$m%Z% G dd� d�Z&e e$�G dd� d��Z'G dd� d�Z(G dd� de(ej)�Z*G dd� de(ej)�Z+G dd� d�Z,G d d � d e,ej)�Z-G d d � d e,ej)�Z.G d d!� d!e,ej)�Z/G d"d#� d#ej)�Z0G d$d%� d%ej)�Z1G d&d'� d'ej)�Z2G d(d)� d)e2�Z3G d*d+� d+e j4�Z5G d,d-� d-ej)�Z6G d.d/� d/ej)�Z7G d0d1� d1�Z8G d2d3� d3e8e7�Z9G d4d5� d5e8e7�Z:G d6d7� d7ej)�Z;G d8d9� d9ej)�Z<G d:d;� d;ej)�Z=G d<d=� d=ej)�Z>G d>d?� d?ej)�Z?dS )@� N)�StringIO)�List)� implementer)� verifyObject)�plugin)�defer)� twisted_trial)�failure�log�reflect)�FilePath��namedAny)�trial)�reporter�runner�unittest�util)� _ForceGarbageCollectionDecorator)� IReporter� ITestCasec @ s e Zd Zdd� Zdd� ZdS )�CapturingDebuggerc C � g | _ d S �N)�_calls��self� r �@/usr/lib/python3/dist-packages/twisted/trial/test/test_runner.py�__init__ � zCapturingDebugger.__init__c O s* | j �d� |d |dd � i |�� d S )N�runcallr � �r �append)r �args�kwargsr r r r! " s zCapturingDebugger.runcallN)�__name__� __module__� __qualname__r r! r r r r r s r c @ s� e Zd ZdZdZdZdZdZdZddd�Z dd� Z dd� Z d d � Z d d � Z d d� Zdd� Zdd� Zd dd�Zd dd�Zdd� Zdd� ZdS ) �CapturingReporterzC Reporter that keeps a log of all actions performed on it. Nc C s( g | _ d| _|| _|| _|| _|| _dS )z. Create a capturing reporter. FN)r � shouldStop�_stream� _tbformat� _rterrors� _publisher)r �stream�tbformat�rterrors� publisherr r r r 3 s zCapturingReporter.__init__c C � | j �d� dS )z� Report the beginning of a run of a single test method @param method: an object that is adaptable to ITestMethod � startTestNr# �r �methodr r r r5 > � zCapturingReporter.startTestc C r4 )z} Report the status of a single test method @param method: an object that is adaptable to ITestMethod �stopTestNr# r6 r r r r9 E r8 zCapturingReporter.stopTestc C r4 )z�called when the reactor has been left in a 'dirty' state @param errs: a list of L{twisted.python.failure.Failure}s � cleanupErrorNr# )r �errsr r r � cleanupErrorsL � z CapturingReporter.cleanupErrorsc C s | j �d� d S )N� addSuccessr# �r �testr r r r> R � z CapturingReporter.addSuccessc C � dS )z@ Do nothing. These tests don't care about done. Nr r r r r �doneU � zCapturingReporter.donec C rB )zD Do nothing. These tests don't care about addError. Nr �r r@ �errorr r r �addErrorZ rD zCapturingReporter.addErrorc C rB )zF Do nothing. These tests don't care about addFailure. Nr )r r@ r r r r � addFailure_ rD z CapturingReporter.addFailurec C rB )zN Do nothing. These tests don't care about addExpectedFailure. Nr )r r@ r �todor r r �addExpectedFailured rD z$CapturingReporter.addExpectedFailurec C rB )zP Do nothing. These tests don't care about addUnexpectedSuccess. Nr )r r@ rI r r r �addUnexpectedSuccessi rD z&CapturingReporter.addUnexpectedSuccessc C rB )zC Do nothing. These tests don't care about addSkip. Nr )r r@ �reasonr r r �addSkipn rD zCapturingReporter.addSkipc C rB )zI Do nothing. These tests don't care about wasSuccessful. Nr r r r r � wasSuccessfuls rD z CapturingReporter.wasSuccessful)NNNNr )r' r( r) �__doc__r0 r1 r% � separator�testsRunr r5 r9 r< r> rC rG rH rJ rK rM rN r r r r r* ' s& r* c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�TrialRunnerTestsMixinz9 Mixin defining tests for L{runner.TrialRunner}. c C s | j �� d S r )r �_tearDownLogFiler r r r �tearDown~ � z TrialRunnerTestsMixin.tearDownc C rB )z= Empty test method, used by the other tests. Nr r r r r � test_empty� rD z TrialRunnerTestsMixin.test_emptyc C s t jjS r )r �theLogPublisher� observersr r r r � _getObservers� s z#TrialRunnerTestsMixin._getObserversc C s6 t | �� �}| j�| j� t | �� �}| �||� dS )zn Any log system observers L{TrialRunner.run} adds are removed by the time it returns. N)�lenrY r �runr@ � assertEqual)r � originalCount�newCountr r r �test_addObservers� s z'TrialRunnerTestsMixin.test_addObserversc sl �j j�g � � ��fdd�}|�j _�j ��j� �j ��j� ��t� �d� ��� d � d u d� dS )z= Test that a new file is opened on each run. c � �� � � �jj� d S r )r$ r �_logFileObserverr ��l�oldSetUpLogFiler r r � setUpLogFile� � zDTrialRunnerTestsMixin.test_logFileAlwaysActive.<locals>.setUpLogFile� r r" z'Should have created a new file observerN)r � _setUpLogFiler[ r@ r\ rZ � assertFalse�r re r rb r �test_logFileAlwaysActive� s z.TrialRunnerTestsMixin.test_logFileAlwaysActivec sV �j j�g � � ��fdd�}|�j _�j ��j� ��t� �d� ��� d j� dS )zB Test that file created is closed during the run. c r` r )r$ r �_logFileObjectr rb r r re � rf zBTrialRunnerTestsMixin.test_logFileGetsClosed.<locals>.setUpLogFiler" r N)r rh r[ r@ r\ rZ � assertTrue�closedrj r rb r �test_logFileGetsClosed� s z,TrialRunnerTestsMixin.test_logFileGetsClosedN) r' r( r) rO rT rV rY r_ rk ro r r r r rR y s rR c @ � e Zd ZdZdd� Zdd� ZdS )�TrialRunnerTestszm Tests for L{runner.TrialRunner} with the feature to turn unclean errors into warnings disabled. c C s( t � | _tjt| jd�| _td�| _d S )N�r0 rV �r r0 r � TrialRunnerr* rq r@ r r r r �setUp� s zTrialRunnerTests.setUpc C s | j �� }| �|jt� dS )z� The reporter constructed by L{runner.TrialRunner} is passed L{twisted.python.log} as the value for the C{publisher} parameter. N)r � _makeResult�assertIdenticalr/ r �r �resultr r r �test_publisher� s z TrialRunnerTests.test_publisherN)r' r( r) rO ru rz r r r r rq � s rq c @ � e Zd ZdZdd� ZdS )�+TrialRunnerWithUncleanWarningsReporterTestsza Tests for the TrialRunner's interaction with an unclean-error suppressing reporter. c C s* t � | _tjt| jdd�| _td�| _d S )NT�r0 �uncleanWarningsrV rs r r r r ru � s �z1TrialRunnerWithUncleanWarningsReporterTests.setUpN�r' r( r) rO ru r r r r r| � s r| c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � DryRunMixinze Mixin for testing that 'dry run' mode works with various L{pyunit.TestCase} subclasses. c C s2 g | _ t� | _tjttjj| jd�| _| �� d S )Nrr )r r r0 r rt r* �DRY_RUN�makeTestFixturesr r r r ru � s � zDryRunMixin.setUpc C rB )zh Set C{self.test} and C{self.suite}, where C{self.suite} is an empty TestSuite. Nr r r r r r� � rD z DryRunMixin.makeTestFixturesc C s" | j �t �� �}| �|jg � dS )zf If there are no tests, the reporter should not receive any events to report. N)r r[ � TestSuiter\ r rx r r r rV � s zDryRunMixin.test_emptyc C s$ | j �| j�}| �|jg d�� dS )z� If we are running a single test, check the reporter starts, passes and then stops the test during a dry run. )r5 r> r9 N)r r[ r@ r\ r rx r r r �test_singleCaseReporting� s z$DryRunMixin.test_singleCaseReportingc C s | j �| j� | �| jg � dS )zT When we are doing a dry run, the tests should not actually be run. N)r r[ r@ r\ r r r r r �test_testsNotRun� s z DryRunMixin.test_testsNotRunN) r' r( r) rO ru r� rV r� r� r r r r r� � s r� c @ r{ )�SynchronousDryRunTestszS Check that 'dry run' mode works well with trial's L{SynchronousTestCase}. c C s* G dd� dt j�}|d�| _t�� | _d S )Nc @ � e Zd Zdd� ZdS )z;SynchronousDryRunTests.makeTestFixtures.<locals>.PyunitCasec S � d S r r r r r r �test_foo � zDSynchronousDryRunTests.makeTestFixtures.<locals>.PyunitCase.test_fooN�r' r( r) r� r r r r � PyunitCase � r� r� )r �SynchronousTestCaser@ �pyunitr� �suite�r r� r r r r� � z'SynchronousDryRunTests.makeTestFixturesN�r' r( r) rO r� r r r r r� � r� c @ r{ )� DryRunTestsz@ Check that 'dry run' mode works well with Trial tests. c s. G � fdd�dt j�}|d�� _t�� � _d S )Nc � e Zd Z� fdd�ZdS )z.DryRunTests.makeTestFixtures.<locals>.MockTestc s � j �d� d S )Nr� )r r$ �r@ r r r r� rA z7DryRunTests.makeTestFixtures.<locals>.MockTest.test_fooNr� r r r r �MockTest � r� r� )r �TestCaser@ r r� r� )r r� r r r r� s z DryRunTests.makeTestFixturesNr� r r r r r� r� r� c @ r{ )�PyUnitDryRunTestszJ Check that 'dry run' mode works well with stdlib unittest tests. c C s* G dd� dt j�}|d�| _t �� | _d S )Nc @ r� )z6PyUnitDryRunTests.makeTestFixtures.<locals>.PyunitCasec S r� r r r r r r r� ( r� z?PyUnitDryRunTests.makeTestFixtures.<locals>.PyunitCase.test_fooNr� r r r r r� ' r� r� r� )r� r� r@ r� r� r� r r r r� & r� z"PyUnitDryRunTests.makeTestFixturesNr� r r r r r� ! r� r� c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Ze� Zd!d"� Zd#d$� Zd%S )&� RunnerTestsc sv t �� �_t�t��d�}d�|d d� �}|d }tj d|ddd |d�g� � �fdd�}t j �_ |t _ g d ��_ d S ) N�.���zTest Helper ReporterzUtility for unit testing.� capturing)� description�longOpt�shortOpt�klassc s, �� | t� � t�j| g|�R i |��� S r )r\ r �list�original)�iface�a�kw��pluginsr r r � getPluginsE s z%RunnerTests.setUp.<locals>.getPlugins) r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 )r �Options�configr �qualr* �split�joinr � _Reporterr r� r� �standardReport)r �parts�packager� r� r r� r ru 0 s" �� zRunnerTests.setUpc C s | j t_d S r )r� r r� r r r r rT m s zRunnerTests.tearDownc C s | j �|� d S r )r� � parseOptions�r r% r r r r� p rA zRunnerTests.parseOptionsc C s. t �| j�}t� |_| �|j� t�� |_ |S r ) r � _makeRunnerr� r r0 � addCleanuprS r � LogPublisher�_log)r �rr r r � getRunners s zRunnerTests.getRunnerc C s2 | � g � | jd }| �� }| �||�� j� d S �Nr )r� r� r� r\ rv � __class__)r ry r r r r � test_runner_can_get_reporter� s z(RunnerTests.test_runner_can_get_reporterc C s2 | � g � | �� }|�� }| �|j| jd � d S r� )r� r� rv r\ r� r� �r r ry r r r �test_runner_get_result� s z"RunnerTests.test_runner_get_resultc C s( | � g � | �� }| �|�� tj� dS )z� By default Trial sets the 'uncleanWarnings' option on the runner to False. This means that dirty reactor errors will be reported as errors. See L{test_reporter.DirtyReactorTests}. N)r� r� �assertNotIsInstancerv r � UncleanWarningsReporterWrapper�r r r r r � test_uncleanWarningsOffByDefault� s �z,RunnerTests.test_uncleanWarningsOffByDefaultc C s* | � dg� | �� }| �|�� tj� dS )z� Specifying '--unclean-warnings' on the trial command line will cause reporters to be wrapped in a device which converts unclean errors to warnings. See L{test_reporter.DirtyReactorTests} for implications. z--unclean-warningsN)r� r� �assertIsInstancerv r r� r� r r r �test_getsUncleanWarnings� s �z$RunnerTests.test_getsUncleanWarningsc C s( | � ddg� | �� }| �|jd� d S )N�--temp-directory� some_path)r� r� r\ �workingDirectoryr� r r r � test_runner_working_directory� s z)RunnerTests.test_runner_working_directoryc s� | � g � | �tjt�� � t| �� ����� t��j� | � � }| � � �i �G � ���fdd�dt j �� |� � d��}|j |j }|rN| �|d d � | ����d�j��d�jd�� d S ) z� If no working directory is explicitly specified and the default working directory is in use by another runner, L{TrialRunner.run} selects a different default working directory to use. c s* e Zd Z� ���fdd�Z�fdd�ZdS )zKRunnerTests.test_concurrentImplicitWorkingDirectory.<locals>.ConcurrentCasec s< t �� �d< }t ��j� | �t j|� ��� d�� dS )z� Start a second test run which will have a default working directory which is the same as the working directory of the test run already in progress. � concurrent� test_secondN)�os�getcwd�chdir�pathr� r[ )r �subsequentDirectory��ConcurrentCase� runDirectory� secondRunner�wherer r � test_first� s zVRunnerTests.test_concurrentImplicitWorkingDirectory.<locals>.ConcurrentCase.test_firstc s t �� � d< dS )zR Record the working directory for later analysis. �recordN)r� r� r )r� r r r� � r= zWRunnerTests.test_concurrentImplicitWorkingDirectory.<locals>.ConcurrentCase.test_secondN)r' r( r) r� r� r r� r r r� � s r� r� r r" � _trial_tempz _trial_temp-1)r� r� N)r� r� r� r� r� r �mktemp�makedirsr� r� r r� r[ �errors�failures�failr\ �child)r � firstRunnerry �badr r� r �'test_concurrentImplicitWorkingDirectory� s& ��z3RunnerTests.test_concurrentImplicitWorkingDirectoryc s� | � dtj�| �� �g� t�� }| �tj|� | �� }| �� �G � �fdd�dt j �� |� � d��}|j |j }|rF| �|d d � dS dS )z� If a working directory which is already in use is explicitly specified, L{TrialRunner.run} raises L{_WorkingDirectoryBusy}. r� c s" e Zd Z� �fdd�Zdd� ZdS )zKRunnerTests.test_concurrentExplicitWorkingDirectory.<locals>.ConcurrentCasec s | � tj�j� d�� dS )z� Try to start another runner in the same working directory and assert that it raises L{_WorkingDirectoryBusy}. � test_failureN)� assertRaisesr �_WorkingDirectoryBusyr[ r �r� r� r r �test_concurrent� s �z[RunnerTests.test_concurrentExplicitWorkingDirectory.<locals>.ConcurrentCase.test_concurrentc S � | � d� dS )zE Should not be called, always fails. z$test_failure should never be called.N)r� r r r r r� � � zXRunnerTests.test_concurrentExplicitWorkingDirectory.<locals>.ConcurrentCase.test_failureN)r' r( r) r� r� r r� r r r� � s r� r� r r" N)r� r� r� �abspathr� r� r� r� r� r r� r[ r� r� r� )r �initialDirectoryr� ry r� r r� r �'test_concurrentExplicitWorkingDirectory� s �z3RunnerTests.test_concurrentExplicitWorkingDirectoryc C sR | � d| �� dddg� | �� }t�� }|�dd�}|�|�}| �| j|j � d S )Nr� � --reporterr� �twisted.trial.test.sampleT) r� r� r� r � TestLoader� loadByNamer[ r\ r� r )r � my_runner�loaderr� ry r r r �test_runner_normal s �� z RunnerTests.test_runner_normalc C s t �� }|�dd�}|�|�S )Nr� T)r r� r� r[ )r r� r� r� r r r �runSampleSuite s zRunnerTests.runSampleSuitec C sP | � g d�� | �� }t� }|_| �|�}| �| j|j� | �dg|j� dS )zL Trial uses its debugger if the `--debug` option is passed. )r� r� �--debugr� r! N)r� r� r �debuggerr� r\ r� r )r r� r� ry r r r �test_runnerDebug s � z RunnerTests.test_runnerDebugc s^ � � ddg� td�}|�� d� _� fdd�}� �tjd|� � �� �� � � � � j� dS ) zL Trial uses pdb if no debugger is specified by `--debugger` r� r� �pdbrcFc � d� _ d S �NT��runcall_called��pdbr� ry r r r r! 5 r z=RunnerTests.test_runnerDebuggerDefaultsToPdb.<locals>.runcallr! N) r� r �touchr� �patchr� �Pdbr� r� rm )r � pdbrcFiler! r r r � test_runnerDebuggerDefaultsToPdb+ s z,RunnerTests.test_runnerDebuggerDefaultsToPdbc sN � � g d�� d� _� fdd�}� �tjd|� � �� �� � � �� j� dS )zU Trial uses pdb if pdb is passed explicitly to the `--debugger` arg. )r� r� � --debuggerr� r� r� Fc r� r� r� r� r r r r! O r zGRunnerTests.test_runnerDebuggerWithExplicitlyPassedPdb.<locals>.runcallr! N)r� r� r r� r r� r� rm )r r! r r r �*test_runnerDebuggerWithExplicitlyPassedPdb> s � z6RunnerTests.test_runnerDebuggerWithExplicitlyPassedPdbc C sF | � g d�� | �� }| �|�}| �| j|j� | �dg|jj� dS )zM Trial uses specified debugger if the debugger is available. )r� r� r z4twisted.trial.test.test_runner.RunnerTests.cdebuggerr� r� r! N)r� r� r� r\ r� r r� )r r� ry r r r �test_runnerDebuggerZ s � z RunnerTests.test_runnerDebuggerc C s. | � dg� | �� }|�� }| �|tj� dS )z� If trial was passed the C{--exitfirst} option, the constructed test result object is wrapped with L{reporter._ExitWrapper}. z --exitfirstN)r� r� rv r� r � _ExitWrapperr� r r r �test_exitfirstm s zRunnerTests.test_exitfirstN)r' r( r) ru rT r� r� r� r� r� r� r� r� r� r� r� r� r r r � cdebuggerr r r r r r r� / s( = 9$ r� c @ r� )�TrialSuiteTestsc C s t d� d S )Nz twisted.trial.runner.TrialSuiter r r r r � test_importsy s z TrialSuiteTests.test_importsN)r' r( r) r r r r r r x r� r c @ sF e Zd ZG dd� dej�Zdd� Zdd� Zdd� Zd d � Z d d � Z d S )�UntilFailureTestsc @ s* e Zd ZU dZg Zed ed< dd� ZdS )zUntilFailureTests.FailAfterzC A test case that fails when run 3 times in a row. N�countc C s, | j �d � t| j �dkr| �d� d S d S )N� zCount reached 3)r r$ rZ r� r r r r r� � s �z$UntilFailureTests.FailAfter.test_foo)r' r( r) rO r r �__annotations__r� r r r r � FailAfter s r c C s4 g t j_t �d�| _t� | _tjtj | jd�| _d S )Nr� rr ) r r r r@ r r0 r rt r �Reporterr r r r ru � s zUntilFailureTests.setUpc C s@ | j �| j�}| �|jd� | �|�� � | �| �|�d� dS )zl Test that the runUntilFailure method of the runner actually fail after a few runs. r" N)r �runUntilFailurer@ r\ rQ ri rN � _getFailuresrx r r r �test_runUntilFailure� s z&UntilFailureTests.test_runUntilFailurec C s t |j�S )zL Get the number of failures that were reported to a result. )rZ r� rx r r r r � s z UntilFailureTests._getFailuresc sb g � � fdd�}| � td|� | j�| j�}| �|jd� | �t� �d� | �� | jtfg� dS )z� C{runUntilFailure} doesn't decorate the tests uselessly: it does it one time when run starts, but not at each turn. c � � � | |f� | S r �r$ �r@ � interface�� decoratedr r �decorate� � z@UntilFailureTests.test_runUntilFailureDecorate.<locals>.decorater r" N) r r r r r@ r\ rQ rZ r �r r ry r r r � test_runUntilFailureDecorate� s z.UntilFailureTests.test_runUntilFailureDecoratec sr g � � fdd�}| � td|� d| j_| j�| j�}| �|jd� | �t� �d� | �� | jt f| jt fg� dS )z� C{runUntilFailure} applies the force-gc decoration after the standard L{ITestCase} decoration, but only one time. c r r r r r r r r � r zGUntilFailureTests.test_runUntilFailureForceGCDecorate.<locals>.decorater Tr" rg N) r r r �_forceGarbageCollectionr r@ r\ rQ rZ r r r r r r �#test_runUntilFailureForceGCDecorate� s �z5UntilFailureTests.test_runUntilFailureForceGCDecorateN) r' r( r) r� r� r ru r r r r! r r r r r ~ s r c @ rp )�UncleanUntilFailureTestszh Test that the run-until-failure feature works correctly with the unclean error suppressor. c C s$ t �| � tjtj| jdd�| _d S )NTr} )r ru r rt r r r0 r r r r ru � s �z UncleanUntilFailureTests.setUpc C s t |jj�S )z� Get the number of failures that were reported to a result that is wrapped in an UncleanFailureWrapper. )rZ �_originalReporterr� rx r r r r � � z%UncleanUntilFailureTests._getFailuresN)r' r( r) rO ru r r r r r r" � s r" c @ r{ )� BreakingSuitez; A L{TestSuite} that logs an error when it is run. c C s, zt d�� t y t�t�� � Y d S w )Nz#error that occurs outside of a test)� RuntimeErrorr �errr �Failurerx r r r r[ � s �zBreakingSuite.runN)r' r( r) rO r[ r r r r r% � r� r% c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �LoggedErrorsTestsa It is possible for an error generated by a test to be logged I{outside} of any test. The log observers constructed by L{TestCase} won't catch these errors. Here we try to generate such errors and ensure they are reported to a L{TestResult} object. c C s | � t� d S r )�flushLoggedErrorsr& r r r r rT � rU zLoggedErrorsTests.tearDownc C s t �� }| �|�� d� dS )zg Check that we can construct a L{runner.LoggedSuite} and that it starts empty. r N)r � LoggedSuiter\ �countTestCases)r r� r r r �test_construct� s z LoggedErrorsTests.test_constructc C sl t �� }t�t� g�}|�|� | �t|j�d� | �|jd d � � tj � | � |jd d � t �� dS )zU Chek that a L{LoggedSuite} reports any logged errors to its result. r" r N)r � TestResultr r, r% r[ r\ rZ r� �id� NOT_IN_TESTrm �checkr& )r ry r� r r r �test_capturesError� s z$LoggedErrorsTests.test_capturesErrorN)r' r( r) rO rT r. r3 r r r r r* � s r* c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �TestHolderTestsc C s d| _ t�| j �| _d S �Nr� )r� r � TestHolder�holderr r r r ru rf zTestHolderTests.setUpc C s, | � | j�� | j� | � | j�� | j� dS )z� Check that L{runner.TestHolder} takes a description as a parameter and that this description is returned by the C{id} and C{shortDescription} methods. N)r\ r7 r0 r� �shortDescriptionr r r r � test_holder s zTestHolderTests.test_holderc C s6 | � | jt| j�� | �tt| j�d| jtf � dS )z? L{runner.TestHolder} implements L{ITestCase}. z5%r claims to provide %r but does not do so correctly.N)rw r7 r rm r r r r r � test_holderImplementsITestCase s ��z.TestHolderTests.test_holderImplementsITestCasec C �4 t �� }| j�|� | �|�� � | �d|j� dS )zc A L{runner.TestHolder} can run against the standard Python C{TestResult}. r" N)r� r/ r7 r[ rm rN r\ rQ rx r r r �test_runsWithStandardResult" � z+TestHolderTests.test_runsWithStandardResultN)r' r( r) ru r9 r: r< r r r r r4 s r4 c @ sN e Zd ZdZed�ZG dd� d�Zdd� Zdd� Zd d � Z d d � Z d d� Z dS )�ErrorHolderTestsMixinaa This mixin defines test methods which can be applied to a L{runner.ErrorHolder} constructed with either a L{Failure} or a C{exc_info}-style tuple. Subclass this and implement C{setUp} to create C{self.holder} referring to a L{runner.ErrorHolder} instance and C{self.error} referring to a L{Failure} which the holder holds. z"integer division or modulo by zeroc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) z$ErrorHolderTestsMixin.TestResultStubz) Stub for L{TestResult}. c C r r )r� r r r r r ? r z-ErrorHolderTestsMixin.TestResultStub.__init__c C r� r r r? r r r r5 B r� z.ErrorHolderTestsMixin.TestResultStub.startTestc C r� r r r? r r r r9 E r� z-ErrorHolderTestsMixin.TestResultStub.stopTestc C s | j �||f� d S r )r� r$ rE r r r rG H s z-ErrorHolderTestsMixin.TestResultStub.addErrorN)r' r( r) rO r r5 r9 rG r r r r �TestResultStub: s r? c C r; )zd A L{runner.ErrorHolder} can run against the standard Python C{TestResult}. r" N)r� r/ r7 r[ ri rN r\ rQ rx r r r r< K r= z1ErrorHolderTestsMixin.test_runsWithStandardResultc C s< | j �| j� | �| jj| j | jj| jj| jjffg� dS )zM L{runner.ErrorHolder} adds an error to the result when run. N) r7 r[ ry r\ r� rF �type�value�tbr r r r �test_runU s �z ErrorHolderTestsMixin.test_runc C s: | � | j� | �| jj| j | jj| jj| jjffg� dS )zP L{runner.ErrorHolder} adds an error to the result when called. N)r7 ry r\ r� rF r@ rA rB r r r r � test_call_ s �z ErrorHolderTestsMixin.test_callc C s | � | j�� d� dS )zH L{runner.ErrorHolder.countTestCases} always returns 0. r N)r\ r7 r- r r r r �test_countTestCasesi s z)ErrorHolderTestsMixin.test_countTestCasesc C s, d� t| jjd ��}| �t| j�|� dS )zh L{runner.ErrorHolder.__repr__} returns a string describing the error it holds. z0<ErrorHolder description='description' error={}>r" N)�format�reprr7 rF r\ )r �expectedr r r � test_repro s �z ErrorHolderTestsMixin.test_reprN) r' r( r) rO �ZeroDivisionError�exceptionForTestsr? r< rC rD rE rI r r r r r> - s r> c @ r{ )� FailureHoldingErrorHolderTestsz� Tests for L{runner.ErrorHolder} behaving similarly to L{runner.TestHolder} when constructed with a L{Failure} representing its error. c C sJ d| _ z| j� ty t�� | _Y nw t�| j | j�| _| � � | _ d S r5 ) r� rK rJ r r( rF r � ErrorHolderr7 r? ry r r r r ru � s �z$FailureHoldingErrorHolderTests.setUpNr r r r r rL { � rL c @ r{ )� ExcInfoHoldingErrorHolderTestsz� Tests for L{runner.ErrorHolder} behaving similarly to L{runner.TestHolder} when constructed with a C{exc_info}-style tuple representing its error. c C sP d| _ z| j� ty t�� }t�� | _Y nw t� | j |�| _ | � � | _ d S r5 ) r� rK rJ �sys�exc_infor r( rF r rM r7 r? ry )r � exceptionInfor r r ru � s �z$ExcInfoHoldingErrorHolderTests.setUpNr r r r r rO � rN rO c @ sB e Zd ZdZG dd� dej�Zdd� Zdd� Zdd � Z d d � Z d S ) �MalformedMethodTestszR Test that trial manages when test methods don't have correct signatures. c @ s* e Zd ZdZdd� Zdd� Ze�e�ZdS )z%MalformedMethodTests.ContainMalformedzV This TestCase holds malformed test methods that trial should handle. c C r� r r )r �blahr r r r� � r� z.MalformedMethodTests.ContainMalformed.test_fooc C r� r r r r r r �test_bar� r� z.MalformedMethodTests.ContainMalformed.test_barN) r' r( r) rO r� rU r �inlineCallbacks� test_spamr r r r �ContainMalformed� s rX c C s\ t � }tjtj|d�}t�|�}|�|�}| �|j d� | � |� � � | �t |j �d� dS )zL Wrapper for one of the test method of L{ContainMalformed}. rr r" N)r r rt r r rS rX r[ r\ rQ ri rN rZ r� )r r7 r0 � trialRunnerr@ ry r r r �_test� s zMalformedMethodTests._testc C r� )zE Test when the method has extra (useless) arguments. r� N�rZ r r r r � test_extraArg� r� z"MalformedMethodTests.test_extraArgc C r� )zJ Test when the method doesn't have even self as argument. rU Nr[ r r r r � test_noArg� r� z MalformedMethodTests.test_noArgc C r� )z5 Test a decorated method also fails. rW Nr[ r r r r �test_decorated� r� z#MalformedMethodTests.test_decoratedN) r' r( r) rO r� r� rX rZ r\ r] r^ r r r r rS � s rS c @ r) ) �DestructiveTestSuiteTestsz2 Test for L{runner.DestructiveTestSuite}. c sn g � G � fdd�dt j�}|d�}t�� }t�|g�}| �� g � |�|� | �� dg� | �|�� d� dS )zL Thes destructive test suite should run the tests normally. c r� )z6DestructiveTestSuiteTests.test_basic.<locals>.MockTestc � � � d� d S r� r r� ��calledr r r� � rU z?DestructiveTestSuiteTests.test_basic.<locals>.MockTest.test_fooNr� r ra r r r� � r� r� r� Tr N) r� r� r r/ r �DestructiveTestSuiter\ r[ r- �r r� r@ ry r� r ra r � test_basic� s z$DestructiveTestSuiteTests.test_basicc st g � G � fdd�dt j�}t�� }t�� }tj|_|�|�}| � � g � |� |� | � � dg� | � |� � d� dS )zu Test the C{shouldStop} management: raising a C{KeyboardInterrupt} must interrupt the suite. c s, e Zd Z� fdd�Zdd� Z� fdd�ZdS )z;DestructiveTestSuiteTests.test_shouldStop.<locals>.MockTestc r` )Nr" r r� ra r r � test_foo1� rU zEDestructiveTestSuiteTests.test_shouldStop.<locals>.MockTest.test_foo1c S s t � �r )�KeyboardInterruptr� r r r � test_foo2� s zEDestructiveTestSuiteTests.test_shouldStop.<locals>.MockTest.test_foo2c r` )Nrg r r� ra r r � test_foo3� rU zEDestructiveTestSuiteTests.test_shouldStop.<locals>.MockTest.test_foo3N)r' r( r) rf rh ri r ra r r r� � s r� r" N) r r� r r/ r r� rc � suiteFactory� loadClassr\ r[ r- )r r� ry r� r� r ra r �test_shouldStop� s z)DestructiveTestSuiteTests.test_shouldStopc C s\ G dd� dt j�}|d�}t�� }t�|g�}| �|�� d� |�|� | �|�� d� dS )zn Checks that the test suite cleanups its tests during the run, so that it ends empty. c @ r� )z8DestructiveTestSuiteTests.test_cleanup.<locals>.MockTestc S r� r r r� r r r r� r� zADestructiveTestSuiteTests.test_cleanup.<locals>.MockTest.test_fooNr� r r r r r� r� r� r� r" r N) r� r� r r/ r rc r\ r- r[ rd r r r � test_cleanup s z&DestructiveTestSuiteTests.test_cleanupN)r' r( r) rO re rl rm r r r r r_ � s r_ c @ s& e Zd ZG dd� dej�Zdd� ZdS )�RunnerDeprecationTestsc @ s< e Zd ZdZdZdZdZdd� Zdd� Zdd� Z d d � Z dS ) z#RunnerDeprecationTests.FakeReporterz� Fake reporter that does *not* implement done() but *does* implement printErrors, separator, printSummary, stream, write and writeln without deprecations. Nc G r� r r r� r r r � printErrors r� z/RunnerDeprecationTests.FakeReporter.printErrorsc G r� r r r� r r r � printSummary" r� z0RunnerDeprecationTests.FakeReporter.printSummaryc G r� r r r� r r r �write% r� z)RunnerDeprecationTests.FakeReporter.writec G r� r r r� r r r �writeln( r� z+RunnerDeprecationTests.FakeReporter.writeln) r' r( r) rO rC rP r0 ro rp rq rr r r r r � FakeReporter s rs c s� t �d��| �� � � fdd��_�fdd�}|� | �| jg�}| �|d d t� | �|d d d t� � j � � | � t � |d d �� | �t|�d � dS ) zk The runner emits a warning if it is using a result that doesn't implement 'done'. Nc s � S r r r )ry r r �<lambda>2 rD zBRunnerDeprecationTests.test_reporterDeprecations.<locals>.<lambda>c s � � t�d�� d S )Nr0 )r[ r� r� r )rY r r �f4 s z;RunnerDeprecationTests.test_reporterDeprecations.<locals>.fr �category�messagezR%s should implement done() but doesn't. Falling back to printErrors() and friends.�filenamer" )r rt rs rv � flushWarnings�test_reporterDeprecationsr\ �DeprecationWarningr r� r� rm �__file__� startswithrZ )r ru �warningsr )ry rY r rz + s ��z0RunnerDeprecationTests.test_reporterDeprecationsN)r' r( r) r r rs rz r r r r rn s rn c @ r{ )�QualifiedNameWalkerTestsz< Tests for L{twisted.trial.runner._qualNameWalker}. c C s6 t t�d��}| �|dg fddgfdddgfg� dS )z� C{_qualNameWalker} is a generator that, when given a Python qualified name, yields that name, and then the parent of that name, and so forth, along with a list of the tried components, in a 2-tuple. zwalker.texas.rangerz walker.texas�ranger�walker�texasN)r� r �_qualNameWalkerr\ )r � walkerResultsr r r �test_walksDownPathK s ��z+QualifiedNameWalkerTests.test_walksDownPathN)r' r( r) rO r� r r r r r F r� r c @ r{ )�TrialMainDoesNothingTestszl Importing L{twisted.trial.__main__} will not run the script unless it is actually C{__main__}. c C s t d� dS )zO If we import L{twisted.trial.__main__}, it should do nothing. ztwisted.trial.__main__N)� __import__r r r r �test_importDoesNothingc r$ z0TrialMainDoesNothingTests.test_importDoesNothingN)r' r( r) rO r� r r r r r� ] rN r� )@r� r� rP r r� �ior �typingr �zope.interfacer �zope.interface.verifyr �twistedr �twisted.internetr �twisted.pluginsr �twisted.pythonr r r �twisted.python.filepathr �twisted.python.reflectr �twisted.scriptsr � twisted.trialr r r �twisted.trial._asyncrunnerr �twisted.trial.itrialr r r r* rR r� rq r| r� r� r� r� r� r r r" r� r% r* r4 r> rL rO rS r_ rn r r� r r r r �<module> s^ Q< �, KL $N1D3PK Mb�Zz�� / / 1 trial/test/__pycache__/moduletest.cpython-310.pycnu �[��� o �b. � @ s G d d� d�Z dS )c @ s e Zd ZdS )�FooN)�__name__� __module__� __qualname__� r r �?/usr/lib/python3/dist-packages/twisted/trial/test/moduletest.pyr s r N)r r r r r �<module> s PK Mb�Z�:Ѩ5 5 1 trial/test/__pycache__/ordertests.cpython-310.pycnu �[��� o �b` � @ sJ d Z ddlmZ G dd� dej�ZG dd� dej�ZG dd� dej�Zd S ) z/ Tests for handling of trial's --order option. � )�unittestc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �FooTestzK Used to make assertions about the order its tests will be run in. c C � d S �N� ��selfr r �?/usr/lib/python3/dist-packages/twisted/trial/test/ordertests.py� test_first � zFooTest.test_firstc C r r r r r r r � test_second r zFooTest.test_secondc C r r r r r r r � test_third r zFooTest.test_thirdc C r r r r r r r � test_fourth r zFooTest.test_fourthN)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s r c @ � e Zd ZdZdd� ZdS )�BazTest�_ Used to make assertions about the order the test cases in this module are run in. c C r r r r r r r �test_baz$ r zBazTest.test_bazN)r r r r r r r r r r � r c @ r )�BarTestr c C r r r r r r r �test_bar. r zBarTest.test_barN)r r r r r r r r r r ( r r N)r � twisted.trialr �TestCaser r r r r r r �<module> s PK Mb�Z��-}�% �% / trial/test/__pycache__/skipping.cpython-310.pycnu �[��� o �bM � @ s d Z ddlmZmZmZmZ G dd� d�ZG dd� dee�ZG dd� dee�ZG d d � d �Z G d d � d e e�Z G d d� de e�Z G dd� d�Z G dd� de e�Z G dd� de e�ZG dd� d�ZG dd� dee�ZG dd� dee�ZG dd � d �ZG d d � d ee�ZG d d � d ee�ZG d!d"� d"�ZG d#d$� d$ee�ZG d%d&� d&ee�ZG d'd(� d(�ZG d)d*� d*ee�ZG d+d,� d,ee�ZG d-d.� d.�ZG d/d0� d0ee�Z G d1d2� d2ee�Z G d3d4� d4�Z G d5d6� d6e e�Z G d7d8� d8e e�Z G d9d:� d:�Z!G d;d<� d<e!e�Z"G d=d>� d>e!e�Z#d?S )@a$ Definitions of test cases with various interesting behaviors, to be used by L{twisted.trial.test.test_tests} and other test modules to exercise different features of trial's test runner. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. � )�FailTest�SkipTest�SynchronousTestCase�TestCasec @ s0 e Zd Zdd� Zdd� Zde_dd� Zde_d S ) � SkippingMixinc C � t d���N�skip1�r ��self� r �=/usr/lib/python3/dist-packages/twisted/trial/test/skipping.py� test_skip1 � zSkippingMixin.test_skip1c C r )NzI should not get raised�� RuntimeErrorr r r r � test_skip2 r zSkippingMixin.test_skip2�skip2c C � | � d� d S )NzI should not fail��failr r r r � test_skip3 � zSkippingMixin.test_skip3�skip3N)�__name__� __module__� __qualname__r r �skipr r r r r r s r c @ � e Zd ZdS )�SynchronousSkippingN�r r r r r r r r ! � r c @ r )�AsynchronousSkippingNr! r r r r r# % r" r# c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�SkippingSetUpMixinc C r )N� skipSetUpr r r r r �setUp* r zSkippingSetUpMixin.setUpc C � d S �Nr r r r r �test_1- � zSkippingSetUpMixin.test_1c C r' r( r r r r r �test_20 r* zSkippingSetUpMixin.test_2N)r r r r& r) r+ r r r r r$ ) s r$ c @ r )�SynchronousSkippingSetUpNr! r r r r r, 4 r" r, c @ r )�AsynchronousSkippingSetUpNr! r r r r r- 8 r" r- c @ s e Zd Zdd� ZdS )� DeprecatedReasonlessSkipMixinc C s t � �r( r r r r r r) = s z$DeprecatedReasonlessSkipMixin.test_1N)r r r r) r r r r r. < s r. c @ r )�#SynchronousDeprecatedReasonlessSkipNr! r r r r r/ A s r/ c @ r )�$AsynchronousDeprecatedReasonlessSkipNr! r r r r r0 G r" r0 c @ s> e Zd ZdZdd� Zdd� Zdd� Zde_d d � Zd d � Zd S )�SkippedClassMixin�classc C s d| j _d S )NT)� __class__� _setUpRanr r r r r& N � zSkippedClassMixin.setUpc C r r r r r r r r Q r z SkippedClassMixin.test_skip1c C r )NzOught to skip mer r r r r r T r z SkippedClassMixin.test_skip2r c C r' r( r r r r r r Y r* z SkippedClassMixin.test_skip3c C r )Nz Skip me toor r r r r � test_skip4\ r z SkippedClassMixin.test_skip4N) r r r r r& r r r r6 r r r r r1 K s r1 c @ r )�SynchronousSkippedClassNr! r r r r r7 ` r" r7 c @ r )�AsynchronousSkippedClassNr! r r r r r8 d r" r8 c @ s6 e Zd Zdd� Zde_dd� Zde_dd� Zd e_d S ) � TodoMixinc C r �Nzdeliberate failurer r r r r � test_todo1i r zTodoMixin.test_todo1�todo1c C r �Nzdeliberate errorr r r r r � test_todo2n r zTodoMixin.test_todo2�todo2c C s dS )zunexpected successNr r r r r � test_todo3s s zTodoMixin.test_todo3�todo3N)r r r r; �todor> r@ r r r r r9 h s r9 c @ r )�SynchronousTodoNr! r r r r rC y r" rC c @ r )�AsynchronousTodoNr! r r r r rD } r" rD c @ �" e Zd Zdd� Zdd� Zde_dS )�SetUpTodoMixinc C r r= r r r r r r& � r zSetUpTodoMixin.setUpc C r' r( r r r r r r; � r* zSetUpTodoMixin.test_todo1z setUp todo1N)r r r r& r; rB r r r r rF � � rF c @ r )�SynchronousSetUpTodoNr! r r r r rH � r" rH c @ r )�AsynchronousSetUpTodoNr! r r r r rI � r" rI c @ rE )�TearDownTodoMixinc C r r= r r r r r �tearDown� r zTearDownTodoMixin.tearDownc C r' r( r r r r r r; � r* z TearDownTodoMixin.test_todo1ztearDown todo1N)r r r rK r; rB r r r r rJ � rG rJ c @ r )�SynchronousTearDownTodoNr! r r r r rL � r" rL c @ r )�AsynchronousTearDownTodoNr! r r r r rM � r" rM c @ s< e Zd ZdZdd� Zde_dd� Zdd� Zde_d d � Zd S ) �TodoClassMixinr2 c C r' r( r r r r r r; � r* zTodoClassMixin.test_todo1�methodc C r' r( r r r r r r> � r* zTodoClassMixin.test_todo2c C r �NzDeliberate Failurer r r r r r@ � r zTodoClassMixin.test_todo3c C r rP r r r r r � test_todo4� r zTodoClassMixin.test_todo4N)r r r rB r; r> r@ rQ r r r r rN � s rN c @ r )�SynchronousTodoClassNr! r r r r rR � r" rR c @ r )�AsynchronousTodoClassNr! r r r r rS � r" rS c @ s� e Zd Zdd� Zedfe_dd� Zeefdfe_dd� Zed fe_d d � Z ee fd fe _d d� Z e dfe _dd� Z edfe _dd� Zedfe_dS )�StrictTodoMixinc C r �Nzexpected failurer r r r r r; � r zStrictTodoMixin.test_todo1r< c C r rU r r r r r r> � r zStrictTodoMixin.test_todo2r? c C r �Nzwe had no idea!r r r r r r@ � r zStrictTodoMixin.test_todo3rA c C r rV r r r r r rQ � r zStrictTodoMixin.test_todo4�todo4c C r r: r r r r r � test_todo5� r zStrictTodoMixin.test_todo5�todo5c C r r: r r r r r � test_todo6� r zStrictTodoMixin.test_todo6�todo6c C r' r( r r r r r � test_todo7� r* zStrictTodoMixin.test_todo7�todo7N)r r r r; r rB r> �OSErrorr@ rQ � SyntaxErrorrX r rZ r\ r r r r rT � s rT c @ r )�SynchronousStrictTodoNr! r r r r r` � r" r` c @ r )�AsynchronousStrictTodoNr! r r r r ra � r" ra c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd S )�AddCleanupMixinc C s dg| _ d S )Nr& )�logr r r r r& � r5 zAddCleanupMixin.setUpc C � dg| _ td��)Nr& zDeliberate failure)rc r r r r r � brokenSetUp� � zAddCleanupMixin.brokenSetUpc C rd )Nr& z Don't do this)rc r r r r r � skippingSetUp� rf z AddCleanupMixin.skippingSetUpc C s | j �|� d S r( �rc �append)r �thingr r r ri � � zAddCleanupMixin.appendc C � | j �d� d S )NrK rh r r r r rK � rk zAddCleanupMixin.tearDownc C rl )N�runTestrh r r r r rm rk zAddCleanupMixin.runTestN) r r r r& re rg ri rK rm r r r r rb � s rb c @ r )�SynchronousAddCleanupNr! r r r r rn r" rn c @ r )�AsynchronousAddCleanupNr! r r r r ro r" ro N)$�__doc__�twisted.trial.unittestr r r r r r r# r$ r, r- r. r/ r0 r1 r7 r8 r9 rC rD rF rH rI rJ rL rM rN rR rS rT r` ra rb rn ro r r r r �<module> sD � %PK Mb�Z�5�� � 1 trial/test/__pycache__/moduleself.cpython-310.pycnu �[��� o �b� � @ s" d dl mZ G dd� dej�ZdS )� )�unittestc @ s e Zd Zdd� ZdS )�Fooc C s d S )N� )�selfr r �?/usr/lib/python3/dist-packages/twisted/trial/test/moduleself.py�testFoo s z Foo.testFooN)�__name__� __module__� __qualname__r r r r r r s r N)� twisted.trialr �SynchronousTestCaser r r r r �<module> s PK Mb�Z&!4"� "� 6 trial/test/__pycache__/test_assertions.cpython-310.pycnu �[��� o �b�� � @ s� d Z ddlZddlZddlmZmZ ddlmZm Z m Z ddl m Z m Z ddlmZ ddlmZmZmZ ddlmZ dd lmZ G d d � d e�ZG d d � d �ZG dd� dej�ZG dd� dej�Z G dd� dej�Z G dd� dej�Z G dd� dej�Z G dd� dej�Z G dd� dej�Z!G d d � d ej�Z"G d d � d ej�Z#e e#j$�d d!� �Z%e e#j$d"d#�d$d%� �Z&G d&d'� d'ej�Z'd(d)� Z(e(Z)e e'j$d*e*d)� d+d,� Z+dS )-a� Tests for assertions provided by C{SynchronousTestCase} and C{TestCase}, provided by L{twisted.trial.unittest}. L{TestFailureTests} demonstrates that L{SynchronousTestCase.fail} works, so that is the only method on C{twisted.trial.unittest.SynchronousTestCase} that is initially assumed to work. The test classes are arranged so that the methods demonstrated to work earlier in the file are used by those later in the file (even though the runner will probably not run the tests in this order). � N)�Version�getVersionString)�Deferred�fail�succeed)� deprecated�deprecatedModuleAttribute)�Failure)�accumulateMethods�fullyQualifiedName�prefixedMethods)� FancyEqMixin)�unittestc @ s& e Zd ZdZdd� Zdefdd�ZdS )� MockEquality��namec C s || _ d S �Nr )�selfr � r �D/usr/lib/python3/dist-packages/twisted/trial/test/test_assertions.py�__init__$ s zMockEquality.__init__�returnc C s d| j � d�S )Nz MockEquality(�)r �r r r r �__repr__' � zMockEquality.__repr__N)�__name__� __module__� __qualname__�compareAttributesr �strr r r r r r ! s r c @ s e Zd ZdZdd� ZeZeZdS )�ComparisonErrorzH An object which raises exceptions from its comparison methods. c C s t d��)NzComparison is broken)� ValueError)r �otherr r r �_error0 � zComparisonError._errorN)r r r �__doc__r$ �__eq__�__ne__r r r r r! + s r! c @ s: e Zd ZdZG dd� dej�Zdd� Zdd� Zdd � Z d S ) �TestFailureTestsa� Tests for the most basic functionality of L{SynchronousTestCase}, for failing tests. This class contains tests to demonstrate that L{SynchronousTestCase.fail} can be used to fail a test, and that that failure is reflected in the test result object. This should be sufficient functionality so that further tests can be built on L{SynchronousTestCase} instead of L{unittest.TestCase}. This depends on L{unittest.TestCase} working. c @ � e Zd Zdd� ZdS )z TestFailureTests.FailingTestc C s | � d� d S )NzThis test fails.�r r r r r � test_failsD r z'TestFailureTests.FailingTest.test_failsN)r r r r, r r r r � FailingTestC � r- c C sD t | jj | jj g}t�� | _| j�d�|��| _t | j�d | _ dS )zo Load a suite of one test which can be used to exercise the failure handling behavior. �.r N) r � __class__r- �pyunit� TestLoader�loader�loadTestsFromName�join�suite�list�test)r � componentsr r r �setUpG s zTestFailureTests.setUpc C sZ z| j �d� W n | j jy% } z| �dt|�� W Y d}~dS d}~ww | �d� dS )z} L{SynchronousTestCase.fail} raises L{SynchronousTestCase.failureException} with the given argument. �failedNzRSynchronousTestCase.fail method did not raise SynchronousTestCase.failureException)r8 r �failureException� assertEqualr �r �resultr r r � test_failQ s ���zTestFailureTests.test_failc C s^ t �� }| j�|� | �|�� � | �|jg � | �t|j �d� | �|j d d | j � dS )z� When a test method raises L{SynchronousTestCase.failureException}, the test is marked as having failed on the L{TestResult}. � r N) r1 � TestResultr6 �run� assertFalse� wasSuccessfulr= �errors�len�failuresr8 r> r r r �test_failingExceptionFails` s z+TestFailureTests.test_failingExceptionFailsN) r r r r& r �SynchronousTestCaser- r: r@ rI r r r r r) 7 s r) c @ �@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�AssertFalseTestsa Tests for L{SynchronousTestCase}'s C{assertFalse} and C{failIf} assertion methods. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. @note: As of 11.2, C{assertFalse} is preferred over C{failIf}. c C sB dddddg fD ]}||d|���}||kr | � d|��� qdS )z� Perform the positive case test for C{failIf} or C{assertFalse}. @param method: The test method to test. r � FNr � failed on �Did not return argument r+ )r �method�notTruer? r r r �_assertFalseFalsex s ��z"AssertFalseTests._assertFalseFalsec C s� dddddgdfD ]<}z ||d|��� W n% | j y: } z| �d|��t|�d|�d|��� W Y d }~q d }~ww | �d |j|f � q d S ) z� Perform the negative case test for C{failIf} or C{assertFalse}. @param method: The test method to test. rA T�cat� �� � rN � Raised incorrect exception on �: N�Call to %s(%r) didn't fail�r< �assertInr r r )r rP �true�er r r �_assertFalseTrue� s& �������z!AssertFalseTests._assertFalseTruec C � | � | j� dS )zt L{SynchronousTestCase.failIf} returns its argument if its argument is not considered true. N)rR �failIfr r r r �test_failIfFalse� � z!AssertFalseTests.test_failIfFalsec C r` )zy L{SynchronousTestCase.assertFalse} returns its argument if its argument is not considered true. N)rR rD r r r r �test_assertFalseFalse� rc z&AssertFalseTests.test_assertFalseFalsec C r` )z� L{SynchronousTestCase.failIf} raises L{SynchronousTestCase.failureException} if its argument is considered true. N)r_ ra r r r r �test_failIfTrue� � z AssertFalseTests.test_failIfTruec C r` )z� L{SynchronousTestCase.assertFalse} raises L{SynchronousTestCase.failureException} if its argument is considered true. N)r_ rD r r r r �test_assertFalseTrue� rf z%AssertFalseTests.test_assertFalseTrueN) r r r r& rR r_ rb rd re rg r r r r rL m s rL c @ rK )�AssertTrueTestsa Tests for L{SynchronousTestCase}'s C{assertTrue} and C{failUnless} assertion methods. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. @note: As of 11.2, C{assertTrue} is preferred over C{failUnless}. c C s� dddddg fD ]<}z ||d|��� W n% | j y9 } z| �d|��t|�d|�d|��� W Y d}~qd}~ww | �d |j|f � qdS ) z� Perform the negative case test for C{assertTrue} and C{failUnless}. @param method: The test method to test. r rM FNr rN rX rY rZ r[ )r rP rQ r^ r r r �_assertTrueFalse� s& �������z AssertTrueTests._assertTrueFalsec C sD dddddgdfD ]}||d|���}||kr | � d|��� q dS ) z� Perform the positive case test for C{assertTrue} and C{failUnless}. @param method: The test method to test. rA TrS rT rU rN rO Nr+ )r rP r] r? r r r �_assertTrueTrue� s ��z AssertTrueTests._assertTrueTruec C r` )z� L{SynchronousTestCase.assertTrue} raises L{SynchronousTestCase.failureException} if its argument is not considered true. N)ri � assertTruer r r r �test_assertTrueFalse� rf z$AssertTrueTests.test_assertTrueFalsec C r` )z� L{SynchronousTestCase.failUnless} raises L{SynchronousTestCase.failureException} if its argument is not considered true. N)ri � failUnlessr r r r �test_failUnlessFalse� rf z$AssertTrueTests.test_failUnlessFalsec C r` )zt L{SynchronousTestCase.assertTrue} returns its argument if its argument is considered true. N)rj rk r r r r �test_assertTrueTrue� rc z#AssertTrueTests.test_assertTrueTruec C r` )zt L{SynchronousTestCase.failUnless} returns its argument if its argument is considered true. N)rj rm r r r r �test_failUnlessTrue� rc z#AssertTrueTests.test_failUnlessTrueN) r r r r& ri rj rl rn ro rp r r r r rh � s rh c @ sl e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@dA� Z#dBdC� Z$dDdE� Z%dFdG� Z&dHdI� Z'dJdK� Z(dLdM� Z)dNdO� Z*dPdQ� Z+e,e-j.dRdS�dSu r�dTe+_/dSS dSS )U�SynchronousAssertionsTestsa� Tests for L{SynchronousTestCase}'s assertion methods. That is, failUnless*, failIf*, assert* (not covered by other more specific test classes). Note: As of 11.2, assertEqual is preferred over the failUnlessEqual(s) variants. Tests have been modified to reflect this preference. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. c C s& | � ||�}||kr| �d� d S d S )Nz)assertEqual should return first parameter)r= r )r �first�second�xr r r �_testEqualPair s �z)SynchronousAssertionsTests._testEqualPairc C s� d}z| � ||� W nM | jyW } z@t�d�}z|� ||� W n, |jyL } z d}t|�}t|�}||krB| �d|�d|��� W Y d}~nd}~ww W Y d}~nd}~ww |sh| �d|�d|�d �� dS dS ) z� Assert that when called with unequal arguments, C{assertEqual} raises a failure exception with the same message as the standard library C{assertEqual} would have raised. Fr: Tz Expected: z; Got: NzCall to assertEqual(z, z ) didn't fail)r= r< r1 �TestCaser r ) r rr rs �raised� ourFailure�case� theirFailure�got�expectedr r r �_testUnequalPair s( ���� �z+SynchronousAssertionsTests._testUnequalPairc C s: | � dd� | �dd� | � dgdg� | �dgd� d S )NrS �dogrA �orange)ru r} r r r r �test_assertEqual_basic/ s z1SynchronousAssertionsTests.test_assertEqual_basicc C sL t d�}t d�}t d�}| �||� | �||� | �||� | �||� d S )Nrr rs )r ru r} )r rt �y�zr r r �test_assertEqual_custom5 s z2SynchronousAssertionsTests.test_assertEqual_customc C s. d}| � | j| jdd|�}| �|t|�� dS )zi When a message is passed to L{assertEqual} it is included in the error message. �message�foo�barN)� assertRaisesr< r= r\ r )r r� � exceptionr r r �test_assertEqualMessage> s �z2SynchronousAssertionsTests.test_assertEqualMessagec C sB | � | j| jddd�}| � | j| jdd�}| �t|�t|�� dS )zz If a message is specified as L{None}, it is not included in the error message of L{assertEqual}. r� r� N)r� r< r= r )r �exceptionForNone�exceptionWithoutr r r �test_assertEqualNoneMessageI s � �z6SynchronousAssertionsTests.test_assertEqualNoneMessagec C sf t � }dg}z| �||� W n | jy | �d� Y d S ty' Y d S w | �d�||�� d S )Nr z6Fail raised when ValueError ought to have been raised.z7Comparing {!r} and {!r} should have raised an exception)r! r= r< r r" �format)r �appler r r r � test_assertEqual_incomparableV s ���z8SynchronousAssertionsTests.test_assertEqual_incomparablec C s |�r r )r �errorr r r � _raiseErrorg � z&SynchronousAssertionsTests._raiseErrorc C s& | � t| jt�}| �t|t�d� d S )Nz?Expect failUnlessRaises to return instance of raised exception.)�failUnlessRaisesr" r� rk � isinstance�r rt r r r � test_failUnlessRaises_expectedj s �z9SynchronousAssertionsTests.test_failUnlessRaises_expectedc C sV z | � t| jt� W n ty | �d� Y d S | jy# Y d S w | �d� d S )Nz9failUnlessRaises shouldn't re-raise unexpected exceptionsz4Expected exception wasn't raised. Should have failed)r� r" r� � TypeErrorr r< r r r r � test_failUnlessRaises_unexpectedq s �z;SynchronousAssertionsTests.test_failUnlessRaises_unexpectedc sd d� z | � t� fdd�� W n | jy* } z| �t|�d� W Y d }~d S d }~ww | �d� d S )NrV c s � S r r r �� returnValuer r �<lambda> � zNSynchronousAssertionsTests.test_failUnlessRaises_noException.<locals>.<lambda>z"ValueError not raised (3 returned)z(Exception not raised. Should have failed)r� r" r< r= r r �r r^ r r� r �!test_failUnlessRaises_noException| s ��z<SynchronousAssertionsTests.test_failUnlessRaises_noExceptionc C sn | � | j| j| j�}| �t|| j�d| j�d�� z | � | j| jt�}W n | jy/ Y d S w | �d� d S )Nz Expected z instance to be returnedz Should have raised exception)r� r< r� rk r� r" r r� r r r �&test_failUnlessRaises_failureException� s � � ��zASynchronousAssertionsTests.test_failUnlessRaises_failureExceptionc C s: t d�}| �t ��}|�1 sw Y | �||j� dS )z� If C{assertRaises} is used to create a context manager and an exception is raised from the body of the C{with} statement then the context manager's C{exception} attribute is set to the exception that was raised. �markerN)r" r� �assertIsr� )r r� �contextr r r � test_assertRaisesContextExpected� s �z;SynchronousAssertionsTests.test_assertRaisesContextExpectedc C s� z| � t�� td��1 sw Y W n, | jy@ } z t|�}djtt�d�}| �|�|�d�|�� W Y d}~dS d}~ww | � d� dS )z� If C{assertRaises} is used to create a context manager and the wrong exception type is raised from the body of the C{with} statement then the C{with} statement raises C{failureException} describing the mismatch. r� Nz/{type} raised instead of ValueError: Traceback)�typez=Exception message did not begin with expected information: {}�:Mismatched exception type should have caused test failure.) r� r" r� r< r r� r rk � startswithr )r r� r� r| r r r �"test_assertRaisesContextUnexpected� s" ����� z=SynchronousAssertionsTests.test_assertRaisesContextUnexpectedc C sz z| � t�� W d � n1 sw Y W n | jy5 } zt|�}| �|d� W Y d}~dS d}~ww | �d� dS )z� If C{assertRaises} is used to create a context manager and no exception is raised from the body of the C{with} statement then the C{with} statement raises C{failureException} describing the lack of exception. Nz%ValueError not raised (None returned)z5Non-exception result should have caused test failure.)r� r" r< r r= r )r r� r� r r r �#test_assertRaisesContextNoException� s ����z>SynchronousAssertionsTests.test_assertRaisesContextNoExceptionc C s� z| � ttf�� t� �1 sw Y W nE | jyZ } z8t|�}d|v}d|v}g }|r3|�d� |r:|�d� |rO| �d�|�d|� �� W Y d}~dS W Y d}~dS d}~ww | �d� dS ) z� If the exception type passed to C{assertRaises} does not have a C{__name__} then the context manager still manages to construct a descriptive string for it. Nr" r� z(expected ValueError in exception messagez'expected TypeError in exception messagez; z message = r� ) r� r" r� �AttributeErrorr< r �appendr r5 )r r� r� � valueError� typeErrorrF r r r �test_brokenName� s& � &��� z*SynchronousAssertionsTests.test_brokenNamec C s\ dgdgdg}}}| � ||�}| �||d� | �| j| j ||� | �| j| j ||� d S )NrA rT �)failIfEqual should return first parameter)� failIfEqualr= r� r< �r rt r� r� �retr r r �test_failIfEqual_basic� � z1SynchronousAssertionsTests.test_failIfEqual_basicc C sX t d�}t d�}t d�}| �||�}| �||d� | �| j| j||� | �||d� d S )Nrr rs �fecundr� z"__ne__ should make these not equal)r r� r= r� r< r� r r r �test_failIfEqual_customEq� s z4SynchronousAssertionsTests.test_failIfEqual_customEqc C s( t � }t � }| �||�}| �||� dS )z� C{failIfIdentical} returns its first argument if its first and second arguments are not the same object. N)�object�failIfIdenticalr= )r rt r� r? r r r � test_failIfIdenticalPositive� s z7SynchronousAssertionsTests.test_failIfIdenticalPositivec C s t � }| �| j| j||� dS )z~ C{failIfIdentical} raises C{failureException} if its first and second arguments are the same object. N)r� r� r< r� r� r r r � test_failIfIdenticalNegative s z7SynchronousAssertionsTests.test_failIfIdenticalNegativec C s\ dgdgdg}}}| � ||�}| �||d� | �| j| j ||� | �| j| j ||� d S )NrA rT z1failUnlessIdentical should return first parameter)�failUnlessIdenticalr= r� r< r� r r r �test_failUnlessIdentical r� z3SynchronousAssertionsTests.test_failUnlessIdenticalc C sd d\}}}| � ||d� | � ||d�}| �||d� | �| j| j ||d� | �| j| j ||d� d S )N)g �?g�������?g333333�?g�������?z4failUnlessApproximates should return first parameterg�������?)�failUnlessApproximatesr= r� r< r� r r r �test_failUnlessApproximates s ���z6SynchronousAssertionsTests.test_failUnlessApproximatesc C s\ d}d}d}d}| � |||� | � |||�}| �||d||f � | �| j| j |||� d S )N� �A�! @�X�O @��C @z<failUnlessAlmostEqual should return first parameter (%r, %r))�failUnlessAlmostEqualr= r� r< �r � precisionrt r� r� r� r r r �test_failUnlessAlmostEqual s ���z5SynchronousAssertionsTests.test_failUnlessAlmostEqualc C sd d}d}d}d}| � |||�}| �||d||f � | �| j| j |||� | �| j| j |||� d S )Nr� r� r� r� z8failIfAlmostEqual should return first parameter (%r, %r))�failIfAlmostEqualr= r� r< r� r r r �test_failIfAlmostEqual. s ���z1SynchronousAssertionsTests.test_failIfAlmostEqualc C s^ d}d}d}| � ||� | � ||�}| �||d� | �| j| j ||� | �| j| j ||� d S �NrS z the dog satz the cat satz should return first parameter)�failUnlessSubstringr= r� r< r� r r r �test_failUnlessSubstring@ � z3SynchronousAssertionsTests.test_failUnlessSubstringc C s^ d}d}d}| � ||� | � ||�}| �||d� | �| j| j ||� | �| j| j ||� d S r� )�failIfSubstringr= r� r< r� r r r �test_failIfSubstringJ r� z/SynchronousAssertionsTests.test_failIfSubstringc C s t d�}| �||� dS )zB L{assertIs} passes if two objects are identical. rr N)r r� �r �ar r r � test_assertIsT s z(SynchronousAssertionsTests.test_assertIsc C s6 t d�t d�}}| �||� | �| j| j||� dS )zE L{assertIs} fails if two objects are not identical. rr N)r r= r� r< r� �r r� �br r r �test_assertIsError[ s z-SynchronousAssertionsTests.test_assertIsErrorc C s. t d�t d�}}| �||� | �||� dS )zI L{assertIsNot} passes if two objects are not identical. rr N)r r= � assertIsNotr� r r r �test_assertIsNotc s z+SynchronousAssertionsTests.test_assertIsNotc C s t d�}| �| j| j||� dS )zD L{assertIsNot} fails if two objects are identical. rr N)r r� r< r� r� r r r �test_assertIsNotErrork s z0SynchronousAssertionsTests.test_assertIsNotErrorc C s$ t dtfi �}|� }| �||� dS )z< Test a true condition of assertIsInstance. �AN�r� r� �assertIsInstance)r r� r� r r r �test_assertIsInstancer s z0SynchronousAssertionsTests.test_assertIsInstancec C s6 t dtfi �}t dtfi �}|� }| �|||f� dS )zR Test a true condition of assertIsInstance with multiple classes. r� �BNr� �r r� r� r� r r r �$test_assertIsInstanceMultipleClassesz s z?SynchronousAssertionsTests.test_assertIsInstanceMultipleClassesc C s: t dtfi �}t dtfi �}|� }| �| j| j||� dS )z6 Test an error with assertIsInstance. r� r� N�r� r� r� r< r� r� r r r �test_assertIsInstanceError� s z5SynchronousAssertionsTests.test_assertIsInstanceErrorc C sL t dtfi �}t dtfi �}t dtfi �}|� }| �| j| j|||f� dS )zK Test an error with assertIsInstance and multiple classes. r� r� �CNr� �r r� r� r� r� r r r �)test_assertIsInstanceErrorMultipleClasses� s zDSynchronousAssertionsTests.test_assertIsInstanceErrorMultipleClassesc C s* | � | j| jdtd�}| �dt|�� dS )z� If L{TestCase.assertIsInstance} is passed a custom message as its 3rd argument, the message is included in the failure exception raised when the assertion fails. rV zSilly assertionN)r� r< r� r r\ )r �excr r r �"test_assertIsInstanceCustomMessage� s �z=SynchronousAssertionsTests.test_assertIsInstanceCustomMessagec C s2 t dtfi �}t dtfi �}|� }| �||� dS )z? Test a true condition of assertNotIsInstance. r� r� N�r� r� �assertNotIsInstancer� r r r �test_assertNotIsInstance� s z3SynchronousAssertionsTests.test_assertNotIsInstancec C sD t dtfi �}t dtfi �}t dtfi �}|� }| �|||f� dS )zT Test a true condition of assertNotIsInstance and multiple classes. r� r� r� Nr� r� r r r �'test_assertNotIsInstanceMultipleClasses� s zBSynchronousAssertionsTests.test_assertNotIsInstanceMultipleClassesc C sF t dtfi �}|� }| �| j| j||�}| �t|�|�d|� �� dS )z9 Test an error with assertNotIsInstance. r� z is an instance of N)r� r� r� r< r� r= r )r r� r� r� r r r � test_assertNotIsInstanceError� s z8SynchronousAssertionsTests.test_assertNotIsInstanceErrorc C s> t dtfi �}t dtfi �}|� }| �| j| j|||f� dS )zN Test an error with assertNotIsInstance and multiple classes. r� r� N)r� r� r� r< r� r� r r r �,test_assertNotIsInstanceErrorMultipleClasses� s zGSynchronousAssertionsTests.test_assertNotIsInstanceErrorMultipleClassesc C s | � ddiddi� dS )z� L{twisted.trial.unittest.TestCase} supports the C{assertDictEqual} method inherited from the standard library in Python 2.7. r� rA N)�assertDictEqualr r r r �test_assertDictEqual� � z/SynchronousAssertionsTests.test_assertDictEqualr� Nz:assertDictEqual is not available on this version of Python)0r r r r& ru r} r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� �getattrr rJ �skipr r r r rq s\ ��rq c @ st e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� ZdS ) �WarningAssertionTestsc C �* dd� }| � tdt|d�}| �|d� dS )z0 Test basic assertWarns report. c S � t jdtd� | S �N�Woo deprecated��category��warnings�warn�DeprecationWarning�r� r r r r � � z:WarningAssertionTests.test_assertWarns.<locals>.deprecatedr� �{ N�� assertWarnsr� �__file__r= �r r �rr r r �test_assertWarns� � �z&WarningAssertionTests.test_assertWarnsc C sH dd� }| � tdt|d�}| �|d� | � tdt|d�}| �|d� dS )z} Test that assertWarns cleans the warning registry, so the warning is not swallowed the second time. c S r� r� r� r� r r r r � r� zGWarningAssertionTests.test_assertWarnsRegistryClean.<locals>.deprecatedr� r� �A Nr� )r r �r1�r2r r r � test_assertWarnsRegistryClean� s � �z3WarningAssertionTests.test_assertWarnsRegistryCleanc C �& dd� }| � | j| jtdt|d� dS )zH Test assertWarns failure when no warning is generated. c S � | S r r r� r r r �normal� r� z;WarningAssertionTests.test_assertWarnsError.<locals>.normalr� r� N�r� r< r� r� r )r r r r r �test_assertWarnsError� s �z+WarningAssertionTests.test_assertWarnsErrorc C r )zF Test assertWarns failure when the category is wrong. c S r� �N�Foo deprecatedr� r� r� r r r r r� zGWarningAssertionTests.test_assertWarnsWrongCategory.<locals>.deprecatedr r� N)r� r< r� � UserWarningr �r r r r r � test_assertWarnsWrongCategory � �z3WarningAssertionTests.test_assertWarnsWrongCategoryc C r )zE Test assertWarns failure when the message is wrong. c S r� r r� r� r r r r r� zFWarningAssertionTests.test_assertWarnsWrongMessage.<locals>.deprecated�Bar deprecatedr� Nr r r r r � test_assertWarnsWrongMessage r z2WarningAssertionTests.test_assertWarnsWrongMessagec C r )z� If the warning emitted by a function refers to a different file than is passed to C{assertWarns}, C{failureException} is raised. c S s t jdtdd� d S )Nr rT )r� � stacklevelr� r� r r r r 4 s zCWarningAssertionTests.test_assertWarnsWrongFile.<locals>.deprecatedr r� Nr r r r r �test_assertWarnsWrongFile. s �z/WarningAssertionTests.test_assertWarnsWrongFilec C sR G dd� d�}| � tdt|�}| �t||�� | � tdt|�}| �t||�� dS )zH Test assertWarns works when creating a class instance. c @ r* )z;WarningAssertionTests.test_assertWarnsOnClass.<locals>.Warnc S � t jdtd� d S )N�Do not call mer� )r� r� �RuntimeWarningr r r r r S � zDWarningAssertionTests.test_assertWarnsOnClass.<locals>.Warn.__init__N)r r r r r r r r �WarnR r. r r N)r� r r rk r� )r r r r r r �test_assertWarnsOnClassM s z-WarningAssertionTests.test_assertWarnsOnClassc C sX G dd� d�}|� }| � tdt|jd�}| �|d� | � tdt|jd�}| �|d� dS )zI Test assertWarns works when used on an instance method. c @ r* )z<WarningAssertionTests.test_assertWarnsOnMethod.<locals>.Warnc S � t jdtd� |S )Nr r� r� r� r r r r a r� zGWarningAssertionTests.test_assertWarnsOnMethod.<locals>.Warn.deprecatedN)r r r r r r r r r ` r. r r r N)r� r� r r r= �r r �wr r r r �test_assertWarnsOnMethod[ s � �z.WarningAssertionTests.test_assertWarnsOnMethodc C sT G dd� d�}|� }| � tdt|d�}| �|d� | � tdt|d�}| �|d� dS )zM Test assertWarns works on instance with C{__call__} method. c @ r* )z:WarningAssertionTests.test_assertWarnsOnCall.<locals>.Warnc S r )N�Egg deprecatedr� r� r� r r r �__call__u r� zCWarningAssertionTests.test_assertWarnsOnCall.<locals>.Warn.__call__N)r r r r# r r r r r t r. r r" r Nr� r r r r �test_assertWarnsOnCallo s z,WarningAssertionTests.test_assertWarnsOnCallc C r� )zD Test assertWarns on a warning filtered by default. c S r� r� �r� r� �PendingDeprecationWarningr� r r r r � r� z@WarningAssertionTests.test_assertWarnsFilter.<locals>.deprecatedr� r� N)r� r& r r= r r r r �test_assertWarnsFilter r z,WarningAssertionTests.test_assertWarnsFilterc s( dd� � � fdd�}| � tdt|� dS )z� C{assertWarns} does not raise an exception if the function it is passed triggers the same warning more than once. c S r r� r% r r r r r � r zJWarningAssertionTests.test_assertWarnsMultipleWarnings.<locals>.deprecatedc s � � � � d S r r r �r r r �f� s zAWarningAssertionTests.test_assertWarnsMultipleWarnings.<locals>.fr� N)r� r& r )r r) r r( r � test_assertWarnsMultipleWarnings� s z6WarningAssertionTests.test_assertWarnsMultipleWarningsc C s6 dd� }| � | j| jtdt|d�}| �t|�d� dS )z� For now, assertWarns is unable to handle multiple different warnings, so it should raise an exception if it's the case. c S s t jdtd� t jdtd� d S )Nr� r� z Another one)r� r� r� r& r� r r r r � s zKWarningAssertionTests.test_assertWarnsDifferentWarnings.<locals>.deprecatedr� r� z Can't handle different warningsN)r� r< r� r� r r= r )r r r^ r r r �!test_assertWarnsDifferentWarnings� s � z7WarningAssertionTests.test_assertWarnsDifferentWarningsc sX G dd� dt �� � fdd�}|d� | �� dt|d� | �|g�\}| �|d d� dS ) z� Warnings emitted before L{TestCase.assertWarns} is called do not get flushed and do not alter the behavior of L{TestCase.assertWarns}. c @ s e Zd ZdS )zPWarningAssertionTests.test_assertWarnsAfterUnassertedWarning.<locals>.TheWarningN)r r r r r r r � TheWarning� s r, c s t j| � d� d S )Nr� )r� r� �r� �r, r r r) � r zGWarningAssertionTests.test_assertWarnsAfterUnassertedWarning.<locals>.fr� r� r� N)�Warningr� r � flushWarningsr= )r r) �warningr r. r �&test_assertWarnsAfterUnassertedWarning� s z<WarningAssertionTests.test_assertWarnsAfterUnassertedWarningN)r r r r r r r r r r r! r$ r' r* r+ r2 r r r r r� � s r� c @ s� e Zd ZdZe� Zeed��Zdd� Z dd� Z dd� Z d d � Z d d � Z d d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)S )*�ResultOfAssertionsTestsz� Tests for L{SynchronousTestCase.successResultOf}, L{SynchronousTestCase.failureResultOf}, and L{SynchronousTestCase.assertNoResult}. � Bad timesc C � | � | j| jt� � dS )z� L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with no current result. N)r� r< �successResultOfr r r r r �test_withoutResult� � z*ResultOfAssertionsTests.test_withoutResultc C � | � | j| jt| j�� dS )z� L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with a failure result. N)r� r< r6 r �failurer r r r � test_successResultOfWithFailure� � �z7ResultOfAssertionsTests.test_successResultOfWithFailurec C sV z | � t| j�� W dS | jy* } z| �| j�� t|�� W Y d}~dS d}~ww )z� L{SynchronousTestCase.successResultOf} raises a L{SynchronousTestCase.failureException} that has the original failure traceback when called with a L{Deferred} with a failure result. N)r6 r r: r< r\ � getTracebackr r� r r r �+test_successResultOfWithFailureHasTraceback� s $��zCResultOfAssertionsTests.test_successResultOfWithFailureHasTracebackc C r5 )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with no current result. N)r� r< �failureResultOfr r r r r �!test_failureResultOfWithoutResult� r8 z9ResultOfAssertionsTests.test_failureResultOfWithoutResultc C r9 )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with a success result. N)r� r< r? r r? r r r r � test_failureResultOfWithSuccess� r< z7ResultOfAssertionsTests.test_failureResultOfWithSuccessc C s | � | j| jt| j�t� dS )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected. N)r� r< r? r r: �KeyErrorr r r r �$test_failureResultOfWithWrongFailure� s �z<ResultOfAssertionsTests.test_failureResultOfWithWrongFailurec C s^ z | � t| j�t� W dS | jy. } z| �d�tjtj�t |�� W Y d}~dS d}~ww )a= L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception type. �#Failure of type ({}.{}) expected onN) r? r r: rB r< r\ r� r r r r� r r r �6test_failureResultOfWithWrongFailureOneExpectedFailure s ����zNResultOfAssertionsTests.test_failureResultOfWithWrongFailureOneExpectedFailurec C sX z | � t| j�t� W dS | jy+ } z| �| j�� t|�� W Y d}~dS d}~ww )a@ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original failure traceback. N)r? r r: rB r< r\ r= r r� r r r �;test_failureResultOfWithWrongFailureOneExpectedFailureHasTB s $��zSResultOfAssertionsTests.test_failureResultOfWithWrongFailureOneExpectedFailureHasTBc C sh z | � t| j�tt� W dS | jy3 } z| �d�tjtj tjtj �t |�� W Y d}~dS d}~ww )aH L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception types in the error message. �,Failure of type ({}.{} or {}.{}) expected onN) r? r r: rB �IOErrorr< r\ r� r r r r� r r r �9test_failureResultOfWithWrongFailureMultiExpectedFailures% s ����zQResultOfAssertionsTests.test_failureResultOfWithWrongFailureMultiExpectedFailuresc C sZ z | � t| j�tt� W dS | jy, } z| �| j�� t|�� W Y d}~dS d}~ww )aJ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original failure traceback in the error message. N) r? r r: rB rH r< r\ r= r r� r r r �>test_failureResultOfWithWrongFailureMultiExpectedFailuresHasTB: s $��zVResultOfAssertionsTests.test_failureResultOfWithWrongFailureMultiExpectedFailuresHasTBc C � | � | j| �t| j��� dS )a When passed a L{Deferred} which currently has a result (ie, L{Deferred.addCallback} would cause the added callback to be called before C{addCallback} returns), L{SynchronousTestCase.successResultOf} returns that result. N)�assertIdenticalr? r6 r r r r r �%test_successResultOfWithSuccessResultG � z=ResultOfAssertionsTests.test_successResultOfWithSuccessResultc C s& | � | j| �t| j�| jjt�� dS )a= When passed a L{Deferred} which currently has a L{Failure} result (ie, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns that L{Failure} if its contained exception type is expected. N)rL r: r? r r� rB r r r r �-test_failureResultOfWithExpectedFailureResultP s �zEResultOfAssertionsTests.test_failureResultOfWithExpectedFailureResultc C rK )a When passed a L{Deferred} which currently has a L{Failure} result (ie, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns that L{Failure}. N)rL r: r? r r r r r �%test_failureResultOfWithFailureResult\ rN z=ResultOfAssertionsTests.test_failureResultOfWithFailureResultc C r9 )z� When passed a L{Deferred} which currently has a success result (see L{test_withSuccessResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. N)r� r< �assertNoResultr r? r r r r �test_assertNoResultSuccesse r< z2ResultOfAssertionsTests.test_assertNoResultSuccessc C r9 )z� When passed a L{Deferred} which currently has a failure result (see L{test_withFailureResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. N)r� r< rQ r r: r r r r �test_assertNoResultFailureo r< z2ResultOfAssertionsTests.test_assertNoResultFailurec C s | � t� � dS )z� When passed a L{Deferred} with no current result, L{SynchronousTestCase.assertNoResult} does not raise an exception. N)rQ r r r r r �test_assertNoResulty rc z+ResultOfAssertionsTests.test_assertNoResultc C �4 t � }| �|� |�| j� | �| j| �|�� dS )z� When passed a L{Deferred} with no current result, which is then fired with a success result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. N�r rQ �callbackr? r= r6 �r �dr r r �$test_assertNoResultPropagatesSuccess� � z<ResultOfAssertionsTests.test_assertNoResultPropagatesSuccessc C rU )z� When passed a L{Deferred} with no current result, which is then fired with a L{Failure} result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. N)r rQ �errbackr: r= r? rX r r r �)test_assertNoResultPropagatesLaterFailure� r[ zAResultOfAssertionsTests.test_assertNoResultPropagatesLaterFailurec C sD t | j�}z| �|� W n | jy Y nw | �d| �|�� dS )�� When passed a L{Deferred} which currently has a L{Failure} result, L{SynchronousTestCase.assertNoResult} changes the result of the L{Deferred} to a success. N�r r: rQ r< r= r6 rX r r r �+test_assertNoResultSwallowsImmediateFailure� s �zCResultOfAssertionsTests.test_assertNoResultSwallowsImmediateFailureN) r r r r& r� r? r � Exceptionr: r7 r; r> r@ rA rC rE rF rI rJ rM rO rP rR rS rT rZ r] r` r r r r r3 � s. r3 c @ s� e Zd ZdZe� Zed�Zee�Z dd� Z dd� Z d0dd �Z d d � Z d d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Z d*d+� Z d,d-� Z d.d/� Z dS )1� ResultOfCoroutineAssertionsTestsz� Tests for L{SynchronousTestCase.successResultOf}, L{SynchronousTestCase.failureResultOf}, and L{SynchronousTestCase.assertNoResult} when given a coroutine. r4 c � s �| j S r )r? r r r r � successResult� s �z.ResultOfCoroutineAssertionsTests.successResultc � s �t � I d H d S r )r r r r r �noCurrentResult� s �z0ResultOfCoroutineAssertionsTests.noCurrentResultNc � s �|d u r| j }|�r )r� �r r� r r r �raisesException� s �z0ResultOfCoroutineAssertionsTests.raisesExceptionc C � | � | j| j| �� � dS )z� L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with no current result. N)r� r< r6 rd r r r r r7 � � �z3ResultOfCoroutineAssertionsTests.test_withoutResultc C rg )z� L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception. N)r� r< r6 rf r r r r �!test_successResultOfWithException� rh zBResultOfCoroutineAssertionsTests.test_successResultOfWithExceptionc C sh t d�}z | �| �|�� W dS | jy3 } z| �dt|�� | �dt|�� W Y d}~dS d}~ww )z� L{SynchronousTestCase.successResultOf} raises a L{SynchronousTestCase.failureException} that has the original failure traceback when called with a coroutine with a failure result. r4 zSuccess result expected on� builtins.Exception: Bad timesN)ra r6 rf r< r\ r �r r� r^ r r r r> � s ��zLResultOfCoroutineAssertionsTests.test_successResultOfWithFailureHasTracebackc C rg )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with no current result. N)r� r< r? rd r r r r r@ � rh zBResultOfCoroutineAssertionsTests.test_failureResultOfWithoutResultc C rg )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with a success result. N)r� r< r? rc r r r r rA � rh z@ResultOfCoroutineAssertionsTests.test_failureResultOfWithSuccessc C s | � | j| j| �� t� dS )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception that was not expected. N)r� r< r? rf rB r r r r rC � s �zEResultOfCoroutineAssertionsTests.test_failureResultOfWithWrongFailurec C s\ z | � | �� t� W dS | jy- } z| �d�tjtj�t|�� W Y d}~dS d}~ww )aF L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception with a failure type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception type. rD N) r? rf rB r< r\ r� r r r r� r r r �:test_failureResultOfWithWrongExceptionOneExpectedException� s ����z[ResultOfCoroutineAssertionsTests.test_failureResultOfWithWrongExceptionOneExpectedExceptionc C sj t d�}z | �| �|�t� W dS | jy4 } z| �dt|�� | �dt|�� W Y d}~dS d}~ww )aK L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception with a failure type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original exception traceback. r4 z/Failure of type (builtins.KeyError) expected onrj N)ra r? rf rB r< r\ r rk r r r �?test_failureResultOfWithWrongExceptionOneExpectedExceptionHasTB s ��z`ResultOfCoroutineAssertionsTests.test_failureResultOfWithWrongExceptionOneExpectedExceptionHasTBc C sf z | � | �� tt� W dS | jy2 } z| �d�tjtjtjtj�t |�� W Y d}~dS d}~ww )aN L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception of a type that was not expected, and the L{SynchronousTestCase.failureException} message contains expected exception types in the error message. rG N) r? rf rB rH r< r\ r� r r r r� r r r �=test_failureResultOfWithWrongExceptionMultiExpectedExceptions s ����z^ResultOfCoroutineAssertionsTests.test_failureResultOfWithWrongExceptionMultiExpectedExceptionsc C sl t d�}z | �| �|�tt� W dS | jy5 } z| �dt|�� | �dt|�� W Y d}~dS d}~ww )aV L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception of a type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original exception traceback in the error message. r4 zCFailure of type (builtins.KeyError or builtins.OSError) expected onrj N)ra r? rf rB rH r< r\ r rk r r r �Btest_failureResultOfWithWrongExceptionMultiExpectedExceptionsHasTB2 s � ��zcResultOfCoroutineAssertionsTests.test_failureResultOfWithWrongExceptionMultiExpectedExceptionsHasTBc C s | � | j| �| �� �� dS )a$ When passed a coroutine which currently has a result (ie, if converted into a L{Deferred}, L{Deferred.addCallback} would cause the added callback to be called before C{addCallback} returns), L{SynchronousTestCase.successResultOf} returns that result. N)rL r? r6 rc r r r r rM E s zFResultOfCoroutineAssertionsTests.test_successResultOfWithSuccessResultc C s( | � | jj| �| �� | jjt�j� dS )ar When passed a coroutine which currently has an exception result (ie, if converted into a L{Deferred}, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns a L{Failure} containing that exception, if the exception type is expected. N)r= r: �valuer? rf r� rB r r r r �)test_failureResultOfWithExpectedExceptionN s ��zJResultOfCoroutineAssertionsTests.test_failureResultOfWithExpectedExceptionc C s | � | jj| �| �� �j� dS )aW When passed a coroutine which currently has an exception result (ie, if converted into a L{Deferred}, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns returns a L{Failure} containing that exception. N)r= r: rp r? rf r r r r �!test_failureResultOfWithException] s �zBResultOfCoroutineAssertionsTests.test_failureResultOfWithExceptionc C rg )z� When passed a coroutine which currently has a success result (see L{test_withSuccessResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. N)r� r< rQ rc r r r r rR i rh z;ResultOfCoroutineAssertionsTests.test_assertNoResultSuccessc C rg )z� When passed a coroutine which currently has an exception result (see L{test_withFailureResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. N)r� r< rQ rf r r r r rS s rh z;ResultOfCoroutineAssertionsTests.test_assertNoResultFailurec C s | � | �� � dS )z� When passed a coroutine with no current result, L{SynchronousTestCase.assertNoResult} does not raise an exception. N)rQ rd r r r r rT } s z4ResultOfCoroutineAssertionsTests.test_assertNoResultc sF t � � � fdd�}|� }| �� � � �| j� | �| j| �|�� dS )z� When passed a coroutine awaiting a L{Deferred} with no current result, which is then fired with a success result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. c � � �� I d H S r r r �rY r r rd � � � z^ResultOfCoroutineAssertionsTests.test_assertNoResultPropagatesSuccess.<locals>.noCurrentResultNrV )r rd �cr rt r rZ � s zEResultOfCoroutineAssertionsTests.test_assertNoResultPropagatesSuccessc sP t | j�}t� � � fdd�}|� }| �� � � �|� | �|j| �|�j� dS )z� When passed a coroutine awaiting a L{Deferred} with no current result, which is then fired with a L{Failure} result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. c � rs r r r rt r r rd � ru zcResultOfCoroutineAssertionsTests.test_assertNoResultPropagatesLaterFailure.<locals>.noCurrentResultN)r r� r rQ r\ r= rp r? )r r) rd rv r rt r r] � s zJResultOfCoroutineAssertionsTests.test_assertNoResultPropagatesLaterFailurec sV t | j�� � fdd�}|� }z| �� � W n | jy Y nw | �d| �|�� dS )r^ c � rs r r r rt r r rf � ru zeResultOfCoroutineAssertionsTests.test_assertNoResultSwallowsImmediateFailure.<locals>.raisesExceptionNr_ )r rf rv r rt r r` � s �zLResultOfCoroutineAssertionsTests.test_assertNoResultSwallowsImmediateFailurer ) r r r r& r� r? ra r� r r: rc rd rf r7 ri r> r@ rA rC rl rm rn ro rM rq rr rR rS rT rZ r] r` r r r r rb � s6 rb c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �AssertionNamesTestszK Tests for consistency of naming within TestCase assertion methods c s" i � t | � d� � fdd�� D �S )N�assertc s& g | ]}|� d �s|dkr� | �qS )�Not�_)r� )�.0�k��dctr r � <listcomp>� s & z3AssertionNamesTests._getAsserts.<locals>.<listcomp>)r r r r} r � _getAsserts� s z AssertionNamesTests._getAssertsc C s |j S r )r r� r r r �_name� s zAssertionNamesTests._namec C s0 t | �� �}t t| d��}| �||�|�� dS )a� The C{failUnless*} test methods are a subset of the C{assert*} test methods. This is intended to ensure that methods using the I{failUnless} naming scheme are not added without corresponding methods using the I{assert} naming scheme. The I{assert} naming scheme is preferred, and new I{assert}-prefixed methods may be added without corresponding I{failUnless}-prefixed methods. rm N)�setr� r r= � intersection)r �asserts� failUnlessesr r r � test_failUnlessMatchesAssert� s z0AssertionNamesTests.test_failUnlessMatchesAssertc C s< t tjd�}t tjd�}| �t|| jd�t|| jd�� d S )N� assertNotra )�key)r r rJ r= �sortedr� )r r� �failIfsr r r � test_failIf_matches_assertNot� s �z1AssertionNamesTests.test_failIf_matches_assertNotc C s� t | ��� D ]R\}}t|�sq|�d�r0| �t| |d �|� d|� d�� | �|t| |d �� |�d�rX| �t| |d d� �|� d|d d� � �� | �|t| |d d� �� qd S )N�Equal�sz but no �Equals���)�vars�items�callable�endswithrk �hasattrr= r� )r r rp r r r �test_equalSpelling� s " ,��z&AssertionNamesTests.test_equalSpellingN) r r r r& r� r� r� r� r� r r r r rw � s rw c @ sV e Zd ZdZedddd�Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dS )�CallDeprecatedTestsz\ Test use of the L{SynchronousTestCase.callDeprecated} method with version objects. �Twisted� r c C s& | � | jtd� | �| �� g d� dS )zj callDeprecated calls a deprecated callable, suppressing the deprecation warning. r� zNo warnings should be shownN)�callDeprecated�version� oldMethodr= r0 r r r r �$test_callDeprecatedSuppressesWarning� s z8CallDeprecatedTests.test_callDeprecatedSuppressesWarningc C s | � | jtd�}| �d|� dS )zn L{callDeprecated} actually calls the callable passed to it, and forwards the result. r� N)r� r� r� r= r> r r r � test_callDeprecatedCallsFunction� s z4CallDeprecatedTests.test_callDeprecatedCallsFunctionc C s6 dd� }| � | j| j| j|�}| �d| t|�� dS )zd L{callDeprecated} raises a test failure if the callable is not deprecated. c S s d S r r r r r r � notDeprecated r� zGCallDeprecatedTests.test_failsWithoutDeprecation.<locals>.notDeprecatedz%r is not deprecated.N)r� r< r� r� r= r )r r� r� r r r � test_failsWithoutDeprecation� s �z0CallDeprecatedTests.test_failsWithoutDeprecationc C sR t dddd�}| �| j| j|td�}| �t| j�t|�� | �t|�t|�� dS )z� callDeprecated raises a test failure if the callable was deprecated at a different version to the one expected. �FoorA rT rV r� N) r r� r< r� r� r\ r r� r )r �differentVersionr� r r r �"test_failsWithIncorrectDeprecation s �z6CallDeprecatedTests.test_failsWithIncorrectDeprecationc C sT t dddd�}dd� }t|�|�}| �||d� | �� }| �t|�dd|� �� d S ) a: L{callDeprecated} ignores all deprecations apart from the first. Multiple warnings are generated when a deprecated function calls another deprecated function. The first warning is the one generated by the explicitly called function. That's the warning that we care about. r� rA rT rV c W s t | � S r )r� )�argsr r r �nestedDeprecation& r% zECallDeprecatedTests.test_nestedDeprecation.<locals>.nestedDeprecation� zUnexpected warnings: N)r r r� r0 r= rG )r r� r� � warningsShownr r r �test_nestedDeprecation s z*CallDeprecatedTests.test_nestedDeprecationc C s | � | jdftd� dS )zj L{callDeprecated} can take a message argument used to check the warning emitted. � newMethodrA N)r� r� �oldMethodReplacedr r r r � test_callDeprecationWithMessage3 r� z3CallDeprecatedTests.test_callDeprecationWithMessagec C sF | � | j| j| jdftd�}| �t| j�t|�� | �dt|�� dS )z| If the message passed to L{callDeprecated} doesn't match, L{callDeprecated} raises a test failure. zsomething.wrongrA z please use newMethod insteadN)r� r< r� r� r� r\ r r re r r r �$test_callDeprecationWithWrongMessage: s �z8CallDeprecatedTests.test_callDeprecationWithWrongMessageN) r r r r& r r� r� r� r� r� r� r� r� r r r r r� � s r� c C r )z( Deprecated method for testing. r �rt r r r r� J s r� r� )� replacementc C s d| S )zh Another deprecated method, which has been deprecated in favor of the mythical 'newMethod'. rT r r� r r r r� R s r� c @ s> e Zd ZdZedddd�Zdd� Zdd � Zd d � Zd d � Z dS )�!GetDeprecatedModuleAttributeTestsz� Test L{SynchronousTestCase.getDeprecatedModuleAttribute} @ivar version: The version at which L{test_assertions.somethingOld} is marked deprecated. @type version: L{incremental.Version} �BarrA rT rV c C s, | � t| �td| j�� | �g | �� � dS )z� L{getDeprecatedModuleAttribute} returns the specified attribute and consumes the deprecation warning that generates. � somethingOldN�r� � _somethingOld� getDeprecatedModuleAttributer r� r= r0 r r r r �test_deprecatedf s ��z1GetDeprecatedModuleAttributeTests.test_deprecatedc C s0 | � t| jtd| jdd�� | �g | �� � dS )z� The I{message} argument to L{getDeprecatedModuleAttribute} matches the prefix of the deprecation message. r� zIt's oldr- Nr� r r r r � test_messageu s �� z.GetDeprecatedModuleAttributeTests.test_messagec C s. | � | j| jtd| jd� | �g | �� � dS )z� L{getDeprecatedModuleAttribute} fails the test if the I{message} isn't part of the deprecation message prefix. r� zIt's shiny and newN)r� r< r� r r� r= r0 r r r r �test_messageMismatch� s �z6GetDeprecatedModuleAttributeTests.test_messageMismatchc C s | � | j| jtd| j� dS )z� L{getDeprecatedModuleAttribute} fails the test when used to get an attribute that isn't actually deprecated. � somethingNewN)r� r< r� r r� r r r r �test_notDeprecated� s �z4GetDeprecatedModuleAttributeTests.test_notDeprecatedN) r r r r& r r� r� r� r� r� r r r r r� [ s r� c C � dS )zj A deprecated module attribute. Used by L{GetDeprecatedModuleAttributeTests.test_deprecated}. Nr r r r r r� � r� r� zIt's old and clunkyc C r� )zy A module attribute that is not deprecated. Used by L{GetDeprecatedModuleAttributeTests.test_notDeprecated}. Nr r r r r r� � r� r� ),r& r r1 r� � incrementalr r �twisted.internet.deferr r r �twisted.python.deprecater r �twisted.python.failurer �twisted.python.reflectr r r �twisted.python.utilr � twisted.trialr r! rv r) rJ rL rh rq r� r3 rb rw r� r� r� r� r� r� r� r r� r r r r �<module> sT 6MM O q b -c G� PK Mb�Z���A� � 3 trial/test/__pycache__/test_plugins.cpython-310.pycnu �[��� o �b� � @ s> d Z ddlmZ ddlmZ ddlmZ G dd� dej�ZdS )z- Tests for L{twisted.plugins.twisted_trial}. � )� getPlugins)�unittest)� IReporterc @ s e Zd ZdZdd� Zdd� ZdS )� PluginsTestsz- Tests for Trial's reporter plugins. c s: � fdd�t t�D �}t|�dkrtd� |f ��|d S )z� Return the Trial reporter plugin with the given long option. If more than one is found, raise ValueError. If none are found, raise IndexError. c s g | ] }|j � kr|�qS � )�longOpt)�.0�plugin�� longOptionr �A/usr/lib/python3/dist-packages/twisted/trial/test/test_plugins.py� <listcomp> s z7PluginsTests.getPluginsByLongOption.<locals>.<listcomp>� z2More than one plugin found with long option %r: %rr )r r �len� ValueError)�selfr �pluginsr r r �getPluginsByLongOption s � ��z#PluginsTests.getPluginsByLongOptionc C sT | � d�}| �d|j� | �d|j� | �d|j� | �d|j� | �d|j� dS )zM One of the reporter plugins is the subunit reporter plugin. �subunitzSubunit Reporterztwisted.trial.reporterN�SubunitReporter)r � assertEqual�name�moduler �assertIdentical�shortOpt�klass)r � subunitPluginr r r �test_subunitPlugin% s z PluginsTests.test_subunitPluginN)�__name__� __module__� __qualname__�__doc__r r r r r r r s r N) r! �twisted.pluginr � twisted.trialr �twisted.trial.itrialr �SynchronousTestCaser r r r r �<module> s PK Mb�Z_�]� � trial/test/novars.pynu �[��� # fodder for test_script, which parses files for emacs local variable # declarations. This one is supposed to have none. # The class declaration is irrelevant class Bar: pass PK Mb�Z���S� � " trial/test/test_asyncassertions.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for async assertions provided by C{twisted.trial.unittest.TestCase}. """ import unittest as pyunit from twisted.internet import defer from twisted.python import failure from twisted.trial import unittest class AsynchronousAssertionsTests(unittest.TestCase): """ Tests for L{TestCase}'s asynchronous extensions to L{SynchronousTestCase}. That is, assertFailure. """ def test_assertFailure(self): d = defer.maybeDeferred(lambda: 1 / 0) return self.assertFailure(d, ZeroDivisionError) def test_assertFailure_wrongException(self): d = defer.maybeDeferred(lambda: 1 / 0) self.assertFailure(d, OverflowError) d.addCallbacks( lambda x: self.fail("Should have failed"), lambda x: x.trap(self.failureException), ) return d def test_assertFailure_noException(self): d = defer.succeed(None) self.assertFailure(d, ZeroDivisionError) d.addCallbacks( lambda x: self.fail("Should have failed"), lambda x: x.trap(self.failureException), ) return d def test_assertFailure_moreInfo(self): """ In the case of assertFailure failing, check that we get lots of information about the exception that was raised. """ try: 1 / 0 except ZeroDivisionError: f = failure.Failure() d = defer.fail(f) d = self.assertFailure(d, RuntimeError) d.addErrback(self._checkInfo, f) return d def _checkInfo(self, assertionFailure, f): assert assertionFailure.check(self.failureException) output = assertionFailure.getErrorMessage() self.assertIn(f.getErrorMessage(), output) self.assertIn(f.getBriefTraceback(), output) def test_assertFailure_masked(self): """ A single wrong assertFailure should fail the whole test. """ class ExampleFailure(Exception): pass class TC(unittest.TestCase): failureException = ExampleFailure def test_assertFailure(self): d = defer.maybeDeferred(lambda: 1 / 0) self.assertFailure(d, OverflowError) self.assertFailure(d, ZeroDivisionError) return d test = TC("test_assertFailure") result = pyunit.TestResult() test.run(result) self.assertEqual(1, len(result.failures)) PK Mb�Z� �q trial/test/mockcustomsuite2.pynu �[��� # Copyright (c) 2006 Twisted Matrix Laboratories. See LICENSE for details """ Mock test module that contains a C{testSuite} method. L{runner.TestLoader} should load the tests from the C{testSuite}, not from the C{Foo} C{TestCase}. See L{twisted.trial.test.test_loader.LoaderTest.test_loadModuleWith_testSuite}. """ from twisted.trial import runner, unittest class Foo(unittest.SynchronousTestCase): def test_foo(self): pass def testSuite(): ts = runner.TestSuite() ts.name = "MyCustomSuite" return ts PK Mb�Z��2 M M trial/test/skipping.pynu �[��� # -*- test-case-name: twisted.trial.test.test_tests -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Definitions of test cases with various interesting behaviors, to be used by L{twisted.trial.test.test_tests} and other test modules to exercise different features of trial's test runner. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. """ from twisted.trial.unittest import FailTest, SkipTest, SynchronousTestCase, TestCase class SkippingMixin: def test_skip1(self): raise SkipTest("skip1") def test_skip2(self): raise RuntimeError("I should not get raised") test_skip2.skip = "skip2" # type: ignore[attr-defined] def test_skip3(self): self.fail("I should not fail") test_skip3.skip = "skip3" # type: ignore[attr-defined] class SynchronousSkipping(SkippingMixin, SynchronousTestCase): pass class AsynchronousSkipping(SkippingMixin, TestCase): pass class SkippingSetUpMixin: def setUp(self): raise SkipTest("skipSetUp") def test_1(self): pass def test_2(self): pass class SynchronousSkippingSetUp(SkippingSetUpMixin, SynchronousTestCase): pass class AsynchronousSkippingSetUp(SkippingSetUpMixin, TestCase): pass class DeprecatedReasonlessSkipMixin: def test_1(self): raise SkipTest() class SynchronousDeprecatedReasonlessSkip( DeprecatedReasonlessSkipMixin, SynchronousTestCase ): pass class AsynchronousDeprecatedReasonlessSkip(DeprecatedReasonlessSkipMixin, TestCase): pass class SkippedClassMixin: skip = "class" def setUp(self): self.__class__._setUpRan = True def test_skip1(self): raise SkipTest("skip1") def test_skip2(self): raise RuntimeError("Ought to skip me") test_skip2.skip = "skip2" # type: ignore def test_skip3(self): pass def test_skip4(self): raise RuntimeError("Skip me too") class SynchronousSkippedClass(SkippedClassMixin, SynchronousTestCase): pass class AsynchronousSkippedClass(SkippedClassMixin, TestCase): pass class TodoMixin: def test_todo1(self): self.fail("deliberate failure") test_todo1.todo = "todo1" # type: ignore[attr-defined] def test_todo2(self): raise RuntimeError("deliberate error") test_todo2.todo = "todo2" # type: ignore[attr-defined] def test_todo3(self): """unexpected success""" test_todo3.todo = "todo3" # type: ignore[attr-defined] class SynchronousTodo(TodoMixin, SynchronousTestCase): pass class AsynchronousTodo(TodoMixin, TestCase): pass class SetUpTodoMixin: def setUp(self): raise RuntimeError("deliberate error") def test_todo1(self): pass test_todo1.todo = "setUp todo1" # type: ignore[attr-defined] class SynchronousSetUpTodo(SetUpTodoMixin, SynchronousTestCase): pass class AsynchronousSetUpTodo(SetUpTodoMixin, TestCase): pass class TearDownTodoMixin: def tearDown(self): raise RuntimeError("deliberate error") def test_todo1(self): pass test_todo1.todo = "tearDown todo1" # type: ignore[attr-defined] class SynchronousTearDownTodo(TearDownTodoMixin, SynchronousTestCase): pass class AsynchronousTearDownTodo(TearDownTodoMixin, TestCase): pass class TodoClassMixin: todo = "class" def test_todo1(self): pass test_todo1.todo = "method" # type: ignore[attr-defined] def test_todo2(self): pass def test_todo3(self): self.fail("Deliberate Failure") test_todo3.todo = "method" # type: ignore[attr-defined] def test_todo4(self): self.fail("Deliberate Failure") class SynchronousTodoClass(TodoClassMixin, SynchronousTestCase): pass class AsynchronousTodoClass(TodoClassMixin, TestCase): pass class StrictTodoMixin: def test_todo1(self): raise RuntimeError("expected failure") test_todo1.todo = (RuntimeError, "todo1") # type: ignore[attr-defined] def test_todo2(self): raise RuntimeError("expected failure") test_todo2.todo = ((RuntimeError, OSError), "todo2") # type: ignore[attr-defined] def test_todo3(self): raise RuntimeError("we had no idea!") test_todo3.todo = (OSError, "todo3") # type: ignore[attr-defined] def test_todo4(self): raise RuntimeError("we had no idea!") test_todo4.todo = ((OSError, SyntaxError), "todo4") # type: ignore[attr-defined] def test_todo5(self): self.fail("deliberate failure") test_todo5.todo = (FailTest, "todo5") # type: ignore[attr-defined] def test_todo6(self): self.fail("deliberate failure") test_todo6.todo = (RuntimeError, "todo6") # type: ignore[attr-defined] def test_todo7(self): pass test_todo7.todo = (RuntimeError, "todo7") # type: ignore[attr-defined] class SynchronousStrictTodo(StrictTodoMixin, SynchronousTestCase): pass class AsynchronousStrictTodo(StrictTodoMixin, TestCase): pass class AddCleanupMixin: def setUp(self): self.log = ["setUp"] def brokenSetUp(self): self.log = ["setUp"] raise RuntimeError("Deliberate failure") def skippingSetUp(self): self.log = ["setUp"] raise SkipTest("Don't do this") def append(self, thing): self.log.append(thing) def tearDown(self): self.log.append("tearDown") def runTest(self): self.log.append("runTest") class SynchronousAddCleanup(AddCleanupMixin, SynchronousTestCase): pass class AsynchronousAddCleanup(AddCleanupMixin, TestCase): pass PK Mb�ZO�78� � trial/test/test_output.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for the output generated by trial. """ import os from io import StringIO from twisted.scripts import trial from twisted.trial import runner from twisted.trial.test import packages _noModuleError = "No module named 'frotz'" def runTrial(*args): from twisted.trial import reporter config = trial.Options() config.parseOptions(args) output = StringIO() myRunner = runner.TrialRunner( reporter.VerboseTextReporter, stream=output, workingDirectory=config["temp-directory"], ) suite = trial._getSuite(config) myRunner.run(suite) return output.getvalue() class ImportErrorsTests(packages.SysPathManglingTest): """Actually run trial as if on the command line and check that the output is what we expect. """ def debug(self): pass parent = "_testImportErrors" def runTrial(self, *args): return runTrial("--temp-directory", self.mktemp(), *args) def _print(self, stuff): print(stuff) return stuff def assertIn(self, container, containee, *args, **kwargs): # redefined to be useful in callbacks super().assertIn(containee, container, *args, **kwargs) return container def assertNotIn(self, container, containee, *args, **kwargs): # redefined to be useful in callbacks super().assertNotIn(containee, container, *args, **kwargs) return container def test_trialRun(self): self.runTrial() def test_nonexistentModule(self): d = self.runTrial("twisted.doesntexist") self.assertIn(d, "[ERROR]") self.assertIn(d, "twisted.doesntexist") return d def test_nonexistentPackage(self): d = self.runTrial("doesntexist") self.assertIn(d, "doesntexist") self.assertIn(d, "ModuleNotFound") self.assertIn(d, "[ERROR]") return d def test_nonexistentPackageWithModule(self): d = self.runTrial("doesntexist.barney") self.assertIn(d, "doesntexist.barney") self.assertIn(d, "ObjectNotFound") self.assertIn(d, "[ERROR]") return d def test_badpackage(self): d = self.runTrial("badpackage") self.assertIn(d, "[ERROR]") self.assertIn(d, "badpackage") self.assertNotIn(d, "IOError") return d def test_moduleInBadpackage(self): d = self.runTrial("badpackage.test_module") self.assertIn(d, "[ERROR]") self.assertIn(d, "badpackage.test_module") self.assertNotIn(d, "IOError") return d def test_badmodule(self): d = self.runTrial("package.test_bad_module") self.assertIn(d, "[ERROR]") self.assertIn(d, "package.test_bad_module") self.assertNotIn(d, "IOError") self.assertNotIn(d, "<module ") return d def test_badimport(self): d = self.runTrial("package.test_import_module") self.assertIn(d, "[ERROR]") self.assertIn(d, "package.test_import_module") self.assertNotIn(d, "IOError") self.assertNotIn(d, "<module ") return d def test_recurseImport(self): d = self.runTrial("package") self.assertIn(d, "[ERROR]") self.assertIn(d, "test_bad_module") self.assertIn(d, "test_import_module") self.assertNotIn(d, "<module ") self.assertNotIn(d, "IOError") return d def test_recurseImportErrors(self): d = self.runTrial("package2") self.assertIn(d, "[ERROR]") self.assertIn(d, "package2") self.assertIn(d, "test_module") self.assertIn(d, _noModuleError) self.assertNotIn(d, "<module ") self.assertNotIn(d, "IOError") return d def test_nonRecurseImportErrors(self): d = self.runTrial("-N", "package2") self.assertIn(d, "[ERROR]") self.assertIn(d, _noModuleError) self.assertNotIn(d, "<module ") return d def test_regularRun(self): d = self.runTrial("package.test_module") self.assertNotIn(d, "[ERROR]") self.assertNotIn(d, "IOError") self.assertIn(d, "OK") self.assertIn(d, "PASSED (successes=1)") return d def test_filename(self): self.mangleSysPath(self.oldPath) d = self.runTrial(os.path.join(self.parent, "package", "test_module.py")) self.assertNotIn(d, "[ERROR]") self.assertNotIn(d, "IOError") self.assertIn(d, "OK") self.assertIn(d, "PASSED (successes=1)") return d def test_dosFile(self): ## XXX -- not really an output test, more of a script test self.mangleSysPath(self.oldPath) d = self.runTrial(os.path.join(self.parent, "package", "test_dos_module.py")) self.assertNotIn(d, "[ERROR]") self.assertNotIn(d, "IOError") self.assertIn(d, "OK") self.assertIn(d, "PASSED (successes=1)") return d PK Mb�Z't�` ` trial/test/ordertests.pynu �[��� # -*- test-case-name: twisted.trial.test.test_script -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for handling of trial's --order option. """ from twisted.trial import unittest class FooTest(unittest.TestCase): """ Used to make assertions about the order its tests will be run in. """ def test_first(self): pass def test_second(self): pass def test_third(self): pass def test_fourth(self): pass class BazTest(unittest.TestCase): """ Used to make assertions about the order the test cases in this module are run in. """ def test_baz(self): pass class BarTest(unittest.TestCase): """ Used to make assertions about the order the test cases in this module are run in. """ def test_bar(self): pass PK Mb�Z��0 � � trial/test/test_doctest.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test Twisted's doctest support. """ from twisted.trial import itrial, reporter, runner, unittest from twisted.trial.test import mockdoctest class RunnersTests(unittest.SynchronousTestCase): """ Tests for Twisted's doctest support. """ def test_id(self): """ Check that the id() of the doctests' case object contains the FQPN of the actual tests. """ loader = runner.TestLoader() suite = loader.loadDoctests(mockdoctest) idPrefix = "twisted.trial.test.mockdoctest.Counter" for test in suite._tests: self.assertIn(idPrefix, itrial.ITestCase(test).id()) def test_basicTrialIntegration(self): """ L{loadDoctests} loads all of the doctests in the given module. """ loader = runner.TestLoader() suite = loader.loadDoctests(mockdoctest) self.assertEqual(7, suite.countTestCases()) def _testRun(self, suite): """ Run C{suite} and check the result. """ result = reporter.TestResult() suite.run(result) self.assertEqual(5, result.successes) self.assertEqual(2, len(result.failures)) def test_expectedResults(self, count=1): """ Trial can correctly run doctests with its xUnit test APIs. """ suite = runner.TestLoader().loadDoctests(mockdoctest) self._testRun(suite) def test_repeatable(self): """ Doctests should be runnable repeatably. """ suite = runner.TestLoader().loadDoctests(mockdoctest) self._testRun(suite) self._testRun(suite) PK Mb�ZP��r �r trial/test/test_script.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import gc import re import sys import textwrap import types from io import StringIO from twisted.python import util from twisted.python.filepath import FilePath from twisted.python.usage import UsageError from twisted.scripts import trial from twisted.trial import unittest from twisted.trial._dist.disttrial import DistTrialRunner from twisted.trial.runner import ( DestructiveTestSuite, TestLoader, TestSuite, TrialRunner, ) from twisted.trial.test.test_loader import testNames pyunit = __import__("unittest") def sibpath(filename): """ For finding files in twisted/trial/test """ return util.sibpath(__file__, filename) class ForceGarbageCollectionTests(unittest.SynchronousTestCase): """ Tests for the --force-gc option. """ def setUp(self): self.config = trial.Options() self.log = [] self.patch(gc, "collect", self.collect) test = pyunit.FunctionTestCase(self.simpleTest) self.test = TestSuite([test, test]) def simpleTest(self): """ A simple test method that records that it was run. """ self.log.append("test") def collect(self): """ A replacement for gc.collect that logs calls to itself. """ self.log.append("collect") def makeRunner(self): """ Return a L{TrialRunner} object that is safe to use in tests. """ runner = trial._makeRunner(self.config) runner.stream = StringIO() return runner def test_forceGc(self): """ Passing the --force-gc option to the trial script forces the garbage collector to run before and after each test. """ self.config["force-gc"] = True self.config.postOptions() runner = self.makeRunner() runner.run(self.test) self.assertEqual( self.log, ["collect", "test", "collect", "collect", "test", "collect"] ) def test_unforceGc(self): """ By default, no garbage collection is forced. """ self.config.postOptions() runner = self.makeRunner() runner.run(self.test) self.assertEqual(self.log, ["test", "test"]) class SuiteUsedTests(unittest.SynchronousTestCase): """ Check the category of tests suite used by the loader. """ def setUp(self): """ Create a trial configuration object. """ self.config = trial.Options() def test_defaultSuite(self): """ By default, the loader should use L{DestructiveTestSuite} """ loader = trial._getLoader(self.config) self.assertEqual(loader.suiteFactory, DestructiveTestSuite) def test_untilFailureSuite(self): """ The C{until-failure} configuration uses the L{TestSuite} to keep instances alive across runs. """ self.config["until-failure"] = True loader = trial._getLoader(self.config) self.assertEqual(loader.suiteFactory, TestSuite) class TestModuleTests(unittest.SynchronousTestCase): def setUp(self): self.config = trial.Options() def tearDown(self): self.config = None def test_testNames(self): """ Check that the testNames helper method accurately collects the names of tests in suite. """ self.assertEqual(testNames(self), [self.id()]) def assertSuitesEqual(self, test1, names): loader = TestLoader() names1 = testNames(test1) names2 = testNames(TestSuite(map(loader.loadByName, names))) names1.sort() names2.sort() self.assertEqual(names1, names2) def test_baseState(self): self.assertEqual(0, len(self.config["tests"])) def test_testmoduleOnModule(self): """ Check that --testmodule loads a suite which contains the tests referred to in test-case-name inside its parameter. """ self.config.opt_testmodule(sibpath("moduletest.py")) self.assertSuitesEqual( trial._getSuite(self.config), ["twisted.trial.test.test_log"] ) def test_testmoduleTwice(self): """ When the same module is specified with two --testmodule flags, it should only appear once in the suite. """ self.config.opt_testmodule(sibpath("moduletest.py")) self.config.opt_testmodule(sibpath("moduletest.py")) self.assertSuitesEqual( trial._getSuite(self.config), ["twisted.trial.test.test_log"] ) def test_testmoduleOnSourceAndTarget(self): """ If --testmodule is specified twice, once for module A and once for a module which refers to module A, then make sure module A is only added once. """ self.config.opt_testmodule(sibpath("moduletest.py")) self.config.opt_testmodule(sibpath("test_log.py")) self.assertSuitesEqual( trial._getSuite(self.config), ["twisted.trial.test.test_log"] ) def test_testmoduleOnSelfModule(self): """ When given a module that refers to *itself* in the test-case-name variable, check that --testmodule only adds the tests once. """ self.config.opt_testmodule(sibpath("moduleself.py")) self.assertSuitesEqual( trial._getSuite(self.config), ["twisted.trial.test.moduleself"] ) def test_testmoduleOnScript(self): """ Check that --testmodule loads tests referred to in test-case-name buffer variables. """ self.config.opt_testmodule(sibpath("scripttest.py")) self.assertSuitesEqual( trial._getSuite(self.config), ["twisted.trial.test.test_log", "twisted.trial.test.test_runner"], ) def test_testmoduleOnNonexistentFile(self): """ Check that --testmodule displays a meaningful error message when passed a non-existent filename. """ buffy = StringIO() stderr, sys.stderr = sys.stderr, buffy filename = "test_thisbetternoteverexist.py" try: self.config.opt_testmodule(filename) self.assertEqual(0, len(self.config["tests"])) self.assertEqual(f"File {filename!r} doesn't exist\n", buffy.getvalue()) finally: sys.stderr = stderr def test_testmoduleOnEmptyVars(self): """ Check that --testmodule adds no tests to the suite for modules which lack test-case-name buffer variables. """ self.config.opt_testmodule(sibpath("novars.py")) self.assertEqual(0, len(self.config["tests"])) def test_testmoduleOnModuleName(self): """ Check that --testmodule does *not* support module names as arguments and that it displays a meaningful error message. """ buffy = StringIO() stderr, sys.stderr = sys.stderr, buffy moduleName = "twisted.trial.test.test_script" try: self.config.opt_testmodule(moduleName) self.assertEqual(0, len(self.config["tests"])) self.assertEqual(f"File {moduleName!r} doesn't exist\n", buffy.getvalue()) finally: sys.stderr = stderr def test_parseLocalVariable(self): declaration = "-*- test-case-name: twisted.trial.test.test_tests -*-" localVars = trial._parseLocalVariables(declaration) self.assertEqual({"test-case-name": "twisted.trial.test.test_tests"}, localVars) def test_trailingSemicolon(self): declaration = "-*- test-case-name: twisted.trial.test.test_tests; -*-" localVars = trial._parseLocalVariables(declaration) self.assertEqual({"test-case-name": "twisted.trial.test.test_tests"}, localVars) def test_parseLocalVariables(self): declaration = ( "-*- test-case-name: twisted.trial.test.test_tests; " "foo: bar -*-" ) localVars = trial._parseLocalVariables(declaration) self.assertEqual( {"test-case-name": "twisted.trial.test.test_tests", "foo": "bar"}, localVars ) def test_surroundingGuff(self): declaration = "## -*- test-case-name: " "twisted.trial.test.test_tests -*- #" localVars = trial._parseLocalVariables(declaration) self.assertEqual({"test-case-name": "twisted.trial.test.test_tests"}, localVars) def test_invalidLine(self): self.assertRaises(ValueError, trial._parseLocalVariables, "foo") def test_invalidDeclaration(self): self.assertRaises(ValueError, trial._parseLocalVariables, "-*- foo -*-") self.assertRaises( ValueError, trial._parseLocalVariables, "-*- foo: bar; qux -*-" ) self.assertRaises( ValueError, trial._parseLocalVariables, "-*- foo: bar: baz; qux: qax -*-" ) def test_variablesFromFile(self): localVars = trial.loadLocalVariables(sibpath("moduletest.py")) self.assertEqual({"test-case-name": "twisted.trial.test.test_log"}, localVars) def test_noVariablesInFile(self): localVars = trial.loadLocalVariables(sibpath("novars.py")) self.assertEqual({}, localVars) def test_variablesFromScript(self): localVars = trial.loadLocalVariables(sibpath("scripttest.py")) self.assertEqual( { "test-case-name": ( "twisted.trial.test.test_log," "twisted.trial.test.test_runner" ) }, localVars, ) def test_getTestModules(self): modules = trial.getTestModules(sibpath("moduletest.py")) self.assertEqual(modules, ["twisted.trial.test.test_log"]) def test_getTestModules_noVars(self): modules = trial.getTestModules(sibpath("novars.py")) self.assertEqual(len(modules), 0) def test_getTestModules_multiple(self): modules = trial.getTestModules(sibpath("scripttest.py")) self.assertEqual( set(modules), {"twisted.trial.test.test_log", "twisted.trial.test.test_runner"}, ) def test_looksLikeTestModule(self): for filename in ["test_script.py", "twisted/trial/test/test_script.py"]: self.assertTrue( trial.isTestFile(filename), f"{filename!r} should be a test file", ) for filename in [ "twisted/trial/test/moduletest.py", sibpath("scripttest.py"), sibpath("test_foo.bat"), ]: self.assertFalse( trial.isTestFile(filename), f"{filename!r} should *not* be a test file", ) class WithoutModuleTests(unittest.SynchronousTestCase): """ Test the C{without-module} flag. """ def setUp(self): """ Create a L{trial.Options} object to be used in the tests, and save C{sys.modules}. """ self.config = trial.Options() self.savedModules = dict(sys.modules) def tearDown(self): """ Restore C{sys.modules}. """ for module in ("imaplib", "smtplib"): if module in self.savedModules: sys.modules[module] = self.savedModules[module] else: sys.modules.pop(module, None) def _checkSMTP(self): """ Try to import the C{smtplib} module, and return it. """ import smtplib return smtplib def _checkIMAP(self): """ Try to import the C{imaplib} module, and return it. """ import imaplib return imaplib def test_disableOneModule(self): """ Check that after disabling a module, it can't be imported anymore. """ self.config.parseOptions(["--without-module", "smtplib"]) self.assertRaises(ImportError, self._checkSMTP) # Restore sys.modules del sys.modules["smtplib"] # Then the function should succeed self.assertIsInstance(self._checkSMTP(), types.ModuleType) def test_disableMultipleModules(self): """ Check that several modules can be disabled at once. """ self.config.parseOptions(["--without-module", "smtplib,imaplib"]) self.assertRaises(ImportError, self._checkSMTP) self.assertRaises(ImportError, self._checkIMAP) # Restore sys.modules del sys.modules["smtplib"] del sys.modules["imaplib"] # Then the functions should succeed self.assertIsInstance(self._checkSMTP(), types.ModuleType) self.assertIsInstance(self._checkIMAP(), types.ModuleType) def test_disableAlreadyImportedModule(self): """ Disabling an already imported module should produce a warning. """ self.assertIsInstance(self._checkSMTP(), types.ModuleType) self.assertWarns( RuntimeWarning, "Module 'smtplib' already imported, disabling anyway.", trial.__file__, self.config.parseOptions, ["--without-module", "smtplib"], ) self.assertRaises(ImportError, self._checkSMTP) class CoverageTests(unittest.SynchronousTestCase): """ Tests for the I{coverage} option. """ if getattr(sys, "gettrace", None) is None: skip = "Cannot test trace hook installation without inspection API." def setUp(self): """ Arrange for the current trace hook to be restored when the test is complete. """ self.addCleanup(sys.settrace, sys.gettrace()) def test_tracerInstalled(self): """ L{trial.Options} handles C{"--coverage"} by installing a trace hook to record coverage information. """ options = trial.Options() options.parseOptions(["--coverage"]) self.assertEqual(sys.gettrace(), options.tracer.globaltrace) def test_coverdirDefault(self): """ L{trial.Options.coverdir} returns a L{FilePath} based on the default for the I{temp-directory} option if that option is not specified. """ options = trial.Options() self.assertEqual( options.coverdir(), FilePath(".").descendant([options["temp-directory"], "coverage"]), ) def test_coverdirOverridden(self): """ If a value is specified for the I{temp-directory} option, L{trial.Options.coverdir} returns a child of that path. """ path = self.mktemp() options = trial.Options() options.parseOptions(["--temp-directory", path]) self.assertEqual(options.coverdir(), FilePath(path).child("coverage")) class OptionsTests(unittest.TestCase): """ Tests for L{trial.Options}. """ def setUp(self): """ Build an L{Options} object to be used in the tests. """ self.options = trial.Options() def test_getWorkerArguments(self): """ C{_getWorkerArguments} discards options like C{random} as they only matter in the manager, and forwards options like C{recursionlimit} or C{disablegc}. """ self.addCleanup(sys.setrecursionlimit, sys.getrecursionlimit()) if gc.isenabled(): self.addCleanup(gc.enable) self.options.parseOptions( ["--recursionlimit", "2000", "--random", "4", "--disablegc"] ) args = self.options._getWorkerArguments() self.assertIn("--disablegc", args) args.remove("--disablegc") self.assertEqual(["--recursionlimit", "2000"], args) def test_jobsConflictWithDebug(self): """ C{parseOptions} raises a C{UsageError} when C{--debug} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5825} """ error = self.assertRaises( UsageError, self.options.parseOptions, ["--jobs", "4", "--debug"] ) self.assertEqual("You can't specify --debug when using --jobs", str(error)) def test_jobsConflictWithProfile(self): """ C{parseOptions} raises a C{UsageError} when C{--profile} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5827} """ error = self.assertRaises( UsageError, self.options.parseOptions, ["--jobs", "4", "--profile"] ) self.assertEqual("You can't specify --profile when using --jobs", str(error)) def test_jobsConflictWithDebugStackTraces(self): """ C{parseOptions} raises a C{UsageError} when C{--debug-stacktraces} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5826} """ error = self.assertRaises( UsageError, self.options.parseOptions, ["--jobs", "4", "--debug-stacktraces"], ) self.assertEqual( "You can't specify --debug-stacktraces when using --jobs", str(error) ) def test_jobsConflictWithExitFirst(self): """ C{parseOptions} raises a C{UsageError} when C{--exitfirst} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/6436} """ error = self.assertRaises( UsageError, self.options.parseOptions, ["--jobs", "4", "--exitfirst"] ) self.assertEqual("You can't specify --exitfirst when using --jobs", str(error)) def test_orderConflictWithRandom(self): """ C{parseOptions} raises a C{UsageError} when C{--order} is passed along with C{--random}. """ error = self.assertRaises( UsageError, self.options.parseOptions, ["--order", "alphabetical", "--random", "1234"], ) self.assertEqual("You can't specify --random when using --order", str(error)) class MakeRunnerTests(unittest.TestCase): """ Tests for the L{_makeRunner} helper. """ def setUp(self): self.options = trial.Options() def test_jobs(self): """ L{_makeRunner} returns a L{DistTrialRunner} instance when the C{--jobs} option is passed, and passes the C{workerNumber} and C{workerArguments} parameters to it. """ self.options.parseOptions(["--jobs", "4", "--force-gc"]) runner = trial._makeRunner(self.options) self.assertIsInstance(runner, DistTrialRunner) self.assertEqual(4, runner._workerNumber) self.assertEqual(["--force-gc"], runner._workerArguments) def test_dryRunWithJobs(self): """ L{_makeRunner} returns a L{TrialRunner} instance in C{DRY_RUN} mode when the C{--dry-run} option is passed, even if C{--jobs} is set. """ self.options.parseOptions(["--jobs", "4", "--dry-run"]) runner = trial._makeRunner(self.options) self.assertIsInstance(runner, TrialRunner) self.assertEqual(TrialRunner.DRY_RUN, runner.mode) def test_DebuggerNotFound(self): namedAny = trial.reflect.namedAny def namedAnyExceptdoNotFind(fqn): if fqn == "doNotFind": raise trial.reflect.ModuleNotFound(fqn) return namedAny(fqn) self.patch(trial.reflect, "namedAny", namedAnyExceptdoNotFind) options = trial.Options() options.parseOptions(["--debug", "--debugger", "doNotFind"]) self.assertRaises(trial._DebuggerNotFound, trial._makeRunner, options) def test_exitfirst(self): """ Passing C{--exitfirst} wraps the reporter with a L{reporter._ExitWrapper} that stops on any non-success. """ self.options.parseOptions(["--exitfirst"]) runner = trial._makeRunner(self.options) self.assertTrue(runner._exitFirst) class RunTests(unittest.TestCase): """ Tests for the L{run} function. """ def setUp(self): # don't re-parse cmdline options, because if --reactor was passed to # the test run trial will try to restart the (already running) reactor self.patch(trial.Options, "parseOptions", lambda self: None) def test_debuggerNotFound(self): """ When a debugger is not found, an error message is printed to the user. """ def _makeRunner(*args, **kwargs): raise trial._DebuggerNotFound("foo") self.patch(trial, "_makeRunner", _makeRunner) try: trial.run() except SystemExit as e: self.assertIn("foo", str(e)) else: self.fail("Should have exited due to non-existent debugger!") class TestArgumentOrderTests(unittest.TestCase): """ Tests for the order-preserving behavior on provided command-line tests. """ def setUp(self): self.config = trial.Options() self.loader = TestLoader() def test_preserveArgumentOrder(self): """ Multiple tests passed on the command line are not reordered. """ tests = [ "twisted.trial.test.test_tests", "twisted.trial.test.test_assertions", "twisted.trial.test.test_deferred", ] self.config.parseOptions(tests) suite = trial._getSuite(self.config) names = testNames(suite) expectedSuite = TestSuite(map(self.loader.loadByName, tests)) expectedNames = testNames(expectedSuite) self.assertEqual(names, expectedNames) class OrderTests(unittest.TestCase): """ Tests for the --order option. """ def setUp(self): self.config = trial.Options() def test_alphabetical(self): """ --order=alphabetical causes trial to run tests alphabetically within each test case. """ self.config.parseOptions( ["--order", "alphabetical", "twisted.trial.test.ordertests.FooTest"] ) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) self.assertEqual( testNames(suite), [ "twisted.trial.test.ordertests.FooTest.test_first", "twisted.trial.test.ordertests.FooTest.test_fourth", "twisted.trial.test.ordertests.FooTest.test_second", "twisted.trial.test.ordertests.FooTest.test_third", ], ) def test_alphabeticalModule(self): """ --order=alphabetical causes trial to run test classes within a given module alphabetically. """ self.config.parseOptions( ["--order", "alphabetical", "twisted.trial.test.ordertests"] ) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) self.assertEqual( testNames(suite), [ "twisted.trial.test.ordertests.BarTest.test_bar", "twisted.trial.test.ordertests.BazTest.test_baz", "twisted.trial.test.ordertests.FooTest.test_first", "twisted.trial.test.ordertests.FooTest.test_fourth", "twisted.trial.test.ordertests.FooTest.test_second", "twisted.trial.test.ordertests.FooTest.test_third", ], ) def test_alphabeticalPackage(self): """ --order=alphabetical causes trial to run test modules within a given package alphabetically, with tests within each module alphabetized. """ self.config.parseOptions(["--order", "alphabetical", "twisted.trial.test"]) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) names = testNames(suite) self.assertTrue(names, msg="Failed to load any tests!") self.assertEqual(names, sorted(names)) def test_toptobottom(self): """ --order=toptobottom causes trial to run test methods within a given test case from top to bottom as they are defined in the body of the class. """ self.config.parseOptions( ["--order", "toptobottom", "twisted.trial.test.ordertests.FooTest"] ) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) self.assertEqual( testNames(suite), [ "twisted.trial.test.ordertests.FooTest.test_first", "twisted.trial.test.ordertests.FooTest.test_second", "twisted.trial.test.ordertests.FooTest.test_third", "twisted.trial.test.ordertests.FooTest.test_fourth", ], ) def test_toptobottomModule(self): """ --order=toptobottom causes trial to run test classes within a given module from top to bottom as they are defined in the module's source. """ self.config.parseOptions( ["--order", "toptobottom", "twisted.trial.test.ordertests"] ) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) self.assertEqual( testNames(suite), [ "twisted.trial.test.ordertests.FooTest.test_first", "twisted.trial.test.ordertests.FooTest.test_second", "twisted.trial.test.ordertests.FooTest.test_third", "twisted.trial.test.ordertests.FooTest.test_fourth", "twisted.trial.test.ordertests.BazTest.test_baz", "twisted.trial.test.ordertests.BarTest.test_bar", ], ) def test_toptobottomPackage(self): """ --order=toptobottom causes trial to run test modules within a given package alphabetically, with tests within each module run top to bottom. """ self.config.parseOptions(["--order", "toptobottom", "twisted.trial.test"]) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) names = testNames(suite) # twisted.trial.test.test_module, so split and key on the first 4 to # get stable alphabetical sort on those self.assertEqual( names, sorted(names, key=lambda name: name.split(".")[:4]), ) def test_toptobottomMissingSource(self): """ --order=toptobottom detects the source line of methods from modules whose source file is missing. """ tempdir = self.mktemp() package = FilePath(tempdir).child("twisted_toptobottom_temp") package.makedirs() package.child("__init__.py").setContent(b"") package.child("test_missing.py").setContent( textwrap.dedent( """ from twisted.trial.unittest import TestCase class TestMissing(TestCase): def test_second(self): pass def test_third(self): pass def test_fourth(self): pass def test_first(self): pass """ ).encode("utf8") ) pathEntry = package.parent().path sys.path.insert(0, pathEntry) self.addCleanup(sys.path.remove, pathEntry) from twisted_toptobottom_temp import test_missing # type: ignore[import] self.addCleanup(sys.modules.pop, "twisted_toptobottom_temp") self.addCleanup(sys.modules.pop, test_missing.__name__) package.child("test_missing.py").remove() self.config.parseOptions( ["--order", "toptobottom", "twisted.trial.test.ordertests"] ) loader = trial._getLoader(self.config) suite = loader.loadModule(test_missing) self.assertEqual( testNames(suite), [ "twisted_toptobottom_temp.test_missing.TestMissing.test_second", "twisted_toptobottom_temp.test_missing.TestMissing.test_third", "twisted_toptobottom_temp.test_missing.TestMissing.test_fourth", "twisted_toptobottom_temp.test_missing.TestMissing.test_first", ], ) def test_unknownOrder(self): """ An unknown order passed to --order raises a L{UsageError}. """ self.assertRaises( UsageError, self.config.parseOptions, ["--order", "I don't exist"] ) class HelpOrderTests(unittest.TestCase): """ Tests for the --help-orders flag. """ def test_help_ordersPrintsSynopsisAndQuits(self): """ --help-orders prints each of the available orders and then exits. """ self.patch(sys, "stdout", StringIO()) exc = self.assertRaises( SystemExit, trial.Options().parseOptions, ["--help-orders"] ) self.assertEqual(exc.code, 0) output = sys.stdout.getvalue() msg = "%r with its description not properly described in %r" for orderName, (orderDesc, _) in trial._runOrders.items(): match = re.search( f"{re.escape(orderName)}.*{re.escape(orderDesc)}", output, ) self.assertTrue(match, msg=msg % (orderName, output)) PK Mb�Z {%[ [ trial/test/test_skip.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # """ Tests for L{twisted.trial.util} """ from unittest import skipIf from twisted.trial.unittest import TestCase @skipIf(True, "Skip all tests when @skipIf is used on a class") class SkipDecoratorUsedOnClass(TestCase): """ All tests should be skipped because @skipIf decorator is used on this class. """ def test_shouldNeverRun_1(self): raise Exception("Test should skip and never reach here") def test_shouldNeverRun_2(self): raise Exception("Test should skip and never reach here") @skipIf(True, "") class SkipDecoratorUsedOnClassWithEmptyReason(TestCase): """ All tests should be skipped because @skipIf decorator is used on this class, even if the reason is an empty string """ def test_shouldNeverRun_1(self): raise Exception("Test should skip and never reach here") def test_shouldNeverRun_2(self): raise Exception("Test should skip and never reach here") class SkipDecoratorUsedOnMethods(TestCase): """ Only methods where @skipIf decorator is used should be skipped. """ @skipIf(True, "skipIf decorator used so skip test") def test_shouldNeverRun(self): raise Exception("Test should skip and never reach here") @skipIf(True, "") def test_shouldNeverRunWithEmptyReason(self): raise Exception("Test should skip and never reach here") def test_shouldShouldRun(self): self.assertTrue(True, "Test should run and not be skipped") @skipIf(False, "should not skip") def test_shouldShouldRunWithSkipIfFalse(self): self.assertTrue(True, "Test should run and not be skipped") @skipIf(False, "") def test_shouldShouldRunWithSkipIfFalseEmptyReason(self): self.assertTrue(True, "Test should run and not be skipped") class SkipAttributeOnClass(TestCase): """ All tests should be skipped because skip attribute is set on this class. """ skip = "'skip' attribute set on this class, so skip all tests" def test_one(self): raise Exception("Test should skip and never reach here") def test_two(self): raise Exception("Test should skip and never reach here") class SkipAttributeOnMethods(TestCase): """ Only methods where @skipIf decorator is used should be skipped. """ def test_one(self): raise Exception("Should never reach here") test_one.skip = "skip test, skip attribute set on method" # type: ignore[attr-defined] def test_shouldNotSkip(self): self.assertTrue(True, "Test should run and not be skipped") PK Mb�Z_-"� � trial/test/test_pyunitcompat.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import sys import traceback import unittest as pyunit from unittest import skipIf from zope.interface import implementer from twisted.python.failure import Failure from twisted.trial.itrial import IReporter, ITestCase from twisted.trial.unittest import PyUnitResultAdapter, SynchronousTestCase class PyUnitTestTests(SynchronousTestCase): class PyUnitTest(pyunit.TestCase): def test_pass(self): pass def setUp(self): self.original = self.PyUnitTest("test_pass") self.test = ITestCase(self.original) def test_callable(self): """ Tests must be callable in order to be used with Python's unittest.py. """ self.assertTrue(callable(self.test), f"{self.test!r} is not callable.") class PyUnitResultTests(SynchronousTestCase): """ Tests to show that PyUnitResultAdapter wraps TestResult objects from the standard library 'unittest' module in such a way as to make them usable and useful from Trial. """ # Once erroneous is ported to Python 3 this can be replaced with # erroneous.ErrorTest: class ErrorTest(SynchronousTestCase): """ A test case which has a L{test_foo} which will raise an error. @ivar ran: boolean indicating whether L{test_foo} has been run. """ ran = False def test_foo(self): """ Set C{self.ran} to True and raise a C{ZeroDivisionError} """ self.ran = True 1 / 0 def test_dontUseAdapterWhenReporterProvidesIReporter(self): """ The L{PyUnitResultAdapter} is only used when the result passed to C{run} does *not* provide L{IReporter}. """ @implementer(IReporter) class StubReporter: """ A reporter which records data about calls made to it. @ivar errors: Errors passed to L{addError}. @ivar failures: Failures passed to L{addFailure}. """ def __init__(self): self.errors = [] self.failures = [] def startTest(self, test): """ Do nothing. """ def stopTest(self, test): """ Do nothing. """ def addError(self, test, error): """ Record the error. """ self.errors.append(error) test = self.ErrorTest("test_foo") result = StubReporter() test.run(result) self.assertIsInstance(result.errors[0], Failure) def test_success(self): class SuccessTest(SynchronousTestCase): ran = False def test_foo(s): s.ran = True test = SuccessTest("test_foo") result = pyunit.TestResult() test.run(result) self.assertTrue(test.ran) self.assertEqual(1, result.testsRun) self.assertTrue(result.wasSuccessful()) def test_failure(self): class FailureTest(SynchronousTestCase): ran = False def test_foo(s): s.ran = True s.fail("boom!") test = FailureTest("test_foo") result = pyunit.TestResult() test.run(result) self.assertTrue(test.ran) self.assertEqual(1, result.testsRun) self.assertEqual(1, len(result.failures)) self.assertFalse(result.wasSuccessful()) def test_error(self): test = self.ErrorTest("test_foo") result = pyunit.TestResult() test.run(result) self.assertTrue(test.ran) self.assertEqual(1, result.testsRun) self.assertEqual(1, len(result.errors)) self.assertFalse(result.wasSuccessful()) def test_setUpError(self): class ErrorTest(SynchronousTestCase): ran = False def setUp(self): 1 / 0 def test_foo(s): s.ran = True test = ErrorTest("test_foo") result = pyunit.TestResult() test.run(result) self.assertFalse(test.ran) self.assertEqual(1, result.testsRun) self.assertEqual(1, len(result.errors)) self.assertFalse(result.wasSuccessful()) def test_tracebackFromFailure(self): """ Errors added through the L{PyUnitResultAdapter} have the same traceback information as if there were no adapter at all. """ try: 1 / 0 except ZeroDivisionError: exc_info = sys.exc_info() f = Failure() pyresult = pyunit.TestResult() result = PyUnitResultAdapter(pyresult) result.addError(self, f) self.assertEqual( pyresult.errors[0][1], "".join(traceback.format_exception(*exc_info)) ) def test_traceback(self): """ As test_tracebackFromFailure, but covering more code. """ class ErrorTest(SynchronousTestCase): exc_info = None def test_foo(self): try: 1 / 0 except ZeroDivisionError: self.exc_info = sys.exc_info() raise test = ErrorTest("test_foo") result = pyunit.TestResult() test.run(result) # We can't test that the tracebacks are equal, because Trial's # machinery inserts a few extra frames on the top and we don't really # want to trim them off without an extremely good reason. # # So, we just test that the result's stack ends with the # exception's stack. expected_stack = "".join(traceback.format_tb(test.exc_info[2])) observed_stack = "\n".join(result.errors[0][1].splitlines()[:-1]) self.assertEqual( expected_stack.strip(), observed_stack[-len(expected_stack) :].strip() ) def test_tracebackFromCleanFailure(self): """ Errors added through the L{PyUnitResultAdapter} have the same traceback information as if there were no adapter at all, even if the Failure that held the information has been cleaned. """ try: 1 / 0 except ZeroDivisionError: exc_info = sys.exc_info() f = Failure() f.cleanFailure() pyresult = pyunit.TestResult() result = PyUnitResultAdapter(pyresult) result.addError(self, f) self.assertEqual( pyresult.errors[0][1], "".join(traceback.format_exception(*exc_info)) ) def test_trialSkip(self): """ Skips using trial's skipping functionality are reported as skips in the L{pyunit.TestResult}. """ class SkipTest(SynchronousTestCase): @skipIf(True, "Let's skip!") def test_skip(self): 1 / 0 test = SkipTest("test_skip") result = pyunit.TestResult() test.run(result) self.assertEqual(result.skipped, [(test, "Let's skip!")]) def test_pyunitSkip(self): """ Skips using pyunit's skipping functionality are reported as skips in the L{pyunit.TestResult}. """ class SkipTest(SynchronousTestCase): @pyunit.skip("skippy") def test_skip(self): 1 / 0 test = SkipTest("test_skip") result = pyunit.TestResult() test.run(result) self.assertEqual(result.skipped, [(test, "skippy")]) PK Mb�Zȓ� � trial/test/test_testcase.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Direct unit tests for L{twisted.trial.unittest.SynchronousTestCase} and L{twisted.trial.unittest.TestCase}. """ from twisted.trial.unittest import SynchronousTestCase, TestCase class TestCaseMixin: """ L{TestCase} tests. """ def setUp(self): """ Create a couple instances of C{MyTestCase}, each for the same test method, to be used in the test methods of this class. """ self.first = self.MyTestCase("test_1") self.second = self.MyTestCase("test_1") def test_equality(self): """ In order for one test method to be runnable twice, two TestCase instances with the same test method name must not compare as equal. """ self.assertTrue(self.first == self.first) self.assertTrue(self.first != self.second) self.assertFalse(self.first == self.second) def test_hashability(self): """ In order for one test method to be runnable twice, two TestCase instances with the same test method name should not have the same hash value. """ container = {} container[self.first] = None container[self.second] = None self.assertEqual(len(container), 2) class SynchronousTestCaseTests(TestCaseMixin, SynchronousTestCase): class MyTestCase(SynchronousTestCase): """ Some test methods which can be used to test behaviors of L{SynchronousTestCase}. """ def test_1(self): pass # Yes, subclass SynchronousTestCase again. There are no interesting behaviors # of self being tested below, only of self.MyTestCase. class AsynchronousTestCaseTests(TestCaseMixin, SynchronousTestCase): class MyTestCase(TestCase): """ Some test methods which can be used to test behaviors of L{TestCase}. """ def test_1(self): pass PK Mb�Z�vUu u trial/test/mockdoctest.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # this module is a trivial class with doctests to test trial's doctest # support. class Counter: """a simple counter object for testing trial's doctest support >>> c = Counter() >>> c.value() 0 >>> c += 3 >>> c.value() 3 >>> c.incr() >>> c.value() == 4 True >>> c == 4 True >>> c != 9 True """ _count = 0 def __init__(self, initialValue=0, maxval=None): self._count = initialValue self.maxval = maxval def __iadd__(self, other): """add other to my value and return self >>> c = Counter(100) >>> c += 333 >>> c == 433 True """ if self.maxval is not None and ((self._count + other) > self.maxval): raise ValueError("sorry, counter got too big") else: self._count += other return self def __eq__(self, other: object) -> bool: """equality operator, compare other to my value() >>> c = Counter() >>> c == 0 True >>> c += 10 >>> c.incr() >>> c == 10 # fail this test on purpose True """ return self._count == other def __ne__(self, other: object) -> bool: """inequality operator >>> c = Counter() >>> c != 10 True """ return not self.__eq__(other) def incr(self): """increment my value by 1 >>> from twisted.trial.test.mockdoctest import Counter >>> c = Counter(10, 11) >>> c.incr() >>> c.value() == 11 True >>> c.incr() Traceback (most recent call last): File "<stdin>", line 1, in ? File "twisted/trial/test/mockdoctest.py", line 51, in incr self.__iadd__(1) File "twisted/trial/test/mockdoctest.py", line 39, in __iadd__ raise ValueError, "sorry, counter got too big" ValueError: sorry, counter got too big """ self.__iadd__(1) def value(self): """return this counter's value >>> c = Counter(555) >>> c.value() == 555 True """ return self._count def unexpectedException(self): """i will raise an unexpected exception... ... *CAUSE THAT'S THE KINDA GUY I AM* >>> 1/0 """ PK Mb�Z@���L �L trial/test/test_util.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # """ Tests for L{twisted.trial.util} """ import os import sys from io import StringIO from zope.interface import implementer from twisted.internet.base import DelayedCall from twisted.internet.interfaces import IProcessTransport from twisted.python import filepath from twisted.python.failure import Failure from twisted.trial import util from twisted.trial.unittest import SynchronousTestCase from twisted.trial.util import ( DirtyReactorAggregateError, _Janitor, acquireAttribute, excInfoOrFailureToExcInfo, ) class MktempTests(SynchronousTestCase): """ Tests for L{TestCase.mktemp}, a helper function for creating temporary file or directory names. """ def test_name(self): """ The path name returned by C{mktemp} is directly beneath a directory which identifies the test method which created the name. """ name = self.mktemp() dirs = os.path.dirname(name).split(os.sep)[:-1] self.assertEqual( dirs, ["twisted.trial.test.test_util", "MktempTests", "test_name"] ) def test_unique(self): """ Repeated calls to C{mktemp} return different values. """ name = self.mktemp() self.assertNotEqual(name, self.mktemp()) def test_created(self): """ The directory part of the path name returned by C{mktemp} exists. """ name = self.mktemp() dirname = os.path.dirname(name) self.assertTrue(os.path.exists(dirname)) self.assertFalse(os.path.exists(name)) def test_location(self): """ The path returned by C{mktemp} is beneath the current working directory. """ path = os.path.abspath(self.mktemp()) self.assertTrue(path.startswith(os.getcwd())) class DirtyReactorAggregateErrorTests(SynchronousTestCase): """ Tests for the L{DirtyReactorAggregateError}. """ def test_formatDelayedCall(self): """ Delayed calls are formatted nicely. """ error = DirtyReactorAggregateError(["Foo", "bar"]) self.assertEqual( str(error), """\ Reactor was unclean. DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug) Foo bar""", ) def test_formatSelectables(self): """ Selectables are formatted nicely. """ error = DirtyReactorAggregateError([], ["selectable 1", "selectable 2"]) self.assertEqual( str(error), """\ Reactor was unclean. Selectables: selectable 1 selectable 2""", ) def test_formatDelayedCallsAndSelectables(self): """ Both delayed calls and selectables can appear in the same error. """ error = DirtyReactorAggregateError(["bleck", "Boozo"], ["Sel1", "Sel2"]) self.assertEqual( str(error), """\ Reactor was unclean. DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug) bleck Boozo Selectables: Sel1 Sel2""", ) class StubReactor: """ A reactor stub which contains enough functionality to be used with the L{_Janitor}. @ivar iterations: A list of the arguments passed to L{iterate}. @ivar removeAllCalled: Number of times that L{removeAll} was called. @ivar selectables: The value that will be returned from L{removeAll}. @ivar delayedCalls: The value to return from L{getDelayedCalls}. """ def __init__(self, delayedCalls, selectables=None): """ @param delayedCalls: See L{StubReactor.delayedCalls}. @param selectables: See L{StubReactor.selectables}. """ self.delayedCalls = delayedCalls self.iterations = [] self.removeAllCalled = 0 if not selectables: selectables = [] self.selectables = selectables def iterate(self, timeout=None): """ Increment C{self.iterations}. """ self.iterations.append(timeout) def getDelayedCalls(self): """ Return C{self.delayedCalls}. """ return self.delayedCalls def removeAll(self): """ Increment C{self.removeAllCalled} and return C{self.selectables}. """ self.removeAllCalled += 1 return self.selectables class StubErrorReporter: """ A subset of L{twisted.trial.itrial.IReporter} which records L{addError} calls. @ivar errors: List of two-tuples of (test, error) which were passed to L{addError}. """ def __init__(self): self.errors = [] def addError(self, test, error): """ Record parameters in C{self.errors}. """ self.errors.append((test, error)) class JanitorTests(SynchronousTestCase): """ Tests for L{_Janitor}! """ def test_cleanPendingSpinsReactor(self): """ During pending-call cleanup, the reactor will be spun twice with an instant timeout. This is not a requirement, it is only a test for current behavior. Hopefully Trial will eventually not do this kind of reactor stuff. """ reactor = StubReactor([]) jan = _Janitor(None, None, reactor=reactor) jan._cleanPending() self.assertEqual(reactor.iterations, [0, 0]) def test_cleanPendingCancelsCalls(self): """ During pending-call cleanup, the janitor cancels pending timed calls. """ def func(): return "Lulz" cancelled = [] delayedCall = DelayedCall(300, func, (), {}, cancelled.append, lambda x: None) reactor = StubReactor([delayedCall]) jan = _Janitor(None, None, reactor=reactor) jan._cleanPending() self.assertEqual(cancelled, [delayedCall]) def test_cleanPendingReturnsDelayedCallStrings(self): """ The Janitor produces string representations of delayed calls from the delayed call cleanup method. It gets the string representations *before* cancelling the calls; this is important because cancelling the call removes critical debugging information from the string representation. """ delayedCall = DelayedCall( 300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0 ) delayedCallString = str(delayedCall) reactor = StubReactor([delayedCall]) jan = _Janitor(None, None, reactor=reactor) strings = jan._cleanPending() self.assertEqual(strings, [delayedCallString]) def test_cleanReactorRemovesSelectables(self): """ The Janitor will remove selectables during reactor cleanup. """ reactor = StubReactor([]) jan = _Janitor(None, None, reactor=reactor) jan._cleanReactor() self.assertEqual(reactor.removeAllCalled, 1) def test_cleanReactorKillsProcesses(self): """ The Janitor will kill processes during reactor cleanup. """ @implementer(IProcessTransport) class StubProcessTransport: """ A stub L{IProcessTransport} provider which records signals. @ivar signals: The signals passed to L{signalProcess}. """ def __init__(self): self.signals = [] def signalProcess(self, signal): """ Append C{signal} to C{self.signals}. """ self.signals.append(signal) pt = StubProcessTransport() reactor = StubReactor([], [pt]) jan = _Janitor(None, None, reactor=reactor) jan._cleanReactor() self.assertEqual(pt.signals, ["KILL"]) def test_cleanReactorReturnsSelectableStrings(self): """ The Janitor returns string representations of the selectables that it cleaned up from the reactor cleanup method. """ class Selectable: """ A stub Selectable which only has an interesting string representation. """ def __repr__(self) -> str: return "(SELECTABLE!)" reactor = StubReactor([], [Selectable()]) jan = _Janitor(None, None, reactor=reactor) self.assertEqual(jan._cleanReactor(), ["(SELECTABLE!)"]) def test_postCaseCleanupNoErrors(self): """ The post-case cleanup method will return True and not call C{addError} on the result if there are no pending calls. """ reactor = StubReactor([]) test = object() reporter = StubErrorReporter() jan = _Janitor(test, reporter, reactor=reactor) self.assertTrue(jan.postCaseCleanup()) self.assertEqual(reporter.errors, []) def test_postCaseCleanupWithErrors(self): """ The post-case cleanup method will return False and call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are pending calls. """ delayedCall = DelayedCall( 300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0 ) delayedCallString = str(delayedCall) reactor = StubReactor([delayedCall], []) test = object() reporter = StubErrorReporter() jan = _Janitor(test, reporter, reactor=reactor) self.assertFalse(jan.postCaseCleanup()) self.assertEqual(len(reporter.errors), 1) self.assertEqual(reporter.errors[0][1].value.delayedCalls, [delayedCallString]) def test_postClassCleanupNoErrors(self): """ The post-class cleanup method will not call C{addError} on the result if there are no pending calls or selectables. """ reactor = StubReactor([]) test = object() reporter = StubErrorReporter() jan = _Janitor(test, reporter, reactor=reactor) jan.postClassCleanup() self.assertEqual(reporter.errors, []) def test_postClassCleanupWithPendingCallErrors(self): """ The post-class cleanup method call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are pending calls. """ delayedCall = DelayedCall( 300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0 ) delayedCallString = str(delayedCall) reactor = StubReactor([delayedCall], []) test = object() reporter = StubErrorReporter() jan = _Janitor(test, reporter, reactor=reactor) jan.postClassCleanup() self.assertEqual(len(reporter.errors), 1) self.assertEqual(reporter.errors[0][1].value.delayedCalls, [delayedCallString]) def test_postClassCleanupWithSelectableErrors(self): """ The post-class cleanup method call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are selectables. """ selectable = "SELECTABLE HERE" reactor = StubReactor([], [selectable]) test = object() reporter = StubErrorReporter() jan = _Janitor(test, reporter, reactor=reactor) jan.postClassCleanup() self.assertEqual(len(reporter.errors), 1) self.assertEqual(reporter.errors[0][1].value.selectables, [repr(selectable)]) class RemoveSafelyTests(SynchronousTestCase): """ Tests for L{util._removeSafely}. """ def test_removeSafelyNoTrialMarker(self): """ If a path doesn't contain a node named C{"_trial_marker"}, that path is not removed by L{util._removeSafely} and a L{util._NoTrialMarker} exception is raised instead. """ directory = self.mktemp().encode("utf-8") os.mkdir(directory) dirPath = filepath.FilePath(directory) self.assertRaises(util._NoTrialMarker, util._removeSafely, dirPath) def test_removeSafelyRemoveFailsMoveSucceeds(self): """ If an L{OSError} is raised while removing a path in L{util._removeSafely}, an attempt is made to move the path to a new name. """ def dummyRemove(): """ Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path removal fails. """ raise OSError() # Patch stdout so we can check the print statements in _removeSafely out = StringIO() self.patch(sys, "stdout", out) # Set up a trial directory with a _trial_marker directory = self.mktemp().encode("utf-8") os.mkdir(directory) dirPath = filepath.FilePath(directory) dirPath.child(b"_trial_marker").touch() # Ensure that path.remove() raises an OSError dirPath.remove = dummyRemove util._removeSafely(dirPath) self.assertIn("could not remove FilePath", out.getvalue()) def test_removeSafelyRemoveFailsMoveFails(self): """ If an L{OSError} is raised while removing a path in L{util._removeSafely}, an attempt is made to move the path to a new name. If that attempt fails, the L{OSError} is re-raised. """ def dummyRemove(): """ Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path removal fails. """ raise OSError("path removal failed") def dummyMoveTo(path): """ Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path movement fails. """ raise OSError("path movement failed") # Patch stdout so we can check the print statements in _removeSafely out = StringIO() self.patch(sys, "stdout", out) # Set up a trial directory with a _trial_marker directory = self.mktemp().encode("utf-8") os.mkdir(directory) dirPath = filepath.FilePath(directory) dirPath.child(b"_trial_marker").touch() # Ensure that path.remove() and path.moveTo() both raise OSErrors dirPath.remove = dummyRemove dirPath.moveTo = dummyMoveTo error = self.assertRaises(OSError, util._removeSafely, dirPath) self.assertEqual(str(error), "path movement failed") self.assertIn("could not remove FilePath", out.getvalue()) class ExcInfoTests(SynchronousTestCase): """ Tests for L{excInfoOrFailureToExcInfo}. """ def test_excInfo(self): """ L{excInfoOrFailureToExcInfo} returns exactly what it is passed, if it is passed a tuple like the one returned by L{sys.exc_info}. """ info = (ValueError, ValueError("foo"), None) self.assertTrue(info is excInfoOrFailureToExcInfo(info)) def test_failure(self): """ When called with a L{Failure} instance, L{excInfoOrFailureToExcInfo} returns a tuple like the one returned by L{sys.exc_info}, with the elements taken from the type, value, and traceback of the failure. """ try: 1 / 0 except BaseException: f = Failure() self.assertEqual((f.type, f.value, f.tb), excInfoOrFailureToExcInfo(f)) class AcquireAttributeTests(SynchronousTestCase): """ Tests for L{acquireAttribute}. """ def test_foundOnEarlierObject(self): """ The value returned by L{acquireAttribute} is the value of the requested attribute on the first object in the list passed in which has that attribute. """ self.value = value = object() self.assertTrue(value is acquireAttribute([self, object()], "value")) def test_foundOnLaterObject(self): """ The same as L{test_foundOnEarlierObject}, but for the case where the 2nd element in the object list has the attribute and the first does not. """ self.value = value = object() self.assertTrue(value is acquireAttribute([object(), self], "value")) def test_notFoundException(self): """ If none of the objects passed in the list to L{acquireAttribute} have the requested attribute, L{AttributeError} is raised. """ self.assertRaises(AttributeError, acquireAttribute, [object()], "foo") def test_notFoundDefault(self): """ If none of the objects passed in the list to L{acquireAttribute} have the requested attribute and a default value is given, the default value is returned. """ default = object() self.assertTrue(default is acquireAttribute([object()], "foo", default)) class ListToPhraseTests(SynchronousTestCase): """ Input is transformed into a string representation of the list, with each item separated by delimiter (defaulting to a comma) and the final two being separated by a final delimiter. """ def test_empty(self): """ If things is empty, an empty string is returned. """ sample = [] expected = "" result = util._listToPhrase(sample, "and") self.assertEqual(expected, result) def test_oneWord(self): """ With a single item, the item is returned. """ sample = ["One"] expected = "One" result = util._listToPhrase(sample, "and") self.assertEqual(expected, result) def test_twoWords(self): """ Two words are separated by the final delimiter. """ sample = ["One", "Two"] expected = "One and Two" result = util._listToPhrase(sample, "and") self.assertEqual(expected, result) def test_threeWords(self): """ With more than two words, the first two are separated by the delimiter. """ sample = ["One", "Two", "Three"] expected = "One, Two, and Three" result = util._listToPhrase(sample, "and") self.assertEqual(expected, result) def test_fourWords(self): """ If a delimiter is specified, it is used instead of the default comma. """ sample = ["One", "Two", "Three", "Four"] expected = "One; Two; Three; or Four" result = util._listToPhrase(sample, "or", delimiter="; ") self.assertEqual(expected, result) def test_notString(self): """ If something in things is not a string, it is converted into one. """ sample = [1, 2, "three"] expected = "1, 2, and three" result = util._listToPhrase(sample, "and") self.assertEqual(expected, result) def test_stringTypeError(self): """ If things is a string, a TypeError is raised. """ sample = "One, two, three" error = self.assertRaises(TypeError, util._listToPhrase, sample, "and") self.assertEqual(str(error), "Things must be a list or a tuple") def test_iteratorTypeError(self): """ If things is an iterator, a TypeError is raised. """ sample = iter([1, 2, 3]) error = self.assertRaises(TypeError, util._listToPhrase, sample, "and") self.assertEqual(str(error), "Things must be a list or a tuple") def test_generatorTypeError(self): """ If things is a generator, a TypeError is raised. """ def sample(): yield from range(2) error = self.assertRaises(TypeError, util._listToPhrase, sample, "and") self.assertEqual(str(error), "Things must be a list or a tuple") PK Mb�Z�i��� � trial/test/suppression.pynu �[��� # -*- test-case-name: twisted.trial.test.test_tests -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases used to make sure that warning suppression works at the module, method, and class levels. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. """ import warnings from twisted.trial import unittest, util METHOD_WARNING_MSG = "method warning message" CLASS_WARNING_MSG = "class warning message" MODULE_WARNING_MSG = "module warning message" class MethodWarning(Warning): pass class ClassWarning(Warning): pass class ModuleWarning(Warning): pass class EmitMixin: """ Mixin for emiting a variety of warnings. """ def _emit(self): warnings.warn(METHOD_WARNING_MSG, MethodWarning) warnings.warn(CLASS_WARNING_MSG, ClassWarning) warnings.warn(MODULE_WARNING_MSG, ModuleWarning) class SuppressionMixin(EmitMixin): suppress = [util.suppress(message=CLASS_WARNING_MSG)] def testSuppressMethod(self): self._emit() testSuppressMethod.suppress = [util.suppress(message=METHOD_WARNING_MSG)] # type: ignore[attr-defined] def testSuppressClass(self): self._emit() def testOverrideSuppressClass(self): self._emit() testOverrideSuppressClass.suppress = [] # type: ignore[attr-defined] class SetUpSuppressionMixin: def setUp(self): self._emit() class TearDownSuppressionMixin: def tearDown(self): self._emit() class TestSuppression2Mixin(EmitMixin): def testSuppressModule(self): self._emit() suppress = [util.suppress(message=MODULE_WARNING_MSG)] class SynchronousTestSuppression(SuppressionMixin, unittest.SynchronousTestCase): pass class SynchronousTestSetUpSuppression( SetUpSuppressionMixin, SynchronousTestSuppression ): pass class SynchronousTestTearDownSuppression( TearDownSuppressionMixin, SynchronousTestSuppression ): pass class SynchronousTestSuppression2(TestSuppression2Mixin, unittest.SynchronousTestCase): pass class AsynchronousTestSuppression(SuppressionMixin, unittest.TestCase): pass class AsynchronousTestSetUpSuppression( SetUpSuppressionMixin, AsynchronousTestSuppression ): pass class AsynchronousTestTearDownSuppression( TearDownSuppressionMixin, AsynchronousTestSuppression ): pass class AsynchronousTestSuppression2(TestSuppression2Mixin, unittest.TestCase): pass PK Mb�Z�S��� �� trial/test/test_reporter.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # Maintainer: Jonathan Lange """ Tests for L{twisted.trial.reporter}. """ import errno import os import re import sys from inspect import getmro from io import BytesIO, StringIO from typing import Type from unittest import TestCase as StdlibTestCase, expectedFailure from twisted.python import log, reflect from twisted.python.failure import Failure from twisted.python.reflect import qual from twisted.trial import itrial, reporter, runner, unittest, util from twisted.trial.reporter import UncleanWarningsReporterWrapper, _ExitWrapper from twisted.trial.test import erroneous, sample from twisted.trial.unittest import SkipTest, Todo, makeTodo class BrokenStream: """ Stream-ish object that raises a signal interrupt error. We use this to make sure that Trial still manages to write what it needs to write. """ written = False flushed = False def __init__(self, fObj): self.fObj = fObj def write(self, s): if self.written: return self.fObj.write(s) self.written = True raise OSError(errno.EINTR, "Interrupted write") def flush(self): if self.flushed: return self.fObj.flush() self.flushed = True raise OSError(errno.EINTR, "Interrupted flush") class StringTest(unittest.SynchronousTestCase): def stringComparison(self, expect, output): output = list(filter(None, output)) self.assertTrue( len(expect) <= len(output), "Must have more observed than expected" "lines %d < %d" % (len(output), len(expect)), ) REGEX_PATTERN_TYPE = type(re.compile("")) for line_number, (exp, out) in enumerate(zip(expect, output)): if exp is None: continue elif isinstance(exp, str): self.assertSubstring( exp, out, "Line %d: %r not in %r" % (line_number, exp, out) ) elif isinstance(exp, REGEX_PATTERN_TYPE): self.assertTrue( exp.match(out), "Line %d: %r did not match string %r" % (line_number, exp.pattern, out), ) else: raise TypeError(f"don't know what to do with object {exp!r}") class TestResultTests(unittest.SynchronousTestCase): def setUp(self): self.result = reporter.TestResult() def test_pyunitAddError(self): # pyunit passes an exc_info tuple directly to addError try: raise RuntimeError("foo") except RuntimeError as e: excValue = e self.result.addError(self, sys.exc_info()) failure = self.result.errors[0][1] self.assertEqual(excValue, failure.value) self.assertEqual(RuntimeError, failure.type) def test_pyunitAddFailure(self): # pyunit passes an exc_info tuple directly to addFailure try: raise self.failureException("foo") except self.failureException as e: excValue = e self.result.addFailure(self, sys.exc_info()) failure = self.result.failures[0][1] self.assertEqual(excValue, failure.value) self.assertEqual(self.failureException, failure.type) class ReporterRealtimeTests(TestResultTests): def setUp(self): output = StringIO() self.result = reporter.Reporter(output, realtime=True) class ErrorReportingTests(StringTest): doubleSeparator = re.compile(r"^=+$") def setUp(self): self.loader = runner.TestLoader() self.output = StringIO() self.result = reporter.Reporter(self.output) def getOutput(self, suite): result = self.getResult(suite) result.done() return self.output.getvalue() def getResult(self, suite): suite.run(self.result) return self.result def test_formatErroredMethod(self): """ A test method which runs and has an error recorded against it is reported in the output stream with the I{ERROR} tag along with a summary of what error was reported and the ID of the test. """ cls = erroneous.SynchronousTestFailureInSetUp suite = self.loader.loadClass(cls) output = self.getOutput(suite).splitlines() match = [ self.doubleSeparator, "[ERROR]", "Traceback (most recent call last):", re.compile(r"^\s+File .*erroneous\.py., line \d+, in setUp$"), re.compile(r"^\s+raise FoolishError." r".I am a broken setUp method..$"), ( "twisted.trial.test.erroneous.FoolishError: " "I am a broken setUp method" ), f"{cls.__module__}.{cls.__name__}.test_noop", ] self.stringComparison(match, output) def test_formatFailedMethod(self): """ A test method which runs and has a failure recorded against it is reported in the output stream with the I{FAIL} tag along with a summary of what failure was reported and the ID of the test. """ suite = self.loader.loadByName( "twisted.trial.test.erroneous.TestRegularFail.test_fail" ) output = self.getOutput(suite).splitlines() match = [ self.doubleSeparator, "[FAIL]", "Traceback (most recent call last):", re.compile(r"^\s+File .*erroneous\.py., line \d+, in test_fail$"), re.compile(r'^\s+self\.fail\("I fail"\)$'), "twisted.trial.unittest.FailTest: I fail", "twisted.trial.test.erroneous.TestRegularFail.test_fail", ] self.stringComparison(match, output) def test_doctestError(self): """ A problem encountered while running a doctest is reported in the output stream with a I{FAIL} or I{ERROR} tag along with a summary of what problem was encountered and the ID of the test. """ from twisted.trial.test import erroneous suite = unittest.decorate(self.loader.loadDoctests(erroneous), itrial.ITestCase) output = self.getOutput(suite) path = "twisted.trial.test.erroneous.unexpectedException" for substring in ["1/0", "ZeroDivisionError", "Exception raised:", path]: self.assertSubstring(substring, output) self.assertTrue( re.search("Fail(ed|ure in) example:", output), "Couldn't match 'Failure in example: ' " "or 'Failed example: '", ) expect = [self.doubleSeparator, re.compile(r"\[(ERROR|FAIL)\]")] self.stringComparison(expect, output.splitlines()) def test_hiddenException(self): """ Check that errors in C{DelayedCall}s get reported, even if the test already has a failure. Only really necessary for testing the deprecated style of tests that use iterate() directly. See L{erroneous.DelayedCall.testHiddenException} for more details. """ from twisted.internet import reactor if reflect.qual(reactor).startswith("twisted.internet.asyncioreactor"): raise self.skipTest( "This test does not work on the asyncio reactor, as the " "traceback comes from inside asyncio, not Twisted." ) test = erroneous.DelayedCall("testHiddenException") output = self.getOutput(test).splitlines() errorQual = qual(RuntimeError) match = [ self.doubleSeparator, "[FAIL]", "Traceback (most recent call last):", re.compile( r"^\s+File .*erroneous\.py., line \d+, in " "testHiddenException$" ), re.compile( r'^\s+self\.fail\("Deliberate failure to mask the ' r'hidden exception"\)$' ), "twisted.trial.unittest.FailTest: " "Deliberate failure to mask the hidden exception", "twisted.trial.test.erroneous.DelayedCall.testHiddenException", self.doubleSeparator, "[ERROR]", "Traceback (most recent call last):", re.compile(r"^\s+File .* in runUntilCurrent"), re.compile(r"^\s+.*"), re.compile(r'^\s+File .*erroneous\.py", line \d+, in go'), re.compile(r"^\s+raise RuntimeError\(self.hiddenExceptionMsg\)"), errorQual + ": something blew up", "twisted.trial.test.erroneous.DelayedCall.testHiddenException", ] self.stringComparison(match, output) class UncleanWarningWrapperErrorReportingTests(ErrorReportingTests): """ Tests that the L{UncleanWarningsReporterWrapper} can sufficiently proxy IReporter failure and error reporting methods to a L{reporter.Reporter}. """ def setUp(self): self.loader = runner.TestLoader() self.output = StringIO() self.result = UncleanWarningsReporterWrapper(reporter.Reporter(self.output)) class TracebackHandlingTests(unittest.SynchronousTestCase): def getErrorFrames(self, test): """ Run the given C{test}, make sure it fails and return the trimmed frames. @param test: The test case to run. @return: The C{list} of frames trimmed. """ stream = StringIO() result = reporter.Reporter(stream) test.run(result) bads = result.failures + result.errors self.assertEqual(len(bads), 1) self.assertEqual(bads[0][0], test) return result._trimFrames(bads[0][1].frames) def checkFrames(self, observedFrames, expectedFrames): for observed, expected in zip(observedFrames, expectedFrames): self.assertEqual(observed[0], expected[0]) observedSegs = os.path.splitext(observed[1])[0].split(os.sep) expectedSegs = expected[1].split("/") self.assertEqual(observedSegs[-len(expectedSegs) :], expectedSegs) self.assertEqual(len(observedFrames), len(expectedFrames)) def test_basic(self): test = erroneous.TestRegularFail("test_fail") frames = self.getErrorFrames(test) self.checkFrames(frames, [("test_fail", "twisted/trial/test/erroneous")]) def test_subroutine(self): test = erroneous.TestRegularFail("test_subfail") frames = self.getErrorFrames(test) self.checkFrames( frames, [ ("test_subfail", "twisted/trial/test/erroneous"), ("subroutine", "twisted/trial/test/erroneous"), ], ) def test_deferred(self): """ C{_trimFrames} removes traces of C{_runCallbacks} when getting an error in a callback returned by a C{TestCase} based test. """ test = erroneous.TestAsynchronousFail("test_fail") frames = self.getErrorFrames(test) self.checkFrames(frames, [("_later", "twisted/trial/test/erroneous")]) def test_noFrames(self): result = reporter.Reporter(None) self.assertEqual([], result._trimFrames([])) def test_oneFrame(self): result = reporter.Reporter(None) self.assertEqual(["fake frame"], result._trimFrames(["fake frame"])) def test_exception(self): """ C{_trimFrames} removes traces of C{runWithWarningsSuppressed} from C{utils} when a synchronous exception happens in a C{TestCase} based test. """ test = erroneous.TestAsynchronousFail("test_exception") frames = self.getErrorFrames(test) self.checkFrames(frames, [("test_exception", "twisted/trial/test/erroneous")]) class FormatFailuresTests(StringTest): def setUp(self): try: raise RuntimeError("foo") except RuntimeError: self.f = Failure() self.f.frames = [ ["foo", "foo/bar.py", 5, [("x", 5)], [("y", "orange")]], ["qux", "foo/bar.py", 10, [("a", "two")], [("b", "MCMXCIX")]], ] self.stream = StringIO() self.result = reporter.Reporter(self.stream) def test_formatDefault(self): tb = self.result._formatFailureTraceback(self.f) self.stringComparison( [ "Traceback (most recent call last):", ' File "foo/bar.py", line 5, in foo', re.compile(r"^\s*$"), ' File "foo/bar.py", line 10, in qux', re.compile(r"^\s*$"), "RuntimeError: foo", ], tb.splitlines(), ) def test_formatString(self): tb = """ File "twisted/trial/unittest.py", line 256, in failUnlessSubstring return self.failUnlessIn(substring, astring, msg) exceptions.TypeError: iterable argument required """ expected = """ File "twisted/trial/unittest.py", line 256, in failUnlessSubstring return self.failUnlessIn(substring, astring, msg) exceptions.TypeError: iterable argument required """ formatted = self.result._formatFailureTraceback(tb) self.assertEqual(expected, formatted) def test_mutation(self): frames = self.f.frames[:] # The call shouldn't mutate the frames. self.result._formatFailureTraceback(self.f) self.assertEqual(self.f.frames, frames) class PyunitNamesTests(unittest.SynchronousTestCase): def setUp(self): self.stream = StringIO() self.test = sample.PyunitTest("test_foo") def test_verboseReporter(self): result = reporter.VerboseTextReporter(self.stream) result.startTest(self.test) output = self.stream.getvalue() self.assertEqual(output, "twisted.trial.test.sample.PyunitTest.test_foo ... ") def test_treeReporter(self): result = reporter.TreeReporter(self.stream) result.startTest(self.test) output = self.stream.getvalue() output = output.splitlines()[-1].strip() self.assertEqual(output, result.getDescription(self.test) + " ...") def test_getDescription(self): result = reporter.TreeReporter(self.stream) output = result.getDescription(self.test) self.assertEqual(output, "test_foo") def test_minimalReporter(self): """ The summary of L{reporter.MinimalReporter} is a simple list of numbers, indicating how many tests ran, how many failed etc. The numbers represents: * the run time of the tests * the number of tests run, printed 2 times for legacy reasons * the number of errors * the number of failures * the number of skips """ result = reporter.MinimalReporter(self.stream) self.test.run(result) result._printSummary() output = self.stream.getvalue().strip().split(" ") self.assertEqual(output[1:], ["1", "1", "0", "0", "0"]) def test_minimalReporterTime(self): """ L{reporter.MinimalReporter} reports the time to run the tests as first data in its output. """ times = [1.0, 1.2, 1.5, 1.9] result = reporter.MinimalReporter(self.stream) result._getTime = lambda: times.pop(0) self.test.run(result) result._printSummary() output = self.stream.getvalue().strip().split(" ") timer = output[0] self.assertEqual(timer, "0.7") def test_emptyMinimalReporter(self): """ The summary of L{reporter.MinimalReporter} is a list of zeroes when no test is actually run. """ result = reporter.MinimalReporter(self.stream) result._printSummary() output = self.stream.getvalue().strip().split(" ") self.assertEqual(output, ["0", "0", "0", "0", "0", "0"]) class DirtyReactorTests(unittest.SynchronousTestCase): """ The trial script has an option to treat L{DirtyReactorAggregateError}s as warnings, as a migration tool for test authors. It causes a wrapper to be placed around reporters that replaces L{DirtyReactorAggregatErrors} with warnings. """ def setUp(self): self.dirtyError = Failure(util.DirtyReactorAggregateError(["foo"], ["bar"])) self.output = StringIO() self.test = DirtyReactorTests("test_errorByDefault") def test_errorByDefault(self): """ L{DirtyReactorAggregateError}s are reported as errors with the default Reporter. """ result = reporter.Reporter(stream=self.output) result.addError(self.test, self.dirtyError) self.assertEqual(len(result.errors), 1) self.assertEqual(result.errors[0][1], self.dirtyError) def test_warningsEnabled(self): """ L{DirtyReactorAggregateError}s are reported as warnings when using the L{UncleanWarningsReporterWrapper}. """ result = UncleanWarningsReporterWrapper(reporter.Reporter(stream=self.output)) self.assertWarns( UserWarning, self.dirtyError.getErrorMessage(), reporter.__file__, result.addError, self.test, self.dirtyError, ) def test_warningsMaskErrors(self): """ L{DirtyReactorAggregateError}s are I{not} reported as errors if the L{UncleanWarningsReporterWrapper} is used. """ result = UncleanWarningsReporterWrapper(reporter.Reporter(stream=self.output)) self.assertWarns( UserWarning, self.dirtyError.getErrorMessage(), reporter.__file__, result.addError, self.test, self.dirtyError, ) self.assertEqual(result._originalReporter.errors, []) def test_dealsWithThreeTuples(self): """ Some annoying stuff can pass three-tuples to addError instead of Failures (like PyUnit). The wrapper, of course, handles this case, since it is a part of L{twisted.trial.itrial.IReporter}! But it does not convert L{DirtyReactorAggregateError} to warnings in this case, because nobody should be passing those in the form of three-tuples. """ result = UncleanWarningsReporterWrapper(reporter.Reporter(stream=self.output)) result.addError(self.test, (self.dirtyError.type, self.dirtyError.value, None)) self.assertEqual(len(result._originalReporter.errors), 1) self.assertEqual( result._originalReporter.errors[0][1].type, self.dirtyError.type ) self.assertEqual( result._originalReporter.errors[0][1].value, self.dirtyError.value ) class TrialNamesTests(unittest.SynchronousTestCase): def setUp(self): self.stream = StringIO() self.test = sample.FooTest("test_foo") def test_verboseReporter(self): result = reporter.VerboseTextReporter(self.stream) result.startTest(self.test) output = self.stream.getvalue() self.assertEqual(output, self.test.id() + " ... ") def test_treeReporter(self): result = reporter.TreeReporter(self.stream) result.startTest(self.test) output = self.stream.getvalue() output = output.splitlines()[-1].strip() self.assertEqual(output, result.getDescription(self.test) + " ...") def test_treeReporterWithDocstrings(self): """A docstring""" result = reporter.TreeReporter(self.stream) self.assertEqual(result.getDescription(self), "test_treeReporterWithDocstrings") def test_getDescription(self): result = reporter.TreeReporter(self.stream) output = result.getDescription(self.test) self.assertEqual(output, "test_foo") class SkipTests(unittest.SynchronousTestCase): """ Tests for L{reporter.Reporter}'s handling of skips. """ def setUp(self): self.stream = StringIO() self.result = reporter.Reporter(self.stream) self.test = sample.FooTest("test_foo") def _getSkips(self, result): """ Get the number of skips that happened to a reporter. """ return len(result.skips) def test_accumulation(self): self.result.addSkip(self.test, "some reason") self.assertEqual(self._getSkips(self.result), 1) def test_success(self): self.result.addSkip(self.test, "some reason") self.assertEqual(True, self.result.wasSuccessful()) def test_summary(self): """ The summary of a successful run with skips indicates that the test suite passed and includes the number of skips. """ self.result.addSkip(self.test, "some reason") self.result.done() output = self.stream.getvalue().splitlines()[-1] prefix = "PASSED " self.assertTrue(output.startswith(prefix)) self.assertEqual(output[len(prefix) :].strip(), "(skips=1)") def test_basicErrors(self): """ The output at the end of a test run with skips includes the reasons for skipping those tests. """ self.result.addSkip(self.test, "some reason") self.result.done() output = self.stream.getvalue().splitlines()[3] self.assertEqual(output.strip(), "some reason") def test_booleanSkip(self): """ Tests can be skipped without specifying a reason by setting the 'skip' attribute to True. When this happens, the test output includes 'True' as the reason. """ self.result.addSkip(self.test, True) self.result.done() output = self.stream.getvalue().splitlines()[3] self.assertEqual(output, "True") def test_exceptionSkip(self): """ Skips can be raised as errors. When this happens, the error is included in the summary at the end of the test suite. """ try: 1 / 0 except Exception as e: error = e self.result.addSkip(self.test, error) self.result.done() output = "\n".join(self.stream.getvalue().splitlines()[3:5]).strip() self.assertEqual(output, str(error)) class UncleanWarningSkipTests(SkipTests): """ Tests for skips on a L{reporter.Reporter} wrapped by an L{UncleanWarningsReporterWrapper}. """ def setUp(self): SkipTests.setUp(self) self.result = UncleanWarningsReporterWrapper(self.result) def _getSkips(self, result): """ Get the number of skips that happened to a reporter inside of an unclean warnings reporter wrapper. """ return len(result._originalReporter.skips) class TodoTests(unittest.SynchronousTestCase): """ Tests for L{reporter.Reporter}'s handling of todos. """ def setUp(self): self.stream = StringIO() self.result = reporter.Reporter(self.stream) self.test = sample.FooTest("test_foo") def _getTodos(self, result): """ Get the expected failures that happened to a reporter. """ return result.expectedFailures def _getUnexpectedSuccesses(self, result): """ Get the unexpected successes that happened to a reporter. """ return result.unexpectedSuccesses def test_accumulation(self): """ L{reporter.Reporter} accumulates the expected failures that it is notified of. """ self.result.addExpectedFailure( self.test, Failure(Exception()), makeTodo("todo!") ) self.assertEqual(len(self._getTodos(self.result)), 1) def test_noTodoProvided(self): """ If no C{Todo} is provided to C{addExpectedFailure}, then L{reporter.Reporter} makes up a sensible default. This allows standard Python unittests to use Twisted reporters. """ failure = Failure(Exception()) self.result.addExpectedFailure(self.test, failure) [(test, error, todo)] = self._getTodos(self.result) self.assertEqual(test, self.test) self.assertEqual(error, failure) self.assertEqual(repr(todo), repr(makeTodo("Test expected to fail"))) def test_success(self): """ A test run is still successful even if there are expected failures. """ self.result.addExpectedFailure( self.test, Failure(Exception()), makeTodo("todo!") ) self.assertEqual(True, self.result.wasSuccessful()) def test_unexpectedSuccess(self): """ A test which is marked as todo but succeeds will have an unexpected success reported to its result. A test run is still successful even when this happens. """ self.result.addUnexpectedSuccess(self.test, makeTodo("Heya!")) self.assertEqual(True, self.result.wasSuccessful()) self.assertEqual(len(self._getUnexpectedSuccesses(self.result)), 1) def test_unexpectedSuccessNoTodo(self): """ A test which is marked as todo but succeeds will have an unexpected success reported to its result. A test run is still successful even when this happens. If no C{Todo} is provided, then we make up a sensible default. This allows standard Python unittests to use Twisted reporters. """ self.result.addUnexpectedSuccess(self.test) [(test, todo)] = self._getUnexpectedSuccesses(self.result) self.assertEqual(test, self.test) self.assertEqual(repr(todo), repr(makeTodo("Test expected to fail"))) def test_summary(self): """ The reporter's C{printSummary} method should print the number of expected failures that occurred. """ self.result.addExpectedFailure( self.test, Failure(Exception()), makeTodo("some reason") ) self.result.done() output = self.stream.getvalue().splitlines()[-1] prefix = "PASSED " self.assertTrue(output.startswith(prefix)) self.assertEqual(output[len(prefix) :].strip(), "(expectedFailures=1)") def test_basicErrors(self): """ The reporter's L{printErrors} method should include the value of the Todo. """ self.result.addExpectedFailure( self.test, Failure(Exception()), makeTodo("some reason") ) self.result.done() output = self.stream.getvalue().splitlines()[3].strip() self.assertEqual(output, "Reason: 'some reason'") def test_booleanTodo(self): """ Booleans CAN'T be used as the value of a todo. Maybe this sucks. This is a test for current behavior, not a requirement. """ self.result.addExpectedFailure(self.test, Failure(Exception()), True) self.assertRaises(Exception, self.result.done) def test_exceptionTodo(self): """ The exception for expected failures should be shown in the C{printErrors} output. """ try: 1 / 0 except Exception as e: error = e self.result.addExpectedFailure(self.test, Failure(error), makeTodo("todo!")) self.result.done() output = "\n".join(self.stream.getvalue().splitlines()[3:]).strip() self.assertTrue(str(error) in output) def test_standardLibraryCompatibilityFailure(self): """ Tests that use the standard library C{expectedFailure} feature worth with Trial reporters. """ class Test(StdlibTestCase): @expectedFailure def test_fail(self): self.fail("failure") test = Test("test_fail") test.run(self.result) self.assertEqual(len(self._getTodos(self.result)), 1) def test_standardLibraryCompatibilitySuccess(self): """ Tests that use the standard library C{expectedFailure} feature worth with Trial reporters. """ class Test(StdlibTestCase): @expectedFailure def test_success(self): pass test = Test("test_success") test.run(self.result) self.assertEqual(len(self._getUnexpectedSuccesses(self.result)), 1) class UncleanWarningTodoTests(TodoTests): """ Tests for L{UncleanWarningsReporterWrapper}'s handling of todos. """ def setUp(self): TodoTests.setUp(self) self.result = UncleanWarningsReporterWrapper(self.result) def _getTodos(self, result): """ Get the todos that happened to a reporter inside of an unclean warnings reporter wrapper. """ return result._originalReporter.expectedFailures def _getUnexpectedSuccesses(self, result): """ Get the number of unexpected successes that happened to a reporter inside of an unclean warnings reporter wrapper. """ return result._originalReporter.unexpectedSuccesses class MockColorizer: """ Used by TreeReporterTests to make sure that output is colored correctly. """ def __init__(self, stream): self.log = [] def write(self, text, color): self.log.append((color, text)) class TreeReporterTests(unittest.SynchronousTestCase): def setUp(self): self.test = sample.FooTest("test_foo") self.stream = StringIO() self.result = reporter.TreeReporter(self.stream) self.result._colorizer = MockColorizer(self.stream) self.log = self.result._colorizer.log def makeError(self): try: 1 / 0 except ZeroDivisionError: f = Failure() return f def test_summaryColoredSuccess(self): """ The summary in case of success should have a good count of successes and be colored properly. """ self.result.addSuccess(self.test) self.result.done() self.assertEqual(self.log[1], (self.result.SUCCESS, "PASSED")) self.assertEqual( self.stream.getvalue().splitlines()[-1].strip(), "(successes=1)" ) def test_summaryColoredFailure(self): """ The summary in case of failure should have a good count of errors and be colored properly. """ try: raise RuntimeError("foo") except RuntimeError: self.result.addError(self, sys.exc_info()) self.result.done() self.assertEqual(self.log[1], (self.result.FAILURE, "FAILED")) self.assertEqual(self.stream.getvalue().splitlines()[-1].strip(), "(errors=1)") def test_getPrelude(self): """ The tree needs to get the segments of the test ID that correspond to the module and class that it belongs to. """ self.assertEqual( ["foo.bar", "baz"], self.result._getPreludeSegments("foo.bar.baz.qux") ) self.assertEqual(["foo", "bar"], self.result._getPreludeSegments("foo.bar.baz")) self.assertEqual(["foo"], self.result._getPreludeSegments("foo.bar")) self.assertEqual([], self.result._getPreludeSegments("foo")) def test_groupResults(self): """ If two different tests have the same error, L{Reporter._groupResults} includes them together in one of the tuples in the list it returns. """ try: raise RuntimeError("foo") except RuntimeError: self.result.addError(self, sys.exc_info()) self.result.addError(self.test, sys.exc_info()) try: raise RuntimeError("bar") except RuntimeError: extra = sample.FooTest("test_bar") self.result.addError(extra, sys.exc_info()) self.result.done() grouped = self.result._groupResults( self.result.errors, self.result._formatFailureTraceback ) self.assertEqual(grouped[0][1], [self, self.test]) self.assertEqual(grouped[1][1], [extra]) def test_printResults(self): """ L{Reporter._printResults} uses the results list and formatter callable passed to it to produce groups of results to write to its output stream. """ def formatter(n): return str(n) + "\n" first = sample.FooTest("test_foo") second = sample.FooTest("test_bar") third = sample.PyunitTest("test_foo") self.result._printResults( "FOO", [(first, 1), (second, 1), (third, 2)], formatter ) self.assertEqual( self.stream.getvalue(), "%(double separator)s\n" "FOO\n" "1\n" "\n" "%(first)s\n" "%(second)s\n" "%(double separator)s\n" "FOO\n" "2\n" "\n" "%(third)s\n" % { "double separator": self.result._doubleSeparator, "first": first.id(), "second": second.id(), "third": third.id(), }, ) class ReporterInterfaceTests(unittest.SynchronousTestCase): """ Tests for the bare interface of a trial reporter. Subclass this test case and provide a different 'resultFactory' to test that a particular reporter implementation will work with the rest of Trial. @cvar resultFactory: A callable that returns a reporter to be tested. The callable must take the same parameters as L{reporter.Reporter}. """ resultFactory: Type[itrial.IReporter] = reporter.Reporter def setUp(self): self.test = sample.FooTest("test_foo") self.stream = StringIO() self.publisher = log.LogPublisher() self.result = self.resultFactory(self.stream, publisher=self.publisher) def test_shouldStopInitiallyFalse(self): """ shouldStop is False to begin with. """ self.assertEqual(False, self.result.shouldStop) def test_shouldStopTrueAfterStop(self): """ shouldStop becomes True soon as someone calls stop(). """ self.result.stop() self.assertEqual(True, self.result.shouldStop) def test_wasSuccessfulInitiallyTrue(self): """ wasSuccessful() is True when there have been no results reported. """ self.assertEqual(True, self.result.wasSuccessful()) def test_wasSuccessfulTrueAfterSuccesses(self): """ wasSuccessful() is True when there have been only successes, False otherwise. """ self.result.addSuccess(self.test) self.assertEqual(True, self.result.wasSuccessful()) def test_wasSuccessfulFalseAfterErrors(self): """ wasSuccessful() becomes False after errors have been reported. """ try: 1 / 0 except ZeroDivisionError: self.result.addError(self.test, sys.exc_info()) self.assertEqual(False, self.result.wasSuccessful()) def test_wasSuccessfulFalseAfterFailures(self): """ wasSuccessful() becomes False after failures have been reported. """ try: self.fail("foo") except self.failureException: self.result.addFailure(self.test, sys.exc_info()) self.assertEqual(False, self.result.wasSuccessful()) class ReporterTests(ReporterInterfaceTests): """ Tests for the base L{reporter.Reporter} class. """ def setUp(self): ReporterInterfaceTests.setUp(self) self._timer = 0 self.result._getTime = self._getTime def _getTime(self): self._timer += 1 return self._timer def test_startStop(self): self.result.startTest(self.test) self.result.stopTest(self.test) self.assertTrue(self.result._lastTime > 0) self.assertEqual(self.result.testsRun, 1) self.assertEqual(self.result.wasSuccessful(), True) def test_brokenStream(self): """ Test that the reporter safely writes to its stream. """ result = self.resultFactory(stream=BrokenStream(self.stream)) result._writeln("Hello") self.assertEqual(self.stream.getvalue(), "Hello\n") self.stream.truncate(0) self.stream.seek(0) result._writeln("Hello %s!", "World") self.assertEqual(self.stream.getvalue(), "Hello World!\n") def test_warning(self): """ L{reporter.Reporter} observes warnings emitted by the Twisted log system and writes them to its output stream. """ message = RuntimeWarning("some warning text") category = "exceptions.RuntimeWarning" filename = "path/to/some/file.py" lineno = 71 self.publisher.msg( warning=message, category=category, filename=filename, lineno=lineno ) self.assertEqual( self.stream.getvalue(), "%s:%d: %s: %s\n" % (filename, lineno, category.split(".")[-1], message), ) def test_duplicateWarningSuppressed(self): """ A warning emitted twice within a single test is only written to the stream once. """ # Emit the warning and assert that it shows up self.test_warning() # Emit the warning again and assert that the stream still only has one # warning on it. self.test_warning() def test_warningEmittedForNewTest(self): """ A warning emitted again after a new test has started is written to the stream again. """ test = self.__class__("test_warningEmittedForNewTest") self.result.startTest(test) # Clear whatever startTest wrote to the stream self.stream.seek(0) self.stream.truncate() # Emit a warning (and incidentally, assert that it was emitted) self.test_warning() # Clean up from the first warning to simplify the rest of the # assertions. self.stream.seek(0) self.stream.truncate() # Stop the first test and start another one (it just happens to be the # same one, but that doesn't matter) self.result.stopTest(test) self.result.startTest(test) # Clean up the stopTest/startTest output self.stream.seek(0) self.stream.truncate() # Emit the warning again and make sure it shows up self.test_warning() def test_stopObserving(self): """ L{reporter.Reporter} stops observing log events when its C{done} method is called. """ self.result.done() self.stream.seek(0) self.stream.truncate() self.publisher.msg( warning=RuntimeWarning("some message"), category="exceptions.RuntimeWarning", filename="file/name.py", lineno=17, ) self.assertEqual(self.stream.getvalue(), "") class SafeStreamTests(unittest.SynchronousTestCase): def test_safe(self): """ Test that L{reporter.SafeStream} successfully write to its original stream even if an interrupt happens during the write. """ stream = StringIO() broken = BrokenStream(stream) safe = reporter.SafeStream(broken) safe.write("Hello") self.assertEqual(stream.getvalue(), "Hello") class SubunitReporterTests(ReporterInterfaceTests): """ Tests for the subunit reporter. This just tests that the subunit reporter implements the basic interface. """ resultFactory: Type[itrial.IReporter] = reporter.SubunitReporter def setUp(self): if reporter.TestProtocolClient is None: raise SkipTest("Subunit not installed, cannot test SubunitReporter") self.test = sample.FooTest("test_foo") self.stream = BytesIO() self.publisher = log.LogPublisher() self.result = self.resultFactory(self.stream, publisher=self.publisher) def assertForwardsToSubunit(self, methodName, *args, **kwargs): """ Assert that 'methodName' on L{SubunitReporter} forwards to the equivalent method on subunit. Checks that the return value from subunit is returned from the L{SubunitReporter} and that the reporter writes the same data to its stream as subunit does to its own. Assumes that the method on subunit has the same name as the method on L{SubunitReporter}. """ stream = BytesIO() subunitClient = reporter.TestProtocolClient(stream) subunitReturn = getattr(subunitClient, methodName)(*args, **kwargs) subunitOutput = stream.getvalue() reporterReturn = getattr(self.result, methodName)(*args, **kwargs) self.assertEqual(subunitReturn, reporterReturn) self.assertEqual(subunitOutput, self.stream.getvalue()) def removeMethod(self, klass, methodName): """ Remove 'methodName' from 'klass'. If 'klass' does not have a method named 'methodName', then 'removeMethod' succeeds silently. If 'klass' does have a method named 'methodName', then it is removed using delattr. Also, methods of the same name are removed from all base classes of 'klass', thus removing the method entirely. @param klass: The class to remove the method from. @param methodName: The name of the method to remove. """ method = getattr(klass, methodName, None) if method is None: return for base in getmro(klass): try: delattr(base, methodName) except (AttributeError, TypeError): break else: self.addCleanup(setattr, base, methodName, method) def test_subunitWithoutAddExpectedFailureInstalled(self): """ Some versions of subunit don't have "addExpectedFailure". For these versions, we report expected failures as successes. """ self.removeMethod(reporter.TestProtocolClient, "addExpectedFailure") try: 1 / 0 except ZeroDivisionError: self.result.addExpectedFailure(self.test, sys.exc_info(), "todo") expectedFailureOutput = self.stream.getvalue() self.stream.truncate(0) self.stream.seek(0) self.result.addSuccess(self.test) successOutput = self.stream.getvalue() self.assertEqual(successOutput, expectedFailureOutput) def test_subunitWithoutAddSkipInstalled(self): """ Some versions of subunit don't have "addSkip". For these versions, we report skips as successes. """ self.removeMethod(reporter.TestProtocolClient, "addSkip") self.result.addSkip(self.test, "reason") skipOutput = self.stream.getvalue() self.stream.truncate(0) self.stream.seek(0) self.result.addSuccess(self.test) successOutput = self.stream.getvalue() self.assertEqual(successOutput, skipOutput) def test_addExpectedFailurePassedThrough(self): """ Some versions of subunit have "addExpectedFailure". For these versions, when we call 'addExpectedFailure' on the test result, we pass the error and test through to the subunit client. """ addExpectedFailureCalls = [] def addExpectedFailure(test, error): addExpectedFailureCalls.append((test, error)) # Provide our own addExpectedFailure, whether or not the locally # installed subunit has addExpectedFailure. self.result._subunit.addExpectedFailure = addExpectedFailure try: 1 / 0 except ZeroDivisionError: exc_info = sys.exc_info() self.result.addExpectedFailure(self.test, exc_info, "todo") self.assertEqual(addExpectedFailureCalls, [(self.test, exc_info)]) def test_addSkipSendsSubunitAddSkip(self): """ Some versions of subunit have "addSkip". For these versions, when we call 'addSkip' on the test result, we pass the test and reason through to the subunit client. """ addSkipCalls = [] def addSkip(test, reason): addSkipCalls.append((test, reason)) # Provide our own addSkip, whether or not the locally-installed # subunit has addSkip. self.result._subunit.addSkip = addSkip self.result.addSkip(self.test, "reason") self.assertEqual(addSkipCalls, [(self.test, "reason")]) def test_doneDoesNothing(self): """ The subunit reporter doesn't need to print out a summary -- the stream of results is everything. Thus, done() does nothing. """ self.result.done() self.assertEqual(b"", self.stream.getvalue()) def test_startTestSendsSubunitStartTest(self): """ SubunitReporter.startTest() sends the subunit 'startTest' message. """ self.assertForwardsToSubunit("startTest", self.test) def test_stopTestSendsSubunitStopTest(self): """ SubunitReporter.stopTest() sends the subunit 'stopTest' message. """ self.assertForwardsToSubunit("stopTest", self.test) def test_addSuccessSendsSubunitAddSuccess(self): """ SubunitReporter.addSuccess() sends the subunit 'addSuccess' message. """ self.assertForwardsToSubunit("addSuccess", self.test) def test_addErrorSendsSubunitAddError(self): """ SubunitReporter.addError() sends the subunit 'addError' message. """ try: 1 / 0 except ZeroDivisionError: error = sys.exc_info() self.assertForwardsToSubunit("addError", self.test, error) def test_addFailureSendsSubunitAddFailure(self): """ SubunitReporter.addFailure() sends the subunit 'addFailure' message. """ try: self.fail("hello") except self.failureException: failure = sys.exc_info() self.assertForwardsToSubunit("addFailure", self.test, failure) def test_addUnexpectedSuccessSendsSubunitAddSuccess(self): """ SubunitReporter.addFailure() sends the subunit 'addSuccess' message, since subunit doesn't model unexpected success. """ stream = BytesIO() subunitClient = reporter.TestProtocolClient(stream) subunitClient.addSuccess(self.test) subunitOutput = stream.getvalue() self.result.addUnexpectedSuccess(self.test) self.assertEqual(subunitOutput, self.stream.getvalue()) def test_loadTimeErrors(self): """ Load-time errors are reported like normal errors. """ test = runner.TestLoader().loadByName("doesntexist") test.run(self.result) output = self.stream.getvalue() # Just check that 'doesntexist' is in the output, rather than # assembling the expected stack trace. self.assertIn(b"doesntexist", output) class SubunitReporterNotInstalledTests(unittest.SynchronousTestCase): """ Test behaviour when the subunit reporter is not installed. """ def test_subunitNotInstalled(self): """ If subunit is not installed, TestProtocolClient will be None, and SubunitReporter will raise an error when you try to construct it. """ stream = StringIO() self.patch(reporter, "TestProtocolClient", None) e = self.assertRaises(Exception, reporter.SubunitReporter, stream) self.assertEqual("Subunit not available", str(e)) class TimingReporterTests(ReporterTests): resultFactory: Type[itrial.IReporter] = reporter.TimingTextReporter class LoggingReporter(reporter.Reporter): """ Simple reporter that stores the last test that was passed to it. """ def __init__(self, *args, **kwargs): reporter.Reporter.__init__(self, *args, **kwargs) self.test = None def addError(self, test, error): self.test = test def addExpectedFailure(self, test, failure, todo=None): self.test = test def addFailure(self, test, failure): self.test = test def addSkip(self, test, skip): self.test = test def addUnexpectedSuccess(self, test, todo=None): self.test = test def startTest(self, test): self.test = test def stopTest(self, test): self.test = test class AdaptedReporterTests(unittest.SynchronousTestCase): """ L{reporter._AdaptedReporter} is a reporter wrapper that wraps all of the tests it receives before passing them on to the original reporter. """ def setUp(self): self.wrappedResult = self.getWrappedResult() def _testAdapter(self, test): return test.id() def assertWrapped(self, wrappedResult, test): self.assertEqual(wrappedResult._originalReporter.test, self._testAdapter(test)) def getFailure(self, exceptionInstance): """ Return a L{Failure} from raising the given exception. @param exceptionInstance: The exception to raise. @return: L{Failure} """ try: raise exceptionInstance except BaseException: return Failure() def getWrappedResult(self): result = LoggingReporter() return reporter._AdaptedReporter(result, self._testAdapter) def test_addError(self): """ C{addError} wraps its test with the provided adapter. """ self.wrappedResult.addError(self, self.getFailure(RuntimeError())) self.assertWrapped(self.wrappedResult, self) def test_addFailure(self): """ C{addFailure} wraps its test with the provided adapter. """ self.wrappedResult.addFailure(self, self.getFailure(AssertionError())) self.assertWrapped(self.wrappedResult, self) def test_addSkip(self): """ C{addSkip} wraps its test with the provided adapter. """ self.wrappedResult.addSkip(self, self.getFailure(SkipTest("no reason"))) self.assertWrapped(self.wrappedResult, self) def test_startTest(self): """ C{startTest} wraps its test with the provided adapter. """ self.wrappedResult.startTest(self) self.assertWrapped(self.wrappedResult, self) def test_stopTest(self): """ C{stopTest} wraps its test with the provided adapter. """ self.wrappedResult.stopTest(self) self.assertWrapped(self.wrappedResult, self) def test_addExpectedFailure(self): """ C{addExpectedFailure} wraps its test with the provided adapter. """ self.wrappedResult.addExpectedFailure( self, self.getFailure(RuntimeError()), Todo("no reason") ) self.assertWrapped(self.wrappedResult, self) def test_expectedFailureWithoutTodo(self): """ C{addExpectedFailure} works without a C{Todo}. """ self.wrappedResult.addExpectedFailure(self, self.getFailure(RuntimeError())) self.assertWrapped(self.wrappedResult, self) def test_addUnexpectedSuccess(self): """ C{addUnexpectedSuccess} wraps its test with the provided adapter. """ self.wrappedResult.addUnexpectedSuccess(self, Todo("no reason")) self.assertWrapped(self.wrappedResult, self) def test_unexpectedSuccessWithoutTodo(self): """ C{addUnexpectedSuccess} works without a C{Todo}. """ self.wrappedResult.addUnexpectedSuccess(self) self.assertWrapped(self.wrappedResult, self) class FakeStream: """ A fake stream which C{isatty} method returns some predictable. @ivar tty: returned value of C{isatty}. @type tty: C{bool} """ def __init__(self, tty=True): self.tty = tty def isatty(self): return self.tty class AnsiColorizerTests(unittest.SynchronousTestCase): """ Tests for L{reporter._AnsiColorizer}. """ def setUp(self): self.savedModules = sys.modules.copy() def tearDown(self): sys.modules.clear() sys.modules.update(self.savedModules) def test_supportedStdOutTTY(self): """ L{reporter._AnsiColorizer.supported} returns C{False} if the given stream is not a TTY. """ self.assertFalse(reporter._AnsiColorizer.supported(FakeStream(False))) def test_supportedNoCurses(self): """ L{reporter._AnsiColorizer.supported} returns C{False} if the curses module can't be imported. """ sys.modules["curses"] = None self.assertFalse(reporter._AnsiColorizer.supported(FakeStream())) def test_supportedSetupTerm(self): """ L{reporter._AnsiColorizer.supported} returns C{True} if C{curses.tigetnum} returns more than 2 supported colors. It only tries to call C{curses.setupterm} if C{curses.tigetnum} previously failed with a C{curses.error}. """ class fakecurses: error = RuntimeError setUp = 0 def setupterm(self): self.setUp += 1 def tigetnum(self, value): if self.setUp: return 3 else: raise self.error() sys.modules["curses"] = fakecurses() self.assertTrue(reporter._AnsiColorizer.supported(FakeStream())) self.assertTrue(reporter._AnsiColorizer.supported(FakeStream())) self.assertEqual(sys.modules["curses"].setUp, 1) def test_supportedTigetNumWrongError(self): """ L{reporter._AnsiColorizer.supported} returns C{False} and doesn't try to call C{curses.setupterm} if C{curses.tigetnum} returns something different than C{curses.error}. """ class fakecurses: error = RuntimeError def tigetnum(self, value): raise ValueError() sys.modules["curses"] = fakecurses() self.assertFalse(reporter._AnsiColorizer.supported(FakeStream())) def test_supportedTigetNumNotEnoughColor(self): """ L{reporter._AnsiColorizer.supported} returns C{False} if C{curses.tigetnum} returns less than 2 supported colors. """ class fakecurses: error = RuntimeError def tigetnum(self, value): return 1 sys.modules["curses"] = fakecurses() self.assertFalse(reporter._AnsiColorizer.supported(FakeStream())) def test_supportedTigetNumErrors(self): """ L{reporter._AnsiColorizer.supported} returns C{False} if C{curses.tigetnum} raises an error, and calls C{curses.setupterm} once. """ class fakecurses: error = RuntimeError setUp = 0 def setupterm(self): self.setUp += 1 def tigetnum(self, value): raise self.error() sys.modules["curses"] = fakecurses() self.assertFalse(reporter._AnsiColorizer.supported(FakeStream())) self.assertEqual(sys.modules["curses"].setUp, 1) class ExitWrapperTests(unittest.SynchronousTestCase): """ Tests for L{reporter._ExitWrapper}. """ def setUp(self): self.failure = Failure(Exception("I am a Failure")) self.test = sample.FooTest("test_foo") self.result = reporter.TestResult() self.wrapped = _ExitWrapper(self.result) self.assertFalse(self.wrapped.shouldStop) def test_stopOnFailure(self): """ L{reporter._ExitWrapper} causes a wrapped reporter to stop after its first failure. """ self.wrapped.addFailure(self.test, self.failure) self.assertTrue(self.wrapped.shouldStop) self.assertEqual(self.result.failures, [(self.test, self.failure)]) def test_stopOnError(self): """ L{reporter._ExitWrapper} causes a wrapped reporter to stop after its first error. """ self.wrapped.addError(self.test, self.failure) self.assertTrue(self.wrapped.shouldStop) self.assertEqual(self.result.errors, [(self.test, self.failure)]) def test_doesNotStopOnUnexpectedSuccess(self): """ L{reporter._ExitWrapper} does not cause a wrapped reporter to stop after an unexpected success. """ self.wrapped.addUnexpectedSuccess(self.test, self.failure) self.assertFalse(self.wrapped.shouldStop) self.assertEqual(self.result.unexpectedSuccesses, [(self.test, self.failure)]) PK Mb�Z�� �. . trial/test/moduletest.pynu �[��� # -*- test-case-name: twisted.trial.test.test_log -*- # fodder for test_script, which parses files for emacs local variable # declarations. This one is supposed to have: # test-case-name: twisted.trial.test.test_log. # in the first line # The class declaration is irrelevant class Foo: pass PK Mb�Z�?\$ $ trial/test/sample.pynu �[��� """This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. """ import unittest as pyunit from twisted.python.util import mergeFunctionMetadata from twisted.trial import unittest class FooTest(unittest.SynchronousTestCase): def test_foo(self): pass def test_bar(self): pass def badDecorator(fn): """ Decorate a function without preserving the name of the original function. Always return a function with the same name. """ def nameCollision(*args, **kwargs): return fn(*args, **kwargs) return nameCollision def goodDecorator(fn): """ Decorate a function and preserve the original name. """ def nameCollision(*args, **kwargs): return fn(*args, **kwargs) return mergeFunctionMetadata(fn, nameCollision) class DecorationTest(unittest.SynchronousTestCase): def test_badDecorator(self): """ This test method is decorated in a way that gives it a confusing name that collides with another method. """ test_badDecorator = badDecorator(test_badDecorator) def test_goodDecorator(self): """ This test method is decorated in a way that preserves its name. """ test_goodDecorator = goodDecorator(test_goodDecorator) def renamedDecorator(self): """ This is secretly a test method and will be decorated and then renamed so test discovery can find it. """ test_renamedDecorator = goodDecorator(renamedDecorator) def nameCollision(self): """ This isn't a test, it's just here to collide with tests. """ class PyunitTest(pyunit.TestCase): def test_foo(self): pass def test_bar(self): pass class NotATest: def test_foo(self): pass class AlphabetTest(unittest.SynchronousTestCase): def test_a(self): pass def test_b(self): pass def test_c(self): pass PK Mb�Z�vOv" v" trial/test/test_deferred.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for returning Deferreds from a TestCase. """ import unittest as pyunit from twisted.internet import defer from twisted.trial import reporter, unittest, util from twisted.trial.test import detests class SetUpTests(unittest.TestCase): def _loadSuite(self, klass): loader = pyunit.TestLoader() r = reporter.TestResult() s = loader.loadTestsFromTestCase(klass) return r, s def test_success(self): result, suite = self._loadSuite(detests.DeferredSetUpOK) suite(result) self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) def test_fail(self): self.assertFalse(detests.DeferredSetUpFail.testCalled) result, suite = self._loadSuite(detests.DeferredSetUpFail) suite(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertFalse(detests.DeferredSetUpFail.testCalled) def test_callbackFail(self): self.assertFalse(detests.DeferredSetUpCallbackFail.testCalled) result, suite = self._loadSuite(detests.DeferredSetUpCallbackFail) suite(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertFalse(detests.DeferredSetUpCallbackFail.testCalled) def test_error(self): self.assertFalse(detests.DeferredSetUpError.testCalled) result, suite = self._loadSuite(detests.DeferredSetUpError) suite(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertFalse(detests.DeferredSetUpError.testCalled) def test_skip(self): self.assertFalse(detests.DeferredSetUpSkip.testCalled) result, suite = self._loadSuite(detests.DeferredSetUpSkip) suite(result) self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 0) self.assertEqual(len(result.skips), 1) self.assertFalse(detests.DeferredSetUpSkip.testCalled) class NeverFireTests(unittest.TestCase): def setUp(self): self._oldTimeout = util.DEFAULT_TIMEOUT_DURATION util.DEFAULT_TIMEOUT_DURATION = 0.1 def tearDown(self): util.DEFAULT_TIMEOUT_DURATION = self._oldTimeout def _loadSuite(self, klass): loader = pyunit.TestLoader() r = reporter.TestResult() s = loader.loadTestsFromTestCase(klass) return r, s def test_setUp(self): self.assertFalse(detests.DeferredSetUpNeverFire.testCalled) result, suite = self._loadSuite(detests.DeferredSetUpNeverFire) suite(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertFalse(detests.DeferredSetUpNeverFire.testCalled) self.assertTrue(result.errors[0][1].check(defer.TimeoutError)) class TestTester(unittest.TestCase): def getTest(self, name): raise NotImplementedError("must override me") def runTest(self, name): result = reporter.TestResult() self.getTest(name).run(result) return result class DeferredTests(TestTester): def getTest(self, name): return detests.DeferredTests(name) def test_pass(self): result = self.runTest("test_pass") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) def test_passGenerated(self): result = self.runTest("test_passGenerated") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertTrue(detests.DeferredTests.touched) test_passGenerated.supress = [ # type: ignore[attr-defined] util.suppress(message="twisted.internet.defer.deferredGenerator is deprecated") ] def test_passInlineCallbacks(self): """ The body of a L{defer.inlineCallbacks} decorated test gets run. """ result = self.runTest("test_passInlineCallbacks") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertTrue(detests.DeferredTests.touched) def test_fail(self): result = self.runTest("test_fail") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 1) def test_failureInCallback(self): result = self.runTest("test_failureInCallback") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 1) def test_errorInCallback(self): result = self.runTest("test_errorInCallback") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 1) def test_skip(self): result = self.runTest("test_skip") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.skips), 1) self.assertFalse(detests.DeferredTests.touched) def test_todo(self): result = self.runTest("test_expectedFailure") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 0) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.expectedFailures), 1) def test_thread(self): result = self.runTest("test_thread") self.assertEqual(result.testsRun, 1) self.assertTrue(result.wasSuccessful(), result.errors) class TimeoutTests(TestTester): def getTest(self, name): return detests.TimeoutTests(name) def _wasTimeout(self, error): self.assertEqual(error.check(defer.TimeoutError), defer.TimeoutError) def test_pass(self): result = self.runTest("test_pass") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) def test_passDefault(self): result = self.runTest("test_passDefault") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) def test_timeout(self): result = self.runTest("test_timeout") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 1) self._wasTimeout(result.errors[0][1]) def test_timeoutZero(self): result = self.runTest("test_timeoutZero") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 1) self._wasTimeout(result.errors[0][1]) def test_skip(self): result = self.runTest("test_skip") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.skips), 1) def test_todo(self): result = self.runTest("test_expectedFailure") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.expectedFailures), 1) self._wasTimeout(result.expectedFailures[0][1]) def test_errorPropagation(self): result = self.runTest("test_errorPropagation") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self._wasTimeout(detests.TimeoutTests.timedOut) def test_classTimeout(self): loader = pyunit.TestLoader() suite = loader.loadTestsFromTestCase(detests.TestClassTimeoutAttribute) result = reporter.TestResult() suite.run(result) self.assertEqual(len(result.errors), 1) self._wasTimeout(result.errors[0][1]) def test_callbackReturnsNonCallingDeferred(self): # hacky timeout # raises KeyboardInterrupt because Trial sucks from twisted.internet import reactor call = reactor.callLater(2, reactor.crash) result = self.runTest("test_calledButNeverCallback") if call.active(): call.cancel() self.assertFalse(result.wasSuccessful()) self._wasTimeout(result.errors[0][1]) # The test loader erroneously attempts to run this: del TestTester PK Mb�Z�=`\�D �D trial/test/test_warning.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for Trial's interaction with the Python warning system. """ import sys import warnings from io import StringIO from unittest import TestResult from twisted.python.filepath import FilePath from twisted.trial._synctest import _collectWarnings, _setWarningRegistryToNone from twisted.trial.unittest import SynchronousTestCase class Mask: """ Hide a test case definition from trial's automatic discovery mechanism. """ class MockTests(SynchronousTestCase): """ A test case which is used by L{FlushWarningsTests} to verify behavior which cannot be verified by code inside a single test method. """ message = "some warning text" category = UserWarning def test_unflushed(self): """ Generate a warning and don't flush it. """ warnings.warn(self.message, self.category) def test_flushed(self): """ Generate a warning and flush it. """ warnings.warn(self.message, self.category) self.assertEqual(len(self.flushWarnings()), 1) class FlushWarningsTests(SynchronousTestCase): """ Tests for C{flushWarnings}, an API for examining the warnings emitted so far in a test. """ def assertDictSubset(self, set, subset): """ Assert that all the keys present in C{subset} are also present in C{set} and that the corresponding values are equal. """ for k, v in subset.items(): self.assertEqual(set[k], v) def assertDictSubsets(self, sets, subsets): """ For each pair of corresponding elements in C{sets} and C{subsets}, assert that the element from C{subsets} is a subset of the element from C{sets}. """ self.assertEqual(len(sets), len(subsets)) for a, b in zip(sets, subsets): self.assertDictSubset(a, b) def test_none(self): """ If no warnings are emitted by a test, C{flushWarnings} returns an empty list. """ self.assertEqual(self.flushWarnings(), []) def test_several(self): """ If several warnings are emitted by a test, C{flushWarnings} returns a list containing all of them. """ firstMessage = "first warning message" firstCategory = UserWarning warnings.warn(message=firstMessage, category=firstCategory) secondMessage = "second warning message" secondCategory = RuntimeWarning warnings.warn(message=secondMessage, category=secondCategory) self.assertDictSubsets( self.flushWarnings(), [ {"category": firstCategory, "message": firstMessage}, {"category": secondCategory, "message": secondMessage}, ], ) def test_repeated(self): """ The same warning triggered twice from the same place is included twice in the list returned by C{flushWarnings}. """ message = "the message" category = RuntimeWarning for i in range(2): warnings.warn(message=message, category=category) self.assertDictSubsets( self.flushWarnings(), [{"category": category, "message": message}] * 2 ) def test_cleared(self): """ After a particular warning event has been returned by C{flushWarnings}, it is not returned by subsequent calls. """ message = "the message" category = RuntimeWarning warnings.warn(message=message, category=category) self.assertDictSubsets( self.flushWarnings(), [{"category": category, "message": message}] ) self.assertEqual(self.flushWarnings(), []) def test_unflushed(self): """ Any warnings emitted by a test which are not flushed are emitted to the Python warning system. """ result = TestResult() case = Mask.MockTests("test_unflushed") case.run(result) warningsShown = self.flushWarnings([Mask.MockTests.test_unflushed]) self.assertEqual(warningsShown[0]["message"], "some warning text") self.assertIdentical(warningsShown[0]["category"], UserWarning) where = type(case).test_unflushed.__code__ filename = where.co_filename # If someone edits MockTests.test_unflushed, the value added to # firstlineno might need to change. lineno = where.co_firstlineno + 4 self.assertEqual(warningsShown[0]["filename"], filename) self.assertEqual(warningsShown[0]["lineno"], lineno) self.assertEqual(len(warningsShown), 1) def test_flushed(self): """ Any warnings emitted by a test which are flushed are not emitted to the Python warning system. """ result = TestResult() case = Mask.MockTests("test_flushed") output = StringIO() monkey = self.patch(sys, "stdout", output) case.run(result) monkey.restore() self.assertEqual(output.getvalue(), "") def test_warningsConfiguredAsErrors(self): """ If a warnings filter has been installed which turns warnings into exceptions, tests have an error added to the reporter for them for each unflushed warning. """ class CustomWarning(Warning): pass result = TestResult() case = Mask.MockTests("test_unflushed") case.category = CustomWarning originalWarnings = warnings.filters[:] try: warnings.simplefilter("error") case.run(result) self.assertEqual(len(result.errors), 1) self.assertIdentical(result.errors[0][0], case) self.assertTrue( # Different python versions differ in whether they report the # fully qualified class name or just the class name. result.errors[0][1] .splitlines()[-1] .endswith("CustomWarning: some warning text") ) finally: warnings.filters[:] = originalWarnings def test_flushedWarningsConfiguredAsErrors(self): """ If a warnings filter has been installed which turns warnings into exceptions, tests which emit those warnings but flush them do not have an error added to the reporter. """ class CustomWarning(Warning): pass result = TestResult() case = Mask.MockTests("test_flushed") case.category = CustomWarning originalWarnings = warnings.filters[:] try: warnings.simplefilter("error") case.run(result) self.assertEqual(result.errors, []) finally: warnings.filters[:] = originalWarnings def test_multipleFlushes(self): """ Any warnings emitted after a call to C{flushWarnings} can be flushed by another call to C{flushWarnings}. """ warnings.warn("first message") self.assertEqual(len(self.flushWarnings()), 1) warnings.warn("second message") self.assertEqual(len(self.flushWarnings()), 1) def test_filterOnOffendingFunction(self): """ The list returned by C{flushWarnings} includes only those warnings which refer to the source of the function passed as the value for C{offendingFunction}, if a value is passed for that parameter. """ firstMessage = "first warning text" firstCategory = UserWarning def one(): warnings.warn(firstMessage, firstCategory, stacklevel=1) secondMessage = "some text" secondCategory = RuntimeWarning def two(): warnings.warn(secondMessage, secondCategory, stacklevel=1) one() two() self.assertDictSubsets( self.flushWarnings(offendingFunctions=[one]), [{"category": firstCategory, "message": firstMessage}], ) self.assertDictSubsets( self.flushWarnings(offendingFunctions=[two]), [{"category": secondCategory, "message": secondMessage}], ) def test_functionBoundaries(self): """ Verify that warnings emitted at the very edges of a function are still determined to be emitted from that function. """ def warner(): warnings.warn("first line warning") warnings.warn("internal line warning") warnings.warn("last line warning") warner() self.assertEqual(len(self.flushWarnings(offendingFunctions=[warner])), 3) def test_invalidFilter(self): """ If an object which is neither a function nor a method is included in the C{offendingFunctions} list, C{flushWarnings} raises L{ValueError}. Such a call flushes no warnings. """ warnings.warn("oh no") self.assertRaises(ValueError, self.flushWarnings, [None]) self.assertEqual(len(self.flushWarnings()), 1) def test_missingSource(self): """ Warnings emitted by a function the source code of which is not available can still be flushed. """ package = FilePath(self.mktemp().encode("utf-8")).child( b"twisted_private_helper" ) package.makedirs() package.child(b"__init__.py").setContent(b"") package.child(b"missingsourcefile.py").setContent( b""" import warnings def foo(): warnings.warn("oh no") """ ) pathEntry = package.parent().path.decode("utf-8") sys.path.insert(0, pathEntry) self.addCleanup(sys.path.remove, pathEntry) from twisted_private_helper import missingsourcefile # type: ignore[import] self.addCleanup(sys.modules.pop, "twisted_private_helper") self.addCleanup(sys.modules.pop, missingsourcefile.__name__) package.child(b"missingsourcefile.py").remove() missingsourcefile.foo() self.assertEqual(len(self.flushWarnings([missingsourcefile.foo])), 1) def test_renamedSource(self): """ Warnings emitted by a function defined in a file which has been renamed since it was initially compiled can still be flushed. This is testing the code which specifically supports working around the unfortunate behavior of CPython to write a .py source file name into the .pyc files it generates and then trust that it is correct in various places. If source files are renamed, .pyc files may not be regenerated, but they will contain incorrect filenames. """ package = FilePath(self.mktemp().encode("utf-8")).child( b"twisted_private_helper" ) package.makedirs() package.child(b"__init__.py").setContent(b"") package.child(b"module.py").setContent( b""" import warnings def foo(): warnings.warn("oh no") """ ) pathEntry = package.parent().path.decode("utf-8") sys.path.insert(0, pathEntry) self.addCleanup(sys.path.remove, pathEntry) # Import it to cause pycs to be generated from twisted_private_helper import module # Clean up the state resulting from that import; we're not going to use # this module, so it should go away. del sys.modules["twisted_private_helper"] del sys.modules[module.__name__] # Some Python versions have extra state related to the just # imported/renamed package. Clean it up too. See also # http://bugs.python.org/issue15912 try: from importlib import invalidate_caches except ImportError: pass else: invalidate_caches() # Rename the source directory package.moveTo(package.sibling(b"twisted_renamed_helper")) # Import the newly renamed version from twisted_renamed_helper import module # type: ignore[import] self.addCleanup(sys.modules.pop, "twisted_renamed_helper") self.addCleanup(sys.modules.pop, module.__name__) # Generate the warning module.foo() # Flush it self.assertEqual(len(self.flushWarnings([module.foo])), 1) def test_offendingFunctions_deep_branch(self): """ In Python 3.6 the dis.findlinestarts documented behaviour was changed such that the reported lines might not be sorted ascending. In Python 3.10 PEP 626 introduced byte-code change such that the last line of a function wasn't always associated with the last byte-code. In the past flushWarning was not detecting that such a function was associated with any warnings. """ def foo(a=1, b=1): if a: if b: warnings.warn("oh no") else: pass # Generate the warning foo() # Flush it self.assertEqual(len(self.flushWarnings([foo])), 1) class FakeWarning(Warning): pass class CollectWarningsTests(SynchronousTestCase): """ Tests for L{_collectWarnings}. """ def test_callsObserver(self): """ L{_collectWarnings} calls the observer with each emitted warning. """ firstMessage = "dummy calls observer warning" secondMessage = firstMessage[::-1] thirdMessage = Warning(1, 2, 3) events = [] def f(): events.append("call") warnings.warn(firstMessage) warnings.warn(secondMessage) warnings.warn(thirdMessage) events.append("returning") _collectWarnings(events.append, f) self.assertEqual(events[0], "call") self.assertEqual(events[1].message, firstMessage) self.assertEqual(events[2].message, secondMessage) self.assertEqual(events[3].message, str(thirdMessage)) self.assertEqual(events[4], "returning") self.assertEqual(len(events), 5) def test_suppresses(self): """ Any warnings emitted by a call to a function passed to L{_collectWarnings} are not actually emitted to the warning system. """ output = StringIO() self.patch(sys, "stdout", output) _collectWarnings(lambda x: None, warnings.warn, "text") self.assertEqual(output.getvalue(), "") def test_callsFunction(self): """ L{_collectWarnings} returns the result of calling the callable passed to it with the parameters given. """ arguments = [] value = object() def f(*args, **kwargs): arguments.append((args, kwargs)) return value result = _collectWarnings(lambda x: None, f, 1, "a", b=2, c="d") self.assertEqual(arguments, [((1, "a"), {"b": 2, "c": "d"})]) self.assertIdentical(result, value) def test_duplicateWarningCollected(self): """ Subsequent emissions of a warning from a particular source site can be collected by L{_collectWarnings}. In particular, the per-module emitted-warning cache should be bypassed (I{__warningregistry__}). """ # Make sure the worst case is tested: if __warningregistry__ isn't in a # module's globals, then the warning system will add it and start using # it to avoid emitting duplicate warnings. Delete __warningregistry__ # to ensure that even modules which are first imported as a test is # running still interact properly with the warning system. global __warningregistry__ del __warningregistry__ def f(): warnings.warn("foo") warnings.simplefilter("default") f() events = [] _collectWarnings(events.append, f) self.assertEqual(len(events), 1) self.assertEqual(events[0].message, "foo") self.assertEqual(len(self.flushWarnings()), 1) def test_immutableObject(self): """ L{_collectWarnings}'s behavior is not altered by the presence of an object which cannot have attributes set on it as a value in C{sys.modules}. """ key = object() sys.modules[key] = key self.addCleanup(sys.modules.pop, key) self.test_duplicateWarningCollected() def test_setWarningRegistryChangeWhileIterating(self): """ If the dictionary passed to L{_setWarningRegistryToNone} changes size partway through the process, C{_setWarningRegistryToNone} continues to set C{__warningregistry__} to L{None} on the rest of the values anyway. This might be caused by C{sys.modules} containing something that's not really a module and imports things on setattr. py.test does this, as does L{twisted.python.deprecate.deprecatedModuleAttribute}. """ d = {} class A: def __init__(self, key): self.__dict__["_key"] = key def __setattr__(self, value, item): d[self._key] = None key1 = object() key2 = object() d[key1] = A(key2) key3 = object() key4 = object() d[key3] = A(key4) _setWarningRegistryToNone(d) # If both key2 and key4 were added, then both A instanced were # processed. self.assertEqual({key1, key2, key3, key4}, set(d.keys())) PK Mb�Z � trial/test/test_suppression.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for warning suppression features of Trial. """ import unittest as pyunit from twisted.python.reflect import namedAny from twisted.trial import unittest from twisted.trial.test import suppression class SuppressionMixin: """ Tests for the warning suppression features of L{twisted.trial.unittest.SynchronousTestCase}. """ def runTests(self, suite): suite.run(pyunit.TestResult()) def _load(self, cls, methodName): """ Return a new L{unittest.TestSuite} with a single test method in it. @param cls: A L{TestCase} subclass defining a test method. @param methodName: The name of the test method from C{cls}. """ return pyunit.TestSuite([cls(methodName)]) def _assertWarnings(self, warnings, which): """ Assert that a certain number of warnings with certain messages were emitted in a certain order. @param warnings: A list of emitted warnings, as returned by C{flushWarnings}. @param which: A list of strings giving warning messages that should appear in C{warnings}. @raise self.failureException: If the warning messages given by C{which} do not match the messages in the warning information in C{warnings}, or if they do not appear in the same order. """ self.assertEqual([warning["message"] for warning in warnings], which) def test_setUpSuppression(self): """ Suppressions defined by the test method being run are applied to any warnings emitted while running the C{setUp} fixture. """ self.runTests(self._load(self.TestSetUpSuppression, "testSuppressMethod")) warningsShown = self.flushWarnings([self.TestSetUpSuppression._emit]) self._assertWarnings( warningsShown, [ suppression.CLASS_WARNING_MSG, suppression.MODULE_WARNING_MSG, suppression.CLASS_WARNING_MSG, suppression.MODULE_WARNING_MSG, ], ) def test_tearDownSuppression(self): """ Suppressions defined by the test method being run are applied to any warnings emitted while running the C{tearDown} fixture. """ self.runTests(self._load(self.TestTearDownSuppression, "testSuppressMethod")) warningsShown = self.flushWarnings([self.TestTearDownSuppression._emit]) self._assertWarnings( warningsShown, [ suppression.CLASS_WARNING_MSG, suppression.MODULE_WARNING_MSG, suppression.CLASS_WARNING_MSG, suppression.MODULE_WARNING_MSG, ], ) def test_suppressMethod(self): """ A suppression set on a test method prevents warnings emitted by that test method which the suppression matches from being emitted. """ self.runTests(self._load(self.TestSuppression, "testSuppressMethod")) warningsShown = self.flushWarnings([self.TestSuppression._emit]) self._assertWarnings( warningsShown, [suppression.CLASS_WARNING_MSG, suppression.MODULE_WARNING_MSG], ) def test_suppressClass(self): """ A suppression set on a L{SynchronousTestCase} subclass prevents warnings emitted by any test methods defined on that class which match the suppression from being emitted. """ self.runTests(self._load(self.TestSuppression, "testSuppressClass")) warningsShown = self.flushWarnings([self.TestSuppression._emit]) self.assertEqual(warningsShown[0]["message"], suppression.METHOD_WARNING_MSG) self.assertEqual(warningsShown[1]["message"], suppression.MODULE_WARNING_MSG) self.assertEqual(len(warningsShown), 2) def test_suppressModule(self): """ A suppression set on a module prevents warnings emitted by any test mewthods defined in that module which match the suppression from being emitted. """ self.runTests(self._load(self.TestSuppression2, "testSuppressModule")) warningsShown = self.flushWarnings([self.TestSuppression._emit]) self.assertEqual(warningsShown[0]["message"], suppression.METHOD_WARNING_MSG) self.assertEqual(warningsShown[1]["message"], suppression.CLASS_WARNING_MSG) self.assertEqual(len(warningsShown), 2) def test_overrideSuppressClass(self): """ The suppression set on a test method completely overrides a suppression with wider scope; if it does not match a warning emitted by that test method, the warning is emitted, even if a wider suppression matches. """ self.runTests(self._load(self.TestSuppression, "testOverrideSuppressClass")) warningsShown = self.flushWarnings([self.TestSuppression._emit]) self.assertEqual(warningsShown[0]["message"], suppression.METHOD_WARNING_MSG) self.assertEqual(warningsShown[1]["message"], suppression.CLASS_WARNING_MSG) self.assertEqual(warningsShown[2]["message"], suppression.MODULE_WARNING_MSG) self.assertEqual(len(warningsShown), 3) class SynchronousSuppressionTests(SuppressionMixin, unittest.SynchronousTestCase): """ @see: L{twisted.trial.test.test_tests} """ TestSetUpSuppression = namedAny( "twisted.trial.test.suppression.SynchronousTestSetUpSuppression" ) TestTearDownSuppression = namedAny( "twisted.trial.test.suppression.SynchronousTestTearDownSuppression" ) TestSuppression = namedAny( "twisted.trial.test.suppression.SynchronousTestSuppression" ) TestSuppression2 = namedAny( "twisted.trial.test.suppression.SynchronousTestSuppression2" ) PK Mb�Z �B�� � trial/test/test_runner.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # Maintainer: Jonathan Lange # Author: Robert Collins import os import pdb import sys import unittest as pyunit from io import StringIO from typing import List from zope.interface import implementer from zope.interface.verify import verifyObject from twisted import plugin from twisted.internet import defer from twisted.plugins import twisted_trial from twisted.python import failure, log, reflect from twisted.python.filepath import FilePath from twisted.python.reflect import namedAny from twisted.scripts import trial from twisted.trial import reporter, runner, unittest, util from twisted.trial._asyncrunner import _ForceGarbageCollectionDecorator from twisted.trial.itrial import IReporter, ITestCase class CapturingDebugger: def __init__(self): self._calls = [] def runcall(self, *args, **kwargs): self._calls.append("runcall") args[0](*args[1:], **kwargs) @implementer(IReporter) class CapturingReporter: """ Reporter that keeps a log of all actions performed on it. """ stream = None tbformat = None args = None separator = None testsRun = None def __init__(self, stream=None, tbformat=None, rterrors=None, publisher=None): """ Create a capturing reporter. """ self._calls = [] self.shouldStop = False self._stream = stream self._tbformat = tbformat self._rterrors = rterrors self._publisher = publisher def startTest(self, method): """ Report the beginning of a run of a single test method @param method: an object that is adaptable to ITestMethod """ self._calls.append("startTest") def stopTest(self, method): """ Report the status of a single test method @param method: an object that is adaptable to ITestMethod """ self._calls.append("stopTest") def cleanupErrors(self, errs): """called when the reactor has been left in a 'dirty' state @param errs: a list of L{twisted.python.failure.Failure}s """ self._calls.append("cleanupError") def addSuccess(self, test): self._calls.append("addSuccess") def done(self): """ Do nothing. These tests don't care about done. """ def addError(self, test, error): """ Do nothing. These tests don't care about addError. """ def addFailure(self, test, failure): """ Do nothing. These tests don't care about addFailure. """ def addExpectedFailure(self, test, failure, todo=None): """ Do nothing. These tests don't care about addExpectedFailure. """ def addUnexpectedSuccess(self, test, todo=None): """ Do nothing. These tests don't care about addUnexpectedSuccess. """ def addSkip(self, test, reason): """ Do nothing. These tests don't care about addSkip. """ def wasSuccessful(self): """ Do nothing. These tests don't care about wasSuccessful. """ class TrialRunnerTestsMixin: """ Mixin defining tests for L{runner.TrialRunner}. """ def tearDown(self): self.runner._tearDownLogFile() def test_empty(self): """ Empty test method, used by the other tests. """ def _getObservers(self): return log.theLogPublisher.observers def test_addObservers(self): """ Any log system observers L{TrialRunner.run} adds are removed by the time it returns. """ originalCount = len(self._getObservers()) self.runner.run(self.test) newCount = len(self._getObservers()) self.assertEqual(newCount, originalCount) def test_logFileAlwaysActive(self): """ Test that a new file is opened on each run. """ oldSetUpLogFile = self.runner._setUpLogFile l = [] def setUpLogFile(): oldSetUpLogFile() l.append(self.runner._logFileObserver) self.runner._setUpLogFile = setUpLogFile self.runner.run(self.test) self.runner.run(self.test) self.assertEqual(len(l), 2) self.assertFalse(l[0] is l[1], "Should have created a new file observer") def test_logFileGetsClosed(self): """ Test that file created is closed during the run. """ oldSetUpLogFile = self.runner._setUpLogFile l = [] def setUpLogFile(): oldSetUpLogFile() l.append(self.runner._logFileObject) self.runner._setUpLogFile = setUpLogFile self.runner.run(self.test) self.assertEqual(len(l), 1) self.assertTrue(l[0].closed) class TrialRunnerTests(TrialRunnerTestsMixin, unittest.SynchronousTestCase): """ Tests for L{runner.TrialRunner} with the feature to turn unclean errors into warnings disabled. """ def setUp(self): self.stream = StringIO() self.runner = runner.TrialRunner(CapturingReporter, stream=self.stream) self.test = TrialRunnerTests("test_empty") def test_publisher(self): """ The reporter constructed by L{runner.TrialRunner} is passed L{twisted.python.log} as the value for the C{publisher} parameter. """ result = self.runner._makeResult() self.assertIdentical(result._publisher, log) class TrialRunnerWithUncleanWarningsReporterTests( TrialRunnerTestsMixin, unittest.SynchronousTestCase ): """ Tests for the TrialRunner's interaction with an unclean-error suppressing reporter. """ def setUp(self): self.stream = StringIO() self.runner = runner.TrialRunner( CapturingReporter, stream=self.stream, uncleanWarnings=True ) self.test = TrialRunnerTests("test_empty") class DryRunMixin: """ Mixin for testing that 'dry run' mode works with various L{pyunit.TestCase} subclasses. """ def setUp(self): self.log = [] self.stream = StringIO() self.runner = runner.TrialRunner( CapturingReporter, runner.TrialRunner.DRY_RUN, stream=self.stream ) self.makeTestFixtures() def makeTestFixtures(self): """ Set C{self.test} and C{self.suite}, where C{self.suite} is an empty TestSuite. """ def test_empty(self): """ If there are no tests, the reporter should not receive any events to report. """ result = self.runner.run(runner.TestSuite()) self.assertEqual(result._calls, []) def test_singleCaseReporting(self): """ If we are running a single test, check the reporter starts, passes and then stops the test during a dry run. """ result = self.runner.run(self.test) self.assertEqual(result._calls, ["startTest", "addSuccess", "stopTest"]) def test_testsNotRun(self): """ When we are doing a dry run, the tests should not actually be run. """ self.runner.run(self.test) self.assertEqual(self.log, []) class SynchronousDryRunTests(DryRunMixin, unittest.SynchronousTestCase): """ Check that 'dry run' mode works well with trial's L{SynchronousTestCase}. """ def makeTestFixtures(self): class PyunitCase(unittest.SynchronousTestCase): def test_foo(self): pass self.test = PyunitCase("test_foo") self.suite = pyunit.TestSuite() class DryRunTests(DryRunMixin, unittest.SynchronousTestCase): """ Check that 'dry run' mode works well with Trial tests. """ def makeTestFixtures(self): class MockTest(unittest.TestCase): def test_foo(test): self.log.append("test_foo") self.test = MockTest("test_foo") self.suite = runner.TestSuite() class PyUnitDryRunTests(DryRunMixin, unittest.SynchronousTestCase): """ Check that 'dry run' mode works well with stdlib unittest tests. """ def makeTestFixtures(self): class PyunitCase(pyunit.TestCase): def test_foo(self): pass self.test = PyunitCase("test_foo") self.suite = pyunit.TestSuite() class RunnerTests(unittest.SynchronousTestCase): def setUp(self): self.config = trial.Options() # whitebox hack a reporter in, because plugins are CACHED and will # only reload if the FILE gets changed. parts = reflect.qual(CapturingReporter).split(".") package = ".".join(parts[:-1]) klass = parts[-1] plugins = [ twisted_trial._Reporter( "Test Helper Reporter", package, description="Utility for unit testing.", longOpt="capturing", shortOpt=None, klass=klass, ) ] # XXX There should really be a general way to hook the plugin system # for tests. def getPlugins(iface, *a, **kw): self.assertEqual(iface, IReporter) return plugins + list(self.original(iface, *a, **kw)) self.original = plugin.getPlugins plugin.getPlugins = getPlugins self.standardReport = [ "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", ] def tearDown(self): plugin.getPlugins = self.original def parseOptions(self, args): self.config.parseOptions(args) def getRunner(self): r = trial._makeRunner(self.config) r.stream = StringIO() # XXX The runner should always take care of cleaning this up itself. # It's not clear why this is necessary. The runner always tears down # its log file. self.addCleanup(r._tearDownLogFile) # XXX The runner should always take care of cleaning this up itself as # well. It's necessary because TrialRunner._setUpTestdir might raise # an exception preventing Reporter.done from being run, leaving the # observer added by Reporter.__init__ still present in the system. # Something better needs to happen inside # TrialRunner._runWithoutDecoration to remove the need for this cludge. r._log = log.LogPublisher() return r def test_runner_can_get_reporter(self): self.parseOptions([]) result = self.config["reporter"] runner = self.getRunner() self.assertEqual(result, runner._makeResult().__class__) def test_runner_get_result(self): self.parseOptions([]) runner = self.getRunner() result = runner._makeResult() self.assertEqual(result.__class__, self.config["reporter"]) def test_uncleanWarningsOffByDefault(self): """ By default Trial sets the 'uncleanWarnings' option on the runner to False. This means that dirty reactor errors will be reported as errors. See L{test_reporter.DirtyReactorTests}. """ self.parseOptions([]) runner = self.getRunner() self.assertNotIsInstance( runner._makeResult(), reporter.UncleanWarningsReporterWrapper ) def test_getsUncleanWarnings(self): """ Specifying '--unclean-warnings' on the trial command line will cause reporters to be wrapped in a device which converts unclean errors to warnings. See L{test_reporter.DirtyReactorTests} for implications. """ self.parseOptions(["--unclean-warnings"]) runner = self.getRunner() self.assertIsInstance( runner._makeResult(), reporter.UncleanWarningsReporterWrapper ) def test_runner_working_directory(self): self.parseOptions(["--temp-directory", "some_path"]) runner = self.getRunner() self.assertEqual(runner.workingDirectory, "some_path") def test_concurrentImplicitWorkingDirectory(self): """ If no working directory is explicitly specified and the default working directory is in use by another runner, L{TrialRunner.run} selects a different default working directory to use. """ self.parseOptions([]) # Make sure we end up with the same working directory after this test # as we had before it. self.addCleanup(os.chdir, os.getcwd()) # Make a new directory and change into it. This isolates us from state # that other tests might have dumped into this process's temp # directory. runDirectory = FilePath(self.mktemp()) runDirectory.makedirs() os.chdir(runDirectory.path) firstRunner = self.getRunner() secondRunner = self.getRunner() where = {} class ConcurrentCase(unittest.SynchronousTestCase): def test_first(self): """ Start a second test run which will have a default working directory which is the same as the working directory of the test run already in progress. """ # Change the working directory to the value it had before this # test suite was started. where["concurrent"] = subsequentDirectory = os.getcwd() os.chdir(runDirectory.path) self.addCleanup(os.chdir, subsequentDirectory) secondRunner.run(ConcurrentCase("test_second")) def test_second(self): """ Record the working directory for later analysis. """ where["record"] = os.getcwd() result = firstRunner.run(ConcurrentCase("test_first")) bad = result.errors + result.failures if bad: self.fail(bad[0][1]) self.assertEqual( where, { "concurrent": runDirectory.child("_trial_temp").path, "record": runDirectory.child("_trial_temp-1").path, }, ) def test_concurrentExplicitWorkingDirectory(self): """ If a working directory which is already in use is explicitly specified, L{TrialRunner.run} raises L{_WorkingDirectoryBusy}. """ self.parseOptions(["--temp-directory", os.path.abspath(self.mktemp())]) initialDirectory = os.getcwd() self.addCleanup(os.chdir, initialDirectory) firstRunner = self.getRunner() secondRunner = self.getRunner() class ConcurrentCase(unittest.SynchronousTestCase): def test_concurrent(self): """ Try to start another runner in the same working directory and assert that it raises L{_WorkingDirectoryBusy}. """ self.assertRaises( util._WorkingDirectoryBusy, secondRunner.run, ConcurrentCase("test_failure"), ) def test_failure(self): """ Should not be called, always fails. """ self.fail("test_failure should never be called.") result = firstRunner.run(ConcurrentCase("test_concurrent")) bad = result.errors + result.failures if bad: self.fail(bad[0][1]) def test_runner_normal(self): self.parseOptions( [ "--temp-directory", self.mktemp(), "--reporter", "capturing", "twisted.trial.test.sample", ] ) my_runner = self.getRunner() loader = runner.TestLoader() suite = loader.loadByName("twisted.trial.test.sample", True) result = my_runner.run(suite) self.assertEqual(self.standardReport, result._calls) def runSampleSuite(self, my_runner): loader = runner.TestLoader() suite = loader.loadByName("twisted.trial.test.sample", True) return my_runner.run(suite) def test_runnerDebug(self): """ Trial uses its debugger if the `--debug` option is passed. """ self.parseOptions( ["--reporter", "capturing", "--debug", "twisted.trial.test.sample"] ) my_runner = self.getRunner() debugger = my_runner.debugger = CapturingDebugger() result = self.runSampleSuite(my_runner) self.assertEqual(self.standardReport, result._calls) self.assertEqual(["runcall"], debugger._calls) def test_runnerDebuggerDefaultsToPdb(self): """ Trial uses pdb if no debugger is specified by `--debugger` """ self.parseOptions(["--debug", "twisted.trial.test.sample"]) pdbrcFile = FilePath("pdbrc") pdbrcFile.touch() self.runcall_called = False def runcall(pdb, suite, result): self.runcall_called = True self.patch(pdb.Pdb, "runcall", runcall) self.runSampleSuite(self.getRunner()) self.assertTrue(self.runcall_called) def test_runnerDebuggerWithExplicitlyPassedPdb(self): """ Trial uses pdb if pdb is passed explicitly to the `--debugger` arg. """ self.parseOptions( [ "--reporter", "capturing", "--debugger", "pdb", "--debug", "twisted.trial.test.sample", ] ) self.runcall_called = False def runcall(pdb, suite, result): self.runcall_called = True self.patch(pdb.Pdb, "runcall", runcall) self.runSampleSuite(self.getRunner()) self.assertTrue(self.runcall_called) cdebugger = CapturingDebugger() def test_runnerDebugger(self): """ Trial uses specified debugger if the debugger is available. """ self.parseOptions( [ "--reporter", "capturing", "--debugger", "twisted.trial.test.test_runner.RunnerTests.cdebugger", "--debug", "twisted.trial.test.sample", ] ) my_runner = self.getRunner() result = self.runSampleSuite(my_runner) self.assertEqual(self.standardReport, result._calls) self.assertEqual(["runcall"], my_runner.debugger._calls) def test_exitfirst(self): """ If trial was passed the C{--exitfirst} option, the constructed test result object is wrapped with L{reporter._ExitWrapper}. """ self.parseOptions(["--exitfirst"]) runner = self.getRunner() result = runner._makeResult() self.assertIsInstance(result, reporter._ExitWrapper) class TrialSuiteTests(unittest.SynchronousTestCase): def test_imports(self): # FIXME, HTF do you test the reactor can be cleaned up ?!!! namedAny("twisted.trial.runner.TrialSuite") class UntilFailureTests(unittest.SynchronousTestCase): class FailAfter(pyunit.TestCase): """ A test case that fails when run 3 times in a row. """ count: List[None] = [] def test_foo(self): self.count.append(None) if len(self.count) == 3: self.fail("Count reached 3") def setUp(self): UntilFailureTests.FailAfter.count = [] self.test = UntilFailureTests.FailAfter("test_foo") self.stream = StringIO() self.runner = runner.TrialRunner(reporter.Reporter, stream=self.stream) def test_runUntilFailure(self): """ Test that the runUntilFailure method of the runner actually fail after a few runs. """ result = self.runner.runUntilFailure(self.test) self.assertEqual(result.testsRun, 1) self.assertFalse(result.wasSuccessful()) self.assertEqual(self._getFailures(result), 1) def _getFailures(self, result): """ Get the number of failures that were reported to a result. """ return len(result.failures) def test_runUntilFailureDecorate(self): """ C{runUntilFailure} doesn't decorate the tests uselessly: it does it one time when run starts, but not at each turn. """ decorated = [] def decorate(test, interface): decorated.append((test, interface)) return test self.patch(unittest, "decorate", decorate) result = self.runner.runUntilFailure(self.test) self.assertEqual(result.testsRun, 1) self.assertEqual(len(decorated), 1) self.assertEqual(decorated, [(self.test, ITestCase)]) def test_runUntilFailureForceGCDecorate(self): """ C{runUntilFailure} applies the force-gc decoration after the standard L{ITestCase} decoration, but only one time. """ decorated = [] def decorate(test, interface): decorated.append((test, interface)) return test self.patch(unittest, "decorate", decorate) self.runner._forceGarbageCollection = True result = self.runner.runUntilFailure(self.test) self.assertEqual(result.testsRun, 1) self.assertEqual(len(decorated), 2) self.assertEqual( decorated, [(self.test, ITestCase), (self.test, _ForceGarbageCollectionDecorator)], ) class UncleanUntilFailureTests(UntilFailureTests): """ Test that the run-until-failure feature works correctly with the unclean error suppressor. """ def setUp(self): UntilFailureTests.setUp(self) self.runner = runner.TrialRunner( reporter.Reporter, stream=self.stream, uncleanWarnings=True ) def _getFailures(self, result): """ Get the number of failures that were reported to a result that is wrapped in an UncleanFailureWrapper. """ return len(result._originalReporter.failures) class BreakingSuite(runner.TestSuite): """ A L{TestSuite} that logs an error when it is run. """ def run(self, result): try: raise RuntimeError("error that occurs outside of a test") except RuntimeError: log.err(failure.Failure()) class LoggedErrorsTests(unittest.SynchronousTestCase): """ It is possible for an error generated by a test to be logged I{outside} of any test. The log observers constructed by L{TestCase} won't catch these errors. Here we try to generate such errors and ensure they are reported to a L{TestResult} object. """ def tearDown(self): self.flushLoggedErrors(RuntimeError) def test_construct(self): """ Check that we can construct a L{runner.LoggedSuite} and that it starts empty. """ suite = runner.LoggedSuite() self.assertEqual(suite.countTestCases(), 0) def test_capturesError(self): """ Chek that a L{LoggedSuite} reports any logged errors to its result. """ result = reporter.TestResult() suite = runner.LoggedSuite([BreakingSuite()]) suite.run(result) self.assertEqual(len(result.errors), 1) self.assertEqual(result.errors[0][0].id(), runner.NOT_IN_TEST) self.assertTrue(result.errors[0][1].check(RuntimeError)) class TestHolderTests(unittest.SynchronousTestCase): def setUp(self): self.description = "description" self.holder = runner.TestHolder(self.description) def test_holder(self): """ Check that L{runner.TestHolder} takes a description as a parameter and that this description is returned by the C{id} and C{shortDescription} methods. """ self.assertEqual(self.holder.id(), self.description) self.assertEqual(self.holder.shortDescription(), self.description) def test_holderImplementsITestCase(self): """ L{runner.TestHolder} implements L{ITestCase}. """ self.assertIdentical(self.holder, ITestCase(self.holder)) self.assertTrue( verifyObject(ITestCase, self.holder), "%r claims to provide %r but does not do so correctly." % (self.holder, ITestCase), ) def test_runsWithStandardResult(self): """ A L{runner.TestHolder} can run against the standard Python C{TestResult}. """ result = pyunit.TestResult() self.holder.run(result) self.assertTrue(result.wasSuccessful()) self.assertEqual(1, result.testsRun) class ErrorHolderTestsMixin: """ This mixin defines test methods which can be applied to a L{runner.ErrorHolder} constructed with either a L{Failure} or a C{exc_info}-style tuple. Subclass this and implement C{setUp} to create C{self.holder} referring to a L{runner.ErrorHolder} instance and C{self.error} referring to a L{Failure} which the holder holds. """ exceptionForTests = ZeroDivisionError("integer division or modulo by zero") class TestResultStub: """ Stub for L{TestResult}. """ def __init__(self): self.errors = [] def startTest(self, test): pass def stopTest(self, test): pass def addError(self, test, error): self.errors.append((test, error)) def test_runsWithStandardResult(self): """ A L{runner.ErrorHolder} can run against the standard Python C{TestResult}. """ result = pyunit.TestResult() self.holder.run(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(1, result.testsRun) def test_run(self): """ L{runner.ErrorHolder} adds an error to the result when run. """ self.holder.run(self.result) self.assertEqual( self.result.errors, [(self.holder, (self.error.type, self.error.value, self.error.tb))], ) def test_call(self): """ L{runner.ErrorHolder} adds an error to the result when called. """ self.holder(self.result) self.assertEqual( self.result.errors, [(self.holder, (self.error.type, self.error.value, self.error.tb))], ) def test_countTestCases(self): """ L{runner.ErrorHolder.countTestCases} always returns 0. """ self.assertEqual(self.holder.countTestCases(), 0) def test_repr(self): """ L{runner.ErrorHolder.__repr__} returns a string describing the error it holds. """ expected = "<ErrorHolder description='description' " "error={}>".format( repr(self.holder.error[1]) ) self.assertEqual(repr(self.holder), expected) class FailureHoldingErrorHolderTests(ErrorHolderTestsMixin, TestHolderTests): """ Tests for L{runner.ErrorHolder} behaving similarly to L{runner.TestHolder} when constructed with a L{Failure} representing its error. """ def setUp(self): self.description = "description" # make a real Failure so we can construct ErrorHolder() try: raise self.exceptionForTests except ZeroDivisionError: self.error = failure.Failure() self.holder = runner.ErrorHolder(self.description, self.error) self.result = self.TestResultStub() class ExcInfoHoldingErrorHolderTests(ErrorHolderTestsMixin, TestHolderTests): """ Tests for L{runner.ErrorHolder} behaving similarly to L{runner.TestHolder} when constructed with a C{exc_info}-style tuple representing its error. """ def setUp(self): self.description = "description" # make a real Failure so we can construct ErrorHolder() try: raise self.exceptionForTests except ZeroDivisionError: exceptionInfo = sys.exc_info() self.error = failure.Failure() self.holder = runner.ErrorHolder(self.description, exceptionInfo) self.result = self.TestResultStub() class MalformedMethodTests(unittest.SynchronousTestCase): """ Test that trial manages when test methods don't have correct signatures. """ class ContainMalformed(pyunit.TestCase): """ This TestCase holds malformed test methods that trial should handle. """ def test_foo(self, blah): pass def test_bar(): # type: ignore[misc] pass test_spam = defer.inlineCallbacks(test_bar) def _test(self, method): """ Wrapper for one of the test method of L{ContainMalformed}. """ stream = StringIO() trialRunner = runner.TrialRunner(reporter.Reporter, stream=stream) test = MalformedMethodTests.ContainMalformed(method) result = trialRunner.run(test) self.assertEqual(result.testsRun, 1) self.assertFalse(result.wasSuccessful()) self.assertEqual(len(result.errors), 1) def test_extraArg(self): """ Test when the method has extra (useless) arguments. """ self._test("test_foo") def test_noArg(self): """ Test when the method doesn't have even self as argument. """ self._test("test_bar") def test_decorated(self): """ Test a decorated method also fails. """ self._test("test_spam") class DestructiveTestSuiteTests(unittest.SynchronousTestCase): """ Test for L{runner.DestructiveTestSuite}. """ def test_basic(self): """ Thes destructive test suite should run the tests normally. """ called = [] class MockTest(pyunit.TestCase): def test_foo(test): called.append(True) test = MockTest("test_foo") result = reporter.TestResult() suite = runner.DestructiveTestSuite([test]) self.assertEqual(called, []) suite.run(result) self.assertEqual(called, [True]) self.assertEqual(suite.countTestCases(), 0) def test_shouldStop(self): """ Test the C{shouldStop} management: raising a C{KeyboardInterrupt} must interrupt the suite. """ called = [] class MockTest(unittest.TestCase): def test_foo1(test): called.append(1) def test_foo2(test): raise KeyboardInterrupt() def test_foo3(test): called.append(2) result = reporter.TestResult() loader = runner.TestLoader() loader.suiteFactory = runner.DestructiveTestSuite suite = loader.loadClass(MockTest) self.assertEqual(called, []) suite.run(result) self.assertEqual(called, [1]) # The last test shouldn't have been run self.assertEqual(suite.countTestCases(), 1) def test_cleanup(self): """ Checks that the test suite cleanups its tests during the run, so that it ends empty. """ class MockTest(pyunit.TestCase): def test_foo(test): pass test = MockTest("test_foo") result = reporter.TestResult() suite = runner.DestructiveTestSuite([test]) self.assertEqual(suite.countTestCases(), 1) suite.run(result) self.assertEqual(suite.countTestCases(), 0) class RunnerDeprecationTests(unittest.SynchronousTestCase): class FakeReporter(reporter.Reporter): """ Fake reporter that does *not* implement done() but *does* implement printErrors, separator, printSummary, stream, write and writeln without deprecations. """ done = None separator = None stream = None def printErrors(self, *args): pass def printSummary(self, *args): pass def write(self, *args): pass def writeln(self, *args): pass def test_reporterDeprecations(self): """ The runner emits a warning if it is using a result that doesn't implement 'done'. """ trialRunner = runner.TrialRunner(None) result = self.FakeReporter() trialRunner._makeResult = lambda: result def f(): # We have to use a pyunit test, otherwise we'll get deprecation # warnings about using iterate() in a test. trialRunner.run(pyunit.TestCase("id")) f() warnings = self.flushWarnings([self.test_reporterDeprecations]) self.assertEqual(warnings[0]["category"], DeprecationWarning) self.assertEqual( warnings[0]["message"], "%s should implement done() but doesn't. Falling back to " "printErrors() and friends." % reflect.qual(result.__class__), ) self.assertTrue(__file__.startswith(warnings[0]["filename"])) self.assertEqual(len(warnings), 1) class QualifiedNameWalkerTests(unittest.SynchronousTestCase): """ Tests for L{twisted.trial.runner._qualNameWalker}. """ def test_walksDownPath(self): """ C{_qualNameWalker} is a generator that, when given a Python qualified name, yields that name, and then the parent of that name, and so forth, along with a list of the tried components, in a 2-tuple. """ walkerResults = list(runner._qualNameWalker("walker.texas.ranger")) self.assertEqual( walkerResults, [ ("walker.texas.ranger", []), ("walker.texas", ["ranger"]), ("walker", ["texas", "ranger"]), ], ) class TrialMainDoesNothingTests(unittest.SynchronousTestCase): """ Importing L{twisted.trial.__main__} will not run the script unless it is actually C{__main__}. """ def test_importDoesNothing(self): """ If we import L{twisted.trial.__main__}, it should do nothing. """ # We shouldn't suddenly drop into a script when we import this! __import__("twisted.trial.__main__") PK Mb�Z�zh h trial/test/test_log.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test the interaction between trial and errors logged during test run. """ import time from twisted.internet import reactor, task from twisted.python import failure, log from twisted.trial import _synctest, reporter, unittest def makeFailure(): """ Return a new, realistic failure. """ try: 1 / 0 except ZeroDivisionError: f = failure.Failure() return f class Mask: """ Hide C{MockTest}s from Trial's automatic test finder. """ class FailureLoggingMixin: def test_silent(self): """ Don't log any errors. """ def test_single(self): """ Log a single error. """ log.err(makeFailure()) def test_double(self): """ Log two errors. """ log.err(makeFailure()) log.err(makeFailure()) def test_singleThenFail(self): """ Log a single error, then fail. """ log.err(makeFailure()) 1 + None class SynchronousFailureLogging(FailureLoggingMixin, unittest.SynchronousTestCase): pass class AsynchronousFailureLogging(FailureLoggingMixin, unittest.TestCase): def test_inCallback(self): """ Log an error in an asynchronous callback. """ return task.deferLater(reactor, 0, lambda: log.err(makeFailure())) class ObserverTests(unittest.SynchronousTestCase): """ Tests for L{_synctest._LogObserver}, a helper for the implementation of L{SynchronousTestCase.flushLoggedErrors}. """ def setUp(self): self.result = reporter.TestResult() self.observer = _synctest._LogObserver() def test_msg(self): """ Test that a standard log message doesn't go anywhere near the result. """ self.observer.gotEvent( { "message": ("some message",), "time": time.time(), "isError": 0, "system": "-", } ) self.assertEqual(self.observer.getErrors(), []) def test_error(self): """ Test that an observed error gets added to the result """ f = makeFailure() self.observer.gotEvent( { "message": (), "time": time.time(), "isError": 1, "system": "-", "failure": f, "why": None, } ) self.assertEqual(self.observer.getErrors(), [f]) def test_flush(self): """ Check that flushing the observer with no args removes all errors. """ self.test_error() flushed = self.observer.flushErrors() self.assertEqual(self.observer.getErrors(), []) self.assertEqual(len(flushed), 1) self.assertTrue(flushed[0].check(ZeroDivisionError)) def _makeRuntimeFailure(self): return failure.Failure(RuntimeError("test error")) def test_flushByType(self): """ Check that flushing the observer remove all failures of the given type. """ self.test_error() # log a ZeroDivisionError to the observer f = self._makeRuntimeFailure() self.observer.gotEvent( dict( message=(), time=time.time(), isError=1, system="-", failure=f, why=None ) ) flushed = self.observer.flushErrors(ZeroDivisionError) self.assertEqual(self.observer.getErrors(), [f]) self.assertEqual(len(flushed), 1) self.assertTrue(flushed[0].check(ZeroDivisionError)) def test_ignoreErrors(self): """ Check that C{_ignoreErrors} actually causes errors to be ignored. """ self.observer._ignoreErrors(ZeroDivisionError) f = makeFailure() self.observer.gotEvent( { "message": (), "time": time.time(), "isError": 1, "system": "-", "failure": f, "why": None, } ) self.assertEqual(self.observer.getErrors(), []) def test_clearIgnores(self): """ Check that C{_clearIgnores} ensures that previously ignored errors get captured. """ self.observer._ignoreErrors(ZeroDivisionError) self.observer._clearIgnores() f = makeFailure() self.observer.gotEvent( { "message": (), "time": time.time(), "isError": 1, "system": "-", "failure": f, "why": None, } ) self.assertEqual(self.observer.getErrors(), [f]) class LogErrorsMixin: """ High-level tests demonstrating the expected behaviour of logged errors during tests. """ def setUp(self): self.result = reporter.TestResult() def tearDown(self): self.flushLoggedErrors(ZeroDivisionError) def test_singleError(self): """ Test that a logged error gets reported as a test error. """ test = self.MockTest("test_single") test(self.result) self.assertEqual(len(self.result.errors), 1) self.assertTrue( self.result.errors[0][1].check(ZeroDivisionError), self.result.errors[0][1] ) self.assertEqual(0, self.result.successes) def test_twoErrors(self): """ Test that when two errors get logged, they both get reported as test errors. """ test = self.MockTest("test_double") test(self.result) self.assertEqual(len(self.result.errors), 2) self.assertEqual(0, self.result.successes) def test_errorsIsolated(self): """ Check that an error logged in one test doesn't fail the next test. """ t1 = self.MockTest("test_single") t2 = self.MockTest("test_silent") t1(self.result) t2(self.result) self.assertEqual(len(self.result.errors), 1) self.assertEqual(self.result.errors[0][0], t1) self.assertEqual(1, self.result.successes) def test_errorsIsolatedWhenTestFails(self): """ An error logged in a failed test doesn't fail the next test. """ t1 = self.MockTest("test_singleThenFail") t2 = self.MockTest("test_silent") t1(self.result) t2(self.result) self.assertEqual(len(self.result.errors), 2) self.assertEqual(self.result.errors[0][0], t1) self.result.errors[0][1].trap(TypeError) self.assertEqual(self.result.errors[1][0], t1) self.result.errors[1][1].trap(ZeroDivisionError) self.assertEqual(1, self.result.successes) def test_boundedObservers(self): """ There are no extra log observers after a test runs. """ # XXX trial is *all about* global log state. It should really be fixed. observer = _synctest._LogObserver() self.patch(_synctest, "_logObserver", observer) observers = log.theLogPublisher.observers[:] test = self.MockTest() test(self.result) self.assertEqual(observers, log.theLogPublisher.observers) class SynchronousLogErrorsTests(LogErrorsMixin, unittest.SynchronousTestCase): MockTest = Mask.SynchronousFailureLogging class AsynchronousLogErrorsTests(LogErrorsMixin, unittest.TestCase): MockTest = Mask.AsynchronousFailureLogging def test_inCallback(self): """ Test that errors logged in callbacks get reported as test errors. """ test = self.MockTest("test_inCallback") test(self.result) self.assertEqual(len(self.result.errors), 1) self.assertTrue( self.result.errors[0][1].check(ZeroDivisionError), self.result.errors[0][1] ) PK Mb�Z�G�� � trial/test/moduleself.pynu �[��� # -*- test-case-name: twisted.trial.test.moduleself -*- from twisted.trial import unittest class Foo(unittest.SynchronousTestCase): def testFoo(self): pass PK Mb�Z�"h+ + trial/test/packages.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # """ Classes and functions used by L{twisted.trial.test.test_util} and L{twisted.trial.test.test_loader}. """ import os import sys # Python 3 has some funny import caching, which we don't want. # invalidate_caches clears it out for us. from importlib import invalidate_caches as invalidateImportCaches from twisted.trial import unittest testModule = """ from twisted.trial import unittest class FooTest(unittest.SynchronousTestCase): def testFoo(self): pass """ dosModule = testModule.replace("\n", "\r\n") testSample = """ '''This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. ''' import unittest as pyunit from twisted.trial import unittest class FooTest(unittest.SynchronousTestCase): def test_foo(self): pass def test_bar(self): pass class PyunitTest(pyunit.TestCase): def test_foo(self): pass def test_bar(self): pass class NotATest: def test_foo(self): pass class AlphabetTest(unittest.SynchronousTestCase): def test_a(self): pass def test_b(self): pass def test_c(self): pass """ testInheritanceSample = """ '''This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. ''' from twisted.trial import unittest class X: def test_foo(self): pass class A(unittest.SynchronousTestCase, X): pass class B(unittest.SynchronousTestCase, X): pass """ class PackageTest(unittest.SynchronousTestCase): files = [ ("badpackage/__init__.py", "frotz\n"), ("badpackage/test_module.py", ""), ("unimportablepackage/__init__.py", ""), ("unimportablepackage/test_module.py", "import notarealmoduleok\n"), ("package2/__init__.py", ""), ("package2/test_module.py", "import frotz\n"), ("package/__init__.py", ""), ("package/frotz.py", "frotz\n"), ("package/test_bad_module.py", 'raise ZeroDivisionError("fake error")'), ("package/test_dos_module.py", dosModule), ("package/test_import_module.py", "import frotz"), ("package/test_module.py", testModule), ("goodpackage/__init__.py", ""), ("goodpackage/test_sample.py", testSample), ("goodpackage/sub/__init__.py", ""), ("goodpackage/sub/test_sample.py", testSample), ("inheritancepackage/__init__.py", ""), ("inheritancepackage/test_x.py", testInheritanceSample), ] def _toModuleName(self, filename): name = os.path.splitext(filename)[0] segs = name.split("/") if segs[-1] == "__init__": segs = segs[:-1] return ".".join(segs) def getModules(self): """ Return matching module names for files listed in C{self.files}. """ return [self._toModuleName(filename) for (filename, code) in self.files] def cleanUpModules(self): modules = self.getModules() modules.sort() modules.reverse() for module in modules: try: del sys.modules[module] except KeyError: pass def createFiles(self, files, parentDir="."): for filename, contents in self.files: filename = os.path.join(parentDir, filename) self._createDirectory(filename) with open(filename, "w") as fd: fd.write(contents) def _createDirectory(self, filename): directory = os.path.dirname(filename) if not os.path.exists(directory): os.makedirs(directory) def setUp(self, parentDir=None): invalidateImportCaches() if parentDir is None: parentDir = self.mktemp() self.parent = parentDir self.createFiles(self.files, parentDir) def tearDown(self): self.cleanUpModules() class SysPathManglingTest(PackageTest): def setUp(self, parent=None): invalidateImportCaches() self.oldPath = sys.path[:] self.newPath = sys.path[:] if parent is None: parent = self.mktemp() PackageTest.setUp(self, parent) self.newPath.append(self.parent) self.mangleSysPath(self.newPath) def tearDown(self): PackageTest.tearDown(self) self.mangleSysPath(self.oldPath) def mangleSysPath(self, pathVar): sys.path[:] = pathVar PK Mb�Z� �i\� \� trial/test/test_tests.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for the behaviour of unit tests. Many tests in this module follow a simple pattern. A mixin is defined which includes test methods for a certain feature. The mixin is inherited from twice, once by a class also inheriting from SynchronousTestCase and once from a class inheriting from TestCase. These two subclasses are named like I{SynchronousFooTests} and I{AsynchronousFooTests}, where I{Foo} is related to the name of the mixin. Sometimes the mixin is defined in another module, along with the synchronous subclass. The mixin is imported into this module to define the asynchronous subclass. This pattern allows the same tests to be applied to the two base test case classes trial provides, ensuring their behavior is the same. Most new tests should be added in this pattern. Tests for functionality which is intentionally only provided by TestCase, not SynchronousTestCase, is excepted of course. """ import gc import sys import unittest as pyunit import weakref from io import StringIO from twisted.internet import defer, reactor from twisted.python.compat import _PYPY from twisted.python.reflect import namedAny from twisted.trial import reporter, runner, unittest, util from twisted.trial._asyncrunner import ( _clearSuite, _ForceGarbageCollectionDecorator, _iterateTests, ) from twisted.trial.test import erroneous from twisted.trial.test.test_suppression import SuppressionMixin class ResultsTestMixin: """ Provide useful APIs for test cases that are about test cases. """ def loadSuite(self, suite): """ Load tests from the given test case class and create a new reporter to use for running it. """ self.loader = pyunit.TestLoader() self.suite = self.loader.loadTestsFromTestCase(suite) self.reporter = reporter.TestResult() def test_setUp(self): """ test the setup """ self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(self.reporter.skips, []) def assertCount(self, numTests): """ Asserts that the test count is plausible """ self.assertEqual(self.suite.countTestCases(), numTests) self.suite(self.reporter) self.assertEqual(self.reporter.testsRun, numTests) class SuccessMixin: """ Tests for the reporting of successful tests in L{twisted.trial.unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.result = reporter.TestResult() def test_successful(self): """ A successful test, used by other tests. """ def assertSuccessful(self, test, result): """ Utility function -- assert there is one success and the state is plausible """ self.assertEqual(result.successes, 1) self.assertEqual(result.failures, []) self.assertEqual(result.errors, []) self.assertEqual(result.expectedFailures, []) self.assertEqual(result.unexpectedSuccesses, []) self.assertEqual(result.skips, []) def test_successfulIsReported(self): """ Test that when a successful test is run, it is reported as a success, and not as any other kind of result. """ test = self.__class__("test_successful") test.run(self.result) self.assertSuccessful(test, self.result) def test_defaultIsSuccessful(self): """ The test case type can be instantiated with no arguments, run, and reported as being successful. """ test = self.__class__() test.run(self.result) self.assertSuccessful(test, self.result) def test_noReference(self): """ Test that no reference is kept on a successful test. """ test = self.__class__("test_successful") ref = weakref.ref(test) test.run(self.result) self.assertSuccessful(test, self.result) del test gc.collect() self.assertIdentical(ref(), None) class SynchronousSuccessTests(SuccessMixin, unittest.SynchronousTestCase): """ Tests for the reporting of successful tests in the synchronous case. """ class AsynchronousSuccessTests(SuccessMixin, unittest.TestCase): """ Tests for the reporting of successful tests in the synchronous case. """ class SkipMethodsMixin(ResultsTestMixin): """ Tests for the reporting of skipping tests in L{twisted.trial.unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.loadSuite(self.Skipping) def test_counting(self): """ Assert that there are three tests. """ self.assertCount(3) def test_results(self): """ Running a suite in which all methods are individually set to skip produces a successful result with no recorded errors or failures, all the skipped methods recorded as skips, and no methods recorded as successes. """ self.suite(self.reporter) self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(len(self.reporter.skips), 3) self.assertEqual(self.reporter.successes, 0) def test_setUp(self): """ Running a suite in which all methods are skipped by C{setUp} raising L{SkipTest} produces a successful result with no recorded errors or failures, all skipped methods recorded as skips, and no methods recorded as successes. """ self.loadSuite(self.SkippingSetUp) self.suite(self.reporter) self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(len(self.reporter.skips), 2) self.assertEqual(self.reporter.successes, 0) def test_reasons(self): """ Test that reasons work """ self.suite(self.reporter) prefix = "test_" # whiteboxing reporter for test, reason in self.reporter.skips: self.assertEqual(test.shortDescription()[len(prefix) :], str(reason)) def test_deprecatedSkipWithoutReason(self): """ If a test method raises L{SkipTest} with no reason, a deprecation warning is emitted. """ self.loadSuite(self.DeprecatedReasonlessSkip) self.suite(self.reporter) warnings = self.flushWarnings([self.DeprecatedReasonlessSkip.test_1]) self.assertEqual(1, len(warnings)) self.assertEqual(DeprecationWarning, warnings[0]["category"]) self.assertEqual( "Do not raise unittest.SkipTest with no arguments! Give a reason " "for skipping tests!", warnings[0]["message"], ) class SynchronousSkipMethodTests(SkipMethodsMixin, unittest.SynchronousTestCase): """ Tests for the reporting of skipping tests in the synchronous case. See: L{twisted.trial.test.test_tests.SkipMethodsMixin} """ Skipping = namedAny("twisted.trial.test.skipping.SynchronousSkipping") SkippingSetUp = namedAny("twisted.trial.test.skipping.SynchronousSkippingSetUp") DeprecatedReasonlessSkip = namedAny( "twisted.trial.test.skipping.SynchronousDeprecatedReasonlessSkip" ) class AsynchronousSkipMethodTests(SkipMethodsMixin, unittest.TestCase): """ Tests for the reporting of skipping tests in the asynchronous case. See: L{twisted.trial.test.test_tests.SkipMethodsMixin} """ Skipping = namedAny("twisted.trial.test.skipping.AsynchronousSkipping") SkippingSetUp = namedAny("twisted.trial.test.skipping.AsynchronousSkippingSetUp") DeprecatedReasonlessSkip = namedAny( "twisted.trial.test.skipping.AsynchronousDeprecatedReasonlessSkip" ) class SkipClassesMixin(ResultsTestMixin): """ Test the class skipping features of L{twisted.trial.unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.loadSuite(self.SkippedClass) self.SkippedClass._setUpRan = False def test_counting(self): """ Skipped test methods still contribute to the total test count. """ self.assertCount(4) def test_setUpRan(self): """ The C{setUp} method is not called if the class is set to skip. """ self.suite(self.reporter) self.assertFalse(self.SkippedClass._setUpRan) def test_results(self): """ Skipped test methods don't cause C{wasSuccessful} to return C{False}, nor do they contribute to the C{errors} or C{failures} of the reporter, or to the count of successes. They do, however, add elements to the reporter's C{skips} list. """ self.suite(self.reporter) self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(len(self.reporter.skips), 4) self.assertEqual(self.reporter.successes, 0) def test_reasons(self): """ Test methods which raise L{unittest.SkipTest} or have their C{skip} attribute set to something are skipped. """ self.suite(self.reporter) expectedReasons = ["class", "skip2", "class", "class"] # whitebox reporter reasonsGiven = [reason for test, reason in self.reporter.skips] self.assertEqual(expectedReasons, reasonsGiven) class SynchronousSkipClassTests(SkipClassesMixin, unittest.SynchronousTestCase): """ Test the class skipping features in the synchronous case. See: L{twisted.trial.test.test_tests.SkipClassesMixin} """ SkippedClass = namedAny("twisted.trial.test.skipping.SynchronousSkippedClass") class AsynchronousSkipClassTests(SkipClassesMixin, unittest.TestCase): """ Test the class skipping features in the asynchronous case. See: L{twisted.trial.test.test_tests.SkipClassesMixin} """ SkippedClass = namedAny("twisted.trial.test.skipping.AsynchronousSkippedClass") class TodoMixin(ResultsTestMixin): """ Tests for the individual test method I{expected failure} features of L{twisted.trial.unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.loadSuite(self.Todo) def test_counting(self): """ Ensure that we've got three test cases. """ self.assertCount(3) def test_results(self): """ Running a suite in which all methods are individually marked as expected to fail produces a successful result with no recorded errors, failures, or skips, all methods which fail and were expected to fail recorded as C{expectedFailures}, and all methods which pass but which were expected to fail recorded as C{unexpectedSuccesses}. Additionally, no tests are recorded as successes. """ self.suite(self.reporter) self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(self.reporter.skips, []) self.assertEqual(len(self.reporter.expectedFailures), 2) self.assertEqual(len(self.reporter.unexpectedSuccesses), 1) self.assertEqual(self.reporter.successes, 0) def test_expectedFailures(self): """ Ensure that expected failures are handled properly. """ self.suite(self.reporter) expectedReasons = ["todo1", "todo2"] reasonsGiven = [r.reason for t, e, r in self.reporter.expectedFailures] self.assertEqual(expectedReasons, reasonsGiven) def test_unexpectedSuccesses(self): """ Ensure that unexpected successes are caught. """ self.suite(self.reporter) expectedReasons = ["todo3"] reasonsGiven = [r.reason for t, r in self.reporter.unexpectedSuccesses] self.assertEqual(expectedReasons, reasonsGiven) def test_expectedSetUpFailure(self): """ C{setUp} is excluded from the failure expectation defined by a C{todo} attribute on a test method. """ self.loadSuite(self.SetUpTodo) self.suite(self.reporter) self.assertFalse(self.reporter.wasSuccessful()) self.assertEqual(len(self.reporter.errors), 1) self.assertEqual(self.reporter.failures, []) self.assertEqual(self.reporter.skips, []) self.assertEqual(len(self.reporter.expectedFailures), 0) self.assertEqual(len(self.reporter.unexpectedSuccesses), 0) self.assertEqual(self.reporter.successes, 0) def test_expectedTearDownFailure(self): """ C{tearDown} is excluded from the failure expectation defined by a C{todo} attribute on a test method. """ self.loadSuite(self.TearDownTodo) self.suite(self.reporter) self.assertFalse(self.reporter.wasSuccessful()) self.assertEqual(len(self.reporter.errors), 1) self.assertEqual(self.reporter.failures, []) self.assertEqual(self.reporter.skips, []) self.assertEqual(len(self.reporter.expectedFailures), 0) # This seems strange, since tearDown raised an exception. However, the # test method did complete without error. The tearDown error is # reflected in the errors list, checked above. self.assertEqual(len(self.reporter.unexpectedSuccesses), 1) self.assertEqual(self.reporter.successes, 0) class SynchronousTodoTests(TodoMixin, unittest.SynchronousTestCase): """ Test the class skipping features in the synchronous case. See: L{twisted.trial.test.test_tests.TodoMixin} """ Todo = namedAny("twisted.trial.test.skipping.SynchronousTodo") SetUpTodo = namedAny("twisted.trial.test.skipping.SynchronousSetUpTodo") TearDownTodo = namedAny("twisted.trial.test.skipping.SynchronousTearDownTodo") class AsynchronousTodoTests(TodoMixin, unittest.TestCase): """ Test the class skipping features in the asynchronous case. See: L{twisted.trial.test.test_tests.TodoMixin} """ Todo = namedAny("twisted.trial.test.skipping.AsynchronousTodo") SetUpTodo = namedAny("twisted.trial.test.skipping.AsynchronousSetUpTodo") TearDownTodo = namedAny("twisted.trial.test.skipping.AsynchronousTearDownTodo") class ClassTodoMixin(ResultsTestMixin): """ Tests for the class-wide I{expected failure} features of L{twisted.trial.unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.loadSuite(self.TodoClass) def test_counting(self): """ Ensure that we've got four test cases. """ self.assertCount(4) def test_results(self): """ Running a suite in which an entire class is marked as expected to fail produces a successful result with no recorded errors, failures, or skips, all methods which fail and were expected to fail recorded as C{expectedFailures}, and all methods which pass but which were expected to fail recorded as C{unexpectedSuccesses}. Additionally, no tests are recorded as successes. """ self.suite(self.reporter) self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(self.reporter.skips, []) self.assertEqual(len(self.reporter.expectedFailures), 2) self.assertEqual(len(self.reporter.unexpectedSuccesses), 2) self.assertEqual(self.reporter.successes, 0) def test_expectedFailures(self): """ Ensure that expected failures are handled properly. """ self.suite(self.reporter) expectedReasons = ["method", "class"] reasonsGiven = [r.reason for t, e, r in self.reporter.expectedFailures] self.assertEqual(expectedReasons, reasonsGiven) def test_unexpectedSuccesses(self): """ Ensure that unexpected successes are caught. """ self.suite(self.reporter) expectedReasons = ["method", "class"] reasonsGiven = [r.reason for t, r in self.reporter.unexpectedSuccesses] self.assertEqual(expectedReasons, reasonsGiven) class SynchronousClassTodoTests(ClassTodoMixin, unittest.SynchronousTestCase): """ Tests for the class-wide I{expected failure} features in the synchronous case. See: L{twisted.trial.test.test_tests.ClassTodoMixin} """ TodoClass = namedAny("twisted.trial.test.skipping.SynchronousTodoClass") class AsynchronousClassTodoTests(ClassTodoMixin, unittest.TestCase): """ Tests for the class-wide I{expected failure} features in the asynchronous case. See: L{twisted.trial.test.test_tests.ClassTodoMixin} """ TodoClass = namedAny("twisted.trial.test.skipping.AsynchronousTodoClass") class StrictTodoMixin(ResultsTestMixin): """ Tests for the I{expected failure} features of L{twisted.trial.unittest.TestCase} in which the exact failure which is expected is indicated. """ def setUp(self): """ Setup our test case """ self.loadSuite(self.StrictTodo) def test_counting(self): """ Assert there are seven test cases """ self.assertCount(7) def test_results(self): """ A test method which is marked as expected to fail with a particular exception is only counted as an expected failure if it does fail with that exception, not if it fails with some other exception. """ self.suite(self.reporter) self.assertFalse(self.reporter.wasSuccessful()) self.assertEqual(len(self.reporter.errors), 2) self.assertEqual(len(self.reporter.failures), 1) self.assertEqual(len(self.reporter.expectedFailures), 3) self.assertEqual(len(self.reporter.unexpectedSuccesses), 1) self.assertEqual(self.reporter.successes, 0) self.assertEqual(self.reporter.skips, []) def test_expectedFailures(self): """ Ensure that expected failures are handled properly. """ self.suite(self.reporter) expectedReasons = ["todo1", "todo2", "todo5"] reasonsGotten = [r.reason for t, e, r in self.reporter.expectedFailures] self.assertEqual(expectedReasons, reasonsGotten) def test_unexpectedSuccesses(self): """ Ensure that unexpected successes are caught. """ self.suite(self.reporter) expectedReasons = [([RuntimeError], "todo7")] reasonsGotten = [ (r.errors, r.reason) for t, r in self.reporter.unexpectedSuccesses ] self.assertEqual(expectedReasons, reasonsGotten) class SynchronousStrictTodoTests(StrictTodoMixin, unittest.SynchronousTestCase): """ Tests for the expected failure case when the exact failure that is expected is indicated in the synchronous case See: L{twisted.trial.test.test_tests.StrictTodoMixin} """ StrictTodo = namedAny("twisted.trial.test.skipping.SynchronousStrictTodo") class AsynchronousStrictTodoTests(StrictTodoMixin, unittest.TestCase): """ Tests for the expected failure case when the exact failure that is expected is indicated in the asynchronous case See: L{twisted.trial.test.test_tests.StrictTodoMixin} """ StrictTodo = namedAny("twisted.trial.test.skipping.AsynchronousStrictTodo") class ReactorCleanupTests(unittest.SynchronousTestCase): """ Tests for cleanup and reporting of reactor event sources left behind by test methods. """ def setUp(self): """ Setup our test case """ self.result = reporter.Reporter(StringIO()) self.loader = runner.TestLoader() def test_leftoverSockets(self): """ Trial reports a L{util.DirtyReactorAggregateError} if a test leaves sockets behind. """ suite = self.loader.loadByName( "twisted.trial.test.erroneous.SocketOpenTest.test_socketsLeftOpen" ) suite.run(self.result) self.assertFalse(self.result.wasSuccessful()) # socket cleanup happens at end of class's tests. # all the tests in the class are successful, even if the suite # fails self.assertEqual(self.result.successes, 1) failure = self.result.errors[0][1] self.assertTrue(failure.check(util.DirtyReactorAggregateError)) def test_leftoverPendingCalls(self): """ Trial reports a L{util.DirtyReactorAggregateError} and fails the test if a test leaves a L{DelayedCall} hanging. """ suite = erroneous.ReactorCleanupTests("test_leftoverPendingCalls") suite.run(self.result) self.assertFalse(self.result.wasSuccessful()) failure = self.result.errors[0][1] self.assertEqual(self.result.successes, 0) self.assertTrue(failure.check(util.DirtyReactorAggregateError)) class FixtureMixin: """ Tests for fixture helper methods (e.g. setUp, tearDown). """ def setUp(self): """ Setup our test case """ self.reporter = reporter.Reporter() self.loader = pyunit.TestLoader() def test_brokenSetUp(self): """ When setUp fails, the error is recorded in the result object. """ suite = self.loader.loadTestsFromTestCase(self.TestFailureInSetUp) suite.run(self.reporter) self.assertTrue(len(self.reporter.errors) > 0) self.assertIsInstance(self.reporter.errors[0][1].value, erroneous.FoolishError) self.assertEqual(0, self.reporter.successes) def test_brokenTearDown(self): """ When tearDown fails, the error is recorded in the result object. """ suite = self.loader.loadTestsFromTestCase(self.TestFailureInTearDown) suite.run(self.reporter) errors = self.reporter.errors self.assertTrue(len(errors) > 0) self.assertIsInstance(errors[0][1].value, erroneous.FoolishError) self.assertEqual(0, self.reporter.successes) def test_tearDownRunsOnTestFailure(self): """ L{SynchronousTestCase.tearDown} runs when a test method fails. """ suite = self.loader.loadTestsFromTestCase(self.TestFailureButTearDownRuns) case = list(suite)[0] self.assertFalse(case.tornDown) suite.run(self.reporter) errors = self.reporter.errors self.assertTrue(len(errors) > 0) self.assertIsInstance(errors[0][1].value, erroneous.FoolishError) self.assertEqual(0, self.reporter.successes) self.assertTrue(case.tornDown) class SynchronousFixtureTests(FixtureMixin, unittest.SynchronousTestCase): """ Tests for broken fixture helper methods in the synchronous case See: L{twisted.trial.test.test_tests.FixtureMixin} """ TestFailureInSetUp = namedAny( "twisted.trial.test.erroneous.SynchronousTestFailureInSetUp" ) TestFailureInTearDown = namedAny( "twisted.trial.test.erroneous.SynchronousTestFailureInTearDown" ) TestFailureButTearDownRuns = namedAny( "twisted.trial.test.erroneous.SynchronousTestFailureButTearDownRuns" ) class AsynchronousFixtureTests(FixtureMixin, unittest.TestCase): """ Tests for broken fixture helper methods in the asynchronous case See: L{twisted.trial.test.test_tests.FixtureMixin} """ TestFailureInSetUp = namedAny( "twisted.trial.test.erroneous.AsynchronousTestFailureInSetUp" ) TestFailureInTearDown = namedAny( "twisted.trial.test.erroneous.AsynchronousTestFailureInTearDown" ) TestFailureButTearDownRuns = namedAny( "twisted.trial.test.erroneous.AsynchronousTestFailureButTearDownRuns" ) class AsynchronousSuppressionTests(SuppressionMixin, unittest.TestCase): """ Tests for the warning suppression features of L{twisted.trial.unittest.TestCase} See L{twisted.trial.test.test_suppression.SuppressionMixin} """ TestSetUpSuppression = namedAny( "twisted.trial.test.suppression.AsynchronousTestSetUpSuppression" ) TestTearDownSuppression = namedAny( "twisted.trial.test.suppression.AsynchronousTestTearDownSuppression" ) TestSuppression = namedAny( "twisted.trial.test.suppression.AsynchronousTestSuppression" ) TestSuppression2 = namedAny( "twisted.trial.test.suppression.AsynchronousTestSuppression2" ) class GCMixin: """ I provide a few mock tests that log setUp, tearDown, test execution and garbage collection. I'm used to test whether gc.collect gets called. """ class BasicTest(unittest.SynchronousTestCase): """ Mock test to run. """ def setUp(self): """ Mock setUp """ self._log("setUp") def test_foo(self): """ Mock test case """ self._log("test") def tearDown(self): """ Mock tear tearDown """ self._log("tearDown") def _log(self, msg): """ Log function """ self._collectCalled.append(msg) def collect(self): """Fake gc.collect""" self._log("collect") def setUp(self): """ Setup our test case """ self._collectCalled = [] self.BasicTest._log = self._log self._oldCollect = gc.collect gc.collect = self.collect def tearDown(self): """ Tear down the test """ gc.collect = self._oldCollect class GarbageCollectionDefaultTests(GCMixin, unittest.SynchronousTestCase): """ By default, tests should not force garbage collection. """ def test_collectNotDefault(self): """ By default, tests should not force garbage collection. """ test = self.BasicTest("test_foo") result = reporter.TestResult() test.run(result) self.assertEqual(self._collectCalled, ["setUp", "test", "tearDown"]) class GarbageCollectionTests(GCMixin, unittest.SynchronousTestCase): """ Test that, when force GC, it works. """ def test_collectCalled(self): """ test gc.collect is called before and after each test. """ test = GarbageCollectionTests.BasicTest("test_foo") test = _ForceGarbageCollectionDecorator(test) result = reporter.TestResult() test.run(result) self.assertEqual( self._collectCalled, ["collect", "setUp", "test", "tearDown", "collect"] ) class UnhandledDeferredTests(unittest.SynchronousTestCase): """ Test what happens when we have an unhandled deferred left around after a test. """ def setUp(self): """ Setup our test case """ from twisted.trial.test import weird # test_unhandledDeferred creates a cycle. we need explicit control of gc gc.disable() self.test1 = _ForceGarbageCollectionDecorator( weird.TestBleeding("test_unhandledDeferred") ) def test_isReported(self): """ Forcing garbage collection should cause unhandled Deferreds to be reported as errors. """ result = reporter.TestResult() self.test1(result) self.assertEqual( len(result.errors), 1, "Unhandled deferred passed without notice" ) @pyunit.skipIf(_PYPY, "GC works differently on PyPy.") def test_doesntBleed(self): """ Forcing garbage collection in the test should mean that there are no unreachable cycles immediately after the test completes. """ result = reporter.TestResult() self.test1(result) self.flushLoggedErrors() # test1 logs errors that get caught be us. # test1 created unreachable cycle. # it & all others should have been collected by now. n = len(gc.garbage) self.assertEqual(n, 0, "unreachable cycle still existed") # check that last gc.collect didn't log more errors x = self.flushLoggedErrors() self.assertEqual(len(x), 0, "Errors logged after gc.collect") def tearDown(self): """ Tear down the test """ gc.collect() gc.enable() self.flushLoggedErrors() class AddCleanupMixin: """ Test the addCleanup method of TestCase. """ def setUp(self): """ Setup our test case """ super().setUp() self.result = reporter.TestResult() self.test = self.AddCleanup() def test_addCleanupCalledIfSetUpFails(self): """ Callables added with C{addCleanup} are run even if setUp fails. """ self.test.setUp = self.test.brokenSetUp self.test.addCleanup(self.test.append, "foo") self.test.run(self.result) self.assertEqual(["setUp", "foo"], self.test.log) def test_addCleanupCalledIfSetUpSkips(self): """ Callables added with C{addCleanup} are run even if setUp raises L{SkipTest}. This allows test authors to reliably provide clean up code using C{addCleanup}. """ self.test.setUp = self.test.skippingSetUp self.test.addCleanup(self.test.append, "foo") self.test.run(self.result) self.assertEqual(["setUp", "foo"], self.test.log) def test_addCleanupCalledInReverseOrder(self): """ Callables added with C{addCleanup} should be called before C{tearDown} in reverse order of addition. """ self.test.addCleanup(self.test.append, "foo") self.test.addCleanup(self.test.append, "bar") self.test.run(self.result) self.assertEqual(["setUp", "runTest", "bar", "foo", "tearDown"], self.test.log) def test_errorInCleanupIsCaptured(self): """ Errors raised in cleanup functions should be treated like errors in C{tearDown}. They should be added as errors and fail the test. Skips, todos and failures are all treated as errors. """ self.test.addCleanup(self.test.fail, "foo") self.test.run(self.result) self.assertFalse(self.result.wasSuccessful()) self.assertEqual(1, len(self.result.errors)) [(test, error)] = self.result.errors self.assertEqual(test, self.test) self.assertEqual(error.getErrorMessage(), "foo") def test_cleanupsContinueRunningAfterError(self): """ If a cleanup raises an error then that does not stop the other cleanups from being run. """ self.test.addCleanup(self.test.append, "foo") self.test.addCleanup(self.test.fail, "bar") self.test.run(self.result) self.assertEqual(["setUp", "runTest", "foo", "tearDown"], self.test.log) self.assertEqual(1, len(self.result.errors)) [(test, error)] = self.result.errors self.assertEqual(test, self.test) self.assertEqual(error.getErrorMessage(), "bar") def test_multipleErrorsReported(self): """ If more than one cleanup fails, then the test should fail with more than one error. """ self.test.addCleanup(self.test.fail, "foo") self.test.addCleanup(self.test.fail, "bar") self.test.run(self.result) self.assertEqual(["setUp", "runTest", "tearDown"], self.test.log) self.assertEqual(2, len(self.result.errors)) [(test1, error1), (test2, error2)] = self.result.errors self.assertEqual(test1, self.test) self.assertEqual(test2, self.test) self.assertEqual(error1.getErrorMessage(), "bar") self.assertEqual(error2.getErrorMessage(), "foo") class SynchronousAddCleanupTests(AddCleanupMixin, unittest.SynchronousTestCase): """ Test the addCleanup method of TestCase in the synchronous case See: L{twisted.trial.test.test_tests.AddCleanupMixin} """ AddCleanup = namedAny("twisted.trial.test.skipping.SynchronousAddCleanup") class AsynchronousAddCleanupTests(AddCleanupMixin, unittest.TestCase): """ Test the addCleanup method of TestCase in the asynchronous case See: L{twisted.trial.test.test_tests.AddCleanupMixin} """ AddCleanup = namedAny("twisted.trial.test.skipping.AsynchronousAddCleanup") def test_addCleanupWaitsForDeferreds(self): """ If an added callable returns a L{Deferred}, then the test should wait until that L{Deferred} has fired before running the next cleanup method. """ def cleanup(message): d = defer.Deferred() reactor.callLater(0, d.callback, message) return d.addCallback(self.test.append) self.test.addCleanup(self.test.append, "foo") self.test.addCleanup(cleanup, "bar") self.test.run(self.result) self.assertEqual(["setUp", "runTest", "bar", "foo", "tearDown"], self.test.log) class SuiteClearingMixin: """ Tests for our extension that allows us to clear out a L{TestSuite}. """ def test_clearSuite(self): """ Calling L{_clearSuite} on a populated L{TestSuite} removes all tests. """ suite = unittest.TestSuite() suite.addTest(self.TestCase()) # Double check that the test suite actually has something in it. self.assertEqual(1, suite.countTestCases()) _clearSuite(suite) self.assertEqual(0, suite.countTestCases()) def test_clearPyunitSuite(self): """ Calling L{_clearSuite} on a populated standard library L{TestSuite} removes all tests. This test is important since C{_clearSuite} operates by mutating internal variables. """ suite = pyunit.TestSuite() suite.addTest(self.TestCase()) # Double check that the test suite actually has something in it. self.assertEqual(1, suite.countTestCases()) _clearSuite(suite) self.assertEqual(0, suite.countTestCases()) class SynchronousSuiteClearingTests(SuiteClearingMixin, unittest.SynchronousTestCase): """ Tests for our extension that allows us to clear out a L{TestSuite} in the synchronous case. See L{twisted.trial.test.test_tests.SuiteClearingMixin} """ TestCase = unittest.SynchronousTestCase class AsynchronousSuiteClearingTests(SuiteClearingMixin, unittest.TestCase): """ Tests for our extension that allows us to clear out a L{TestSuite} in the asynchronous case. See L{twisted.trial.test.test_tests.SuiteClearingMixin} """ TestCase = unittest.TestCase class TestDecoratorMixin: """ Tests for our test decoration features. """ def assertTestsEqual(self, observed, expected): """ Assert that the given decorated tests are equal. """ self.assertEqual(observed.__class__, expected.__class__, "Different class") observedOriginal = getattr(observed, "_originalTest", None) expectedOriginal = getattr(expected, "_originalTest", None) self.assertIdentical(observedOriginal, expectedOriginal) if observedOriginal is expectedOriginal is None: self.assertIdentical(observed, expected) def assertSuitesEqual(self, observed, expected): """ Assert that the given test suites with decorated tests are equal. """ self.assertEqual(observed.__class__, expected.__class__, "Different class") self.assertEqual( len(observed._tests), len(expected._tests), "Different number of tests." ) for observedTest, expectedTest in zip(observed._tests, expected._tests): if getattr(observedTest, "_tests", None) is not None: self.assertSuitesEqual(observedTest, expectedTest) else: self.assertTestsEqual(observedTest, expectedTest) def test_usesAdaptedReporterWithRun(self): """ For decorated tests, C{run} uses a result adapter that preserves the test decoration for calls to C{addError}, C{startTest} and the like. See L{reporter._AdaptedReporter}. """ test = self.TestCase() decoratedTest = unittest.TestDecorator(test) # Move to top in ticket #5964: from twisted.trial.test.test_reporter import LoggingReporter result = LoggingReporter() decoratedTest.run(result) self.assertTestsEqual(result.test, decoratedTest) def test_usesAdaptedReporterWithCall(self): """ For decorated tests, C{__call__} uses a result adapter that preserves the test decoration for calls to C{addError}, C{startTest} and the like. See L{reporter._AdaptedReporter}. """ test = self.TestCase() decoratedTest = unittest.TestDecorator(test) # Move to top in ticket #5964: from twisted.trial.test.test_reporter import LoggingReporter result = LoggingReporter() decoratedTest(result) self.assertTestsEqual(result.test, decoratedTest) def test_decorateSingleTest(self): """ Calling L{decorate} on a single test case returns the test case decorated with the provided decorator. """ test = self.TestCase() decoratedTest = unittest.decorate(test, unittest.TestDecorator) self.assertTestsEqual(unittest.TestDecorator(test), decoratedTest) def test_decorateTestSuite(self): """ Calling L{decorate} on a test suite will return a test suite with each test decorated with the provided decorator. """ test = self.TestCase() suite = unittest.TestSuite([test]) decoratedTest = unittest.decorate(suite, unittest.TestDecorator) self.assertSuitesEqual( decoratedTest, unittest.TestSuite([unittest.TestDecorator(test)]) ) def test_decorateInPlaceMutatesOriginal(self): """ Calling L{decorate} on a test suite will mutate the original suite. """ test = self.TestCase() suite = unittest.TestSuite([test]) decoratedTest = unittest.decorate(suite, unittest.TestDecorator) self.assertSuitesEqual( decoratedTest, unittest.TestSuite([unittest.TestDecorator(test)]) ) self.assertSuitesEqual( suite, unittest.TestSuite([unittest.TestDecorator(test)]) ) def test_decorateTestSuiteReferences(self): """ When decorating a test suite in-place, the number of references to the test objects in that test suite should stay the same. Previously, L{unittest.decorate} recreated a test suite, so the original suite kept references to the test objects. This test is here to ensure the problem doesn't reappear again. """ getrefcount = getattr(sys, "getrefcount", None) if getrefcount is None: # For example non CPython like _PYPY. raise unittest.SkipTest("getrefcount not supported on this platform") test = self.TestCase() suite = unittest.TestSuite([test]) count1 = getrefcount(test) unittest.decorate(suite, unittest.TestDecorator) count2 = getrefcount(test) self.assertEqual(count1, count2) def test_decorateNestedTestSuite(self): """ Calling L{decorate} on a test suite with nested suites will return a test suite that maintains the same structure, but with all tests decorated. """ test = self.TestCase() suite = unittest.TestSuite([unittest.TestSuite([test])]) decoratedTest = unittest.decorate(suite, unittest.TestDecorator) expected = unittest.TestSuite( [unittest.TestSuite([unittest.TestDecorator(test)])] ) self.assertSuitesEqual(decoratedTest, expected) def test_decorateDecoratedSuite(self): """ Calling L{decorate} on a test suite with already-decorated tests decorates all of the tests in the suite again. """ test = self.TestCase() decoratedTest = unittest.decorate(test, unittest.TestDecorator) redecoratedTest = unittest.decorate(decoratedTest, unittest.TestDecorator) self.assertTestsEqual(redecoratedTest, unittest.TestDecorator(decoratedTest)) def test_decoratePreservesSuite(self): """ Tests can be in non-standard suites. L{decorate} preserves the non-standard suites when it decorates the tests. """ test = self.TestCase() suite = runner.DestructiveTestSuite([test]) decorated = unittest.decorate(suite, unittest.TestDecorator) self.assertSuitesEqual( decorated, runner.DestructiveTestSuite([unittest.TestDecorator(test)]) ) class SynchronousTestDecoratorTests(TestDecoratorMixin, unittest.SynchronousTestCase): """ Tests for our test decoration features in the synchronous case. See L{twisted.trial.test.test_tests.TestDecoratorMixin} """ TestCase = unittest.SynchronousTestCase class AsynchronousTestDecoratorTests(TestDecoratorMixin, unittest.TestCase): """ Tests for our test decoration features in the asynchronous case. See L{twisted.trial.test.test_tests.TestDecoratorMixin} """ TestCase = unittest.TestCase class MonkeyPatchMixin: """ Tests for the patch() helper method in L{unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.originalValue = "original" self.patchedValue = "patched" self.objectToPatch = self.originalValue self.test = self.TestCase() def test_patch(self): """ Calling C{patch()} on a test monkey patches the specified object and attribute. """ self.test.patch(self, "objectToPatch", self.patchedValue) self.assertEqual(self.objectToPatch, self.patchedValue) def test_patchRestoredAfterRun(self): """ Any monkey patches introduced by a test using C{patch()} are reverted after the test has run. """ self.test.patch(self, "objectToPatch", self.patchedValue) self.test.run(reporter.Reporter()) self.assertEqual(self.objectToPatch, self.originalValue) def test_revertDuringTest(self): """ C{patch()} return a L{monkey.MonkeyPatcher} object that can be used to restore the original values before the end of the test. """ patch = self.test.patch(self, "objectToPatch", self.patchedValue) patch.restore() self.assertEqual(self.objectToPatch, self.originalValue) def test_revertAndRepatch(self): """ The returned L{monkey.MonkeyPatcher} object can re-apply the patch during the test run. """ patch = self.test.patch(self, "objectToPatch", self.patchedValue) patch.restore() patch.patch() self.assertEqual(self.objectToPatch, self.patchedValue) def test_successivePatches(self): """ Successive patches are applied and reverted just like a single patch. """ self.test.patch(self, "objectToPatch", self.patchedValue) self.assertEqual(self.objectToPatch, self.patchedValue) self.test.patch(self, "objectToPatch", "second value") self.assertEqual(self.objectToPatch, "second value") self.test.run(reporter.Reporter()) self.assertEqual(self.objectToPatch, self.originalValue) class SynchronousMonkeyPatchTests(MonkeyPatchMixin, unittest.SynchronousTestCase): """ Tests for the patch() helper method in the synchronous case. See L{twisted.trial.test.test_tests.MonkeyPatchMixin} """ TestCase = unittest.SynchronousTestCase class AsynchronousMonkeyPatchTests(MonkeyPatchMixin, unittest.TestCase): """ Tests for the patch() helper method in the asynchronous case. See L{twisted.trial.test.test_tests.MonkeyPatchMixin} """ TestCase = unittest.TestCase class IterateTestsMixin: """ L{_iterateTests} returns a list of all test cases in a test suite or test case. """ def test_iterateTestCase(self): """ L{_iterateTests} on a single test case returns a list containing that test case. """ test = self.TestCase() self.assertEqual([test], list(_iterateTests(test))) def test_iterateSingletonTestSuite(self): """ L{_iterateTests} on a test suite that contains a single test case returns a list containing that test case. """ test = self.TestCase() suite = runner.TestSuite([test]) self.assertEqual([test], list(_iterateTests(suite))) def test_iterateNestedTestSuite(self): """ L{_iterateTests} returns tests that are in nested test suites. """ test = self.TestCase() suite = runner.TestSuite([runner.TestSuite([test])]) self.assertEqual([test], list(_iterateTests(suite))) def test_iterateIsLeftToRightDepthFirst(self): """ L{_iterateTests} returns tests in left-to-right, depth-first order. """ test = self.TestCase() suite = runner.TestSuite([runner.TestSuite([test]), self]) self.assertEqual([test, self], list(_iterateTests(suite))) class SynchronousIterateTestsTests(IterateTestsMixin, unittest.SynchronousTestCase): """ Check that L{_iterateTests} returns a list of all test cases in a test suite or test case for synchronous tests. See L{twisted.trial.test.test_tests.IterateTestsMixin} """ TestCase = unittest.SynchronousTestCase class AsynchronousIterateTestsTests(IterateTestsMixin, unittest.TestCase): """ Check that L{_iterateTests} returns a list of all test cases in a test suite or test case for asynchronous tests. See L{twisted.trial.test.test_tests.IterateTestsMixin} """ TestCase = unittest.TestCase class TrialGeneratorFunctionTests(unittest.SynchronousTestCase): """ Tests for generator function methods in test cases. """ def test_errorOnGeneratorFunction(self): """ In a TestCase, a test method which is a generator function is reported as an error, as such a method will never run assertions. """ class GeneratorTestCase(unittest.TestCase): """ A fake TestCase for testing purposes. """ def test_generator(self): """ A method which is also a generator function, for testing purposes. """ self.fail("this should never be reached") yield testCase = GeneratorTestCase("test_generator") result = reporter.TestResult() testCase.run(result) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertIn( "GeneratorTestCase.test_generator", result.errors[0][1].value.args[0] ) self.assertIn( "GeneratorTestCase testMethod=test_generator", result.errors[0][1].value.args[0], ) self.assertIn( "is a generator function and therefore will never run", result.errors[0][1].value.args[0], ) def test_synchronousTestCaseErrorOnGeneratorFunction(self): """ In a SynchronousTestCase, a test method which is a generator function is reported as an error, as such a method will never run assertions. """ class GeneratorSynchronousTestCase(unittest.SynchronousTestCase): """ A fake SynchronousTestCase for testing purposes. """ def test_generator(self): """ A method which is also a generator function, for testing purposes. """ self.fail("this should never be reached") yield testCase = GeneratorSynchronousTestCase("test_generator") result = reporter.TestResult() testCase.run(result) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertIn( "GeneratorSynchronousTestCase.test_generator", result.errors[0][1].value.args[0], ) self.assertIn( "GeneratorSynchronousTestCase testMethod=test_generator", result.errors[0][1].value.args[0], ) self.assertIn( "is a generator function and therefore will never run", result.errors[0][1].value.args[0], ) PK Mb�Z�=� � trial/test/test_keyboard.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for interrupting tests with Control-C. """ from io import StringIO from twisted.trial import reporter, runner, unittest class TrialTest(unittest.SynchronousTestCase): def setUp(self): self.output = StringIO() self.reporter = reporter.TestResult() self.loader = runner.TestLoader() class InterruptInTestTests(TrialTest): class InterruptedTest(unittest.TestCase): def test_02_raiseInterrupt(self): raise KeyboardInterrupt def test_01_doNothing(self): pass def test_03_doNothing(self): InterruptInTestTests.test_03_doNothing_run = True def setUp(self): super().setUp() self.suite = self.loader.loadClass(InterruptInTestTests.InterruptedTest) InterruptInTestTests.test_03_doNothing_run = None def test_setUpOK(self): self.assertEqual(3, self.suite.countTestCases()) self.assertEqual(0, self.reporter.testsRun) self.assertFalse(self.reporter.shouldStop) def test_interruptInTest(self): runner.TrialSuite([self.suite]).run(self.reporter) self.assertTrue(self.reporter.shouldStop) self.assertEqual(2, self.reporter.testsRun) self.assertFalse( InterruptInTestTests.test_03_doNothing_run, "test_03_doNothing ran." ) class InterruptInSetUpTests(TrialTest): testsRun = 0 class InterruptedTest(unittest.TestCase): def setUp(self): if InterruptInSetUpTests.testsRun > 0: raise KeyboardInterrupt def test_01(self): InterruptInSetUpTests.testsRun += 1 def test_02(self): InterruptInSetUpTests.testsRun += 1 InterruptInSetUpTests.test_02_run = True def setUp(self): super().setUp() self.suite = self.loader.loadClass(InterruptInSetUpTests.InterruptedTest) InterruptInSetUpTests.test_02_run = False InterruptInSetUpTests.testsRun = 0 def test_setUpOK(self): self.assertEqual(0, InterruptInSetUpTests.testsRun) self.assertEqual(2, self.suite.countTestCases()) self.assertEqual(0, self.reporter.testsRun) self.assertFalse(self.reporter.shouldStop) def test_interruptInSetUp(self): runner.TrialSuite([self.suite]).run(self.reporter) self.assertTrue(self.reporter.shouldStop) self.assertEqual(2, self.reporter.testsRun) self.assertFalse(InterruptInSetUpTests.test_02_run, "test_02 ran") class InterruptInTearDownTests(TrialTest): testsRun = 0 class InterruptedTest(unittest.TestCase): def tearDown(self): if InterruptInTearDownTests.testsRun > 0: raise KeyboardInterrupt def test_01(self): InterruptInTearDownTests.testsRun += 1 def test_02(self): InterruptInTearDownTests.testsRun += 1 InterruptInTearDownTests.test_02_run = True def setUp(self): super().setUp() self.suite = self.loader.loadClass(InterruptInTearDownTests.InterruptedTest) InterruptInTearDownTests.testsRun = 0 InterruptInTearDownTests.test_02_run = False def test_setUpOK(self): self.assertEqual(0, InterruptInTearDownTests.testsRun) self.assertEqual(2, self.suite.countTestCases()) self.assertEqual(0, self.reporter.testsRun) self.assertFalse(self.reporter.shouldStop) def test_interruptInTearDown(self): runner.TrialSuite([self.suite]).run(self.reporter) self.assertEqual(1, self.reporter.testsRun) self.assertTrue(self.reporter.shouldStop) self.assertFalse(InterruptInTearDownTests.test_02_run, "test_02 ran") PK Mb�Z�}[�� � trial/test/test_plugins.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # Maintainer: Jonathan Lange """ Tests for L{twisted.plugins.twisted_trial}. """ from twisted.plugin import getPlugins from twisted.trial import unittest from twisted.trial.itrial import IReporter class PluginsTests(unittest.SynchronousTestCase): """ Tests for Trial's reporter plugins. """ def getPluginsByLongOption(self, longOption): """ Return the Trial reporter plugin with the given long option. If more than one is found, raise ValueError. If none are found, raise IndexError. """ plugins = [ plugin for plugin in getPlugins(IReporter) if plugin.longOpt == longOption ] if len(plugins) > 1: raise ValueError( "More than one plugin found with long option %r: %r" % (longOption, plugins) ) return plugins[0] def test_subunitPlugin(self): """ One of the reporter plugins is the subunit reporter plugin. """ subunitPlugin = self.getPluginsByLongOption("subunit") self.assertEqual("Subunit Reporter", subunitPlugin.name) self.assertEqual("twisted.trial.reporter", subunitPlugin.module) self.assertEqual("subunit", subunitPlugin.longOpt) self.assertIdentical(None, subunitPlugin.shortOpt) self.assertEqual("SubunitReporter", subunitPlugin.klass) PK Mb�Z�㽂 � trial/test/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Unit tests for the Trial unit-testing framework. """ PK Mb�Z����� � trial/_synctest.pynu �[��� # -*- test-case-name: twisted.trial.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Things likely to be used by writers of unit tests. Maintainer: Jonathan Lange """ import inspect import os import sys import tempfile import types import unittest as pyunit import warnings from dis import findlinestarts as _findlinestarts from typing import Optional, Tuple # Python 2.7 and higher has skip support built-in from unittest import SkipTest from twisted.internet.defer import ensureDeferred from twisted.python import failure, log, monkey from twisted.python.deprecate import ( DEPRECATION_WARNING_FORMAT, getDeprecationWarningString, getVersionString, warnAboutFunction, ) from twisted.python.reflect import fullyQualifiedName from twisted.python.util import runWithWarningsSuppressed from twisted.trial import itrial, util class FailTest(AssertionError): """ Raised to indicate the current test has failed to pass. """ class Todo: """ Internal object used to mark a L{TestCase} as 'todo'. Tests marked 'todo' are reported differently in Trial L{TestResult}s. If todo'd tests fail, they do not fail the suite and the errors are reported in a separate category. If todo'd tests succeed, Trial L{TestResult}s will report an unexpected success. """ def __init__(self, reason, errors=None): """ @param reason: A string explaining why the test is marked 'todo' @param errors: An iterable of exception types that the test is expected to raise. If one of these errors is raised by the test, it will be trapped. Raising any other kind of error will fail the test. If L{None} is passed, then all errors will be trapped. """ self.reason = reason self.errors = errors def __repr__(self) -> str: return f"<Todo reason={self.reason!r} errors={self.errors!r}>" def expected(self, failure): """ @param failure: A L{twisted.python.failure.Failure}. @return: C{True} if C{failure} is expected, C{False} otherwise. """ if self.errors is None: return True for error in self.errors: if failure.check(error): return True return False def makeTodo(value): """ Return a L{Todo} object built from C{value}. If C{value} is a string, return a Todo that expects any exception with C{value} as a reason. If C{value} is a tuple, the second element is used as the reason and the first element as the excepted error(s). @param value: A string or a tuple of C{(errors, reason)}, where C{errors} is either a single exception class or an iterable of exception classes. @return: A L{Todo} object. """ if isinstance(value, str): return Todo(reason=value) if isinstance(value, tuple): errors, reason = value try: errors = list(errors) except TypeError: errors = [errors] return Todo(reason=reason, errors=errors) class _Warning: """ A L{_Warning} instance represents one warning emitted through the Python warning system (L{warnings}). This is used to insulate callers of L{_collectWarnings} from changes to the Python warnings system which might otherwise require changes to the warning objects that function passes to the observer object it accepts. @ivar message: The string which was passed as the message parameter to L{warnings.warn}. @ivar category: The L{Warning} subclass which was passed as the category parameter to L{warnings.warn}. @ivar filename: The name of the file containing the definition of the code object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. @ivar lineno: The source line associated with the active instruction of the code object object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. """ def __init__(self, message, category, filename, lineno): self.message = message self.category = category self.filename = filename self.lineno = lineno def _setWarningRegistryToNone(modules): """ Disable the per-module cache for every module found in C{modules}, typically C{sys.modules}. @param modules: Dictionary of modules, typically sys.module dict """ for v in list(modules.values()): if v is not None: try: v.__warningregistry__ = None except BaseException: # Don't specify a particular exception type to handle in case # some wacky object raises some wacky exception in response to # the setattr attempt. pass def _collectWarnings(observeWarning, f, *args, **kwargs): """ Call C{f} with C{args} positional arguments and C{kwargs} keyword arguments and collect all warnings which are emitted as a result in a list. @param observeWarning: A callable which will be invoked with a L{_Warning} instance each time a warning is emitted. @return: The return value of C{f(*args, **kwargs)}. """ def showWarning(message, category, filename, lineno, file=None, line=None): assert isinstance(message, Warning) observeWarning(_Warning(str(message), category, filename, lineno)) # Disable the per-module cache for every module otherwise if the warning # which the caller is expecting us to collect was already emitted it won't # be re-emitted by the call to f which happens below. _setWarningRegistryToNone(sys.modules) origFilters = warnings.filters[:] origShow = warnings.showwarning warnings.simplefilter("always") try: warnings.showwarning = showWarning result = f(*args, **kwargs) finally: warnings.filters[:] = origFilters warnings.showwarning = origShow return result class UnsupportedTrialFeature(Exception): """A feature of twisted.trial was used that pyunit cannot support.""" class PyUnitResultAdapter: """ Wrap a C{TestResult} from the standard library's C{unittest} so that it supports the extended result types from Trial, and also supports L{twisted.python.failure.Failure}s being passed to L{addError} and L{addFailure}. """ def __init__(self, original): """ @param original: A C{TestResult} instance from C{unittest}. """ self.original = original def _exc_info(self, err): return util.excInfoOrFailureToExcInfo(err) def startTest(self, method): self.original.startTest(method) def stopTest(self, method): self.original.stopTest(method) def addFailure(self, test, fail): self.original.addFailure(test, self._exc_info(fail)) def addError(self, test, error): self.original.addError(test, self._exc_info(error)) def _unsupported(self, test, feature, info): self.original.addFailure( test, (UnsupportedTrialFeature, UnsupportedTrialFeature(feature, info), None), ) def addSkip(self, test, reason): """ Report the skip as a failure. """ self.original.addSkip(test, reason) def addUnexpectedSuccess(self, test, todo=None): """ Report the unexpected success as a failure. """ self._unsupported(test, "unexpected success", todo) def addExpectedFailure(self, test, error): """ Report the expected failure (i.e. todo) as a failure. """ self._unsupported(test, "expected failure", error) def addSuccess(self, test): self.original.addSuccess(test) def upDownError(self, method, error, warn, printStatus): pass class _AssertRaisesContext: """ A helper for implementing C{assertRaises}. This is a context manager and a helper method to support the non-context manager version of C{assertRaises}. @ivar _testCase: See C{testCase} parameter of C{__init__} @ivar _expected: See C{expected} parameter of C{__init__} @ivar _returnValue: The value returned by the callable being tested (only when not being used as a context manager). @ivar _expectedName: A short string describing the expected exception (usually the name of the exception class). @ivar exception: The exception which was raised by the function being tested (if it raised one). """ def __init__(self, testCase, expected): """ @param testCase: The L{TestCase} instance which is used to raise a test-failing exception when that is necessary. @param expected: The exception type expected to be raised. """ self._testCase = testCase self._expected = expected self._returnValue = None try: self._expectedName = self._expected.__name__ except AttributeError: self._expectedName = str(self._expected) def _handle(self, obj): """ Call the given object using this object as a context manager. @param obj: The object to call and which is expected to raise some exception. @type obj: L{object} @return: Whatever exception is raised by C{obj()}. @rtype: L{BaseException} """ with self as context: self._returnValue = obj() return context.exception def __enter__(self): return self def __exit__(self, exceptionType, exceptionValue, traceback): """ Check exit exception against expected exception. """ # No exception raised. if exceptionType is None: self._testCase.fail( "{} not raised ({} returned)".format( self._expectedName, self._returnValue ) ) if not isinstance(exceptionValue, exceptionType): # Support some Python 2.6 ridiculousness. Exceptions raised using # the C API appear here as the arguments you might pass to the # exception class to create an exception instance. So... do that # to turn them into the instances. if isinstance(exceptionValue, tuple): exceptionValue = exceptionType(*exceptionValue) else: exceptionValue = exceptionType(exceptionValue) # Store exception so that it can be access from context. self.exception = exceptionValue # Wrong exception raised. if not issubclass(exceptionType, self._expected): reason = failure.Failure(exceptionValue, exceptionType, traceback) self._testCase.fail( "{} raised instead of {}:\n {}".format( fullyQualifiedName(exceptionType), self._expectedName, reason.getTraceback(), ), ) # All good. return True class _Assertions(pyunit.TestCase): """ Replaces many of the built-in TestCase assertions. In general, these assertions provide better error messages and are easier to use in callbacks. """ def fail(self, msg=None): """ Absolutely fail the test. Do not pass go, do not collect $200. @param msg: the message that will be displayed as the reason for the failure """ raise self.failureException(msg) def assertFalse(self, condition, msg=None): """ Fail the test if C{condition} evaluates to True. @param condition: any object that defines __nonzero__ """ super().assertFalse(condition, msg) return condition assertNot = assertFalse failUnlessFalse = assertFalse failIf = assertFalse def assertTrue(self, condition, msg=None): """ Fail the test if C{condition} evaluates to False. @param condition: any object that defines __nonzero__ """ super().assertTrue(condition, msg) return condition assert_ = assertTrue failUnlessTrue = assertTrue failUnless = assertTrue def assertRaises(self, exception, f=None, *args, **kwargs): """ Fail the test unless calling the function C{f} with the given C{args} and C{kwargs} raises C{exception}. The failure will report the traceback and call stack of the unexpected exception. @param exception: exception type that is to be expected @param f: the function to call @return: If C{f} is L{None}, a context manager which will make an assertion about the exception raised from the suite it manages. If C{f} is not L{None}, the exception raised by C{f}. @raise self.failureException: Raised if the function call does not raise an exception or if it raises an exception of a different type. """ context = _AssertRaisesContext(self, exception) if f is None: return context return context._handle(lambda: f(*args, **kwargs)) # unittest.TestCase.assertRaises() is defined with 4 arguments # but we define it with 5 arguments. So we need to tell mypy # to ignore the following assignment to failUnlessRaises failUnlessRaises = assertRaises # type: ignore[assignment] def assertEqual(self, first, second, msg=None): """ Fail the test if C{first} and C{second} are not equal. @param msg: A string describing the failure that's included in the exception. """ super().assertEqual(first, second, msg) return first failUnlessEqual = assertEqual failUnlessEquals = assertEqual assertEquals = assertEqual def assertIs(self, first, second, msg=None): """ Fail the test if C{first} is not C{second}. This is an obect-identity-equality test, not an object equality (i.e. C{__eq__}) test. @param msg: if msg is None, then the failure message will be '%r is not %r' % (first, second) """ if first is not second: raise self.failureException(msg or f"{first!r} is not {second!r}") return first failUnlessIdentical = assertIs assertIdentical = assertIs def assertIsNot(self, first, second, msg=None): """ Fail the test if C{first} is C{second}. This is an obect-identity-equality test, not an object equality (i.e. C{__eq__}) test. @param msg: if msg is None, then the failure message will be '%r is %r' % (first, second) """ if first is second: raise self.failureException(msg or f"{first!r} is {second!r}") return first failIfIdentical = assertIsNot assertNotIdentical = assertIsNot def assertNotEqual(self, first, second, msg=None): """ Fail the test if C{first} == C{second}. @param msg: if msg is None, then the failure message will be '%r == %r' % (first, second) """ if not first != second: raise self.failureException(msg or f"{first!r} == {second!r}") return first assertNotEquals = assertNotEqual failIfEquals = assertNotEqual failIfEqual = assertNotEqual def assertIn(self, containee, container, msg=None): """ Fail the test if C{containee} is not found in C{container}. @param containee: the value that should be in C{container} @param container: a sequence type, or in the case of a mapping type, will follow semantics of 'if key in dict.keys()' @param msg: if msg is None, then the failure message will be '%r not in %r' % (first, second) """ if containee not in container: raise self.failureException(msg or f"{containee!r} not in {container!r}") return containee failUnlessIn = assertIn def assertNotIn(self, containee, container, msg=None): """ Fail the test if C{containee} is found in C{container}. @param containee: the value that should not be in C{container} @param container: a sequence type, or in the case of a mapping type, will follow semantics of 'if key in dict.keys()' @param msg: if msg is None, then the failure message will be '%r in %r' % (first, second) """ if containee in container: raise self.failureException(msg or f"{containee!r} in {container!r}") return containee failIfIn = assertNotIn def assertNotAlmostEqual(self, first, second, places=7, msg=None, delta=None): """ Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero. @note: decimal places (from zero) is usually not the same as significant digits (measured from the most significant digit). @note: included for compatibility with PyUnit test cases """ if round(second - first, places) == 0: raise self.failureException( msg or f"{first!r} == {second!r} within {places!r} places" ) return first assertNotAlmostEquals = assertNotAlmostEqual failIfAlmostEqual = assertNotAlmostEqual failIfAlmostEquals = assertNotAlmostEqual def assertAlmostEqual(self, first, second, places=7, msg=None, delta=None): """ Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero. @note: decimal places (from zero) is usually not the same as significant digits (measured from the most significant digit). @note: included for compatibility with PyUnit test cases """ if round(second - first, places) != 0: raise self.failureException( msg or f"{first!r} != {second!r} within {places!r} places" ) return first assertAlmostEquals = assertAlmostEqual failUnlessAlmostEqual = assertAlmostEqual def assertApproximates(self, first, second, tolerance, msg=None): """ Fail if C{first} - C{second} > C{tolerance} @param msg: if msg is None, then the failure message will be '%r ~== %r' % (first, second) """ if abs(first - second) > tolerance: raise self.failureException(msg or f"{first} ~== {second}") return first failUnlessApproximates = assertApproximates def assertSubstring(self, substring, astring, msg=None): """ Fail if C{substring} does not exist within C{astring}. """ return self.failUnlessIn(substring, astring, msg) failUnlessSubstring = assertSubstring def assertNotSubstring(self, substring, astring, msg=None): """ Fail if C{astring} contains C{substring}. """ return self.failIfIn(substring, astring, msg) failIfSubstring = assertNotSubstring def assertWarns(self, category, message, filename, f, *args, **kwargs): """ Fail if the given function doesn't generate the specified warning when called. It calls the function, checks the warning, and forwards the result of the function if everything is fine. @param category: the category of the warning to check. @param message: the output message of the warning to check. @param filename: the filename where the warning should come from. @param f: the function which is supposed to generate the warning. @type f: any callable. @param args: the arguments to C{f}. @param kwargs: the keywords arguments to C{f}. @return: the result of the original function C{f}. """ warningsShown = [] result = _collectWarnings(warningsShown.append, f, *args, **kwargs) if not warningsShown: self.fail("No warnings emitted") first = warningsShown[0] for other in warningsShown[1:]: if (other.message, other.category) != (first.message, first.category): self.fail("Can't handle different warnings") self.assertEqual(first.message, message) self.assertIdentical(first.category, category) # Use starts with because of .pyc/.pyo issues. self.assertTrue( filename.startswith(first.filename), f"Warning in {first.filename!r}, expected {filename!r}", ) # It would be nice to be able to check the line number as well, but # different configurations actually end up reporting different line # numbers (generally the variation is only 1 line, but that's enough # to fail the test erroneously...). # self.assertEqual(lineno, xxx) return result failUnlessWarns = assertWarns def assertIsInstance(self, instance, classOrTuple, message=None): """ Fail if C{instance} is not an instance of the given class or of one of the given classes. @param instance: the object to test the type (first argument of the C{isinstance} call). @type instance: any. @param classOrTuple: the class or classes to test against (second argument of the C{isinstance} call). @type classOrTuple: class, type, or tuple. @param message: Custom text to include in the exception text if the assertion fails. """ if not isinstance(instance, classOrTuple): if message is None: suffix = "" else: suffix = ": " + message self.fail(f"{instance!r} is not an instance of {classOrTuple}{suffix}") failUnlessIsInstance = assertIsInstance def assertNotIsInstance(self, instance, classOrTuple): """ Fail if C{instance} is an instance of the given class or of one of the given classes. @param instance: the object to test the type (first argument of the C{isinstance} call). @type instance: any. @param classOrTuple: the class or classes to test against (second argument of the C{isinstance} call). @type classOrTuple: class, type, or tuple. """ if isinstance(instance, classOrTuple): self.fail(f"{instance!r} is an instance of {classOrTuple}") failIfIsInstance = assertNotIsInstance def successResultOf(self, deferred): """ Return the current success result of C{deferred} or raise C{self.failureException}. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} which has a success result. This means L{Deferred.callback<twisted.internet.defer.Deferred.callback>} or L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called on it and it has reached the end of its callback chain and the last callback or errback returned a non-L{failure.Failure}. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has no result or has a failure result. @return: The result of C{deferred}. """ deferred = ensureDeferred(deferred) result = [] deferred.addBoth(result.append) if not result: self.fail( "Success result expected on {!r}, found no result instead".format( deferred ) ) result = result[0] if isinstance(result, failure.Failure): self.fail( "Success result expected on {!r}, " "found failure result instead:\n{}".format( deferred, result.getTraceback() ) ) return result def failureResultOf(self, deferred, *expectedExceptionTypes): """ Return the current failure result of C{deferred} or raise C{self.failureException}. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} which has a failure result. This means L{Deferred.callback<twisted.internet.defer.Deferred.callback>} or L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called on it and it has reached the end of its callback chain and the last callback or errback raised an exception or returned a L{failure.Failure}. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @param expectedExceptionTypes: Exception types to expect - if provided, and the exception wrapped by the failure result is not one of the types provided, then this test will fail. @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has no result, has a success result, or has an unexpected failure result. @return: The failure result of C{deferred}. @rtype: L{failure.Failure} """ deferred = ensureDeferred(deferred) result = [] deferred.addBoth(result.append) if not result: self.fail( "Failure result expected on {!r}, found no result instead".format( deferred ) ) result = result[0] if not isinstance(result, failure.Failure): self.fail( "Failure result expected on {!r}, " "found success result ({!r}) instead".format(deferred, result) ) if expectedExceptionTypes and not result.check(*expectedExceptionTypes): expectedString = " or ".join( [".".join((t.__module__, t.__name__)) for t in expectedExceptionTypes] ) self.fail( "Failure of type ({}) expected on {!r}, " "found type {!r} instead: {}".format( expectedString, deferred, result.type, result.getTraceback() ) ) return result def assertNoResult(self, deferred): """ Assert that C{deferred} does not have a result at this point. If the assertion succeeds, then the result of C{deferred} is left unchanged. Otherwise, any L{failure.Failure} result is swallowed. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} without a result. This means that neither L{Deferred.callback<twisted.internet.defer.Deferred.callback>} nor L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called, or that the L{Deferred<twisted.internet.defer.Deferred>} is waiting on another L{Deferred<twisted.internet.defer.Deferred>} for a result. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has a result. """ deferred = ensureDeferred(deferred) result = [] def cb(res): result.append(res) return res deferred.addBoth(cb) if result: # If there is already a failure, the self.fail below will # report it, so swallow it in the deferred deferred.addErrback(lambda _: None) self.fail( "No result expected on {!r}, found {!r} instead".format( deferred, result[0] ) ) class _LogObserver: """ Observes the Twisted logs and catches any errors. @ivar _errors: A C{list} of L{Failure} instances which were received as error events from the Twisted logging system. @ivar _added: A C{int} giving the number of times C{_add} has been called less the number of times C{_remove} has been called; used to only add this observer to the Twisted logging since once, regardless of the number of calls to the add method. @ivar _ignored: A C{list} of exception types which will not be recorded. """ def __init__(self): self._errors = [] self._added = 0 self._ignored = [] def _add(self): if self._added == 0: log.addObserver(self.gotEvent) self._added += 1 def _remove(self): self._added -= 1 if self._added == 0: log.removeObserver(self.gotEvent) def _ignoreErrors(self, *errorTypes): """ Do not store any errors with any of the given types. """ self._ignored.extend(errorTypes) def _clearIgnores(self): """ Stop ignoring any errors we might currently be ignoring. """ self._ignored = [] def flushErrors(self, *errorTypes): """ Flush errors from the list of caught errors. If no arguments are specified, remove all errors. If arguments are specified, only remove errors of those types from the stored list. """ if errorTypes: flushed = [] remainder = [] for f in self._errors: if f.check(*errorTypes): flushed.append(f) else: remainder.append(f) self._errors = remainder else: flushed = self._errors self._errors = [] return flushed def getErrors(self): """ Return a list of errors caught by this observer. """ return self._errors def gotEvent(self, event): """ The actual observer method. Called whenever a message is logged. @param event: A dictionary containing the log message. Actual structure undocumented (see source for L{twisted.python.log}). """ if event.get("isError", False) and "failure" in event: f = event["failure"] if len(self._ignored) == 0 or not f.check(*self._ignored): self._errors.append(f) _logObserver = _LogObserver() class SynchronousTestCase(_Assertions): """ A unit test. The atom of the unit testing universe. This class extends C{unittest.TestCase} from the standard library. A number of convenient testing helpers are added, including logging and warning integration, monkey-patching support, and more. To write a unit test, subclass C{SynchronousTestCase} and define a method (say, 'test_foo') on the subclass. To run the test, instantiate your subclass with the name of the method, and call L{run} on the instance, passing a L{TestResult} object. The C{trial} script will automatically find any C{SynchronousTestCase} subclasses defined in modules beginning with 'test_' and construct test cases for all methods beginning with 'test'. If an error is logged during the test run, the test will fail with an error. See L{log.err}. @ivar failureException: An exception class, defaulting to C{FailTest}. If the test method raises this exception, it will be reported as a failure, rather than an exception. All of the assertion methods raise this if the assertion fails. @ivar skip: L{None} or a string explaining why this test is to be skipped. If defined, the test will not be run. Instead, it will be reported to the result object as 'skipped' (if the C{TestResult} supports skipping). @ivar todo: L{None}, a string or a tuple of C{(errors, reason)} where C{errors} is either an exception class or an iterable of exception classes, and C{reason} is a string. See L{Todo} or L{makeTodo} for more information. @ivar suppress: L{None} or a list of tuples of C{(args, kwargs)} to be passed to C{warnings.filterwarnings}. Use these to suppress warnings raised in a test. Useful for testing deprecated code. See also L{util.suppress}. """ failureException = FailTest def __init__(self, methodName="runTest"): super().__init__(methodName) self._passed = False self._cleanups = [] self._testMethodName = methodName testMethod = getattr(self, methodName) self._parents = [testMethod, self, sys.modules.get(self.__class__.__module__)] def __eq__(self, other: object) -> bool: """ Override the comparison defined by the base TestCase which considers instances of the same class with the same _testMethodName to be equal. Since trial puts TestCase instances into a set, that definition of comparison makes it impossible to run the same test method twice. Most likely, trial should stop using a set to hold tests, but until it does, this is necessary on Python 2.6. -exarkun """ if isinstance(other, SynchronousTestCase): return self is other else: return NotImplemented def __hash__(self): return hash((self.__class__, self._testMethodName)) def shortDescription(self): desc = super().shortDescription() if desc is None: return self._testMethodName return desc def getSkip(self) -> Tuple[bool, Optional[str]]: """ Return the skip reason set on this test, if any is set. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{skip} attribute, returns that in a tuple (L{True}, L{str}). If the C{skip} attribute does not exist, look for C{__unittest_skip__} and C{__unittest_skip_why__} attributes which are set by the standard library L{unittest.skip} function. Returns (L{False}, L{None}) if it cannot find anything. See L{TestCase} docstring for more details. """ skipReason = util.acquireAttribute(self._parents, "skip", None) doSkip = skipReason is not None if skipReason is None: doSkip = getattr(self, "__unittest_skip__", False) if doSkip: skipReason = getattr(self, "__unittest_skip_why__", "") return (doSkip, skipReason) def getTodo(self): """ Return a L{Todo} object if the test is marked todo. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{todo} attribute, returns that. Returns L{None} if it cannot find anything. See L{TestCase} docstring for more details. """ todo = util.acquireAttribute(self._parents, "todo", None) if todo is None: return None return makeTodo(todo) def runTest(self): """ If no C{methodName} argument is passed to the constructor, L{run} will treat this method as the thing with the actual test inside. """ def run(self, result): """ Run the test case, storing the results in C{result}. First runs C{setUp} on self, then runs the test method (defined in the constructor), then runs C{tearDown}. As with the standard library L{unittest.TestCase}, the return value of these methods is disregarded. In particular, returning a L{Deferred<twisted.internet.defer.Deferred>} has no special additional consequences. @param result: A L{TestResult} object. """ log.msg("--> %s <--" % (self.id())) new_result = itrial.IReporter(result, None) if new_result is None: result = PyUnitResultAdapter(result) else: result = new_result result.startTest(self) (doSkip, skipReason) = self.getSkip() if doSkip: # don't run test methods that are marked as .skip result.addSkip(self, skipReason) result.stopTest(self) return self._passed = False self._warnings = [] self._installObserver() # All the code inside _runFixturesAndTest will be run such that warnings # emitted by it will be collected and retrievable by flushWarnings. _collectWarnings(self._warnings.append, self._runFixturesAndTest, result) # Any collected warnings which the test method didn't flush get # re-emitted so they'll be logged or show up on stdout or whatever. for w in self.flushWarnings(): try: warnings.warn_explicit(**w) except BaseException: result.addError(self, failure.Failure()) result.stopTest(self) def addCleanup(self, f, *args, **kwargs): """ Add the given function to a list of functions to be called after the test has run, but before C{tearDown}. Functions will be run in reverse order of being added. This helps ensure that tear down complements set up. As with all aspects of L{SynchronousTestCase}, Deferreds are not supported in cleanup functions. """ self._cleanups.append((f, args, kwargs)) def patch(self, obj, attribute, value): """ Monkey patch an object for the duration of the test. The monkey patch will be reverted at the end of the test using the L{addCleanup} mechanism. The L{monkey.MonkeyPatcher} is returned so that users can restore and re-apply the monkey patch within their tests. @param obj: The object to monkey patch. @param attribute: The name of the attribute to change. @param value: The value to set the attribute to. @return: A L{monkey.MonkeyPatcher} object. """ monkeyPatch = monkey.MonkeyPatcher((obj, attribute, value)) monkeyPatch.patch() self.addCleanup(monkeyPatch.restore) return monkeyPatch def flushLoggedErrors(self, *errorTypes): """ Remove stored errors received from the log. C{TestCase} stores each error logged during the run of the test and reports them as errors during the cleanup phase (after C{tearDown}). @param errorTypes: If unspecified, flush all errors. Otherwise, only flush errors that match the given types. @return: A list of failures that have been removed. """ return self._observer.flushErrors(*errorTypes) def flushWarnings(self, offendingFunctions=None): """ Remove stored warnings from the list of captured warnings and return them. @param offendingFunctions: If L{None}, all warnings issued during the currently running test will be flushed. Otherwise, only warnings which I{point} to a function included in this list will be flushed. All warnings include a filename and source line number; if these parts of a warning point to a source line which is part of a function, then the warning I{points} to that function. @type offendingFunctions: L{None} or L{list} of functions or methods. @raise ValueError: If C{offendingFunctions} is not L{None} and includes an object which is not a L{types.FunctionType} or L{types.MethodType} instance. @return: A C{list}, each element of which is a C{dict} giving information about one warning which was flushed by this call. The keys of each C{dict} are: - C{'message'}: The string which was passed as the I{message} parameter to L{warnings.warn}. - C{'category'}: The warning subclass which was passed as the I{category} parameter to L{warnings.warn}. - C{'filename'}: The name of the file containing the definition of the code object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. - C{'lineno'}: The source line associated with the active instruction of the code object object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. """ if offendingFunctions is None: toFlush = self._warnings[:] self._warnings[:] = [] else: toFlush = [] for aWarning in self._warnings: for aFunction in offendingFunctions: if not isinstance( aFunction, (types.FunctionType, types.MethodType) ): raise ValueError(f"{aFunction!r} is not a function or method") # inspect.getabsfile(aFunction) sometimes returns a # filename which disagrees with the filename the warning # system generates. This seems to be because a # function's code object doesn't deal with source files # being renamed. inspect.getabsfile(module) seems # better (or at least agrees with the warning system # more often), and does some normalization for us which # is desirable. inspect.getmodule() is attractive, but # somewhat broken in Python < 2.6. See Python bug 4845. aModule = sys.modules[aFunction.__module__] filename = inspect.getabsfile(aModule) if filename != os.path.normcase(aWarning.filename): continue lineNumbers = [ lineNumber for _, lineNumber in _findlinestarts(aFunction.__code__) ] if not (min(lineNumbers) <= aWarning.lineno <= max(lineNumbers)): continue # The warning points to this function, flush it and move on # to the next warning. toFlush.append(aWarning) break # Remove everything which is being flushed. list(map(self._warnings.remove, toFlush)) return [ { "message": w.message, "category": w.category, "filename": w.filename, "lineno": w.lineno, } for w in toFlush ] def getDeprecatedModuleAttribute(self, moduleName, name, version, message=None): """ Retrieve a module attribute which should have been deprecated, and assert that we saw the appropriate deprecation warning. @type moduleName: C{str} @param moduleName: Fully-qualified Python name of the module containing the deprecated attribute; if called from the same module as the attributes are being deprecated in, using the C{__name__} global can be helpful @type name: C{str} @param name: Attribute name which we expect to be deprecated @param version: The first L{version<twisted.python.versions.Version>} that the module attribute was deprecated. @type message: C{str} @param message: (optional) The expected deprecation message for the module attribute @return: The given attribute from the named module @raise FailTest: if no warnings were emitted on getattr, or if the L{DeprecationWarning} emitted did not produce the canonical please-use-something-else message that is standard for Twisted deprecations according to the given version and replacement. @since: Twisted 21.2.0 """ fqpn = moduleName + "." + name module = sys.modules[moduleName] attr = getattr(module, name) warningsShown = self.flushWarnings([self.getDeprecatedModuleAttribute]) if len(warningsShown) == 0: self.fail(f"{fqpn} is not deprecated.") observedWarning = warningsShown[0]["message"] expectedWarning = DEPRECATION_WARNING_FORMAT % { "fqpn": fqpn, "version": getVersionString(version), } if message is not None: expectedWarning = expectedWarning + ": " + message self.assert_( observedWarning.startswith(expectedWarning), f"Expected {observedWarning!r} to start with {expectedWarning!r}", ) return attr def callDeprecated(self, version, f, *args, **kwargs): """ Call a function that should have been deprecated at a specific version and in favor of a specific alternative, and assert that it was thusly deprecated. @param version: A 2-sequence of (since, replacement), where C{since} is a the first L{version<incremental.Version>} that C{f} should have been deprecated since, and C{replacement} is a suggested replacement for the deprecated functionality, as described by L{twisted.python.deprecate.deprecated}. If there is no suggested replacement, this parameter may also be simply a L{version<incremental.Version>} by itself. @param f: The deprecated function to call. @param args: The arguments to pass to C{f}. @param kwargs: The keyword arguments to pass to C{f}. @return: Whatever C{f} returns. @raise Exception: Whatever C{f} raises. If any exception is raised by C{f}, though, no assertions will be made about emitted deprecations. @raise FailTest: if no warnings were emitted by C{f}, or if the L{DeprecationWarning} emitted did not produce the canonical please-use-something-else message that is standard for Twisted deprecations according to the given version and replacement. """ result = f(*args, **kwargs) warningsShown = self.flushWarnings([self.callDeprecated]) try: info = list(version) except TypeError: since = version replacement = None else: [since, replacement] = info if len(warningsShown) == 0: self.fail(f"{f!r} is not deprecated.") observedWarning = warningsShown[0]["message"] expectedWarning = getDeprecationWarningString(f, since, replacement=replacement) self.assertEqual(expectedWarning, observedWarning) return result def mktemp(self): """ Create a new path name which can be used for a new file or directory. The result is a relative path that is guaranteed to be unique within the current working directory. The parent of the path will exist, but the path will not. For a temporary directory call os.mkdir on the path. For a temporary file just create the file (e.g. by opening the path for writing and then closing it). @return: The newly created path @rtype: C{str} """ MAX_FILENAME = 32 # some platforms limit lengths of filenames base = os.path.join( self.__class__.__module__[:MAX_FILENAME], self.__class__.__name__[:MAX_FILENAME], self._testMethodName[:MAX_FILENAME], ) if not os.path.exists(base): os.makedirs(base) dirname = tempfile.mkdtemp("", "", base) return os.path.join(dirname, "temp") def _getSuppress(self): """ Returns any warning suppressions set for this test. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{suppress} attribute, returns that. Returns any empty list (i.e. suppress no warnings) if it cannot find anything. See L{TestCase} docstring for more details. """ return util.acquireAttribute(self._parents, "suppress", []) def _getSkipReason(self, method, skip): """ Return the reason to use for skipping a test method. @param method: The method which produced the skip. @param skip: A L{unittest.SkipTest} instance raised by C{method}. """ if len(skip.args) > 0: return skip.args[0] warnAboutFunction( method, "Do not raise unittest.SkipTest with no arguments! Give a reason " "for skipping tests!", ) return skip def _run(self, suppress, todo, method, result): """ Run a single method, either a test method or fixture. @param suppress: Any warnings to suppress, as defined by the C{suppress} attribute on this method, test case, or the module it is defined in. @param todo: Any expected failure or failures, as defined by the C{todo} attribute on this method, test case, or the module it is defined in. @param method: The method to run. @param result: The TestResult instance to which to report results. @return: C{True} if the method fails and no further method/fixture calls should be made, C{False} otherwise. """ if inspect.isgeneratorfunction(method): exc = TypeError( "{!r} is a generator function and therefore will never run".format( method ) ) result.addError(self, failure.Failure(exc)) return True try: runWithWarningsSuppressed(suppress, method) except SkipTest as e: result.addSkip(self, self._getSkipReason(method, e)) except BaseException: reason = failure.Failure() if todo is None or not todo.expected(reason): if reason.check(self.failureException): addResult = result.addFailure else: addResult = result.addError addResult(self, reason) else: result.addExpectedFailure(self, reason, todo) else: return False return True def _runFixturesAndTest(self, result): """ Run C{setUp}, a test method, test cleanups, and C{tearDown}. @param result: The TestResult instance to which to report results. """ suppress = self._getSuppress() try: if self._run(suppress, None, self.setUp, result): return todo = self.getTodo() method = getattr(self, self._testMethodName) failed = self._run(suppress, todo, method, result) finally: self._runCleanups(result) if todo and not failed: result.addUnexpectedSuccess(self, todo) if self._run(suppress, None, self.tearDown, result): failed = True for error in self._observer.getErrors(): result.addError(self, error) failed = True self._observer.flushErrors() self._removeObserver() if not (failed or todo): result.addSuccess(self) def _runCleanups(self, result): """ Synchronously run any cleanups which have been added. """ while len(self._cleanups) > 0: f, args, kwargs = self._cleanups.pop() try: f(*args, **kwargs) except BaseException: f = failure.Failure() result.addError(self, f) def _installObserver(self): self._observer = _logObserver self._observer._add() def _removeObserver(self): self._observer._remove() PK Mb�Z�}�� � trial/__main__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. if __name__ == "__main__": import sys from pkg_resources import load_entry_point sys.exit(load_entry_point("Twisted", "console_scripts", "trial")()) PK Mb�Z��nX@7 @7 trial/_asynctest.pynu �[��� # -*- test-case-name: twisted.trial.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Things likely to be used by writers of unit tests. Maintainer: Jonathan Lange """ import inspect import warnings from typing import List from zope.interface import implementer # We can't import reactor at module-level because this code runs before trial # installs a user-specified reactor, installing the default reactor and # breaking reactor installation. See also #6047. from twisted.internet import defer, utils from twisted.python import failure from twisted.trial import itrial, util from twisted.trial._synctest import FailTest, SkipTest, SynchronousTestCase _wait_is_running: List[None] = [] @implementer(itrial.ITestCase) class TestCase(SynchronousTestCase): """ A unit test. The atom of the unit testing universe. This class extends L{SynchronousTestCase} which extends C{unittest.TestCase} from the standard library. The main feature is the ability to return C{Deferred}s from tests and fixture methods and to have the suite wait for those C{Deferred}s to fire. Also provides new assertions such as L{assertFailure}. @ivar timeout: A real number of seconds. If set, the test will raise an error if it takes longer than C{timeout} seconds. If not set, util.DEFAULT_TIMEOUT_DURATION is used. """ def __init__(self, methodName="runTest"): """ Construct an asynchronous test case for C{methodName}. @param methodName: The name of a method on C{self}. This method should be a unit test. That is, it should be a short method that calls some of the assert* methods. If C{methodName} is unspecified, L{SynchronousTestCase.runTest} will be used as the test method. This is mostly useful for testing Trial. """ super().__init__(methodName) def assertFailure(self, deferred, *expectedFailures): """ Fail if C{deferred} does not errback with one of C{expectedFailures}. Returns the original Deferred with callbacks added. You will need to return this Deferred from your test case. """ def _cb(ignore): raise self.failureException( f"did not catch an error, instead got {ignore!r}" ) def _eb(failure): if failure.check(*expectedFailures): return failure.value else: output = "\nExpected: {!r}\nGot:\n{}".format( expectedFailures, str(failure) ) raise self.failureException(output) return deferred.addCallbacks(_cb, _eb) failUnlessFailure = assertFailure def _run(self, methodName, result): from twisted.internet import reactor timeout = self.getTimeout() def onTimeout(d): e = defer.TimeoutError( f"{self!r} ({methodName}) still running at {timeout} secs" ) f = failure.Failure(e) # try to errback the deferred that the test returns (for no gorram # reason) (see issue1005 and test_errorPropagation in # test_deferred) try: d.errback(f) except defer.AlreadyCalledError: # if the deferred has been called already but the *back chain # is still unfinished, crash the reactor and report timeout # error ourself. reactor.crash() self._timedOut = True # see self._wait todo = self.getTodo() if todo is not None and todo.expected(f): result.addExpectedFailure(self, f, todo) else: result.addError(self, f) onTimeout = utils.suppressWarnings( onTimeout, util.suppress(category=DeprecationWarning) ) method = getattr(self, methodName) if inspect.isgeneratorfunction(method): exc = TypeError( "{!r} is a generator function and therefore will never run".format( method ) ) return defer.fail(exc) d = defer.maybeDeferred( utils.runWithWarningsSuppressed, self._getSuppress(), method ) call = reactor.callLater(timeout, onTimeout, d) d.addBoth(lambda x: call.active() and call.cancel() or x) return d def __call__(self, *args, **kwargs): return self.run(*args, **kwargs) def deferSetUp(self, ignored, result): d = self._run("setUp", result) d.addCallbacks( self.deferTestMethod, self._ebDeferSetUp, callbackArgs=(result,), errbackArgs=(result,), ) return d def _ebDeferSetUp(self, failure, result): if failure.check(SkipTest): result.addSkip(self, self._getSkipReason(self.setUp, failure.value)) else: result.addError(self, failure) if failure.check(KeyboardInterrupt): result.stop() return self.deferRunCleanups(None, result) def deferTestMethod(self, ignored, result): d = self._run(self._testMethodName, result) d.addCallbacks( self._cbDeferTestMethod, self._ebDeferTestMethod, callbackArgs=(result,), errbackArgs=(result,), ) d.addBoth(self.deferRunCleanups, result) d.addBoth(self.deferTearDown, result) return d def _cbDeferTestMethod(self, ignored, result): if self.getTodo() is not None: result.addUnexpectedSuccess(self, self.getTodo()) else: self._passed = True return ignored def _ebDeferTestMethod(self, f, result): todo = self.getTodo() if todo is not None and todo.expected(f): result.addExpectedFailure(self, f, todo) elif f.check(self.failureException, FailTest): result.addFailure(self, f) elif f.check(KeyboardInterrupt): result.addError(self, f) result.stop() elif f.check(SkipTest): result.addSkip( self, self._getSkipReason(getattr(self, self._testMethodName), f.value) ) else: result.addError(self, f) def deferTearDown(self, ignored, result): d = self._run("tearDown", result) d.addErrback(self._ebDeferTearDown, result) return d def _ebDeferTearDown(self, failure, result): result.addError(self, failure) if failure.check(KeyboardInterrupt): result.stop() self._passed = False @defer.inlineCallbacks def deferRunCleanups(self, ignored, result): """ Run any scheduled cleanups and report errors (if any) to the result. object. """ failures = [] for func, args, kwargs in self._cleanups[::-1]: try: yield func(*args, **kwargs) except Exception: failures.append(failure.Failure()) for f in failures: result.addError(self, f) self._passed = False def _cleanUp(self, result): try: clean = util._Janitor(self, result).postCaseCleanup() if not clean: self._passed = False except BaseException: result.addError(self, failure.Failure()) self._passed = False for error in self._observer.getErrors(): result.addError(self, error) self._passed = False self.flushLoggedErrors() self._removeObserver() if self._passed: result.addSuccess(self) def _classCleanUp(self, result): try: util._Janitor(self, result).postClassCleanup() except BaseException: result.addError(self, failure.Failure()) def _makeReactorMethod(self, name): """ Create a method which wraps the reactor method C{name}. The new method issues a deprecation warning and calls the original. """ def _(*a, **kw): warnings.warn( "reactor.%s cannot be used inside unit tests. " "In the future, using %s will fail the test and may " "crash or hang the test run." % (name, name), stacklevel=2, category=DeprecationWarning, ) return self._reactorMethods[name](*a, **kw) return _ def _deprecateReactor(self, reactor): """ Deprecate C{iterate}, C{crash} and C{stop} on C{reactor}. That is, each method is wrapped in a function that issues a deprecation warning, then calls the original. @param reactor: The Twisted reactor. """ self._reactorMethods = {} for name in ["crash", "iterate", "stop"]: self._reactorMethods[name] = getattr(reactor, name) setattr(reactor, name, self._makeReactorMethod(name)) def _undeprecateReactor(self, reactor): """ Restore the deprecated reactor methods. Undoes what L{_deprecateReactor} did. @param reactor: The Twisted reactor. """ for name, method in self._reactorMethods.items(): setattr(reactor, name, method) self._reactorMethods = {} def _runFixturesAndTest(self, result): """ Really run C{setUp}, the test method, and C{tearDown}. Any of these may return L{defer.Deferred}s. After they complete, do some reactor cleanup. @param result: A L{TestResult} object. """ from twisted.internet import reactor self._deprecateReactor(reactor) self._timedOut = False try: d = self.deferSetUp(None, result) try: self._wait(d) finally: self._cleanUp(result) self._classCleanUp(result) finally: self._undeprecateReactor(reactor) def addCleanup(self, f, *args, **kwargs): """ Extend the base cleanup feature with support for cleanup functions which return Deferreds. If the function C{f} returns a Deferred, C{TestCase} will wait until the Deferred has fired before proceeding to the next function. """ return super().addCleanup(f, *args, **kwargs) def getSuppress(self): return self._getSuppress() def getTimeout(self): """ Returns the timeout value set on this test. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{timeout} attribute, returns that. Returns L{util.DEFAULT_TIMEOUT_DURATION} if it cannot find anything. See L{TestCase} docstring for more details. """ timeout = util.acquireAttribute( self._parents, "timeout", util.DEFAULT_TIMEOUT_DURATION ) try: return float(timeout) except (ValueError, TypeError): # XXX -- this is here because sometimes people will have methods # called 'timeout', or set timeout to 'orange', or something # Particularly, test_news.NewsTestCase and ReactorCoreTestCase # both do this. warnings.warn( "'timeout' attribute needs to be a number.", category=DeprecationWarning ) return util.DEFAULT_TIMEOUT_DURATION def _wait(self, d, running=_wait_is_running): """Take a Deferred that only ever callbacks. Block until it happens.""" if running: raise RuntimeError("_wait is not reentrant") from twisted.internet import reactor results = [] def append(any): if results is not None: results.append(any) def crash(ign): if results is not None: reactor.crash() crash = utils.suppressWarnings( crash, util.suppress( message=r"reactor\.crash cannot be used.*", category=DeprecationWarning ), ) def stop(): reactor.crash() stop = utils.suppressWarnings( stop, util.suppress( message=r"reactor\.crash cannot be used.*", category=DeprecationWarning ), ) running.append(None) try: d.addBoth(append) if results: # d might have already been fired, in which case append is # called synchronously. Avoid any reactor stuff. return d.addBoth(crash) reactor.stop = stop try: reactor.run() finally: del reactor.stop # If the reactor was crashed elsewhere due to a timeout, hopefully # that crasher also reported an error. Just return. # _timedOut is most likely to be set when d has fired but hasn't # completed its callback chain (see self._run) if results or self._timedOut: # defined in run() and _run() return # If the timeout didn't happen, and we didn't get a result or # a failure, then the user probably aborted the test, so let's # just raise KeyboardInterrupt. # FIXME: imagine this: # web/test/test_webclient.py: # exc = self.assertRaises(error.Error, wait, method(url)) # # wait() will raise KeyboardInterrupt, and assertRaises will # swallow it. Therefore, wait() raising KeyboardInterrupt is # insufficient to stop trial. A suggested solution is to have # this code set a "stop trial" flag, or otherwise notify trial # that it should really try to stop as soon as possible. raise KeyboardInterrupt() finally: results = None running.pop() PK Mb�Z�Ֆ� � trial/unittest.pynu �[��� # -*- test-case-name: twisted.trial.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Things likely to be used by writers of unit tests. """ from twisted.trial._asyncrunner import TestDecorator, TestSuite, decorate from twisted.trial._asynctest import TestCase # Define the public API from the two implementation modules from twisted.trial._synctest import ( FailTest, PyUnitResultAdapter, SkipTest, SynchronousTestCase, Todo, makeTodo, ) # Further obscure the origins of these objects, to reduce surprise (and this is # what the values were before code got shuffled around between files, but was # otherwise unchanged). FailTest.__module__ = SkipTest.__module__ = __name__ __all__ = [ "decorate", "FailTest", "makeTodo", "PyUnitResultAdapter", "SkipTest", "SynchronousTestCase", "TestCase", "TestDecorator", "TestSuite", "Todo", ] PK Mb�Z��O��0 �0 trial/util.pynu �[��� # -*- test-case-name: twisted.trial.test.test_util -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # """ A collection of utility functions and classes, used internally by Trial. This code is for Trial's internal use. Do NOT use this code if you are writing tests. It is subject to change at the Trial maintainer's whim. There is nothing here in this module for you to use unless you are maintaining Trial. Any non-Trial Twisted code that uses this module will be shot. Maintainer: Jonathan Lange @var DEFAULT_TIMEOUT_DURATION: The default timeout which will be applied to asynchronous (ie, Deferred-returning) test methods, in seconds. """ from random import randrange from twisted.internet import interfaces, utils from twisted.python.failure import Failure from twisted.python.filepath import FilePath from twisted.python.lockfile import FilesystemLock __all__ = [ "DEFAULT_TIMEOUT_DURATION", "excInfoOrFailureToExcInfo", "suppress", "acquireAttribute", ] DEFAULT_TIMEOUT = object() DEFAULT_TIMEOUT_DURATION = 120.0 class DirtyReactorAggregateError(Exception): """ Passed to L{twisted.trial.itrial.IReporter.addError} when the reactor is left in an unclean state after a test. @ivar delayedCalls: The L{DelayedCall<twisted.internet.base.DelayedCall>} objects which weren't cleaned up. @ivar selectables: The selectables which weren't cleaned up. """ def __init__(self, delayedCalls, selectables=None): self.delayedCalls = delayedCalls self.selectables = selectables def __str__(self) -> str: """ Return a multi-line message describing all of the unclean state. """ msg = "Reactor was unclean." if self.delayedCalls: msg += ( "\nDelayedCalls: (set " "twisted.internet.base.DelayedCall.debug = True to " "debug)\n" ) msg += "\n".join(map(str, self.delayedCalls)) if self.selectables: msg += "\nSelectables:\n" msg += "\n".join(map(str, self.selectables)) return msg class _Janitor: """ The guy that cleans up after you. @ivar test: The L{TestCase} to report errors about. @ivar result: The L{IReporter} to report errors to. @ivar reactor: The reactor to use. If None, the global reactor will be used. """ def __init__(self, test, result, reactor=None): """ @param test: See L{_Janitor.test}. @param result: See L{_Janitor.result}. @param reactor: See L{_Janitor.reactor}. """ self.test = test self.result = result self.reactor = reactor def postCaseCleanup(self): """ Called by L{unittest.TestCase} after a test to catch any logged errors or pending L{DelayedCall<twisted.internet.base.DelayedCall>}s. """ calls = self._cleanPending() if calls: aggregate = DirtyReactorAggregateError(calls) self.result.addError(self.test, Failure(aggregate)) return False return True def postClassCleanup(self): """ Called by L{unittest.TestCase} after the last test in a C{TestCase} subclass. Ensures the reactor is clean by murdering the threadpool, catching any pending L{DelayedCall<twisted.internet.base.DelayedCall>}s, open sockets etc. """ selectables = self._cleanReactor() calls = self._cleanPending() if selectables or calls: aggregate = DirtyReactorAggregateError(calls, selectables) self.result.addError(self.test, Failure(aggregate)) self._cleanThreads() def _getReactor(self): """ Get either the passed-in reactor or the global reactor. """ if self.reactor is not None: reactor = self.reactor else: from twisted.internet import reactor return reactor def _cleanPending(self): """ Cancel all pending calls and return their string representations. """ reactor = self._getReactor() # flush short-range timers reactor.iterate(0) reactor.iterate(0) delayedCallStrings = [] for p in reactor.getDelayedCalls(): if p.active(): delayedString = str(p) p.cancel() else: print("WEIRDNESS! pending timed call not active!") delayedCallStrings.append(delayedString) return delayedCallStrings _cleanPending = utils.suppressWarnings( _cleanPending, ( ("ignore",), { "category": DeprecationWarning, "message": r"reactor\.iterate cannot be used.*", }, ), ) def _cleanThreads(self): reactor = self._getReactor() if interfaces.IReactorThreads.providedBy(reactor): if reactor.threadpool is not None: # Stop the threadpool now so that a new one is created. # This improves test isolation somewhat (although this is a # post class cleanup hook, so it's only isolating classes # from each other, not methods from each other). reactor._stopThreadPool() def _cleanReactor(self): """ Remove all selectables from the reactor, kill any of them that were processes, and return their string representation. """ reactor = self._getReactor() selectableStrings = [] for sel in reactor.removeAll(): if interfaces.IProcessTransport.providedBy(sel): sel.signalProcess("KILL") selectableStrings.append(repr(sel)) return selectableStrings _DEFAULT = object() def acquireAttribute(objects, attr, default=_DEFAULT): """ Go through the list 'objects' sequentially until we find one which has attribute 'attr', then return the value of that attribute. If not found, return 'default' if set, otherwise, raise AttributeError. """ for obj in objects: if hasattr(obj, attr): return getattr(obj, attr) if default is not _DEFAULT: return default raise AttributeError(f"attribute {attr!r} not found in {objects!r}") def excInfoOrFailureToExcInfo(err): """ Coerce a Failure to an _exc_info, if err is a Failure. @param err: Either a tuple such as returned by L{sys.exc_info} or a L{Failure} object. @return: A tuple like the one returned by L{sys.exc_info}. e.g. C{exception_type, exception_object, traceback_object}. """ if isinstance(err, Failure): # Unwrap the Failure into an exc_info tuple. err = (err.type, err.value, err.getTracebackObject()) return err def suppress(action="ignore", **kwarg): """ Sets up the .suppress tuple properly, pass options to this method as you would the stdlib warnings.filterwarnings() So, to use this with a .suppress magic attribute you would do the following: >>> from twisted.trial import unittest, util >>> import warnings >>> >>> class TestFoo(unittest.TestCase): ... def testFooBar(self): ... warnings.warn("i am deprecated", DeprecationWarning) ... testFooBar.suppress = [util.suppress(message='i am deprecated')] ... >>> Note that as with the todo and timeout attributes: the module level attribute acts as a default for the class attribute which acts as a default for the method attribute. The suppress attribute can be overridden at any level by specifying C{.suppress = []} """ return ((action,), kwarg) # This should be deleted, and replaced with twisted.application's code; see # #6016: def profiled(f, outputFile): def _(*args, **kwargs): import profile prof = profile.Profile() try: result = prof.runcall(f, *args, **kwargs) prof.dump_stats(outputFile) except SystemExit: pass prof.print_stats() return result return _ class _NoTrialMarker(Exception): """ No trial marker file could be found. Raised when trial attempts to remove a trial temporary working directory that does not contain a marker file. """ def _removeSafely(path): """ Safely remove a path, recursively. If C{path} does not contain a node named C{_trial_marker}, a L{_NoTrialMarker} exception is raised and the path is not removed. """ if not path.child(b"_trial_marker").exists(): raise _NoTrialMarker( f"{path!r} is not a trial temporary path, refusing to remove it" ) try: path.remove() except OSError as e: print( "could not remove %r, caught OSError [Errno %s]: %s" % (path, e.errno, e.strerror) ) try: newPath = FilePath( b"_trial_temp_old" + str(randrange(10000000)).encode("utf-8") ) path.moveTo(newPath) except OSError as e: print( "could not rename path, caught OSError [Errno %s]: %s" % (e.errno, e.strerror) ) raise class _WorkingDirectoryBusy(Exception): """ A working directory was specified to the runner, but another test run is currently using that directory. """ def _unusedTestDirectory(base): """ Find an unused directory named similarly to C{base}. Once a directory is found, it will be locked and a marker dropped into it to identify it as a trial temporary directory. @param base: A template path for the discovery process. If this path exactly cannot be used, a path which varies only in a suffix of the basename will be used instead. @type base: L{FilePath} @return: A two-tuple. The first element is a L{FilePath} representing the directory which was found and created. The second element is a locked L{FilesystemLock<twisted.python.lockfile.FilesystemLock>}. Another call to C{_unusedTestDirectory} will not be able to reused the same name until the lock is released, either explicitly or by this process exiting. """ counter = 0 while True: if counter: testdir = base.sibling("%s-%d" % (base.basename(), counter)) else: testdir = base testDirLock = FilesystemLock(testdir.path + ".lock") if testDirLock.lock(): # It is not in use if testdir.exists(): # It exists though - delete it _removeSafely(testdir) # Create it anew and mark it as ours so the next _removeSafely on # it succeeds. testdir.makedirs() testdir.child(b"_trial_marker").setContent(b"") return testdir, testDirLock else: # It is in use if base.basename() == "_trial_temp": counter += 1 else: raise _WorkingDirectoryBusy() def _listToPhrase(things, finalDelimiter, delimiter=", "): """ Produce a string containing each thing in C{things}, separated by a C{delimiter}, with the last couple being separated by C{finalDelimiter} @param things: The elements of the resulting phrase @type things: L{list} or L{tuple} @param finalDelimiter: What to put between the last two things (typically 'and' or 'or') @type finalDelimiter: L{str} @param delimiter: The separator to use between each thing, not including the last two. Should typically include a trailing space. @type delimiter: L{str} @return: The resulting phrase @rtype: L{str} """ if not isinstance(things, (list, tuple)): raise TypeError("Things must be a list or a tuple") if not things: return "" if len(things) == 1: return str(things[0]) if len(things) == 2: return f"{str(things[0])} {finalDelimiter} {str(things[1])}" else: strThings = [] for thing in things: strThings.append(str(thing)) return "{}{}{} {}".format( delimiter.join(strThings[:-1]), delimiter, finalDelimiter, strThings[-1], ) PK Mb�Z�Ȧ/ / trial/_dist/workerreporter.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_workerreporter -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test reporter forwarding test results over trial distributed AMP commands. @since: 12.3 """ from twisted.python.failure import Failure from twisted.python.reflect import qual from twisted.trial._dist import managercommands from twisted.trial.reporter import TestResult class WorkerReporter(TestResult): """ Reporter for trial's distributed workers. We send things not through a stream, but through an C{AMP} protocol's C{callRemote} method. @ivar _DEFAULT_TODO: Default message for expected failures and unexpected successes, used only if a C{Todo} is not provided. """ _DEFAULT_TODO = "Test expected to fail" def __init__(self, ampProtocol): """ @param ampProtocol: The communication channel with the trial distributed manager which collects all test results. @type ampProtocol: C{AMP} """ super().__init__() self.ampProtocol = ampProtocol def _getFailure(self, error): """ Convert a C{sys.exc_info()}-style tuple to a L{Failure}, if necessary. """ if isinstance(error, tuple): return Failure(error[1], error[0], error[2]) return error def _getFrames(self, failure): """ Extract frames from a C{Failure} instance. """ frames = [] for frame in failure.frames: frames.extend([frame[0], frame[1], str(frame[2])]) return frames def addSuccess(self, test): """ Send a success over. """ super().addSuccess(test) testName = test.id() self.ampProtocol.callRemote(managercommands.AddSuccess, testName=testName) def addError(self, test, error): """ Send an error over. """ super().addError(test, error) testName = test.id() failure = self._getFailure(error) error = failure.getErrorMessage() errorClass = qual(failure.type) frames = [frame for frame in self._getFrames(failure)] self.ampProtocol.callRemote( managercommands.AddError, testName=testName, error=error, errorClass=errorClass, frames=frames, ) def addFailure(self, test, fail): """ Send a Failure over. """ super().addFailure(test, fail) testName = test.id() failure = self._getFailure(fail) fail = failure.getErrorMessage() failClass = qual(failure.type) frames = [frame for frame in self._getFrames(failure)] self.ampProtocol.callRemote( managercommands.AddFailure, testName=testName, fail=fail, failClass=failClass, frames=frames, ) def addSkip(self, test, reason): """ Send a skip over. """ super().addSkip(test, reason) reason = str(reason) testName = test.id() self.ampProtocol.callRemote( managercommands.AddSkip, testName=testName, reason=reason ) def _getTodoReason(self, todo): """ Get the reason for a C{Todo}. If C{todo} is L{None}, return a sensible default. """ if todo is None: return self._DEFAULT_TODO else: return todo.reason def addExpectedFailure(self, test, error, todo=None): """ Send an expected failure over. """ super().addExpectedFailure(test, error, todo) errorMessage = error.getErrorMessage() testName = test.id() self.ampProtocol.callRemote( managercommands.AddExpectedFailure, testName=testName, error=errorMessage, todo=self._getTodoReason(todo), ) def addUnexpectedSuccess(self, test, todo=None): """ Send an unexpected success over. """ super().addUnexpectedSuccess(test, todo) testName = test.id() self.ampProtocol.callRemote( managercommands.AddUnexpectedSuccess, testName=testName, todo=self._getTodoReason(todo), ) def printSummary(self): """ I{Don't} print a summary """ PK Mb�ZԖa�: : 3 trial/_dist/__pycache__/workertrial.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlZdd� Zeej� ddlmZ ddlm Z m Z ddl m Z m Z ddlmZ G d d � d �Zejfd d �Zed krJe� dS dS )zj Implementation of C{AMP} worker commands, and main executable entry point for the workers. @since: 12.3 � Nc C s* d| v r| d � tj�tjdd�< dS dS )z� Override C{sys.path} with what the parent passed in B{TRIAL_PYTHONPATH}. @see: twisted.trial._dist.disttrial.DistTrialRunner.launchWorkerProcesses �TRIAL_PYTHONPATHN)�split�os�pathsep�sys�path)�environ� r �A/usr/lib/python3/dist-packages/twisted/trial/_dist/workertrial.py� _setupPath s �r )� FileWrapper)�startLoggingWithObserver�textFromEventDict)�_WORKER_AMP_STDIN�_WORKER_AMP_STDOUT)� WorkerOptionsc @ s e Zd ZdZdd� Zdd� ZdS )�WorkerLogObserverzF A log observer that forward its output to a C{AMP} protocol. c C s || _ dS )zg @param protocol: a connected C{AMP} protocol instance. @type protocol: C{AMP} N)�protocol)�selfr r r r �__init__* s zWorkerLogObserver.__init__c C s6 ddl m} t|�}|du rdS | jj|j|d� dS )z' Produce a log output. r )�managercommandsN)�out)�twisted.trial._distr r r � callRemote� TestWrite)r � eventDictr �textr r r �emit1 s zWorkerLogObserver.emitN)�__name__� __module__� __qualname__�__doc__r r r r r r r % s r c C s t � }|�� ddlm} ||d �}| td�}| td�}|�t|�� t|�}t |j d� z|� d�}W n t yQ } z|j d tjkrLW Y d }~q.� d }~ww |d krWn|�|� |�� tj�� tj�� q/|jr�t�d � |j�� } | jdd|�� jd � d S d S ) z� Main function to be run if __name__ == "__main__". @param _fdopen: If specified, the function to use in place of C{os.fdopen}. @type _fdopen: C{callable} r )�WorkerProtocolzforce-gc�rb�wbFT� N� )� show_missing�summary�coverdir)r � parseOptions�twisted.trial._dist.workerr" r r �makeConnectionr r r r �read�OSError�args�errno�EINTR� dataReceived�flushr �stdout�stderr�tracer�settrace�results� write_resultsr) r ) �_fdopen�configr" �workerProtocol� protocolIn� protocolOut�observer�r�er8 r r r �main= s@ �� � ��rB �__main__)r! r0 r r r r �twisted.internet.protocolr �twisted.python.logr r r r r �twisted.trial._dist.optionsr r �fdopenrB r r r r r �<module> s - �PK Mb�ZP��� � 0 trial/_dist/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dZdZdS )a� This package implements the distributed Trial test runner: - The L{twisted.trial._dist.disttrial} module implements a test runner which runs in a manager process and can launch additional worker processes in which to run tests and gather up results from all of them. - The L{twisted.trial._dist.options} module defines command line options used to configure the distributed test runner. - The L{twisted.trial._dist.managercommands} module defines AMP commands which are sent from worker processes back to the manager process to report the results of tests. - The L{twisted.trial._dist.workercommands} module defines AMP commands which are sent from the manager process to the worker processes to control the execution of tests there. - The L{twisted.trial._dist.distreporter} module defines a proxy for L{twisted.trial.itrial.IReporter} which enforces the typical requirement that results be passed to a reporter for only one test at a time, allowing any reporter to be used with despite disttrial's simultaneously running tests. - The L{twisted.trial._dist.workerreporter} module implements a L{twisted.trial.itrial.IReporter} which is used by worker processes and reports results back to the manager process using AMP commands. - The L{twisted.trial._dist.workertrial} module is a runnable script which is the main point for worker processes. - The L{twisted.trial._dist.worker} process defines the manager's AMP protocol for accepting results from worker processes and a process protocol for use running workers as local child processes (as opposed to distributing them to another host). @since: 12.3 � � N)�__doc__�_WORKER_AMP_STDIN�_WORKER_AMP_STDOUT� r r �>/usr/lib/python3/dist-packages/twisted/trial/_dist/__init__.py�<module> s (PK Mb�Z��_;� � 7 trial/_dist/__pycache__/managercommands.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZmZmZmZ eZG dd� de�ZG dd� de�ZG dd� de�Z G d d � d e�Z G d d � d e�Z G d d� de�Z G dd� de�Z dS )zN Commands for reporting test success of failure to the manager. @since: 12.3 � )�Boolean�Command�ListOf�Unicodec @ �( e Zd ZdZde� fgZde� fgZdS )� AddSuccessz Add a success. � testName� successN��__name__� __module__� __qualname__�__doc__� NativeString� argumentsr �response� r r �E/usr/lib/python3/dist-packages/twisted/trial/_dist/managercommands.pyr � r c @ �D e Zd ZdZde� fde� fde� fdee� �fgZde� fgZdS )�AddErrorz Add an error. r � errors errorClass� framesr N� r r r r r r r r r r r r r r � �r c @ r )� AddFailurez Add a failure. r s fails failClassr r Nr r r r r r & r r c @ �0 e Zd ZdZde� fde� fgZde� fgZdS )�AddSkipz Add a skip. r s reasonr Nr r r r r r 4 � r c @ s8 e Zd ZdZde� fde� fde� fgZde� fgZdS )�AddExpectedFailurez" Add an expected failure. r r � todor Nr r r r r r = s �r c @ r )�AddUnexpectedSuccessz$ Add an unexpected success. r r r Nr r r r r r! J r r! c @ r )� TestWritez Write test log. s outr Nr r r r r r" S r r" N)r �twisted.protocols.ampr r r r r r r r r r r! r" r r r r �<module> s PK Mb�Z�v~8 8 6 trial/_dist/__pycache__/workercommands.cpython-310.pycnu �[��� o �b> � @ s@ d Z ddlmZmZmZ eZG dd� de�ZG dd� de�ZdS )zI Commands for telling a worker to load tests or run tests. @since: 12.3 � )�Boolean�Command�Unicodec @ �( e Zd ZdZde� fgZde� fgZdS )�Runz Run a test. s testCase� successN��__name__� __module__� __qualname__�__doc__� NativeString� argumentsr �response� r r �D/usr/lib/python3/dist-packages/twisted/trial/_dist/workercommands.pyr � r c @ r )�StartzB Set up the worker process, giving the running directory. s directoryr Nr r r r r r r r N)r �twisted.protocols.ampr r r r r r r r r r �<module> s PK Mb�Z���� � / trial/_dist/__pycache__/options.cpython-310.pycnu �[��� o �b� � @ sL d Z ddlmZ ddlmZ ddlmZ ddlmZ G dd� deee�Z dS ) z= Options handling specific to trial's workers. @since: 12.3 � )�ReactorSelectionMixin��FilePath)�Options)� _BasicOptionsc @ s e Zd ZdZdd� ZdS )� WorkerOptionsz< Options forwarded to the trial distributed worker. c C s t d�S )zx Return a L{FilePath} representing the directory into which coverage results should be written. �coverager )�self� r �=/usr/lib/python3/dist-packages/twisted/trial/_dist/options.py�coverdir s zWorkerOptions.coverdirN)�__name__� __module__� __qualname__�__doc__r r r r r r s r N) r �twisted.application.appr �twisted.python.filepathr �twisted.python.usager �twisted.scripts.trialr r r r r r �<module> s PK Mb�Z�9�w w 6 trial/_dist/__pycache__/workerreporter.cpython-310.pycnu �[��� o �b/ � @ sH d Z ddlmZ ddlmZ ddlmZ ddlmZ G dd� de�Z dS ) zZ Test reporter forwarding test results over trial distributed AMP commands. @since: 12.3 � )�Failure)�qual)�managercommands)� TestResultc s� e Zd ZdZdZ� fdd�Zdd� Zdd� Z� fd d �Z� fd d �Z � fd d�Z � fdd�Z dd� Z d� fdd� Z d� fdd� Zdd� Z� ZS )�WorkerReportera Reporter for trial's distributed workers. We send things not through a stream, but through an C{AMP} protocol's C{callRemote} method. @ivar _DEFAULT_TODO: Default message for expected failures and unexpected successes, used only if a C{Todo} is not provided. zTest expected to failc s t � �� || _dS )z� @param ampProtocol: The communication channel with the trial distributed manager which collects all test results. @type ampProtocol: C{AMP} N)�super�__init__� ampProtocol)�selfr �� __class__� �D/usr/lib/python3/dist-packages/twisted/trial/_dist/workerreporter.pyr s zWorkerReporter.__init__c C s& t |t�rt|d |d |d �S |S )zX Convert a C{sys.exc_info()}-style tuple to a L{Failure}, if necessary. � r � )� isinstance�tupler )r �errorr r r � _getFailure& s zWorkerReporter._getFailurec C s4 g }|j D ]}|�|d |d t|d �g� q|S )z< Extract frames from a C{Failure} instance. r r r )�frames�extend�str)r �failurer �framer r r � _getFrames. s "zWorkerReporter._getFramesc s* t � �|� |�� }| jjtj|d� dS )z& Send a success over. )�testNameN)r � addSuccess�idr � callRemoter � AddSuccess)r �testr r r r r 7 s zWorkerReporter.addSuccessc �b t � �||� |�� }| �|�}|�� }t|j�}dd� | �|�D �}| jj t j ||||d� dS )z% Send an error over. c S � g | ]}|�qS r r ��.0r r r r � <listcomp>H � z+WorkerReporter.addError.<locals>.<listcomp>)r r � errorClassr N) r �addErrorr r �getErrorMessager �typer r r r �AddError)r r r r r r' r r r r r( ? � �zWorkerReporter.addErrorc r! )z& Send a Failure over. c S r" r r r# r r r r% Z r& z-WorkerReporter.addFailure.<locals>.<listcomp>)r �fail� failClassr N) r � addFailurer r r) r r* r r r r � AddFailure)r r r- r r r. r r r r r/ Q r, zWorkerReporter.addFailurec s6 t � �||� t|�}|�� }| jjtj||d� dS )z# Send a skip over. )r �reasonN)r �addSkipr r r r r �AddSkip)r r r1 r r r r r2 c s �zWorkerReporter.addSkipc C s |du r| j S |jS )zj Get the reason for a C{Todo}. If C{todo} is L{None}, return a sensible default. N)� _DEFAULT_TODOr1 )r �todor r r �_getTodoReasonn s z WorkerReporter._getTodoReasonNc s@ t � �|||� |�� }|�� }| jjtj||| �|�d� dS )z0 Send an expected failure over. )r r r5 N) r �addExpectedFailurer) r r r r �AddExpectedFailurer6 )r r r r5 � errorMessager r r r r7 y s �z!WorkerReporter.addExpectedFailurec s4 t � �||� |�� }| jjtj|| �|�d� dS )z2 Send an unexpected success over. )r r5 N)r �addUnexpectedSuccessr r r r �AddUnexpectedSuccessr6 )r r r5 r r r r r: � s �z#WorkerReporter.addUnexpectedSuccessc C s dS )z* I{Don't} print a summary Nr )r r r r � printSummary� s zWorkerReporter.printSummary)N)�__name__� __module__� __qualname__�__doc__r4 r r r r r( r/ r2 r6 r7 r: r< � __classcell__r r r r r s r N) r@ �twisted.python.failurer �twisted.python.reflectr �twisted.trial._distr �twisted.trial.reporterr r r r r r �<module> s PK Mb�Z���e�' �' . trial/_dist/__pycache__/worker.cpython-310.pycnu �[��� o �b�$ � @ s d Z ddlZddlmZ ddlmZ ddlmZmZ ddl m Z ddl m Z ddl mZ dd lmZ dd lmZmZmZmZ dd lmZ dd lmZmZ dd lm Z G dd� de �Z G dd� de �Z ee�G dd� d��Z ee�G dd� d��Z G dd� de �Z!dS )z: This module implements the worker classes. @since: 12.3 � N)� implementer)�Deferred)�IAddress� ITransport)�ProcessProtocol)�AMP)�Failure)� namedObject)�_WORKER_AMP_STDIN�_WORKER_AMP_STDOUT�managercommands�workercommands)�WorkerReporter)� TestLoader� TrialSuite)�Todoc @ sB e Zd ZdZd dd�Zdd� Zej�e� dd� Z ej �e � d S ) �WorkerProtocolz5 The worker-side trial distributed protocol. Fc C s t � | _t| �| _|| _d S �N)r �_loaderr �_result�_forceGarbageCollection)�self�forceGarbageCollection� r �</usr/lib/python3/dist-packages/twisted/trial/_dist/worker.py�__init__& s zWorkerProtocol.__init__c C s. | j �|�}t|g| j�}|�| j� ddiS )z* Run a test case by name. �successT)r � loadByNamer r �runr )r �testCase�case�suiter r r r + s zWorkerProtocol.runc C s t �|� ddiS )zb Set up the worker, moving into given directory for tests to run in them. r T)�os�chdir)r � directoryr r r �start6 s zWorkerProtocol.startN)F) �__name__� __module__� __qualname__�__doc__r r r �Run� responderr% �Startr r r r r ! s r c @ s� e Zd ZdZdd� Zej�e� dd� Zdd� Z ej �e � dd � Z ej �e � d d � Z ej�e � d d � Zej�e� dd� Zej�e� dd� Zej�e� dd� Zdd� Zdd� ZdS )�LocalWorkerAMPz7 Local implementation of the manager commands. c C s | j �| j� ddiS )z0 Add a success to the reporter. r T)r � addSuccess� _testCase)r �testNamer r r r. F s zLocalWorkerAMP.addSuccessc C sZ t |�}t||�}tdt|�d�D ]}|j�|| ||d t||d �g g f� q|S )a� Helper to build a C{Failure} with some traceback. @param error: An C{Exception} instance. @param errorClass: The class name of the C{error} class. @param frames: A flat list of strings representing the information need to approximatively rebuild C{Failure} frames. @return: A L{Failure} instance with enough information about a test error. r � � � )r r �range�len�frames�append�int)r �error� errorClassr6 � errorType�failure�ir r r � _buildFailureO s $�z LocalWorkerAMP._buildFailurec C �& | � |||�}| j�| j|� ddiS )z/ Add an error to the reporter. r T)r> r �addErrorr/ )r r0 r9 r: r6 r< r r r r@ e � zLocalWorkerAMP.addErrorc C r? )z0 Add a failure to the reporter. r T)r> r � addFailurer/ )r r0 �fail� failClassr6 r< r r r rB o rA zLocalWorkerAMP.addFailurec C � | j �| j|� ddiS )z- Add a skip to the reporter. r T)r �addSkipr/ )r r0 �reasonr r r rF y � zLocalWorkerAMP.addSkipc C s" t |�}| j�| j||� ddiS )z: Add an expected failure to the reporter. r T)r r �addExpectedFailurer/ )r r0 r9 �todo�_todor r r rI � s z!LocalWorkerAMP.addExpectedFailurec C rE )z< Add an unexpected success to the reporter. r T)r �addUnexpectedSuccessr/ )r r0 rJ r r r rL � rH z#LocalWorkerAMP.addUnexpectedSuccessc C s" | j �|d � | j �� ddiS )z4 Print test output from the worker. � r T)� _testStream�write�flush)r �outr r r � testWrite� s zLocalWorkerAMP.testWritec C s | j �| j� |S )zL Stop the current running test case, forwarding the result. )r �stopTestr/ )r �resultr r r � _stopTest� s zLocalWorkerAMP._stopTestc C s< || _ || _| j�|� |�� }| jtj|d�}|�| j�S )z Run a test. )r ) r/ r � startTest�id� callRemoter r* � addCallbackrU )r r rT � testCaseId�dr r r r � s zLocalWorkerAMP.runc C s || _ dS )z? Set the stream used to log output from tests. N)rN )r �streamr r r � setTestStream� s z LocalWorkerAMP.setTestStreamN)r& r' r( r) r. r � AddSuccessr+ r> r@ �AddErrorrB � AddFailurerF �AddSkiprI �AddExpectedFailurerL �AddUnexpectedSuccessrR � TestWriterU r r] r r r r r- A s( r- c @ s e Zd ZdZdS )�LocalWorkerAddressz A L{IAddress} implementation meant to provide stub addresses for L{ITransport.getPeer} and L{ITransport.getHost}. N)r& r' r( r) r r r r re � s re c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�LocalWorkerTransportzi A stub transport implementation used to support L{AMP} over a L{ProcessProtocol} transport. c C s || _ d S r )� _transport)r � transportr r r r � s z LocalWorkerTransport.__init__c C s | j �t|� dS )z, Forward data to transport. N�rg � writeToChildr �r �datar r r rO � s zLocalWorkerTransport.writec C s |D ] }| j �t|� qdS )zP Emulate C{writeSequence} by iterating data in the C{sequence}. Nri )r �sequencerl r r r � writeSequence� s �z"LocalWorkerTransport.writeSequencec C s | j �� dS )z' Closes the transport. N)rg �loseConnection�r r r r ro � s z#LocalWorkerTransport.loseConnectionc C � t � S �z: Return a L{LocalWorkerAddress} instance. �re rp r r r �getHost� � z LocalWorkerTransport.getHostc C rq rr rs rp r r r �getPeer� ru z LocalWorkerTransport.getPeerN) r& r' r( r) r rO rn ro rt rv r r r r rf � s rf c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )� LocalWorkeraX Local process worker protocol. This worker runs as a local process and communicates via stdin/out. @ivar _ampProtocol: The L{AMP} protocol instance used to communicate with the worker. @ivar _logDirectory: The directory where logs will reside. @ivar _logFile: The name of the main log file for tests output. c C s || _ || _|| _t� | _d S r )� _ampProtocol� _logDirectory�_logFiler � endDeferred)r � ampProtocol� logDirectory�logFiler r r r � s zLocalWorker.__init__c C s� | j �t| j�� tj�| j�st�| j� t tj� | jd�d�| _ t tj� | jd�d�| _ t tj� | j| j �dddd�| _| j �| j� | j}| j jtj|d�}|�d d � � d S ) zL When connection is made, create the AMP protocol instance. zout.log�wbzerr.log�wzutf-8�strict)�encoding�errors)r$ c S s d S r r )�xr r r �<lambda> s z,LocalWorker.connectionMade.<locals>.<lambda>N)rx �makeConnectionrf rh r" �path�existsry �makedirs�open�join�_outLog�_errLogrz �_testLogr] rX r r, � addErrback)r r} r[ r r r �connectionMade� s �zLocalWorker.connectionMadec C s" | j �� | j�� | j�� dS )zk On connection lost, close the log files that we're managing for stdin and stdout. N)r� �closer� r� �r rG r r r �connectionLost s zLocalWorker.connectionLostc C s& | � |� | j� |� | j�|� dS )z� When the process closes, call C{connectionLost} for cleanup purposes and forward the information to the C{_ampProtocol}. N)r� rx r{ �callbackr� r r r � processEnded s zLocalWorker.processEndedc C � | j �|� dS )z8 Send data received from stdout to log. N)r� rO rk r r r � outReceived( s zLocalWorker.outReceivedc C r� )z* Write error data to log. N)r� rO rk r r r � errReceived/ s zLocalWorker.errReceivedc C s* |t kr | j�|� dS t�| ||� dS )zT Handle data received on the specific pipe for the C{_ampProtocol}. N)r rx � dataReceivedr �childDataReceived)r �childFDrl r r r r� 5 s z LocalWorker.childDataReceivedN) r& r' r( r) r r� r� r� r� r� r� r r r r rw � s rw )"r) r" �zope.interfacer �twisted.internet.deferr �twisted.internet.interfacesr r �twisted.internet.protocolr �twisted.protocols.ampr �twisted.python.failurer �twisted.python.reflectr �twisted.trial._distr r r r �"twisted.trial._dist.workerreporterr �twisted.trial.runnerr r �twisted.trial.unittestr r r- re rf rw r r r r �<module> s( w)PK Mb�Z�6ol�" �" 1 trial/_dist/__pycache__/disttrial.cpython-310.pycnu �[��� o �bn! � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZmZ dd lmZ dd lmZmZ dd lmZ dd lmZ G d d� d�ZdS )z� This module contains the trial distributed runner, the management class responsible for coordinating all of trial's behavior at the highest level. @since: 12.3 � N)� DeferredList�� cooperate)�FilePath)� theSystemPath)� _iterateTests)�_WORKER_AMP_STDIN�_WORKER_AMP_STDOUT)� DistReporter)� LocalWorker�LocalWorkerAMP)� UncleanWarningsReporterWrapper)�_unusedTestDirectoryc @ sj e Zd ZdZeZdd� Z dd d �Zd d � Zd d� Z dd� Z dd� Z de dfdd�Z dd� ZdS )�DistTrialRunneraY A specialized runner for distributed trial. The runner launches a number of local worker processes which will run tests. @ivar _workerNumber: the number of workers to be spawned. @type _workerNumber: C{int} @ivar _stream: stream which the reporter will use. @ivar _reporterFactory: the reporter class to be used. c C s. | j | j| j| jd�}| jrt|�}| �|�S )zL Make reporter factory, and wrap it with a L{DistReporter}. )�realtime)�_reporterFactory�_stream� _tbformat� _rterrors�_uncleanWarningsr �_distReporterFactory)�self�reporter� r �?/usr/lib/python3/dist-packages/twisted/trial/_dist/disttrial.py� _makeResult* s � zDistTrialRunner._makeResultN�defaultF�test.log� _trial_tempc C s` || _ || _|| _|d u rtj}|| _|| _|| _|| _d | _ | | _ || _ d | _ d | _ d| _d S )NF)� _workerNumber�_workerArgumentsr �sys�stdoutr r r r �_result�_workingDirectory�_logFile�_logFileObserver�_logFileObject� _logWarnings) r �reporterFactory� workerNumber�workerArguments�stream�tracebackFormat�realTimeErrors�uncleanWarnings�logfile�workingDirectoryr r r �__init__5 s zDistTrialRunner.__init__c C s |� � dS )z� Write test run final outcome to result. @param result: A C{TestResult} which will print errors and the summary. N)�done)r �resultr r r � writeResultsQ s z DistTrialRunner.writeResultsc s � �fdd�t |�D �S )aY Create local worker protocol instances and return them. @param protocols: An iterable of L{LocalWorkerAMP} instances. @param workingDirectory: The base path in which we should run the workers. @type workingDirectory: C{str} @return: A list of C{quantity} C{LocalWorker} instances. c s, g | ]\}}t |tj��t|��� j��qS r )r �os�path�join�strr% )�.0�x�protocol�r r1 r r � <listcomp>e s ��z6DistTrialRunner.createLocalWorkers.<locals>.<listcomp>)� enumerate)r � protocolsr1 r r= r �createLocalWorkersY s �z"DistTrialRunner.createLocalWorkersc C sv t d jj}ddddddtdtdi}tj�� }tj� t j�|d< |D ]}t j |g}|� |� ||t j |||d� q"d S ) a Spawn processes from a list of process protocols. @param spawner: A C{IReactorProcess.spawnProcess} implementation. @param protocols: An iterable of C{ProcessProtocol} instances. @param arguments: Extra arguments passed to the processes. z twisted.trial._dist.workertrialr �w� �r� �TRIAL_PYTHONPATH)�args�childFDs�envN) r �filePathr7 r r r6 �environ�copy�pathsepr8 r! � executable�extend) r �spawnerr@ � arguments�workertrialPathrH rK �workerrG r r r �launchWorkerProcessesj s � �z%DistTrialRunner.launchWorkerProcessesc s6 � fdd��� ��fdd��|�fdd�|D ��� � S )a� Drive a L{LocalWorkerAMP} instance, iterating the tests and calling C{run} for every one of them. @param worker: The L{LocalWorkerAMP} to drive. @param result: The global L{DistReporter} instance. @param testCases: The global list of tests to iterate. @param cooperate: The cooperate function to use, to be customized in tests. @type cooperate: C{function} @return: A C{Deferred} firing when all the tests are finished. c s � j �|| � | S �N)�original� addFailure)�error�case)r4 r r � resultErrback� s z3DistTrialRunner._driveWorker.<locals>.resultErrbackc s �� | � �}|��| � |S rU )�run� addErrback)rY �d)r4 rZ rS r r �task� s z*DistTrialRunner._driveWorker.<locals>.taskc 3 s � | ]}� |�V qd S rU r )r: rY )r^ r r � <genexpr>� s � z/DistTrialRunner._driveWorker.<locals>.<genexpr>)�whenDone)r rS r4 � testCasesr r )r4 rZ r^ rS r � _driveWorker� s z DistTrialRunner._driveWorkerc s@ �du r ddl m� ��� �� �� }�j�d|f � |s*� ��j� ���� �S t t �j ��\}� t |�j �}dd� t|�D �� ��� |j�}dd� |D �����j|�j� � ���� fdd ��g � ����� fd d ���� � fd d �} ��� fdd�} ��fdd���� } | ��� | �| � ��dd| � ��� �S )a{ Spawn local worker processes and load tests. After that, run them. @param suite: A tests suite to be run. @param reactor: The reactor to use, to be customized in tests. @type reactor: A provider of L{twisted.internet.interfaces.IReactorProcess} @param cooperate: The cooperate function to use, to be customized in tests. @type cooperate: C{function} @param untilFailure: If C{True}, continue to run the tests until they fail. @type untilFailure: C{bool}. @return: The test result. @rtype: L{DistReporter} Nr )�reactorzRunning %d tests. c S s g | ]}t � �qS r )r )r: r; r r r r> � � z'DistTrialRunner.run.<locals>.<listcomp>c S s g | ]}|j �qS r )� endDeferred)r: rS r r r r> � rd c sD t tt����} g }� D ]}|��j|�| �d�� q t|ddd�S )Nr T)� consumeErrors�fireOnOneErrback)�iter�listr �appendrb r )ra �workerDeferredsrS )� ampWorkersr r4 r �suiter r �runTests� s ��z%DistTrialRunner.run.<locals>.runTestsc s. �� �� �s d S ��� sd S �� }|�� �S rU )r5 � wasSuccessful� addCallback)�ignr] )�nextRunr4 rn r � untilFailurer r rr � s z$DistTrialRunner.run.<locals>.nextRunc s& �� � �s��d � � �� d S d S rU )�unlockrj �stop�rq )rc �stopping� testDirLockr r ru � s �z!DistTrialRunner.run.<locals>.stopc s( �s�� d � t�dd�} | �� �S d S )NT)rf )rj r rp )r] )�continueShutdown�processEndDeferredsrw r r �beforeShutDown� s �z+DistTrialRunner.run.<locals>.beforeShutDownc s �� � � | S rU )r5 rv )r4 r r r ry � s z-DistTrialRunner.run.<locals>.continueShutdown�before�shutdown)�twisted.internetrc r �countTestCasesr �writer[ rV r5 r r r$ �minr �rangerA r7 rT � spawnProcessr rp �addBoth�addSystemEventTrigger) r rm rc r rs �count�testDirr* �workersru r{ r] r ) rl ry r rr rz rc r4 rn r rw rm rx rs r r[ � s6 zDistTrialRunner.runc C s | j |dd�S )z| Run the tests with local worker processes until they fail. @param suite: A tests suite to be run. T)rs )r[ )r rm r r r �runUntilFailure� s z DistTrialRunner.runUntilFailure)Nr FFr r )�__name__� __module__� __qualname__�__doc__r r r r2 r5 rA rT rb r r[ r� r r r r r s" � Xr )r� r6 r! �twisted.internet.deferr �twisted.internet.taskr �twisted.python.filepathr �twisted.python.modulesr �twisted.trial._asyncrunnerr �twisted.trial._distr r � twisted.trial._dist.distreporterr �twisted.trial._dist.workerr r �twisted.trial.reporterr �twisted.trial.utilr r r r r r �<module> s PK Mb�Z4�W� 4 trial/_dist/__pycache__/distreporter.cpython-310.pycnu �[��� o �b � @ sH d Z ddlmZ ddlmZ ddlmZ ee�G dd� dee���ZdS )z� The reporter is not made to support concurrent test running, so we will hold test results in here and only send them to the reporter once the test is over. @since: 12.3 � )� implementer)�proxyForInterface)� IReporterc sd e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd d � Zdd d�Z ddd�Z dd� Z dd� Z � Z S )� DistReporterz See module docstring. c s t � �|� i | _d S �N)�super�__init__�running)�self�original�� __class__� �B/usr/lib/python3/dist-packages/twisted/trial/_dist/distreporter.pyr s zDistReporter.__init__c C s. g | j |�� < | j |�� �| jj|f� dS )z& Queue test starting. N)r �id�appendr � startTest�r �testr r r r s zDistReporter.startTestc C �" | j |�� �| jj||f� dS )z) Queue adding a failure. N)r r r r � addFailure)r r �failr r r r % � "zDistReporter.addFailurec C r )z% Queue error adding. N)r r r r �addError)r r �errorr r r r + r zDistReporter.addErrorc C r )z& Queue adding a skip. N)r r r r �addSkip)r r �reasonr r r r 1 r zDistReporter.addSkipNc C r )z5 Queue adding an unexpected success. N)r r r r �addUnexpectedSuccess)r r �todor r r r 7 r z!DistReporter.addUnexpectedSuccessc C s$ | j |�� �| jj|||f� dS )z5 Queue adding an unexpected failure. N)r r r r �addExpectedFailure)r r r r r r r r = s �z DistReporter.addExpectedFailurec C s | j |�� �| jj|f� dS )z) Queue adding a success. N)r r r r � addSuccessr r r r r E s zDistReporter.addSuccessc C sT | j |�� �| jj|f� | j |�� D ] }|d |dd� � q| j |�� = dS )zA Queue stopping the test, then unroll the queue. r � N)r r r r �stopTest)r r �stepr r r r" K s zDistReporter.stopTestr )�__name__� __module__� __qualname__�__doc__r r r r r r r r r" � __classcell__r r r r r s r N)r' �zope.interfacer �twisted.python.componentsr �twisted.trial.itrialr r r r r r �<module> s PK Mb�Z�g�$ �$ trial/_dist/worker.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_worker -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module implements the worker classes. @since: 12.3 """ import os from zope.interface import implementer from twisted.internet.defer import Deferred from twisted.internet.interfaces import IAddress, ITransport from twisted.internet.protocol import ProcessProtocol from twisted.protocols.amp import AMP from twisted.python.failure import Failure from twisted.python.reflect import namedObject from twisted.trial._dist import ( _WORKER_AMP_STDIN, _WORKER_AMP_STDOUT, managercommands, workercommands, ) from twisted.trial._dist.workerreporter import WorkerReporter from twisted.trial.runner import TestLoader, TrialSuite from twisted.trial.unittest import Todo class WorkerProtocol(AMP): """ The worker-side trial distributed protocol. """ def __init__(self, forceGarbageCollection=False): self._loader = TestLoader() self._result = WorkerReporter(self) self._forceGarbageCollection = forceGarbageCollection def run(self, testCase): """ Run a test case by name. """ case = self._loader.loadByName(testCase) suite = TrialSuite([case], self._forceGarbageCollection) suite.run(self._result) return {"success": True} workercommands.Run.responder(run) def start(self, directory): """ Set up the worker, moving into given directory for tests to run in them. """ os.chdir(directory) return {"success": True} workercommands.Start.responder(start) class LocalWorkerAMP(AMP): """ Local implementation of the manager commands. """ def addSuccess(self, testName): """ Add a success to the reporter. """ self._result.addSuccess(self._testCase) return {"success": True} managercommands.AddSuccess.responder(addSuccess) def _buildFailure(self, error, errorClass, frames): """ Helper to build a C{Failure} with some traceback. @param error: An C{Exception} instance. @param errorClass: The class name of the C{error} class. @param frames: A flat list of strings representing the information need to approximatively rebuild C{Failure} frames. @return: A L{Failure} instance with enough information about a test error. """ errorType = namedObject(errorClass) failure = Failure(error, errorType) for i in range(0, len(frames), 3): failure.frames.append( (frames[i], frames[i + 1], int(frames[i + 2]), [], []) ) return failure def addError(self, testName, error, errorClass, frames): """ Add an error to the reporter. """ failure = self._buildFailure(error, errorClass, frames) self._result.addError(self._testCase, failure) return {"success": True} managercommands.AddError.responder(addError) def addFailure(self, testName, fail, failClass, frames): """ Add a failure to the reporter. """ failure = self._buildFailure(fail, failClass, frames) self._result.addFailure(self._testCase, failure) return {"success": True} managercommands.AddFailure.responder(addFailure) def addSkip(self, testName, reason): """ Add a skip to the reporter. """ self._result.addSkip(self._testCase, reason) return {"success": True} managercommands.AddSkip.responder(addSkip) def addExpectedFailure(self, testName, error, todo): """ Add an expected failure to the reporter. """ _todo = Todo(todo) self._result.addExpectedFailure(self._testCase, error, _todo) return {"success": True} managercommands.AddExpectedFailure.responder(addExpectedFailure) def addUnexpectedSuccess(self, testName, todo): """ Add an unexpected success to the reporter. """ self._result.addUnexpectedSuccess(self._testCase, todo) return {"success": True} managercommands.AddUnexpectedSuccess.responder(addUnexpectedSuccess) def testWrite(self, out): """ Print test output from the worker. """ self._testStream.write(out + "\n") self._testStream.flush() return {"success": True} managercommands.TestWrite.responder(testWrite) def _stopTest(self, result): """ Stop the current running test case, forwarding the result. """ self._result.stopTest(self._testCase) return result def run(self, testCase, result): """ Run a test. """ self._testCase = testCase self._result = result self._result.startTest(testCase) testCaseId = testCase.id() d = self.callRemote(workercommands.Run, testCase=testCaseId) return d.addCallback(self._stopTest) def setTestStream(self, stream): """ Set the stream used to log output from tests. """ self._testStream = stream @implementer(IAddress) class LocalWorkerAddress: """ A L{IAddress} implementation meant to provide stub addresses for L{ITransport.getPeer} and L{ITransport.getHost}. """ @implementer(ITransport) class LocalWorkerTransport: """ A stub transport implementation used to support L{AMP} over a L{ProcessProtocol} transport. """ def __init__(self, transport): self._transport = transport def write(self, data): """ Forward data to transport. """ self._transport.writeToChild(_WORKER_AMP_STDIN, data) def writeSequence(self, sequence): """ Emulate C{writeSequence} by iterating data in the C{sequence}. """ for data in sequence: self._transport.writeToChild(_WORKER_AMP_STDIN, data) def loseConnection(self): """ Closes the transport. """ self._transport.loseConnection() def getHost(self): """ Return a L{LocalWorkerAddress} instance. """ return LocalWorkerAddress() def getPeer(self): """ Return a L{LocalWorkerAddress} instance. """ return LocalWorkerAddress() class LocalWorker(ProcessProtocol): """ Local process worker protocol. This worker runs as a local process and communicates via stdin/out. @ivar _ampProtocol: The L{AMP} protocol instance used to communicate with the worker. @ivar _logDirectory: The directory where logs will reside. @ivar _logFile: The name of the main log file for tests output. """ def __init__(self, ampProtocol, logDirectory, logFile): self._ampProtocol = ampProtocol self._logDirectory = logDirectory self._logFile = logFile self.endDeferred = Deferred() def connectionMade(self): """ When connection is made, create the AMP protocol instance. """ self._ampProtocol.makeConnection(LocalWorkerTransport(self.transport)) if not os.path.exists(self._logDirectory): os.makedirs(self._logDirectory) self._outLog = open(os.path.join(self._logDirectory, "out.log"), "wb") self._errLog = open(os.path.join(self._logDirectory, "err.log"), "wb") # Log data is received via AMP which is UTF-8 unicode. # The log file should be written using a Unicode encoding, and not # the default system encoding which might not be Unicode compatible. self._testLog = open( os.path.join(self._logDirectory, self._logFile), "w", encoding="utf-8", errors="strict", ) self._ampProtocol.setTestStream(self._testLog) logDirectory = self._logDirectory d = self._ampProtocol.callRemote(workercommands.Start, directory=logDirectory) # Ignore the potential errors, the test suite will fail properly and it # would just print garbage. d.addErrback(lambda x: None) def connectionLost(self, reason): """ On connection lost, close the log files that we're managing for stdin and stdout. """ self._outLog.close() self._errLog.close() self._testLog.close() def processEnded(self, reason): """ When the process closes, call C{connectionLost} for cleanup purposes and forward the information to the C{_ampProtocol}. """ self.connectionLost(reason) self._ampProtocol.connectionLost(reason) self.endDeferred.callback(reason) def outReceived(self, data): """ Send data received from stdout to log. """ self._outLog.write(data) def errReceived(self, data): """ Write error data to log. """ self._errLog.write(data) def childDataReceived(self, childFD, data): """ Handle data received on the specific pipe for the C{_ampProtocol}. """ if childFD == _WORKER_AMP_STDOUT: self._ampProtocol.dataReceived(data) else: ProcessProtocol.childDataReceived(self, childFD, data) PK Mb�Zb�� lA lA " trial/_dist/test/test_disttrial.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.trial._dist.disttrial}. """ import os import sys from io import StringIO from zope.interface import implementer, verify from twisted.internet import error, interfaces, reactor from twisted.internet.defer import fail, gatherResults, maybeDeferred, succeed from twisted.internet.main import CONNECTION_DONE from twisted.internet.protocol import ProcessProtocol, Protocol from twisted.internet.task import Cooperator, deferLater from twisted.python.failure import Failure from twisted.python.lockfile import FilesystemLock from twisted.test.proto_helpers import MemoryReactorClock from twisted.test.test_cooperator import FakeScheduler from twisted.trial._dist.distreporter import DistReporter from twisted.trial._dist.disttrial import DistTrialRunner from twisted.trial._dist.worker import LocalWorker from twisted.trial.reporter import ( Reporter, TreeReporter, UncleanWarningsReporterWrapper, ) from twisted.trial.runner import ErrorHolder, TrialSuite from twisted.trial.unittest import SynchronousTestCase, TestCase class FakeTransport: """ A simple fake process transport. """ def writeToChild(self, fd, data): """ Ignore write calls. """ @implementer(interfaces.IReactorProcess) class CountingReactor(MemoryReactorClock): """ A fake reactor that counts the calls to L{IReactorCore.run}, L{IReactorCore.stop}, and L{IReactorProcess.spawnProcess}. """ spawnCount = 0 stopCount = 0 runCount = 0 def __init__(self, workers): MemoryReactorClock.__init__(self) self._workers = workers def spawnProcess( self, workerProto, executable, args=(), env={}, path=None, uid=None, gid=None, usePTY=0, childFDs=None, ): """ See L{IReactorProcess.spawnProcess}. @param workerProto: See L{IReactorProcess.spawnProcess}. @param args: See L{IReactorProcess.spawnProcess}. @param kwargs: See L{IReactorProcess.spawnProcess}. """ self._workers.append(workerProto) workerProto.makeConnection(FakeTransport()) self.spawnCount += 1 def stop(self): """ See L{IReactorCore.stop}. """ MemoryReactorClock.stop(self) self.stopCount += 1 def run(self): """ See L{IReactorCore.run}. """ self.runCount += 1 # The same as IReactorCore.run, except no stop. self.running = True self.hasRun = True for f, args, kwargs in self.whenRunningHooks: f(*args, **kwargs) class CountingReactorTests(SynchronousTestCase): """ Tests for L{CountingReactor}. """ def setUp(self): self.workers = [] self.reactor = CountingReactor(self.workers) def test_providesIReactorProcess(self): """ L{CountingReactor} instances provide L{IReactorProcess}. """ verify.verifyObject(interfaces.IReactorProcess, self.reactor) def test_spawnProcess(self): """ The process protocol for a spawned process is connected to a transport and appended onto the provided C{workers} list, and the reactor's C{spawnCount} increased. """ self.assertFalse(self.reactor.spawnCount) proto = Protocol() for count in [1, 2]: self.reactor.spawnProcess(proto, sys.executable, args=[sys.executable]) self.assertTrue(proto.transport) self.assertEqual(self.workers, [proto] * count) self.assertEqual(self.reactor.spawnCount, count) def test_stop(self): """ Stopping the reactor increments its C{stopCount} """ self.assertFalse(self.reactor.stopCount) for count in [1, 2]: self.reactor.stop() self.assertEqual(self.reactor.stopCount, count) def test_run(self): """ Running the reactor increments its C{runCount}, does not imply C{stop}, and calls L{IReactorCore.callWhenRunning} hooks. """ self.assertFalse(self.reactor.runCount) whenRunningCalls = [] self.reactor.callWhenRunning(whenRunningCalls.append, None) for count in [1, 2]: self.reactor.run() self.assertEqual(self.reactor.runCount, count) self.assertEqual(self.reactor.stopCount, 0) self.assertEqual(len(whenRunningCalls), count) class EternalTerminationPredicateFactory: """ A rigged terminationPredicateFactory for which time never pass. """ def __call__(self): """ See: L{task._Timer} """ return False class DistTrialRunnerTests(TestCase): """ Tests for L{DistTrialRunner}. """ def setUp(self): """ Create a runner for testing. """ self.runner = DistTrialRunner( TreeReporter, 4, [], workingDirectory=self.mktemp() ) self.runner._stream = StringIO() def reap(self, workers): """ Reap the workers and trap L{ConnectionDone} failures on their C{endDeferred}s. @param workers: The workers to reap. @type workers: An iterable of L{LocalWorker} """ for worker in workers: worker.endDeferred.addErrback(Failure.trap, error.ConnectionDone) worker.processEnded(Failure(CONNECTION_DONE)) def getFakeSchedulerAndEternalCooperator(self): """ Helper to create fake scheduler and cooperator in tests. The cooperator has a termination timer which will never inform the scheduler that the task needs to be terminated. @return: L{tuple} of (scheduler, cooperator) """ scheduler = FakeScheduler() cooperator = Cooperator( scheduler=scheduler, terminationPredicateFactory=EternalTerminationPredicateFactory, ) return scheduler, cooperator def test_writeResults(self): """ L{DistTrialRunner.writeResults} writes to the stream specified in the init. """ stringIO = StringIO() result = DistReporter(Reporter(stringIO)) self.runner.writeResults(result) self.assertTrue(stringIO.tell() > 0) def test_createLocalWorkers(self): """ C{createLocalWorkers} iterates the list of protocols and create one L{LocalWorker} for each. """ protocols = [object() for x in range(4)] workers = self.runner.createLocalWorkers(protocols, "path") for s in workers: self.assertIsInstance(s, LocalWorker) self.assertEqual(4, len(workers)) def test_launchWorkerProcesses(self): """ Given a C{spawnProcess} function, C{launchWorkerProcess} launches a python process with an existing path as its argument. """ protocols = [ProcessProtocol() for i in range(4)] arguments = [] environment = {} def fakeSpawnProcess( processProtocol, executable, args=(), env={}, path=None, uid=None, gid=None, usePTY=0, childFDs=None, ): arguments.append(executable) arguments.extend(args) environment.update(env) self.runner.launchWorkerProcesses(fakeSpawnProcess, protocols, ["foo"]) self.assertEqual(arguments[0], arguments[1]) self.assertTrue(os.path.exists(arguments[2])) self.assertEqual("foo", arguments[3]) self.assertEqual(os.pathsep.join(sys.path), environment["TRIAL_PYTHONPATH"]) def test_run(self): """ C{run} starts the reactor exactly once and spawns each of the workers exactly once. """ workers = [] fakeReactor = CountingReactor(workers) self.addCleanup(self.reap, workers) suite = TrialSuite() for i in range(10): suite.addTest(TestCase()) self.runner.run(suite, fakeReactor) self.assertEqual(fakeReactor.runCount, 1) self.assertEqual(fakeReactor.spawnCount, self.runner._workerNumber) def test_runUsedDirectory(self): """ L{DistTrialRunner} checks if the test directory is already locked, and if it is generates a name based on it. """ class CountingReactorWithLock(CountingReactor): def spawnProcess(oself, worker, *args, **kwargs): oself._workers.append(worker) self.assertEqual( os.path.abspath(worker._logDirectory), os.path.abspath( os.path.join(workingDirectory + "-1", str(oself.spawnCount)) ), ) localLock = FilesystemLock(workingDirectory + "-1.lock") self.assertFalse(localLock.lock()) oself.spawnCount += 1 worker.makeConnection(FakeTransport()) worker._ampProtocol.run = lambda *args: succeed(None) newDirectory = self.mktemp() os.mkdir(newDirectory) workingDirectory = os.path.join(newDirectory, "_trial_temp") lock = FilesystemLock(workingDirectory + ".lock") lock.lock() self.addCleanup(lock.unlock) self.runner._workingDirectory = workingDirectory workers = [] fakeReactor = CountingReactorWithLock(workers) self.addCleanup(self.reap, workers) suite = TrialSuite() for i in range(10): suite.addTest(TestCase()) self.runner.run(suite, fakeReactor) def test_minimalWorker(self): """ L{DistTrialRunner} doesn't try to start more workers than the number of tests. """ workers = [] fakeReactor = CountingReactor(workers) self.addCleanup(self.reap, workers) self.runner.run(TestCase(), fakeReactor) self.assertEqual(fakeReactor.runCount, 1) self.assertEqual(fakeReactor.spawnCount, 1) def test_runUncleanWarnings(self): """ Running with the C{unclean-warnings} option makes L{DistTrialRunner} uses the L{UncleanWarningsReporterWrapper}. """ workers = [] fakeReactor = CountingReactor(workers) self.addCleanup(self.reap, workers) self.runner._uncleanWarnings = True result = self.runner.run(TestCase(), fakeReactor) self.assertIsInstance(result, DistReporter) self.assertIsInstance(result.original, UncleanWarningsReporterWrapper) def test_runWithoutTest(self): """ When the suite contains no test, L{DistTrialRunner} takes a shortcut path without launching any process or starting the reactor. """ fakeReactor = object() suite = TrialSuite() result = self.runner.run(suite, fakeReactor) self.assertIsInstance(result, DistReporter) output = self.runner._stream.getvalue() self.assertIn("Running 0 test", output) self.assertIn("PASSED", output) def test_runWithoutTestButWithAnError(self): """ Even if there is no test, the suite can contain an error (most likely, an import error): this should make the run fail, and the error should be printed. """ fakeReactor = object() error = ErrorHolder("an error", Failure(RuntimeError("foo bar"))) result = self.runner.run(error, fakeReactor) self.assertIsInstance(result, DistReporter) output = self.runner._stream.getvalue() self.assertIn("Running 0 test", output) self.assertIn("foo bar", output) self.assertIn("an error", output) self.assertIn("errors=1", output) self.assertIn("FAILED", output) def test_runUnexpectedError(self): """ If for some reasons we can't connect to the worker process, the test suite catches and fails. """ class CountingReactorWithFail(CountingReactor): def spawnProcess(self, worker, *args, **kwargs): self._workers.append(worker) worker.makeConnection(FakeTransport()) self.spawnCount += 1 worker._ampProtocol.run = self.failingRun def failingRun(self, case, result): return fail(RuntimeError("oops")) scheduler, cooperator = self.getFakeSchedulerAndEternalCooperator() workers = [] fakeReactor = CountingReactorWithFail(workers) self.addCleanup(self.reap, workers) result = self.runner.run(TestCase(), fakeReactor, cooperator.cooperate) self.assertEqual(fakeReactor.runCount, 1) self.assertEqual(fakeReactor.spawnCount, 1) scheduler.pump() self.assertEqual(1, len(result.original.failures)) def test_runStopAfterTests(self): """ L{DistTrialRunner} calls C{reactor.stop} and unlocks the test directory once the tests have run. """ class CountingReactorWithSuccess(CountingReactor): def spawnProcess(self, worker, *args, **kwargs): self._workers.append(worker) worker.makeConnection(FakeTransport()) self.spawnCount += 1 worker._ampProtocol.run = self.succeedingRun def succeedingRun(self, case, result): return succeed(None) workingDirectory = self.runner._workingDirectory workers = [] fakeReactor = CountingReactorWithSuccess(workers) self.runner.run(TestCase(), fakeReactor) def check(): localLock = FilesystemLock(workingDirectory + ".lock") self.assertTrue(localLock.lock()) self.assertEqual(1, fakeReactor.stopCount) self.assertEqual(list(fakeReactor.triggers.keys()), ["before"]) self.assertEqual(list(fakeReactor.triggers["before"]), ["shutdown"]) self.reap(workers) return deferLater(reactor, 0, check) def test_runWaitForProcessesDeferreds(self): """ L{DistTrialRunner} waits for the worker processes to stop when the reactor is stopping, and then unlocks the test directory, not trying to stop the reactor again. """ workers = [] workingDirectory = self.runner._workingDirectory fakeReactor = CountingReactor(workers) self.runner.run(TestCase(), fakeReactor) def check(ign): # Let the AMP deferreds fire return deferLater(reactor, 0, realCheck) def realCheck(): localLock = FilesystemLock(workingDirectory + ".lock") self.assertTrue(localLock.lock()) # Stop is not called, as it ought to have been called before self.assertEqual(0, fakeReactor.stopCount) self.assertEqual(list(fakeReactor.triggers.keys()), ["before"]) self.assertEqual(list(fakeReactor.triggers["before"]), ["shutdown"]) self.reap(workers) return gatherResults( [ maybeDeferred(f, *a, **kw) for f, a, kw in fakeReactor.triggers["before"]["shutdown"] ] ).addCallback(check) def test_runUntilFailure(self): """ L{DistTrialRunner} can run in C{untilFailure} mode where it will run the given tests until they fail. """ called = [] class CountingReactorWithSuccess(CountingReactor): def spawnProcess(self, worker, *args, **kwargs): self._workers.append(worker) worker.makeConnection(FakeTransport()) self.spawnCount += 1 worker._ampProtocol.run = self.succeedingRun def succeedingRun(self, case, result): called.append(None) if len(called) == 5: return fail(RuntimeError("oops")) return succeed(None) workers = [] fakeReactor = CountingReactorWithSuccess(workers) self.addCleanup(self.reap, workers) scheduler, cooperator = self.getFakeSchedulerAndEternalCooperator() result = self.runner.run( TestCase(), fakeReactor, cooperate=cooperator.cooperate, untilFailure=True ) scheduler.pump() self.assertEqual(5, len(called)) self.assertFalse(result.wasSuccessful()) output = self.runner._stream.getvalue() self.assertIn("PASSED", output) self.assertIn("FAIL", output) PK Mb�Z�j0� � 9 trial/_dist/test/__pycache__/test_options.cpython-310.pycnu �[��� o �b3 � @ sH d Z ddlZddlZddlZddlmZ ddlmZ G dd� de�ZdS )z3 Tests for distributed trial's options management. � N)� WorkerOptions)�TestCasec @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �WorkerOptionsTestsz% Tests for L{WorkerOptions}. c C s t � | _dS )zK Build an L{WorkerOptions} object to be used in the tests. N)r �options��self� r �G/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_options.py�setUp s zWorkerOptionsTests.setUpc C s` | � tjt�� � t�� r| � tj� t�� | j�g d�� | � dt�� � | � t�� � dS )zd L{WorkerOptions} supports a subset of standard options supported by trial. )z--recursionlimit�2000z --disablegci� N) � addCleanup�sys�setrecursionlimit�getrecursionlimit�gc� isenabled�enabler � parseOptions� assertEqual� assertFalser r r r �test_standardOptions s z'WorkerOptionsTests.test_standardOptionsc C s. | � tj�tj�t�� d��| j�� j� dS )z� L{WorkerOptions.coverdir} returns the C{coverage} child directory of the current directory to be used for storing coverage data. �coverageN)r �os�path�realpath�join�getcwdr �coverdirr r r r � test_coverage( s �z WorkerOptionsTests.test_coverageN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r ) r" r r r �twisted.trial._dist.optionsr �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z�C�� � > trial/_dist/test/__pycache__/test_distreporter.cpython-310.pycnu �[��� o �b� � @ sH d Z ddlmZ ddlmZ ddlmZ ddlmZ G dd� de�Z dS ) z0 Tests for L{twisted.trial._dist.distreporter}. � )�StringIO)� DistReporter)� TreeReporter)�TestCasec @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �DistReporterTestsz$ Tests for L{DistReporter}. c C s$ t � | _tt| j��| _t� | _d S )N)r �streamr r � distReporterr �test��self� r �L/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_distreporter.py�setUp s zDistReporterTests.setUpc C sd | j �| j� | �| j�� d� | j �| j� | �| j�� d� | j �| j� | �| j�� d� dS )zY Success output only gets sent to the stream after the test has stopped. � N) r � startTestr � assertEqualr �getvalue� addSuccess�stopTest�assertNotEqualr r r r �test_startSuccessStop s z'DistReporterTests.test_startSuccessStopc C sf | j �| j� | �| j�� d� | j �| jd� | �| j�� d� | j �| j� | �| j�� d� dS )zW Error output only gets sent to the stream after the test has stopped. r �errorN) r r r r r r �addErrorr r r r r r �test_startErrorStop$ s z%DistReporterTests.test_startErrorStopc C s� | j �| j� | j �| jd� | j �| jd� | j �| jd� | j �| jd� | j �| jdd� | �t | j j | j� � �d� dS )zh Calling methods of L{DistReporter} add calls to the running queue of the test. �foo�bar�egg�spam�err� N) r r r � addFailurer �addSkip�addUnexpectedSuccess�addExpectedFailurer �len�running�idr r r r �test_forwardedMethods/ s "z'DistReporterTests.test_forwardedMethodsN)�__name__� __module__� __qualname__�__doc__r r r r' r r r r r s r N) r+ �ior � twisted.trial._dist.distreporterr �twisted.trial.reporterr �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z P � � 5 trial/_dist/test/__pycache__/__init__.cpython-310.pycnu �[��� o �bv � @ s d Z dS )z& Distributed trial test runner tests. N)�__doc__� r r �C/usr/lib/python3/dist-packages/twisted/trial/_dist/test/__init__.py�<module> s PK Mb�Z���ЪH �H ; trial/_dist/test/__pycache__/test_disttrial.cpython-310.pycnu �[��� o �blA � @ sj d Z ddlZddlZddlmZ ddlmZmZ ddlm Z m Z m Z ddl m Z mZmZmZ ddlmZ ddlmZmZ dd lmZmZ dd lmZ dd lm Z dd l m Z dd l m Z ddl!m"Z" ddl#m$Z$ ddl%m&Z& ddl'm(Z(m)Z)m*Z* ddl+m,Z,m-Z- ddl.m/Z/m0Z0 G dd� d�Z1ee j2�G dd� de ��Z3G dd� de/�Z4G dd� d�Z5G d d � d e0�Z6dS ) z- Tests for L{twisted.trial._dist.disttrial}. � N)�StringIO)� implementer�verify)�error� interfaces�reactor)�fail� gatherResults� maybeDeferred�succeed)�CONNECTION_DONE)�ProcessProtocol�Protocol)� Cooperator� deferLater)�Failure)�FilesystemLock)�MemoryReactorClock)� FakeScheduler)� DistReporter)�DistTrialRunner)� LocalWorker)�Reporter� TreeReporter� UncleanWarningsReporterWrapper)� ErrorHolder� TrialSuite)�SynchronousTestCase�TestCasec @ � e Zd ZdZdd� ZdS )� FakeTransportz* A simple fake process transport. c C � dS )z% Ignore write calls. N� )�self�fd�datar" r" �I/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_disttrial.py� writeToChild( s zFakeTransport.writeToChildN)�__name__� __module__� __qualname__�__doc__r' r" r" r" r& r # � r c @ sL e Zd ZdZdZdZdZdd� Zdi dddddfdd�Zd d � Z d d � Z dS ) �CountingReactorz� A fake reactor that counts the calls to L{IReactorCore.run}, L{IReactorCore.stop}, and L{IReactorProcess.spawnProcess}. r c C s t �| � || _d S �N)r �__init__�_workers)r# �workersr" r" r& r/ 9 s zCountingReactor.__init__r" Nc C s* | j �|� |�t� � | jd7 _dS )z� See L{IReactorProcess.spawnProcess}. @param workerProto: See L{IReactorProcess.spawnProcess}. @param args: See L{IReactorProcess.spawnProcess}. @param kwargs: See L{IReactorProcess.spawnProcess}. � N)r0 �append�makeConnectionr � spawnCount) r# � workerProto� executable�args�env�path�uid�gid�usePTY�childFDsr" r" r& � spawnProcess= s z CountingReactor.spawnProcessc C s t �| � | jd7 _dS )z+ See L{IReactorCore.stop}. r2 N)r �stop� stopCount�r# r" r" r& r@ T s zCountingReactor.stopc C s> | j d7 _ d| _d| _| jD ] \}}}||i |�� qdS )z* See L{IReactorCore.run}. r2 TN)�runCount�running�hasRun�whenRunningHooks)r# �fr8 �kwargsr" r" r& �run[ s �zCountingReactor.run) r( r) r* r+ r5 rA rC r/ r? r@ rI r" r" r" r& r- . s � r- c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �CountingReactorTestsz' Tests for L{CountingReactor}. c C s g | _ t| j �| _d S r. )r1 r- r rB r" r" r& �setUpn s zCountingReactorTests.setUpc C s t �tj| j� dS )zJ L{CountingReactor} instances provide L{IReactorProcess}. N)r � verifyObjectr �IReactorProcessr rB r" r" r& � test_providesIReactorProcessr s z1CountingReactorTests.test_providesIReactorProcessc C sj | � | jj� t� }dD ]&}| jj|tjtjgd� | �|j� | � | j |g| � | � | jj|� q dS )z� The process protocol for a spawned process is connected to a transport and appended onto the provided C{workers} list, and the reactor's C{spawnCount} increased. �r2 � �r8 N) � assertFalser r5 r r? �sysr7 � assertTrue� transport� assertEqualr1 )r# �proto�countr" r" r& �test_spawnProcessx s �z&CountingReactorTests.test_spawnProcessc C s6 | � | jj� dD ]}| j�� | �| jj|� q dS )zB Stopping the reactor increments its C{stopCount} rO N)rR r rA r@ rV )r# rX r" r" r& � test_stop� s �z CountingReactorTests.test_stopc C sj | � | jj� g }| j�|jd� dD ] }| j�� | �| jj|� | �| jjd� | �t|�|� qdS )z� Running the reactor increments its C{runCount}, does not imply C{stop}, and calls L{IReactorCore.callWhenRunning} hooks. NrO r ) rR r rC �callWhenRunningr3 rI rV rA �len)r# �whenRunningCallsrX r" r" r& �test_run� s �z CountingReactorTests.test_runN) r( r) r* r+ rK rN rY rZ r^ r" r" r" r& rJ i s rJ c @ r )�"EternalTerminationPredicateFactoryzI A rigged terminationPredicateFactory for which time never pass. c C r! )z% See: L{task._Timer} Fr" rB r" r" r& �__call__� s z+EternalTerminationPredicateFactory.__call__N)r( r) r* r+ r` r" r" r" r& r_ � r, r_ c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�DistTrialRunnerTestsz' Tests for L{DistTrialRunner}. c C s$ t tdg | �� d�| _t� | j_dS )z. Create a runner for testing. � )�workingDirectoryN)r r �mktemp�runnerr �_streamrB r" r" r& rK � s �zDistTrialRunnerTests.setUpc C s. |D ]}|j �tjtj� |�tt�� qdS )z� Reap the workers and trap L{ConnectionDone} failures on their C{endDeferred}s. @param workers: The workers to reap. @type workers: An iterable of L{LocalWorker} N)� endDeferred� addErrbackr �trapr �ConnectionDone� processEndedr )r# r1 �workerr" r" r& �reap� s �zDistTrialRunnerTests.reapc C s t � }t|td�}||fS )a Helper to create fake scheduler and cooperator in tests. The cooperator has a termination timer which will never inform the scheduler that the task needs to be terminated. @return: L{tuple} of (scheduler, cooperator) )� scheduler�terminationPredicateFactory)r r r_ )r# rn � cooperatorr" r" r& �$getFakeSchedulerAndEternalCooperator� s �z9DistTrialRunnerTests.getFakeSchedulerAndEternalCooperatorc C s4 t � }tt|��}| j�|� | �|�� dk� dS )ze L{DistTrialRunner.writeResults} writes to the stream specified in the init. r N)r r r re � writeResultsrT �tell)r# �stringIO�resultr" r" r& �test_writeResults� s z&DistTrialRunnerTests.test_writeResultsc C sJ dd� t d�D �}| j�|d�}|D ]}| �|t� q| �dt|�� dS )zv C{createLocalWorkers} iterates the list of protocols and create one L{LocalWorker} for each. c S � g | ]}t � �qS r" )�object)�.0�xr" r" r& � <listcomp>� � z@DistTrialRunnerTests.test_createLocalWorkers.<locals>.<listcomp>rb r: N)�rangere �createLocalWorkers�assertIsInstancer rV r\ )r# � protocolsr1 �sr" r" r& �test_createLocalWorkers� s z,DistTrialRunnerTests.test_createLocalWorkersc s� dd� t d�D �}g � i �di dddddf� �fdd� }| j�||d g� | �� d � d � | �tj�� d �� | �d � d � | �tj� t j��d � dS )z� Given a C{spawnProcess} function, C{launchWorkerProcess} launches a python process with an existing path as its argument. c S rw r" )r )ry �ir" r" r& r{ � r| zCDistTrialRunnerTests.test_launchWorkerProcesses.<locals>.<listcomp>rb r" Nr c s" � � |� � �|� ��|� d S r. )r3 �extend�update) �processProtocolr7 r8 r9 r: r; r< r= r> �� arguments� environmentr" r& �fakeSpawnProcess� s zIDistTrialRunnerTests.test_launchWorkerProcesses.<locals>.fakeSpawnProcess�foor2 rP � �TRIAL_PYTHONPATH) r} re �launchWorkerProcessesrV rT �osr: �exists�pathsep�joinrS )r# r� r� r" r� r& �test_launchWorkerProcesses� s � z/DistTrialRunnerTests.test_launchWorkerProcessesc C sl g }t |�}| �| j|� t� }td�D ]}|�t� � q| j�||� | � |j d� | � |j | jj � dS )zm C{run} starts the reactor exactly once and spawns each of the workers exactly once. � r2 N) r- � addCleanuprm r r} �addTestr re rI rV rC r5 � _workerNumber)r# r1 � fakeReactor�suiter� r" r" r& r^ s z DistTrialRunnerTests.test_runc s� G � �fdd�dt �}� �� }t�|� tj�|d��t�d �}|�� � �|j � �� j _ g }||�}� �� j |� t � }td�D ]}|�t� � qC� j �||� dS )z� L{DistTrialRunner} checks if the test directory is already locked, and if it is generates a name based on it. c s e Zd Z� �fdd�ZdS )zKDistTrialRunnerTests.test_runUsedDirectory.<locals>.CountingReactorWithLockc s� | j �|� � �tj�|j�tj�tj��d t| j ���� t �d �}� � |� � � | j d7 _ |� t� � dd� |j_d S )Nz-1z-1.lockr2 c W � t d �S r. �r rQ r" r" r& �<lambda>. s zjDistTrialRunnerTests.test_runUsedDirectory.<locals>.CountingReactorWithLock.spawnProcess.<locals>.<lambda>)r0 r3 rV r� r: �abspath� _logDirectoryr� �strr5 r rR �lockr4 r � _ampProtocolrI )�oselfrl r8 rH � localLock�r# rc r" r& r? " s �� zXDistTrialRunnerTests.test_runUsedDirectory.<locals>.CountingReactorWithLock.spawnProcessN)r( r) r* r? r" r� r" r& �CountingReactorWithLock! s r� � _trial_temp�.lockr� N)r- rd r� �mkdirr: r� r r� r� �unlockre �_workingDirectoryrm r r} r� r rI )r# r� � newDirectoryr� r1 r� r� r� r" r� r& �test_runUsedDirectory s z*DistTrialRunnerTests.test_runUsedDirectoryc C sJ g }t |�}| �| j|� | j�t� |� | �|jd� | �|jd� dS )zh L{DistTrialRunner} doesn't try to start more workers than the number of tests. r2 N) r- r� rm re rI r rV rC r5 )r# r1 r� r" r" r& �test_minimalWorkerC s z'DistTrialRunnerTests.test_minimalWorkerc C sP g }t |�}| �| j|� d| j_| j�t� |�}| �|t� | �|j t � dS )z� Running with the C{unclean-warnings} option makes L{DistTrialRunner} uses the L{UncleanWarningsReporterWrapper}. TN) r- r� rm re �_uncleanWarningsrI r r r �originalr )r# r1 r� ru r" r" r& �test_runUncleanWarningsP s z,DistTrialRunnerTests.test_runUncleanWarningsc C sN t � }t� }| j�||�}| �|t� | jj�� }| �d|� | �d|� dS )z� When the suite contains no test, L{DistTrialRunner} takes a shortcut path without launching any process or starting the reactor. �Running 0 test�PASSEDN) rx r re rI r r rf �getvalue�assertIn)r# r� r� ru �outputr" r" r& �test_runWithoutTest^ s z(DistTrialRunnerTests.test_runWithoutTestc C s~ t � }tdttd���}| j�||�}| �|t� | jj� � }| � d|� | � d|� | � d|� | � d|� | � d|� dS )z� Even if there is no test, the suite can contain an error (most likely, an import error): this should make the run fail, and the error should be printed. zan errorzfoo barr� zerrors=1�FAILEDN) rx r r � RuntimeErrorre rI r r rf r� r� )r# r� r ru r� r" r" r& �!test_runWithoutTestButWithAnErrork s z6DistTrialRunnerTests.test_runWithoutTestButWithAnErrorc C s� G dd� dt �}| �� \}}g }||�}| �| j|� | j�t� ||j�}| �|j d� | �|j d� |� � | �dt |j j�� dS )zw If for some reasons we can't connect to the worker process, the test suite catches and fails. c @ � e Zd Zdd� Zdd� ZdS )zMDistTrialRunnerTests.test_runUnexpectedError.<locals>.CountingReactorWithFailc _ �4 | j �|� |�t� � | jd7 _| j|j_d S �Nr2 )r0 r3 r4 r r5 � failingRunr� rI �r# rl r8 rH r" r" r& r? � � zZDistTrialRunnerTests.test_runUnexpectedError.<locals>.CountingReactorWithFail.spawnProcessc S s t td��S )N�oops)r r� �r# �caseru r" r" r& r� � s zXDistTrialRunnerTests.test_runUnexpectedError.<locals>.CountingReactorWithFail.failingRunN)r( r) r* r? r� r" r" r" r& �CountingReactorWithFail� � r� r2 N)r- rq r� rm re rI r � cooperaterV rC r5 �pumpr\ r� �failures)r# r� rn rp r1 r� ru r" r" r& �test_runUnexpectedError| s z,DistTrialRunnerTests.test_runUnexpectedErrorc s� G dd� dt �}�jj�g }||�� �j�t� � � � ��fdd�}��t� j�� �dg� ��t� jd �dg� �� |� t t d|�S )zz L{DistTrialRunner} calls C{reactor.stop} and unlocks the test directory once the tests have run. c @ r� )zODistTrialRunnerTests.test_runStopAfterTests.<locals>.CountingReactorWithSuccessc _ r� r� �r0 r3 r4 r r5 � succeedingRunr� rI r� r" r" r& r? � r� z\DistTrialRunnerTests.test_runStopAfterTests.<locals>.CountingReactorWithSuccess.spawnProcessc S r� r. r� r� r" r" r& r� � s z]DistTrialRunnerTests.test_runStopAfterTests.<locals>.CountingReactorWithSuccess.succeedingRunN�r( r) r* r? r� r" r" r" r& �CountingReactorWithSuccess� r� r� c �, t �d �} ��| �� � ��d� j� d S )Nr� r2 �r rT r� rV rA �r� �r� r# rc r" r& �check� s z:DistTrialRunnerTests.test_runStopAfterTests.<locals>.check�before�shutdownr ) r- re r� rI r rV �list�triggers�keysrm r r )r# r� r1 r� r" r� r& �test_runStopAfterTests� s z+DistTrialRunnerTests.test_runStopAfterTestsc s� g }�j j�t|�� �j �t� � � �fdd�}� ��fdd����t� j�� �dg� ��t� jd �dg� �� |� t dd� � jd d D ��� |�S ) z� L{DistTrialRunner} waits for the worker processes to stop when the reactor is stopping, and then unlocks the test directory, not trying to stop the reactor again. c s t td� �S )Nr )r r )�ign)� realCheckr" r& r� � s zEDistTrialRunnerTests.test_runWaitForProcessesDeferreds.<locals>.checkc r� )Nr� r r� r� r� r" r& r� � s zIDistTrialRunnerTests.test_runWaitForProcessesDeferreds.<locals>.realCheckr� r� c S s( g | ]\}}}t |g|�R i |���qS r" )r )ry rG �a�kwr" r" r& r{ � s ��zJDistTrialRunnerTests.test_runWaitForProcessesDeferreds.<locals>.<listcomp>) re r� r- rI r rV r� r� r� rm r � addCallback)r# r1 r� r" )r� r� r# rc r& �!test_runWaitForProcessesDeferreds� s ���z6DistTrialRunnerTests.test_runWaitForProcessesDeferredsc s� g � G � fdd�dt �}g }||�}| �| j|� | �� \}}| jjt� ||jdd�}|�� | � dt � �� | � |� � � | jj �� }| �d|� | �d|� dS ) z L{DistTrialRunner} can run in C{untilFailure} mode where it will run the given tests until they fail. c s e Zd Zdd� Z� fdd�ZdS )zMDistTrialRunnerTests.test_runUntilFailure.<locals>.CountingReactorWithSuccessc _ r� r� r� r� r" r" r& r? � r� zZDistTrialRunnerTests.test_runUntilFailure.<locals>.CountingReactorWithSuccess.spawnProcessc s* � � d � t� �dkrttd��S td �S )N� r� )r3 r\ r r� r r� ��calledr" r& r� � s z[DistTrialRunnerTests.test_runUntilFailure.<locals>.CountingReactorWithSuccess.succeedingRunNr� r" r� r" r& r� � s r� T)r� � untilFailurer� r� �FAILN)r- r� rm rq re rI r r� r� rV r\ rR � wasSuccessfulrf r� r� )r# r� r1 r� rn rp ru r� r" r� r& �test_runUntilFailure� s � z)DistTrialRunnerTests.test_runUntilFailureN)r( r) r* r+ rK rm rq rv r� r� r^ r� r� r� r� r� r� r� r� r� r" r" r" r& ra � s$ ( " !ra )7r+ r� rS �ior �zope.interfacer r �twisted.internetr r r �twisted.internet.deferr r r r �twisted.internet.mainr �twisted.internet.protocolr r �twisted.internet.taskr r �twisted.python.failurer �twisted.python.lockfiler �twisted.test.proto_helpersr � twisted.test.test_cooperatorr � twisted.trial._dist.distreporterr � twisted.trial._dist.disttrialr �twisted.trial._dist.workerr �twisted.trial.reporterr r r �twisted.trial.runnerr r �twisted.trial.unittestr r r rM r- rJ r_ ra r" r" r" r& �<module> s4 :8 PK Mb�Z#�� A A 8 trial/_dist/test/__pycache__/test_worker.cpython-310.pycnu �[��� o 5�@gn= � @ sR d Z ddlZddlZddlmZmZ ddlmZ ddlm Z m Z ddl m Z ddl mZmZ ddlmZ dd lmZ dd lmZ dd lmZ dd lmZ dd lmZ ddl m Z ddl m Z m Z ddl!m"Z"m#Z#m$Z$m%Z% ddl&m'Z' ddl(m)Z) G dd� de�Z*G dd� de)�Z+G dd� de)�Z,G dd� de#�Z-G dd � d �Z.G d d � d e)�Z/dS ) z) Test for distributed trial worker side. � N)�BytesIO�StringIO)� verifyObject)�fail�succeed)�ConnectionDone)�IAddress� ITransport)�CONNECTION_DONE)�AMP)�Failure)�FilePath)�fullyQualifiedName)�trial)�StringTransport)�managercommands�workercommands)� LocalWorker�LocalWorkerAMP�LocalWorkerTransport�WorkerProtocol)� TestResult)�TestCasec @ s e Zd ZdZdS )�FakeAMPz A fake amp protocol. N)�__name__� __module__� __qualname__�__doc__� r r �F/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_worker.pyr # s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �WorkerProtocolTestsz& Tests for L{WorkerProtocol}. c C s@ t � | _t � | _t� | _| j�| j� t� | _| j�| j� dS )zN Set up a transport, a result stream and a protocol instance. N)r �serverTransport�clientTransportr �server�makeConnectionr �client��selfr r r �setUp. s zWorkerProtocolTests.setUpc sd � j jtjdd�}� fdd�}|�|� � j�� j�� � � j� � � j �� j �� � � j � � |S )z� Calling the L{workercommands.Run} command on the client returns a response with C{success} sets to C{True}. � doesntexist)�testCasec s � � | d � d S �N�success)� assertTrue��resultr& r r �check@ � z+WorkerProtocolTests.test_run.<locals>.check) r% � callRemoter �Run� addCallbackr# � dataReceivedr" �value�clearr! )r' �dr0 r r& r �test_run9 s z WorkerProtocolTests.test_runc C sF t j�t jj�}| �t j|� | j�d� | �t j�t jj�|� dS )z@ The C{start} command changes the current path. z..N) �os�path�realpath�curdir� addCleanup�chdirr# �start�assertNotEqual)r' r= r r r � test_startJ s z WorkerProtocolTests.test_startN)r r r r r( r9 rB r r r r r ) s r c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�LocalWorkerAMPTestszR Test case for distributed trial's manager-side local worker AMP protocol c C s� t � | _t� | _| j�| j� t� | _t � | _t� | _ | j �| j� t � � }d| _ |d � | j � t �|�j�� | _| j�| j| j� | j�� d S )Nztwisted.doesnexist�tests)r �managerTransportr � managerAMPr$ r r/ �workerTransportr �workerr �Options�testName�append� _getSuite�_tests�popr* �runr7 )r' �configr r r r( Y s zLocalWorkerAMPTests.setUpc C s2 | j �| j�� � | j�� | j�| j�� � dS )z� Sends data from C{self.workerTransport} to C{self.managerAMP}, and then data from C{self.managerTransport} back to C{self.worker}. N)rF r5 rG r6 r7 rH rE r& r r r �pumpTransportsj s z"LocalWorkerAMPTests.pumpTransportsc s@ g � | j jtj| jd�}|�� fdd�� | �� | �� � dS )z* Run a test, and succeed. )rJ c � � � | d �S r+ �rK r. ��resultsr r �<lambda>z � z5LocalWorkerAMPTests.test_runSuccess.<locals>.<lambda>N)rH r2 r � AddSuccessrJ r4 rQ r- �r' r8 r rT r �test_runSuccesss s z#LocalWorkerAMPTests.test_runSuccessc s^ g � | j jtj| jddd�}|�� fdd�� | �� | �| j| j j d d � | � � � dS )z2 Run a test, and fail expectedly. �error� todoReason)rJ r[ �todoc rR r+ rS r. rT r r rV � rW z=LocalWorkerAMPTests.test_runExpectedFailure.<locals>.<lambda>r N) rH r2 r �AddExpectedFailurerJ r4 rQ � assertEqualr* r/ �expectedFailuresr- rY r rT r �test_runExpectedFailure s �z+LocalWorkerAMPTests.test_runExpectedFailurec �h g � t t�}| jjtj| jd|g d�}|�� fdd�� | �� | � | j | j j d d � | � � � dS )z5 Run a test, and encounter an error. r[ �rJ r[ � errorClass�framesc rR r+ rS r. rT r r rV � rW z3LocalWorkerAMPTests.test_runError.<locals>.<lambda>r N)r � ValueErrorrH r2 r �AddErrorrJ r4 rQ r_ r* r/ �errorsr- �r' rd r8 r rT r � test_runError� � �z!LocalWorkerAMPTests.test_runErrorc s� g � t t�}| jjtj| jd|g d�d�}|�� fdd�� | �� | � | j | j j d d � | � ddd g g fg| j j d d j � | �� � d S ) z� L{LocalWorkerAMP._buildFailure} recreates the C{Failure.frames} from the C{frames} argument passed to C{AddError}. r[ )�file.py� invalid code�3rc c rR r+ rS r. rT r r rV � rW z=LocalWorkerAMPTests.test_runErrorWithFrames.<locals>.<lambda>r rl rm � � N)r rf rH r2 r rg rJ r4 rQ r_ r* r/ rh re r- ri r rT r �test_runErrorWithFrames� s � �z+LocalWorkerAMPTests.test_runErrorWithFramesc rb )z' Run a test, and fail. r )rJ r � failClassre c rR r+ rS r. rT r r rV � rW z5LocalWorkerAMPTests.test_runFailure.<locals>.<lambda>r N)r � RuntimeErrorrH r2 r � AddFailurerJ r4 rQ r_ r* r/ �failuresr- )r' rr r8 r rT r �test_runFailure� rk z#LocalWorkerAMPTests.test_runFailurec �\ g � | j jtj| jdd�}|�� fdd�� | �� | �| j| j j d d � | � � � dS )z* Run a test, but skip it. �reason)rJ rx c rR r+ rS r. rT r r rV � rW z2LocalWorkerAMPTests.test_runSkip.<locals>.<lambda>r N) rH r2 r �AddSkiprJ r4 rQ r_ r* r/ �skipsr- rY r rT r � test_runSkip� � �z LocalWorkerAMPTests.test_runSkipc rw )z7 Run a test, and succeed unexpectedly. r] )rJ r] c rR r+ rS r. rT r r rV � rW zALocalWorkerAMPTests.test_runUnexpectedSuccesses.<locals>.<lambda>r N) rH r2 r �AddUnexpectedSuccessrJ r4 rQ r_ r* r/ �unexpectedSuccessesr- rY r rT r �test_runUnexpectedSuccesses� r| z/LocalWorkerAMPTests.test_runUnexpectedSuccessesc sd g � t � }| j�|� tj}| jj|dd�}|�� fdd�� | �� | � d|� � � | � � � dS )zb L{LocalWorkerAMP.testWrite} writes the data received to its test stream. z Some output)�outc rR r+ rS r. rT r r rV � rW z4LocalWorkerAMPTests.test_testWrite.<locals>.<lambda>z Some output N) r rF � setTestStreamr � TestWriterH r2 r4 rQ r_ �getvaluer- )r' �stream�commandr8 r rT r �test_testWrite� s z"LocalWorkerAMPTests.test_testWritec sb t � � g �� fdd�}|| j_G �fdd�dt�}| j�| j|� �}| �| jg�� |�| j� �S )z| L{LocalWorkerAMP.run} calls C{stopTest} on its test result once the C{Run} commands has succeeded. c s t � �S �N)r )r� r* r. r r �fakeCallRemote s z=LocalWorkerAMPTests.test_stopAfterRun.<locals>.fakeCallRemotec s e Zd Z� fdd�ZdS )z=LocalWorkerAMPTests.test_stopAfterRun.<locals>.StopTestResultc s � � |� d S r� rS )r' �test��stoppedr r �stopTest s zFLocalWorkerAMPTests.test_stopAfterRun.<locals>.StopTestResult.stopTestN)r r r r� r r� r r �StopTestResult s r� ) �objectrF r2 r rO r* r_ r4 �assertIdentical)r' r� r� r8 r )r/ r� r �test_stopAfterRun� s z%LocalWorkerAMPTests.test_stopAfterRunN)r r r r r( rQ rZ ra rj rq rv r{ r r� r� r r r r rC T s rC c @ s e Zd ZdZdZdZdd� ZdS )�SpyDataLocalWorkerAMPz� A fake implementation of L{LocalWorkerAMP} that records the received data and doesn't automatically dispatch any command.. r � c C s | j |7 _ d S r� �� dataString)r' �datar r r r5 r1 z"SpyDataLocalWorkerAMP.dataReceivedN)r r r r �idr� r5 r r r r r� s r� c @ s( e Zd ZdZdZdZdd� Zdd� ZdS ) � FakeTransportz> A fake process transport implementation for testing. r� r c C s | j |7 _ d S r� r� )r' �fdr� r r r � writeToChild( r1 zFakeTransport.writeToChildc C s | j d7 _ d S )Nrp )�callsr& r r r �loseConnection+ r1 z FakeTransport.loseConnectionN)r r r r r� r� r� r� r r r r r� s r� c @ sx e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd S ) �LocalWorkerTestsz? Tests for L{LocalWorker} and L{LocalWorkerTransport}. c O sH t |i |��}|�t� � | �|jj� | �|jj� | �|jj� |S )z� Create a L{LocalWorker}, connect it to a transport, and ensure its log files are closed. @param args: See L{LocalWorker} @param kwargs: See L{LocalWorker} @return: a L{LocalWorker} instance )r r$ r� r> �_testLog�close�_outLog�_errLog)r' �args�kwargsrH r r r �tidyLocalWorker4 s z LocalWorkerTests.tidyLocalWorkerc C sV | � t� dd�}t� |_|�dd� |�dd� | �d|jj� | �d|j�� � dS )z� L{LocalWorker.childDataReceived} forwards the received data to linked L{AMP} protocol if the right file descriptor, otherwise forwards to C{ProcessProtocol.childDataReceived}. �.�test.log� s foorp s barN) r� r� r r� �childDataReceivedr_ � _ampProtocolr� r� �r' � localWorkerr r r �test_childDataReceivedF s z'LocalWorkerTests.test_childDataReceivedc C s� t � }t| �� �}|�d�}t�� }| �tjtj|� t�tjd� t ||j d�}|� t � � | �|j j� | �|jj� z |�d� W |j�� n|j�� w | �dtj�d� |�� � dS )z� L{LocalWorker} write the log data with local newlines but in UTF-8 encoding regardless of the default encoding. r� )�C�asciiu Here comes the ☉!s Here comes the ☉!r� N)r� r �mktemp�child�locale� getlocaler> � setlocale�LC_ALLr r; r$ r� r� r� r� � testWriter� r_ r: �linesep�encode� getContent)r' �amp�tempDir�logFile� currentLocalerH r r r �_test_unicodeLogFileUTF8S s" �z)LocalWorkerTests._test_unicodeLogFileUTF8c C �< | � t� dd�}t� |_d}|�|� | �||j�� � dS )zb L{LocalWorker.outReceived} logs the output into its C{_outLog} log file. r� r� �+ The quick brown fox jumps over the lazy dogN)r� r� r r� � outReceivedr_ r� �r' r� r� r r r �test_outReceivedr � z!LocalWorkerTests.test_outReceivedc C r� )zb L{LocalWorker.errReceived} logs the errors into its C{_errLog} log file. r� r� r� N)r� r� r r� � errReceivedr_ r� r� r r r �test_errReceived} r� z!LocalWorkerTests.test_errReceivedc C s. t � }t|�}d}|�|� | �||j� dS )zi L{LocalWorkerTransport.write} forwards the written data to the given transport. r� N)r� r �writer_ r� �r' � transport�localTransportr� r r r � test_write� s zLocalWorkerTests.test_writec C s4 t � }t|�}d}|�|� | �d�|�|j� dS )zq L{LocalWorkerTransport.writeSequence} forwards the written data to the given transport. )s The quick s brown fox jumps s over the lazy dogr� N)r� r � writeSequencer_ �joinr� r� r r r �test_writeSequence� s z#LocalWorkerTests.test_writeSequencec C s( t � }t|�}|�� | �|jd� dS )zj L{LocalWorkerTransport.loseConnection} forwards the call to the given transport. rp N)r� r r� r_ r� )r' r� r� r r r �test_loseConnection� s z$LocalWorkerTests.test_loseConnectionc C sH | � t� dd�}|�d� | �|jj� | �|jj� | �|jj� dS )zG L{LocalWorker.connectionLost} closes the log streams. r� r� N)r� r� �connectionLostr- r� �closedr� r� r� r r r �test_connectionLost� s z$LocalWorkerTests.test_connectionLostc C sv t � }t� }t|dd�}|�|� |�tt�� | �|jj � | �|j j � | �|j j � | � d|j � | �|jt�S )zs L{LocalWorker.processEnded} calls C{connectionLost} on itself and on the L{AMP} protocol. r� r� N)r� r� r r$ � processEndedr r r- r� r� r� r� r� r� � assertFailure� endDeferredr )r' r� �protocolr� r r r �test_processEnded� s z"LocalWorkerTests.test_processEndedc C s4 t d�}| �tt|�� �� | �tt|�� �� dS )zy L{LocalWorkerTransport.getPeer} and L{LocalWorkerTransport.getHost} return L{IAddress} objects. N)r r- r r �getPeer�getHost�r' r� r r r �test_addresses� s z LocalWorkerTests.test_addressesc C s t d�}| �tt|�� dS )zk L{LocalWorkerTransport} implements L{ITransport} to be able to be used by L{AMP}. N)r r- r r r� r r r �test_transport� s z LocalWorkerTests.test_transportc C s8 dd� }t � }||_| �|dd� | �g | �t�� dS )z� L{LocalWorker} swallows the exceptions returned by the L{AMP} protocol start method, as it generates unnecessary errors. c S s t td��S )N�oops)r rs )r� � directoryr r r �failCallRemote� s z8LocalWorkerTests.test_startError.<locals>.failCallRemoter� r� N)r� r2 r� r_ �flushLoggedErrorsrs )r' r� r� r r r �test_startError� s z LocalWorkerTests.test_startErrorN)r r r r r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� / s r� )0r r� r: �ior r �zope.interface.verifyr �twisted.internet.deferr r �twisted.internet.errorr �twisted.internet.interfacesr r �twisted.internet.mainr �twisted.protocols.ampr �twisted.python.failurer �twisted.python.filepathr �twisted.python.reflectr �twisted.scriptsr �twisted.test.proto_helpersr �twisted.trial._distr r �twisted.trial._dist.workerr r r r �twisted.trial.reporterr �twisted.trial.unittestr r r rC r� r� r� r r r r �<module> s4 + @ PK Mb�Z��'{ { @ trial/_dist/test/__pycache__/test_workerreporter.cpython-310.pycnu �[��� o �b% � @ sZ d Z ddlmZ ddlmZ ddlmZ ddlmZm Z G dd� d�Z G dd � d e�Z d S ) z2 Tests for L{twisted.trial._dist.workerreporter}. � )�Failure)�managercommands)�WorkerReporter)�TestCase�Todoc @ s e Zd ZdZdZdZdd� ZdS )�FakeAMProtocolzE A fake C{AMP} implementations to track C{callRemote} calls. r Nc K s || _ || _d S �N)�lastCall�lastArgs)�self�command�kwargs� r �N/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_workerreporter.py� callRemote s zFakeAMProtocol.callRemote)�__name__� __module__� __qualname__�__doc__�idr r r r r r r s r c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�WorkerReporterTestsz& Tests for L{WorkerReporter}. c C s t � | _t| j�| _t� | _d S r )r �fakeAMProtocolr �workerReporterr �test�r r r r �setUp s zWorkerReporterTests.setUpc C �$ | j �| j� | �| jjtj� dS )ze L{WorkerReporter.addSuccess} sends a L{managercommands.AddSuccess} command. N)r � addSuccessr � assertEqualr r r � AddSuccessr r r r �test_addSuccess% s z#WorkerReporterTests.test_addSuccessc C �. | j �| jttd��� | �| jjtj � dS )zY L{WorkerReporter.addError} sends a L{managercommands.AddError} command. �errorN) r �addErrorr r � RuntimeErrorr r r r �AddErrorr r r r � test_addError- s z!WorkerReporterTests.test_addErrorc C �0 | j �| jttd�df� | �| jjtj� dS )z� Adding an error using L{WorkerReporter.addError} as a C{sys.exc_info}-style tuple sends an L{managercommands.AddError} command. r" N) r r# r r$ r r r r r% r r r r �test_addErrorTuple4 � �z&WorkerReporterTests.test_addErrorTuplec C r! )ze L{WorkerReporter.addFailure} sends a L{managercommands.AddFailure} command. �failN) r � addFailurer r r$ r r r r � AddFailurer r r r �test_addFailure? s z#WorkerReporterTests.test_addFailurec C r' )z� Adding a failure using L{WorkerReporter.addFailure} as a C{sys.exc_info}-style tuple sends an L{managercommands.AddFailure} message. r* N) r r+ r r$ r r r r r, r r r r �test_addFailureTupleG r) z(WorkerReporterTests.test_addFailureTuplec C s& | j �| jd� | �| jjtj� dS )zW L{WorkerReporter.addSkip} sends a L{managercommands.AddSkip} command. �reasonN)r �addSkipr r r r r �AddSkipr r r r � test_addSkipR s z WorkerReporterTests.test_addSkipc C s4 | j �| jttd��td�� | �| jjt j � dS )�� L{WorkerReporter.addExpectedFailure} sends a L{managercommands.AddExpectedFailure} command. protocol. r" �todoN) r �addExpectedFailurer r r$ r r r r r �AddExpectedFailurer r r r �test_addExpectedFailureY s � �z+WorkerReporterTests.test_addExpectedFailurec C r! )r3 r" N) r r5 r r r$ r r r r r6 r r r r � test_addExpectedFailureNoTodof s � �z1WorkerReporterTests.test_addExpectedFailureNoTodoc C s* | j �| jtd�� | �| jjtj� dS )�y L{WorkerReporter.addUnexpectedSuccess} sends a L{managercommands.AddUnexpectedSuccess} command. r4 N) r �addUnexpectedSuccessr r r r r r �AddUnexpectedSuccessr r r r �test_addUnexpectedSuccesss s �z-WorkerReporterTests.test_addUnexpectedSuccessc C r )r9 N)r r: r r r r r r; r r r r � test_addUnexpectedSuccessNoTodo} s �z3WorkerReporterTests.test_addUnexpectedSuccessNoTodoN)r r r r r r r& r( r- r. r2 r7 r8 r< r= r r r r r s r N) r �twisted.python.failurer �twisted.trial._distr �"twisted.trial._dist.workerreporterr �twisted.trial.unittestr r r r r r r r �<module> s PK Mb�Z;�Ȑ � = trial/_dist/test/__pycache__/test_workertrial.cpython-310.pycnu �[��� o �bd � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl m Z m Z m Z mZmZ ddlmZmZmZ ddlmZ G d d � d e�ZG d d � d e�ZG d d� de�ZG dd� de�ZdS )z/ Tests for L{twisted.trial._dist.workertrial}. � N)�BytesIO)�AMP)�StringTransport)�_WORKER_AMP_STDIN�_WORKER_AMP_STDOUT�managercommands�workercommands� workertrial)�WorkerLogObserver� _setupPath�main)�TestCasec @ s e Zd ZdZdS )�FakeAMPz A fake amp protocol. N)�__name__� __module__� __qualname__�__doc__� r r �K/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_workertrial.pyr s r c @ � e Zd ZdZdd� ZdS )�WorkerLogObserverTestsz) Tests for L{WorkerLogObserver}. c sL g � G � fdd�d�}t |� �}|�ddgi� | �� tjddifg� dS )zU L{WorkerLogObserver} forwards data to L{managercommands.TestWrite}. c s e Zd Z� fdd�ZdS )z4WorkerLogObserverTests.test_emit.<locals>.FakeClientc s � � ||f� d S �N)�append)�self�method�kwargs��callsr r � callRemote, s z?WorkerLogObserverTests.test_emit.<locals>.FakeClient.callRemoteN)r r r r r r r r � FakeClient+ s r �messagezSome log�outN)r �emit� assertEqualr � TestWrite)r r �observerr r r � test_emit% s z WorkerLogObserverTests.test_emitN)r r r r r& r r r r r s r c @ sJ e Zd ZdZdd� Zddd�Zdd� Zd d � Zd d � Zd d� Z dd� Z dS )� MainTestsz Tests for L{main}. c C s> t � | _t � | _| �td| j� | �ttdtj � dgt_ d S )N�startLoggingWithObserver�argv�trial) r � readStream� writeStream�patchr r( � addCleanup�setattr�sysr) �r r r r �setUp9 s � zMainTests.setUpNc C sB |t kr | �d|� | jS |tkr| �d|� | jS td|����)z� Fake C{os.fdopen} implementation which returns C{self.readStream} for the stdin fd and C{self.writeStream} for the stdout fd. �rb�wbzUnexpected fd )r �assertIdenticalr+ r r# r, �AssertionError)r �fd�moder r r �fdopenB s zMainTests.fdopenc C s | � |� dS )zP Override C{startLoggingWithObserver} for not starting logging. N)� assertFalse)r r" � setStdoutr r r r( P s z"MainTests.startLoggingWithObserverc C s t | j� | �d| j�� � dS )zU If no data is ever written, L{main} exits without writing data out. � N)r r9 r# r, �getvaluer1 r r r � test_emptyV s zMainTests.test_emptyc C s\ t � }t� }|�|� |jtjdd� |j| _| j�dd� t | j � | � d| j � � � dS )z� L{main} forwards data from its input stream to a L{WorkerProtocol} instance which writes data to the output stream. � doesntexist)�testCaser s No module named 'doesntexist'N)r r �makeConnectionr r �Run�ior+ �seekr r9 �assertInr, r= )r �client�clientTransportr r r �test_forwardCommand] s z MainTests.test_forwardCommandc sL g � G � fdd�d�}|� | _ t| j� | �d| j�� � | �dg� � dS )z� If reading the input stream fails with a C{IOError} with errno C{EINTR}, L{main} ignores it and continues reading. c s e Zd ZdZ� fdd�ZdS )z2MainTests.test_readInterrupted.<locals>.FakeStreamr c s4 | j d7 _ | j dkrttj��� �t�� � dS )N� r< )�count�OSError�errno�EINTRr r0 �exc_info��oself�size��excInfosr r �readu s z7MainTests.test_readInterrupted.<locals>.FakeStream.readN�r r r rJ rT r rR r r � FakeStreamr s rV r< )NNNN)r+ r r9 r# r, r= �r rV r rR r �test_readInterruptedk s z MainTests.test_readInterruptedc C s* G dd� d�}|� | _ | �tt| j� dS )zm L{main} only ignores C{IOError} with C{EINTR} errno: otherwise, the error pops out. c @ r )z1MainTests.test_otherReadError.<locals>.FakeStreamr c S s$ | j d7 _ | j dkrtd��dS )NrI zSomething else� )rJ rK rO r r r rT � s z6MainTests.test_otherReadError.<locals>.FakeStream.readNrU r r r r rV � s rV N)r+ � assertRaises�IOErrorr r9 rW r r r �test_otherReadError� s z MainTests.test_otherReadErrorr ) r r r r r2 r9 r( r> rH rX r\ r r r r r' 4 s r' c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �SetupPathTestsz; Tests for L{_setupPath} C{sys.path} manipulation. c C s | � ttdtjd d � � d S )N�path)r. r/ r0 r^ r1 r r r r2 � s zSetupPathTests.setUpc C s2 dt j�ddg�i}t|� | �ddgtj� dS )zu L{_setupPath} overrides C{sys.path} if B{TRIAL_PYTHONPATH} is specified in the environment. �TRIAL_PYTHONPATH�foo�barN)�os�pathsep�joinr r# r0 r^ )r �environr r r �test_overridePath� s z SetupPathTests.test_overridePathc C s( t jdd� }ti � | �|t j� dS )z| L{_setupPath} doesn't change C{sys.path} if B{TRIAL_PYTHONPATH} is not present in the environment. N)r0 r^ r r# )r � originalPathr r r �test_noVariable� s z SetupPathTests.test_noVariableN)r r r r r2 rf rh r r r r r] � s r] )r rL rb r0 rC r �twisted.protocols.ampr �twisted.test.proto_helpersr �twisted.trial._distr r r r r � twisted.trial._dist.workertrialr r r �twisted.trial.unittestr r r r' r] r r r r �<module> s aPK Mb�Z4�O�n= n= trial/_dist/test/test_worker.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test for distributed trial worker side. """ import locale import os from io import BytesIO, StringIO from zope.interface.verify import verifyObject from twisted.internet.defer import fail, succeed from twisted.internet.error import ConnectionDone from twisted.internet.interfaces import IAddress, ITransport from twisted.internet.main import CONNECTION_DONE from twisted.protocols.amp import AMP from twisted.python.failure import Failure from twisted.python.filepath import FilePath from twisted.python.reflect import fullyQualifiedName from twisted.scripts import trial from twisted.test.proto_helpers import StringTransport from twisted.trial._dist import managercommands, workercommands from twisted.trial._dist.worker import ( LocalWorker, LocalWorkerAMP, LocalWorkerTransport, WorkerProtocol, ) from twisted.trial.reporter import TestResult from twisted.trial.unittest import TestCase class FakeAMP(AMP): """ A fake amp protocol. """ class WorkerProtocolTests(TestCase): """ Tests for L{WorkerProtocol}. """ def setUp(self): """ Set up a transport, a result stream and a protocol instance. """ self.serverTransport = StringTransport() self.clientTransport = StringTransport() self.server = WorkerProtocol() self.server.makeConnection(self.serverTransport) self.client = FakeAMP() self.client.makeConnection(self.clientTransport) def test_run(self): """ Calling the L{workercommands.Run} command on the client returns a response with C{success} sets to C{True}. """ d = self.client.callRemote(workercommands.Run, testCase="doesntexist") def check(result): self.assertTrue(result["success"]) d.addCallback(check) self.server.dataReceived(self.clientTransport.value()) self.clientTransport.clear() self.client.dataReceived(self.serverTransport.value()) self.serverTransport.clear() return d def test_start(self): """ The C{start} command changes the current path. """ curdir = os.path.realpath(os.path.curdir) self.addCleanup(os.chdir, curdir) self.server.start("..") self.assertNotEqual(os.path.realpath(os.path.curdir), curdir) class LocalWorkerAMPTests(TestCase): """ Test case for distributed trial's manager-side local worker AMP protocol """ def setUp(self): self.managerTransport = StringTransport() self.managerAMP = LocalWorkerAMP() self.managerAMP.makeConnection(self.managerTransport) self.result = TestResult() self.workerTransport = StringTransport() self.worker = AMP() self.worker.makeConnection(self.workerTransport) config = trial.Options() self.testName = "twisted.doesnexist" config["tests"].append(self.testName) self.testCase = trial._getSuite(config)._tests.pop() self.managerAMP.run(self.testCase, self.result) self.managerTransport.clear() def pumpTransports(self): """ Sends data from C{self.workerTransport} to C{self.managerAMP}, and then data from C{self.managerTransport} back to C{self.worker}. """ self.managerAMP.dataReceived(self.workerTransport.value()) self.workerTransport.clear() self.worker.dataReceived(self.managerTransport.value()) def test_runSuccess(self): """ Run a test, and succeed. """ results = [] d = self.worker.callRemote(managercommands.AddSuccess, testName=self.testName) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertTrue(results) def test_runExpectedFailure(self): """ Run a test, and fail expectedly. """ results = [] d = self.worker.callRemote( managercommands.AddExpectedFailure, testName=self.testName, error="error", todo="todoReason", ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.expectedFailures[0][0]) self.assertTrue(results) def test_runError(self): """ Run a test, and encounter an error. """ results = [] errorClass = fullyQualifiedName(ValueError) d = self.worker.callRemote( managercommands.AddError, testName=self.testName, error="error", errorClass=errorClass, frames=[], ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.errors[0][0]) self.assertTrue(results) def test_runErrorWithFrames(self): """ L{LocalWorkerAMP._buildFailure} recreates the C{Failure.frames} from the C{frames} argument passed to C{AddError}. """ results = [] errorClass = fullyQualifiedName(ValueError) d = self.worker.callRemote( managercommands.AddError, testName=self.testName, error="error", errorClass=errorClass, frames=["file.py", "invalid code", "3"], ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.errors[0][0]) self.assertEqual( [("file.py", "invalid code", 3, [], [])], self.result.errors[0][1].frames ) self.assertTrue(results) def test_runFailure(self): """ Run a test, and fail. """ results = [] failClass = fullyQualifiedName(RuntimeError) d = self.worker.callRemote( managercommands.AddFailure, testName=self.testName, fail="fail", failClass=failClass, frames=[], ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.failures[0][0]) self.assertTrue(results) def test_runSkip(self): """ Run a test, but skip it. """ results = [] d = self.worker.callRemote( managercommands.AddSkip, testName=self.testName, reason="reason" ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.skips[0][0]) self.assertTrue(results) def test_runUnexpectedSuccesses(self): """ Run a test, and succeed unexpectedly. """ results = [] d = self.worker.callRemote( managercommands.AddUnexpectedSuccess, testName=self.testName, todo="todo" ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.unexpectedSuccesses[0][0]) self.assertTrue(results) def test_testWrite(self): """ L{LocalWorkerAMP.testWrite} writes the data received to its test stream. """ results = [] stream = StringIO() self.managerAMP.setTestStream(stream) command = managercommands.TestWrite d = self.worker.callRemote(command, out="Some output") d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual("Some output\n", stream.getvalue()) self.assertTrue(results) def test_stopAfterRun(self): """ L{LocalWorkerAMP.run} calls C{stopTest} on its test result once the C{Run} commands has succeeded. """ result = object() stopped = [] def fakeCallRemote(command, testCase): return succeed(result) self.managerAMP.callRemote = fakeCallRemote class StopTestResult(TestResult): def stopTest(self, test): stopped.append(test) d = self.managerAMP.run(self.testCase, StopTestResult()) self.assertEqual([self.testCase], stopped) return d.addCallback(self.assertIdentical, result) class SpyDataLocalWorkerAMP(LocalWorkerAMP): """ A fake implementation of L{LocalWorkerAMP} that records the received data and doesn't automatically dispatch any command.. """ id = 0 dataString = b"" def dataReceived(self, data): self.dataString += data class FakeTransport: """ A fake process transport implementation for testing. """ dataString = b"" calls = 0 def writeToChild(self, fd, data): self.dataString += data def loseConnection(self): self.calls += 1 class LocalWorkerTests(TestCase): """ Tests for L{LocalWorker} and L{LocalWorkerTransport}. """ def tidyLocalWorker(self, *args, **kwargs): """ Create a L{LocalWorker}, connect it to a transport, and ensure its log files are closed. @param args: See L{LocalWorker} @param kwargs: See L{LocalWorker} @return: a L{LocalWorker} instance """ worker = LocalWorker(*args, **kwargs) worker.makeConnection(FakeTransport()) self.addCleanup(worker._testLog.close) self.addCleanup(worker._outLog.close) self.addCleanup(worker._errLog.close) return worker def test_childDataReceived(self): """ L{LocalWorker.childDataReceived} forwards the received data to linked L{AMP} protocol if the right file descriptor, otherwise forwards to C{ProcessProtocol.childDataReceived}. """ localWorker = self.tidyLocalWorker(SpyDataLocalWorkerAMP(), ".", "test.log") localWorker._outLog = BytesIO() localWorker.childDataReceived(4, b"foo") localWorker.childDataReceived(1, b"bar") self.assertEqual(b"foo", localWorker._ampProtocol.dataString) self.assertEqual(b"bar", localWorker._outLog.getvalue()) def _test_unicodeLogFileUTF8(self): """ L{LocalWorker} write the log data with local newlines but in UTF-8 encoding regardless of the default encoding. """ amp = SpyDataLocalWorkerAMP() tempDir = FilePath(self.mktemp()) logFile = tempDir.child("test.log") # Modern OSes are running default locale in UTF-8 and this is what # is used by Python at startup. # For this test, we force an ASCII default encoding. currentLocale = locale.getlocale() self.addCleanup(locale.setlocale, locale.LC_ALL, currentLocale) locale.setlocale(locale.LC_ALL, ("C", "ascii")) worker = LocalWorker(amp, tempDir.path, "test.log") worker.makeConnection(FakeTransport()) self.addCleanup(worker._outLog.close) self.addCleanup(worker._errLog.close) try: amp.testWrite("Here comes the \N{sun}!") finally: worker._testLog.close() self.assertEqual( b"Here comes the \xe2\x98\x89!" + os.linesep.encode("ascii"), logFile.getContent(), ) def test_outReceived(self): """ L{LocalWorker.outReceived} logs the output into its C{_outLog} log file. """ localWorker = self.tidyLocalWorker(SpyDataLocalWorkerAMP(), ".", "test.log") localWorker._outLog = BytesIO() data = b"The quick brown fox jumps over the lazy dog" localWorker.outReceived(data) self.assertEqual(data, localWorker._outLog.getvalue()) def test_errReceived(self): """ L{LocalWorker.errReceived} logs the errors into its C{_errLog} log file. """ localWorker = self.tidyLocalWorker(SpyDataLocalWorkerAMP(), ".", "test.log") localWorker._errLog = BytesIO() data = b"The quick brown fox jumps over the lazy dog" localWorker.errReceived(data) self.assertEqual(data, localWorker._errLog.getvalue()) def test_write(self): """ L{LocalWorkerTransport.write} forwards the written data to the given transport. """ transport = FakeTransport() localTransport = LocalWorkerTransport(transport) data = b"The quick brown fox jumps over the lazy dog" localTransport.write(data) self.assertEqual(data, transport.dataString) def test_writeSequence(self): """ L{LocalWorkerTransport.writeSequence} forwards the written data to the given transport. """ transport = FakeTransport() localTransport = LocalWorkerTransport(transport) data = (b"The quick ", b"brown fox jumps ", b"over the lazy dog") localTransport.writeSequence(data) self.assertEqual(b"".join(data), transport.dataString) def test_loseConnection(self): """ L{LocalWorkerTransport.loseConnection} forwards the call to the given transport. """ transport = FakeTransport() localTransport = LocalWorkerTransport(transport) localTransport.loseConnection() self.assertEqual(transport.calls, 1) def test_connectionLost(self): """ L{LocalWorker.connectionLost} closes the log streams. """ localWorker = self.tidyLocalWorker(SpyDataLocalWorkerAMP(), ".", "test.log") localWorker.connectionLost(None) self.assertTrue(localWorker._outLog.closed) self.assertTrue(localWorker._errLog.closed) self.assertTrue(localWorker._testLog.closed) def test_processEnded(self): """ L{LocalWorker.processEnded} calls C{connectionLost} on itself and on the L{AMP} protocol. """ transport = FakeTransport() protocol = SpyDataLocalWorkerAMP() localWorker = LocalWorker(protocol, ".", "test.log") localWorker.makeConnection(transport) localWorker.processEnded(Failure(CONNECTION_DONE)) self.assertTrue(localWorker._outLog.closed) self.assertTrue(localWorker._errLog.closed) self.assertTrue(localWorker._testLog.closed) self.assertIdentical(None, protocol.transport) return self.assertFailure(localWorker.endDeferred, ConnectionDone) def test_addresses(self): """ L{LocalWorkerTransport.getPeer} and L{LocalWorkerTransport.getHost} return L{IAddress} objects. """ localTransport = LocalWorkerTransport(None) self.assertTrue(verifyObject(IAddress, localTransport.getPeer())) self.assertTrue(verifyObject(IAddress, localTransport.getHost())) def test_transport(self): """ L{LocalWorkerTransport} implements L{ITransport} to be able to be used by L{AMP}. """ localTransport = LocalWorkerTransport(None) self.assertTrue(verifyObject(ITransport, localTransport)) def test_startError(self): """ L{LocalWorker} swallows the exceptions returned by the L{AMP} protocol start method, as it generates unnecessary errors. """ def failCallRemote(command, directory): return fail(RuntimeError("oops")) protocol = SpyDataLocalWorkerAMP() protocol.callRemote = failCallRemote self.tidyLocalWorker(protocol, ".", "test.log") self.assertEqual([], self.flushLoggedErrors(RuntimeError)) PK Mb�Z~�(�� � % trial/_dist/test/test_distreporter.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.trial._dist.distreporter}. """ from io import StringIO from twisted.trial._dist.distreporter import DistReporter from twisted.trial.reporter import TreeReporter from twisted.trial.unittest import TestCase class DistReporterTests(TestCase): """ Tests for L{DistReporter}. """ def setUp(self): self.stream = StringIO() self.distReporter = DistReporter(TreeReporter(self.stream)) self.test = TestCase() def test_startSuccessStop(self): """ Success output only gets sent to the stream after the test has stopped. """ self.distReporter.startTest(self.test) self.assertEqual(self.stream.getvalue(), "") self.distReporter.addSuccess(self.test) self.assertEqual(self.stream.getvalue(), "") self.distReporter.stopTest(self.test) self.assertNotEqual(self.stream.getvalue(), "") def test_startErrorStop(self): """ Error output only gets sent to the stream after the test has stopped. """ self.distReporter.startTest(self.test) self.assertEqual(self.stream.getvalue(), "") self.distReporter.addError(self.test, "error") self.assertEqual(self.stream.getvalue(), "") self.distReporter.stopTest(self.test) self.assertNotEqual(self.stream.getvalue(), "") def test_forwardedMethods(self): """ Calling methods of L{DistReporter} add calls to the running queue of the test. """ self.distReporter.startTest(self.test) self.distReporter.addFailure(self.test, "foo") self.distReporter.addError(self.test, "bar") self.distReporter.addSkip(self.test, "egg") self.distReporter.addUnexpectedSuccess(self.test, "spam") self.distReporter.addExpectedFailure(self.test, "err", "foo") self.assertEqual(len(self.distReporter.running[self.test.id()]), 6) PK Mb�Z�ψ�3 3 trial/_dist/test/test_options.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for distributed trial's options management. """ import gc import os import sys from twisted.trial._dist.options import WorkerOptions from twisted.trial.unittest import TestCase class WorkerOptionsTests(TestCase): """ Tests for L{WorkerOptions}. """ def setUp(self): """ Build an L{WorkerOptions} object to be used in the tests. """ self.options = WorkerOptions() def test_standardOptions(self): """ L{WorkerOptions} supports a subset of standard options supported by trial. """ self.addCleanup(sys.setrecursionlimit, sys.getrecursionlimit()) if gc.isenabled(): self.addCleanup(gc.enable) gc.enable() self.options.parseOptions(["--recursionlimit", "2000", "--disablegc"]) self.assertEqual(2000, sys.getrecursionlimit()) self.assertFalse(gc.isenabled()) def test_coverage(self): """ L{WorkerOptions.coverdir} returns the C{coverage} child directory of the current directory to be used for storing coverage data. """ self.assertEqual( os.path.realpath(os.path.join(os.getcwd(), "coverage")), self.options.coverdir().path, ) PK Mb�Z�t0O% % ' trial/_dist/test/test_workerreporter.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.trial._dist.workerreporter}. """ from twisted.python.failure import Failure from twisted.trial._dist import managercommands from twisted.trial._dist.workerreporter import WorkerReporter from twisted.trial.unittest import TestCase, Todo class FakeAMProtocol: """ A fake C{AMP} implementations to track C{callRemote} calls. """ id = 0 lastCall = None def callRemote(self, command, **kwargs): self.lastCall = command self.lastArgs = kwargs class WorkerReporterTests(TestCase): """ Tests for L{WorkerReporter}. """ def setUp(self): self.fakeAMProtocol = FakeAMProtocol() self.workerReporter = WorkerReporter(self.fakeAMProtocol) self.test = TestCase() def test_addSuccess(self): """ L{WorkerReporter.addSuccess} sends a L{managercommands.AddSuccess} command. """ self.workerReporter.addSuccess(self.test) self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddSuccess) def test_addError(self): """ L{WorkerReporter.addError} sends a L{managercommands.AddError} command. """ self.workerReporter.addError(self.test, Failure(RuntimeError("error"))) self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddError) def test_addErrorTuple(self): """ Adding an error using L{WorkerReporter.addError} as a C{sys.exc_info}-style tuple sends an L{managercommands.AddError} command. """ self.workerReporter.addError( self.test, (RuntimeError, RuntimeError("error"), None) ) self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddError) def test_addFailure(self): """ L{WorkerReporter.addFailure} sends a L{managercommands.AddFailure} command. """ self.workerReporter.addFailure(self.test, Failure(RuntimeError("fail"))) self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddFailure) def test_addFailureTuple(self): """ Adding a failure using L{WorkerReporter.addFailure} as a C{sys.exc_info}-style tuple sends an L{managercommands.AddFailure} message. """ self.workerReporter.addFailure( self.test, (RuntimeError, RuntimeError("fail"), None) ) self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddFailure) def test_addSkip(self): """ L{WorkerReporter.addSkip} sends a L{managercommands.AddSkip} command. """ self.workerReporter.addSkip(self.test, "reason") self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddSkip) def test_addExpectedFailure(self): """ L{WorkerReporter.addExpectedFailure} sends a L{managercommands.AddExpectedFailure} command. protocol. """ self.workerReporter.addExpectedFailure( self.test, Failure(RuntimeError("error")), Todo("todo") ) self.assertEqual( self.fakeAMProtocol.lastCall, managercommands.AddExpectedFailure ) def test_addExpectedFailureNoTodo(self): """ L{WorkerReporter.addExpectedFailure} sends a L{managercommands.AddExpectedFailure} command. protocol. """ self.workerReporter.addExpectedFailure( self.test, Failure(RuntimeError("error")) ) self.assertEqual( self.fakeAMProtocol.lastCall, managercommands.AddExpectedFailure ) def test_addUnexpectedSuccess(self): """ L{WorkerReporter.addUnexpectedSuccess} sends a L{managercommands.AddUnexpectedSuccess} command. """ self.workerReporter.addUnexpectedSuccess(self.test, Todo("todo")) self.assertEqual( self.fakeAMProtocol.lastCall, managercommands.AddUnexpectedSuccess ) def test_addUnexpectedSuccessNoTodo(self): """ L{WorkerReporter.addUnexpectedSuccess} sends a L{managercommands.AddUnexpectedSuccess} command. """ self.workerReporter.addUnexpectedSuccess(self.test) self.assertEqual( self.fakeAMProtocol.lastCall, managercommands.AddUnexpectedSuccess ) PK Mb�Zv5R v v trial/_dist/test/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Distributed trial test runner tests. """ PK Mb�Z?' �d d $ trial/_dist/test/test_workertrial.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.trial._dist.workertrial}. """ import errno import os import sys from io import BytesIO from twisted.protocols.amp import AMP from twisted.test.proto_helpers import StringTransport from twisted.trial._dist import ( _WORKER_AMP_STDIN, _WORKER_AMP_STDOUT, managercommands, workercommands, workertrial, ) from twisted.trial._dist.workertrial import WorkerLogObserver, _setupPath, main from twisted.trial.unittest import TestCase class FakeAMP(AMP): """ A fake amp protocol. """ class WorkerLogObserverTests(TestCase): """ Tests for L{WorkerLogObserver}. """ def test_emit(self): """ L{WorkerLogObserver} forwards data to L{managercommands.TestWrite}. """ calls = [] class FakeClient: def callRemote(self, method, **kwargs): calls.append((method, kwargs)) observer = WorkerLogObserver(FakeClient()) observer.emit({"message": ["Some log"]}) self.assertEqual(calls, [(managercommands.TestWrite, {"out": "Some log"})]) class MainTests(TestCase): """ Tests for L{main}. """ def setUp(self): self.readStream = BytesIO() self.writeStream = BytesIO() self.patch( workertrial, "startLoggingWithObserver", self.startLoggingWithObserver ) self.addCleanup(setattr, sys, "argv", sys.argv) sys.argv = ["trial"] def fdopen(self, fd, mode=None): """ Fake C{os.fdopen} implementation which returns C{self.readStream} for the stdin fd and C{self.writeStream} for the stdout fd. """ if fd == _WORKER_AMP_STDIN: self.assertIdentical("rb", mode) return self.readStream elif fd == _WORKER_AMP_STDOUT: self.assertEqual("wb", mode) return self.writeStream else: raise AssertionError(f"Unexpected fd {fd!r}") def startLoggingWithObserver(self, emit, setStdout): """ Override C{startLoggingWithObserver} for not starting logging. """ self.assertFalse(setStdout) def test_empty(self): """ If no data is ever written, L{main} exits without writing data out. """ main(self.fdopen) self.assertEqual(b"", self.writeStream.getvalue()) def test_forwardCommand(self): """ L{main} forwards data from its input stream to a L{WorkerProtocol} instance which writes data to the output stream. """ client = FakeAMP() clientTransport = StringTransport() client.makeConnection(clientTransport) client.callRemote(workercommands.Run, testCase="doesntexist") self.readStream = clientTransport.io self.readStream.seek(0, 0) main(self.fdopen) self.assertIn(b"No module named 'doesntexist'", self.writeStream.getvalue()) def test_readInterrupted(self): """ If reading the input stream fails with a C{IOError} with errno C{EINTR}, L{main} ignores it and continues reading. """ excInfos = [] class FakeStream: count = 0 def read(oself, size): oself.count += 1 if oself.count == 1: raise OSError(errno.EINTR) else: excInfos.append(sys.exc_info()) return b"" self.readStream = FakeStream() main(self.fdopen) self.assertEqual(b"", self.writeStream.getvalue()) self.assertEqual([(None, None, None)], excInfos) def test_otherReadError(self): """ L{main} only ignores C{IOError} with C{EINTR} errno: otherwise, the error pops out. """ class FakeStream: count = 0 def read(oself, size): oself.count += 1 if oself.count == 1: raise OSError("Something else") return "" self.readStream = FakeStream() self.assertRaises(IOError, main, self.fdopen) class SetupPathTests(TestCase): """ Tests for L{_setupPath} C{sys.path} manipulation. """ def setUp(self): self.addCleanup(setattr, sys, "path", sys.path[:]) def test_overridePath(self): """ L{_setupPath} overrides C{sys.path} if B{TRIAL_PYTHONPATH} is specified in the environment. """ environ = {"TRIAL_PYTHONPATH": os.pathsep.join(["foo", "bar"])} _setupPath(environ) self.assertEqual(["foo", "bar"], sys.path) def test_noVariable(self): """ L{_setupPath} doesn't change C{sys.path} if B{TRIAL_PYTHONPATH} is not present in the environment. """ originalPath = sys.path[:] _setupPath({}) self.assertEqual(originalPath, sys.path) PK Mb�ZB��� trial/_dist/distreporter.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_distreporter -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ The reporter is not made to support concurrent test running, so we will hold test results in here and only send them to the reporter once the test is over. @since: 12.3 """ from zope.interface import implementer from twisted.python.components import proxyForInterface from twisted.trial.itrial import IReporter @implementer(IReporter) class DistReporter(proxyForInterface(IReporter)): # type: ignore[misc] """ See module docstring. """ def __init__(self, original): super().__init__(original) self.running = {} def startTest(self, test): """ Queue test starting. """ self.running[test.id()] = [] self.running[test.id()].append((self.original.startTest, test)) def addFailure(self, test, fail): """ Queue adding a failure. """ self.running[test.id()].append((self.original.addFailure, test, fail)) def addError(self, test, error): """ Queue error adding. """ self.running[test.id()].append((self.original.addError, test, error)) def addSkip(self, test, reason): """ Queue adding a skip. """ self.running[test.id()].append((self.original.addSkip, test, reason)) def addUnexpectedSuccess(self, test, todo=None): """ Queue adding an unexpected success. """ self.running[test.id()].append((self.original.addUnexpectedSuccess, test, todo)) def addExpectedFailure(self, test, error, todo=None): """ Queue adding an unexpected failure. """ self.running[test.id()].append( (self.original.addExpectedFailure, test, error, todo) ) def addSuccess(self, test): """ Queue adding a success. """ self.running[test.id()].append((self.original.addSuccess, test)) def stopTest(self, test): """ Queue stopping the test, then unroll the queue. """ self.running[test.id()].append((self.original.stopTest, test)) for step in self.running[test.id()]: step[0](*step[1:]) del self.running[test.id()] PK Mb�ZI K� � trial/_dist/options.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_options -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Options handling specific to trial's workers. @since: 12.3 """ from twisted.application.app import ReactorSelectionMixin from twisted.python.filepath import FilePath from twisted.python.usage import Options from twisted.scripts.trial import _BasicOptions class WorkerOptions(_BasicOptions, Options, ReactorSelectionMixin): """ Options forwarded to the trial distributed worker. """ def coverdir(self): """ Return a L{FilePath} representing the directory into which coverage results should be written. """ return FilePath("coverage") PK Mb�Z�X�n! n! trial/_dist/disttrial.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_disttrial -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module contains the trial distributed runner, the management class responsible for coordinating all of trial's behavior at the highest level. @since: 12.3 """ import os import sys from twisted.internet.defer import DeferredList from twisted.internet.task import cooperate from twisted.python.filepath import FilePath from twisted.python.modules import theSystemPath from twisted.trial._asyncrunner import _iterateTests from twisted.trial._dist import _WORKER_AMP_STDIN, _WORKER_AMP_STDOUT from twisted.trial._dist.distreporter import DistReporter from twisted.trial._dist.worker import LocalWorker, LocalWorkerAMP from twisted.trial.reporter import UncleanWarningsReporterWrapper from twisted.trial.util import _unusedTestDirectory class DistTrialRunner: """ A specialized runner for distributed trial. The runner launches a number of local worker processes which will run tests. @ivar _workerNumber: the number of workers to be spawned. @type _workerNumber: C{int} @ivar _stream: stream which the reporter will use. @ivar _reporterFactory: the reporter class to be used. """ _distReporterFactory = DistReporter def _makeResult(self): """ Make reporter factory, and wrap it with a L{DistReporter}. """ reporter = self._reporterFactory( self._stream, self._tbformat, realtime=self._rterrors ) if self._uncleanWarnings: reporter = UncleanWarningsReporterWrapper(reporter) return self._distReporterFactory(reporter) def __init__( self, reporterFactory, workerNumber, workerArguments, stream=None, tracebackFormat="default", realTimeErrors=False, uncleanWarnings=False, logfile="test.log", workingDirectory="_trial_temp", ): self._workerNumber = workerNumber self._workerArguments = workerArguments self._reporterFactory = reporterFactory if stream is None: stream = sys.stdout self._stream = stream self._tbformat = tracebackFormat self._rterrors = realTimeErrors self._uncleanWarnings = uncleanWarnings self._result = None self._workingDirectory = workingDirectory self._logFile = logfile self._logFileObserver = None self._logFileObject = None self._logWarnings = False def writeResults(self, result): """ Write test run final outcome to result. @param result: A C{TestResult} which will print errors and the summary. """ result.done() def createLocalWorkers(self, protocols, workingDirectory): """ Create local worker protocol instances and return them. @param protocols: An iterable of L{LocalWorkerAMP} instances. @param workingDirectory: The base path in which we should run the workers. @type workingDirectory: C{str} @return: A list of C{quantity} C{LocalWorker} instances. """ return [ LocalWorker(protocol, os.path.join(workingDirectory, str(x)), self._logFile) for x, protocol in enumerate(protocols) ] def launchWorkerProcesses(self, spawner, protocols, arguments): """ Spawn processes from a list of process protocols. @param spawner: A C{IReactorProcess.spawnProcess} implementation. @param protocols: An iterable of C{ProcessProtocol} instances. @param arguments: Extra arguments passed to the processes. """ workertrialPath = theSystemPath["twisted.trial._dist.workertrial"].filePath.path childFDs = { 0: "w", 1: "r", 2: "r", _WORKER_AMP_STDIN: "w", _WORKER_AMP_STDOUT: "r", } environ = os.environ.copy() # Add an environment variable containing the raw sys.path, to be used by # subprocesses to make sure it's identical to the parent. See # workertrial._setupPath. environ["TRIAL_PYTHONPATH"] = os.pathsep.join(sys.path) for worker in protocols: args = [sys.executable, workertrialPath] args.extend(arguments) spawner(worker, sys.executable, args=args, childFDs=childFDs, env=environ) def _driveWorker(self, worker, result, testCases, cooperate): """ Drive a L{LocalWorkerAMP} instance, iterating the tests and calling C{run} for every one of them. @param worker: The L{LocalWorkerAMP} to drive. @param result: The global L{DistReporter} instance. @param testCases: The global list of tests to iterate. @param cooperate: The cooperate function to use, to be customized in tests. @type cooperate: C{function} @return: A C{Deferred} firing when all the tests are finished. """ def resultErrback(error, case): result.original.addFailure(case, error) return error def task(case): d = worker.run(case, result) d.addErrback(resultErrback, case) return d return cooperate(task(case) for case in testCases).whenDone() def run(self, suite, reactor=None, cooperate=cooperate, untilFailure=False): """ Spawn local worker processes and load tests. After that, run them. @param suite: A tests suite to be run. @param reactor: The reactor to use, to be customized in tests. @type reactor: A provider of L{twisted.internet.interfaces.IReactorProcess} @param cooperate: The cooperate function to use, to be customized in tests. @type cooperate: C{function} @param untilFailure: If C{True}, continue to run the tests until they fail. @type untilFailure: C{bool}. @return: The test result. @rtype: L{DistReporter} """ if reactor is None: from twisted.internet import reactor result = self._makeResult() count = suite.countTestCases() self._stream.write("Running %d tests.\n" % (count,)) if not count: # Take a shortcut if there is no test suite.run(result.original) self.writeResults(result) return result testDir, testDirLock = _unusedTestDirectory(FilePath(self._workingDirectory)) workerNumber = min(count, self._workerNumber) ampWorkers = [LocalWorkerAMP() for x in range(workerNumber)] workers = self.createLocalWorkers(ampWorkers, testDir.path) processEndDeferreds = [worker.endDeferred for worker in workers] self.launchWorkerProcesses(reactor.spawnProcess, workers, self._workerArguments) def runTests(): testCases = iter(list(_iterateTests(suite))) workerDeferreds = [] for worker in ampWorkers: workerDeferreds.append( self._driveWorker(worker, result, testCases, cooperate=cooperate) ) return DeferredList( workerDeferreds, consumeErrors=True, fireOnOneErrback=True ) stopping = [] def nextRun(ign): self.writeResults(result) if not untilFailure: return if not result.wasSuccessful(): return d = runTests() return d.addCallback(nextRun) def stop(ign): testDirLock.unlock() if not stopping: stopping.append(None) reactor.stop() def beforeShutDown(): if not stopping: stopping.append(None) d = DeferredList(processEndDeferreds, consumeErrors=True) return d.addCallback(continueShutdown) def continueShutdown(ign): self.writeResults(result) return ign d = runTests() d.addCallback(nextRun) d.addBoth(stop) reactor.addSystemEventTrigger("before", "shutdown", beforeShutDown) reactor.run() return result def runUntilFailure(self, suite): """ Run the tests with local worker processes until they fail. @param suite: A tests suite to be run. """ return self.run(suite, untilFailure=True) PK Mb�Z�?�� � trial/_dist/workertrial.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_workertrial -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Implementation of C{AMP} worker commands, and main executable entry point for the workers. @since: 12.3 """ import errno import os import sys def _setupPath(environ): """ Override C{sys.path} with what the parent passed in B{TRIAL_PYTHONPATH}. @see: twisted.trial._dist.disttrial.DistTrialRunner.launchWorkerProcesses """ if "TRIAL_PYTHONPATH" in environ: sys.path[:] = environ["TRIAL_PYTHONPATH"].split(os.pathsep) _setupPath(os.environ) from twisted.internet.protocol import FileWrapper from twisted.python.log import startLoggingWithObserver, textFromEventDict from twisted.trial._dist import _WORKER_AMP_STDIN, _WORKER_AMP_STDOUT from twisted.trial._dist.options import WorkerOptions class WorkerLogObserver: """ A log observer that forward its output to a C{AMP} protocol. """ def __init__(self, protocol): """ @param protocol: a connected C{AMP} protocol instance. @type protocol: C{AMP} """ self.protocol = protocol def emit(self, eventDict): """ Produce a log output. """ from twisted.trial._dist import managercommands text = textFromEventDict(eventDict) if text is None: return self.protocol.callRemote(managercommands.TestWrite, out=text) def main(_fdopen=os.fdopen): """ Main function to be run if __name__ == "__main__". @param _fdopen: If specified, the function to use in place of C{os.fdopen}. @type _fdopen: C{callable} """ config = WorkerOptions() config.parseOptions() from twisted.trial._dist.worker import WorkerProtocol workerProtocol = WorkerProtocol(config["force-gc"]) protocolIn = _fdopen(_WORKER_AMP_STDIN, "rb") protocolOut = _fdopen(_WORKER_AMP_STDOUT, "wb") workerProtocol.makeConnection(FileWrapper(protocolOut)) observer = WorkerLogObserver(workerProtocol) startLoggingWithObserver(observer.emit, False) while True: try: r = protocolIn.read(1) except OSError as e: if e.args[0] == errno.EINTR: continue else: raise if r == b"": break else: workerProtocol.dataReceived(r) protocolOut.flush() sys.stdout.flush() sys.stderr.flush() if config.tracer: sys.settrace(None) results = config.tracer.results() results.write_results( show_missing=True, summary=False, coverdir=config.coverdir().path ) if __name__ == "__main__": main() PK Mb�ZA*ʓ> > trial/_dist/workercommands.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Commands for telling a worker to load tests or run tests. @since: 12.3 """ from twisted.protocols.amp import Boolean, Command, Unicode NativeString = Unicode class Run(Command): """ Run a test. """ arguments = [(b"testCase", NativeString())] response = [(b"success", Boolean())] class Start(Command): """ Set up the worker process, giving the running directory. """ arguments = [(b"directory", NativeString())] response = [(b"success", Boolean())] PK Mb�ZK�i� � trial/_dist/managercommands.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Commands for reporting test success of failure to the manager. @since: 12.3 """ from twisted.protocols.amp import Boolean, Command, ListOf, Unicode NativeString = Unicode class AddSuccess(Command): """ Add a success. """ arguments = [(b"testName", NativeString())] response = [(b"success", Boolean())] class AddError(Command): """ Add an error. """ arguments = [ (b"testName", NativeString()), (b"error", NativeString()), (b"errorClass", NativeString()), (b"frames", ListOf(NativeString())), ] response = [(b"success", Boolean())] class AddFailure(Command): """ Add a failure. """ arguments = [ (b"testName", NativeString()), (b"fail", NativeString()), (b"failClass", NativeString()), (b"frames", ListOf(NativeString())), ] response = [(b"success", Boolean())] class AddSkip(Command): """ Add a skip. """ arguments = [(b"testName", NativeString()), (b"reason", NativeString())] response = [(b"success", Boolean())] class AddExpectedFailure(Command): """ Add an expected failure. """ arguments = [ (b"testName", NativeString()), (b"error", NativeString()), (b"todo", NativeString()), ] response = [(b"success", Boolean())] class AddUnexpectedSuccess(Command): """ Add an unexpected success. """ arguments = [(b"testName", NativeString()), (b"todo", NativeString())] response = [(b"success", Boolean())] class TestWrite(Command): """ Write test log. """ arguments = [(b"out", NativeString())] response = [(b"success", Boolean())] PK Mb�Zn[O3� � trial/_dist/__init__.pynu �[��� # -*- test-case-name: twisted.trial._dist.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This package implements the distributed Trial test runner: - The L{twisted.trial._dist.disttrial} module implements a test runner which runs in a manager process and can launch additional worker processes in which to run tests and gather up results from all of them. - The L{twisted.trial._dist.options} module defines command line options used to configure the distributed test runner. - The L{twisted.trial._dist.managercommands} module defines AMP commands which are sent from worker processes back to the manager process to report the results of tests. - The L{twisted.trial._dist.workercommands} module defines AMP commands which are sent from the manager process to the worker processes to control the execution of tests there. - The L{twisted.trial._dist.distreporter} module defines a proxy for L{twisted.trial.itrial.IReporter} which enforces the typical requirement that results be passed to a reporter for only one test at a time, allowing any reporter to be used with despite disttrial's simultaneously running tests. - The L{twisted.trial._dist.workerreporter} module implements a L{twisted.trial.itrial.IReporter} which is used by worker processes and reports results back to the manager process using AMP commands. - The L{twisted.trial._dist.workertrial} module is a runnable script which is the main point for worker processes. - The L{twisted.trial._dist.worker} process defines the manager's AMP protocol for accepting results from worker processes and a process protocol for use running workers as local child processes (as opposed to distributing them to another host). @since: 12.3 """ # File descriptors numbers used to set up pipes with the worker. _WORKER_AMP_STDIN = 3 _WORKER_AMP_STDOUT = 4 PK Mb�Z�7`, , trial/_asyncrunner.pynu �[��� # -*- test-case-name: twisted.trial.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Infrastructure for test running and suites. """ import doctest import gc import unittest as pyunit from zope.interface import implementer from twisted.python import components from twisted.trial import itrial, reporter from twisted.trial._synctest import _logObserver class TestSuite(pyunit.TestSuite): """ Extend the standard library's C{TestSuite} with a consistently overrideable C{run} method. """ def run(self, result): """ Call C{run} on every member of the suite. """ for test in self._tests: if result.shouldStop: break test(result) return result @implementer(itrial.ITestCase) class TestDecorator( components.proxyForInterface( # type: ignore[misc] itrial.ITestCase, "_originalTest" ) ): """ Decorator for test cases. @param _originalTest: The wrapped instance of test. @type _originalTest: A provider of L{itrial.ITestCase} """ def __call__(self, result): """ Run the unit test. @param result: A TestResult object. """ return self.run(result) def run(self, result): """ Run the unit test. @param result: A TestResult object. """ return self._originalTest.run(reporter._AdaptedReporter(result, self.__class__)) def _clearSuite(suite): """ Clear all tests from C{suite}. This messes with the internals of C{suite}. In particular, it assumes that the suite keeps all of its tests in a list in an instance variable called C{_tests}. """ suite._tests = [] def decorate(test, decorator): """ Decorate all test cases in C{test} with C{decorator}. C{test} can be a test case or a test suite. If it is a test suite, then the structure of the suite is preserved. L{decorate} tries to preserve the class of the test suites it finds, but assumes the presence of the C{_tests} attribute on the suite. @param test: The C{TestCase} or C{TestSuite} to decorate. @param decorator: A unary callable used to decorate C{TestCase}s. @return: A decorated C{TestCase} or a C{TestSuite} containing decorated C{TestCase}s. """ try: tests = iter(test) except TypeError: return decorator(test) # At this point, we know that 'test' is a test suite. _clearSuite(test) for case in tests: test.addTest(decorate(case, decorator)) return test class _PyUnitTestCaseAdapter(TestDecorator): """ Adapt from pyunit.TestCase to ITestCase. """ class _BrokenIDTestCaseAdapter(_PyUnitTestCaseAdapter): """ Adapter for pyunit-style C{TestCase} subclasses that have undesirable id() methods. That is C{unittest.FunctionTestCase} and C{unittest.DocTestCase}. """ def id(self): """ Return the fully-qualified Python name of the doctest. """ testID = self._originalTest.shortDescription() if testID is not None: return testID return self._originalTest.id() class _ForceGarbageCollectionDecorator(TestDecorator): """ Forces garbage collection to be run before and after the test. Any errors logged during the post-test collection are added to the test result as errors. """ def run(self, result): gc.collect() TestDecorator.run(self, result) _logObserver._add() gc.collect() for error in _logObserver.getErrors(): result.addError(self, error) _logObserver.flushErrors() _logObserver._remove() components.registerAdapter(_PyUnitTestCaseAdapter, pyunit.TestCase, itrial.ITestCase) components.registerAdapter( _BrokenIDTestCaseAdapter, pyunit.FunctionTestCase, itrial.ITestCase ) _docTestCase = getattr(doctest, "DocTestCase", None) if _docTestCase: components.registerAdapter(_BrokenIDTestCaseAdapter, _docTestCase, itrial.ITestCase) def _iterateTests(testSuiteOrCase): """ Iterate through all of the test cases in C{testSuiteOrCase}. """ try: suite = iter(testSuiteOrCase) except TypeError: yield testSuiteOrCase else: for test in suite: yield from _iterateTests(test) PK Mb�Z��p�� �� trial/reporter.pynu �[��� # -*- test-case-name: twisted.trial.test.test_reporter -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # Maintainer: Jonathan Lange """ Defines classes that handle the results of tests. """ import os import sys import time import unittest as pyunit import warnings from collections import OrderedDict from zope.interface import implementer from twisted.python import log, reflect from twisted.python.components import proxyForInterface from twisted.python.failure import Failure from twisted.python.util import untilConcludes from twisted.trial import itrial, util try: from subunit import TestProtocolClient # type: ignore[import] except ImportError: TestProtocolClient = None def _makeTodo(value): """ Return a L{Todo} object built from C{value}. This is a synonym for L{twisted.trial.unittest.makeTodo}, but imported locally to avoid circular imports. @param value: A string or a tuple of C{(errors, reason)}, where C{errors} is either a single exception class or an iterable of exception classes. @return: A L{Todo} object. """ from twisted.trial.unittest import makeTodo return makeTodo(value) class BrokenTestCaseWarning(Warning): """ Emitted as a warning when an exception occurs in one of setUp or tearDown. """ class SafeStream: """ Wraps a stream object so that all C{write} calls are wrapped in L{untilConcludes<twisted.python.util.untilConcludes>}. """ def __init__(self, original): self.original = original def __getattr__(self, name): return getattr(self.original, name) def write(self, *a, **kw): return untilConcludes(self.original.write, *a, **kw) @implementer(itrial.IReporter) class TestResult(pyunit.TestResult): """ Accumulates the results of several L{twisted.trial.unittest.TestCase}s. @ivar successes: count the number of successes achieved by the test run. @type successes: C{int} """ # Used when no todo provided to addExpectedFailure or addUnexpectedSuccess. _DEFAULT_TODO = "Test expected to fail" def __init__(self): super().__init__() self.skips = [] self.expectedFailures = [] self.unexpectedSuccesses = [] self.successes = 0 self._timings = [] def __repr__(self) -> str: return "<%s run=%d errors=%d failures=%d todos=%d dones=%d skips=%d>" % ( reflect.qual(self.__class__), self.testsRun, len(self.errors), len(self.failures), len(self.expectedFailures), len(self.skips), len(self.unexpectedSuccesses), ) def _getTime(self): return time.time() def _getFailure(self, error): """ Convert a C{sys.exc_info()}-style tuple to a L{Failure}, if necessary. """ if isinstance(error, tuple): return Failure(error[1], error[0], error[2]) return error def startTest(self, test): """ This must be called before the given test is commenced. @type test: L{pyunit.TestCase} """ super().startTest(test) self._testStarted = self._getTime() def stopTest(self, test): """ This must be called after the given test is completed. @type test: L{pyunit.TestCase} """ super().stopTest(test) self._lastTime = self._getTime() - self._testStarted def addFailure(self, test, fail): """ Report a failed assertion for the given test. @type test: L{pyunit.TestCase} @type fail: L{Failure} or L{tuple} """ self.failures.append((test, self._getFailure(fail))) def addError(self, test, error): """ Report an error that occurred while running the given test. @type test: L{pyunit.TestCase} @type error: L{Failure} or L{tuple} """ self.errors.append((test, self._getFailure(error))) def addSkip(self, test, reason): """ Report that the given test was skipped. In Trial, tests can be 'skipped'. Tests are skipped mostly because there is some platform or configuration issue that prevents them from being run correctly. @type test: L{pyunit.TestCase} @type reason: L{str} """ self.skips.append((test, reason)) def addUnexpectedSuccess(self, test, todo=None): """ Report that the given test succeeded against expectations. In Trial, tests can be marked 'todo'. That is, they are expected to fail. When a test that is expected to fail instead succeeds, it should call this method to report the unexpected success. @type test: L{pyunit.TestCase} @type todo: L{unittest.Todo}, or L{None}, in which case a default todo message is provided. """ if todo is None: todo = _makeTodo(self._DEFAULT_TODO) self.unexpectedSuccesses.append((test, todo)) def addExpectedFailure(self, test, error, todo=None): """ Report that the given test failed, and was expected to do so. In Trial, tests can be marked 'todo'. That is, they are expected to fail. @type test: L{pyunit.TestCase} @type error: L{Failure} @type todo: L{unittest.Todo}, or L{None}, in which case a default todo message is provided. """ if todo is None: todo = _makeTodo(self._DEFAULT_TODO) self.expectedFailures.append((test, error, todo)) def addSuccess(self, test): """ Report that the given test succeeded. @type test: L{pyunit.TestCase} """ self.successes += 1 def wasSuccessful(self): """ Report whether or not this test suite was successful or not. The behaviour of this method changed in L{pyunit} in Python 3.4 to fail if there are any errors, failures, or unexpected successes. Previous to 3.4, it was only if there were errors or failures. This method implements the old behaviour for backwards compatibility reasons, checking just for errors and failures. @rtype: L{bool} """ return len(self.failures) == len(self.errors) == 0 def done(self): """ The test suite has finished running. """ @implementer(itrial.IReporter) class TestResultDecorator( proxyForInterface(itrial.IReporter, "_originalReporter") # type: ignore[misc] ): """ Base class for TestResult decorators. @ivar _originalReporter: The wrapped instance of reporter. @type _originalReporter: A provider of L{itrial.IReporter} """ @implementer(itrial.IReporter) class UncleanWarningsReporterWrapper(TestResultDecorator): """ A wrapper for a reporter that converts L{util.DirtyReactorAggregateError}s to warnings. """ def addError(self, test, error): """ If the error is a L{util.DirtyReactorAggregateError}, instead of reporting it as a normal error, throw a warning. """ if isinstance(error, Failure) and error.check(util.DirtyReactorAggregateError): warnings.warn(error.getErrorMessage()) else: self._originalReporter.addError(test, error) @implementer(itrial.IReporter) class _ExitWrapper(TestResultDecorator): """ A wrapper for a reporter that causes the reporter to stop after unsuccessful tests. """ def addError(self, *args, **kwargs): self.shouldStop = True return self._originalReporter.addError(*args, **kwargs) def addFailure(self, *args, **kwargs): self.shouldStop = True return self._originalReporter.addFailure(*args, **kwargs) class _AdaptedReporter(TestResultDecorator): """ TestResult decorator that makes sure that addError only gets tests that have been adapted with a particular test adapter. """ def __init__(self, original, testAdapter): """ Construct an L{_AdaptedReporter}. @param original: An {itrial.IReporter}. @param testAdapter: A callable that returns an L{itrial.ITestCase}. """ TestResultDecorator.__init__(self, original) self.testAdapter = testAdapter def addError(self, test, error): """ See L{itrial.IReporter}. """ test = self.testAdapter(test) return self._originalReporter.addError(test, error) def addExpectedFailure(self, test, failure, todo=None): """ See L{itrial.IReporter}. @type test: A L{pyunit.TestCase}. @type failure: A L{failure.Failure} or L{AssertionError} @type todo: A L{unittest.Todo} or None When C{todo} is L{None} a generic C{unittest.Todo} is built. L{pyunit.TestCase}'s C{run()} calls this with 3 positional arguments (without C{todo}). """ return self._originalReporter.addExpectedFailure( self.testAdapter(test), failure, todo ) def addFailure(self, test, failure): """ See L{itrial.IReporter}. """ test = self.testAdapter(test) return self._originalReporter.addFailure(test, failure) def addSkip(self, test, skip): """ See L{itrial.IReporter}. """ test = self.testAdapter(test) return self._originalReporter.addSkip(test, skip) def addUnexpectedSuccess(self, test, todo=None): """ See L{itrial.IReporter}. @type test: A L{pyunit.TestCase}. @type todo: A L{unittest.Todo} or None When C{todo} is L{None} a generic C{unittest.Todo} is built. L{pyunit.TestCase}'s C{run()} calls this with 2 positional arguments (without C{todo}). """ test = self.testAdapter(test) return self._originalReporter.addUnexpectedSuccess(test, todo) def startTest(self, test): """ See L{itrial.IReporter}. """ return self._originalReporter.startTest(self.testAdapter(test)) def stopTest(self, test): """ See L{itrial.IReporter}. """ return self._originalReporter.stopTest(self.testAdapter(test)) @implementer(itrial.IReporter) class Reporter(TestResult): """ A basic L{TestResult} with support for writing to a stream. @ivar _startTime: The time when the first test was started. It defaults to L{None}, which means that no test was actually launched. @type _startTime: C{float} or L{None} @ivar _warningCache: A C{set} of tuples of warning message (file, line, text, category) which have already been written to the output stream during the currently executing test. This is used to avoid writing duplicates of the same warning to the output stream. @type _warningCache: C{set} @ivar _publisher: The log publisher which will be observed for warning events. @type _publisher: L{twisted.python.log.LogPublisher} """ _separator = "-" * 79 _doubleSeparator = "=" * 79 def __init__( self, stream=sys.stdout, tbformat="default", realtime=False, publisher=None ): super().__init__() self._stream = SafeStream(stream) self.tbformat = tbformat self.realtime = realtime self._startTime = None self._warningCache = set() # Start observing log events so as to be able to report warnings. self._publisher = publisher if publisher is not None: publisher.addObserver(self._observeWarnings) def _observeWarnings(self, event): """ Observe warning events and write them to C{self._stream}. This method is a log observer which will be registered with C{self._publisher.addObserver}. @param event: A C{dict} from the logging system. If it has a C{'warning'} key, a logged warning will be extracted from it and possibly written to C{self.stream}. """ if "warning" in event: key = ( event["filename"], event["lineno"], event["category"].split(".")[-1], str(event["warning"]), ) if key not in self._warningCache: self._warningCache.add(key) self._stream.write("%s:%s: %s: %s\n" % key) def startTest(self, test): """ Called when a test begins to run. Records the time when it was first called and resets the warning cache. @param test: L{ITestCase} """ super().startTest(test) if self._startTime is None: self._startTime = self._getTime() self._warningCache = set() def addFailure(self, test, fail): """ Called when a test fails. If C{realtime} is set, then it prints the error to the stream. @param test: L{ITestCase} that failed. @param fail: L{failure.Failure} containing the error. """ super().addFailure(test, fail) if self.realtime: fail = self.failures[-1][1] # guarantee it's a Failure self._write(self._formatFailureTraceback(fail)) def addError(self, test, error): """ Called when a test raises an error. If C{realtime} is set, then it prints the error to the stream. @param test: L{ITestCase} that raised the error. @param error: L{failure.Failure} containing the error. """ error = self._getFailure(error) super().addError(test, error) if self.realtime: error = self.errors[-1][1] # guarantee it's a Failure self._write(self._formatFailureTraceback(error)) def _write(self, format, *args): """ Safely write to the reporter's stream. @param format: A format string to write. @param args: The arguments for the format string. """ s = str(format) assert isinstance(s, str) if args: self._stream.write(s % args) else: self._stream.write(s) untilConcludes(self._stream.flush) def _writeln(self, format, *args): """ Safely write a line to the reporter's stream. Newline is appended to the format string. @param format: A format string to write. @param args: The arguments for the format string. """ self._write(format, *args) self._write("\n") def upDownError(self, method, error, warn=True, printStatus=True): super().upDownError(method, error, warn, printStatus) if warn: tbStr = self._formatFailureTraceback(error) log.msg(tbStr) msg = "caught exception in {}, your TestCase is broken\n\n{}".format( method, tbStr, ) warnings.warn(msg, BrokenTestCaseWarning, stacklevel=2) def cleanupErrors(self, errs): super().cleanupErrors(errs) warnings.warn( "%s\n%s" % ( "REACTOR UNCLEAN! traceback(s) follow: ", self._formatFailureTraceback(errs), ), BrokenTestCaseWarning, ) def _trimFrames(self, frames): """ Trim frames to remove internal paths. When a C{SynchronousTestCase} method fails synchronously, the stack looks like this: - [0]: C{SynchronousTestCase._run} - [1]: C{util.runWithWarningsSuppressed} - [2:-2]: code in the test method which failed - [-1]: C{_synctest.fail} When a C{TestCase} method fails synchronously, the stack looks like this: - [0]: C{defer.maybeDeferred} - [1]: C{utils.runWithWarningsSuppressed} - [2]: C{utils.runWithWarningsSuppressed} - [3:-2]: code in the test method which failed - [-1]: C{_synctest.fail} When a method fails inside a C{Deferred} (i.e., when the test method returns a C{Deferred}, and that C{Deferred}'s errback fires), the stack captured inside the resulting C{Failure} looks like this: - [0]: C{defer.Deferred._runCallbacks} - [1:-2]: code in the testmethod which failed - [-1]: C{_synctest.fail} As a result, we want to trim either [maybeDeferred, runWWS, runWWS] or [Deferred._runCallbacks] or [SynchronousTestCase._run, runWWS] from the front, and trim the [unittest.fail] from the end. There is also another case, when the test method is badly defined and contains extra arguments. If it doesn't recognize one of these cases, it just returns the original frames. @param frames: The C{list} of frames from the test failure. @return: The C{list} of frames to display. """ newFrames = list(frames) if len(frames) < 2: return newFrames firstMethod = newFrames[0][0] firstFile = os.path.splitext(os.path.basename(newFrames[0][1]))[0] secondMethod = newFrames[1][0] secondFile = os.path.splitext(os.path.basename(newFrames[1][1]))[0] syncCase = (("_run", "_synctest"), ("runWithWarningsSuppressed", "util")) asyncCase = (("maybeDeferred", "defer"), ("runWithWarningsSuppressed", "utils")) twoFrames = ((firstMethod, firstFile), (secondMethod, secondFile)) # On PY3, we have an extra frame which is reraising the exception for frame in newFrames: frameFile = os.path.splitext(os.path.basename(frame[1]))[0] if frameFile == "compat" and frame[0] == "reraise": # If it's in the compat module and is reraise, BLAM IT newFrames.pop(newFrames.index(frame)) if twoFrames == syncCase: newFrames = newFrames[2:] elif twoFrames == asyncCase: newFrames = newFrames[3:] elif (firstMethod, firstFile) == ("_runCallbacks", "defer"): newFrames = newFrames[1:] if not newFrames: # The method fails before getting called, probably an argument # problem return newFrames last = newFrames[-1] if ( last[0].startswith("fail") and os.path.splitext(os.path.basename(last[1]))[0] == "_synctest" ): newFrames = newFrames[:-1] return newFrames def _formatFailureTraceback(self, fail): if isinstance(fail, str): return fail.rstrip() + "\n" fail.frames, frames = self._trimFrames(fail.frames), fail.frames result = fail.getTraceback(detail=self.tbformat, elideFrameworkCode=True) fail.frames = frames return result def _groupResults(self, results, formatter): """ Group tests together based on their results. @param results: An iterable of tuples of two or more elements. The first element of each tuple is a test case. The remaining elements describe the outcome of that test case. @param formatter: A callable which turns a test case result into a string. The elements after the first of the tuples in C{results} will be passed as positional arguments to C{formatter}. @return: A C{list} of two-tuples. The first element of each tuple is a unique string describing one result from at least one of the test cases in C{results}. The second element is a list of the test cases which had that result. """ groups = OrderedDict() for content in results: case = content[0] outcome = content[1:] key = formatter(*outcome) groups.setdefault(key, []).append(case) return list(groups.items()) def _printResults(self, flavor, errors, formatter): """ Print a group of errors to the stream. @param flavor: A string indicating the kind of error (e.g. 'TODO'). @param errors: A list of errors, often L{failure.Failure}s, but sometimes 'todo' errors. @param formatter: A callable that knows how to format the errors. """ for reason, cases in self._groupResults(errors, formatter): self._writeln(self._doubleSeparator) self._writeln(flavor) self._write(reason) self._writeln("") for case in cases: self._writeln(case.id()) def _printExpectedFailure(self, error, todo): return "Reason: {!r}\n{}".format( todo.reason, self._formatFailureTraceback(error) ) def _printUnexpectedSuccess(self, todo): ret = f"Reason: {todo.reason!r}\n" if todo.errors: ret += "Expected errors: {}\n".format(", ".join(todo.errors)) return ret def _printErrors(self): """ Print all of the non-success results to the stream in full. """ self._write("\n") self._printResults("[SKIPPED]", self.skips, lambda x: "%s\n" % x) self._printResults("[TODO]", self.expectedFailures, self._printExpectedFailure) self._printResults("[FAIL]", self.failures, self._formatFailureTraceback) self._printResults("[ERROR]", self.errors, self._formatFailureTraceback) self._printResults( "[SUCCESS!?!]", self.unexpectedSuccesses, self._printUnexpectedSuccess ) def _getSummary(self): """ Return a formatted count of tests status results. """ summaries = [] for stat in ( "skips", "expectedFailures", "failures", "errors", "unexpectedSuccesses", ): num = len(getattr(self, stat)) if num: summaries.append("%s=%d" % (stat, num)) if self.successes: summaries.append("successes=%d" % (self.successes,)) summary = (summaries and " (" + ", ".join(summaries) + ")") or "" return summary def _printSummary(self): """ Print a line summarising the test results to the stream. """ summary = self._getSummary() if self.wasSuccessful(): status = "PASSED" else: status = "FAILED" self._write("%s%s\n", status, summary) def done(self): """ Summarize the result of the test run. The summary includes a report of all of the errors, todos, skips and so forth that occurred during the run. It also includes the number of tests that were run and how long it took to run them (not including load time). Expects that C{_printErrors}, C{_writeln}, C{_write}, C{_printSummary} and C{_separator} are all implemented. """ if self._publisher is not None: self._publisher.removeObserver(self._observeWarnings) self._printErrors() self._writeln(self._separator) if self._startTime is not None: self._writeln( "Ran %d tests in %.3fs", self.testsRun, time.time() - self._startTime ) self._write("\n") self._printSummary() class MinimalReporter(Reporter): """ A minimalist reporter that prints only a summary of the test result, in the form of (timeTaken, #tests, #tests, #errors, #failures, #skips). """ def _printErrors(self): """ Don't print a detailed summary of errors. We only care about the counts. """ def _printSummary(self): """ Print out a one-line summary of the form: '%(runtime) %(number_of_tests) %(number_of_tests) %(num_errors) %(num_failures) %(num_skips)' """ numTests = self.testsRun if self._startTime is not None: timing = self._getTime() - self._startTime else: timing = 0 t = ( timing, numTests, numTests, len(self.errors), len(self.failures), len(self.skips), ) self._writeln(" ".join(map(str, t))) class TextReporter(Reporter): """ Simple reporter that prints a single character for each test as it runs, along with the standard Trial summary text. """ def addSuccess(self, test): super().addSuccess(test) self._write(".") def addError(self, *args): super().addError(*args) self._write("E") def addFailure(self, *args): super().addFailure(*args) self._write("F") def addSkip(self, *args): super().addSkip(*args) self._write("S") def addExpectedFailure(self, *args): super().addExpectedFailure(*args) self._write("T") def addUnexpectedSuccess(self, *args): super().addUnexpectedSuccess(*args) self._write("!") class VerboseTextReporter(Reporter): """ A verbose reporter that prints the name of each test as it is running. Each line is printed with the name of the test, followed by the result of that test. """ # This is actually the bwverbose option def startTest(self, tm): self._write("%s ... ", tm.id()) super().startTest(tm) def addSuccess(self, test): super().addSuccess(test) self._write("[OK]") def addError(self, *args): super().addError(*args) self._write("[ERROR]") def addFailure(self, *args): super().addFailure(*args) self._write("[FAILURE]") def addSkip(self, *args): super().addSkip(*args) self._write("[SKIPPED]") def addExpectedFailure(self, *args): super().addExpectedFailure(*args) self._write("[TODO]") def addUnexpectedSuccess(self, *args): super().addUnexpectedSuccess(*args) self._write("[SUCCESS!?!]") def stopTest(self, test): super().stopTest(test) self._write("\n") class TimingTextReporter(VerboseTextReporter): """ Prints out each test as it is running, followed by the time taken for each test to run. """ def stopTest(self, method): """ Mark the test as stopped, and write the time it took to run the test to the stream. """ super().stopTest(method) self._write("(%.03f secs)\n" % self._lastTime) class _AnsiColorizer: """ A colorizer is an object that loosely wraps around a stream, allowing callers to write text to the stream in a particular color. Colorizer classes must implement C{supported()} and C{write(text, color)}. """ _colors = dict( black=30, red=31, green=32, yellow=33, blue=34, magenta=35, cyan=36, white=37 ) def __init__(self, stream): self.stream = stream @classmethod def supported(cls, stream=sys.stdout): """ A class method that returns True if the current platform supports coloring terminal output using this method. Returns False otherwise. """ if not stream.isatty(): return False # auto color only on TTYs try: import curses except ImportError: return False else: try: try: return curses.tigetnum("colors") > 2 except curses.error: curses.setupterm() return curses.tigetnum("colors") > 2 except BaseException: # guess false in case of error return False def write(self, text, color): """ Write the given text to the stream in the given color. @param text: Text to be written to the stream. @param color: A string label for a color. e.g. 'red', 'white'. """ color = self._colors[color] self.stream.write(f"\x1b[{color};1m{text}\x1b[0m") class _Win32Colorizer: """ See _AnsiColorizer docstring. """ def __init__(self, stream): from win32console import ( # type: ignore[import] FOREGROUND_BLUE, FOREGROUND_GREEN, FOREGROUND_INTENSITY, FOREGROUND_RED, STD_OUTPUT_HANDLE, GetStdHandle, ) red, green, blue, bold = ( FOREGROUND_RED, FOREGROUND_GREEN, FOREGROUND_BLUE, FOREGROUND_INTENSITY, ) self.stream = stream self.screenBuffer = GetStdHandle(STD_OUTPUT_HANDLE) self._colors = { "normal": red | green | blue, "red": red | bold, "green": green | bold, "blue": blue | bold, "yellow": red | green | bold, "magenta": red | blue | bold, "cyan": green | blue | bold, "white": red | green | blue | bold, } @classmethod def supported(cls, stream=sys.stdout): try: import win32console screenBuffer = win32console.GetStdHandle(win32console.STD_OUTPUT_HANDLE) except ImportError: return False import pywintypes # type: ignore[import] try: screenBuffer.SetConsoleTextAttribute( win32console.FOREGROUND_RED | win32console.FOREGROUND_GREEN | win32console.FOREGROUND_BLUE ) except pywintypes.error: return False else: return True def write(self, text, color): color = self._colors[color] self.screenBuffer.SetConsoleTextAttribute(color) self.stream.write(text) self.screenBuffer.SetConsoleTextAttribute(self._colors["normal"]) class _NullColorizer: """ See _AnsiColorizer docstring. """ def __init__(self, stream): self.stream = stream @classmethod def supported(cls, stream=sys.stdout): return True def write(self, text, color): self.stream.write(text) @implementer(itrial.IReporter) class SubunitReporter: """ Reports test output via Subunit. @ivar _subunit: The subunit protocol client that we are wrapping. @ivar _successful: An internal variable, used to track whether we have received only successful results. @since: 10.0 """ testsRun = None def __init__( self, stream=sys.stdout, tbformat="default", realtime=False, publisher=None ): """ Construct a L{SubunitReporter}. @param stream: A file-like object representing the stream to print output to. Defaults to stdout. @param tbformat: The format for tracebacks. Ignored, since subunit always uses Python's standard format. @param realtime: Whether or not to print exceptions in the middle of the test results. Ignored, since subunit always does this. @param publisher: The log publisher which will be preserved for reporting events. Ignored, as it's not relevant to subunit. """ if TestProtocolClient is None: raise Exception("Subunit not available") self._subunit = TestProtocolClient(stream) self._successful = True def done(self): """ Record that the entire test suite run is finished. We do nothing, since a summary clause is irrelevant to the subunit protocol. """ pass @property def shouldStop(self): """ Whether or not the test runner should stop running tests. """ return self._subunit.shouldStop def stop(self): """ Signal that the test runner should stop running tests. """ return self._subunit.stop() def wasSuccessful(self): """ Has the test run been successful so far? @return: C{True} if we have received no reports of errors or failures, C{False} otherwise. """ # Subunit has a bug in its implementation of wasSuccessful, see # https://bugs.edge.launchpad.net/subunit/+bug/491090, so we can't # simply forward it on. return self._successful def startTest(self, test): """ Record that C{test} has started. """ return self._subunit.startTest(test) def stopTest(self, test): """ Record that C{test} has completed. """ return self._subunit.stopTest(test) def addSuccess(self, test): """ Record that C{test} was successful. """ return self._subunit.addSuccess(test) def addSkip(self, test, reason): """ Record that C{test} was skipped for C{reason}. Some versions of subunit don't have support for addSkip. In those cases, the skip is reported as a success. @param test: A unittest-compatible C{TestCase}. @param reason: The reason for it being skipped. The C{str()} of this object will be included in the subunit output stream. """ addSkip = getattr(self._subunit, "addSkip", None) if addSkip is None: self.addSuccess(test) else: self._subunit.addSkip(test, reason) def addError(self, test, err): """ Record that C{test} failed with an unexpected error C{err}. Also marks the run as being unsuccessful, causing L{SubunitReporter.wasSuccessful} to return C{False}. """ self._successful = False return self._subunit.addError(test, util.excInfoOrFailureToExcInfo(err)) def addFailure(self, test, err): """ Record that C{test} failed an assertion with the error C{err}. Also marks the run as being unsuccessful, causing L{SubunitReporter.wasSuccessful} to return C{False}. """ self._successful = False return self._subunit.addFailure(test, util.excInfoOrFailureToExcInfo(err)) def addExpectedFailure(self, test, failure, todo=None): """ Record an expected failure from a test. Some versions of subunit do not implement this. For those versions, we record a success. """ failure = util.excInfoOrFailureToExcInfo(failure) addExpectedFailure = getattr(self._subunit, "addExpectedFailure", None) if addExpectedFailure is None: self.addSuccess(test) else: addExpectedFailure(test, failure) def addUnexpectedSuccess(self, test, todo=None): """ Record an unexpected success. Since subunit has no way of expressing this concept, we record a success on the subunit stream. """ # Not represented in pyunit/subunit. self.addSuccess(test) class TreeReporter(Reporter): """ Print out the tests in the form a tree. Tests are indented according to which class and module they belong. Results are printed in ANSI color. """ currentLine = "" indent = " " columns = 79 FAILURE = "red" ERROR = "red" TODO = "blue" SKIP = "blue" TODONE = "red" SUCCESS = "green" def __init__(self, stream=sys.stdout, *args, **kwargs): super().__init__(stream, *args, **kwargs) self._lastTest = [] for colorizer in [_Win32Colorizer, _AnsiColorizer, _NullColorizer]: if colorizer.supported(stream): self._colorizer = colorizer(stream) break def getDescription(self, test): """ Return the name of the method which 'test' represents. This is what gets displayed in the leaves of the tree. e.g. getDescription(TestCase('test_foo')) ==> test_foo """ return test.id().split(".")[-1] def addSuccess(self, test): super().addSuccess(test) self.endLine("[OK]", self.SUCCESS) def addError(self, *args): super().addError(*args) self.endLine("[ERROR]", self.ERROR) def addFailure(self, *args): super().addFailure(*args) self.endLine("[FAIL]", self.FAILURE) def addSkip(self, *args): super().addSkip(*args) self.endLine("[SKIPPED]", self.SKIP) def addExpectedFailure(self, *args): super().addExpectedFailure(*args) self.endLine("[TODO]", self.TODO) def addUnexpectedSuccess(self, *args): super().addUnexpectedSuccess(*args) self.endLine("[SUCCESS!?!]", self.TODONE) def _write(self, format, *args): if args: format = format % args self.currentLine = format super()._write(self.currentLine) def _getPreludeSegments(self, testID): """ Return a list of all non-leaf segments to display in the tree. Normally this is the module and class name. """ segments = testID.split(".")[:-1] if len(segments) == 0: return segments segments = [ seg for seg in (".".join(segments[:-1]), segments[-1]) if len(seg) > 0 ] return segments def _testPrelude(self, testID): """ Write the name of the test to the stream, indenting it appropriately. If the test is the first test in a new 'branch' of the tree, also write all of the parents in that branch. """ segments = self._getPreludeSegments(testID) indentLevel = 0 for seg in segments: if indentLevel < len(self._lastTest): if seg != self._lastTest[indentLevel]: self._write(f"{self.indent * indentLevel}{seg}\n") else: self._write(f"{self.indent * indentLevel}{seg}\n") indentLevel += 1 self._lastTest = segments def cleanupErrors(self, errs): self._colorizer.write(" cleanup errors", self.ERROR) self.endLine("[ERROR]", self.ERROR) super().cleanupErrors(errs) def upDownError(self, method, error, warn, printStatus): self._colorizer.write(" %s" % method, self.ERROR) if printStatus: self.endLine("[ERROR]", self.ERROR) super().upDownError(method, error, warn, printStatus) def startTest(self, test): """ Called when C{test} starts. Writes the tests name to the stream using a tree format. """ self._testPrelude(test.id()) self._write( "%s%s ... " % (self.indent * (len(self._lastTest)), self.getDescription(test)) ) super().startTest(test) def endLine(self, message, color): """ Print 'message' in the given color. @param message: A string message, usually '[OK]' or something similar. @param color: A string color, 'red', 'green' and so forth. """ spaces = " " * (self.columns - len(self.currentLine) - len(message)) super()._write(spaces) self._colorizer.write(message, color) super()._write("\n") def _printSummary(self): """ Print a line summarising the test results to the stream, and color the status result. """ summary = self._getSummary() if self.wasSuccessful(): status = "PASSED" color = self.SUCCESS else: status = "FAILED" color = self.FAILURE self._colorizer.write(status, color) self._write("%s\n", summary) PK Mb�Z6 F7�| �| trial/runner.pynu �[��� # -*- test-case-name: twisted.trial.test.test_runner -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ A miscellany of code used to run Trial tests. Maintainer: Jonathan Lange """ __all__ = [ "TestSuite", "DestructiveTestSuite", "ErrorHolder", "LoggedSuite", "TestHolder", "TestLoader", "TrialRunner", "TrialSuite", "filenameToModule", "isPackage", "isPackageDirectory", "isTestCase", "name", "samefile", "NOT_IN_TEST", ] import doctest import importlib import inspect import os import sys import time import types import warnings from importlib.machinery import SourceFileLoader from zope.interface import implementer from twisted.internet import defer from twisted.python import failure, filepath, log, modules, reflect from twisted.trial import unittest, util from twisted.trial._asyncrunner import _ForceGarbageCollectionDecorator, _iterateTests from twisted.trial._synctest import _logObserver from twisted.trial.itrial import ITestCase from twisted.trial.reporter import UncleanWarningsReporterWrapper, _ExitWrapper # These are imported so that they remain in the public API for t.trial.runner from twisted.trial.unittest import TestSuite pyunit = __import__("unittest") def isPackage(module): """Given an object return True if the object looks like a package""" if not isinstance(module, types.ModuleType): return False basename = os.path.splitext(os.path.basename(module.__file__))[0] return basename == "__init__" def isPackageDirectory(dirname): """ Is the directory at path 'dirname' a Python package directory? Returns the name of the __init__ file (it may have a weird extension) if dirname is a package directory. Otherwise, returns False """ def _getSuffixes(): return importlib.machinery.all_suffixes() for ext in _getSuffixes(): initFile = "__init__" + ext if os.path.exists(os.path.join(dirname, initFile)): return initFile return False def samefile(filename1, filename2): """ A hacky implementation of C{os.path.samefile}. Used by L{filenameToModule} when the platform doesn't provide C{os.path.samefile}. Do not use this. """ return os.path.abspath(filename1) == os.path.abspath(filename2) def filenameToModule(fn): """ Given a filename, do whatever possible to return a module object matching that file. If the file in question is a module in Python path, properly import and return that module. Otherwise, load the source manually. @param fn: A filename. @return: A module object. @raise ValueError: If C{fn} does not exist. """ oldFn = fn if (3, 8) <= sys.version_info < (3, 10) and not os.path.isabs(fn): # module.__spec__.__file__ is supposed to be absolute in py3.8+ # importlib.util.spec_from_file_location does this automatically from # 3.10+ # This was backported to 3.8 and 3.9, but then reverted in 3.8.11 and # 3.9.6 # See https://twistedmatrix.com/trac/ticket/10230 # and https://bugs.python.org/issue44070 fn = os.path.join(os.getcwd(), fn) if not os.path.exists(fn): raise ValueError(f"{oldFn!r} doesn't exist") moduleName = reflect.filenameToModuleName(fn) try: ret = reflect.namedAny(moduleName) except (ValueError, AttributeError): # Couldn't find module. The file 'fn' is not in PYTHONPATH return _importFromFile(fn, moduleName=moduleName) # >=3.7 has __file__ attribute as None, previously __file__ was not present if getattr(ret, "__file__", None) is None: # This isn't a Python module in a package, so import it from a file return _importFromFile(fn, moduleName=moduleName) # ensure that the loaded module matches the file retFile = os.path.splitext(ret.__file__)[0] + ".py" # not all platforms (e.g. win32) have os.path.samefile same = getattr(os.path, "samefile", samefile) if os.path.isfile(fn) and not same(fn, retFile): del sys.modules[ret.__name__] ret = _importFromFile(fn, moduleName=moduleName) return ret def _importFromFile(fn, *, moduleName): fn = _resolveDirectory(fn) if not moduleName: moduleName = os.path.splitext(os.path.split(fn)[-1])[0] if moduleName in sys.modules: return sys.modules[moduleName] spec = importlib.util.spec_from_file_location(moduleName, fn) if not spec: raise SyntaxError(fn) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) sys.modules[moduleName] = module return module def _resolveDirectory(fn): if os.path.isdir(fn): initFile = isPackageDirectory(fn) if initFile: fn = os.path.join(fn, initFile) else: raise ValueError(f"{fn!r} is not a package directory") return fn def _getMethodNameInClass(method): """ Find the attribute name on the method's class which refers to the method. For some methods, notably decorators which have not had __name__ set correctly: getattr(method.im_class, method.__name__) != method """ if getattr(method.im_class, method.__name__, object()) != method: for alias in dir(method.im_class): if getattr(method.im_class, alias, object()) == method: return alias return method.__name__ class DestructiveTestSuite(TestSuite): """ A test suite which remove the tests once run, to minimize memory usage. """ def run(self, result): """ Almost the same as L{TestSuite.run}, but with C{self._tests} being empty at the end. """ while self._tests: if result.shouldStop: break test = self._tests.pop(0) test(result) return result # When an error occurs outside of any test, the user will see this string # in place of a test's name. NOT_IN_TEST = "<not in test>" class LoggedSuite(TestSuite): """ Any errors logged in this suite will be reported to the L{TestResult} object. """ def run(self, result): """ Run the suite, storing all errors in C{result}. If an error is logged while no tests are running, then it will be added as an error to C{result}. @param result: A L{TestResult} object. """ observer = _logObserver observer._add() super().run(result) observer._remove() for error in observer.getErrors(): result.addError(TestHolder(NOT_IN_TEST), error) observer.flushErrors() class TrialSuite(TestSuite): """ Suite to wrap around every single test in a C{trial} run. Used internally by Trial to set up things necessary for Trial tests to work, regardless of what context they are run in. """ def __init__(self, tests=(), forceGarbageCollection=False): if forceGarbageCollection: newTests = [] for test in tests: test = unittest.decorate(test, _ForceGarbageCollectionDecorator) newTests.append(test) tests = newTests suite = LoggedSuite(tests) super().__init__([suite]) def _bail(self): from twisted.internet import reactor d = defer.Deferred() reactor.addSystemEventTrigger("after", "shutdown", lambda: d.callback(None)) reactor.fireSystemEvent("shutdown") # radix's suggestion # As long as TestCase does crap stuff with the reactor we need to # manually shutdown the reactor here, and that requires util.wait # :( # so that the shutdown event completes unittest.TestCase("mktemp")._wait(d) def run(self, result): try: TestSuite.run(self, result) finally: self._bail() def name(thing): """ @param thing: an object from modules (instance of PythonModule, PythonAttribute), a TestCase subclass, or an instance of a TestCase. """ if isTestCase(thing): # TestCase subclass theName = reflect.qual(thing) else: # thing from trial, or thing from modules. # this monstrosity exists so that modules' objects do not have to # implement id(). -jml try: theName = thing.id() except AttributeError: theName = thing.name return theName def isTestCase(obj): """ @return: C{True} if C{obj} is a class that contains test cases, C{False} otherwise. Used to find all the tests in a module. """ try: return issubclass(obj, pyunit.TestCase) except TypeError: return False @implementer(ITestCase) class TestHolder: """ Placeholder for a L{TestCase} inside a reporter. As far as a L{TestResult} is concerned, this looks exactly like a unit test. """ failureException = None def __init__(self, description): """ @param description: A string to be displayed L{TestResult}. """ self.description = description def __call__(self, result): return self.run(result) def id(self): return self.description def countTestCases(self): return 0 def run(self, result): """ This test is just a placeholder. Run the test successfully. @param result: The C{TestResult} to store the results in. @type result: L{twisted.trial.itrial.IReporter}. """ result.startTest(self) result.addSuccess(self) result.stopTest(self) def shortDescription(self): return self.description class ErrorHolder(TestHolder): """ Used to insert arbitrary errors into a test suite run. Provides enough methods to look like a C{TestCase}, however, when it is run, it simply adds an error to the C{TestResult}. The most common use-case is for when a module fails to import. """ def __init__(self, description, error): """ @param description: A string used by C{TestResult}s to identify this error. Generally, this is the name of a module that failed to import. @param error: The error to be added to the result. Can be an `exc_info` tuple or a L{twisted.python.failure.Failure}. """ super().__init__(description) self.error = util.excInfoOrFailureToExcInfo(error) def __repr__(self) -> str: return "<ErrorHolder description={!r} error={!r}>".format( self.description, self.error[1], ) def run(self, result): """ Run the test, reporting the error. @param result: The C{TestResult} to store the results in. @type result: L{twisted.trial.itrial.IReporter}. """ result.startTest(self) result.addError(self, self.error) result.stopTest(self) class TestLoader: """ I find tests inside function, modules, files -- whatever -- then return them wrapped inside a Test (either a L{TestSuite} or a L{TestCase}). @ivar methodPrefix: A string prefix. C{TestLoader} will assume that all the methods in a class that begin with C{methodPrefix} are test cases. @ivar modulePrefix: A string prefix. Every module in a package that begins with C{modulePrefix} is considered a module full of tests. @ivar forceGarbageCollection: A flag applied to each C{TestCase} loaded. See L{unittest.TestCase} for more information. @ivar sorter: A key function used to sort C{TestCase}s, test classes, modules and packages. @ivar suiteFactory: A callable which is passed a list of tests (which themselves may be suites of tests). Must return a test suite. """ methodPrefix = "test" modulePrefix = "test_" def __init__(self): self.suiteFactory = TestSuite self.sorter = name self._importErrors = [] def sort(self, xs): """ Sort the given things using L{sorter}. @param xs: A list of test cases, class or modules. """ return sorted(xs, key=self.sorter) def findTestClasses(self, module): """Given a module, return all Trial test classes""" classes = [] for name, val in inspect.getmembers(module): if isTestCase(val): classes.append(val) return self.sort(classes) def findByName(self, _name, recurse=False): """ Find and load tests, given C{name}. @param _name: The qualified name of the thing to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @return: If C{name} is a filename, return the module. If C{name} is a fully-qualified Python name, return the object it refers to. """ if os.sep in _name: # It's a file, try and get the module name for this file. name = reflect.filenameToModuleName(_name) try: # Try and import it, if it's on the path. # CAVEAT: If you have two twisteds, and you try and import the # one NOT on your path, it'll load the one on your path. But # that's silly, nobody should do that, and existing Trial does # that anyway. __import__(name) except ImportError: # If we can't import it, look for one NOT on the path. return self.loadFile(_name, recurse=recurse) else: name = _name obj = parent = remaining = None for searchName, remainingName in _qualNameWalker(name): # Walk down the qualified name, trying to import a module. For # example, `twisted.test.test_paths.FilePathTests` would try # the full qualified name, then just up to test_paths, and then # just up to test, and so forth. # This gets us the highest level thing which is a module. try: obj = reflect.namedModule(searchName) # If we reach here, we have successfully found a module. # obj will be the module, and remaining will be the remaining # part of the qualified name. remaining = remainingName break except ImportError: # Check to see where the ImportError happened. If it happened # in this file, ignore it. tb = sys.exc_info()[2] # Walk down to the deepest frame, where it actually happened. while tb.tb_next is not None: tb = tb.tb_next # Get the filename that the ImportError originated in. filenameWhereHappened = tb.tb_frame.f_code.co_filename # If it originated in the reflect file, then it's because it # doesn't exist. If it originates elsewhere, it's because an # ImportError happened in a module that does exist. if filenameWhereHappened != reflect.__file__: raise if remaining == "": raise reflect.ModuleNotFound(f"The module {name} does not exist.") if obj is None: # If it's none here, we didn't get to import anything. # Try something drastic. obj = reflect.namedAny(name) remaining = name.split(".")[len(".".split(obj.__name__)) + 1 :] try: for part in remaining: # Walk down the remaining modules. Hold on to the parent for # methods, as on Python 3, you can no longer get the parent # class from just holding onto the method. parent, obj = obj, getattr(obj, part) except AttributeError: raise AttributeError(f"{name} does not exist.") return self.loadAnything( obj, parent=parent, qualName=remaining, recurse=recurse ) def loadModule(self, module): """ Return a test suite with all the tests from a module. Included are TestCase subclasses and doctests listed in the module's __doctests__ module. If that's not good for you, put a function named either C{testSuite} or C{test_suite} in your module that returns a TestSuite, and I'll use the results of that instead. If C{testSuite} and C{test_suite} are both present, then I'll use C{testSuite}. """ ## XXX - should I add an optional parameter to disable the check for ## a custom suite. ## OR, should I add another method if not isinstance(module, types.ModuleType): raise TypeError(f"{module!r} is not a module") if hasattr(module, "testSuite"): return module.testSuite() elif hasattr(module, "test_suite"): return module.test_suite() suite = self.suiteFactory() for testClass in self.findTestClasses(module): suite.addTest(self.loadClass(testClass)) if not hasattr(module, "__doctests__"): return suite docSuite = self.suiteFactory() for docTest in module.__doctests__: docSuite.addTest(self.loadDoctests(docTest)) return self.suiteFactory([suite, docSuite]) loadTestsFromModule = loadModule def loadClass(self, klass): """ Given a class which contains test cases, return a list of L{TestCase}s. @param klass: The class to load tests from. """ if not isinstance(klass, type): raise TypeError(f"{klass!r} is not a class") if not isTestCase(klass): raise ValueError(f"{klass!r} is not a test case") names = self.getTestCaseNames(klass) tests = self.sort( [self._makeCase(klass, self.methodPrefix + name) for name in names] ) return self.suiteFactory(tests) loadTestsFromTestCase = loadClass def getTestCaseNames(self, klass): """ Given a class that contains C{TestCase}s, return a list of names of methods that probably contain tests. """ return reflect.prefixedMethodNames(klass, self.methodPrefix) def loadMethod(self, method): raise NotImplementedError("Can't happen on Py3") def _makeCase(self, klass, methodName): return klass(methodName) def loadPackage(self, package, recurse=False): """ Load tests from a module object representing a package, and return a TestSuite containing those tests. Tests are only loaded from modules whose name begins with 'test_' (or whatever C{modulePrefix} is set to). @param package: a types.ModuleType object (or reasonable facsimile obtained by importing) which may contain tests. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @raise TypeError: If C{package} is not a package. @return: a TestSuite created with my suiteFactory, containing all the tests. """ if not isPackage(package): raise TypeError(f"{package!r} is not a package") pkgobj = modules.getModule(package.__name__) if recurse: discovery = pkgobj.walkModules() else: discovery = pkgobj.iterModules() discovered = [] for disco in discovery: if disco.name.split(".")[-1].startswith(self.modulePrefix): discovered.append(disco) suite = self.suiteFactory() for modinfo in self.sort(discovered): try: module = modinfo.load() except BaseException: thingToAdd = ErrorHolder(modinfo.name, failure.Failure()) else: thingToAdd = self.loadModule(module) suite.addTest(thingToAdd) return suite def loadDoctests(self, module): """ Return a suite of tests for all the doctests defined in C{module}. @param module: A module object or a module name. """ if isinstance(module, str): try: module = reflect.namedAny(module) except BaseException: return ErrorHolder(module, failure.Failure()) if not inspect.ismodule(module): warnings.warn("trial only supports doctesting modules") return extraArgs = {} # Work around Python issue2604: DocTestCase.tearDown clobbers globs def saveGlobals(test): """ Save C{test.globs} and replace it with a copy so that if necessary, the original will be available for the next test run. """ test._savedGlobals = getattr(test, "_savedGlobals", test.globs) test.globs = test._savedGlobals.copy() extraArgs["setUp"] = saveGlobals return doctest.DocTestSuite(module, **extraArgs) def loadAnything(self, obj, recurse=False, parent=None, qualName=None): """ Load absolutely anything (as long as that anything is a module, package, class, or method (with associated parent class and qualname). @param obj: The object to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @param parent: If C{obj} is a method, this is the parent class of the method. C{qualName} is also required. @param qualName: If C{obj} is a method, this a list containing is the qualified name of the method. C{parent} is also required. @return: A C{TestCase} or C{TestSuite}. """ if isinstance(obj, types.ModuleType): # It looks like a module if isPackage(obj): # It's a package, so recurse down it. return self.loadPackage(obj, recurse=recurse) # Otherwise get all the tests in the module. return self.loadTestsFromModule(obj) elif isinstance(obj, type) and issubclass(obj, pyunit.TestCase): # We've found a raw test case, get the tests from it. return self.loadTestsFromTestCase(obj) elif ( isinstance(obj, types.FunctionType) and isinstance(parent, type) and issubclass(parent, pyunit.TestCase) ): # We've found a method, and its parent is a TestCase. Instantiate # it with the name of the method we want. name = qualName[-1] inst = parent(name) # Sanity check to make sure that the method we have got from the # test case is the same one as was passed in. This doesn't actually # use the function we passed in, because reasons. assert getattr(inst, inst._testMethodName).__func__ == obj return inst elif isinstance(obj, TestSuite): # We've found a test suite. return obj else: raise TypeError(f"don't know how to make test from: {obj}") def loadByName(self, name, recurse=False): """ Load some tests by name. @param name: The qualified name for the test to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. """ try: return self.suiteFactory([self.findByName(name, recurse=recurse)]) except BaseException: return self.suiteFactory([ErrorHolder(name, failure.Failure())]) loadTestsFromName = loadByName def loadByNames(self, names, recurse=False): """ Load some tests by a list of names. @param names: A L{list} of qualified names. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. """ things = [] errors = [] for name in names: try: things.append(self.loadByName(name, recurse=recurse)) except BaseException: errors.append(ErrorHolder(name, failure.Failure())) things.extend(errors) return self.suiteFactory(self._uniqueTests(things)) def _uniqueTests(self, things): """ Gather unique suite objects from loaded things. This will guarantee uniqueness of inherited methods on TestCases which would otherwise hash to same value and collapse to one test unexpectedly if using simpler means: e.g. set(). """ seen = set() for testthing in things: testthings = testthing._tests for thing in testthings: # This is horrible. if str(thing) not in seen: yield thing seen.add(str(thing)) def loadFile(self, fileName, recurse=False): """ Load a file, and then the tests in that file. @param fileName: The file name to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. """ name = reflect.filenameToModuleName(fileName) try: module = SourceFileLoader(name, fileName).load_module() return self.loadAnything(module, recurse=recurse) except OSError: raise ValueError(f"{fileName} is not a Python file.") def _qualNameWalker(qualName): """ Given a Python qualified name, this function yields a 2-tuple of the most specific qualified name first, followed by the next-most-specific qualified name, and so on, paired with the remainder of the qualified name. @param qualName: A Python qualified name. @type qualName: L{str} """ # Yield what we were just given yield (qualName, []) # If they want more, split the qualified name up qualParts = qualName.split(".") for index in range(1, len(qualParts)): # This code here will produce, from the example walker.texas.ranger: # (walker.texas, ["ranger"]) # (walker, ["texas", "ranger"]) yield (".".join(qualParts[:-index]), qualParts[-index:]) class TrialRunner: """ A specialised runner that the trial front end uses. """ DEBUG = "debug" DRY_RUN = "dry-run" def _setUpTestdir(self): self._tearDownLogFile() currentDir = os.getcwd() base = filepath.FilePath(self.workingDirectory) testdir, self._testDirLock = util._unusedTestDirectory(base) os.chdir(testdir.path) return currentDir def _tearDownTestdir(self, oldDir): os.chdir(oldDir) self._testDirLock.unlock() _log = log def _makeResult(self): reporter = self.reporterFactory( self.stream, self.tbformat, self.rterrors, self._log ) if self._exitFirst: reporter = _ExitWrapper(reporter) if self.uncleanWarnings: reporter = UncleanWarningsReporterWrapper(reporter) return reporter def __init__( self, reporterFactory, mode=None, logfile="test.log", stream=sys.stdout, profile=False, tracebackFormat="default", realTimeErrors=False, uncleanWarnings=False, workingDirectory=None, forceGarbageCollection=False, debugger=None, exitFirst=False, ): self.reporterFactory = reporterFactory self.logfile = logfile self.mode = mode self.stream = stream self.tbformat = tracebackFormat self.rterrors = realTimeErrors self.uncleanWarnings = uncleanWarnings self._result = None self.workingDirectory = workingDirectory or "_trial_temp" self._logFileObserver = None self._logFileObject = None self._forceGarbageCollection = forceGarbageCollection self.debugger = debugger self._exitFirst = exitFirst if profile: self.run = util.profiled(self.run, "profile.data") def _tearDownLogFile(self): if self._logFileObserver is not None: log.removeObserver(self._logFileObserver.emit) self._logFileObserver = None if self._logFileObject is not None: self._logFileObject.close() self._logFileObject = None def _setUpLogFile(self): self._tearDownLogFile() if self.logfile == "-": logFile = sys.stdout else: logFile = open(self.logfile, "a") self._logFileObject = logFile self._logFileObserver = log.FileLogObserver(logFile) log.startLoggingWithObserver(self._logFileObserver.emit, 0) def run(self, test): """ Run the test or suite and return a result object. """ test = unittest.decorate(test, ITestCase) return self._runWithoutDecoration(test, self._forceGarbageCollection) def _runWithoutDecoration(self, test, forceGarbageCollection=False): """ Private helper that runs the given test but doesn't decorate it. """ result = self._makeResult() # decorate the suite with reactor cleanup and log starting # This should move out of the runner and be presumed to be # present suite = TrialSuite([test], forceGarbageCollection) startTime = time.time() if self.mode == self.DRY_RUN: for single in _iterateTests(suite): result.startTest(single) result.addSuccess(single) result.stopTest(single) else: if self.mode == self.DEBUG: run = lambda: self.debugger.runcall(suite.run, result) else: run = lambda: suite.run(result) oldDir = self._setUpTestdir() try: self._setUpLogFile() run() finally: self._tearDownLogFile() self._tearDownTestdir(oldDir) endTime = time.time() done = getattr(result, "done", None) if done is None: warnings.warn( "%s should implement done() but doesn't. Falling back to " "printErrors() and friends." % reflect.qual(result.__class__), category=DeprecationWarning, stacklevel=3, ) result.printErrors() result.writeln(result.separator) result.writeln( "Ran %d tests in %.3fs", result.testsRun, endTime - startTime ) result.write("\n") result.printSummary() else: result.done() return result def runUntilFailure(self, test): """ Repeatedly run C{test} until it fails. """ count = 0 while True: count += 1 self.stream.write("Test Pass %d\n" % (count,)) if count == 1: result = self.run(test) else: result = self._runWithoutDecoration(test) if result.testsRun == 0: break if not result.wasSuccessful(): break return result PK Mb�Z�" � � trial/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # Maintainer: Jonathan Lange """ Twisted Trial: Asynchronous unit testing framework. Trial extends Python's builtin C{unittest} to provide support for asynchronous tests. Trial strives to be compatible with other Python xUnit testing frameworks. "Compatibility" is a difficult things to define. In practice, it means that: - L{twisted.trial.unittest.TestCase} objects should be able to be used by other test runners without those runners requiring special support for Trial tests. - Tests that subclass the standard library C{TestCase} and don't do anything "too weird" should be able to be discoverable and runnable by the Trial test runner without the authors of those tests having to jump through hoops. - Tests that implement the interface provided by the standard library C{TestCase} should be runnable by the Trial runner. - The Trial test runner and Trial L{unittest.TestCase} objects ought to be able to use standard library C{TestResult} objects, and third party C{TestResult} objects based on the standard library. This list is not necessarily exhaustive -- compatibility is hard to define. Contributors who discover more helpful ways of defining compatibility are encouraged to update this document. Examples: B{Timeouts} for tests should be implemented in the runner. If this is done, then timeouts could work for third-party TestCase objects as well as for L{twisted.trial.unittest.TestCase} objects. Further, Twisted C{TestCase} objects will run in other runners without timing out. See U{http://twistedmatrix.com/trac/ticket/2675}. Running tests in a temporary directory should be a feature of the test case, because often tests themselves rely on this behaviour. If the feature is implemented in the runner, then tests will change behaviour (possibly breaking) when run in a different test runner. Further, many tests don't even care about the filesystem. See U{http://twistedmatrix.com/trac/ticket/2916}. """ PK Mb�Z<�H�� �� % spread/__pycache__/pb.cpython-310.pycnu �[��� o �b_� � @ s� d Z ddlZddlmZ ddlmZmZ ddlmZm Z m Z m Z ddl m Z ddlmZmZ ddlmZ dd lmZmZmZ dd lmZmZ dd lmZ dd l m Z dd l m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 ddl3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z: dZ;dZ<G dd� de=�Z>G dd� de>�Z?G dd� de=�Z@G dd� de=�ZAeG dd� d��ZBG d d � d e=�ZCG d d � d e�ZDeeD�G d d!� d!��ZEG d"d#� d#e$�ZFee5�eG d$d%� d%e)ejG���ZHe1d&eH� G d'd(� d(�ZIG d)d*� d*ejJe �ZKG d+d,� d,e'ejJ�ZLe1eKeL� dDd-d.�ZMG d/d0� d0e jN�ZOd1d2� ZPd3d4� ZQG d5d6� d6ejR�ZSG d7d8� d8ejT�ZUG d9d:� d:e �ZVee!�G d;d<� d<��ZWeeWe e!� G d=d>� d>�ZXG d?d@� d@e$eX�ZYee eV�G dAdB� dBe$eX��ZZg dC�Z[dS )Ea� Perspective Broker "This isn't a professional opinion, but it's probably got enough internet to kill you." --glyph Introduction ============ This is a broker for proxies for and copies of objects. It provides a translucent interface layer to those proxies. The protocol is not opaque, because it provides objects which represent the remote proxies and require no context (server references, IDs) to operate on. It is not transparent because it does I{not} attempt to make remote objects behave identically, or even similarly, to local objects. Method calls are invoked asynchronously, and specific rules are applied when serializing arguments. To get started, begin with L{PBClientFactory} and L{PBServerFactory}. @author: Glyph Lefkowitz � N)�md5)� Interface� implementer)� Anonymous� IAnonymous� ICredentials�IUsernameHashedPassword)�Portal)�defer�protocol)�styles)�failure�log�reflect)�cmp� comparable)�registerAdapter)�banana)� Cacheable�Copyable�IPBRoot� Jellyable� NoSuchMethod� Referenceable� RemoteCache�RemoteCacheObserver� RemoteCopy�Root� Serializable�Viewable� ViewPoint�copyTags�setCopierForClass�setCopierForClassTree�setFactoryForClass� setUnjellyableFactoryForClass�setUnjellyableForClass�setUnjellyableForClassTree)� IJellyable� IUnjellyable)� _newInstance�globalSecurity�jelly�unjellyi iS" c @ � e Zd ZdZdS )� ProtocolErrorzN This error is raised when an invalid protocol statement is received. N��__name__� __module__� __qualname__�__doc__� r5 r5 �3/usr/lib/python3/dist-packages/twisted/spread/pb.pyr/ T � r/ c @ r. )�DeadReferenceErrorzx This error is raised when a method is called on a dead reference (one whose broker has been disconnected). Nr0 r5 r5 r5 r6 r8 Z r7 r8 c @ r. )�Errora This error can be raised to generate known error conditions. When a PB callable method (perspective_, remote_, view_) raises this error, it indicates that a traceback should not be printed, but instead, the string representation of the exception should be sent. Nr0 r5 r5 r5 r6 r9 a r7 r9 c @ � e Zd ZdZdd� ZdS )� RemoteErrora� This class is used to wrap a string-ified exception from the remote side to be able to reraise it. (Raising string exceptions is no longer possible in Python 2.6+) The value of this exception will be a str() representation of the remote value. @ivar remoteType: The full import path of the exception class which was raised on the remote end. @type remoteType: C{str} @ivar remoteTraceback: The remote traceback. @type remoteTraceback: C{str} @note: It's not possible to include the remoteTraceback if this exception is thrown into a generator. It must be accessed as an attribute. c C s t �| |� || _|| _d S �N)� Exception�__init__� remoteType�remoteTraceback)�selfr? �valuer@ r5 r5 r6 r> � s zRemoteError.__init__N�r1 r2 r3 r4 r> r5 r5 r5 r6 r; l s r; c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � RemoteMethodz> This is a translucent reference to a remote message. c C s || _ || _dS )zT Initialize with a L{RemoteReference} and the name of this message. N)�obj�name)rA rF rG r5 r5 r6 r> � s zRemoteMethod.__init__c C s t | j| jf|�S r< )r rF rG �rA �otherr5 r5 r6 �__cmp__� s zRemoteMethod.__cmp__c C s t | j| jf�S r< )�hashrF rG �rA r5 r5 r6 �__hash__� s zRemoteMethod.__hash__c O s( | j j�d| j j| j j| j�d�||�S )z8 Asynchronously invoke a remote method. � �utf-8)rF �broker� _sendMessage� perspective�luidrG �encode)rA �args�kwr5 r5 r6 �__call__� s �zRemoteMethod.__call__N)r1 r2 r3 r4 r> rJ rM rW r5 r5 r5 r6 rE � s rE c @ s e Zd ZdS )�PBConnectionLostN)r1 r2 r3 r5 r5 r5 r6 rX � s rX c @ r: )� IPerspectivea per*spec*tive, n. : The relationship of aspects of a subject to each other and to a whole: 'a perspective of history'; 'a need to view the problem in the proper perspective'. This is a Perspective Broker-specific wrapper for an avatar. That is to say, a PB-published view on to the business logic for the system's concept of a 'user'. The concept of attached/detached is no longer implemented by the framework. The realm is expected to implement such semantics if needed. c C � dS )a� This method is called when a network message is received. @arg broker: The Perspective Broker. @type message: str @arg message: The name of the method called by the other end. @type args: list in jelly format @arg args: The arguments that were passed by the other end. It is recommend that you use the `unserialize' method of the broker to decode this. @type kwargs: dict in jelly format @arg kwargs: The keyword arguments that were passed by the other end. It is recommended that you use the `unserialize' method of the broker to decode this. @rtype: A jelly list. @return: It is recommended that you use the `serialize' method of the broker on whatever object you need to return to generate the return value. Nr5 )rP �messagerU �kwargsr5 r5 r6 �perspectiveMessageReceived� � z'IPerspective.perspectiveMessageReceivedN�r1 r2 r3 r4 r] r5 r5 r5 r6 rY � s rY c @ r: )�Avatara A default IPerspective implementor. This class is intended to be subclassed, and a realm should return an instance of such a subclass when IPerspective is requested of it. A peer requesting a perspective will receive only a L{RemoteReference} to a pb.Avatar. When a method is called on that L{RemoteReference}, it will translate to a method on the remote perspective named 'perspective_methodname'. (For more information on invoking methods on other objects, see L{flavors.ViewPoint}.) c C sv |� || �}|� || �}t| d| �}z ||i |��}W n ty1 t�|� d|� d|� �� � w |�|| |||�S )ai This method is called when a network message is received. This will call:: self.perspective_%(message)s(*broker.unserialize(args), **broker.unserialize(kw)) to handle the method; subclasses of Avatar are expected to implement methods using this naming convention. zperspective_%sz didn't accept z and )� unserialize�getattr� TypeErrorr �msg� serialize)rA rP r[ rU rV �method�stater5 r5 r6 r] � s �z!Avatar.perspectiveMessageReceivedNr_ r5 r5 r5 r6 r` � s r` c @ s e Zd ZdZddd�ZdS )�AsReferenceablez6 A reference directed towards another object. �remotec C s t ||d �| _d S )N�MessageReceived)rb �remoteMessageReceived)rA �object� messageTyper5 r5 r6 r> s zAsReferenceable.__init__N)ri rC r5 r5 r5 r6 rh � s rh c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�RemoteReferencea] A translucent reference to a remote object. I may be a reference to a L{flavors.ViewPoint}, a L{flavors.Referenceable}, or an L{IPerspective} implementer (e.g., pb.Avatar). From the client's perspective, it is not possible to tell which except by convention. I am a "translucent" reference because although no additional bookkeeping overhead is given to the application programmer for manipulating a reference, return values are asynchronous. See also L{twisted.internet.defer}. @ivar broker: The broker I am obtained through. @type broker: L{Broker} c C s" || _ || _|| _|| _g | _dS )z�(internal) Initialize me with a broker and a locally-unique ID. The ID is unique only to the particular Perspective Broker instance. N)rS rP � doRefCountrR �disconnectCallbacks)rA rR rP rS ro r5 r5 r6 r> s zRemoteReference.__init__c C s< t |�sJ �| j�|� t| j�dkr | j�| j� dS dS )z� Register a callback to be called if our broker gets disconnected. @param callback: a callable which will be called with one argument, this instance. � N)�callablerp �append�lenrP �notifyOnDisconnect� _disconnected�rA �callbackr5 r5 r6 ru ' s �z"RemoteReference.notifyOnDisconnectc C s( | j �|� | j s| j�| j� dS dS )zu Remove a callback that was registered with notifyOnDisconnect. @param callback: a callable N)rp �removerP �dontNotifyOnDisconnectrv rw r5 r5 r6 rz 3 s �z&RemoteReference.dontNotifyOnDisconnectc C s | j D ]}|| � qd| _ dS )zN Called if we are disconnected and have callbacks registered. N)rp rw r5 r5 r6 rv = s z RemoteReference._disconnectedc C s( |j r| j|j ks J d��d| jfS dS )zc If I am being sent back to where I came from, serialize as a local backreference. z6Can't send references to brokers other than their own.s local)s unpersistablez References cannot be serialized)�invokerrP rS )rA �jellierr5 r5 r6 �jellyForE s � zRemoteReference.jellyForc C s | � |jj|j|d d� | S )Nrq )r> r{ �unserializingPerspective)rA � unjellier� unjellyListr5 r5 r6 � unjellyForQ s �zRemoteReference.unjellyForc O s. t |t�s |�d�}| j�d| j| j|||�S )a� Asynchronously invoke a remote method. @type _name: L{str} @param _name: the name of the remote method to invoke @param args: arguments to serialize for the remote function @param kw: keyword arguments to serialize for the remote function. @rtype: L{twisted.internet.defer.Deferred} @returns: a Deferred which will be fired when the result of this remote call is received. �utf8rN )� isinstance�bytesrT rP rQ rR rS )rA �_namerU rV r5 r5 r6 � callRemoteZ s �zRemoteReference.callRemotec C s t | |�S )zX @param key: The key. @return: A L{RemoteMethod} for this key. )rE )rA �keyr5 r5 r6 � remoteMethodp s z RemoteReference.remoteMethodc C s0 t |t�r|j| jkrt| j|j�S t| j|�S )zM @param other: another L{RemoteReference} to compare me to. )r� rn rP r rS rH r5 r5 r6 rJ x s zRemoteReference.__cmp__c C s | j S )z Hash me. )rS rL r5 r5 r6 rM � s zRemoteReference.__hash__c C s | j r | j�| j� dS dS )zD Do distributed reference counting on finalization. N)ro rP � sendDecRefrS rL r5 r5 r6 �__del__� s �zRemoteReference.__del__N)r1 r2 r3 r4 r> ru rz rv r} r� r� r� rJ rM r� r5 r5 r5 r6 rn s rn ri c @ s8 e Zd ZdZd dd�Zdefdd�Zdd � Zd d � ZdS ) �Localz3 (internal) A reference to a local object. Nc C s || _ || _d| _dS )z Initialize. rq N)rl rR �refcount)rA rl rR r5 r5 r6 r> � s zLocal.__init__�returnc C s d| j �d| j� d�S )Nz <pb.Local z ref:�>)rl r� rL r5 r5 r6 �__repr__� s zLocal.__repr__c C � | j d | _ | j S )zi Increment the reference count. @return: the reference count after incrementing rq �r� rL r5 r5 r6 �incref� � z Local.increfc C s | j d | _ | j S )zi Decrement the reference count. @return: the reference count after decrementing rq r� rL r5 r5 r6 �decref� r� z Local.decrefr< ) r1 r2 r3 r4 r> �strr� r� r� r5 r5 r5 r6 r� � s r� c @ s e Zd ZdZdZdd� ZdS )�CopyableFailurez} A L{flavors.RemoteCopy} and L{flavors.Copyable} version of L{twisted.python.failure.Failure} for serialization. r c C s� | j �� }d|d< g |d< g |d< t| j�|d< t| jt�r$| j|d< n t�| j�� d�|d< | j r:| � � |d< |S d |d< |S ) z� Collect state related to the exception which occurred, discarding state which cannot reasonably be serialized. N�tb�frames�stackrB �typerO � tracebackzTraceback unavailable ) �__dict__�copyr� rB r� r� r� r �qualrT �unsafeTracebacks� getTraceback)rA rg r5 r5 r6 �getStateToCopy� s �z CopyableFailure.getStateToCopyN)r1 r2 r3 r4 r� r� r5 r5 r5 r6 r� � s r� c @ s* e Zd ZdZd dd�Zdd� ZeZeZdS ) � CopiedFailurea� A L{CopiedFailure} is a L{pb.RemoteCopy} of a L{failure.Failure} transferred via PB. @ivar type: The full import path of the exception class which was raised on the remote end. @type type: C{str} @ivar value: A str() representation of the remote value. @type value: L{CopiedFailure} or C{str} @ivar traceback: The remote traceback. @type traceback: C{str} Nr �defaultc C sT |d u rt j}| j}t|t�s|�d�}|�d� |�|d | j � |�d� d S )NrO z Traceback from remote host -- z: � )r �logfiler� r� r� �decode�writerB )rA �file�elideFrameworkCode�detail� failureTyper5 r5 r6 �printTraceback� s z CopiedFailure.printTracebackc C s |� t| j| j| j��S )a� Throw the original exception into the given generator, preserving traceback information if available. In the case of a L{CopiedFailure} where the exception type is a string, a L{pb.RemoteError} is thrown instead. @return: The next value yielded from the generator. @raise StopIteration: If there are no more values in the generator. @raise RemoteError: The wrapped remote exception. )�throwr; r� rB r� )rA �gr5 r5 r6 �throwExceptionIntoGenerator� s z)CopiedFailure.throwExceptionIntoGenerator)Nr r� )r1 r2 r3 r4 r� r� �printBriefTraceback�printDetailedTracebackr5 r5 r5 r6 r� � s r� c C s t t| j�}||_|S r< )r* r� r� r� )�failr� �fr5 r5 r6 �failure2Copyable s r� c @ s� e Zd ZdZdZdZdZdefdd�Zdd� Z d d � Z d d � Z d d� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� ZdZdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'Zd(d)� Zd*d+� Z d,d-� Z d^d.d/�Z d0d1� Z d2d3� Z d4d5� Z!d6d7� Z"d_d8d9�Z#d`d:d;�Z$d<d=� Z%d>d?� Z&d@dA� Z'dBdC� Z(dDdE� Z)dFdG� Z*dHdI� Z+dJdK� Z,dLdM� Z-dNdO� Z.dPdQ� Z/dRdS� Z0dTdU� Z1dVdW� Z2dXdY� Z3dZd[� Z4d\d]� Z5dS )a�Brokerz$ I am a broker for objects. � Nrq c C sr t j�| |� d| _g | _g | _g | _i | _|| _g | _ d| _ d| _ d | _ i | _ i | _i | _i | _i | _i | _d S �Nr )r �Bananar> � disconnected� disconnects�failures�connects� localObjects�security� pageProducers�currentRequestID�currentLocalIDr~ �luids�remotelyCachedObjects�remotelyCachedLUIDs�locallyCachedObjects�waitingForAnswers� _localCleanup)rA �isClientr� r5 r5 r6 r> s" zBroker.__init__c C sV t t| j�d dd�D ]}| j| }|�� |�� s | j|= q | js)| j�� dS dS )zM Called when the consumer attached to me runs out of buffer. rq ���N)�rangert r� � sendNextPage� stillPaging� transport�unregisterProducer)rA �pageridx�pagerr5 r5 r6 �resumeProducing7 s ��zBroker.resumeProducingc C � d S r< r5 rL r5 r5 r6 �pauseProducingD � zBroker.pauseProducingc C r� r< r5 rL r5 r5 r6 � stopProducingH r� zBroker.stopProducingc C s0 | j �|� t| j �dkr| j�| d� d S d S )Nrq r )r� rs rt r� �registerProducer)rA r� r5 r5 r6 �registerPageProducerL s �zBroker.registerPageProducerc C sj t |t�r1|d }t |t�s|�d�}d| }t| |d�}|r)||dd� � dS | �d|� dS td��)z: Evaluate an expression as it's received. r r� zproto_%sNrq s didNotUnderstandz Non-list expression received.)r� �listr� r� rb �sendCallr/ )rA �sexp�command� methodNamerf r5 r5 r6 �expressionReceivedQ s zBroker.expressionReceivedc C s$ || j krtd| j � d|� ���dS )z� Protocol message: (version version-number) Check to make sure that both ends of the protocol are speaking the same version dialect. @param vnum: The version number. zVersion Incompatibility: � N)�versionr/ )rA �vnumr5 r5 r6 � proto_versione s �zBroker.proto_versionc G s | � |� dS )z� Utility method to send an expression to the other side of the connection. @param exp: The expression. N)� sendEncoded)rA �expr5 r5 r6 r� r s zBroker.sendCallc C s t �d| � dS )a Respond to stock 'C{didNotUnderstand}' message. Log the command that was not understood and continue. (Note: this will probably be changed to close the connection or raise an exception in the future.) @param command: The command to log. z Didn't understand command: %rN)r rd )rA r� r5 r5 r6 �proto_didNotUnderstandz s z Broker.proto_didNotUnderstandc C sT | � d| j� | jD ]}z|� W q ty t�� Y q w d| _| j�| � dS )zF Initialize. Called after Banana negotiation is done. s versionN)r� r� r� � BaseExceptionr �deferr�factory�clientConnectionMade�rA �notifierr5 r5 r6 �connectionReady� s �zBroker.connectionReadyc C s: | j D ]}z|� W q ty t�� Y qw d | _ d S r< )r� r� r r� r� r5 r5 r6 �connectionFailed� s � zBroker.connectionFailedc C s d| _ d| _| jr*| j�� D ]}z |�t�t|��� W q ty) t � � Y qw | j �� D ]!}|j }|j }z |�|t| ||�� W q/ tyP t � � Y q/w | jdd� D ]}z|� W qX tyl t � � Y qXw d| _d| _d| _d| _d| _ d| _d| _d| _dS )zg The connection was lost. @param reason: message to put in L{failure.Failure} rq N)r� r� r� �values�errbackr �FailurerX r� r r� r� rl rR �stoppedObservingr r� � localSecurity�remoteSecurityr� r� r� )rA �reason�d�lobj� cacheablerR r� r5 r5 r6 �connectionLost� sB � � � � zBroker.connectionLostc C � t |�sJ �| j�|� dS )zQ @param notifier: callback to call when the Broker disconnects. N)rr r� rs r� r5 r5 r6 ru � � zBroker.notifyOnDisconnectc C r� )zT @param notifier: callback to call if the Broker fails to connect. N)rr r� rs r� r5 r5 r6 � notifyOnFail� r� zBroker.notifyOnFailc C sP t |�sJ �| jdu r z|� W dS ty t�� Y dS w | j�|� dS )zN @param notifier: callback to call when the Broker connects. N)rr r� r� r �errrs r� r5 r5 r6 �notifyOnConnect� s �zBroker.notifyOnConnectc C s( z | j �|� W dS ty Y dS w )zY @param notifier: callback to remove from list of disconnect callbacks. N)r� ry � ValueErrorr� r5 r5 r6 rz � s �z Broker.dontNotifyOnDisconnectc C s2 t |t�r |�d�}| j�|�}|du rdS |jS )z� Get a local object for a locally unique ID. @return: An object previously stored with L{registerReference} or L{None} if there is no object which corresponds to the given identifier. r� N)r� r� rT r� �getrl )rA rS �lobr5 r5 r6 �localObjectForID� s zBroker.localObjectForIDr c C s� |dusJ �|� � }| j�|�}|du rEt| j�tkr3| jd | _| jdkr/| j�� t d��t d��| � � }t |�| j|< || j|< |S | j| � � |S )z� Store a persistent reference to a local object and map its id() to a generated, session-unique ID. @param object: a local object @return: the generated ID Nrq � z.Maximum PB reference count exceeded. Goodbye.z$Maximum PB reference count exceeded.) �processUniqueIDr� r� rt r� �MAX_BROKER_REFS�maxBrokerRefsViolationsr� �loseConnectionr9 � newLocalIDr� r� )rA rl �puidrS r5 r5 r6 �registerReference s �zBroker.registerReferencec C s2 t |t�r |�d�}|dusJ �t|�| j|< dS )z� Store a special (string) ID for this object. This is how you specify a 'base' set of objects that the remote protocol can connect to. @param name: An ID. @param object: The object. r� N)r� r� rT r� r� )rA rG rl r5 r5 r6 �setNameForLocal s zBroker.setNameForLocalc C s" t |t�r |�d�}td| |d�S )a Returns an object from the remote name mapping. Note that this does not check the validity of the name, only creates a translucent reference for it. @param name: The name to look up. @return: An object which maps to the name. r� Nr )r� r� rT rn )rA rG r5 r5 r6 � remoteForName, s zBroker.remoteForNamec C s2 |� � }| j�|�}|dur|r| j| �� |S )a @param instance: The instance to look up. @param incref: Flag to specify whether to increment the reference. @return: An ID that says what this instance is cached as remotely, or L{None} if it's not. N)r r� r� r� r� )rA �instancer� r rS r5 r5 r6 �cachedRemotelyAs; s zBroker.cachedRemotelyAsc C s | j | jS )zk @param luid: The LUID to look up. @return: An instance which is cached remotely. )r� rl )rA rS r5 r5 r6 �remotelyCachedForLUIDK s z Broker.remotelyCachedForLUIDc C sn |� � }| �� }t| j�tkr'| jd | _| jdkr#| j�� td��td��|| j |< t || j �| j|< |S )z3 XXX @return: A new LUID. rq r z*Maximum PB cache count exceeded. Goodbye.z Maximum PB cache count exceeded.) r r rt r� r r r� r r9 r� r� �serializingPerspective)rA r r rS r5 r5 r6 � cacheRemotelyS s zBroker.cacheRemotelyc C s || j |< dS )zL(internal) Store a non-filled-out cached instance locally. N�r� �rA �cidr r5 r5 r6 � cacheLocallyh s zBroker.cacheLocallyc C s | j | }|S r< r r r5 r5 r6 �cachedLocallyAso s zBroker.cachedLocallyAsc C s� t |tj�r|j| jdd� ||||d�d� |S || _|| _|| _|| _zt || j d| �W d| _d| _d| _d| _S d| _d| _d| _d| _w )a Jelly an object according to the remote security rules for this broker. @param object: The object to jelly. @param perspective: The perspective. @param method: The method. @param args: Arguments. @param kw: Keyword arguments. c S s | S r< r5 )�xr5 r5 r6 �<lambda>� r^ z"Broker.serialize.<locals>.<lambda>)rR rf rU rV )�callbackKeywordsN) r� r �Deferred� addCallbacksre r � jellyMethod� jellyArgs�jellyKwr, r� )rA rl rR rf rU rV r5 r5 r6 re s s2 �� �zBroker.serializec C s( || _ z t|| jd| �W d| _ S d| _ w )z� Unjelly an sexp according to the local security rules for this broker. @param sexp: The object to unjelly. @param perspective: The perspective. N)r~ r- r� )rA r� rR r5 r5 r6 ra � s zBroker.unserializec C r� )z3 @return: A newly generated LUID. rq )r� rL r5 r5 r6 r � � zBroker.newLocalIDc C r� )z9 @return: A newly generated request ID. rq )r� rL r5 r5 r6 � newRequestID� r zBroker.newRequestIDc C s d }d }d} d|v r|d }|d= d|v r |d }|d= d|v r/|s$|r(J d��|d } |d= | j r6td��z| j|||d�} | j|||d�} W n tyX t�t�� � Y S w | �� } | rxt� � } | | j | < |sl|rwt � d� | � ||� nd } | �|d | ||| | | � | S ) Nrq � pbcallback� pberrback�pbanswerz*You can't specify a no-answer requirement.zCalling Stale Broker)rR rf z&warning! using deprecated "pbcallback"s message)r� r8 re r� r r� r r� r r r� r rd r r� )rA �prefixrR �objectIDr[ rU rV �pbc�pbe�answerRequired�netArgs�netKw� requestID�rvalr5 r5 r6 rQ � sP � �� zBroker._sendMessagec C � | � | j||||||� d S r< )� _recvMessager �rA r) r# r[ r& r' r( r5 r5 r6 � proto_message� � �zBroker.proto_messagec C r+ r< )r, r r- r5 r5 r6 �proto_cachemessage� r/ zBroker.proto_cachemessagec C s@ t |t�s |�d�}z||�}|du rtd��|�| |||�} W n] ty^ } z2|rLt | t�s6| j�| j�r=| � | |� n| � t | �|� W Y d} ~ dS W Y d} ~ dS W Y d} ~ dS d} ~ w t y} |rvt j ddd� t � } | � | |� t �� Y dS w |r�t | tj�r�|f} | j| j| j| | d� dS | �| |� dS dS )a� Received a message-send. Look up message based on object, unserialize the arguments, and invoke it with args, and send an 'answer' or 'error' response. @param findObjMethod: A callable which takes C{objectID} as argument. @param requestID: The requiest ID. @param objectID: The object ID. @param message: The message. @param answerRequired: @param netArgs: Arguments. @param netKw: Keyword arguments. r� NzInvalid Object ID�)Peer will receive following PB traceback:T)�isError)� callbackArgs� errbackArgs)r� r� r� r9 rk r r� �isClassAllowed� __class__� _sendErrorr� r� r rd r� r r r � _sendAnswer�_sendFailureOrError) rA � findObjMethodr) r# r[ r& r' r( rl � netResult�er� rU r5 r5 r6 r, � sF � � � � ��zBroker._recvMessagec C s | � d||� dS )z� (internal) Send an answer to a previously sent message. @param netResult: The answer. @param requestID: The request ID. s answerN�r� )rA r; r) r5 r5 r6 r8 @ � zBroker._sendAnswerc C �& | j | }| j |= |�| �|�� dS )z� (internal) Got an answer to a previously sent message. Look up the appropriate callback and call it. @param requestID: The request ID. @param netResult: The answer. N)r� rx ra )rA r) r; r� r5 r5 r6 � proto_answerI s zBroker.proto_answerc C s. |� t�du r| �||� dS | �||� dS )z� Call L{_sendError} or L{_sendFailure}, depending on whether C{fail} represents an L{Error} subclass or not. @param fail: The failure. @param requestID: The request ID. N)�checkr9 � _sendFailurer7 �rA r� r) r5 r5 r6 r9 V s zBroker._sendFailureOrErrorc C s$ t �d� t �|� | �||� dS )zz Log error and then send it. @param fail: The failure. @param requestID: The request ID. r1 N)r rd r� r7 rC r5 r5 r6 rB c s zBroker._sendFailurec C st t |tj�r$t |jt�s| j�|jj�r|j}n t |t�s$t || j j �}t |t�r.| j j |_ | � d|| � |�� dS )z� (internal) Send an error for a previously sent message. @param fail: The failure. @param requestID: The request ID. s errorN)r� r r� rB r r� r5 r6 r� r� r� r� r� re rC r5 r5 r6 r7 n s � zBroker._sendErrorc C r? )z} (internal) Deal with an error. @param requestID: The request ID. @param fail: The failure. N)r� r� ra )rA r) r� r� r5 r5 r6 � proto_error� s zBroker.proto_errorc C � | � d|� dS )z^ (internal) Send a DECREF directive. @param objectID: The object ID. s decrefNr= �rA r# r5 r5 r6 r� � � zBroker.sendDecRefc C sf t |t�r |�d�}| j| �� }|dkr1| j| j�� }| j|= | j|= | j� |dd� �� dS dS )z� (internal) Decrement the reference count of an object. If the reference count is zero, it will free the reference to this object. @param objectID: The object ID. r� r c S r� r< r5 r5 r5 r5 r6 r � r^ z%Broker.proto_decref.<locals>.<lambda>N) r� r� rT r� r� rl r r� r� �pop)rA r# �refsr r5 r5 r6 � proto_decref� s �zBroker.proto_decrefc C rE )z_ (internal) Send a DECACHE directive. @param objectID: The object ID. s decacheNr= rF r5 r5 r6 � decCacheRef� rG zBroker.decCacheRefc C s� | j | �� }|dkrD| j | }|j}|j}z |�|t| ||�� W n ty/ t�� Y nw |� � }| j |= | j |= | � d|� dS dS )z� (internal) Decrement the reference count of a cached object. If the reference count is zero, free the reference, then send an 'uncached' directive. @param objectID: The object ID. r s uncacheN) r� r� rl rR r� r r� r r� r r� r� )rA r# rI r� r� rR r r5 r5 r6 � proto_decache� s" � ��zBroker.proto_decachec C s | j | }d|_| j |= dS )zx (internal) Tell the client it is now OK to uncache an object. @param objectID: The object ID. N)r� rP )rA r# rF r5 r5 r6 � proto_uncache� s zBroker.proto_uncache�r )NNNNr< )6r1 r2 r3 r4 r� �usernamer� r+ r> r� r� r� r� r� r� r� r� r� r� r� r� ru r� r� rz r r r r r r r r r r re ra r r rQ r. r0 r, r8 r@ r9 rB r7 rD r� rJ rK rL rM r5 r5 r5 r6 r� sf & ) *) B r� c C s> t � }|�|� |�� }t � }|�|� |�| � |�� }|S )z� Respond to a challenge. This is useful for challenge/response authentication. @param challenge: A challenge. @param password: A password. @return: The password hashed twice. )r �update�digest)� challenge�password�m�hashedPassword�doubleHashedPasswordr5 r5 r6 �respond� s rW c C s. t dd� tt�dd��D ��} t| ��� } | S )z% @return: Some random data. c s s � | ] }t �d d�V qdS )�A �Z N)�random�randint)�.0r r5 r5 r6 � <genexpr>� s � z challenge.<locals>.<genexpr>� � )r� r� rZ � randranger rQ )�crapr5 r5 r6 rR � s rR c @ s� e Zd ZdZeZdZdefdd�Zdd� Z dd� Z d d � Z d d � Z d dd�Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d d �Zd S )!�PBClientFactoryz� Client factory for PB brokers. As with all client factories, use with reactor.connectTCP/SSL/etc.. getPerspective and getRootObject can be called either before or after the connect. Fc C s || _ || _| �� dS )aE @param unsafeTracebacks: if set, tracebacks for exceptions will be sent over the wire. @type unsafeTracebacks: C{bool} @param security: security options used by the broker, default to C{globalSecurity}. @type security: L{twisted.spread.jelly.SecurityOptions} N)r� r� �_reset)rA r� r� r5 r5 r6 r> s zPBClientFactory.__init__c C s | j d| jd�}| |_|S )zP Build the broker instance, passing the security options to it. T�r� r� )r r� r� )rA �addr�pr5 r5 r6 � buildProtocol s z PBClientFactory.buildProtocolc C s g | _ d | _d | _d S r< )�rootObjectRequests�_broker�_rootrL r5 r5 r6 rc s zPBClientFactory._resetc C s& | j }| �� |D ]}|�|� q d S r< )rh rc r� )rA r� � deferredsr� r5 r5 r6 �_failAll s �zPBClientFactory._failAllc C s | � |� d S r< )rl )rA � connectorr� r5 r5 r6 �clientConnectionFailed% s z&PBClientFactory.clientConnectionFailedr c C s" |r d| _ d| _dS | �|� dS )zJ Reconnecting subclasses should call with reconnecting=1. N)ri rj rl )rA rm r� � reconnectingr5 r5 r6 �clientConnectionLost( s z$PBClientFactory.clientConnectionLostc C s8 || _ |�d�| _| j}g | _|D ]}|�| j� qd S )N�root)ri r rj rh rx )rA rP �dsr� r5 r5 r6 r� 4 s �z$PBClientFactory.clientConnectionMadec C s2 | j r | j js t�| j�S t�� }| j�|� |S )ze Get root object of remote PB server. @return: Deferred of the root object. )ri r� r �succeedrj r rh rs )rA r� r5 r5 r6 � getRootObject< s z PBClientFactory.getRootObjectc C s | j r | j j�� dS dS )z� If the factory is connected, close the connection. Note that if you set up the factory to reconnect, you will need to implement extra logic to prevent automatic reconnection after this is called. N)ri r� r rL r5 r5 r6 � disconnectH s �zPBClientFactory.disconnectc C s |� d|��| j||�S )N�login)r� � addCallback� _cbResponse)rA rq rO rS �clientr5 r5 r6 �_cbSendUsernameS s �z PBClientFactory._cbSendUsernamec C s |\}}|� dt||�|�S )NrW )r� rW )rA � challengesrS ry rR � challengerr5 r5 r6 rx X s zPBClientFactory._cbResponsec C s |� d|�S )ab Attempt an anonymous login on the given remote root object. @type root: L{RemoteReference} @param root: The object on which to attempt the login, most likely returned by a call to L{PBClientFactory.getRootObject}. @param client: A jellyable object which will be used as the I{mind} parameter for the login attempt. @rtype: L{Deferred} @return: A L{Deferred} which will be called back with a L{RemoteReference} to an avatar when anonymous login succeeds, or which will errback if anonymous login fails. �loginAnonymous)r� )rA rq ry r5 r5 r6 �_cbLoginAnonymous\ s z!PBClientFactory._cbLoginAnonymousNc C s> | � � }t�|�r|�| j|� |S |�| j|j|j|� |S )a� Login and get perspective from remote PB server. Currently the following credentials are supported:: L{twisted.cred.credentials.IUsernamePassword} L{twisted.cred.credentials.IAnonymous} @rtype: L{Deferred} @return: A L{Deferred} which will be called back with a L{RemoteReference} for the avatar logged in to, or which will errback if login fails. )rt r � providedByrw r~ rz rO rS )rA � credentialsry r� r5 r5 r6 rv n s ��zPBClientFactory.loginrN r< )r1 r2 r3 r4 r� r r� r+ r> rg rc rl rn rp r� rt ru rz rx r~ rv r5 r5 r5 r6 rb � s" rb c @ s6 e Zd ZdZdZeZdefdd�Zdd� Z dd� Z d S ) �PBServerFactorya� Server factory for perspective broker. Login is done using a Portal object, whose realm is expected to return avatars implementing IPerspective. The credential checkers in the portal should accept IUsernameHashedPassword or IUsernameMD5Password. Alternatively, any object providing or adaptable to L{IPBRoot} can be used instead of a portal to provide the root object of the PB server. Fc C s t |�| _|| _|| _dS )a� @param root: factory providing the root Referenceable used by the broker. @type root: object providing or adaptable to L{IPBRoot}. @param unsafeTracebacks: if set, tracebacks for exceptions will be sent over the wire. @type unsafeTracebacks: C{bool} @param security: security options used by the broker, default to C{globalSecurity}. @type security: L{twisted.spread.jelly.SecurityOptions} N)r rq r� r� )rA rq r� r� r5 r5 r6 r> � s zPBServerFactory.__init__c C s. | j d| jd�}| |_|�d| j�|�� |S )zT Return a Broker attached to the factory (as the service provider). Frd rq )r r� r� r rq � rootObject)rA re �protor5 r5 r6 rg � s z PBServerFactory.buildProtocolc C r� r< r5 )rA r r5 r5 r6 r� � r� z$PBServerFactory.clientConnectionMadeN) r1 r2 r3 r4 r� r� r r+ r> rg r� r5 r5 r5 r6 r� � s r� c @ � e Zd ZdZdd� Zdd� ZdS )�IUsernameMD5Passwordab I encapsulate a username and a hashed password. This credential is used for username/password over PB. CredentialCheckers which check this kind of credential must store the passwords in plaintext form or as a MD5 digest. @type username: C{str} or C{Deferred} @ivar username: The username associated with these credentials. c C rZ )a� Validate these credentials against the correct password. @type password: C{str} @param password: The correct, plaintext password against which to check. @rtype: C{bool} or L{Deferred} @return: C{True} if the credentials represented by this object match the given password, C{False} if they do not, or a L{Deferred} which will be called back with one of these values. Nr5 �rS r5 r5 r6 � checkPassword� r^ z"IUsernameMD5Password.checkPasswordc C rZ )a� Validate these credentials against the correct MD5 digest of the password. @type password: C{str} @param password: The correct MD5 digest of a password against which to check. @rtype: C{bool} or L{Deferred} @return: C{True} if the credentials represented by this object match the given digest, C{False} if they do not, or a L{Deferred} which will be called back with one of these values. Nr5 r� r5 r5 r6 �checkMD5Password� r^ z%IUsernameMD5Password.checkMD5PasswordN)r1 r2 r3 r4 r� r� r5 r5 r5 r6 r� � s r� c @ r� )� _PortalRootz/ Root object, used to login to portal. c C s || _ d S r< )�portal)rA r� r5 r5 r6 r> � s z_PortalRoot.__init__c C s t | j|�S r< )�_PortalWrapperr� )rA rP r5 r5 r6 r� � s z_PortalRoot.rootObjectN)r1 r2 r3 r4 r> r� r5 r5 r5 r6 r� � s r� c @ r: )�_JellyableAvatarMixinzk Helper class for code which deals with avatars which PB must be capable of sending to a peer. c sT |\}}� t �|�st|d�}|�� }� g� � fdd�}|| jj|< | j�|� |S )z� Ensure that the avatar to be returned to the client is jellyable and set up disconnection notification to call the realm's logout object. rR c s � sd S � d } � d= | � d S r� r5 )�fn��logoutr5 r6 � maybeLogout s z3_JellyableAvatarMixin._cbLogin.<locals>.maybeLogout)r( r rh r rP r� ru )rA �result� interface�avatarr r� r5 r� r6 �_cbLogin� s z _JellyableAvatarMixin._cbLoginN)r1 r2 r3 r4 r� r5 r5 r5 r6 r� � s r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r� z= Root Referenceable object, used to login to portal. c C s || _ || _d S r< )r� rP )rA r� rP r5 r5 r6 r> s z_PortalWrapper.__init__c C s t � }|t| j| j||�fS )z[ Start of username/password login. @param username: The username. )rR �_PortalAuthChallengerr� rP )rA rO �cr5 r5 r6 � remote_login s z_PortalWrapper.remote_loginc C s" | j �t� |t�}|�| j� |S )aU Attempt an anonymous login. @param mind: An object to use as the mind parameter to the portal login call (possibly None). @rtype: L{Deferred} @return: A Deferred which will be called back with an avatar when login succeeds or which will be errbacked if login fails somehow. )r� rv r rY rw r� )rA �mindr� r5 r5 r6 �remote_loginAnonymous& s z$_PortalWrapper.remote_loginAnonymousN)r1 r2 r3 r4 r> r� r� r5 r5 r5 r6 r� s r� c @ rD ) r� z5 Called with response to password challenge. c C s || _ || _|| _|| _d S r< )r� rP rO rR )rA r� rP rO rR r5 r5 r6 r> < s z _PortalAuthChallenger.__init__c C s& || _ | j�| |t�}|�| j� |S r< )�responser� rv rY rw r� )rA r� r� r� r5 r5 r6 �remote_respondB s z$_PortalAuthChallenger.remote_respondc C s | � t|��� �S )z� L{IUsernameHashedPassword} @param password: The password. @return: L{_PortalAuthChallenger.checkMD5Password} )r� r rQ )rA rS r5 r5 r6 r� H r> z#_PortalAuthChallenger.checkPasswordc C s. t � }|�|� |�| j� |�� }| j|kS )z� L{IUsernameMD5Password} @param md5Password: @rtype: L{bool} @return: L{True} if password matches. )r rP rR rQ r� )rA � md5Password�md�correctr5 r5 r6 r� Q s z&_PortalAuthChallenger.checkMD5PasswordN)r1 r2 r3 r4 r> r� r� r� r5 r5 r5 r6 r� 6 s r� )(r r r r r r r r r r r r r r! r& r% r' r" r$ r# r �portnor/ r8 r9 rX rE rY r` rh rn r� r� r� r� rW rR rb r� r� rN )\r4 rZ �hashlibr �zope.interfacer r �twisted.cred.credentialsr r r r �twisted.cred.portalr �twisted.internetr r �twisted.persistedr �twisted.pythonr r r �twisted.python.compatr r �twisted.python.componentsr �twisted.spreadr �twisted.spread.flavorsr r r r r r r r r r r r r r! r" r# r$ r% r& r' �twisted.spread.interfacesr( r) �twisted.spread.jellyr* r+ r, r- r r� r= r/ r8 r9 r; rE rX rY r` rh � Ephemeralrn r� r� r� r� r� r� r� rW rR � ClientFactoryrb � ServerFactoryr� r� r� r� r� r� �__all__r5 r5 r5 r6 �<module> st X )( $ + W 0* #" )PK Mb�Z��� � ' spread/__pycache__/util.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZmZ ddlmZ ddlm Z ddl m Z G dd� d�Z G d d � d �Z G d d � d �ZG d d� d�ZG dd� de�Zeej�G dd� de��ZG dd� de j�Zdd� ZdS )z Utility classes for spread. � )� implementer)�defer� interfaces)�basic)�Failure)�pbc @ s e Zd Zdd� Zdd� ZdS )� LocalMethodc C s || _ || _d S �N)�local�name)�selfr r � r �5/usr/lib/python3/dist-packages/twisted/spread/util.py�__init__ � zLocalMethod.__init__c O s | j j| jg|�R i |��S r )r � callRemoter )r �args�kwr r r �__call__ s zLocalMethod.__call__N)�__name__� __module__� __qualname__r r r r r r r s r c @ s$ e Zd ZdZdZdd� Zdd� ZdS )� LocalAsRemotezN A class useful for emulating the effects of remote behavior locally. � c O s| t | d| �rt| d| �|i |��S zt| d| �}t�||i |���W S ty= t� }| jr6|�� t�|� Y S w )ax Call a specially-designated local method. self.callRemote('x') will first try to invoke a method named sync_x and return its result (which should probably be a Deferred). Second, it will look for a method called async_x, which will be called and then have its result (or Failure) automatically wrapped in a Deferred. �sync_�async_) �hasattr�getattrr �succeed� BaseExceptionr �reportAllTracebacks�printTraceback�fail)r r r r �method�fr r r r # s �zLocalAsRemote.callRemotec C s t | |�S r )r )r r r r r � remoteMethod8 � zLocalAsRemote.remoteMethodN)r r r �__doc__r r r% r r r r r s r c @ s* e Zd ZdZd dd�Zdd� Zdd� Zd S ) �LocalAsyncForwarderzD A class useful for forwarding a locally-defined interface. r c C s$ |� |�sJ �|| _|| _|| _d S r )� providedBy� forwarded�interfaceClass�failWhenNotImplemented)r r* r+ r, r r r r A s z LocalAsyncForwarder.__init__c O s t | j|�|i |��S r )r r* )r r# r r r r r � _callMethodG s z LocalAsyncForwarder._callMethodc O sP | j �|�rtj| j|g|�R i |��}|S | jr#t�ttd| ��S t� d �S )Nz No Such Method in Interface: %s) r+ �queryDescriptionForr � maybeDeferredr- r, r" r �NotImplementedErrorr )r r# r r �resultr r r r J s � z LocalAsyncForwarder.callRemoteN)r )r r r r' r r- r r r r r r( < s r( c @ s: e Zd ZdZd dd�Zdd� Zdd� Zd d � Zd d � ZdS )�Pagerz5 I am an object which pages out information. Nc O s> t |�r|| _|| _|| _nd| _d| _|| _|j�| � dS )z� Create a pager with a Reference to a remote collector and an optional callable to invoke upon completion. Nr )�callable�callback� callbackArgs�callbackKeyword� _stillPaging� collector�broker�registerPageProducer)r r8 r4 r r r r r r [ s zPager.__init__c C s: | j s| jjddd� | jdur| j| ji | j�� | j S )�5 (internal) Method called by Broker. � endedPagingF��pbanswerN)r7 r8 r r4 r5 r6 �r r r r � stillPagingj s zPager.stillPagingc C s | j jd| �� dd� dS )r; �gotPageFr= N)r8 r �nextPager? r r r � sendNextPaget s zPager.sendNextPagec C s t � �)zO Override this to return an object to be sent to my collector. )r0 r? r r r rB z s zPager.nextPagec C s d| _ dS )z4 Call this when you're done paging. r N)r7 r? r r r � stopPaging� s zPager.stopPagingr ) r r r r' r r@ rC rB rD r r r r r2 V s r2 c @ s" e Zd ZdZddd�Zdd� ZdS ) � StringPagerz: A simple pager that splits a string into chunks. � Nc O s2 || _ d| _|| _tj| ||g|�R i |�� d S )Nr )�string�pointer� chunkSizer2 r )r r8 �strI r4 r r r r r r � s zStringPager.__init__c C sD | j | j| j| j � }| j| j7 _| jt| j �kr | �� |S r )rG rH rI �lenrD �r �valr r r rB � s zStringPager.nextPage)rF N)r r r r' r rB r r r r rE � s rE c @ sB e Zd ZdZddd�Zdd� Zdd� Zd d � Zd d � Zd d� Z dS )� FilePagerzC Reads a file in chunks and sends the chunks as they come. Nc O s0 g | _ tj| ||g|�R i |�� | �|� d S r )�chunksr2 r �startProducing)r r8 �fdr4 r r r r r r � s zFilePager.__init__c s* t �� �|� �� _� j�� fdd�� d S )Nc s � � � S r )rD )�xr? r r �<lambda>� s z*FilePager.startProducing.<locals>.<lambda>)r � FileSender�beginFileTransfer�deferred�addBoth)r rQ r r? r rP � s zFilePager.startProducingc C s || _ |s | j �� d S d S r )�producer�resumeProducing)r rX � streamingr r r �registerProducer� s �zFilePager.registerProducerc C s d | _ d S r )rX r? r r r �unregisterProducer� r& z FilePager.unregisterProducerc C � | j �|� d S r )rO �append)r �chunkr r r �write� � zFilePager.writec C s6 | j sdS | j �d�}| j�� | jjd|dd� dS )zD Get the first chunk read and send it to collector. Nr rA Fr= )rO �poprX rY r8 r rL r r r rC � s zFilePager.sendNextPager ) r r r r' r rP r[ r\ r` rC r r r r rN � s rN c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �CallbackPageCollectorz� I receive pages from the peer. You may instantiate a Pager with a remote reference to me. I will call the callback with a list of pages once they are all received. c C s g | _ || _d S r )�pagesr4 )r r4 r r r r � r z CallbackPageCollector.__init__c C r] r )rd r^ )r �pager r r �remote_gotPage� ra z$CallbackPageCollector.remote_gotPagec C s | � | j� d S r )r4 rd r? r r r �remote_endedPaging� ra z(CallbackPageCollector.remote_endedPagingN)r r r r' r rf rg r r r r rc � s rc c O s, t �� }| j|t|j�g|�R i |�� |S )zr A utility method that will call a remote method which expects a PageCollector as the first argument. )r �Deferredr rc r4 )� referenceable� methodNamer r �dr r r � getAllPages� s rl N)r' �zope.interfacer �twisted.internetr r �twisted.protocolsr �twisted.python.failurer �twisted.spreadr r r r( r2 rE � IConsumerrN � Referenceablerc rl r r r r �<module> s 1% PK Mb�ZN�U� � + spread/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )zO Twisted Spread: Spreadable (Distributed) Computing. @author: Glyph Lefkowitz N)�__doc__� r r �9/usr/lib/python3/dist-packages/twisted/spread/__init__.py�<module> s PK Mb�Z�i\- - * spread/__pycache__/publish.cpython-310.pycnu �[��� o �b, � @ sd d Z ddlZddlmZ ddlmZmZmZ G dd� dej�Z G dd� dej �Z d d � Z d d � Z dS ) z] Persistently cached objects for PB. Maintainer: Glyph Lefkowitz Future Plans: None known. � N)�defer)�banana�flavors�jellyc @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� Publishablez6An object whose cached state persists across sessions.c C s | � � || _d S )N)� republish� publishedID)�selfr � r �8/usr/lib/python3/dist-packages/twisted/spread/publish.py�__init__ s zPublishable.__init__c C s t � � | _dS )z=Set the timestamp to current and (TODO) update all observers.N)�time� timestamp�r r r r r � zPublishable.republishc C s | � |�S )� (internal))�getStateToPublishFor�r � perspectiver r r �view_getStateToPublish s z"Publishable.view_getStateToPublishc C s | � � S )z:Implement me to special-case your state for a perspective.)�getStateToPublishr r r r r # s z Publishable.getStateToPublishForc C s t d| j ��)zBImplement me to return state to copy as part of the publish phase.z%s.getStateToPublishFor)�NotImplementedError� __class__r r r r r ' r z Publishable.getStateToPublishc C s: |r |j }|�� j}nd}d}t�|| �| j||| jd�S )z6Get all necessary metadata to keep a clientside cache.�None)�remoter r �servicer )�perspectiveName� getService� serviceNamer � ViewPointr r )r r �observer�pname�snamer r r � getStateToCacheAndObserveFor+ s �z(Publishable.getStateToCacheAndObserveForN) �__name__� __module__� __qualname__�__doc__r r r r r r# r r r r r s r c @ sJ e Zd ZdZdZdZddd�Zdd� Zdd � Zd d � Z d d � Z dd� Z dS )�RemotePublishedz6The local representation of remote Publishable object.r �pubc C s d� | j| jt| j�|�S )Nz {}-{}-{}.{})�formatr r �strr )r �extr r r � getFileNameC s �zRemotePublished.getFileNamec C s� | j �|� g | _z t| �� d�� }|�� }W d � n1 s w Y W n ty1 d}Y nw t�t � |��}|j | j k}|rM| � |j � d| _ d S | j�d��| j � d S )N�rbr � r )�__dict__�update�_activationListeners�openr- �read�OSErrorr �unjellyr �decoder � _cbGotUpdate�_wasCleanWhenLoadedr � callRemote� addCallbacks)r �state�dataFile�data�recent�newselfr r r �setCopyableStateK s �� � z RemotePublished.setCopyableStatec C s, | j �� }|d= |d= |d= |d= |d= |S )N�brokerr �luidr2 � isActivated)r0 �copy)r �otherr r r � __getstate__\ s z RemotePublished.__getstate__c C s~ | j �|� d| _| jD ]}|| � q g | _| �� t| �� d��}|�t� t � | ��� W d � d S 1 s8w Y d S )Nr/ �wb) r0 r1 rD r2 � activatedr3 r- �writer �encoder )r �newState�listenerr= r r r r8 g s "�z RemotePublished._cbGotUpdatec C s dS )znImplement this method if you want to be notified when your publishable subclass is activated. Nr r r r r rI r s zRemotePublished.activatedc C s" | j r || � dS | j�|� dS )zZExternally register for notification when this publishable has received all relevant data.N)rD r2 �append)r �callbackr r r �callWhenActivatedw s z!RemotePublished.callWhenActivatedN)r) ) r$ r% r& r' rD r9 r- rA rG r8 rI rP r r r r r( = s r( c C s t �� }| jt|j|fd� |S )aD Wrap a deferred returned from a pb method in another deferred that expects a RemotePublished as a result. This will allow you to wait until the result is really available. Idiomatic usage would look like:: publish.whenReady(serverObject.getMeAPublishable()).addCallback(lookAtThePublishable) )� callbackArgs)r �Deferredr; � _pubReady�errback)�d�d2r r r � whenReady s rW c C s | � |j� dS )r N)rP rO )�resultrV r r r rS � s rS )r' r �twisted.internetr �twisted.spreadr r r � Cacheabler � RemoteCacher( rW rS r r r r �<module> s )B PK Mb�Z�k�h�[ �[ * spread/__pycache__/flavors.cpython-310.pycnu �[��� o �bf[ � @ s� d Z ddlZddlmZmZ ddlmZmZ ddlm Z m Z ddl m Z m Z mZmZmZmZmZmZmZ eZeZeZeZdZd Zd Zd Z G d d � d e �Z G dd� de�Z G dd� de �Z G dd� de �Z!ee �G dd� de!��Z"G dd� de!�Z#G dd� de �Z$G dd� de �Z%G d d � d e%�Z&G d d � d e �Z'G d d!� d!e'e �Z(d"d#� Z)ed$e)� d%d&� Z*ed'e*� d(d)� Z+ed*e+� e G d+d,� d,��Z,e G d-d.� d.��Z-dS )/a� This module represents flavors of remotely accessible objects. Currently this is only objects accessible through Perspective Broker, but will hopefully encompass all forms of remote access which can emulate subsets of PB (such as XMLRPC or SOAP). Future Plans: Optimization. Exploitation of new-style object model. Optimizations to this module should not affect external-use semantics at all, but may have a small impact on users who subclass and override methods. @author: Glyph Lefkowitz � N)� Interface� implementer)�log�reflect)�cmp� comparable� ) � Jellyable� Unjellyable� _createBlank�getInstanceState�setInstanceState� setUnjellyableFactoryForClass�setUnjellyableForClass�setUnjellyableForClassTree�unjellyableRegistrys copy� caches cached� remotec @ s e Zd ZdZdS )� NoSuchMethodz(Raised if there is no such remote methodN)�__name__� __module__� __qualname__�__doc__� r r �8/usr/lib/python3/dist-packages/twisted/spread/flavors.pyr 7 s r c @ � e Zd ZdZdd� ZdS )�IPBRootz6Factory for root Referenceable objects for PB servers.c C � dS )z%Return root Referenceable for broker.Nr )�brokerr r r � rootObject> � zIPBRoot.rootObjectN�r r r r r r r r r r ; s r c @ r )� Serializableax An object that can be passed remotely. I am a style of object which can be serialized by Perspective Broker. Objects which wish to be referenceable or copied remotely have to subclass Serializable. However, clients of Perspective Broker will probably not want to directly subclass Serializable; the Flavors of transferable objects are listed below. What it means to be "Serializable" is that an object can be passed to or returned from a remote method. Certain basic types (dictionaries, lists, tuples, numbers, strings) are serializable by default; however, classes need to choose a specific serialization style: L{Referenceable}, L{Viewable}, L{Copyable} or L{Cacheable}. You may also pass C{[lists, dictionaries, tuples]} of L{Serializable} instances to or return them from remote methods, as many levels deep as you like. c C s t | �S )z�Return an ID which uniquely represents this object for this process. By default, this uses the 'id' builtin, but can be overridden to indicate that two values are identity-equivalent (such as proxies for the same object). )�id��selfr r r �processUniqueIDV s z Serializable.processUniqueIDN)r r r r r& r r r r r" B s r" c @ s" e Zd ZdZ dd� Zdd� ZdS )� ReferenceableNc C s� |� |�}|� |�}dd� |�� D �r dd� |�� D �}t|t�s&|�d�}t| d| d�}|du r9td|� ���z ||i |��}W n tyW t � |� d |� d |� �� � w |� || j �S ) z�A remote message has been received. Dispatch it appropriately. The default implementation is to dispatch to a method called 'remote_messagename' and call it with the same arguments. c S s g | ] }t |t�r|�qS r )� isinstance�bytes)�.0�keyr r r � <listcomp>y s z7Referenceable.remoteMessageReceived.<locals>.<listcomp>c S s i | ] \}}|� d �|�qS ��utf8)�decode)r* �k�vr r r � <dictcomp>z s z7Referenceable.remoteMessageReceived.<locals>.<dictcomp>r. z remote_%sNzNo such method: remote_� didn't accept � and ) � unserialize�keys�itemsr( �strr/ �getattrr � TypeErrorr �msg� serialize� perspective�r% r �message�args�kw�method�stater r r �remoteMessageReceivedn s �z#Referenceable.remoteMessageReceivedc C s d|j �| �gS )zw(internal) Return a tuple which will be used as the s-expression to serialize this to a peer. r )�invoker�registerReference�r% �jellierr r r �jellyFor� s zReferenceable.jellyFor)r r r r= rD rI r r r r r' a s r' c @ r )�Roota I provide a root object to L{pb.Broker}s for a L{pb.PBClientFactory} or L{pb.PBServerFactory}. When a factory produces a L{pb.Broker}, it supplies that L{pb.Broker} with an object named "root". That object is obtained by calling my rootObject method. c C s | S )z�A factory is requesting to publish me as a root object. When a factory is sending me as the root object, this method will be invoked to allow per-broker versions of an object. By default I return myself. r )r% r r r r r � s zRoot.rootObjectNr! r r r r rJ � s rJ c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) � ViewPointaF I act as an indirect reference to an object accessed through a L{pb.IPerspective}. Simply put, I combine an object with a perspective so that when a peer calls methods on the object I refer to, the method will be invoked with that perspective as a first argument, so that it can know who is calling it. While L{Viewable} objects will be converted to ViewPoints by default when they are returned from or sent as arguments to a remote method, any object may be manually proxied as well. (XXX: Now that this class is no longer named C{Proxy}, this is the only occurrence of the term 'proxied' in this docstring, and may be unclear.) This can be useful when dealing with L{pb.IPerspective}s, L{Copyable}s, and L{Cacheable}s. It is legal to implement a method as such on a perspective:: | def perspective_getViewPointForOther(self, name): | defr = self.service.getPerspectiveRequest(name) | defr.addCallbacks(lambda x, self=self: ViewPoint(self, x), log.msg) | return defr This will allow you to have references to Perspective objects in two different ways. One is through the initial 'attach' call -- each peer will have a L{pb.RemoteReference} to their perspective directly. The other is through this method; each peer can get a L{pb.RemoteReference} to all other perspectives in the service; but that L{pb.RemoteReference} will be to a L{ViewPoint}, not directly to the object. The practical offshoot of this is that you can implement 2 varieties of remotely callable methods on this Perspective; view_xxx and C{perspective_xxx}. C{view_xxx} methods will follow the rules for ViewPoint methods (see ViewPoint.L{remoteMessageReceived}), and C{perspective_xxx} methods will follow the rules for Perspective methods. c C s || _ || _dS )z/Initialize me with a Perspective and an Object.N)r= �object)r% r= rM r r r �__init__� s zViewPoint.__init__c C s t | j�t | j�fS )zGReturn an ID unique to a proxy for this perspective+object combination.)r# r= rM r$ r r r r& � � zViewPoint.processUniqueIDc C s� |� || j�}|� || j�}t|t�s|�d�}t| jd| �}z || jf| i |��}W n tyB t� |� d|� d|� �� � w |� || j|||�}|S )a7 A remote message has been received. Dispatch it appropriately. The default implementation is to dispatch to a method called 'C{view_messagename}' to my Object and call it on my object with the same arguments, modified by inserting my Perspective as the first argument. r. zview_%sr3 r4 ) r5 r= r( r8 r/ r9 rM r: r r; r< )r% r r? r@ rA rB rC �rvr r r rD � s �z ViewPoint.remoteMessageReceivedN)r r r r rN r& rD r r r r rL � s ' rL c @ r )�ViewableaB I will be converted to a L{ViewPoint} when passed to or returned from a remote method. The beginning of a peer's interaction with a PB Service is always through a perspective. However, if a C{perspective_xxx} method returns a Viewable, it will be serialized to the peer as a response to that method. c C s t |jj| ��|�S )zHSerialize a L{ViewPoint} for me and the perspective of the given broker.)rL rE �serializingPerspectiverI rG r r r rI � rO zViewable.jellyForN)r r r r rI r r r r rQ � s rQ c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �Copyablea� Subclass me to get copied each time you are returned from or passed to a remote method. When I am returned from or passed to a remote method call, I will be converted into data via a set of callbacks (see my methods for more info). That data will then be serialized using Jelly, and sent to the peer. The peer will then look up the type to represent this with; see L{RemoteCopy} for details. c C s | j S )z�Gather state to send when I am serialized for a peer. I will default to returning self.__dict__. Override this to customize this behavior. )�__dict__r$ r r r �getStateToCopy s zCopyable.getStateToCopyc C � | � � S )z� Gather state to send when I am serialized for a particular perspective. I will default to calling L{getStateToCopy}. Override this to customize this behavior. )rU �r% r= r r r �getStateToCopyFor s zCopyable.getStateToCopyForc C s t �| j��d�S )z�Determine what type tag to send for me. By default, send the string representation of my class (package.module.Class); normally this is adequate, but you may override this to change it. �utf-8)r �qual� __class__�encoder$ r r r � getTypeToCopy s zCopyable.getTypeToCopyc C rV )z�Determine what type tag to send for me. By default, defer to self.L{getTypeToCopy}() normally this is adequate, but you may override this to change it. )r] rW r r r �getTypeToCopyFor( s zCopyable.getTypeToCopyForc C sZ |j du r t| |�S |j j}| �|�}| �|�}|�| �}|�||�|�g� |�| |�S )z�Assemble type tag and state to copy for this broker. This will call L{getTypeToCopyFor} and L{getStateToCopy}, and return an appropriate s-expression to represent me. N) rE r rR r^ rX �prepare�extend�jelly�preserve)r% rH �p�trC �sxpr r r rI 1 s zCopyable.jellyForN) r r r r rU rX r] r^ rI r r r r rS � s rS c @ rK ) � Cacheablea� A cached instance. This means that it's copied; but there is some logic to make sure that it's only copied once. Additionally, when state is retrieved, it is passed a "proto-reference" to the state as it will exist on the client. XXX: The documentation for this class needs work, but it's the most complex part of PB and it is inherently difficult to explain. c C s | � |�S )a- Get state to cache on the client and client-cache reference to observe locally. This is similar to getStateToCopyFor, but it additionally passes in a reference to the client-side RemoteCache instance that will be created when it is unserialized. This allows Cacheable instances to keep their RemoteCaches up to date when they change, such that no changes can occur between the point at which the state is initially copied and the client receives it that are not propagated. )rX �r% r= �observerr r r � getStateToCacheAndObserveForN s z&Cacheable.getStateToCacheAndObserveForc C s� |j du r t| |�S |j �| d�}|du rI|j �| �}|j j}| �|�}t|j | |�}| �||�}|�| �}|� |�}|� |||g� |� | |�S t |fS )z�Return an appropriate tuple to serialize me. Depending on whether this broker has cached me or not, this may return either a full state or a reference to an existing cache. Nr ) rE r �cachedRemotelyAs� cacheRemotelyrR r^ �RemoteCacheObserverri r_ ra r` rb � cached_atom) r% rH �luidrc �type_rh rC �l�jstater r r rI ^ s zCacheable.jellyForc C r )z�This method is called when a client has stopped observing me. The 'observer' argument is the same as that passed in to getStateToCacheAndObserveFor. Nr rg r r r �stoppedObservingt r zCacheable.stoppedObservingN)r r r r ri rI rr r r r r rf B s rf c @ s e Zd ZdZdd� Zdd� ZdS )� RemoteCopya I am a remote copy of a Copyable object. When the state from a L{Copyable} object is received, an instance will be created based on the copy tags table (see setUnjellyableForClass) and sent the L{setCopyableState} message. I provide a reasonable default implementation of that message; subclass me if you wish to serve as a copier for remote data. NOTE: copiers are invoked with no arguments. Do not implement a constructor which requires args in a subclass of L{RemoteCopy}! c C s dd� |� � D �}|| _dS )a( I will be invoked with the state to copy locally. 'state' is the data returned from the remote object's 'getStateToCopyFor' method, which will often be the remote object's dictionary (or a filtered approximation of it depending on my peer's perspective). c S s* i | ]\}}t |t�r|�d �n||�qS r- )r( r) r/ )r* �x�yr r r r2 � s �z/RemoteCopy.setCopyableState.<locals>.<dictcomp>N)r7 rT )r% rC r r r �setCopyableState� s � zRemoteCopy.setCopyableStatec C s. |j d u r t| ||�S | �|�|d �� | S �Nr )rE r rv �unjelly)r% � unjellier� jellyListr r r � unjellyFor� s zRemoteCopy.unjellyForN)r r r r rv r{ r r r r rs | s rs c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd Z d Z d d� Z dd� Z d S )� RemoteCachea� A cache is a local representation of a remote L{Cacheable} object. This represents the last known state of this object. It may also have methods invoked on it -- in order to update caches, the cached class generates a L{pb.RemoteReference} to this object as it is originally sent. Much like copy, I will be invoked with no arguments. Do not implement a constructor that requires arguments in one of my subclasses. c C s� t |t�s |�d�}|�|�}|�|�}t| d| �}z ||i |��}W n ty9 t�|� d|� d|� �� � w |�|d|||�S )z�A remote message has been received. Dispatch it appropriately. The default implementation is to dispatch to a method called 'C{observe_messagename}' and call it on my with the same arguments. r. z observe_%sr3 r4 N) r( r8 r/ r5 r9 r: r r; r< r> r r r rD � s �z!RemoteCache.remoteMessageReceivedc C s2 |j du r t| |�S |j | ju sJ d��d| jfS )zKserialize me (only for the broker I'm for) as the original cached referenceNz3You cannot exchange cached proxies between brokers.s lcache)rE r r rn rG r r r rI � s � zRemoteCache.jellyForc C s� |j d u r t| ||�S |j | _|d | _| �� }t|dd �}|r#|� |j �|d | � |�|�|d �� |j | _ |j | _|d | _|S )Nr rN � ) rE r r rn �_borgifyr9 � cacheLocallyrv rx rT )r% ry rz �borgCopy�initr r r r{ � s zRemoteCache.unjellyForc C s2 t || j�rtt| j�t|j��S tt| j�|�S )z#Compare me [to another RemoteCache.)r( r[ r r# rT �r% �otherr r r �__cmp__� s zRemoteCache.__cmp__c C s t t| j�tj �S )zHash me.)�intr# rT �sys�maxsizer$ r r r �__hash__� rO zRemoteCache.__hash__Nc C s> z| j r| j �| j� W dS W dS ty t�� Y dS w )z.Do distributed reference counting on finalize.N)r � decCacheRefrn � BaseExceptionr �deferrr$ r r r �__del__� s � �zRemoteCache.__del__c C s t | j�}| j|_|S )a� Create a new object that shares its state (i.e. its C{__dict__}) and type with this object, but does not share its identity. This is an instance of U{the Borg design pattern <https://code.activestate.com/recipes/66531/>} originally described by Alex Martelli, but unlike the example given there, this is not a replacement for a Singleton. Instead, it is for lifecycle tracking (and distributed garbage collection). The purpose of these separate objects is to have a separate object tracking each application-level reference to the root L{RemoteCache} object being tracked by the broker, and to have their C{__del__} methods be invoked. This may be achievable via a weak value dictionary to track the root L{RemoteCache} instances instead, but this implementation strategy predates the availability of weak references in Python. @return: The new instance. @rtype: C{self.__class__} )r r[ rT )r% �blankr r r r~ � s zRemoteCache._borgify) r r r r rD rI r{ r� r� r rn r� r~ r r r r r| � s r| c C s |d }| j �|��� S rw )rE �cachedLocallyAsr~ )ry � unjellyListrn r r r � unjellyCached s r� �cachedc C s |d }| j �|�}|S rw )rE �remotelyCachedForLUID)ry r� rn �objr r r � unjellyLCache s r� �lcachec C s | j �|d �}|S rw )rE �localObjectForID)ry r� r� r r r � unjellyLocal! s r� �localc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �RemoteCacheMethodz,A method on a reference to a L{RemoteCache}.c C s || _ || _|| _|| _dS )z(internal) initialize.N)�namer r= r� )r% r� r r� r= r r r rN - s zRemoteCacheMethod.__init__c C s t | j| j| j| jf|�S �N)r r� r r= r� r� r r r r� 4 s zRemoteCacheMethod.__cmp__c C s t | j| j| j| jf�S r� )�hashr� r r= r� r$ r r r r� 7 s zRemoteCacheMethod.__hash__c O sD | j �| j�}|du rddlm} |d��| j �d| j|| j||�S )�(internal) action method.Nr �� ProtocolError�QYou can't call a cached method when the object hasn't been given to the peer yet.r )r rj r� �pbr� � _sendMessager= r� )r% r@ rA �cacheIDr� r r r �__call__: s ��zRemoteCacheMethod.__call__N)r r r r rN r� r� r� r r r r r� ) s r� c @ sF e Zd ZdZdd� Zdefdd�Zdd� Zd d � Zd d � Z d d� Z dS )rl a6 I am a reverse-reference to the peer's L{RemoteCache}. I am generated automatically when a cache is serialized. I represent a reference to the client's L{RemoteCache} object that will represent a particular L{Cacheable}; I am the additional object passed to getStateToCacheAndObserveFor. c C s || _ || _|| _dS )a (internal) Initialize me. @param broker: a L{pb.Broker} instance. @param cached: a L{Cacheable} instance that this L{RemoteCacheObserver} corresponds to. @param perspective: a reference to the perspective who is observing this. N)r r� r= )r% r r� r= r r r rN R s z RemoteCacheObserver.__init__�returnc C s d� | j| j| jt| ��S )Nz'<RemoteCacheObserver({}, {}, {}) at {}>)�formatr r� r= r# r$ r r r �__repr__a s �z RemoteCacheObserver.__repr__c C s* t | j�d t | j�d t | j�d S )z`Generate a hash unique to all L{RemoteCacheObserver}s for this broker/perspective/cached tripleti )r� r r= r� r$ r r r r� i s � ��z RemoteCacheObserver.__hash__c C s t | j| j| jf|�S )z-Compare me to another L{RemoteCacheObserver}.)r r r= r� r� r r r r� r s zRemoteCacheObserver.__cmp__c O sV | j �| j�}t|t�r|�d�}|du r ddlm} |d��| j �d| j ||||�S )r� rY Nr r� r� r ) r rj r� r( r8 r\ r� r� r� r= )r% �_namer@ rA r� r� r r r � callRemotew s ��z RemoteCacheObserver.callRemotec C s t || j| j| j�S )z&Get a L{pb.RemoteMethod} for this key.)r� r r� r= )r% r+ r r r � remoteMethod� rO z RemoteCacheObserver.remoteMethodN) r r r r rN r8 r� r� r� r� r� r r r r rl H s rl ).r r� �zope.interfacer r �twisted.pythonr r �twisted.python.compatr r ra r r r r r r r r r �setCopierForClass�setCopierForClassTree�setFactoryForClass�copyTags� copy_atom� cache_atomrm � remote_atom�AttributeErrorr r r" r' rJ rL rQ rS rf rs r| r� r� r� r� rl r r r r �<module> sH , 2ID:!s PK Mb�Z �]*n} n} ( spread/__pycache__/jelly.cpython-310.pycnu �[��� o �bY� � @ s d Z ddlZddlZddlZddlZddlZddlmZ ddlm Z ddl m Z ddl m Z mZmZmZmZmZ ddlmZ ddlmZ dd lmZmZmZ dd lm Z m Z e fZ d Z d Z!d Z"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*dZ+dZ,ee dddd�ddd � d Z-i a.i a/d d � Z0d d!� Z1d"d#� Z2d$d%� Z3d&d'� Z4dBd(d)�Z5d*d+� Z6d,d-� Z7G d.d/� d/�Z8e e �G d0d1� d1��Z9e e �G d2d3� d3��Z:G d4d5� d5�Z;G d6d7� d7�Z<G d8d9� d9e=�Z>G d:d;� d;�Z?G d<d=� d=�Z@e@� ZAeA�B� e?� ddfd>d?�ZCe?� ddfd@dA�ZDdS )CaM S-expression-based persistence of python objects. It does something very much like L{Pickle<pickle>}; however, pickle's main goal seems to be efficiency (both in space and time); jelly's main goals are security, human readability, and portability to other environments. This is how Jelly converts various objects to s-expressions. Boolean:: True --> ['boolean', 'true'] Integer:: 1 --> 1 List:: [1, 2] --> ['list', 1, 2] String:: "hello" --> "hello" Float:: 2.3 --> 2.3 Dictionary:: {'a': 1, 'b': 'c'} --> ['dictionary', ['b', 'c'], ['a', 1]] Module:: UserString --> ['module', 'UserString'] Class:: UserString.UserString --> ['class', ['module', 'UserString'], 'UserString'] Function:: string.join --> ['function', 'join', ['module', 'string']] Instance: s is an instance of UserString.UserString, with a __dict__ {'data': 'hello'}:: ["UserString.UserString", ['dictionary', ['data', 'hello']]] Class Method: UserString.UserString.center:: ['method', 'center', ['None'], ['class', ['module', 'UserString'], 'UserString']] Instance Method: s.center, where s is an instance of UserString.UserString:: ['method', 'center', ['instance', ['reference', 1, ['class', ['module', 'UserString'], 'UserString']], ['dictionary', ['data', 'd']]], ['dereference', 1]] The Python 2.x C{sets.Set} and C{sets.ImmutableSet} classes are serialized to the same thing as the builtin C{set} and C{frozenset} classes. (This is only relevant if you are communicating with a version of jelly running on an older version of Python.) @author: Glyph Lefkowitz � N)�reduce)� implementer)�Version)�NotKnown� _Container� _Dereference�_DictKeyAndValue�_InstanceMethod�_Tuple)� nativeString)�deprecatedModuleAttribute)�namedAny� namedObject�qual)� IJellyable� IUnjellyable� None� class� module� functions dereferences persistents references dictionarys list� sets tuples instance� frozenset�Twisted� z'instance_atom is unused within Twisted.ztwisted.spread.jelly� instance_atoms unpersistablec C s t | t�r | �| �S dS )a� Given an object, if that object is a type, return a new, blank instance of that type which has not had C{__init__} called on it. If the object is not a type, return L{None}. @param cls: The type (or class) to create an instance of. @type cls: L{type} or something else that cannot be instantiated. @return: a new blank instance or L{None} if C{cls} is not a class or type. N)� isinstance�type�__new__)�cls� r �6/usr/lib/python3/dist-packages/twisted/spread/jelly.py� _createBlank� s �r! c s, t | �� � fdd�}t� d|�}||� � S )z� Make a new instance of a class without calling its __init__ method. @param state: A C{dict} used to update C{inst.__dict__} either directly or via C{__setstate__}, if available. @return: A new instance of C{cls}. c s | � _ d S �N��__dict__)�state��instancer r � defaultSetter� � z#_newInstance.<locals>.defaultSetter� __setstate__)r! �getattr)r r% r( �setterr r& r � _newInstance� s r- c C s. t | t�}|r t| �} t | t�s| �d�} | S )N�utf-8)r r r �bytes�encode)� classnamep�isObjectr r r � _maybeClass� s r3 c C � t | �} |t| < t�| � dS )at Set which local class will represent a remote type. If you have written a Copyable class that you expect your client to be receiving, write a local "copy" class to represent it, then call:: jellier.setUnjellyableForClass('module.package.Class', MyCopier). Call this at the module level immediately after its class definition. MyCopier should be a subclass of RemoteCopy. The classname may be a special tag returned by 'Copyable.getTypeToCopyFor' rather than an actual classname. This call is also for cached classes, since there will be no overlap. The rules are the same. N)r3 �unjellyableRegistry�globalSecurity� allowTypes)� classname� unjellyabler r r �setUnjellyableForClass� s r: c C r4 )a� Set the factory to construct a remote instance of a type:: jellier.setUnjellyableFactoryForClass('module.package.Class', MyFactory) Call this at the module level immediately after its class definition. C{copyFactory} should return an instance or subclass of L{RemoteCopy<pb.RemoteCopy>}. Similar to L{setUnjellyableForClass} except it uses a factory instead of creating an instance. N)r3 �unjellyableFactoryRegistryr6 r7 )r8 � copyFactoryr r r � setUnjellyableFactoryForClass� s r= c C sn |du r| j }|r d| }t| �D ]#}t| |�}zt||�}W n ty( Y qw |r4t|� |� �|� qdS )a� Set all classes in a module derived from C{baseClass} as copiers for a corresponding remote class. When you have a hierarchy of Copyable (or Cacheable) classes on one side, and a mirror structure of Copied (or RemoteCache) classes on the other, use this to setUnjellyableForClass all your Copieds for the Copyables. Each copyTag (the "classname" argument to getTypeToCopyFor, and what the Copyable's getTypeToCopyFor returns) is formed from adding a prefix to the Copied's class name. The prefix defaults to module.__name__. If you wish the copy tag to consist of solely the classname, pass the empty string ''. @param module: a module object from which to pull the Copied classes. (passing sys.modules[__name__] might be useful) @param baseClass: the base class from which all your Copied classes derive. @param prefix: the string prefixed to classnames to form the unjellyableRegistry. Nz%s.)�__name__�dirr+ � issubclass� TypeErrorr: )�module� baseClass�prefix�name�loaded�yesr r r �setUnjellyableForClassTree� s ���rH c C sP t | d�r | �� }n| j}|�| �}|�t| j��d�|�|�g� |� | |�S )zM Utility method to default to 'normal' state rules in serialization. � __getstate__r. ) �hasattrrI r$ �prepare�extendr � __class__r0 �jelly�preserve)�inst�jellierr% �sxpr r r �getInstanceState s rS c C s0 |� |d �}t| d�r| �|� | S || _| S )zO Utility method to default to 'normal' state rules in unserialization. � r* )�unjellyrJ r* r$ )rP � unjellier� jellyListr% r r r �setInstanceState s �rX c @ s& e Zd ZdZdd� Zdefdd�ZdS )� Unpersistablezd This is an instance of a class that comes back when something couldn't be unpersisted. c C s || _ dS )zY Initialize an unpersistable object with a descriptive C{reason} string. N)�reason)�selfrZ r r r �__init__% s zUnpersistable.__init__�returnc C s dt | j� S )NzUnpersistable(%s))�reprrZ �r[ r r r �__repr__+ � zUnpersistable.__repr__N)r> � __module__� __qualname__�__doc__r\ �strr` r r r r rY s rY c @ � e Zd ZdZdd� Zdd� ZdS )� Jellyablezc Inherit from me to Jelly yourself directly with the `getStateFor' convenience method. c C s | j S r" r# )r[ rQ r r r � getStateFor6 s zJellyable.getStateForc C s< |� | �}|�t| j��d�|�| �|��g� |�| |�S )zH @see: L{twisted.spread.interfaces.IJellyable.jellyFor} r. )rK rL r rM r0 rN rh rO )r[ rQ rR r r r �jellyFor9 s �� zJellyable.jellyForN)r> rb rc rd rh ri r r r r rg / � rg c @ rf )� Unjellyablezf Inherit from me to Unjelly yourself directly with the C{setStateFor} convenience method. c C s || _ d S r" r# )r[ rV r% r r r � setStateForN r) zUnjellyable.setStateForc C s |� |d �}| �||� | S )z� Perform the inverse operation of L{Jellyable.jellyFor}. @see: L{twisted.spread.interfaces.IUnjellyable.unjellyFor} rT )rU rl )r[ rV rW r% r r r � unjellyForQ s zUnjellyable.unjellyForN)r> rb rc rd rl rm r r r r rk G rj rk c @ sZ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z ddd�Z dS )�_JellierzC (Internal) This class manages state for a call to jelly() c C s. || _ i | _i | _i | _d| _|| _|| _dS )z Initialize. rT N)�taster� preserved�cooked�cooker�_ref_id�persistentStore�invoker)r[ ro rt ru r r r r\ a s z_Jellier.__init__c C sR | j t|� }t�|�}| j}| jd | _t||g|dd�< t|g| jt|�< |S )a� (internal) Backreference an object. Notes on this method for the hapless future maintainer: If I've already gone through the prepare/preserve cycle on the specified object (it is being referenced after the serializer is "done with" it, e.g. this reference is NOT circular), the copy-in-place of aList is relevant, since the list being modified is the actual, pre-existing jelly expression that was returned for that object. If not, it's technically superfluous, since the value in self.preserved didn't need to be set, but the invariant that self.preserved[id(object)] is a list is convenient because that means we don't have to test and create it or not create it here, creating fewer code-paths. that's why self.preserved is always set to a list. Sorry that this code is so hard to follow, but Python objects are tricky to persist correctly. -glyph rT N)rp �id�copyrs �reference_atom�dereference_atomrq )r[ �object�aList�newList�refidr r r �_cookp s z_Jellier._cookc C s g | j t|�< || jt|�< g S )a] (internal) Create a list for persisting an object to. This will allow backreferences to be made internal to the object. (circular references). The reason this needs to happen is that we don't generate an ID for every object, so we won't necessarily know which ID the object will have in the future. When it is 'cooked' ( see _cook ), it will be assigned an ID, and the temporary placeholder list created here will be modified in-place to create an expression that gives this object an ID: [reference id# [object-jelly]]. )rp rv rr )r[ rz r r r rK � s z_Jellier.preparec C sD t |�| jv r|| jt |� d< | jt |� }|S || jt |�< |S )zQ (internal) Mark an object's persistent list for later referral. � )rv rq rp )r[ rz �sexpr r r rO � s �z_Jellier.preservec C s> t |�}|| jv r| j| S || jv r | �|� | j| S d S r" )rv rq rp r~ )r[ �obj�objIdr r r � _checkMutable� s �z_Jellier._checkMutablec C s� t |t�r| �|�}|r|S |�| �S t|�}| j�t|��d���r�|t t t fv r,|S t |t j �rH|j}|j}|j}d|j| �|�| �|�gS |tu rSd|�d�gS t |td ��r]dgS t |t j�rmd|jd |j gS t |t j�rxd|jgS |tu r�d |r�d p�d gS |tju r�|jr�td ��d d� dd� |j |j |j |j |j!|j"|j#fD ���d�gS |tj$u r�|jr�td ��dd� dd� |j |j!|j"|j#fD ���d�gS |tj%u r�dd� dd� |j |j |j fD ���d�gS |tj&u �rdd� dd� |j'|j(|j)fD ���d�gS t*|t��rdt|��d�gS |t+j,u �r | �-|�S | �|�}|�r)|S | �.|�}|t/u �r=|�0| �1t2|�� n�|t3u �rL|�0| �1t4|�� n�|t5v �rn|�6t7� |�8� D ]\}} |�6| �|�| �| �g� �qZnq|t9u �r}|�0| �1t:|�� nb|t;u �r�|�0| �1t<|�� nSt|j��d�} d } | j=�r�| �=|| �} | d u�r�|�6t>� |�6| � n/| j�?|j��r�|�6| � t@|d��r�|�A� } n|jB} |�6| �| �� n | �Cdt|j� |� | �D||�S tEd|� d|� ���)Nr. s method� unicode�UTF-8r r �.r � boolean� true� falsez2Currently can't jelly datetime objects with tzinfo� datetime� c S � g | ]}t |��qS r �re ��.0�xr r r � <listcomp>� � ��z"_Jellier.jelly.<locals>.<listcomp>� timec S r� r r� r� r r r r� � r� � datec S r� r r� r� r r r r� � � timedeltac S r� r r� r� r r r r� r� r rI z$instance of class %s deemed insecurez Type not allowed for object: )Fr rg r� ri r ro � isTypeAllowedr r0 r/ �int�float�types� MethodType�__self__�__func__rM r> rN re � FunctionTyperb rc � ModuleType�bool�datetime�tzinfo�NotImplementedError�join�year�month�day�hour�minute�second� microsecond�time�date� timedelta�days�seconds� microsecondsr@ �decimal�Decimal� jelly_decimalrK �listrL �_jellyIterable� list_atom�tuple� tuple_atom� DictTypes�append�dictionary_atom�items�set�set_atom� frozenset�frozenset_atomrt �persistent_atom�isClassAllowedrJ rI r$ � unpersistablerO � InsecureJelly) r[ r� �preRef�objType�aSelf�aFunc�aClassrR �key�val� className� persistentr% r r r rN � s� � ���� � ���� �� �� � �� z_Jellier.jellyc c s" � |V |D ]}| � |�V qdS )a Jelly an iterable object. @param atom: the identifier atom of the object. @type atom: C{str} @param obj: any iterable object. @type obj: C{iterable} @return: a generator of jellied data. @rtype: C{generator} N)rN )r[ �atomr� �itemr r r r� < s � �z_Jellier._jellyIterablec C s0 |� � \}}}tdd� |�}|r| }d||gS )z� Jelly a decimal object. @param d: a decimal object to serialize. @type d: C{decimal.Decimal} @return: jelly for the decimal object. @rtype: C{list} c S s | d | S )N� r )�left�rightr r r �<lambda>X s z(_Jellier.jelly_decimal.<locals>.<lambda>� decimal)�as_tupler )r[ �d�sign�guts�exponent�valuer r r r� M s z_Jellier.jelly_decimalNc C s8 |du rg }|� t� t|t�r|�d�}|� |� |S )z� (internal) Returns an sexp: (unpersistable "reason"). Utility method for making note that a particular object could not be serialized. Nr. )r� �unpersistable_atomr re r0 )r[ rZ rR r r r r� ] s z_Jellier.unpersistabler" ) r> rb rc rd r\ r~ rK rO r� rN r� r� r� r r r r rn \ s rn c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Z d5d6� Z d7d8� Z d9d:� Z d;S )<� _Unjellierc C s" || _ || _i | _g | _|| _d S r" )ro �persistentLoad� references� postCallbacksru )r[ ro r� ru r r r r\ l s z_Unjellier.__init__c C s | � |�}| jD ]}|� q|S r" )rU r� )r[ r� �o�mr r r � unjellyFulls s z_Unjellier.unjellyFullc C s t |d�r | j�|j� |S )z� If the given object has support for the C{postUnjelly} hook, set it up to be called at the end of deserialization. @param unjellied: an object that has already been unjellied. @return: C{unjellied} � postUnjelly)rJ r� r� r� )r[ � unjelliedr r r �_maybePostUnjellyy s z _Unjellier._maybePostUnjellyc C s& t |�tur|S |d }| j�|�st|��t�|�}|d ur/tt|�d|�}| � || |��S t �|�}|d urD| � || � |d ���S t |�}t| d| d �}|d ur\||dd � �S |� d�}d�|d d� �} | j�| �s{td| � d|� d ���t|�} | j�| �s�td | ��| �| |d �S ) Nr rm rT z _unjelly_%sr� ���zModule z not allowed (in type z).zClass %s not allowed.)r r� ro r� r� r5 �getr+ r! r� r; rU r �splitr� �isModuleAllowedr r� �_genericUnjelly) r[ r� � jelTypeBytes�regClass�method� regFactory� jelTypeText�thunk� nameSplit�modName�clzr r r rU � s4 � z_Unjellier.unjellyc C s | � t|| �|���S )a� Unjelly a type for which no specific unjellier is registered, but which is nonetheless allowed. @param cls: the class of the instance we are unjellying. @type cls: L{type} @param state: The jellied representation of the object's state; its C{__dict__} unless it has a C{__setstate__} that takes something else. @type state: L{list} @return: the new, unjellied instance. )r� r- rU )r[ r r% r r r r� � s z_Unjellier._genericUnjellyc C s d S r" r �r[ �expr r r � _unjelly_None� s z_Unjellier._unjelly_Nonec C s t |d d�S )Nr r� r� r� r r r �_unjelly_unicode� ra z_Unjellier._unjelly_unicodec C sD |d }|d }|dk rd}nd}t �|��� d }t �|||f�S )z* Unjelly decimal objects. r rT )r� r� r� )r[ r� r� r� r� r� r r r �_unjelly_decimal� s z_Unjellier._unjelly_decimalc C s |d dv sJ �|d dkS )Nr )r� r� r� r r� r r r �_unjelly_boolean� s z_Unjellier._unjelly_booleanc C s t j tt|d �� �� S �Nr )r� �mapr� r� r� r r r �_unjelly_datetime� � z _Unjellier._unjelly_datetimec C � t jtt|d �� �� S r� )r� r� r� r� r� r� r r r � _unjelly_date� r� z_Unjellier._unjelly_datec C r� r� )r� r� r� r� r� r� r r r � _unjelly_time� r� z_Unjellier._unjelly_timec C s( t t|d �� �\}}}tj|||d�S )Nr )r� r� r� )r� r� r� r� r� )r[ r� r� r� r� r r r �_unjelly_timedelta� s z _Unjellier._unjelly_timedeltac C s, | � |�}t|t�r|�||� |||< |S r" )rU r r � addDependant)r[ r� �loc�jelr� r r r � unjellyInto� s z_Unjellier.unjellyIntoc C s6 |d }| j �|�}|d ur|S t|�}|| j |< |S r� )r� r� r )r[ �lstr} r� �derr r r �_unjelly_dereference� s z _Unjellier._unjelly_dereferencec C sf |d }|d }| � |�}| j�|�}|d u r || j|< |S t|t�r/|�|� || j|< |S J d��)Nr rT z!Multiple references with same ID!)rU r� r� r r �resolveDependants)r[ r r} r� r� �refr r r �_unjelly_reference� s � �z _Unjellier._unjelly_referencec C sN t tt|���}d}|D ]}t| �|||| �t�r d}q |r#t|�S t|�S )NrT r )r� �range�lenr r r r� r )r[ r �l�finished�elemr r r �_unjelly_tuple� s �z_Unjellier._unjelly_tuplec C s0 t tt|���}|D ] }| �|||| � q |S r" )r� r r r )r[ r r r r r r � _unjelly_list s z_Unjellier._unjelly_listc C sT t tt|���}d}|D ]}| �|||| �}t|t�r d}q |s&t||�S ||�S )z� Helper method to unjelly set or frozenset. @param lst: the content of the set. @type lst: C{list} @param containerType: the type of C{set} to use. TF)r� r r r r r r )r[ r � containerTyper r r �datar r r �_unjellySetOrFrozenset s � z!_Unjellier._unjellySetOrFrozensetc C � | � |t�S )z7 Unjelly set using the C{set} builtin. )r r� �r[ r r r r � _unjelly_set � z_Unjellier._unjelly_setc C r )zC Unjelly frozenset using the C{frozenset} builtin. )r r� r r r r �_unjelly_frozenset" r z _Unjellier._unjelly_frozensetc C s: i }|D ]\}}t |�}| �|d|� | �|d|� q|S )Nr rT )r r )r[ r r� �k�v�kvdr r r �_unjelly_dictionary( s z _Unjellier._unjelly_dictionaryc C sL t |d �}t|�tkrtd��| j�|�s td|����t|i i d�}|S )Nr z5Attempted to unjelly a module with a non-string name.z"Attempted to unjelly module named r� )r r re r� ro r� � __import__)r[ �rest� moduleName�modr r r �_unjelly_module0 s z_Unjellier._unjelly_modulec C s� t |d �}|�t d��}t d��|d d� �}| j�|�s$td| ��t|�}t|�}|tur8td||f ��| j�|�sFtdt |� ��|S )Nr r� r� zmodule %s not allowedz6class %r unjellied to something that isn't a class: %rzclass not allowed: %s) r r� r� ro r� r� r r r� r )r[ r! �cname�clistr� �klausr� r r r �_unjelly_class9 s �� z_Unjellier._unjelly_classc C sT t |d �}|�t d��}t d��|d d� �}| j�|�s$td| ��t|�}|S )Nr r� r� zModule not allowed: %s)r r� r� ro r� r� r )r[ r! �fname�modSplitr� �functionr r r �_unjelly_functionJ s z _Unjellier._unjelly_functionc C s" | j r | � |d | �}|S td�S )Nr z Persistent callback not found)r� rY )r[ r! �ploadr r r �_unjelly_persistentT s z _Unjellier._unjelly_persistentc C s0 t jdtddd� | �|d �}| �||d �S )z� (internal) Unjelly an instance. Called to handle the deprecated I{instance} token. @param rest: The s-expression representing the instance. @return: The unjellied instance. ztUnjelly support for the instance atom is deprecated since Twisted 15.0.0. Upgrade peer for modern instance support.� r )�category�filename�linenorT )�warnings� warn_explicit�DeprecationWarningrU r� )r[ r! r� r r r �_unjelly_instance[ s �z _Unjellier._unjelly_instancec C s t d|d � ��S )NzUnpersistable data: r )rY )r[ r! r r r �_unjelly_unpersistablep s z!_Unjellier._unjelly_unpersistablec C s� |d }| � |d �}| � |d �}t|t�std��||jv rJ|du r+t||�}|S t|t�r8t|||�}|S tj |j| |g|gd �R � }|S t d��)z. (internal) Unjelly a method. r rT r z"Method found with non-class class.NFzinstance method changed) rU r r r� r$ r+ r r r� r� rA )r[ r! �im_name�im_self�im_class�imr r r �_unjelly_methods s& � � ���z_Unjellier._unjelly_methodN) r> rb rc r\ r� r� rU r� r� r� r� r� r� r r r r r r r r r r r r r$ r( r, r. r6 r7 r< r r r r r� k s< r� c @ s e Zd ZdZdS )r� z� This exception will be raised when a jelly is deemed `insecure'; e.g. it contains a type, class, or module disallowed by the specified `taster' N)r> rb rc rd r r r r r� � s r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �DummySecurityOptionsz{ DummySecurityOptions() -> insecure security options Dummy security options -- this class will allow anything. c C � dS )z� DummySecurityOptions.isModuleAllowed(moduleName) -> boolean returns 1 if a module by that name is allowed, 0 otherwise rT r �r[ r" r r r r� � � z$DummySecurityOptions.isModuleAllowedc C r> )z� DummySecurityOptions.isClassAllowed(class) -> boolean Assumes the module has already been allowed. Returns 1 if the given class is allowed, 0 otherwise. rT r �r[ �klassr r r r� � s z#DummySecurityOptions.isClassAllowedc C r> )z� DummySecurityOptions.isTypeAllowed(typeName) -> boolean Returns 1 if the given type is allowed, 0 otherwise. rT r �r[ �typeNamer r r r� � r@ z"DummySecurityOptions.isTypeAllowedN)r> rb rc rd r� r� r� r r r r r= � s r= c @ sX e Zd ZdZg d�Zdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dS )�SecurityOptionszF This will by default disallow everything, except for 'none'. ) � dictionaryr� r� � reference� dereferencer� r� �long_int�long�dictc C sv i dd�dd�dd�dd�dd�dd�dd�d d�d d�d d�d d�d d�dd�dd�dd�dd�| _ i | _i | _dS )z/ SecurityOptions() initialize. r rT s boolr� s strings strs ints floatr� r� r� r� s NoneTyper� r� r r N)� allowedTypes�allowedModules�allowedClassesr_ r r r r\ � sF �������� � � � � ���� zSecurityOptions.__init__c C s | j | j� dS )zz Allow all `basic' types. (Dictionary and list. Int, string, and float are implicitly allowed.) N)r7 � basicTypesr_ r r r �allowBasicTypes� s z SecurityOptions.allowBasicTypesc G s> |D ]}t |t�r|�d�}t |t�st|�}d| j|< qdS )zg SecurityOptions.allowTypes(typeString): Allow a particular type, by its name. r. rT N)r re r0 r/ r rL )r[ r� �typr r r r7 � s �zSecurityOptions.allowTypesc G sJ | � � | �dddd� |D ]}| �t|�� | �|j� d| j|< qdS )a SecurityOptions.allowInstances(klass, klass, ...): allow instances of the specified classes This will also allow the 'instance', 'class' (renamed 'classobj' in Python 2.3), and 'module' types, as well as basic types. r' �class�classobjrB rT N)rP r7 r � allowModulesrb rN )r[ �classesrB r r r �allowInstancesOf� s �z SecurityOptions.allowInstancesOfc G s@ |D ]}t |�tjkr|j}t|t�s|�d�}d| j|< qdS )z� SecurityOptions.allowModules(module, module, ...): allow modules by name. This will also allow the 'module' type. r. rT N)r r� r� r> r r/ r0 rM )r[ �modulesrB r r r rT s �z SecurityOptions.allowModulesc C s t |t�s |�d�}|| jv S )z� SecurityOptions.isModuleAllowed(moduleName) -> boolean returns 1 if a module by that name is allowed, 0 otherwise r. )r r/ r0 rM r? r r r r� s z SecurityOptions.isModuleAllowedc C s || j v S )z� SecurityOptions.isClassAllowed(class) -> boolean Assumes the module has already been allowed. Returns 1 if the given class is allowed, 0 otherwise. )rN rA r r r r� s z SecurityOptions.isClassAllowedc C s& t |t�s |�d�}|| jv pd|v S )z� SecurityOptions.isTypeAllowed(typeName) -> boolean Returns 1 if the given type is allowed, 0 otherwise. r. � .)r r/ r0 rL rC r r r r� s z SecurityOptions.isTypeAllowedN) r> rb rc rd rO r\ rP r7 rV rT r� r� r� r r r r rE � s rE c C � t |||��| �S )z� Serialize to s-expression. Returns a list which is the serialized representation of an object. An optional 'taster' argument takes a SecurityOptions and will mark any insecure objects as unpersistable rather than serializing them. )rn rN )rz ro rt ru r r r rN / s rN c C rY )aT Unserialize from s-expression. Takes a list that was the result from a call to jelly() and unserializes an arbitrary object from it. The optional 'taster' argument, an instance of SecurityOptions, will cause an InsecureJelly exception to be raised if a disallowed type, module, or class attempted to unserialize. )r� r� )r� ro r� ru r r r rU : s rU r" )Erd rw r� r� r� r3 � functoolsr �zope.interfacer � incrementalr �twisted.persisted.crefutilr r r r r r �twisted.python.compatr �twisted.python.deprecater �twisted.python.reflectr r r �twisted.spread.interfacesr r rK r� � None_atom� class_atom� module_atom� function_atomry r� rx r� r� r� r� r r� r� r5 r; r! r- r3 r: r= rH rS rX rY rg rk rn r� � Exceptionr� r= rE r6 rP rN rU r r r r �<module> s~ : � ) $ z PK Mb�Zx�{N�$ �$ ) spread/__pycache__/banana.cpython-310.pycnu �[��� o �b�/ � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZ G d d � d e�Zd d � Zd d� ZdZdZdZdZdZdZdZdZdZdd� Z da e d� dZ G dd � d ej ej �Z!e!� Z"e"�#� e"�$d � d d � Z%d d!� Z&dS )"z� Banana -- s-exp based protocol. Future Plans: This module is almost entirely stable. The same caveat applies to it as applies to L{twisted.spread.jelly}, however. Read its future plans for more details. @author: Glyph Lefkowitz � N)�BytesIO)�protocol)�styles)�log)� iterbytes)�fullyQualifiedNamec @ s e Zd ZdS )� BananaErrorN)�__name__� __module__� __qualname__� r r �7/usr/lib/python3/dist-packages/twisted/spread/banana.pyr s r c C sN | dkr |d� d S | dksJ d��| r%|t | d@ f�� | d? } | sd S d S )Nr � z!can only encode positive integers� � )�bytes)�integer�streamr r r �int2b128 s �r c C s6 d}d}t | �D ]}t|�}||| 7 }|dK }q|S )z� Convert an integer represented as a base 128 string into an L{int}. @param st: The integer encoded in a byte string. @type st: L{bytes} @return: The integer value extracted from the byte string. @rtype: L{int} � r r )r �ord)�st�e�i�char�nr r r �b1282int) s r � �� �� �� �� �� �� �� �c C s | a dS )ak Set the limit on the prefix length for all Banana connections established after this call. The prefix length limit determines how many bytes of prefix a banana decoder will allow before rejecting a potential object as too large. @type limit: L{int} @param limit: The number of bytes of prefix for banana to allow when decoding. N)� _PREFIX_LIMIT)�limitr r r �setPrefixLimitK s r' �@ i c @ s( e Zd ZdZddgZdZeZdd� Zdd� Z d d � Z d d � Z d d� Z dd� Z dZdd� Zdd� Zi dd�dd�dd�d d �d d �d d!�d"d#�d$d%�d&d'�d(d)�d*d+�d,d-�d.d/�d0d1�d2d3�d4d5�d6d7�d8d9d:d;d<d=d>d?d@dAdBdCdDdEdF��Zi Ze�� D ]\ZZeee< q|dMdGdH�ZdIdJ� ZdKdL� ZdS )N�Bananaz� L{Banana} implements the I{Banana} s-expression protocol, client and server. @ivar knownDialects: These are the profiles supported by this Banana implementation. @type knownDialects: L{list} of L{bytes} � pb� noneNc C s< || _ d|d d | _d| _d| _d|d d | _dS )zt Set the prefix limit for decoding done by this protocol instance. @see: L{setPrefixLimit} � r r i �i���N)� prefixLimit�_smallestLongInt� _smallestInt� _largestInt�_largestLongInt)�selfr& r r r r' r s zBanana.setPrefixLimitc C s dS )zPSurrogate for connectionMade Called after protocol negotiation. Nr �r2 r r r �connectionReady~ s zBanana.connectionReadyc C s || _ | �� d S �N)�currentDialectr4 )r2 �dialectr r r �_selectDialect� s zBanana._selectDialectc C s� | j r | �|� d S | jr0|D ]}|| jv r#| �|� | �|� d S qt�d� | j� � d S || jv r<| �|� d S t�d� | j� � d S )NzSThe client doesn't speak any of the protocols offered by the server: disconnecting.zYThe client selected a protocol the server didn't suggest and doesn't know: disconnecting.) r6 �expressionReceived�isClient� knownDialects� sendEncodedr8 r �msg� transport�loseConnection)r2 �obj� serverVerr r r �callExpressionReceived� s& �� �z Banana.callExpressionReceivedc C s* | � t� d | _| js| �| j� d S d S r5 )r' r% r6 r: r< r; r3 r r r �connectionMade� s �zBanana.connectionMadec C s. | j }|r|d d �|� d S | �|� d S )N���r )� listStack�appendrB )r2 �item�lr r r �gotItem� s zBanana.gotItem� c C s� | j | }| j}| j}|�re| j |ks J d�t| j �t|����|| _ d}t|�D ] }|tkr1 n|d }q)|| jkrCtd| jf ��d S |d |� }|||d � }||d d � } t |�| jkrjtd| jf ��|t kr�t |�}|t krztd��|� |g f� | }n�|tkr�t |�}|t kr�td��t | �|kr�| |d � }|| d |� � n�d S |tkr�| }t |�}||� n{|tkr�| }t |�}||� nl|tkr�| }t |�}|| � n\|tkr�| }t |� }||� nL|tk�r | }t |�}| j| } | jdk�r|| � n1td | ����|tk�r.t | �d k�r,| d d � }|t�d | d d � �d � n d S td |����|�rct |d d �|d d k�rc|�� d } || � |�rct |d d �|d d k�sG|sd| _ d S )NzThis ain't right: {} {}r r z1Security precaution: more than %d bytes of prefixz9Security precaution: longer than %d bytes worth of prefixz#Security precaution: List too long.z%Security precaution: String too long.r* z Invalid item for pb protocol � �!dzInvalid Type Byte rD rJ )�bufferrE rI �format�reprr � HIGH_BIT_SETr- r �len�LISTr � SIZE_LIMITrF �STRING�INT�LONGINT�LONGNEG�NEG�VOCAB�incomingVocabularyr6 �NotImplementedError�FLOAT�struct�unpack�pop) r2 �chunkrM rE rI �pos�ch�num�typebyte�restrG r r r � dataReceived� s� � �� �� $ $�� MzBanana.dataReceivedc C s t � �)z=Called when an expression (list, string, or int) is received.)r[ )r2 �lstr r r r9 s zBanana.expressionReceiveds Noner s classr, s dereference� s reference� s dictionary� s function� s instancer s listrK s module� s persistent� s tuple� s unpersistable� s copy� s cache� s cached� s remote� s local� � � � � � � � � � � � � � � )s lcaches versions logins passwords challenges logged_ins not_logged_ins cachemessages messages answers errors decrefs decaches uncachec C s$ g | _ t�| j�| _d| _|| _d S )Nr )rE �copy�outgoingVocabulary�outgoingSymbols�outgoingSymbolCountr: )r2 r: r r r �__init__4 s zBanana.__init__c C s, t � }| �||j� |�� }| j�|� dS )a Send the encoded representation of the given object: @param obj: An object to encode and send. @raise BananaError: If the given object is not an instance of one of the types supported by Banana. @return: L{None} N)r �_encode�write�getvaluer> )r2 r@ � encodeStream�valuer r r r< : s zBanana.sendEncodedc C s� t |ttf�r.t|�tkrtdt|�f ��tt|�|� |t� |D ]}| �||� q#d S t |t �r�|| j k s=|| j krDtd|f ��|| j k rUt| |� |t � d S |dk ret| |� |t� d S || jkrut||� |t� d S t||� |t� d S t |t�r�|t� |t�d|�� d S t |t�r�| jdkr�|| jv r�| j| }t||� |t� d S t|�tkr�tdt|�f ��tt|�|� |t� ||� d S td�t t |��|���)Nz#list/tuple is too long to send (%d)z int is too large to send (%d)r rL r* z$byte string is too long to send (%d)z#Banana cannot send {} objects: {!r}) � isinstance�list�tuplerQ rS r r rR r� �intr. r1 r/ rW rX r0 rU rV �floatr\ r] �packr r6 r� rY rT rN r �type)r2 r@ r� �elem�symbolIDr r r r� J sT � � ��zBanana._encode)r )r r r �__doc__r; r- rS � sizeLimitr' r4 r8 rB rC rI rM rf r9 r� rZ �items�k�vr� r< r� r r r r r) a s� S������� � � � � �������% r) r+ c C s t � }|t_t�| � |�� S )zEncode a list s-expression.)r �_ir> r< r� )rg r� r r r �encode� s r� c C s8 g }|j t_zt�| � W dt_t`|d S dt_t`w )z) Decode a banana-encoded string. rJ r )rF r� r9 rf rM )r rH r r r �decode� s �r� )'r� r� r] �ior �twisted.internetr �twisted.persistedr �twisted.pythonr �twisted.python.compatr �twisted.python.reflectr � Exceptionr r r rR rU rT rX r\ rV rW rY rP r' r% rS �Protocol� Ephemeralr) r� rC r8 r� r� r r r r �<module> sB PK Mb�Z�)� � - spread/__pycache__/interfaces.cpython-310.pycnu �[��� o �b� � @ s4 d Z ddlmZ G dd� de�ZG dd� de�ZdS )z Twisted Spread Interfaces. � )� Interfacec @ � e Zd Zdd� ZdS )� IJellyablec C � dS )z+ Jelly myself for jellier. N� )�jellierr r �;/usr/lib/python3/dist-packages/twisted/spread/interfaces.py�jellyFor � zIJellyable.jellyForN)�__name__� __module__� __qualname__r r r r r r � r c @ r )� IUnjellyablec C r )aO Unjelly myself for the jellier. @param jellier: A stateful object which exists for the lifetime of a single call to L{unjelly}. @param jellyList: The C{list} which represents the jellied state of the object to be unjellied. @return: The object which results from unjellying. Nr )r � jellyListr r r � unjellyFor r zIUnjellyable.unjellyForN)r r r r r r r r r r r N)�__doc__�zope.interfacer r r r r r r �<module> s PK Mb�Zg���Y� Y� spread/jelly.pynu �[��� # -*- test-case-name: twisted.spread.test.test_jelly -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ S-expression-based persistence of python objects. It does something very much like L{Pickle<pickle>}; however, pickle's main goal seems to be efficiency (both in space and time); jelly's main goals are security, human readability, and portability to other environments. This is how Jelly converts various objects to s-expressions. Boolean:: True --> ['boolean', 'true'] Integer:: 1 --> 1 List:: [1, 2] --> ['list', 1, 2] String:: \"hello\" --> \"hello\" Float:: 2.3 --> 2.3 Dictionary:: {'a': 1, 'b': 'c'} --> ['dictionary', ['b', 'c'], ['a', 1]] Module:: UserString --> ['module', 'UserString'] Class:: UserString.UserString --> ['class', ['module', 'UserString'], 'UserString'] Function:: string.join --> ['function', 'join', ['module', 'string']] Instance: s is an instance of UserString.UserString, with a __dict__ {'data': 'hello'}:: [\"UserString.UserString\", ['dictionary', ['data', 'hello']]] Class Method: UserString.UserString.center:: ['method', 'center', ['None'], ['class', ['module', 'UserString'], 'UserString']] Instance Method: s.center, where s is an instance of UserString.UserString:: ['method', 'center', ['instance', ['reference', 1, ['class', ['module', 'UserString'], 'UserString']], ['dictionary', ['data', 'd']]], ['dereference', 1]] The Python 2.x C{sets.Set} and C{sets.ImmutableSet} classes are serialized to the same thing as the builtin C{set} and C{frozenset} classes. (This is only relevant if you are communicating with a version of jelly running on an older version of Python.) @author: Glyph Lefkowitz """ import copy import datetime import decimal # System Imports import types import warnings from functools import reduce from zope.interface import implementer from incremental import Version from twisted.persisted.crefutil import ( NotKnown, _Container, _Dereference, _DictKeyAndValue, _InstanceMethod, _Tuple, ) # Twisted Imports from twisted.python.compat import nativeString from twisted.python.deprecate import deprecatedModuleAttribute from twisted.python.reflect import namedAny, namedObject, qual from twisted.spread.interfaces import IJellyable, IUnjellyable DictTypes = (dict,) None_atom = b"None" # N # code class_atom = b"class" # c module_atom = b"module" # m function_atom = b"function" # f # references dereference_atom = b"dereference" # D persistent_atom = b"persistent" # p reference_atom = b"reference" # r # mutable collections dictionary_atom = b"dictionary" # d list_atom = b"list" # l set_atom = b"set" # immutable collections # (assignment to __dict__ and __class__ still might go away!) tuple_atom = b"tuple" # t instance_atom = b"instance" # i frozenset_atom = b"frozenset" deprecatedModuleAttribute( Version("Twisted", 15, 0, 0), "instance_atom is unused within Twisted.", "twisted.spread.jelly", "instance_atom", ) # errors unpersistable_atom = b"unpersistable" # u unjellyableRegistry = {} unjellyableFactoryRegistry = {} def _createBlank(cls): """ Given an object, if that object is a type, return a new, blank instance of that type which has not had C{__init__} called on it. If the object is not a type, return L{None}. @param cls: The type (or class) to create an instance of. @type cls: L{type} or something else that cannot be instantiated. @return: a new blank instance or L{None} if C{cls} is not a class or type. """ if isinstance(cls, type): return cls.__new__(cls) def _newInstance(cls, state): """ Make a new instance of a class without calling its __init__ method. @param state: A C{dict} used to update C{inst.__dict__} either directly or via C{__setstate__}, if available. @return: A new instance of C{cls}. """ instance = _createBlank(cls) def defaultSetter(state): instance.__dict__ = state setter = getattr(instance, "__setstate__", defaultSetter) setter(state) return instance def _maybeClass(classnamep): isObject = isinstance(classnamep, type) if isObject: classnamep = qual(classnamep) if not isinstance(classnamep, bytes): classnamep = classnamep.encode("utf-8") return classnamep def setUnjellyableForClass(classname, unjellyable): """ Set which local class will represent a remote type. If you have written a Copyable class that you expect your client to be receiving, write a local "copy" class to represent it, then call:: jellier.setUnjellyableForClass('module.package.Class', MyCopier). Call this at the module level immediately after its class definition. MyCopier should be a subclass of RemoteCopy. The classname may be a special tag returned by 'Copyable.getTypeToCopyFor' rather than an actual classname. This call is also for cached classes, since there will be no overlap. The rules are the same. """ global unjellyableRegistry classname = _maybeClass(classname) unjellyableRegistry[classname] = unjellyable globalSecurity.allowTypes(classname) def setUnjellyableFactoryForClass(classname, copyFactory): """ Set the factory to construct a remote instance of a type:: jellier.setUnjellyableFactoryForClass('module.package.Class', MyFactory) Call this at the module level immediately after its class definition. C{copyFactory} should return an instance or subclass of L{RemoteCopy<pb.RemoteCopy>}. Similar to L{setUnjellyableForClass} except it uses a factory instead of creating an instance. """ global unjellyableFactoryRegistry classname = _maybeClass(classname) unjellyableFactoryRegistry[classname] = copyFactory globalSecurity.allowTypes(classname) def setUnjellyableForClassTree(module, baseClass, prefix=None): """ Set all classes in a module derived from C{baseClass} as copiers for a corresponding remote class. When you have a hierarchy of Copyable (or Cacheable) classes on one side, and a mirror structure of Copied (or RemoteCache) classes on the other, use this to setUnjellyableForClass all your Copieds for the Copyables. Each copyTag (the \"classname\" argument to getTypeToCopyFor, and what the Copyable's getTypeToCopyFor returns) is formed from adding a prefix to the Copied's class name. The prefix defaults to module.__name__. If you wish the copy tag to consist of solely the classname, pass the empty string \'\'. @param module: a module object from which to pull the Copied classes. (passing sys.modules[__name__] might be useful) @param baseClass: the base class from which all your Copied classes derive. @param prefix: the string prefixed to classnames to form the unjellyableRegistry. """ if prefix is None: prefix = module.__name__ if prefix: prefix = "%s." % prefix for name in dir(module): loaded = getattr(module, name) try: yes = issubclass(loaded, baseClass) except TypeError: "It's not a class." else: if yes: setUnjellyableForClass(f"{prefix}{name}", loaded) def getInstanceState(inst, jellier): """ Utility method to default to 'normal' state rules in serialization. """ if hasattr(inst, "__getstate__"): state = inst.__getstate__() else: state = inst.__dict__ sxp = jellier.prepare(inst) sxp.extend([qual(inst.__class__).encode("utf-8"), jellier.jelly(state)]) return jellier.preserve(inst, sxp) def setInstanceState(inst, unjellier, jellyList): """ Utility method to default to 'normal' state rules in unserialization. """ state = unjellier.unjelly(jellyList[1]) if hasattr(inst, "__setstate__"): inst.__setstate__(state) else: inst.__dict__ = state return inst class Unpersistable: """ This is an instance of a class that comes back when something couldn't be unpersisted. """ def __init__(self, reason): """ Initialize an unpersistable object with a descriptive C{reason} string. """ self.reason = reason def __repr__(self) -> str: return "Unpersistable(%s)" % repr(self.reason) @implementer(IJellyable) class Jellyable: """ Inherit from me to Jelly yourself directly with the `getStateFor' convenience method. """ def getStateFor(self, jellier): return self.__dict__ def jellyFor(self, jellier): """ @see: L{twisted.spread.interfaces.IJellyable.jellyFor} """ sxp = jellier.prepare(self) sxp.extend( [ qual(self.__class__).encode("utf-8"), jellier.jelly(self.getStateFor(jellier)), ] ) return jellier.preserve(self, sxp) @implementer(IUnjellyable) class Unjellyable: """ Inherit from me to Unjelly yourself directly with the C{setStateFor} convenience method. """ def setStateFor(self, unjellier, state): self.__dict__ = state def unjellyFor(self, unjellier, jellyList): """ Perform the inverse operation of L{Jellyable.jellyFor}. @see: L{twisted.spread.interfaces.IUnjellyable.unjellyFor} """ state = unjellier.unjelly(jellyList[1]) self.setStateFor(unjellier, state) return self class _Jellier: """ (Internal) This class manages state for a call to jelly() """ def __init__(self, taster, persistentStore, invoker): """ Initialize. """ self.taster = taster # `preserved' is a dict of previously seen instances. self.preserved = {} # `cooked' is a dict of previously backreferenced instances to their # `ref' lists. self.cooked = {} self.cooker = {} self._ref_id = 1 self.persistentStore = persistentStore self.invoker = invoker def _cook(self, object): """ (internal) Backreference an object. Notes on this method for the hapless future maintainer: If I've already gone through the prepare/preserve cycle on the specified object (it is being referenced after the serializer is \"done with\" it, e.g. this reference is NOT circular), the copy-in-place of aList is relevant, since the list being modified is the actual, pre-existing jelly expression that was returned for that object. If not, it's technically superfluous, since the value in self.preserved didn't need to be set, but the invariant that self.preserved[id(object)] is a list is convenient because that means we don't have to test and create it or not create it here, creating fewer code-paths. that's why self.preserved is always set to a list. Sorry that this code is so hard to follow, but Python objects are tricky to persist correctly. -glyph """ aList = self.preserved[id(object)] newList = copy.copy(aList) # make a new reference ID refid = self._ref_id self._ref_id = self._ref_id + 1 # replace the old list in-place, so that we don't have to track the # previous reference to it. aList[:] = [reference_atom, refid, newList] self.cooked[id(object)] = [dereference_atom, refid] return aList def prepare(self, object): """ (internal) Create a list for persisting an object to. This will allow backreferences to be made internal to the object. (circular references). The reason this needs to happen is that we don't generate an ID for every object, so we won't necessarily know which ID the object will have in the future. When it is 'cooked' ( see _cook ), it will be assigned an ID, and the temporary placeholder list created here will be modified in-place to create an expression that gives this object an ID: [reference id# [object-jelly]]. """ # create a placeholder list to be preserved self.preserved[id(object)] = [] # keep a reference to this object around, so it doesn't disappear! # (This isn't always necessary, but for cases where the objects are # dynamically generated by __getstate__ or getStateToCopyFor calls, it # is; id() will return the same value for a different object if it gets # garbage collected. This may be optimized later.) self.cooker[id(object)] = object return [] def preserve(self, object, sexp): """ (internal) Mark an object's persistent list for later referral. """ # if I've been cooked in the meanwhile, if id(object) in self.cooked: # replace the placeholder empty list with the real one self.preserved[id(object)][2] = sexp # but give this one back. sexp = self.preserved[id(object)] else: self.preserved[id(object)] = sexp return sexp def _checkMutable(self, obj): objId = id(obj) if objId in self.cooked: return self.cooked[objId] if objId in self.preserved: self._cook(obj) return self.cooked[objId] def jelly(self, obj): if isinstance(obj, Jellyable): preRef = self._checkMutable(obj) if preRef: return preRef return obj.jellyFor(self) objType = type(obj) if self.taster.isTypeAllowed(qual(objType).encode("utf-8")): # "Immutable" Types if objType in (bytes, int, float): return obj elif isinstance(obj, types.MethodType): aSelf = obj.__self__ aFunc = obj.__func__ aClass = aSelf.__class__ return [ b"method", aFunc.__name__, self.jelly(aSelf), self.jelly(aClass), ] elif objType is str: return [b"unicode", obj.encode("UTF-8")] elif isinstance(obj, type(None)): return [b"None"] elif isinstance(obj, types.FunctionType): return [b"function", obj.__module__ + "." + obj.__qualname__] elif isinstance(obj, types.ModuleType): return [b"module", obj.__name__] elif objType is bool: return [b"boolean", obj and b"true" or b"false"] elif objType is datetime.datetime: if obj.tzinfo: raise NotImplementedError( "Currently can't jelly datetime objects with tzinfo" ) return [ b"datetime", " ".join( [ str(x) for x in ( obj.year, obj.month, obj.day, obj.hour, obj.minute, obj.second, obj.microsecond, ) ] ).encode("utf-8"), ] elif objType is datetime.time: if obj.tzinfo: raise NotImplementedError( "Currently can't jelly datetime objects with tzinfo" ) return [ b"time", " ".join( [ str(x) for x in (obj.hour, obj.minute, obj.second, obj.microsecond) ] ).encode("utf-8"), ] elif objType is datetime.date: return [ b"date", " ".join([str(x) for x in (obj.year, obj.month, obj.day)]).encode( "utf-8" ), ] elif objType is datetime.timedelta: return [ b"timedelta", " ".join( [str(x) for x in (obj.days, obj.seconds, obj.microseconds)] ).encode("utf-8"), ] elif issubclass(objType, type): return [b"class", qual(obj).encode("utf-8")] elif objType is decimal.Decimal: return self.jelly_decimal(obj) else: preRef = self._checkMutable(obj) if preRef: return preRef # "Mutable" Types sxp = self.prepare(obj) if objType is list: sxp.extend(self._jellyIterable(list_atom, obj)) elif objType is tuple: sxp.extend(self._jellyIterable(tuple_atom, obj)) elif objType in DictTypes: sxp.append(dictionary_atom) for key, val in obj.items(): sxp.append([self.jelly(key), self.jelly(val)]) elif objType is set: sxp.extend(self._jellyIterable(set_atom, obj)) elif objType is frozenset: sxp.extend(self._jellyIterable(frozenset_atom, obj)) else: className = qual(obj.__class__).encode("utf-8") persistent = None if self.persistentStore: persistent = self.persistentStore(obj, self) if persistent is not None: sxp.append(persistent_atom) sxp.append(persistent) elif self.taster.isClassAllowed(obj.__class__): sxp.append(className) if hasattr(obj, "__getstate__"): state = obj.__getstate__() else: state = obj.__dict__ sxp.append(self.jelly(state)) else: self.unpersistable( "instance of class %s deemed insecure" % qual(obj.__class__), sxp, ) return self.preserve(obj, sxp) else: raise InsecureJelly(f"Type not allowed for object: {objType} {obj}") def _jellyIterable(self, atom, obj): """ Jelly an iterable object. @param atom: the identifier atom of the object. @type atom: C{str} @param obj: any iterable object. @type obj: C{iterable} @return: a generator of jellied data. @rtype: C{generator} """ yield atom for item in obj: yield self.jelly(item) def jelly_decimal(self, d): """ Jelly a decimal object. @param d: a decimal object to serialize. @type d: C{decimal.Decimal} @return: jelly for the decimal object. @rtype: C{list} """ sign, guts, exponent = d.as_tuple() value = reduce(lambda left, right: left * 10 + right, guts) if sign: value = -value return [b"decimal", value, exponent] def unpersistable(self, reason, sxp=None): """ (internal) Returns an sexp: (unpersistable "reason"). Utility method for making note that a particular object could not be serialized. """ if sxp is None: sxp = [] sxp.append(unpersistable_atom) if isinstance(reason, str): reason = reason.encode("utf-8") sxp.append(reason) return sxp class _Unjellier: def __init__(self, taster, persistentLoad, invoker): self.taster = taster self.persistentLoad = persistentLoad self.references = {} self.postCallbacks = [] self.invoker = invoker def unjellyFull(self, obj): o = self.unjelly(obj) for m in self.postCallbacks: m() return o def _maybePostUnjelly(self, unjellied): """ If the given object has support for the C{postUnjelly} hook, set it up to be called at the end of deserialization. @param unjellied: an object that has already been unjellied. @return: C{unjellied} """ if hasattr(unjellied, "postUnjelly"): self.postCallbacks.append(unjellied.postUnjelly) return unjellied def unjelly(self, obj): if type(obj) is not list: return obj jelTypeBytes = obj[0] if not self.taster.isTypeAllowed(jelTypeBytes): raise InsecureJelly(jelTypeBytes) regClass = unjellyableRegistry.get(jelTypeBytes) if regClass is not None: method = getattr(_createBlank(regClass), "unjellyFor", regClass) return self._maybePostUnjelly(method(self, obj)) regFactory = unjellyableFactoryRegistry.get(jelTypeBytes) if regFactory is not None: return self._maybePostUnjelly(regFactory(self.unjelly(obj[1]))) jelTypeText = nativeString(jelTypeBytes) thunk = getattr(self, "_unjelly_%s" % jelTypeText, None) if thunk is not None: return thunk(obj[1:]) else: nameSplit = jelTypeText.split(".") modName = ".".join(nameSplit[:-1]) if not self.taster.isModuleAllowed(modName): raise InsecureJelly( f"Module {modName} not allowed (in type {jelTypeText})." ) clz = namedObject(jelTypeText) if not self.taster.isClassAllowed(clz): raise InsecureJelly("Class %s not allowed." % jelTypeText) return self._genericUnjelly(clz, obj[1]) def _genericUnjelly(self, cls, state): """ Unjelly a type for which no specific unjellier is registered, but which is nonetheless allowed. @param cls: the class of the instance we are unjellying. @type cls: L{type} @param state: The jellied representation of the object's state; its C{__dict__} unless it has a C{__setstate__} that takes something else. @type state: L{list} @return: the new, unjellied instance. """ return self._maybePostUnjelly(_newInstance(cls, self.unjelly(state))) def _unjelly_None(self, exp): return None def _unjelly_unicode(self, exp): return str(exp[0], "UTF-8") def _unjelly_decimal(self, exp): """ Unjelly decimal objects. """ value = exp[0] exponent = exp[1] if value < 0: sign = 1 else: sign = 0 guts = decimal.Decimal(value).as_tuple()[1] return decimal.Decimal((sign, guts, exponent)) def _unjelly_boolean(self, exp): assert exp[0] in (b"true", b"false") return exp[0] == b"true" def _unjelly_datetime(self, exp): return datetime.datetime(*map(int, exp[0].split())) def _unjelly_date(self, exp): return datetime.date(*map(int, exp[0].split())) def _unjelly_time(self, exp): return datetime.time(*map(int, exp[0].split())) def _unjelly_timedelta(self, exp): days, seconds, microseconds = map(int, exp[0].split()) return datetime.timedelta(days=days, seconds=seconds, microseconds=microseconds) def unjellyInto(self, obj, loc, jel): o = self.unjelly(jel) if isinstance(o, NotKnown): o.addDependant(obj, loc) obj[loc] = o return o def _unjelly_dereference(self, lst): refid = lst[0] x = self.references.get(refid) if x is not None: return x der = _Dereference(refid) self.references[refid] = der return der def _unjelly_reference(self, lst): refid = lst[0] exp = lst[1] o = self.unjelly(exp) ref = self.references.get(refid) if ref is None: self.references[refid] = o elif isinstance(ref, NotKnown): ref.resolveDependants(o) self.references[refid] = o else: assert 0, "Multiple references with same ID!" return o def _unjelly_tuple(self, lst): l = list(range(len(lst))) finished = 1 for elem in l: if isinstance(self.unjellyInto(l, elem, lst[elem]), NotKnown): finished = 0 if finished: return tuple(l) else: return _Tuple(l) def _unjelly_list(self, lst): l = list(range(len(lst))) for elem in l: self.unjellyInto(l, elem, lst[elem]) return l def _unjellySetOrFrozenset(self, lst, containerType): """ Helper method to unjelly set or frozenset. @param lst: the content of the set. @type lst: C{list} @param containerType: the type of C{set} to use. """ l = list(range(len(lst))) finished = True for elem in l: data = self.unjellyInto(l, elem, lst[elem]) if isinstance(data, NotKnown): finished = False if not finished: return _Container(l, containerType) else: return containerType(l) def _unjelly_set(self, lst): """ Unjelly set using the C{set} builtin. """ return self._unjellySetOrFrozenset(lst, set) def _unjelly_frozenset(self, lst): """ Unjelly frozenset using the C{frozenset} builtin. """ return self._unjellySetOrFrozenset(lst, frozenset) def _unjelly_dictionary(self, lst): d = {} for k, v in lst: kvd = _DictKeyAndValue(d) self.unjellyInto(kvd, 0, k) self.unjellyInto(kvd, 1, v) return d def _unjelly_module(self, rest): moduleName = nativeString(rest[0]) if type(moduleName) != str: raise InsecureJelly("Attempted to unjelly a module with a non-string name.") if not self.taster.isModuleAllowed(moduleName): raise InsecureJelly(f"Attempted to unjelly module named {moduleName!r}") mod = __import__(moduleName, {}, {}, "x") return mod def _unjelly_class(self, rest): cname = nativeString(rest[0]) clist = cname.split(nativeString(".")) modName = nativeString(".").join(clist[:-1]) if not self.taster.isModuleAllowed(modName): raise InsecureJelly("module %s not allowed" % modName) klaus = namedObject(cname) objType = type(klaus) if objType is not type: raise InsecureJelly( "class %r unjellied to something that isn't a class: %r" % (cname, klaus) ) if not self.taster.isClassAllowed(klaus): raise InsecureJelly("class not allowed: %s" % qual(klaus)) return klaus def _unjelly_function(self, rest): fname = nativeString(rest[0]) modSplit = fname.split(nativeString(".")) modName = nativeString(".").join(modSplit[:-1]) if not self.taster.isModuleAllowed(modName): raise InsecureJelly("Module not allowed: %s" % modName) # XXX do I need an isFunctionAllowed? function = namedAny(fname) return function def _unjelly_persistent(self, rest): if self.persistentLoad: pload = self.persistentLoad(rest[0], self) return pload else: return Unpersistable("Persistent callback not found") def _unjelly_instance(self, rest): """ (internal) Unjelly an instance. Called to handle the deprecated I{instance} token. @param rest: The s-expression representing the instance. @return: The unjellied instance. """ warnings.warn_explicit( "Unjelly support for the instance atom is deprecated since " "Twisted 15.0.0. Upgrade peer for modern instance support.", category=DeprecationWarning, filename="", lineno=0, ) clz = self.unjelly(rest[0]) return self._genericUnjelly(clz, rest[1]) def _unjelly_unpersistable(self, rest): return Unpersistable(f"Unpersistable data: {rest[0]}") def _unjelly_method(self, rest): """ (internal) Unjelly a method. """ im_name = rest[0] im_self = self.unjelly(rest[1]) im_class = self.unjelly(rest[2]) if not isinstance(im_class, type): raise InsecureJelly("Method found with non-class class.") if im_name in im_class.__dict__: if im_self is None: im = getattr(im_class, im_name) elif isinstance(im_self, NotKnown): im = _InstanceMethod(im_name, im_self, im_class) else: im = types.MethodType( im_class.__dict__[im_name], im_self, *([im_class] * (False)) ) else: raise TypeError("instance method changed") return im #### Published Interface. class InsecureJelly(Exception): """ This exception will be raised when a jelly is deemed `insecure'; e.g. it contains a type, class, or module disallowed by the specified `taster' """ class DummySecurityOptions: """ DummySecurityOptions() -> insecure security options Dummy security options -- this class will allow anything. """ def isModuleAllowed(self, moduleName): """ DummySecurityOptions.isModuleAllowed(moduleName) -> boolean returns 1 if a module by that name is allowed, 0 otherwise """ return 1 def isClassAllowed(self, klass): """ DummySecurityOptions.isClassAllowed(class) -> boolean Assumes the module has already been allowed. Returns 1 if the given class is allowed, 0 otherwise. """ return 1 def isTypeAllowed(self, typeName): """ DummySecurityOptions.isTypeAllowed(typeName) -> boolean Returns 1 if the given type is allowed, 0 otherwise. """ return 1 class SecurityOptions: """ This will by default disallow everything, except for 'none'. """ basicTypes = [ "dictionary", "list", "tuple", "reference", "dereference", "unpersistable", "persistent", "long_int", "long", "dict", ] def __init__(self): """ SecurityOptions() initialize. """ # I don't believe any of these types can ever pose a security hazard, # except perhaps "reference"... self.allowedTypes = { b"None": 1, b"bool": 1, b"boolean": 1, b"string": 1, b"str": 1, b"int": 1, b"float": 1, b"datetime": 1, b"time": 1, b"date": 1, b"timedelta": 1, b"NoneType": 1, b"unicode": 1, b"decimal": 1, b"set": 1, b"frozenset": 1, } self.allowedModules = {} self.allowedClasses = {} def allowBasicTypes(self): """ Allow all `basic' types. (Dictionary and list. Int, string, and float are implicitly allowed.) """ self.allowTypes(*self.basicTypes) def allowTypes(self, *types): """ SecurityOptions.allowTypes(typeString): Allow a particular type, by its name. """ for typ in types: if isinstance(typ, str): typ = typ.encode("utf-8") if not isinstance(typ, bytes): typ = qual(typ) self.allowedTypes[typ] = 1 def allowInstancesOf(self, *classes): """ SecurityOptions.allowInstances(klass, klass, ...): allow instances of the specified classes This will also allow the 'instance', 'class' (renamed 'classobj' in Python 2.3), and 'module' types, as well as basic types. """ self.allowBasicTypes() self.allowTypes("instance", "class", "classobj", "module") for klass in classes: self.allowTypes(qual(klass)) self.allowModules(klass.__module__) self.allowedClasses[klass] = 1 def allowModules(self, *modules): """ SecurityOptions.allowModules(module, module, ...): allow modules by name. This will also allow the 'module' type. """ for module in modules: if type(module) == types.ModuleType: module = module.__name__ if not isinstance(module, bytes): module = module.encode("utf-8") self.allowedModules[module] = 1 def isModuleAllowed(self, moduleName): """ SecurityOptions.isModuleAllowed(moduleName) -> boolean returns 1 if a module by that name is allowed, 0 otherwise """ if not isinstance(moduleName, bytes): moduleName = moduleName.encode("utf-8") return moduleName in self.allowedModules def isClassAllowed(self, klass): """ SecurityOptions.isClassAllowed(class) -> boolean Assumes the module has already been allowed. Returns 1 if the given class is allowed, 0 otherwise. """ return klass in self.allowedClasses def isTypeAllowed(self, typeName): """ SecurityOptions.isTypeAllowed(typeName) -> boolean Returns 1 if the given type is allowed, 0 otherwise. """ if not isinstance(typeName, bytes): typeName = typeName.encode("utf-8") return typeName in self.allowedTypes or b"." in typeName globalSecurity = SecurityOptions() globalSecurity.allowBasicTypes() def jelly(object, taster=DummySecurityOptions(), persistentStore=None, invoker=None): """ Serialize to s-expression. Returns a list which is the serialized representation of an object. An optional 'taster' argument takes a SecurityOptions and will mark any insecure objects as unpersistable rather than serializing them. """ return _Jellier(taster, persistentStore, invoker).jelly(object) def unjelly(sexp, taster=DummySecurityOptions(), persistentLoad=None, invoker=None): """ Unserialize from s-expression. Takes a list that was the result from a call to jelly() and unserializes an arbitrary object from it. The optional 'taster' argument, an instance of SecurityOptions, will cause an InsecureJelly exception to be raised if a disallowed type, module, or class attempted to unserialize. """ return _Unjellier(taster, persistentLoad, invoker).unjellyFull(sexp) PK Mb�Z� �T�4 �4 3 spread/test/__pycache__/test_banana.cpython-310.pycnu �[��� o �b�7 � @ s� d dl Z d dlmZ d dlmZ d dlmZmZ d dlm Z d dl m Z d dl m Z d dlmZ d d lmZ d ZG d d � d e�Zd d� Zdd� ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )� N)�partial)�BytesIO)�main�protocol)�failure)� iterbytes)�banana)�StringTransport)�TestCasel ���� c @ s e Zd Zdd� ZdS )� MathTestsc C sp t tdd��t tdd�� t tdd�� dg }|D ]}t� }t�||j� |�� }t�|�}| �||� qd S )Nr �d i� iL i@B i�B l ) �list�ranger r �int2b128�write�getvalue�b1282int� assertEqual)�self� funkylist�i�x�v�y� r �A/usr/lib/python3/dist-packages/twisted/spread/test/test_banana.py� test_int2b128 s � ��� �zMathTests.test_int2b128N)�__name__� __module__� __qualname__r r r r r r s r c C s | � |� dS )z� Dictate a Banana dialect to use. @param protocol: A L{banana.Banana} instance which has not yet had a dialect negotiated. @param dialect: A L{bytes} instance naming a Banana dialect to select. N)�_selectDialect)r �dialectr r r � selectDialect# s r" c C s0 t � }| � }|�|� |�� |�|� |�� S )a� Banana encode an object using L{banana.Banana.sendEncoded}. @param bananaFactory: A no-argument callable which will return a new, unconnected protocol instance to use to do the encoding (this should most likely be a L{banana.Banana} instance). @param obj: The object to encode. @type obj: Any type supported by Banana. @return: A L{bytes} instance giving the encoded form of C{obj}. )r �makeConnection�clear� sendEncoded�value)� bananaFactory�obj� transportr r r r �encode2 s r* c @ s. e Zd ZdZejZdd� Zdd� Zdd� Z dS ) �BananaTestBasezn The base for test classes. It defines commonly used things and sets up a connection for testing. c C sN t � | _| �� | _| j�t�| j�� t| jd� | j| j_ t t | j�| _ d S )Ns none) r �io�encClass�encr# r � FileWrapperr" � putResult�expressionReceivedr r* �r r r r �setUpP s zBananaTestBase.setUpc C s || _ dS )z� Store an expression received by C{self.enc}. @param result: The object that was received. @type result: Any type supported by Banana. N)�result)r r4 r r r r0 X s zBananaTestBase.putResultc C s | j �t�tj�� | ` d S �N)r. �connectionLostr �Failurer �CONNECTION_DONEr2 r r r �tearDowna s zBananaTestBase.tearDownN) r r r �__doc__r �Bananar- r3 r0 r9 r r r r r+ H s r+ c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0S )1� BananaTestsz General banana tests. c C s0 | j �d� | j �| j�� � | jdksJ �d S )Ns hello)r. r% � dataReceivedr, r r4 r2 r r r � test_stringk � zBananaTests.test_stringc C s | � dd� dS )z� Banana does not support unicode. ``Banana.sendEncoded`` raises ``BananaError`` if called with an instance of ``unicode``. �helloz builtins.strN)�_unsupportedTypeTestr2 r r r �test_unsupportedUnicodep s z#BananaTests.test_unsupportedUnicodec C s | � td� dS )z� Banana does not support arbitrary builtin types like L{type}. L{banana.Banana.sendEncoded} raises L{banana.BananaError} if called with an instance of L{type}. z builtins.typeN)rA �typer2 r r r �test_unsupportedBuiltinTypew s z'BananaTests.test_unsupportedBuiltinTypec C s | � t� td � dS )z� Banana does not support arbitrary user-defined types (such as those defined with the ``class`` statement). ``Banana.sendEncoded`` raises ``BananaError`` if called with an instance of such a type. z .MathTestsN)rA r r r2 r r r �test_unsupportedUserType� s z$BananaTests.test_unsupportedUserTypec C s0 | � tj| jj|�}| �d|� d�t|�� dS )a� Assert that L{banana.Banana.sendEncoded} raises L{banana.BananaError} if called with the given object. @param obj: Some object that Banana does not support. @param name: The name of the type of the object. @raise: The failure exception is raised if L{Banana.sendEncoded} does not raise L{banana.BananaError} or if the message associated with the exception is not formatted to include the type of the unsupported object. zBanana cannot send z objectsN)� assertRaisesr � BananaErrorr. r% �assertIn�str)r r( �name�excr r r rA � s z BananaTests._unsupportedTypeTestc C s> | j �d� | j �| j�� � | �| jd� | �| jt� dS )z� A positive integer less than 2 ** 32 should round-trip through banana without changing value and should come out represented as an C{int} (regardless of the type which was encoded). i�' N) r. r% r= r, r r r4 �assertIsInstance�intr2 r r r �test_int� s zBananaTests.test_intc C s( | j j}|d }d| d }|d }|S )N� � � )r. � prefixLimit)r �bytes�bits�largest�smallestr r r � _getSmallest� s zBananaTests._getSmallestc C � | � � }| �tj| jj|� dS )zz Test that a long above the implementation-specific limit is rejected as too large to be encoded. N)rW rF r rG r. r% )r rV r r r �test_encodeTooLargeLong� � z#BananaTests.test_encodeTooLargeLongc C �j | � � }| j�| jjd � | j�|� | j�� }| j�d� | j�| jjd � | �t j | jj |� dS )zz Test that a long above the implementation specific limit is rejected as too large to be decoded. rP r N) rW r. �setPrefixLimitrR r% r, r �truncaterF r rG r= )r rV �encodedr r r �test_decodeTooLargeLong� � z#BananaTests.test_decodeTooLargeLongc C s | � � S r5 )rW r2 r r r � _getLargest� s zBananaTests._getLargestc C rX )z� Test that a negative long below the implementation-specific limit is rejected as too small to be encoded. N)ra rF r rG r. r% )r rU r r r �test_encodeTooSmallLong� rZ z#BananaTests.test_encodeTooSmallLongc C r[ )z� Test that a negative long below the implementation specific limit is rejected as too small to be decoded. rP r N) ra r. r\ rR r% r, r r] rF r rG r= )r rU r^ r r r �test_decodeTooSmallLong� r` z#BananaTests.test_decodeTooSmallLongc C �0 | j �d� | j �| j�� � | �| jd� d S )Ni� �r. r% r= r, r r r4 r2 r r r � test_integer� r? zBananaTests.test_integerc C rd )Ni ���re r2 r r r � test_negative� r? zBananaTests.test_negativec C rd )Ng ��@re r2 r r r � test_float� r? zBananaTests.test_floatc C sX ddddgddgddd d d ggd gg g}| j �|� | j �| j�� � | �| j|� d S ) NrQ rP � � � �>@皙���D@� � six� seven� eight� � re �r �foor r r � test_list� s � zBananaTests.test_listc C sl ddddgddgddd d d ggd gt jd t jd t jd g }| j�|� | �| j�� � | �| j|� dS )zj Test feeding the data byte per byte to the receiver. Normally data is not split. rQ rP ri rj rk rl rm rn ro rp rq rr ���N) �sys�maxsizer. r% �feedr, r r r4 rs r r r � test_partial� s � zBananaTests.test_partialc C s t |�D ]}| j�|� qdS )z� Feed the data byte per byte to the receiver. @param data: The bytes to deliver. @type data: L{bytes} N)r r. r= )r �data�byter r r ry s �zBananaTests.feedc C � d}| � tj| j|� d S )Ns ��rF r rG ry �r r{ r r r �test_oversizedList � z BananaTests.test_oversizedListc C r} )Ns �r~ r r r r �test_oversizedString! r� z BananaTests.test_oversizedStringc C s. d}z | j �|� W d S tjy Y d S w )Ns �)r. r= r rG )r � crashStringr r r �test_crashString& s �z BananaTests.test_crashStringc C rd )N� �re r2 r r r �test_crashNegativeLong9 s z"BananaTests.test_crashNegativeLongc C sP d}d}d}| � | �|d �d| � | � | �|d �d| � | � | �|d �d | � d }| � | �|d �d | � | � | �|d �d | � | � | �|d �d| � d}| � | �|d �d| � | � | �|d �d | � | � | �|d �d� d}| � | �|d �d | � | � | �|d �d| � | � | �|d �d| � dS )z� Test that integers below the maximum C{INT} token size cutoff are serialized as C{INT} or C{NEG} and that larger integers are serialized as C{LONGINT} or C{LONGNEG}. i���r� s �rP � }rQ � ~r � s �� � ri � s �s �s �� N)r r* )r � baseIntIn� baseNegIn� baseIntOut�baseLongIntOut� baseNegOut�baseLongNegOutr r r �test_sizedIntegerTypesE s$ z"BananaTests.test_sizedIntegerTypesN)r r r r: r> rB rD rE rA rN rW rY r_ ra rb rc rf rg rh ru rz ry r� r� r� r� r� r r r r r< f s2 r< c @ sZ e Zd ZdZdZeejje f�ej Z ed�ej Z dd� Z dd� Z dd � Zd d � Zd S ) � DialectTestsz2 Tests for Banana's handling of dialects. s remote)�z c C s | � t| jj| j� dS )z| If no dialect has been selected and a PB VOCAB item is received, L{NotImplementedError} is raised. N)rF �NotImplementedErrorr. r= � legalPbItemr2 r r r �test_dialectNotSetl s z DialectTests.test_dialectNotSetc C s. t | jd� | j�| j� | �| j| j� dS )zS If the PB dialect has been selected, a PB VOCAB item is accepted. � pbN)r" r. r= r� r r4 �vocabr2 r r r �test_receivePbs s zDialectTests.test_receivePbc C s$ t | jd� | �t| jj| j� dS )z� If the PB dialect has been selected and an unrecognized PB VOCAB item is received, L{banana.Banana.dataReceived} raises L{KeyError}. r� N)r" r. rF �KeyErrorr= � illegalPbItemr2 r r r �test_receiveIllegalPb{ s z"DialectTests.test_receiveIllegalPbc C s2 t | jd� | j�| j� | �| j| j�� � dS )zl if pb dialect is selected, the sender must be able to send things in that dialect. r� N)r" r. r% r� r r� r, r r2 r r r � test_sendPb� s zDialectTests.test_sendPbN)r r r r: r� rS r r; �outgoingVocabulary�VOCABr� r� r� r� r� r� r r r r r� c s r� c @ s e Zd ZdZdd� ZdS )�GlobalCoderTestszM Tests for the free functions L{banana.encode} and L{banana.decode}. c C s0 d}| � tjtj|� d}| �t�|�d� dS )zJ Calls to L{banana.decode} are independent of each other. sB �s �rQ N)rF r rG �decoder )r � undecodable� decodabler r r �test_statelessDecode� s z%GlobalCoderTests.test_statelessDecodeN)r r r r: r� r r r r r� � s r� )rw � functoolsr r, r �twisted.internetr r �twisted.pythonr �twisted.python.compatr �twisted.spreadr �twisted.test.proto_helpersr �twisted.trial.unittestr �_maxintr r" r* r+ r< r� r� r r r r �<module> s$ ~*PK Mb�Z ��J� � 0 spread/test/__pycache__/__init__.cpython-310.pycnu �[��� o �bn � @ s d Z dS )z Tests for L{twisted.spread}. N)�__doc__� r r �>/usr/lib/python3/dist-packages/twisted/spread/test/__init__.py�<module> s PK Mb�Z��8�zS zS 2 spread/test/__pycache__/test_jelly.cpython-310.pycnu �[��� o �boJ � @ s" d Z ddlZddlZddlmZmZmZ ddlmZ ddl m Z ddl m Z G dd� dej �ZG d d � d �Zd d � ZG d d� d�ZG dd� d�ZG dd� d�ZG dd� d�ZG dd� d�Zdd� ZG dd� de �ZG dd � d e �ZG d d � d ejej�ZG d d � d ejej�Z G d!d"� d"e �Z dS )#z/ Test cases for L{jelly} object serialization. � N)�banana�jelly�pb)�StringTransport)�unittest)�TestCasec @ s e Zd ZdZdZddd�ZdS )�TestNodezD An object to test jellyfying of new style class instances. � Nc C s4 |r|j d | _ |j�| � nd| _ || _g | _d S )N� )�id�children�append�parent)�selfr � r �@/usr/lib/python3/dist-packages/twisted/spread/test/test_jelly.py�__init__ s zTestNode.__init__�N)�__name__� __module__� __qualname__�__doc__� classAttrr r r r r r s r c @ � e Zd ZdZdd� ZdS )�A� Dummy class. c C � dS �z; Method to be used in serialization tests. Nr �r r r r �amethod( � z A.amethodN)r r r r r r r r r r # � r c C r )z: A dummy function to test function serialization. Nr r r r r �afunc. r r" c @ r )�Br c C r r r r r r r �bmethod9 r z B.bmethodN)r r r r r$ r r r r r# 4 r! r# c @ r )�Cr c C r r r r r r r �cmethodD r z C.cmethodN)r r r r r& r r r r r% ? r! r% c @ s e Zd ZdZdS )�Dz Dummy new-style class. N)r r r r r r r r r' J s r' c @ s. e Zd ZdZdZd dd�Zdd� Zdd � ZdS ) �Ez+ Dummy new-style class with slots. ��x�yNc C � || _ || _d S r r) �r r* r+ r r r r W � z E.__init__c C s | j | jd�S )Nr) r) r r r r � __getstate__[ � zE.__getstate__c C s |d | _ |d | _d S )Nr* r+ r) �r �stater r r � __setstate__^ s zE.__setstate__)NN)r r r r � __slots__r r/ r3 r r r r r( P s r( c @ s e Zd Zdd� Zdd� ZdS )�SimpleJellyTestc C r, r r) r- r r r r d r. zSimpleJellyTest.__init__c C s | j |j kS r )�__dict__�r �otherr r r � isTheSameAsh s zSimpleJellyTest.isTheSameAsN)r r r r r9 r r r r r5 c s r5 c C s8 t � |�}t�|�}t�|�}t �|�}| �||� dS )zt Verify that the given object round-trips through jelly & banana and comes out equivalent to the input. N)r r �encode�decode�unjelly� assertEqual)�testCase� toSerialize�jellied�encoded�decoded� unjelliedr r r �jellyRoundTripl s rD c @ s e Zd ZdZdg d�g d�g d�g d�gZdd� Zd d � Zd d � Zd d� Zdd� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Z d7d8� Z d9d:� Z d;d<� Z d=d>� Z d?d@� Z!dAdB� Z"dCS )D� JellyTestsz� Testcases for L{jelly} module serialization. @cvar decimalData: serialized version of decimal data, to be used in tests. @type decimalData: L{list} s list)� decimali� ���)rF r r )rF �@� r )rF i������c C sJ t � |�}t �� }|�� t �||� |j�|� | �t jt j||� dS )z� Helper test method to test security options for a type. @param inputList: a sample input for the type. @type inputList: L{list} @param atom: atom identifier for the type. @type atom: L{str} N)r �SecurityOptions�allowBasicTypesr< � allowedTypes�pop� assertRaises� InsecureJelly)r � inputList�atom�c�tasterr r r � _testSecurity� s zJellyTests._testSecurityc C sV t � }t� }t� }|j|_||_tj}t`z| �ttj t�|�� W |t_dS |t_w )z� If a class change after an instance has been created, L{jelly.unjelly} shoud raise a C{TypeError} when trying to unjelly the instance. N) r r# r% r& r$ �arN � TypeErrorr r< )r rU �brR � savecmethodr r r �test_methodsNotSelfIdentity� s z&JellyTests.test_methodsNotSelfIdentityc C s` t � }d|_t � }||_||_t�|�}t�|�}| �|t � | �|j|j� | �|jd� dS )z� Test that a new style class can be jellied and unjellied with its objects and attribute values preserved. r N) r' r* �n2�n3r r< �assertIsInstance�assertIsr= )r �nrZ rR �mr r r � test_newStyle� s zJellyTests.test_newStylec C s> t � }d|_t�|�}t�|�}| �|t � | �|jd� dS )z� A class defined with I{slots} can be jellied and unjellied with the values for its attributes preserved. r N)r( r* r r< r\ r= )r r^ rR r_ r r r �test_newStyleWithSlots� s z!JellyTests.test_newStyleWithSlotsc C �& t g}t�t�|��}| �||� dS )zm Test that a new style class type can be jellied and unjellied to the original type. N)r' r r< r= �r �t�rr r r �test_typeNewStyle� � z JellyTests.test_typeNewStylec C rb )ze Test that a builtin type can be jellied and unjellied to the original type. N)�strr r< r= rc r r r �test_typeBuiltin� rg zJellyTests.test_typeBuiltinc C sP t j �� }t j �� | }||g}t�|�}t�|�}| �||� | �||� dS )z� Jellying L{datetime.timedelta} instances and then unjellying the result should produce objects which represent the values of the original inputs. N)�datetime�nowr r< r= � assertIsNot)r �dtn�dtdrP rR �outputr r r � test_dateTime� s zJellyTests.test_dateTimec C sj t �ddd�}t �dddd�}t j �||�}|t � ddd� }t| |� t| |� t| |� t| |� d S ) z� Jellying L{datetime.time}, L{datetime.timedelta}, L{datetime.datetime}, and L{datetime.date} objects should result in jellied objects which can be serialized and unserialized with banana. i� � � r � � iX � N)rj �date�time�combinerD )r � sampleDate� sampleTime�sampleDateTime�sampleTimeDeltar r r �test_bananaTimeTypes� s z JellyTests.test_bananaTimeTypesc C sT t �d�t �d�t �d�t �d�g}t�|�}t�|�}| �||� | �||� dS )z� Jellying L{decimal.Decimal} instances and then unjellying the result should produce objects which represent the values of the original inputs. �9.95r rH �-78.901N)�decimal�Decimalr r< r= rl )r rP rR ro r r r � test_decimal� s � zJellyTests.test_decimalc C s@ t �d�t �d�t �d�t �d�g}t�| j�}| �||� dS )a Unjellying the s-expressions produced by jelly for L{decimal.Decimal} instances should result in L{decimal.Decimal} instances with the values represented by the s-expressions. This test also verifies that L{decimalData} contains valid jellied data. This is important since L{test_decimalMissing} re-uses L{decimalData} and is expected to be unable to produce L{decimal.Decimal} instances even though the s-expression correctly represents a list of them. r~ r rH r N)r� r� r r< � decimalDatar= )r �expectedro r r r �test_decimalUnjelly s � z JellyTests.test_decimalUnjellyc C s t �d�g}| �|d� dS )z� By default, C{decimal} objects should be allowed by L{jelly.SecurityOptions}. If not allowed, L{jelly.unjelly} should raise L{jelly.InsecureJelly} when trying to unjelly it. r~ rF N)r� r� rT �r rP r r r �test_decimalSecurity s z JellyTests.test_decimalSecurityc C s6 h d�g}t �t � |��}| �||� | �||� dS )z� Jellying C{set} instances and then unjellying the result should produce objects which represent the values of the original inputs. � r � ru N)r r< r= rl �r rP ro r r r �test_set& s zJellyTests.test_setc C s: t g d��g}t�t�|��}| �||� | �||� dS )z� Jellying L{frozenset} instances and then unjellying the result should produce objects which represent the values of the original inputs. �r r� ru N)� frozensetr r< r= rl r� r r r �test_frozenset1 s zJellyTests.test_frozensetc C s h d�g}| � |d� dS )z� By default, C{set} objects should be allowed by L{jelly.SecurityOptions}. If not allowed, L{jelly.unjelly} should raise L{jelly.InsecureJelly} when trying to unjelly it. r� s setN)rT r� r r r �test_setSecurity< s zJellyTests.test_setSecurityc C s t g d��g}| �|d� dS )z� By default, L{frozenset} objects should be allowed by L{jelly.SecurityOptions}. If not allowed, L{jelly.unjelly} should raise L{jelly.InsecureJelly} when trying to unjelly it. r� s frozensetN)r� rT r� r r r �test_frozensetSecurityE s z!JellyTests.test_frozensetSecurityc C sN | � tdd��tdd��� tdd�}t�|�}t�|�}| � |�|�� dS )z% Simplest test case. rU rW r r� N)� assertTruer5 r9 r r< )r rU �cerealrW r r r � test_simpleN s � zJellyTests.test_simplec C s� g }|}|� |� |� |� | �|d |d � | �|d d |� t�|�}t�|�}| �|d |d � | �|d d |� dS )zJ Test to make sure that objects retain identity properly. r r N)r r] r r< )r r* r+ �s�zr r r � test_identityZ s zJellyTests.test_identityc C s8 d}t �t � |��}| �||� | �t|�t|�� d S )N�blah)r r< r= �typer- r r r �test_stri s zJellyTests.test_strc C sb g }d|i|f}|� |� t�|�}t�|�}| �|d d |d � | �|d d d |� d S )N�listr r �r r r< r] )r �reref� toplevelTupler� r� r r r �test_stressReferenceso s z JellyTests.test_stressReferencesc C sF g }|f}|� |f� t�|�}t�|�}| �|d d d |� d S �Nr r� )r rU rd r� r� r r r �test_moreReferencesx s z JellyTests.test_moreReferencesc C s* t �� }t � i �}| �t jt j||� dS )z@ Test for type-level security of serialization. N)r rJ rN rO r< )r rS �dctr r r �test_typeSecurity� s z JellyTests.test_typeSecurityc C s t �t�}| �t|� d S r )r r< r' r] )r �ujr r r �test_newStyleClasses� s z JellyTests.test_newStyleClassesc C s~ t � }t�t�|�� t�t�|j�� tg d�td� td�ddddt tddit jg }|D ]}| �|t�t�|��� q.dS )zA Test for all types currently supported in jelly r� r �testg�����L4@NrU )r r r< r r" �boolr r= )r rU �items�ir r r �test_lotsaTypes� s& ��zJellyTests.test_lotsaTypesc C sx G dd� d�a t� }t |�}t |�}t ||f�}||||||d|i}t�t�|��d }| �|jd j|jd j� d S )Nc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) � TupleStatec S � || _ d S r �r8 r7 r r r r � � zTupleState.__init__c S s | j fS r r� r r r r r/ � s zTupleState.__getstate__c S s |d | _ d S r� r� r1 r r r r3 � r0 zTupleState.__setstate__c S s t | j�S r )�hashr8 r r r r �__hash__� r� zTupleState.__hash__N)r r r r r/ r3 r� r r r r r� � s r� �t3r r )r� r r r< r] r8 )r rU �t1�t2r� �d�t3primer r r � test_setState� s zJellyTests.test_setStatec C s� t �� }|�tt� t� }t� }t� }||_||_||_||_t � ||�}t � ||�}| � |jt j � t � |�}| � t j t j ||� | �|j|jd� t � t|�}t � ||�}| �|td| � dS )zA Test for class-level security of serialization. zIdentity mismatchzA came back: %sN)r rJ �allowInstancesOfr r# r% rW rR r* r< r\ � UnpersistablerN rO r] )r rS rU rW rR �friendlyr* �meanr r r �test_classSecurity� s$ z JellyTests.test_classSecurityc C s\ G dd� dt j�}t �|t j� |� }d|_t �t � |��}| �|jd� | �|t j� dS )zr Test that if Unjellyable is used to deserialize a jellied object, state comes out right. c @ � e Zd ZdS )z7JellyTests.test_unjellyable.<locals>.JellyableTestClassN�r r r r r r r �JellyableTestClass� � r� �valueN)r � Jellyable�setUnjellyableForClass� Unjellyable� attributer< r= r\ )r r� �inputro r r r �test_unjellyable� s zJellyTests.test_unjellyablec C s� i dg}|fdd�}|fdd�}t dd�}t dd�}t d d �}||_||_||_tj||d �}tj||d �}| �|j|jj� | �|d d� | �|j|jd� d S )Nr c S s, |d d |d< | |d |d < t |d �S )Nr r )rh )�obj�jel�perstr r r �persistentStore� s z:JellyTests.test_persistentStorage.<locals>.persistentStorec S s t | �}|d | S r� )�int)�pidstr�unjr� �pidr r r �persistentLoad� s z9JellyTests.test_persistentStorage.<locals>.persistentLoadr� ru r rt � )r� )r� r z persistentStore was not called.z$Persistent storage identity failure.)r5 rW rR r r< r] r� ) r r� r� r� rU rW rR r� r* r r r �test_persistentStorage� s z!JellyTests.test_persistentStoragec C sB t � }t |�}t |� t |� t�|�}t�|�}| �||� d S r )r r r< �_check_newstyle)r r^ �n1r� r_ r r r � test_newStyleClassesAttributes s z)JellyTests.test_newStyleClassesAttributesc C sl | � |j|j� | � |jd� | � |jd� | � t|j�t|j�� t|j|j�D ] \}}| �||� q)d S )Nr )r= r r �lenr �zipr� )r rU rW r* r+ r r r r� s �zJellyTests._check_newstylec C s` t �� }t �� }|�t� � tj||d�}t �� }|�t� � tj||d�}| �|j|j � dS )a A L{pb.Referenceable} instance jellies to a structure which unjellies to a L{pb.RemoteReference}. The C{RemoteReference} has a I{luid} that matches up with the local object key in the L{pb.Broker} which sent the L{Referenceable}. ��invokerN) r � Referenceable�Broker�makeConnectionr r r< �assertIn�luid� localObjects)r �ref� jellyBroker�j� unjellyBrokerr� r r r �test_referenceable s z JellyTests.test_referenceableN)#r r r r r� rT rY r` ra rf ri rp r} r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r rE x sL � rE c @ s e Zd ZdZdd� Zdd� ZdS )�JellyDeprecationTestsz+ Tests for deprecated Jelly things c C sP t j | �| jg�}| �t|�d� | �|d d d� | �|d d t� dS )zD L{jelly.instance_atom} is deprecated since 15.0.0. r r �messagezltwisted.spread.jelly.instance_atom was deprecated in Twisted 15.0.0: instance_atom is unused within Twisted.�categoryN)r � instance_atom� flushWarnings�test_deprecatedInstanceAtomr= r� �DeprecationWarning�r �warningsr r r r� . s �z1JellyDeprecationTests.test_deprecatedInstanceAtomc C sZ t �dddgdgg� | �� }| �t|�d� | �|d d d� | �|d d t� d S ) zI Unjellying the instance atom is deprecated with 15.0.0. �instance�classz twisted.spread.test.test_jelly.A� dictionaryr r r� ztUnjelly support for the instance atom is deprecated since Twisted 15.0.0. Upgrade peer for modern instance support.r� N)r r< r� r= r� r� r� r r r �%test_deprecatedUnjellyingInstanceAtom< s � �z;JellyDeprecationTests.test_deprecatedUnjellyingInstanceAtomN)r r r r r� r� r r r r r� ) s r� c @ � e Zd Zdd� ZdS )�ClassAc C s t | �| _d S r )�ClassBr� r r r r r N r0 zClassA.__init__N�r r r r r r r r r� M � r� c @ r� )r� c C r� r )r� )r r� r r r r S r� zClassB.__init__Nr� r r r r r� R r� r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �CircularReferenceTestszN Tests for circular references handling in the jelly/unjelly process. c C s@ t �tt� t �tt� t �t � t� ��}| �|jj|d� d S )N�,Identity not preserved in circular reference)r r� r� r� r< r] r� )r rU r r r �test_simpleCircle\ s z(CircularReferenceTests.test_simpleCirclec C sf G dd� d�}|� }d |_ t� }t�tt� t�tt� tj||d�}t�|�}| �|jj|d� d S )Nc @ r� )zHCircularReferenceTests.test_circleWithInvoker.<locals>.DummyInvokerClassNr� r r r r �DummyInvokerClassc r� r� r� r� )�serializingPerspectiver� r r� r� r< �failUnlessIdenticalr� )r r� � dummyInvoker�a0r� �a1r r r �test_circleWithInvokerb s �z-CircularReferenceTests.test_circleWithInvokerc C sP t � }t|d�}|�|� t�t�|��}| �|jt � | �t|j�|g� dS )z� Check that a C{set} can contain a circular reference and be serialized and unserialized without losing the reference. N) �setr5 �addr r< r\ r* r= r� )r r� rU �resr r r r� q s z CircularReferenceTests.test_setc C sP t dd�}t|g�}||_t�t�|��}| �|jt� | �t|j�|g� dS )z� Check that a L{frozenset} can contain a circular reference and be serialized and unserialized without losing the reference. N)r5 r� r* r r< r\ r= r� )r rU r� r r r r r� } s z%CircularReferenceTests.test_frozensetN)r r r r r� r� r� r� r r r r r� W s r� ) r rj r� �twisted.spreadr r r �twisted.test.proto_helpersr � twisted.trialr �twisted.trial.unittestr r� r r r" r# r% r' r( r5 rD rE r� �Copyable� RemoteCopyr� r� r� r r r r �<module> s0 4$PK Mb�Zm�08& & / spread/test/__pycache__/test_pb.cpython-310.pycnu �[��� o �b8� � @ sr d Z ddlZddlZddlZddlZddlZddlmZ ddlm Z ddl m Z ddl mZmZ ddlmZmZmZ ddlmZmZ dd lmZmZmZmZ dd l m Z m Z m Z dd l m!Z! dd l"m#Z# dd l$m%Z%m&Z& ddl'm(Z( ddl)m*Z*m+Z+m,Z,m-Z- ddl.m/Z/ ddl0m1Z1 G dd� de+j2�Z3G dd� de+j4�Z5eej6�G dd� d��Z7G dd� d�Z8dd� Z9G d d � d �Z:G d d � d e/�Z;d�d d!�Z<G d"d#� d#e+j=�Z>G d$d%� d%e+j=�Z?G d&d'� d'e+j@�ZAG d(d)� d)e+jB�ZCe+�DeAeC� G d*d+� d+e+j@�ZEd,d-� ZFe+�GeEeF� G d.d/� d/e+j=�ZHG d0d1� d1e+jI�ZJG d2d3� d3e+j=�ZKG d4d5� d5e+jI�ZLG d6d7� d7e+jM�ZNe+�DeLeN� G d8d9� d9e+jM�ZOe+�DeJeO� G d:d;� d;e+j=�ZPG d<d=� d=e+j=�ZQG d>d?� d?e+j=�ZRG d@dA� dAe+j=�ZSG dBdC� dCe+j@e+jB�ZTe+�DeTeT� G dDdE� dEe+j@e+jB�ZUe+�DeUeU� G dFdG� dGe+jIe+jM�ZVe+�DeVeV� G dHdI� dIe+jW�ZXG dJdK� dKe+jW�ZYG dLdM� dMe1jZ�Z[G dNdO� dOe+j\�Z]G dPdQ� dQe1j^�Z_G dRdS� dSe1j^�Z`dTZadabdacdUdV� ZdG dWdX� dXe+j=�ZeG dYdZ� dZe+j=�ZfG d[d\� d\e1j^�ZgG d]d^� d^e,jh�ZiG d_d`� d`e,jj�ZkG dadb� dbe+j=�Zle+�Deiek� G dcdd� dde1j^�ZmG dedf� dfen�ZoG dgdh� dhe+j@�ZpG didj� dje+j=�ZqG dkdl� dle-jr�Zsee+jt�G dmdn� dne+j4��ZuG dodp� dp�ZvG dqdr� dre+j2�ZwG dsdt� dtev�ZxG dudv� dve1j^�ZyG dwdx� dxe1j^�Zzee+jt�G dydz� dz��Z{G d{d|� d|e1j^�Z|G d}d~� d~e�Z}ee}�G dd�� d���Z~G d�d�� d�e1j^�ZG d�d�� d�e1j^�Z�dS )�z� Tests for Perspective Broker module. TODO: update protocol level tests to use new connection API, leaving only specific tests for old API. � N)�deque)�BytesIO)�Dict)� Interface� implementer)�checkers� credentials�portal)�UnauthorizedLogin�UnhandledCredentials)�address�main�protocol�reactor)�Deferred� gatherResults�succeed)�ConnectionRefusedError)�WrappingFactory)�failure�log)� iterbytes)�jelly�pb�publish�util)�_FakeConnector)�unittestc @ � e Zd Zdd� ZdS )�Dummyc C s t |t�rdS dS )Nz hello world!zgoodbye, cruel world!)� isinstance�DummyPerspective��self�user� r% �=/usr/lib/python3/dist-packages/twisted/spread/test/test_pb.py�view_doNothing( s zDummy.view_doNothingN)�__name__� __module__� __qualname__r' r% r% r% r& r ' � r c @ � e Zd ZdZdd� ZdS )r! zE An L{IPerspective} avatar which will be used in some tests. c C � t � S �N)r �r# r% r% r& � perspective_getDummyViewPoint4 � z.DummyPerspective.perspective_getDummyViewPointN)r( r) r* �__doc__r0 r% r% r% r& r! / � r! c @ r )� DummyRealmc G s. |D ]}|t ju r|t|�dd� f S qd S )Nc S � d S r. r% r% r% r% r& �<lambda>= � z*DummyRealm.requestAvatar.<locals>.<lambda>)r � IPerspectiver! )r# �avatarId�mind� interfaces�ifacer% r% r& � requestAvatar: s ��zDummyRealm.requestAvatarN)r( r) r* r= r% r% r% r& r4 8 s r4 c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �IOPumpz� Utility to pump data between clients and servers for protocol testing. Perhaps this is a utility worthy of being in protocol.py? c C s || _ || _|| _|| _d S r. )�client�server�clientIO�serverIO)r# r@ rA rB rC r% r% r& �__init__G s zIOPump.__init__c C sN d| _ t�� d }| j s!| �� r#t�� |krdS | j s%| �� sdS dS dS dS )z� Pump until there is no more input or output or until L{stop} is called. This does not run any timers, so don't use it with any code that calls reactor.callLater. F� N)�_stop�time�pump)r# �timeoutr% r% r& �flushM s �z IOPump.flushc C � d| _ dS )zd Stop a running L{flush} operation, even if data remains to be transferred. TN)rF r/ r% r% r& �stopZ � z IOPump.stopc C s� | j �d� | j�d� | j �� }| j�� }| j �d� | j�d� | j �� | j�� | jj�� | jj�� t |�D ]}| j� |� q<t |�D ]}| j� |� qI|sV|rXdS dS )zX Move data back and forth. Returns whether any data was moved. r � ) rB �seekrC �read�truncater@ � transport�_checkProducerrA r � dataReceived)r# �cData�sData�byter% r% r& rH a s" z IOPump.pumpN)r( r) r* r2 rD rJ rL rH r% r% r% r& r? @ s r? c s� d}� � |�}|� |�}t� }t� }|�t�|�� |�t�|�� t||||�}dd� } � fdd�} | �| |� | �| |� | �| � |�� |||fS )al Create a server and a client and connect the two with an L{IOPump}. @param test: the test case where the client and server will be used. @type test: L{twisted.trial.unittest.TestCase} @param clientFactory: The factory that creates the client object. @type clientFactory: L{twisted.spread.pb.PBClientFactory} @param serverFactory: The factory that creates the server object. @type serverFactory: L{twisted.spread.pb.PBServerFactory} @return: a 3-tuple of (client, server, pump) @rtype: (L{twisted.spread.pb.Broker}, L{twisted.spread.pb.Broker}, L{IOPump}) )� 127.0.0.1c S s | j s| �t�tj�� d S d S r. )� disconnected�connectionLostr �Failurer �CONNECTION_DONE)�brokerr% r% r& �maybeDisconnect� s �z/connectServerAndClient.<locals>.maybeDisconnectc s � j d t�tj�d� d S )N)� connector�reason)�clientConnectionLostr r[ r r\ r% �� clientFactoryr% r& �disconnectClientFactory� s �z7connectServerAndClient.<locals>.disconnectClientFactory)� buildProtocol�StringIO�makeConnectionr � FileWrapperr? � addCleanuprH ) �testrc � serverFactory�addr� clientBroker� serverBroker�clientTransport�serverTransportrH r^ rd r% rb r& �connectServerAndClient{ s rq c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � _ReconnectingFakeConnectorStatez� Manages connection notifications for a L{_ReconnectingFakeConnector} instance. @ivar notifications: pending L{Deferreds} that will fire when the L{_ReconnectingFakeConnector}'s connect method is called c C � t � | _d S r. )r � notificationsr/ r% r% r& rD � � z(_ReconnectingFakeConnectorState.__init__c C s t � }| j�|� |S )z� Connection notification. @return: A L{Deferred} that fires when this instance's L{twisted.internet.interfaces.IConnector.connect} method is called. @rtype: L{Deferred} )r rt � appendleft)r# �notifierr% r% r& �notifyOnConnect� s z/_ReconnectingFakeConnectorState.notifyOnConnectc C s$ | j r| j �� �| � | j sdS dS )z1 Fire all pending notifications. N)rt �pop�callbackr/ r% r% r& � notifyAll� s �z)_ReconnectingFakeConnectorState.notifyAllN)r( r) r* r2 rD rx r{ r% r% r% r& rr � s rr c s, e Zd ZdZ� fdd�Z� fdd�Z� ZS )�_ReconnectingFakeConnectorzc A fake L{IConnector} that can fire L{Deferred}s when its C{connect} method is called. c s t � �|� || _dS )a @param address: An L{IAddress} provider that represents this connector's destination. @type address: An L{IAddress} provider. @param state: The state instance @type state: L{_ReconnectingFakeConnectorState} N)�superrD �_state)r# r �state�� __class__r% r& rD � s z#_ReconnectingFakeConnector.__init__c s t � �� | j�� dS )zM A C{connect} implementation that calls C{reconnectCallback} N)r} �connectr~ r{ r/ r� r% r& r� � s z"_ReconnectingFakeConnector.connect)r( r) r* r2 rD r� � __classcell__r% r% r� r& r| � s r| c C s> |pt � }tjdd�}t�t�||g��}t�� }t| ||�S )z� Connect a client and server L{Broker} together with an L{IOPump} @param realm: realm to use, defaulting to a L{DummyRealm} @returns: a 3-tuple (client, server, pump). � guest)�guest) r4 r �'InMemoryUsernamePasswordDatabaseDontUser �PBServerFactoryr �Portal�PBClientFactoryrq )rj �realm�checkerrk rc r% r% r& �connectedServerAndClient� s r� c @ � e Zd Zdd� Zdd� ZdS )� SimpleRemotec C � || _ |d S �NrN )�arg�r# r� r% r% r& � remote_thunk� � zSimpleRemote.remote_thunkc C � t � �r. )� Exceptionr� r% r% r& � remote_knuth� r1 zSimpleRemote.remote_knuthN)r( r) r* r� r� r% r% r% r& r� � s r� c @ r )� NestedRemotec C r- r. )r� r/ r% r% r& �remote_getSimple r1 z NestedRemote.remote_getSimpleN)r( r) r* r� r% r% r% r& r� r+ r� c @ r )� SimpleCopyc C � d| _ ddi| _dg| _d S �NrN �Hello�Worldrj ��x�y�zr/ r% r% r& rD � zSimpleCopy.__init__N�r( r) r* rD r% r% r% r& r� r+ r� c @ � e Zd ZdS )�SimpleLocalCopyN�r( r) r* r% r% r% r& r� � r� c @ s. e Zd ZU dZi Zeed f ed< dd� ZdS )�SimpleFactoryCopyz] @cvar allIDs: hold every created instances of this class. @type allIDs: C{dict} �allIDsc C s || _ | tj|< d S r. )�idr� r� )r# r� r% r% r& rD s zSimpleFactoryCopy.__init__N) r( r) r* r2 r� r �int�__annotations__rD r% r% r% r& r� s r� c C sZ | � dd�}|du rtdt| �� ���|tjvr tdtj� ���tj| }|s+td��|S )zl Factory of L{SimpleFactoryCopy}, getting a created instance given the C{id} found in C{state}. r� Nz&factory copy state has no 'id' member zfactory class has no ID: z&factory method found no object with id)�get� RuntimeError�reprr� r� )r �stateId�instr% r% r& �createFactoryCopy! s r� c @ r� )� NestedCopyc C r- r. )r� r/ r% r% r& �remote_getCopy5 r1 zNestedCopy.remote_getCopyc C s t |�S r. )r� )r# �valuer% r% r& �remote_getFactory8 � z NestedCopy.remote_getFactoryN)r( r) r* r� r� r% r% r% r& r� 4 � r� c @ r )� SimpleCachec C r� r� r� r/ r% r% r& � __init___= r� zSimpleCache.__init___N)r( r) r* r� r% r% r% r& r� < r+ r� c @ r� )�NestedComplicatedCachec C rs r. )� VeryVeryComplicatedCacheable�cr/ r% r% r& rD D ru z NestedComplicatedCache.__init__c C � | j S r. )r� r/ r% r% r& �remote_getCacheG r1 z&NestedComplicatedCache.remote_getCacheN)r( r) r* rD r� r% r% r% r& r� C r� r� c @ �, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) r� c C s d| _ d| _d| _d S )NrN � � �r� r� �foor/ r% r% r& rD L s z%VeryVeryComplicatedCacheable.__init__c C s d| _ | j�dd� d S )N� r� )r� �observer� callRemoter/ r% r% r& �setFoo4Q � z$VeryVeryComplicatedCacheable.setFoo4c C s || _ | j| j| jd�S )Nr� )r� r� r� r� �r# � perspectiver� r% r% r& � getStateToCacheAndObserveForU r� z9VeryVeryComplicatedCacheable.getStateToCacheAndObserveForc C s, t �d� |�d� || jkrd | _d S d S )Nzstopped observing�end)r �msgr� r� r� r% r% r& �stoppedObservingY s �z-VeryVeryComplicatedCacheable.stoppedObservingN)r( r) r* rD r� r� r� r% r% r% r& r� K s r� c @ r� )�RatherBaroqueCachec C � || _ d S r. �r� )r# �newFoor% r% r& � observe_fooa � z RatherBaroqueCache.observe_fooc C s t �d� d S )Nzthe end of things)r r� r/ r% r% r& � observe_endd � z RatherBaroqueCache.observe_endN)r( r) r* r� r� r% r% r% r& r� ` r� r� c @ r� ) �SimpleLocalCachec C � | j �|� d S r. )�__dict__�update)r# r r% r% r& �setCopyableStatel � z!SimpleLocalCache.setCopyableStatec C r� r. )�checkr/ r% r% r& � checkMethodo r1 z SimpleLocalCache.checkMethodc C s | S r. r% r/ r% r% r& � checkSelfr � zSimpleLocalCache.checkSelfc C � dS r� r% r/ r% r% r& r� u r� zSimpleLocalCache.checkN)r( r) r* r� r� r� r� r% r% r% r& r� k � r� c @ �$ e Zd Zdd� Zdd� Zdd� ZdS )� NestedCachec C rs r. )r� r� r/ r% r% r& rD } ru zNestedCache.__init__c C s | j | j gS r. �r� r/ r% r% r& r� � ru zNestedCache.remote_getCachec C s | j |u S r. r� �r# �cacher% r% r& �remote_putCache� r� zNestedCache.remote_putCacheN)r( r) r* rD r� r� r% r% r% r& r� | s r� c @ r� ) � Observablec C s g | _ d S r. )� observersr/ r% r% r& rD � r� zObservable.__init__c C r� r. )r� �append�r# �obsr% r% r& �remote_observe� r� zObservable.remote_observec C r� r. )r� �remover� r% r% r& �remote_unobserve� r� zObservable.remote_unobservec C s | j D ] }|�d| |� qd S )N�notify)r� r� )r# �objr� r% r% r& r� � s �zObservable.notifyN)r( r) r* rD r� r� r� r% r% r% r& r� � r� r� c @ r� ) �DeferredRemotec C � d| _ d S )Nr ��runr/ r% r% r& rD � r� zDeferredRemote.__init__c C r� r� r� r� r% r% r& �runMe� r� zDeferredRemote.runMec C s J d��)Nr zshouldn't have been run!r% r� r% r% r& � dontRunMe� r� zDeferredRemote.dontRunMec C s t � }|�| j| j� || _|S )zo Return a L{Deferred} to be fired on client side. When fired, C{self.runMe} is called. )r � addCallbacksr� r� �d)r# r� r% r% r& �remote_doItLater� s z DeferredRemote.remote_doItLaterN)r( r) r* rD r� r� r� r% r% r% r& r� � s r� c @ s e Zd ZdZdZdd� ZdS )�Observerr Nc C s" || _ | jd | _|�d| � d S )NrN � unobserve)r� �notifiedr� )r# �otherr� r% r% r& � remote_notify� s zObserver.remote_notify)r( r) r* r r� r r% r% r% r& r� � s r� c @ r )� NewStyleCopyc C r� r. )�s)r# r r% r% r& rD � r� zNewStyleCopy.__init__Nr� r% r% r% r& r � r+ r c @ s( e Zd ZdZdZdZdd� Zdd� ZdS )� NewStyleCopy2r rN c C s" t jd7 _t�| �}d|_|S )NrN r� )r � allocated�object�__new__r� )r# r� r% r% r& r � s zNewStyleCopy2.__new__c C s t jd7 _d S r� )r � initializedr/ r% r% r& rD � s zNewStyleCopy2.__init__N)r( r) r* r r r� r rD r% r% r% r& r � s r c @ r )�NewStyleCacheCopyc C r� r. )r� r� r% r% r& r� � r1 z.NewStyleCacheCopy.getStateToCacheAndObserveForN)r( r) r* r� r% r% r% r& r � r+ r c @ r� )�Echoerc C s |S r. r% �r# �str% r% r& � remote_echo� r� zEchoer.remote_echoc K s ||fS r. r% )r# r �kwr% r% r& �remote_echoWithKeywords� r� z Echoer.remote_echoWithKeywordsN)r( r) r* r r r% r% r% r& r � r� r c @ r� )�CachedReturnerc C r� r. �r� r� r% r% r& rD � r� zCachedReturner.__init__c C r� r. r r r% r% r& �remote_giveMeCache� r1 z!CachedReturner.remote_giveMeCacheN)r( r) r* rD r r% r% r% r& r � r� r c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) � NewStyleTestsc C sD t �t� �| _t �� }t| || jd�\}| _| _| �|� � �| _ dS )zY Create a pb server using L{Echoer} protocol and connect a client to it. )rj rc rk N) r r� r rk r� rq rA rH �successResultOf� getRootObject�ref)r# rc r@ r% r% r& �setUp� s �zNewStyleTests.setUpc C s dt _dt _dt _dS )zp Close client and server connections, reset values of L{NewStyleCopy2} class variables. r rN N)r r r r� r/ r% r% r& �tearDown� s zNewStyleTests.tearDownc s< t d�� �j�d� �}�j�� � �fdd�}|�|� |S )zY Create a new style object, send it over the wire, and check the result. r� �echoc s, �� | t� ��| jd� ��| � u � d S )Nr� )�assertIsInstancer � assertEqualr � assertFalse��res��origr# r% r& �cb s z'NewStyleTests.test_newStyle.<locals>.cb�r r r� rH rJ � addCallback�r# r� r" r% r r& � test_newStyle� s zNewStyleTests.test_newStylec sV t � � ��t jd� ��t jd� �j�d� �}�j�� � �fdd�}|�|� |S )zN Send a new style object and check the number of allocations. rN r c sF �� | t� ��| jd� ��tjd� ��tjd� ��| � � d S )Nr� r� rN )r r r r� r r � assertIsNotr r r% r& r" s z$NewStyleTests.test_alloc.<locals>.cb) r r r r r r� rH rJ r$ r% r% r r& � test_alloc s zNewStyleTests.test_allocc sB t d�� �jjd� ddd�}�j�� � �fdd�}|�|� |S )zo Create a new style object with keywords, send it over the wire, and check the result. �value1�echoWithKeywords�one�two��keyword1�keyword2c sh �� | t� �� | d t� �� | d t� ��| d jd� ��| d � � ��| d ddd�� d S )Nr rN r) r+ r, r- )r �tupler �dictr r r' r r r% r& r" . s z3NewStyleTests.test_newStyleWithKeywords.<locals>.cbr# r% r% r r& �test_newStyleWithKeywords# s � z'NewStyleTests.test_newStyleWithKeywordsN)r( r) r* r r r& r( r2 r% r% r% r& r � s r c @ s$ e Zd ZdZdZdd� Zdd� ZdS )� ConnectionNotifyServerFactoryaj A server factory which stores the last connection and fires a L{Deferred} on connection made. This factory can handle only one client connection. @ivar protocolInstance: the last protocol instance. @type protocolInstance: C{pb.Broker} @ivar connectionMade: the deferred fired upon connection. @type connectionMade: C{Deferred} Nc C s t j�| |� t� | _dS )z) Initialize the factory. N)r r� rD r �connectionMade)r# �rootr% r% r& rD I s z&ConnectionNotifyServerFactory.__init__c C s. || _ | jd}| _|dur|�d� dS dS )zF Store the protocol and fire the connection deferred. N)�protocolInstancer4 rz )r# r r� r% r% r& �clientConnectionMadeP s �z2ConnectionNotifyServerFactory.clientConnectionMade)r( r) r* r2 r6 rD r7 r% r% r% r& r3 : s r3 c @ r� )�NewStyleCachedTestsc sv t � � _d� j_t�dtt� j���� _t� � }t� d� j� � j |� � fdd�}|� � �|�}� jjj}t||g�S )zi Create a pb server using L{CachedReturner} protocol and connect a client to it. r� r � localhostc s | � _ d S r. �r r: r/ r% r& �gotRooth r� z*NewStyleCachedTests.setUp.<locals>.gotRoot)r r! r r � listenTCPr3 r rA r r� � connectTCP�getHost�portr r$ �factoryr4 r )r# rc r; �d1�d2r% r/ r& r [ s � zNewStyleCachedTests.setUpc C s( | j jjj�� | jjj�� | j �� S )z6 Close client and server connections. )rA r@ r6 rR �loseConnectionr r] � stopListeningr/ r% r% r& r o s z NewStyleCachedTests.tearDownc s8 � j �d� j�}� fdd�}|�|d� |�|d� |S )z� A new-style cacheable object can be retrieved and re-retrieved over a single connection. The value of an attribute of the cacheable can be accessed on the receiving side. � giveMeCachec sF � � | t� � �d| j� � �� j| � |r!| � _� j�d� j�S d S )Nr� rE ) r r r r r' r! r r r� )r �againr/ r% r& r" s �z2NewStyleCachedTests.test_newStyleCache.<locals>.cbTF)r r� r! r$ r% r% r/ r& �test_newStyleCachew s z&NewStyleCachedTests.test_newStyleCacheN)r( r) r* r r rG r% r% r% r& r8 Z s r8 c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� ZdS )$� BrokerTestsNc C s& zt �d� W d S ty Y d S w )N�None-None-TESTING.pub)�os�unlink�OSErrorr/ r% r% r& r � s �zBrokerTests.tearDownc C � | � d|� �� d S )Nz&This should cause a return value, not ��fail)r# �errorr% r% r& � thunkErrorBad� � zBrokerTests.thunkErrorBadc C r� r. )� thunkResult�r# �resultr% r% r& �thunkResultGood� r� zBrokerTests.thunkResultGoodc C r5 r. r% )r# �tbr% r% r& �thunkErrorGood� r� zBrokerTests.thunkErrorGoodc C rM )Nz This should cause an error, not rN rT r% r% r& �thunkResultBad� rR zBrokerTests.thunkResultBadc C s� t | d�\}}}G dd� dtj�}G dd� dtj�}|�d|� � |�d�}|� }|� }|�d||� |�� |�� |�� | �|j|d� | � |� d�|� d�� d S ) N�rj c @ r )z%BrokerTests.test_reference.<locals>.Xc S r� r. )�caughtr� r% r% r& � remote_catch� r� z2BrokerTests.test_reference.<locals>.X.remote_catchN)r( r) r* r\ r% r% r% r& �X� r+ r] c @ r )z%BrokerTests.test_reference.<locals>.Yc S s |� d|� d S )N�catch�r� �r# �a�br% r% r& � remote_throw� r� z2BrokerTests.test_reference.<locals>.Y.remote_throwN)r( r) r* rc r% r% r% r& �Y� r+ rd r� �throwzX should have caught Z) r� r � Referenceable�setNameForLocal� remoteForNamer� rH �assertIsr[ r � remoteMethod) r# r� r rH r] rd r� r� r� r% r% r& �test_reference� s zBrokerTests.test_referencec C s� t | d�\}}}||f||ffD ]5\}}t� }|�d|� |�d�}d| _|�d| jd ��| j| j� |� � |� � | � | j | jd� qd S )NrZ r� � �thunkrN zresult wasn't received.) r� r� rg rh �expectedThunkResultr� r� rV rQ rH r rS )r# r� r rH r� r� r� �barr% r% r& � test_result� s � ��zBrokerTests.test_resultc C r� r. )� nestedRemoterT r% r% r& �refcountResult� r� zBrokerTests.refcountResultc C s� g }g }t | d�\}}}t� }|�d|� |�d�}ttjd �D ]}|jjs+|jjr- n|� d�� |j |j � |� � q!tjd } | � |jjd� | �t|�| d| � dt|�� �� d S ) NrZ r� � � getSimplerN ztransport was not closedz expected z got )r� r� rg rh �ranger �MAX_BROKER_REFSrR �closedr� r� r� rH � assertTruer �len) r# �l�er� r rH r� r� �igno�expectedr% r% r& �test_tooManyRefs� s &z BrokerTests.test_tooManyRefsc C s� t | d�\}}}t� }|�d|� |�d�}|�d��| j| j� |�� |�� | � | j j d� | � | j j d d� | � | j j d d� d S ) NrZ r� �getCopyrN r� r� r rj )r� r� rg rh r� r� rV rQ rH r rS r� r� r� )r# r� r rH r� r� r% r% r& � test_copy� s zBrokerTests.test_copyc C s� t | d�\}}}t� }t� }|�d|� |�d�}|�d|� |�� |�d� |�� |�� |�d� |�� |�� | �|j d� | � |j dd� d S )NrZ ra �observerN rs z didn't notifyznotified too much) r� r� r� rg rh r� rH r� �assertIsNotNoner� r )r# r� r rH ra rb �rar% r% r& � test_observe� s zBrokerTests.test_observec C s� t | d�\}}}t� }|�d|� |�d�}|�� |�� g }|�d��|j� |�� |�� | �|j d� |j � d� | � |j dd� |�� |�� | � |d dd � d S ) NrZ r� � doItLaterz Deferred method run too early.rE z Deferred method run too late.r � zIncorrect result.) r� r� rg rh rH r� r$ r� r r� r� rz r )r# r� r rH r� r{ �resultsr% r% r& � test_defer s zBrokerTests.test_deferc C s� t | d�\}}}t� }|�d|� |�d�}|�d��| j| j� |�� |�� | j j }| � ||j � | ` t jdkr?t�� |�� |�� |�� | �||j � d S )NrZ r� rt � )r� r� rg rh r� r� rr rQ rH rq �luid�assertIn� localObjects�sys� hexversion�gc�collect� assertNotIn)r# r� r rH r� ro �rluidr% r% r& � test_refcount s$ � zBrokerTests.test_refcountc C s: t | d�\}}}t� }t� }|j}|�d|� |�d|� |�d�}|�d�}g } |�d��| j�� | j� |�d��| j�� | j� g } |�d��| j� |�d��| j� |� � | � | d j d� | � | d j d� | � | d jd� |�� |� � | � | d jd � | � t| �d� | d d } | �| �� j| d � | �| �� | d � g } |�d | ��| j� |� � | �| d � | � |�d�|�d�� | j} | d j}| �| |jd � ~ ~ |� � ~ ~ |� � tjdkr�t � � |� � | � | |jd� | � | |j d� | � ||jd� | � ||j d� | � |j!d� d S )NrZ r� �xxx�getCacher rN r� r� r� zpotential refcounting issuez!other potential refcounting issue�putCachez remote cache doesn't have itr� z Server still had it after GCz Client still had it after GCz!Server still had complex after GCz!Client still had complex after GCzobserver was not removed)"r� r� r� r� rg rh r� r$ r� � addErrbackrJ r r� r� r� r� ry �assertIdenticalr� �__self__r� rx rj r� r� �remotelyCachedObjectsr� r� r� r� r� �locallyCachedObjects� assertIsNoner� )r# r� r rH r� �obj2�vcc�o2�o3�coll�complex�cp�col2r� � baroqueLuidr% r% r& � test_cache4 sj � ��zBrokerTests.test_cachec C s zt �d� W n ty Y nw t| d�\}}}t� }|�d|� |�d�}g }|�d��|j | j � |� � |� � }| � |jd� | � |jd� | � |jd� | � |jd� t| d�\}}}|�d|� |�d�}|�d��|j | j � |� � |� � }| � |jd� d S )NrI rZ r� �getPubrN r )rJ rK rL r� � GetPublisherrg rh r� r� r� rQ rJ ry r �activateCalled� isActivated�yayIGotPublished�_wasCleanWhenLoaded)r# r� r rH r� ro �accumr� r% r% r& �test_publishablev s0 � z BrokerTests.test_publishablec C s |j | _d S r. )r� rS )r# �valr% r% r& �gotCopy� ru zBrokerTests.gotCopyc C s| t | d�\}}}d}t� }|�d|� |�d�}|�d|��| j| j� |�� |�� |�� | � | j |d| j � �� d S )NrZ �c r� � getFactoryz!ID not correct on factory object ) r� r� rg rh r� r� r� rY rH r rS )r# r� r rH �IDr� r� r% r% r& �test_factoryCopy� s �z BrokerTests.test_factoryCopy)r( r) r* rS r rQ rV rX rY rk rp rr r~ r� r� r� r� r� r� r� r� r% r% r% r& rH � s& B rH s� helloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldhelloworldc O s | a |ad S r. )� callbackArgs�callbackKeyword)�argsr r% r% r& �finishedCallback� s r� c @ r� )� Pagerizerc O s |||| _ | _| _d S r. )rz r� r )r# rz r� r r% r% r& rD � s zPagerizer.__init__c C s4 t j|td| jg| j�R i | j�� d | _| _d S )N�d )r � StringPager� bigStringrz r� r �r# � collectorr% r% r& �remote_getPages� s ���zPagerizer.remote_getPagesN)r( r) r* rD r� r% r% r% r& r� � r� r� c @ s e Zd ZdZdd� Zdd� ZdS )� FilePagerizerNc O s || _ |||| _| _| _d S r. )�filenamerz r� r )r# r� rz r� r r% r% r& rD � s zFilePagerizer.__init__c C s< t j|t| jd�| jg| j�R i | j��| _d | _| _d S )N�rb)r � FilePager�openr� rz r� r �pagerr� r% r% r& r� � s ���z FilePagerizer.remote_getPages)r( r) r* r� rD r� r% r% r% r& r� � s r� c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� PagingTestsz0 Test pb objects sending data by pages. c C sF | � � | _t| jd��}|�t� W d � dS 1 s w Y dS )z? Create a file used to test L{util.FilePager}. �wbN)�mktempr� r� �writer� )r# �fr% r% r& r � s "�zPagingTests.setUpc C s� t | d�\}}}|�dttddd�� |�d�}g }t�|d��|j� |s,|� � |r&| � d� |d �t d � | � t d d � | � td did � d S )zg Test L{util.StringPager}, passing a callback to fire when all pages are sent. rZ r� �hellors �r� �getPages� r �'Pages received not equal to pages sent!)r� � Completed callback not invokedr� N)r� rg r� r� rh r � getAllPagesr$ r� rH r �joinr� r� r� �r# r� r rH r� rz r% r% r& �test_pagingWithCallback� s �� �z#PagingTests.test_pagingWithCallbackc C sn t | d�\}}}|�dtd�� |�d�}g }t�|d��|j� |s)|�� |r#| � d� |d �t d� dS )z> Test L{util.StringPager} without a callback. rZ r� Nr� r� r r� ) r� rg r� rh r r� r$ r� rH r r� r� r� r% r% r& �test_pagingWithoutCallback� s ��z&PagingTests.test_pagingWithoutCallbackc C s� | � � }t|d��� t| d�\}}}t|d�}|�d|� |�d�}g }t�|d�� |j � d}|sE|dkrE|� � |d8 }|sE|dks7|sL| � d � | � d �|d �d d � dS ) z@ Test L{util.FilePager}, sending an empty file. �wrZ Nro r� rs r rN zgetAllPages timed outr� r� )r� r� �closer� r� rg rh r r� r$ r� rH rO r r� ) r# � filenameEmptyr� r rH � pagerizerr� rz �ttlr% r% r& �test_emptyFilePaging� s � z PagingTests.test_emptyFilePagingc C s� t | d�\}}}t| jtddd�}|�d|� |�d�}g }t�|d��|j � |s0|� � |r*| � d� |d �t d � | � td d � | � td did � | � |jjg � d S )z� Test L{util.FilePager}, passing a callback to fire when all pages are sent, and verify that the pager doesn't keep chunks in memory. rZ �frodo� r� ro r� r� r r� )r� r� r� N)r� r� r� r� rg rh r r� r$ r� rH r r� r� r� r� r� �chunks�r# r� r rH r� r� rz r% r% r& �test_filePagingWithCallback s" �� �z'PagingTests.test_filePagingWithCallbackc C s� t | d�\}}}t| jd�}|�d|� |�d�}g }t�|d��|j� |s-|� � |r'| � d� |d �t d� | � |j jg � dS )z< Test L{util.FilePager} without a callback. rZ Nro r� r� r r� )r� r� r� rg rh r r� r$ r� rH r r� r� r� r� r� r% r% r& � test_filePagingWithoutCallback% s ��z*PagingTests.test_filePagingWithoutCallbackN) r( r) r* r2 r r� r� r� r� r� r% r% r% r& r� � s r� c @ r )�DumbPublishablec C s ddiS )Nr� rN r% r/ r% r% r& �getStateToPublish8 r� z!DumbPublishable.getStateToPublishN)r( r) r* r� r% r% r% r& r� 7 r+ r� c @ r )�DumbPubc C r� r� )r� r/ r% r% r& � activated= r� zDumbPub.activatedN)r( r) r* r� r% r% r% r& r� < r+ r� c @ r� )r� c C s t d�| _d S )N�TESTING)r� �pubr/ r% r% r& rD B r� zGetPublisher.__init__c C r� r. )r� r/ r% r% r& � remote_getPubE r1 zGetPublisher.remote_getPubN)r( r) r* rD r� r% r% r% r& r� A r� r� c @ �8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �DisconnectionTestsz' Test disconnection callbacks. c G s t d|� ���)Nz I shouldn't have been called: �r� )r# r� r% r% r& rP Q r� zDisconnectionTests.errorc C rK )z. Called on broker disconnect. rN N)� gotCallbackr/ r% r% r& �gotDisconnectedT � z"DisconnectionTests.gotDisconnectedc C s | � || j� d| _dS )z7 Called on RemoteReference disconnect. rN N)r � remoteObject�objectCallback�r# �or% r% r& �objectDisconnectedZ s z%DisconnectionTests.objectDisconnectedc C sf t | d�\}}}|�� |�dt� � |�d�}g }|�dt� ��|j� |� � | � t |�d� d S )NrZ r� � setBadCopyrN ) r� rH rg � BadCopySetrh r� � BadCopyabler� r� rJ r ry )r# r� r rH �grz r% r% r& �test_badSerializationa s z(DisconnectionTests.test_badSerializationc C s$ t | d�\}}}|�� |�dt� � |�d�}|�� |�� |�� |�| j� | �| j|j� |� | j� | � | j|j� |�| j� | �|j |j� | �| j|j � |� | j� | � |j |j� | � | j|j � |�| j � |�| j� || _|�t�tj�� | �| j� | �| j� d S )NrZ r� )r� rH rg r� rh �notifyOnDisconnectrP r� � disconnects�dontNotifyOnDisconnectr� � _disconnected�disconnectCallbacksr� r� r� rZ r r[ r r\ rx r� r� )r# r� r rH �rr% r% r& �test_disconnectionk s. z%DisconnectionTests.test_disconnectionN) r( r) r* r2 rP r� r� r� r� r% r% r% r& r� L s r� c @ r� )�FreakOutNr� r% r% r% r& r � r� r c @ r )r� c C r� r. )r )r# �pr% r% r& �getStateToCopyFor� r1 z BadCopyable.getStateToCopyForN)r( r) r* r r% r% r% r& r� � r+ r� c @ r )r� c C r5 r. r% )r# �bcr% r% r& �remote_setBadCopy� r� z BadCopySet.remote_setBadCopyN)r( r) r* r r% r% r% r& r� � r+ r� c @ s* e Zd ZdZdd� Zd dd�Zdd� Zd S ) �LocalRemoteTestr c C s |d S r� r% )r# r� r% r% r& � sync_add1� r� zLocalRemoteTest.sync_add1rN c C � || S r. r% )r# r� r� r% r% r& � async_add� r� zLocalRemoteTest.async_addc C r� r. r� r/ r% r% r& � async_fail� r1 zLocalRemoteTest.async_failN)r rN )r( r) r* �reportAllTracebacksr r r r% r% r% r& r � s r c @ s@ e Zd ZdZd ZZdd� Zdd� Zdd� Zd d � Z d d � Z d S )� MyPerspectivez� @ivar loggedIn: set to C{True} when the avatar is logged in. @type loggedIn: C{bool} @ivar loggedOut: set to C{True} when the avatar is logged out. @type loggedOut: C{bool} Fc C r� r. �r9 �r# r9 r% r% r& rD � r� zMyPerspective.__init__c C r� )zT Return the avatar identifier which was used to access this avatar. r r/ r% r% r& �perspective_getAvatarId� s z%MyPerspective.perspective_getAvatarIdc C r- r. )�MyViewr/ r% r% r& �perspective_getViewPoint� r1 z&MyPerspective.perspective_getViewPointc C r )z� Add the given objects and return the result. This is a method unavailable on L{Echoer}, so it can only be invoked by authenticated users who received their avatar from L{TestRealm}. r% r` r% r% r& �perspective_add� s z MyPerspective.perspective_addc C r� �NT�� loggedOutr/ r% r% r& �logout� r� zMyPerspective.logoutN) r( r) r* r2 �loggedInr rD r r r r r% r% r% r& r � s r c @ s e Zd ZdZeZdZdd� ZdS )� TestRealma� A realm which repeatedly gives out a single instance of L{MyPerspective} for non-anonymous logins and which gives out a new instance of L{Echoer} for each anonymous login. @ivar lastPerspective: The L{MyPerspective} most recently created and returned from C{requestAvatar}. @ivar perspectiveFactory: A one-argument callable which will be used to create avatars to be returned from C{requestAvatar}. Nc C s\ |t jksJ �|dks J �|tju rt jt� dd� fS | �|�| _d| j_t j| j| jjfS )z� Verify that the mind and interface supplied have the expected values (this should really be done somewhere else, like inside a test method) and return an avatar appropriate for the given identifier. �BRAINS!c S r5 r. r% r% r% r% r& r6 � r7 z)TestRealm.requestAvatar.<locals>.<lambda>T) r r8 r � ANONYMOUSr �perspectiveFactory�lastPerspectiver r �r# r9 r: � interfacer% r% r& r= � s zTestRealm.requestAvatar)r( r) r* r2 r r r r= r% r% r% r& r � s r c @ r )r c C s t |t�S r. )r r r" r% r% r& � view_check� r� zMyView.view_checkN)r( r) r* r r% r% r% r& r � r+ r c @ � e Zd ZdZdd� Zdd� ZdS )� LeakyRealmz] A realm which hangs onto a reference to the mind object in its logout function. c C s || _ dS )z� Create a L{LeakyRealm}. @param mindEater: a callable that will be called with the C{mind} object when it is available N)� _mindEater)r# � mindEaterr% r% r& rD � s zLeakyRealm.__init__c s* | � � � | �|��tj�� �fdd�fS )Nc s � �� � fS r. )r r% �r: �perspr% r& r6 s z*LeakyRealm.requestAvatar.<locals>.<lambda>)r! r r r8 r r% r# r& r= s zLeakyRealm.requestAvatarN)r( r) r* r2 rD r= r% r% r% r& r � s r c @ r, )�NewCredLeakTestsz/ Tests to try to trigger memory leaks. c s� d�_ �fdd�}t�t|�d�\}��g � |�d�}|�dd�}dd � }|�|� � ��fd d �}|�|� ��� ��� d g� t� � �� �� � � dS ) z� The server does not leak a reference when the client disconnects suddenly, even if the cred logout function forms a reference cycle with the perspective. Nc s t �| �� _d S r. )�weakrefr �mindRef)r: r/ r% r& � setMindRef r� z4NewCredLeakTests.test_logoutLeak.<locals>.setMindRef)rj r� r5 �loginr� c S s$ | \}}t � }|�dt�|d�|�S )N�respondr� )r� r� r r* )r� � challenge� challengerr: r% r% r& � cbResponse$ s �z4NewCredLeakTests.test_logoutLeak.<locals>.cbResponsec s* �� � � �d� ��t�td��� d S )NrN �boom)rL r� rZ r r[ r� )�_)�connectionBrokenrH rn r% r& rZ - s z8NewCredLeakTests.test_logoutLeak.<locals>.connectionLostrN ) r' r� r rh r� r$ rJ r r� r� r� )r# r( rm r5 r� r- rZ r% )r0 rH r# rn r& �test_logoutLeak s � z NewCredLeakTests.test_logoutLeakN)r( r) r* r2 r1 r% r% r% r& r% r3 r% c @ s� e Zd ZdZdd� Zd%dd�Ze�ej �fdd�Z d d � Z d d � Z d d� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� ZdS )&� NewCredTestsz= Tests related to the L{twisted.cred} support in PB. c C s0 t � | _t�| j�| _t| j�| _t�� | _dS )z� Create a portal with no checkers and wrap it around a simple test realm. Set up a PB server on a TCP port which serves perspectives using that portal. N) r r� r r� r3 rk r r� rc r/ r% r% r& r D s zNewCredTests.setUpNc C sR t | | j| j�\| _| _| _t� | _tt � ddd�| j�| _ | j� � � | j� dS )a� Connect a client obtained from C{clientFactory} and a server obtained from the current server factory via an L{IOPump}, then assign them to the appropriate instance variables @ivar clientFactory: the broker client factory @ivar clientFactory: L{pb.PBClientFactory} instance @ivar client: the client broker @type client: L{pb.Broker} @ivar server: the server broker @type server: L{pb.Broker} @ivar pump: the IOPump connecting the client and server @type pump: L{IOPump} @ivar connector: A connector whose connect method recreates the above instance variables @type connector: L{twisted.internet.base.IConnector} �TCPrX i� N)rq rc rk r@ rA rH rr �connectorStater| r � IPv4Addressr_ rx r$ �establishClientAndServer)r# �_ignoredr% r% r& r6 O s ��z%NewCredTests.establishClientAndServerc C s0 | � | jjj� | j�|� | j�| j|� dS )a� Asserts that the client broker's transport was closed and then mimics the event loop by calling the broker's connectionLost callback with C{reason}, followed by C{self.clientFactory}'s C{clientConnectionLost} @param reason: (optional) the reason to pass to the client broker's connectionLost callback @type reason: L{Failure} N)rx r@ rR rw rZ rc ra r_ )r# r` r% r% r& � completeClientLostConnectiono s z)NewCredTests.completeClientLostConnectionc sB � � � � j�� }� fdd�}� fdd�}|�|� |�|� |S )z� Assert that L{PBClientFactory.getRootObject}'s Deferred fires with a L{RemoteReference}, and that disconnecting it runs its disconnection callbacks. c s � � | tj� | S r. )r r �RemoteReference��rootObjr/ r% r& � gotRootObject� s z6NewCredTests.test_getRootObject.<locals>.gotRootObjectc s( t � }| �|j� � j�� � �� |S r. )r r� rz rc � disconnectr8 )r; �disconnectedDeferredr/ r% r& r= � s z3NewCredTests.test_getRootObject.<locals>.disconnect�r6 rc r r$ )r# �rootObjDeferredr< r= r% r/ r& �test_getRootObject� s z NewCredTests.test_getRootObjectc s( � � � � j�� }� fdd�}|�|�S )z� Test that when a connection is lost, calling a method on a RemoteReference obtained from it raises L{DeadReferenceError}. c s@ t � }� �|j� � �fdd�}|�|� �j�� ��� |S )Nc s �� tj� jd� d S )N�method)� assertRaisesr �DeadReferenceErrorr� )�ign)r; r# r% r& �lostConnection� s zSNewCredTests.test_deadReferenceError.<locals>.gotRootObject.<locals>.lostConnection)r r� rz r$ rc r= r8 )r; r> rF r/ r: r& r< � s z;NewCredTests.test_deadReferenceError.<locals>.gotRootObjectr? )r# r@ r< r% r/ r& �test_deadReferenceError� s z$NewCredTests.test_deadReferenceErrorc sB G dd� dt j�}|� � _� �� � j�� }� fdd�}|�|�S )z� Test that if the L{reconnecting} flag is passed with a True value then a remote call made from a disconnection notification callback gets a result successfully. c @ r, )z=NewCredTests.test_clientConnectionLost.<locals>.ReconnectOnceFc S s0 | j }d| _ tj�| |||�}|r|�� |S r )�reconnectedAlreadyr r� ra r� )r# r_ r` � reconnectingrU r% r% r& ra � s �zRNewCredTests.test_clientConnectionLost.<locals>.ReconnectOnce.clientConnectionLostN)r( r) r* rH ra r% r% r% r& � ReconnectOnce� s rJ c sH � � | tj� t� }| �|j� � j�� � �� � fdd�}|� |�S )Nc s � j �� }� fdd�}|�|�S )Nc s6 � � | tj� t� }| �|j� � j�� � �� |S r. ) r r r9 r r� rz rc r= r8 )�anotherRootObjr� r/ r% r& �gotAnotherRootObject� s zqNewCredTests.test_clientConnectionLost.<locals>.gotRootObject.<locals>.disconnected.<locals>.gotAnotherRootObject)rc r r$ )rE r� rL r/ r% r& rY � s zSNewCredTests.test_clientConnectionLost.<locals>.gotRootObject.<locals>.disconnected) r r r9 r r� rz rc r= r8 r$ )r; r� rY r/ r% r& r< � s z=NewCredTests.test_clientConnectionLost.<locals>.gotRootObject)r r� rc r6 r r$ )r# rJ r@ r< r% r/ r& �test_clientConnectionLost� s z&NewCredTests.test_clientConnectionLostc C s< | � � | j�d�}|�t�t� �� |�t� t j �� dS )z� Test that if a Broker loses its connection without receiving any bytes, it doesn't raise any exceptions or log any errors. )rX i90 N) r6 rk re rg r rh rf rZ r r[ r r\ )r# � serverProtor% r% r& �test_immediateClose� s z NewCredTests.test_immediateClosec C s< t �� }|�t�dd��}|�dt�td��� | � |t�S )z� L{PBClientFactory.login} returns a L{Deferred} which is errbacked with the L{ConnectionRefusedError} if the underlying connection is refused. � foo� barNz!Test simulated refused connection) r r� r) r �UsernamePassword�clientConnectionFailedr r[ r � assertFailure)r# rc � loginDeferredr% r% r& �test_loginConnectionRefused� s ��� z(NewCredTests.test_loginConnectionRefusedc s� �j �tjdd�� t�dd�}d}t� � �j�||�}� �fdd�}�fdd�}|� |� |� |� �fd d �}|� |� �� � �j � � t �� �j � � � �d � |S ) z� Test that login can be performed with IUsernamePassword credentials and that when the connection is dropped the avatar is logged out. � pass�r$ � userr c s" �� �jjj� ��| tj� � S r. )rx r� r r r r r9 �r� ��loginCompletedr# r% r& �cbLogin s z.NewCredTests.test_loginLogout.<locals>.cbLoginc s � j �� � �� d S r. )rc r= r8 ��ignoredr/ r% r& � cbDisconnect s z3NewCredTests.test_loginLogout.<locals>.cbDisconnectc s � � � jjj� d S r. )rx r� r r r^ r/ r% r& �cbLogout& rR z/NewCredTests.test_loginLogout.<locals>.cbLogoutN)r �registerCheckerr r� r rR r rc r) r$ r6 rH rJ r� r� rz )r# �credsr: r� r] r` ra r% r[ r& �test_loginLogout s& � z NewCredTests.test_loginLogoutc s� t � � G � fdd�dtj�}|�j_�j�tjdd�� �j � t � dd�d�}� fdd�}|� |� �fd d �}|� |� ��� �j�� t�� �j�� |S ) z� If a L{RemoteReference} to an L{IPerspective} avatar is decrefed and there remain no other references to the avatar on the server, the avatar is garbage collected and the logout method called. c s$ e Zd ZdZdd� Z� fdd�ZdS )z=NewCredTests.test_logoutAfterDecref.<locals>.EventPerspectivezQ An avatar which fires a Deferred when it is logged out. c S r5 r. r% r r% r% r& rD C r� zFNewCredTests.test_logoutAfterDecref.<locals>.EventPerspective.__init__c s � � d � d S r. )rz r/ r r% r& r F r� zDNewCredTests.test_logoutAfterDecref.<locals>.EventPerspective.logoutN)r( r) r* r2 rD r r% r r% r& �EventPerspective> s re rQ r� rP r c s � S r. r% )�avatarr r% r& � cbLoggedInS s z7NewCredTests.test_logoutAfterDecref.<locals>.cbLoggedInc s � � � jjji � d S r. )r rk r6 � _localCleanupr^ r/ r% r& � cbLoggedOutZ s z8NewCredTests.test_logoutAfterDecref.<locals>.cbLoggedOut)r r �Avatarr� r r rb r r� rc r) r rR r$ r6 rH rJ r� r� )r# re r� rg ri r% )r r# r& �test_logoutAfterDecref6 s$ � � z#NewCredTests.test_logoutAfterDecrefc s� � j �tjddd�� � j�t�dd�d�}� j�t�dd�d�}t||g�}dd� }|� |� � fd d �}|� |� � � � � j � � |S ) z� Two different correct login attempts can be made on the same root object at the same time and produce two different resulting avatars. rQ s quux)r� �bazrP r � bazc S s | \}}t |�d�|�d�g�S )N� getAvatarId)r r� )rU �first�secondr% r% r& rg } s �z5NewCredTests.test_concurrentLogin.<locals>.cbLoggedInc s$ | \}}� � |d� � � |d� d S )NrP rm )r )r� ro rp r/ r% r& � cbAvatarIds� s z6NewCredTests.test_concurrentLogin.<locals>.cbAvatarIds) r rb r r� rc r) r rR r r$ r6 rH rJ )r# � firstLogin� secondLoginr� rg rq r% r/ r& �test_concurrentLoginl s" � � � z!NewCredTests.test_concurrentLoginc s� � j �tjdd�� � j�t�dd��}� j�t�dd��}� �|t � � �|t � t ||g�}� fdd�}|� |� � � � � j �� |S )zz Test that a login attempt with an invalid user or invalid password fails in the appropriate way. rW rX s nosuchuserrY s wrongpassc � � � t�}� �t|�d� d S )Nr� )�flushLoggedErrorsr r ry ��ignore�errorsr/ r% r& �cleanup� � z;NewCredTests.test_badUsernamePasswordLogin.<locals>.cleanup)r rb r r� rc r) r rR rT r r r$ r6 rH rJ )r# rr rs r� rz r% r/ r& � test_badUsernamePasswordLogin� s" � � � z*NewCredTests.test_badUsernamePasswordLoginc C sX | j �t�� � | j�t�� d�}dd� }|�|� |�| j d� | � � | j � � |S )z� Verify that a PB server using a portal configured with a checker which allows IAnonymous credentials can be logged into using IAnonymous credentials. r c S � | � dd�S �Nr �{ r_ rZ r% r% r& rg � ru z4NewCredTests.test_anonymousLogin.<locals>.cbLoggedInr ) r rb r �AllowAnonymousAccessrc r) r � Anonymousr$ r r6 rH rJ )r# r� rg r% r% r& �test_anonymousLogin� s z NewCredTests.test_anonymousLoginc s^ � j �tjdd�� � j�t�� d�}� �|t � � fdd�}|� |� � � � � j � � |S )zg Verify that without an anonymous checker set up, anonymous login is rejected. �passrX r c ru r� )rv r r ry rw r/ r% r& rz � r{ z=NewCredTests.test_anonymousLoginNotPermitted.<locals>.cleanup)r rb r r� rc r) r r� rT r r$ r6 rH rJ �r# r� rz r% r/ r& � test_anonymousLoginNotPermitted� s � z,NewCredTests.test_anonymousLoginNotPermittedc C sl | j �t�� � | j �tjdd�� | j�t�� d�}dd� }|� |� |� | j d� | � � | j � � |S )z� Like L{test_anonymousLogin} but against a portal with a checker for both IAnonymous and IUsernamePassword. rW rX r c S r} r~ r_ rZ r% r% r& r] � ru zENewCredTests.test_anonymousLoginWithMultipleCheckers.<locals>.cbLoginr )r rb r r� r� rc r) r r� r$ r r6 rH rJ �r# r� r] r% r% r& �'test_anonymousLoginWithMultipleCheckers� s � z4NewCredTests.test_anonymousLoginWithMultipleCheckersc C sp | j �t�� � | j �tjdd�� | j�t�dd�d�}dd� }|� |� |� | j d� | � � | j � � |S )z� Like L{test_anonymousLoginWithMultipleCheckers} but check that username/password authentication works. rW rX rY r c S s | � ddd�S )N�addr� � r_ rZ r% r% r& r] � r� zINewCredTests.test_authenticatedLoginWithMultipleCheckers.<locals>.cbLoginr )r rb r r� r� rc r) r rR r$ r r6 rH rJ r� r% r% r& �+test_authenticatedLoginWithMultipleCheckers� s � � z8NewCredTests.test_authenticatedLoginWithMultipleCheckersc C sp | j �tjdd�� | j�t�dd�d�}dd� }|�|� dd� }|�|� |�| j � | � � | j � � |S ) zb Verify that a viewpoint can be retrieved after authenticating with cred. rW rX rY r c S � | � d�S )N� getViewPointr_ rZ r% r% r& r] r� z'NewCredTests.test_view.<locals>.cbLoginc S r� )Nr� r_ )� viewpointr% r% r& �cbView r� z&NewCredTests.test_view.<locals>.cbView) r rb r r� rc r) r rR r$ rx r6 rH rJ )r# r� r] r� r% r% r& � test_view s � � zNewCredTests.test_viewr. )r( r) r* r2 r r6 r r[ r r\ r8 rA rG rM rO rV rd rk rt r| r� r� r� r� r� r% r% r% r& r2 ? s( ! �3 16% r2 c @ r� )�NonSubclassingPerspectivec C r5 r. r% r r% r% r& rD * r� z"NonSubclassingPerspective.__init__c C s( |� || �}|� || �}|�|||f�S r. )� unserialize� serialize)r# r] �messager� �kwargsr% r% r& �perspectiveMessageReceived. s z4NonSubclassingPerspective.perspectiveMessageReceivedc C r� r r r/ r% r% r& r 4 r� z NonSubclassingPerspective.logoutN)r( r) r* rD r� r r% r% r% r& r� ( s r� c @ r )�NSPTestsz Tests for authentication against a realm where the L{IPerspective} implementation is not a subclass of L{Avatar}. c C s� t � | _t| j_t�| j�| _t�� | _| j� dd� | j� | j� t t � | j��| _tjd| jdd�| _| �| jj� | j�� j| _d S )NrY rW r rX )r )r r� r� r r r� r r� r� �addUserrb r r r� r@ r r< r? ri rD r> �portnor/ r% r% r& r > s zNSPTests.setUpc sn t �� � � �t�dd�d�}t�d�j� � |�dd� � |��j ddd d if� � �fd d �}|�|� |S ) z� An L{IPerspective} implementation which does not subclass L{Avatar} can expose remote methods for the client to call. rY rW r rX c S s | j dddd�S )N�ANYTHING�hererl )ro r_ )r r% r% r& r6 R s z#NSPTests.test_NSP.<locals>.<lambda>r� )r� ro rl c s$ � � � �jjD ]}|j�� qd S r. )r= r@ � protocolsrR rC )r_ r �r@ r# r% r& rz U s �z"NSPTests.test_NSP.<locals>.cleanup) r r� r) r rR r r= r� r$ r r� r% r� r& �test_NSPJ s zNSPTests.test_NSPN)r( r) r* r2 r r� r% r% r% r& r� 8 s r� c @ r )� IForwardedzA Interface used for testing L{util.LocalAsyncForwarder}. c C r� )z, Simple synchronous method. Nr% r% r% r% r& � forwardMec r7 zIForwarded.forwardMec C r� )z- Simple asynchronous method. Nr% r% r% r% r& �forwardDeferredh r7 zIForwarded.forwardDeferredN)r( r) r* r2 r� r� r% r% r% r& r� ^ s r� c @ s0 e Zd ZdZdZdZdd� Zdd� Zdd� Zd S ) � Forwardedz� Test implementation of L{IForwarded}. @ivar forwarded: set if C{forwardMe} is called. @type forwarded: C{bool} @ivar unforwarded: set if C{dontForwardMe} is called. @type unforwarded: C{bool} Fc C rK )z6 Set a local flag to test afterwards. TN)� forwardedr/ r% r% r& r� | r� zForwarded.forwardMec C rK )zv Set a local flag to test afterwards. This should not be called as it's not in the interface. TN)� unforwardedr/ r% r% r& � dontForwardMe� rM zForwarded.dontForwardMec C s t d�S )z0 Asynchronously return C{True}. T)r r/ r% r% r& r� � s zForwarded.forwardDeferredN) r( r) r* r2 r� r� r� r� r� r% r% r% r& r� n s r� c @ r� ) �SpreadUtilTestsz+ Tests for L{twisted.spread.util}. c C s t � }| �|�dd�d� dS )zk Call a synchronous method of a L{util.LocalAsRemote} object and check the result. �add1r� r� N)r r r� r� r% r% r& � test_sync� s zSpreadUtilTests.test_syncc C s: t � }t � }|jdddd�}| �|t� |�| jd� |S )zm Call an asynchronous method of a L{util.LocalAsRemote} object and check the result. r� r� r� )r� r� )r r� r r r$ r )r# r� r� r% r% r& � test_async� s zSpreadUtilTests.test_asyncc s4 t � }|�d�}� fdd�}|�� fdd�|� |S )zG Test an asynchronous failure on a remote method call. rO c s � � | tj� | �t� d S r. )r r r[ �trapr� )r� r/ r% r& �eb� s z*SpreadUtilTests.test_asyncFail.<locals>.ebc s � � d�S )Nzsupposed to failrN r r/ r% r& r6 � s z0SpreadUtilTests.test_asyncFail.<locals>.<lambda>)r r� r� )r# r� r� r� r% r/ r& �test_asyncFail� s z SpreadUtilTests.test_asyncFailc C s$ t � }|�d�}| �|d�d� dS )zM Test the C{remoteMethod} facility of L{util.LocalAsRemote}. r� r� r� N)r rj r )r# r� �mr% r% r& �test_remoteMethod� s z!SpreadUtilTests.test_remoteMethodc C sl t � }t�|t�}|�d� | �|j� |�d� | �|j� |�d�}g }|� |j � | � |d d� dS )ze Test a call to L{util.LocalAsyncForwarder} using L{Forwarded} local object. r� r� r� r rN N) r� r �LocalAsyncForwarderr� r� rx r� r r� r$ r� r )r# r� �lf�rrrz r% r% r& �test_localAsyncForwarder� s z(SpreadUtilTests.test_localAsyncForwarderN) r( r) r* r2 r� r� r� r� r� r% r% r% r& r� � s r� c @ r> ) �PBWithSecurityOptionsTestsz& Test security customization. c C s& t �� }|�d�}| �|jtj� dS )zl By default, client broker should use C{jelly.globalSecurity} as security settings. N)r r� re ri �securityr �globalSecurity�r# r@ r] r% r% r& �!test_clientDefaultSecurityOptions� s z<PBWithSecurityOptionsTests.test_clientDefaultSecurityOptionsc C s* t �t� �}|�d�}| �|jtj� dS )zl By default, server broker should use C{jelly.globalSecurity} as security settings. N)r r� r re ri r� r r� r� r% r% r& �!test_serverDefaultSecurityOptions� s z<PBWithSecurityOptionsTests.test_serverDefaultSecurityOptionsc C s0 t �� }tj|d�}|�d�}| �|j|� dS )zs Check that the security settings are passed from the client factory to the broker object. �r� N)r �SecurityOptionsr r� re ri r� �r# r� r@ r] r% r% r& � test_clientSecurityCustomization� s z;PBWithSecurityOptionsTests.test_clientSecurityCustomizationc C s4 t �� }tjt� |d�}|�d�}| �|j|� dS )zs Check that the security settings are passed from the server factory to the broker object. r� N)r r� r r� r re ri r� r� r% r% r& � test_serverSecurityCustomization� s z;PBWithSecurityOptionsTests.test_serverSecurityCustomizationN)r( r) r* r2 r� r� r� r� r% r% r% r& r� � s r� r. )�r2 r� rJ r� rG r& � collectionsr �ior rf �typingr �zope.interfacer r � twisted.credr r r �twisted.cred.errorr r �twisted.internetr r r r �twisted.internet.deferr r r �twisted.internet.errorr �twisted.protocols.policiesr �twisted.pythonr r �twisted.python.compatr �twisted.spreadr r r r �twisted.test.proto_helpersr � twisted.trialr �Viewabler rj r! �IRealmr4 r? rq rr r| r� rf r� r� �Copyabler� � RemoteCopyr� �setUnjellyableForClassr� r� � setUnjellyableFactoryForClassr� � Cacheabler� r� r� � RemoteCacher� r� r� r� r� r� r r r �Rootr r �SynchronousTestCaser r� r3 �TestCaser8 rH r� r� r� r� r� r� r� � Publishabler� �RemotePublishedr� r� r� r� r r� r� � LocalAsRemoter r8 r r r r r% r2 r� r� r� r� r� r� r% r% r% r& �<module> s� ;3! R 7 l C #!6 l&!@PK Mb�Z)'�-�H �H 6 spread/test/__pycache__/test_pbfailure.cpython-310.pycnu �[��� o �b; � @ sj d Z ddlmZ ddlmZmZ ddlmZ ddlm Z ddl m Z m Z m Z ddlmZ G dd � d e�ZG d d � d e�ZG d d � d e j�ZG dd� de j�ZG dd� de je je j�ZG dd� de je j�Ze �ee� e �ee� e j� e� G dd� de j �Z G dd� de j �Z G dd� dej!�Z"G dd� de"�Z#G d d � d e#�Z$G d d � d �Z%G d d!� d!ej!�Z&d"S )#z! Tests for error handling in PB. � )�StringIO)�defer�reactor)�log)�qual)�flavors�jelly�pb)�unittestc @ � e Zd ZdZdS )�AsynchronousExceptionz� Helper used to test remote methods which return Deferreds which fail with exceptions which are not L{pb.Error} subclasses. N��__name__� __module__� __qualname__�__doc__� r r �D/usr/lib/python3/dist-packages/twisted/spread/test/test_pbfailure.pyr � r c @ r )�SynchronousExceptionzm Helper used to test remote methods which raise exceptions which are not L{pb.Error} subclasses. Nr r r r r r r r c @ r )�AsynchronousErrorz� Helper used to test remote methods which return Deferreds which fail with exceptions which are L{pb.Error} subclasses. Nr r r r r r ! r r c @ r )�SynchronousErrorzi Helper used to test remote methods which raise exceptions which are L{pb.Error} subclasses. Nr r r r r r ( r r c @ � e Zd ZdS )� JellyErrorN�r r r r r r r r / � r c @ r )� SecurityErrorNr r r r r r 3 r r c @ sh e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z ddd�Z ddd�Z dS )� SimpleRootc C � t �td��S )zD Fail asynchronously with a non-pb.Error exception. z remote asynchronous exception)r �failr ��selfr r r � remote_asynchronousException> � z'SimpleRoot.remote_asynchronousExceptionc C � t d��)zC Fail synchronously with a non-pb.Error exception. z remote synchronous exception)r r r r r �remote_synchronousExceptionD � z&SimpleRoot.remote_synchronousExceptionc C r )z@ Fail asynchronously with a pb.Error exception. zremote asynchronous error)r r r r r r r �remote_asynchronousErrorJ r# z#SimpleRoot.remote_asynchronousErrorc C r$ )z? Fail synchronously with a pb.Error exception. zremote synchronous error)r r r r r �remote_synchronousErrorP r& z"SimpleRoot.remote_synchronousErrorc C s G dd� dt j�}|d��)z> Fail with error that is not known to client. c @ r )z4SimpleRoot.remote_unknownError.<locals>.UnknownErrorNr r r r r � UnknownError[ r r) zI'm not known to client!)r �Error)r! r) r r r �remote_unknownErrorV s z SimpleRoot.remote_unknownErrorc C � | � � d S �N)� raiseJellyr r r r � remote_jelly` � zSimpleRoot.remote_jellyc C r, r- )� raiseSecurityr r r r �remote_securityc r0 zSimpleRoot.remote_securityc C �" t �� }|�| j� |�d � |S r- )r �Deferred� addCallbackr. �callback�r! �dr r r �remote_deferredJellyf � z SimpleRoot.remote_deferredJellyc C r3 r- )r r4 r5 r1 r6 r7 r r r �remote_deferredSecurityl r: z"SimpleRoot.remote_deferredSecurityNc C r$ )NzI'm jellyable!)r �r! �resultsr r r r. r � zSimpleRoot.raiseJellyc C r$ )Nz I'm secure!)r r< r r r r1 u r> zSimpleRoot.raiseSecurityr- )r r r r" r% r' r( r+ r/ r2 r9 r; r. r1 r r r r r = s r c @ s e Zd ZdZdZdd� ZdS )�SaveProtocolServerFactoryzd A L{pb.PBServerFactory} that saves the latest connected client in C{protocolInstance}. Nc C s || _ dS )z3 Keep track of the given protocol. N)�protocolInstance)r! �protocolr r r �clientConnectionMade� s z.SaveProtocolServerFactory.clientConnectionMade)r r r r r@ rB r r r r r? y s r? c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�PBConnTestCaser c C s | � � | �� d S r- )� _setUpServer� _setUpClientr r r r �setUp� s zPBConnTestCase.setUpc C s. t t� �| _| j| j_tjd| jdd�| _d S )Nr � 127.0.0.1)� interface)r? r � serverFactory�unsafeTracebacksr � listenTCP� serverPortr r r r rD � s �zPBConnTestCase._setUpServerc C s, | j �� j}t�� | _t�d|| j�| _d S )NrG ) rL �getHost�portr �PBClientFactory� clientFactoryr � connectTCP�clientConnector)r! �portNor r r rE � s �zPBConnTestCase._setUpClientc C s0 | j jd ur | j jj�� t�| �� | �� g�S r- )rI r@ � transport�loseConnectionr � gatherResults�_tearDownServer�_tearDownClientr r r r �tearDown� s zPBConnTestCase.tearDownc C s t �| jj�S r- )r � maybeDeferredrL � stopListeningr r r r rW � s z PBConnTestCase._tearDownServerc C s | j �� t�d �S r- )rR � disconnectr �succeedr r r r rX � s z PBConnTestCase._tearDownClientN) r r r rJ rF rD rE rY rW rX r r r r rC � s rC c @ s� e Zd ZejjZdd� Zdd� Zdd� Z dd� Z d d � Z d d � Z d d� Z d$dd�Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� ZdS )%�PBFailureTestsc s6 ���fdd�� �j �� }� �fdd�}|�|� |S )Nc sF | � � � ��| jd� �r��� �}��t|�d� | j| j| jfS )N�Traceback unavailable � )�trap�compare� traceback�flushLoggedErrors� assertEqual�len�type�value)�err�errs)� exceptionType�flushr! r r �eb� s z)PBFailureTests._exceptionTest.<locals>.ebc s | � ��}|�� � |S r- )� callRemote� addErrback)�rootr8 )rm �methodr r � gotRootObject� s z4PBFailureTests._exceptionTest.<locals>.gotRootObject�rP � getRootObjectr5 )r! rq rk rl r8 rr r )rm rk rl rq r! r �_exceptionTest� s z PBFailureTests._exceptionTestc C � | � dtd�S )z� Test that a Deferred returned by a remote method which already has a Failure correctly has that error passed back to the calling side. �asynchronousExceptionT)ru r r r r r �test_asynchronousException� � z)PBFailureTests.test_asynchronousExceptionc C rv )zw Like L{test_asynchronousException}, but for a method which raises an exception synchronously. �synchronousExceptionT)ru r r r r r �test_synchronousException� ry z(PBFailureTests.test_synchronousExceptionc C rv )z� Like L{test_asynchronousException}, but for a method which returns a Deferred failing with an L{pb.Error} subclass. �asynchronousErrorF)ru r r r r r �test_asynchronousError� ry z%PBFailureTests.test_asynchronousErrorc C rv )z} Like L{test_asynchronousError}, but for a method which synchronously raises a L{pb.Error} subclass. �synchronousErrorF)ru r r r r r �test_synchronousError� ry z$PBFailureTests.test_synchronousErrorc C s | � ||� |S r- )re )r! �result�expectedResultr r r �_success� s zPBFailureTests._successc C s |j | j||fd� |S )N)� callbackArgs)� addCallbacksr� )r! � remoteCallr� rm r r r �_addFailingCallbacks� s z#PBFailureTests._addFailingCallbacksNc s, �j �� }� ����fdd�}|�|� |S )z� Call the given remote method and attach the given errback to the resulting Deferred. If C{exc} is not None, also assert that one exception of that type was logged. c s8 �� | ����� �}�d ur��fdd�}|�|� |S )Nc s �� t��� ��d� | S )Nr` )re rf rd )ri )�excr! r r � gotFailure� s z@PBFailureTests._testImpl.<locals>.gotRootObj.<locals>.gotFailure)r� rn �addBoth)�obj�failureDeferredr� �rm r� �expectedrq r! r r � gotRootObj� s � z,PBFailureTests._testImpl.<locals>.gotRootObjrs )r! rq r� rm r� � rootDeferredr� r r� r � _testImpl� s zPBFailureTests._testImplc � � fdd�}� � dd|�S )z� Test that an exception which is a subclass of L{pb.Error} has more information passed across the network to the calling side. c �, | � t� � �| jt� � �| j| j� dS )N�+ �ra r �assertNotIsInstancerg �str�assertIsInstancerh �r r r r � failureJelly � z6PBFailureTests.test_jellyFailure.<locals>.failureJellyr r� �r� )r! r� r r r �test_jellyFailure� � z PBFailureTests.test_jellyFailurec r� )z� Test that a Deferred which fails with a L{pb.Error} is treated in the same way as a synchronously raised L{pb.Error}. c r� )N� r� r� r r r �failureDeferredJelly r� zFPBFailureTests.test_deferredJellyFailure.<locals>.failureDeferredJelly� deferredJellyr� r� )r! r� r r r �test_deferredJellyFailure r� z(PBFailureTests.test_deferredJellyFailurec r� )z� A non-jellyable L{pb.Error} subclass raised by a remote method is turned into a Failure with a type set to the FQPN of the exception type. c � � � | jd� dS )Ns3 twisted.spread.test.test_pbfailure.SynchronousError� �re rg r� r r r �failureUnjellyable � �zBPBFailureTests.test_unjellyableFailure.<locals>.failureUnjellyabler~ r� r� )r! r� r r r �test_unjellyableFailure � z&PBFailureTests.test_unjellyableFailurec r� )z� Test that an exception which is a subclass of L{pb.Error} but not known on the client side has its type set properly. c r� )Ns/ twisted.spread.test.test_pbfailure.UnknownError�� r� r� r r r �failureUnknown- r� z:PBFailureTests.test_unknownFailure.<locals>.failureUnknown� unknownErrorr� r� )r! r� r r r �test_unknownFailure' r� z"PBFailureTests.test_unknownFailurec r� )z� Test that even if an exception is not explicitly jellyable (by being a L{pb.Jellyable} subclass), as long as it is an L{pb.Error} subclass it receives the same special treatment. c r� )N�� �ra r r� rg r� r� rh r� r r r �failureSecurity< r� z<PBFailureTests.test_securityFailure.<locals>.failureSecurity�securityr� r� )r! r� r r r �test_securityFailure5 r� z#PBFailureTests.test_securityFailurec r� )z� Test that a Deferred which fails with a L{pb.Error} which is not also a L{pb.Jellyable} is treated in the same way as a synchronously raised exception of the same type. c r� )N� r� r� r r r �failureDeferredSecurityK r� zEPBFailureTests.test_deferredSecurity.<locals>.failureDeferredSecurity�deferredSecurityr� r� )r! r� r r r �test_deferredSecurityD r� z$PBFailureTests.test_deferredSecurityc s � fdd�}� � dd|t�S )z� Test that attempting to call a method which is not defined correctly results in an AttributeError on the calling side. c s | � tj� � �| jd� dS )Nr_ �� )ra r � NoSuchMethodrb rc r� r r r � failureNoSuchY s z>PBFailureTests.test_noSuchMethodFailure.<locals>.failureNoSuch�nosuchr� )r� �AttributeError)r! r� r r r �test_noSuchMethodFailureS s z'PBFailureTests.test_noSuchMethodFailurec s6 � j �� }dd� }|�|� � fdd�}|�|� |S )z� Test that a copied failure received from a PB call can be logged locally. Note: this test needs some serious help: all it really tests is that log.err(copiedFailure) doesn't raise an exception. c S s | � d�S )Nrz )rn )�rootObjr r r � connectedj s z;PBFailureTests.test_copiedFailureLogging.<locals>.connectedc s( t �| � � �t�}� �t|�d� d S )N� )r ri rd r re rf )�failurerj r r r � exceptiono s z;PBFailureTests.test_copiedFailureLogging.<locals>.exception)rP rt r5 ro )r! r8 r� r� r r r �test_copiedFailureLogging` s z(PBFailureTests.test_copiedFailureLoggingc s� t �td��}t�tj|t� d��}g � � �fdd�}|� }|�d� ��t|j |� �� t � �d� � d }�� |j t t��d�� �� |jd � �� |jd � dS ) z� L{pb.CopiedFailure.throwExceptionIntoGenerator} will throw a L{RemoteError} into the given paused generator at the point where it last yielded. �foo��invokerc 3 sN � zd V W n t jy } z � �| � W Y d } ~ d S d } ~ ww ��d� d S )NzRemoteError not raised)r � RemoteError�appendr )r� �r� r! r r � generatorFunc� s � ��zFPBFailureTests.test_throwExceptionIntoGenerator.<locals>.generatorFuncNr` r �ascii)r� r_ )r �CopyableFailurer� r �unjelly� DummyInvoker�send� assertRaises� StopIteration�throwExceptionIntoGeneratorre rf � remoteTyper �encode�args�remoteTraceback)r! �original�copyr� �genr� r r� r � test_throwExceptionIntoGeneratorx s z/PBFailureTests.test_throwExceptionIntoGeneratorr- )r r r r �TestCasere rb ru rx r{ r} r r� r� r� r� r� r� r� r� r� r� r� r� r r r r r^ � s& r^ c @ s e Zd ZejjZdZdS )�PBFailureUnsafeTestsr` N)r r r r r� � failIfEqualsrb rJ r r r r r� � s r� c @ s e Zd ZdZdZdS )r� zZ A behaviorless object to be used as the invoker parameter to L{jelly.jelly}. N)r r r r �serializingPerspectiver r r r r� � s r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �FailureJellyingTestsz: Tests for the interaction of jelly and failures. c C sn t �t� �}| �|�t�t� | �|�t�t� t�tj|t� d��}| �|�t�t� | �|�t�t� dS )z� An unjellied L{CopyableFailure} has a check method which behaves the same way as the original L{CopyableFailure}'s check method. r� N� r r� �ZeroDivisionError�assertIs�check�ArithmeticErrorr r� r� )r! r� �copiedr r r �test_unjelliedFailureCheck� s z/FailureJellyingTests.test_unjelliedFailureCheckc C s� t �t� �}| �|�t�t� | �|�t�t� t�tj|t� d��}t �|�}t�tj|t� d��}| �|�t�t� | �|�t�t� dS )aX The object which results from jellying a L{CopyableFailure}, unjellying the result, creating a new L{CopyableFailure} from the result of that, jellying it, and finally unjellying the result of that has a check method which behaves the same way as the original L{CopyableFailure}'s check method. r� Nr� )r! r� � copiedOnce� derivative� copiedTwicer r r � test_twiceUnjelliedFailureCheck� s z4FailureJellyingTests.test_twiceUnjelliedFailureCheckc C sZ t �td��}t�tj|t� d��}t� }|�|� tt�}d� |�}| � ||� � � dS )a When L{CopiedFailure.printTraceback} is used to print a copied failure which was unjellied from a L{CopyableFailure} with C{unsafeTracebacks} set to C{False}, the string representation of the exception value is included in the output. z some reasonr� z.Traceback from remote host -- {}: some reason N) r r� � Exceptionr r� r� r �printTracebackr �formatre �getvalue)r! r� r� �outputr� �expectedOutputr r r � test_printTracebackIncludesValue� s �z5FailureJellyingTests.test_printTracebackIncludesValueN)r r r r r� r� r� r r r r r� � s r� N)'r �ior �twisted.internetr r �twisted.pythonr �twisted.python.reflectr �twisted.spreadr r r � twisted.trialr r� r r r* r r � Jellyable� RemoteCopyr r �setUnjellyableForClass�globalSecurity�allowInstancesOf�Rootr �PBServerFactoryr? r� rC r^ r� r� r� r r r r �<module> s0 <" k PK Mb�Z�"�oJ oJ spread/test/test_jelly.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases for L{jelly} object serialization. """ import datetime import decimal from twisted.spread import banana, jelly, pb from twisted.test.proto_helpers import StringTransport from twisted.trial import unittest from twisted.trial.unittest import TestCase class TestNode(jelly.Jellyable): """ An object to test jellyfying of new style class instances. """ classAttr = 4 def __init__(self, parent=None): if parent: self.id = parent.id + 1 parent.children.append(self) else: self.id = 1 self.parent = parent self.children = [] class A: """ Dummy class. """ def amethod(self): """ Method to be used in serialization tests. """ def afunc(self): """ A dummy function to test function serialization. """ class B: """ Dummy class. """ def bmethod(self): """ Method to be used in serialization tests. """ class C: """ Dummy class. """ def cmethod(self): """ Method to be used in serialization tests. """ class D: """ Dummy new-style class. """ class E: """ Dummy new-style class with slots. """ __slots__ = ("x", "y") def __init__(self, x=None, y=None): self.x = x self.y = y def __getstate__(self): return {"x": self.x, "y": self.y} def __setstate__(self, state): self.x = state["x"] self.y = state["y"] class SimpleJellyTest: def __init__(self, x, y): self.x = x self.y = y def isTheSameAs(self, other): return self.__dict__ == other.__dict__ def jellyRoundTrip(testCase, toSerialize): """ Verify that the given object round-trips through jelly & banana and comes out equivalent to the input. """ jellied = jelly.jelly(toSerialize) encoded = banana.encode(jellied) decoded = banana.decode(encoded) unjellied = jelly.unjelly(decoded) testCase.assertEqual(toSerialize, unjellied) class JellyTests(TestCase): """ Testcases for L{jelly} module serialization. @cvar decimalData: serialized version of decimal data, to be used in tests. @type decimalData: L{list} """ decimalData = [ b"list", [b"decimal", 995, -2], [b"decimal", 0, 0], [b"decimal", 123456, 0], [b"decimal", -78901, -3], ] def _testSecurity(self, inputList, atom): """ Helper test method to test security options for a type. @param inputList: a sample input for the type. @type inputList: L{list} @param atom: atom identifier for the type. @type atom: L{str} """ c = jelly.jelly(inputList) taster = jelly.SecurityOptions() taster.allowBasicTypes() # By default, it should succeed jelly.unjelly(c, taster) taster.allowedTypes.pop(atom) # But it should raise an exception when disallowed self.assertRaises(jelly.InsecureJelly, jelly.unjelly, c, taster) def test_methodsNotSelfIdentity(self): """ If a class change after an instance has been created, L{jelly.unjelly} shoud raise a C{TypeError} when trying to unjelly the instance. """ a = A() b = B() c = C() a.bmethod = c.cmethod b.a = a savecmethod = C.cmethod del C.cmethod try: self.assertRaises(TypeError, jelly.unjelly, jelly.jelly(b)) finally: C.cmethod = savecmethod def test_newStyle(self): """ Test that a new style class can be jellied and unjellied with its objects and attribute values preserved. """ n = D() n.x = 1 n2 = D() n.n2 = n2 n.n3 = n2 c = jelly.jelly(n) m = jelly.unjelly(c) self.assertIsInstance(m, D) self.assertIs(m.n2, m.n3) self.assertEqual(m.x, 1) def test_newStyleWithSlots(self): """ A class defined with I{slots} can be jellied and unjellied with the values for its attributes preserved. """ n = E() n.x = 1 c = jelly.jelly(n) m = jelly.unjelly(c) self.assertIsInstance(m, E) self.assertEqual(n.x, 1) def test_typeNewStyle(self): """ Test that a new style class type can be jellied and unjellied to the original type. """ t = [D] r = jelly.unjelly(jelly.jelly(t)) self.assertEqual(t, r) def test_typeBuiltin(self): """ Test that a builtin type can be jellied and unjellied to the original type. """ t = [str] r = jelly.unjelly(jelly.jelly(t)) self.assertEqual(t, r) def test_dateTime(self): """ Jellying L{datetime.timedelta} instances and then unjellying the result should produce objects which represent the values of the original inputs. """ dtn = datetime.datetime.now() dtd = datetime.datetime.now() - dtn inputList = [dtn, dtd] c = jelly.jelly(inputList) output = jelly.unjelly(c) self.assertEqual(inputList, output) self.assertIsNot(inputList, output) def test_bananaTimeTypes(self): """ Jellying L{datetime.time}, L{datetime.timedelta}, L{datetime.datetime}, and L{datetime.date} objects should result in jellied objects which can be serialized and unserialized with banana. """ sampleDate = datetime.date(2020, 7, 11) sampleTime = datetime.time(1, 16, 5, 344) sampleDateTime = datetime.datetime.combine(sampleDate, sampleTime) sampleTimeDelta = sampleDateTime - datetime.datetime(2020, 7, 3) jellyRoundTrip(self, sampleDate) jellyRoundTrip(self, sampleTime) jellyRoundTrip(self, sampleDateTime) jellyRoundTrip(self, sampleTimeDelta) def test_decimal(self): """ Jellying L{decimal.Decimal} instances and then unjellying the result should produce objects which represent the values of the original inputs. """ inputList = [ decimal.Decimal("9.95"), decimal.Decimal(0), decimal.Decimal(123456), decimal.Decimal("-78.901"), ] c = jelly.jelly(inputList) output = jelly.unjelly(c) self.assertEqual(inputList, output) self.assertIsNot(inputList, output) def test_decimalUnjelly(self): """ Unjellying the s-expressions produced by jelly for L{decimal.Decimal} instances should result in L{decimal.Decimal} instances with the values represented by the s-expressions. This test also verifies that L{decimalData} contains valid jellied data. This is important since L{test_decimalMissing} re-uses L{decimalData} and is expected to be unable to produce L{decimal.Decimal} instances even though the s-expression correctly represents a list of them. """ expected = [ decimal.Decimal("9.95"), decimal.Decimal(0), decimal.Decimal(123456), decimal.Decimal("-78.901"), ] output = jelly.unjelly(self.decimalData) self.assertEqual(output, expected) def test_decimalSecurity(self): """ By default, C{decimal} objects should be allowed by L{jelly.SecurityOptions}. If not allowed, L{jelly.unjelly} should raise L{jelly.InsecureJelly} when trying to unjelly it. """ inputList = [decimal.Decimal("9.95")] self._testSecurity(inputList, b"decimal") def test_set(self): """ Jellying C{set} instances and then unjellying the result should produce objects which represent the values of the original inputs. """ inputList = [{1, 2, 3}] output = jelly.unjelly(jelly.jelly(inputList)) self.assertEqual(inputList, output) self.assertIsNot(inputList, output) def test_frozenset(self): """ Jellying L{frozenset} instances and then unjellying the result should produce objects which represent the values of the original inputs. """ inputList = [frozenset([1, 2, 3])] output = jelly.unjelly(jelly.jelly(inputList)) self.assertEqual(inputList, output) self.assertIsNot(inputList, output) def test_setSecurity(self): """ By default, C{set} objects should be allowed by L{jelly.SecurityOptions}. If not allowed, L{jelly.unjelly} should raise L{jelly.InsecureJelly} when trying to unjelly it. """ inputList = [{1, 2, 3}] self._testSecurity(inputList, b"set") def test_frozensetSecurity(self): """ By default, L{frozenset} objects should be allowed by L{jelly.SecurityOptions}. If not allowed, L{jelly.unjelly} should raise L{jelly.InsecureJelly} when trying to unjelly it. """ inputList = [frozenset([1, 2, 3])] self._testSecurity(inputList, b"frozenset") def test_simple(self): """ Simplest test case. """ self.assertTrue( SimpleJellyTest("a", "b").isTheSameAs(SimpleJellyTest("a", "b")) ) a = SimpleJellyTest(1, 2) cereal = jelly.jelly(a) b = jelly.unjelly(cereal) self.assertTrue(a.isTheSameAs(b)) def test_identity(self): """ Test to make sure that objects retain identity properly. """ x = [] y = x x.append(y) x.append(y) self.assertIs(x[0], x[1]) self.assertIs(x[0][0], x) s = jelly.jelly(x) z = jelly.unjelly(s) self.assertIs(z[0], z[1]) self.assertIs(z[0][0], z) def test_str(self): x = "blah" y = jelly.unjelly(jelly.jelly(x)) self.assertEqual(x, y) self.assertEqual(type(x), type(y)) def test_stressReferences(self): reref = [] toplevelTuple = ({"list": reref}, reref) reref.append(toplevelTuple) s = jelly.jelly(toplevelTuple) z = jelly.unjelly(s) self.assertIs(z[0]["list"], z[1]) self.assertIs(z[0]["list"][0], z) def test_moreReferences(self): a = [] t = (a,) a.append((t,)) s = jelly.jelly(t) z = jelly.unjelly(s) self.assertIs(z[0][0][0], z) def test_typeSecurity(self): """ Test for type-level security of serialization. """ taster = jelly.SecurityOptions() dct = jelly.jelly({}) self.assertRaises(jelly.InsecureJelly, jelly.unjelly, dct, taster) def test_newStyleClasses(self): uj = jelly.unjelly(D) self.assertIs(D, uj) def test_lotsaTypes(self): """ Test for all types currently supported in jelly """ a = A() jelly.unjelly(jelly.jelly(a)) jelly.unjelly(jelly.jelly(a.amethod)) items = [ afunc, [1, 2, 3], not bool(1), bool(1), "test", 20.3, (1, 2, 3), None, A, unittest, {"a": 1}, A.amethod, ] for i in items: self.assertEqual(i, jelly.unjelly(jelly.jelly(i))) def test_setState(self): global TupleState class TupleState: def __init__(self, other): self.other = other def __getstate__(self): return (self.other,) def __setstate__(self, state): self.other = state[0] def __hash__(self): return hash(self.other) a = A() t1 = TupleState(a) t2 = TupleState(a) t3 = TupleState((t1, t2)) d = {t1: t1, t2: t2, t3: t3, "t3": t3} t3prime = jelly.unjelly(jelly.jelly(d))["t3"] self.assertIs(t3prime.other[0].other, t3prime.other[1].other) def test_classSecurity(self): """ Test for class-level security of serialization. """ taster = jelly.SecurityOptions() taster.allowInstancesOf(A, B) a = A() b = B() c = C() # add a little complexity to the data a.b = b a.c = c # and a backreference a.x = b b.c = c # first, a friendly insecure serialization friendly = jelly.jelly(a, taster) x = jelly.unjelly(friendly, taster) self.assertIsInstance(x.c, jelly.Unpersistable) # now, a malicious one mean = jelly.jelly(a) self.assertRaises(jelly.InsecureJelly, jelly.unjelly, mean, taster) self.assertIs(x.x, x.b, "Identity mismatch") # test class serialization friendly = jelly.jelly(A, taster) x = jelly.unjelly(friendly, taster) self.assertIs(x, A, "A came back: %s" % x) def test_unjellyable(self): """ Test that if Unjellyable is used to deserialize a jellied object, state comes out right. """ class JellyableTestClass(jelly.Jellyable): pass jelly.setUnjellyableForClass(JellyableTestClass, jelly.Unjellyable) input = JellyableTestClass() input.attribute = "value" output = jelly.unjelly(jelly.jelly(input)) self.assertEqual(output.attribute, "value") self.assertIsInstance(output, jelly.Unjellyable) def test_persistentStorage(self): perst = [{}, 1] def persistentStore(obj, jel, perst=perst): perst[1] = perst[1] + 1 perst[0][perst[1]] = obj return str(perst[1]) def persistentLoad(pidstr, unj, perst=perst): pid = int(pidstr) return perst[0][pid] a = SimpleJellyTest(1, 2) b = SimpleJellyTest(3, 4) c = SimpleJellyTest(5, 6) a.b = b a.c = c c.b = b jel = jelly.jelly(a, persistentStore=persistentStore) x = jelly.unjelly(jel, persistentLoad=persistentLoad) self.assertIs(x.b, x.c.b) self.assertTrue(perst[0], "persistentStore was not called.") self.assertIs(x.b, a.b, "Persistent storage identity failure.") def test_newStyleClassesAttributes(self): n = TestNode() n1 = TestNode(n) TestNode(n1) TestNode(n) # Jelly it jel = jelly.jelly(n) m = jelly.unjelly(jel) # Check that it has been restored ok self._check_newstyle(n, m) def _check_newstyle(self, a, b): self.assertEqual(a.id, b.id) self.assertEqual(a.classAttr, 4) self.assertEqual(b.classAttr, 4) self.assertEqual(len(a.children), len(b.children)) for x, y in zip(a.children, b.children): self._check_newstyle(x, y) def test_referenceable(self): """ A L{pb.Referenceable} instance jellies to a structure which unjellies to a L{pb.RemoteReference}. The C{RemoteReference} has a I{luid} that matches up with the local object key in the L{pb.Broker} which sent the L{Referenceable}. """ ref = pb.Referenceable() jellyBroker = pb.Broker() jellyBroker.makeConnection(StringTransport()) j = jelly.jelly(ref, invoker=jellyBroker) unjellyBroker = pb.Broker() unjellyBroker.makeConnection(StringTransport()) uj = jelly.unjelly(j, invoker=unjellyBroker) self.assertIn(uj.luid, jellyBroker.localObjects) class JellyDeprecationTests(TestCase): """ Tests for deprecated Jelly things """ def test_deprecatedInstanceAtom(self): """ L{jelly.instance_atom} is deprecated since 15.0.0. """ jelly.instance_atom warnings = self.flushWarnings([self.test_deprecatedInstanceAtom]) self.assertEqual(len(warnings), 1) self.assertEqual( warnings[0]["message"], "twisted.spread.jelly.instance_atom was deprecated in Twisted " "15.0.0: instance_atom is unused within Twisted.", ) self.assertEqual(warnings[0]["category"], DeprecationWarning) def test_deprecatedUnjellyingInstanceAtom(self): """ Unjellying the instance atom is deprecated with 15.0.0. """ jelly.unjelly( ["instance", ["class", "twisted.spread.test.test_jelly.A"], ["dictionary"]] ) warnings = self.flushWarnings() self.assertEqual(len(warnings), 1) self.assertEqual( warnings[0]["message"], "Unjelly support for the instance atom is deprecated since " "Twisted 15.0.0. Upgrade peer for modern instance support.", ) self.assertEqual(warnings[0]["category"], DeprecationWarning) class ClassA(pb.Copyable, pb.RemoteCopy): def __init__(self): self.ref = ClassB(self) class ClassB(pb.Copyable, pb.RemoteCopy): def __init__(self, ref): self.ref = ref class CircularReferenceTests(TestCase): """ Tests for circular references handling in the jelly/unjelly process. """ def test_simpleCircle(self): jelly.setUnjellyableForClass(ClassA, ClassA) jelly.setUnjellyableForClass(ClassB, ClassB) a = jelly.unjelly(jelly.jelly(ClassA())) self.assertIs(a.ref.ref, a, "Identity not preserved in circular reference") def test_circleWithInvoker(self): class DummyInvokerClass: pass dummyInvoker = DummyInvokerClass() dummyInvoker.serializingPerspective = None a0 = ClassA() jelly.setUnjellyableForClass(ClassA, ClassA) jelly.setUnjellyableForClass(ClassB, ClassB) j = jelly.jelly(a0, invoker=dummyInvoker) a1 = jelly.unjelly(j) self.failUnlessIdentical( a1.ref.ref, a1, "Identity not preserved in circular reference" ) def test_set(self): """ Check that a C{set} can contain a circular reference and be serialized and unserialized without losing the reference. """ s = set() a = SimpleJellyTest(s, None) s.add(a) res = jelly.unjelly(jelly.jelly(a)) self.assertIsInstance(res.x, set) self.assertEqual(list(res.x), [res]) def test_frozenset(self): """ Check that a L{frozenset} can contain a circular reference and be serialized and unserialized without losing the reference. """ a = SimpleJellyTest(None, None) s = frozenset([a]) a.x = s res = jelly.unjelly(jelly.jelly(a)) self.assertIsInstance(res.x, frozenset) self.assertEqual(list(res.x), [res]) PK Mb�Zb[0 �7 �7 spread/test/test_banana.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import sys from functools import partial from io import BytesIO from twisted.internet import main, protocol from twisted.python import failure from twisted.python.compat import iterbytes from twisted.spread import banana from twisted.test.proto_helpers import StringTransport from twisted.trial.unittest import TestCase _maxint = 9223372036854775807 class MathTests(TestCase): def test_int2b128(self): funkylist = ( list(range(0, 100)) + list(range(1000, 1100)) + list(range(1000000, 1000100)) + [1024 ** 10] ) for i in funkylist: x = BytesIO() banana.int2b128(i, x.write) v = x.getvalue() y = banana.b1282int(v) self.assertEqual(y, i) def selectDialect(protocol, dialect): """ Dictate a Banana dialect to use. @param protocol: A L{banana.Banana} instance which has not yet had a dialect negotiated. @param dialect: A L{bytes} instance naming a Banana dialect to select. """ # We can't do this the normal way by delivering bytes because other setup # stuff gets in the way (for example, clients and servers have incompatible # negotiations for this step). So use the private API to make this happen. protocol._selectDialect(dialect) def encode(bananaFactory, obj): """ Banana encode an object using L{banana.Banana.sendEncoded}. @param bananaFactory: A no-argument callable which will return a new, unconnected protocol instance to use to do the encoding (this should most likely be a L{banana.Banana} instance). @param obj: The object to encode. @type obj: Any type supported by Banana. @return: A L{bytes} instance giving the encoded form of C{obj}. """ transport = StringTransport() banana = bananaFactory() banana.makeConnection(transport) transport.clear() banana.sendEncoded(obj) return transport.value() class BananaTestBase(TestCase): """ The base for test classes. It defines commonly used things and sets up a connection for testing. """ encClass = banana.Banana def setUp(self): self.io = BytesIO() self.enc = self.encClass() self.enc.makeConnection(protocol.FileWrapper(self.io)) selectDialect(self.enc, b"none") self.enc.expressionReceived = self.putResult self.encode = partial(encode, self.encClass) def putResult(self, result): """ Store an expression received by C{self.enc}. @param result: The object that was received. @type result: Any type supported by Banana. """ self.result = result def tearDown(self): self.enc.connectionLost(failure.Failure(main.CONNECTION_DONE)) del self.enc class BananaTests(BananaTestBase): """ General banana tests. """ def test_string(self): self.enc.sendEncoded(b"hello") self.enc.dataReceived(self.io.getvalue()) assert self.result == b"hello" def test_unsupportedUnicode(self): """ Banana does not support unicode. ``Banana.sendEncoded`` raises ``BananaError`` if called with an instance of ``unicode``. """ self._unsupportedTypeTest("hello", "builtins.str") def test_unsupportedBuiltinType(self): """ Banana does not support arbitrary builtin types like L{type}. L{banana.Banana.sendEncoded} raises L{banana.BananaError} if called with an instance of L{type}. """ # type is an instance of type self._unsupportedTypeTest(type, "builtins.type") def test_unsupportedUserType(self): """ Banana does not support arbitrary user-defined types (such as those defined with the ``class`` statement). ``Banana.sendEncoded`` raises ``BananaError`` if called with an instance of such a type. """ self._unsupportedTypeTest(MathTests(), __name__ + ".MathTests") def _unsupportedTypeTest(self, obj, name): """ Assert that L{banana.Banana.sendEncoded} raises L{banana.BananaError} if called with the given object. @param obj: Some object that Banana does not support. @param name: The name of the type of the object. @raise: The failure exception is raised if L{Banana.sendEncoded} does not raise L{banana.BananaError} or if the message associated with the exception is not formatted to include the type of the unsupported object. """ exc = self.assertRaises(banana.BananaError, self.enc.sendEncoded, obj) self.assertIn(f"Banana cannot send {name} objects", str(exc)) def test_int(self): """ A positive integer less than 2 ** 32 should round-trip through banana without changing value and should come out represented as an C{int} (regardless of the type which was encoded). """ self.enc.sendEncoded(10151) self.enc.dataReceived(self.io.getvalue()) self.assertEqual(self.result, 10151) self.assertIsInstance(self.result, int) def _getSmallest(self): # How many bytes of prefix our implementation allows bytes = self.enc.prefixLimit # How many useful bits we can extract from that based on Banana's # base-128 representation. bits = bytes * 7 # The largest number we _should_ be able to encode largest = 2 ** bits - 1 # The smallest number we _shouldn't_ be able to encode smallest = largest + 1 return smallest def test_encodeTooLargeLong(self): """ Test that a long above the implementation-specific limit is rejected as too large to be encoded. """ smallest = self._getSmallest() self.assertRaises(banana.BananaError, self.enc.sendEncoded, smallest) def test_decodeTooLargeLong(self): """ Test that a long above the implementation specific limit is rejected as too large to be decoded. """ smallest = self._getSmallest() self.enc.setPrefixLimit(self.enc.prefixLimit * 2) self.enc.sendEncoded(smallest) encoded = self.io.getvalue() self.io.truncate(0) self.enc.setPrefixLimit(self.enc.prefixLimit // 2) self.assertRaises(banana.BananaError, self.enc.dataReceived, encoded) def _getLargest(self): return -self._getSmallest() def test_encodeTooSmallLong(self): """ Test that a negative long below the implementation-specific limit is rejected as too small to be encoded. """ largest = self._getLargest() self.assertRaises(banana.BananaError, self.enc.sendEncoded, largest) def test_decodeTooSmallLong(self): """ Test that a negative long below the implementation specific limit is rejected as too small to be decoded. """ largest = self._getLargest() self.enc.setPrefixLimit(self.enc.prefixLimit * 2) self.enc.sendEncoded(largest) encoded = self.io.getvalue() self.io.truncate(0) self.enc.setPrefixLimit(self.enc.prefixLimit // 2) self.assertRaises(banana.BananaError, self.enc.dataReceived, encoded) def test_integer(self): self.enc.sendEncoded(1015) self.enc.dataReceived(self.io.getvalue()) self.assertEqual(self.result, 1015) def test_negative(self): self.enc.sendEncoded(-1015) self.enc.dataReceived(self.io.getvalue()) self.assertEqual(self.result, -1015) def test_float(self): self.enc.sendEncoded(1015.0) self.enc.dataReceived(self.io.getvalue()) self.assertEqual(self.result, 1015.0) def test_list(self): foo = [ 1, 2, [3, 4], [30.5, 40.2], 5, [b"six", b"seven", [b"eight", 9]], [10], [], ] self.enc.sendEncoded(foo) self.enc.dataReceived(self.io.getvalue()) self.assertEqual(self.result, foo) def test_partial(self): """ Test feeding the data byte per byte to the receiver. Normally data is not split. """ foo = [ 1, 2, [3, 4], [30.5, 40.2], 5, [b"six", b"seven", [b"eight", 9]], [10], # TODO: currently the C implementation's a bit buggy... sys.maxsize * 3, sys.maxsize * 2, sys.maxsize * -2, ] self.enc.sendEncoded(foo) self.feed(self.io.getvalue()) self.assertEqual(self.result, foo) def feed(self, data): """ Feed the data byte per byte to the receiver. @param data: The bytes to deliver. @type data: L{bytes} """ for byte in iterbytes(data): self.enc.dataReceived(byte) def test_oversizedList(self): data = b"\x02\x01\x01\x01\x01\x80" # list(size=0x0101010102, about 4.3e9) self.assertRaises(banana.BananaError, self.feed, data) def test_oversizedString(self): data = b"\x02\x01\x01\x01\x01\x82" # string(size=0x0101010102, about 4.3e9) self.assertRaises(banana.BananaError, self.feed, data) def test_crashString(self): crashString = b"\x00\x00\x00\x00\x04\x80" # string(size=0x0400000000, about 17.2e9) # cBanana would fold that into a 32-bit 'int', then try to allocate # a list with PyList_New(). cBanana ignored the NULL return value, # so it would segfault when trying to free the imaginary list. # This variant doesn't segfault straight out in my environment. # Instead, it takes up large amounts of CPU and memory... # crashString = '\x00\x00\x00\x00\x01\x80' # print repr(crashString) # self.failUnlessRaises(Exception, self.enc.dataReceived, crashString) try: # should now raise MemoryError self.enc.dataReceived(crashString) except banana.BananaError: pass def test_crashNegativeLong(self): # There was a bug in cBanana which relied on negating a negative integer # always giving a positive result, but for the lowest possible number in # 2s-complement arithmetic, that's not true, i.e. # long x = -2147483648; # long y = -x; # x == y; /* true! */ # (assuming 32-bit longs) self.enc.sendEncoded(-2147483648) self.enc.dataReceived(self.io.getvalue()) self.assertEqual(self.result, -2147483648) def test_sizedIntegerTypes(self): """ Test that integers below the maximum C{INT} token size cutoff are serialized as C{INT} or C{NEG} and that larger integers are serialized as C{LONGINT} or C{LONGNEG}. """ baseIntIn = +2147483647 baseNegIn = -2147483648 baseIntOut = b"\x7f\x7f\x7f\x07\x81" self.assertEqual(self.encode(baseIntIn - 2), b"\x7d" + baseIntOut) self.assertEqual(self.encode(baseIntIn - 1), b"\x7e" + baseIntOut) self.assertEqual(self.encode(baseIntIn - 0), b"\x7f" + baseIntOut) baseLongIntOut = b"\x00\x00\x00\x08\x85" self.assertEqual(self.encode(baseIntIn + 1), b"\x00" + baseLongIntOut) self.assertEqual(self.encode(baseIntIn + 2), b"\x01" + baseLongIntOut) self.assertEqual(self.encode(baseIntIn + 3), b"\x02" + baseLongIntOut) baseNegOut = b"\x7f\x7f\x7f\x07\x83" self.assertEqual(self.encode(baseNegIn + 2), b"\x7e" + baseNegOut) self.assertEqual(self.encode(baseNegIn + 1), b"\x7f" + baseNegOut) self.assertEqual(self.encode(baseNegIn + 0), b"\x00\x00\x00\x00\x08\x83") baseLongNegOut = b"\x00\x00\x00\x08\x86" self.assertEqual(self.encode(baseNegIn - 1), b"\x01" + baseLongNegOut) self.assertEqual(self.encode(baseNegIn - 2), b"\x02" + baseLongNegOut) self.assertEqual(self.encode(baseNegIn - 3), b"\x03" + baseLongNegOut) class DialectTests(BananaTestBase): """ Tests for Banana's handling of dialects. """ vocab = b"remote" legalPbItem = bytes((banana.Banana.outgoingVocabulary[vocab],)) + banana.VOCAB illegalPbItem = bytes((122,)) + banana.VOCAB def test_dialectNotSet(self): """ If no dialect has been selected and a PB VOCAB item is received, L{NotImplementedError} is raised. """ self.assertRaises(NotImplementedError, self.enc.dataReceived, self.legalPbItem) def test_receivePb(self): """ If the PB dialect has been selected, a PB VOCAB item is accepted. """ selectDialect(self.enc, b"pb") self.enc.dataReceived(self.legalPbItem) self.assertEqual(self.result, self.vocab) def test_receiveIllegalPb(self): """ If the PB dialect has been selected and an unrecognized PB VOCAB item is received, L{banana.Banana.dataReceived} raises L{KeyError}. """ selectDialect(self.enc, b"pb") self.assertRaises(KeyError, self.enc.dataReceived, self.illegalPbItem) def test_sendPb(self): """ if pb dialect is selected, the sender must be able to send things in that dialect. """ selectDialect(self.enc, b"pb") self.enc.sendEncoded(self.vocab) self.assertEqual(self.legalPbItem, self.io.getvalue()) class GlobalCoderTests(TestCase): """ Tests for the free functions L{banana.encode} and L{banana.decode}. """ def test_statelessDecode(self): """ Calls to L{banana.decode} are independent of each other. """ # Banana encoding of 2 ** 449 undecodable = b"\x7f" * 65 + b"\x85" self.assertRaises(banana.BananaError, banana.decode, undecodable) # Banana encoding of 1. This should be decodable even though the # previous call passed un-decodable data and triggered an exception. decodable = b"\x01\x81" self.assertEqual(banana.decode(decodable), 1) PK Mb�Z�.�8� 8� spread/test/test_pb.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for Perspective Broker module. TODO: update protocol level tests to use new connection API, leaving only specific tests for old API. """ # issue1195 TODOs: replace pump.pump() with something involving Deferreds. # Clean up warning suppression. import gc import os import sys import time import weakref from collections import deque from io import BytesIO as StringIO from typing import Dict from zope.interface import Interface, implementer from twisted.cred import checkers, credentials, portal from twisted.cred.error import UnauthorizedLogin, UnhandledCredentials from twisted.internet import address, main, protocol, reactor from twisted.internet.defer import Deferred, gatherResults, succeed from twisted.internet.error import ConnectionRefusedError from twisted.protocols.policies import WrappingFactory from twisted.python import failure, log from twisted.python.compat import iterbytes from twisted.spread import jelly, pb, publish, util from twisted.test.proto_helpers import _FakeConnector from twisted.trial import unittest class Dummy(pb.Viewable): def view_doNothing(self, user): if isinstance(user, DummyPerspective): return "hello world!" else: return "goodbye, cruel world!" class DummyPerspective(pb.Avatar): """ An L{IPerspective} avatar which will be used in some tests. """ def perspective_getDummyViewPoint(self): return Dummy() @implementer(portal.IRealm) class DummyRealm: def requestAvatar(self, avatarId, mind, *interfaces): for iface in interfaces: if iface is pb.IPerspective: return iface, DummyPerspective(avatarId), lambda: None class IOPump: """ Utility to pump data between clients and servers for protocol testing. Perhaps this is a utility worthy of being in protocol.py? """ def __init__(self, client, server, clientIO, serverIO): self.client = client self.server = server self.clientIO = clientIO self.serverIO = serverIO def flush(self): """ Pump until there is no more input or output or until L{stop} is called. This does not run any timers, so don't use it with any code that calls reactor.callLater. """ # failsafe timeout self._stop = False timeout = time.time() + 5 while not self._stop and self.pump(): if time.time() > timeout: return def stop(self): """ Stop a running L{flush} operation, even if data remains to be transferred. """ self._stop = True def pump(self): """ Move data back and forth. Returns whether any data was moved. """ self.clientIO.seek(0) self.serverIO.seek(0) cData = self.clientIO.read() sData = self.serverIO.read() self.clientIO.seek(0) self.serverIO.seek(0) self.clientIO.truncate() self.serverIO.truncate() self.client.transport._checkProducer() self.server.transport._checkProducer() for byte in iterbytes(cData): self.server.dataReceived(byte) for byte in iterbytes(sData): self.client.dataReceived(byte) if cData or sData: return 1 else: return 0 def connectServerAndClient(test, clientFactory, serverFactory): """ Create a server and a client and connect the two with an L{IOPump}. @param test: the test case where the client and server will be used. @type test: L{twisted.trial.unittest.TestCase} @param clientFactory: The factory that creates the client object. @type clientFactory: L{twisted.spread.pb.PBClientFactory} @param serverFactory: The factory that creates the server object. @type serverFactory: L{twisted.spread.pb.PBServerFactory} @return: a 3-tuple of (client, server, pump) @rtype: (L{twisted.spread.pb.Broker}, L{twisted.spread.pb.Broker}, L{IOPump}) """ addr = ("127.0.0.1",) clientBroker = clientFactory.buildProtocol(addr) serverBroker = serverFactory.buildProtocol(addr) clientTransport = StringIO() serverTransport = StringIO() clientBroker.makeConnection(protocol.FileWrapper(clientTransport)) serverBroker.makeConnection(protocol.FileWrapper(serverTransport)) pump = IOPump(clientBroker, serverBroker, clientTransport, serverTransport) def maybeDisconnect(broker): if not broker.disconnected: broker.connectionLost(failure.Failure(main.CONNECTION_DONE)) def disconnectClientFactory(): # There's no connector, just a FileWrapper mediated by the # IOPump. Fortunately PBClientFactory.clientConnectionLost # doesn't do anything with the connector so we can get away # with passing None here. clientFactory.clientConnectionLost( connector=None, reason=failure.Failure(main.CONNECTION_DONE) ) test.addCleanup(maybeDisconnect, clientBroker) test.addCleanup(maybeDisconnect, serverBroker) test.addCleanup(disconnectClientFactory) # Establish the connection pump.pump() return clientBroker, serverBroker, pump class _ReconnectingFakeConnectorState: """ Manages connection notifications for a L{_ReconnectingFakeConnector} instance. @ivar notifications: pending L{Deferreds} that will fire when the L{_ReconnectingFakeConnector}'s connect method is called """ def __init__(self): self.notifications = deque() def notifyOnConnect(self): """ Connection notification. @return: A L{Deferred} that fires when this instance's L{twisted.internet.interfaces.IConnector.connect} method is called. @rtype: L{Deferred} """ notifier = Deferred() self.notifications.appendleft(notifier) return notifier def notifyAll(self): """ Fire all pending notifications. """ while self.notifications: self.notifications.pop().callback(self) class _ReconnectingFakeConnector(_FakeConnector): """ A fake L{IConnector} that can fire L{Deferred}s when its C{connect} method is called. """ def __init__(self, address, state): """ @param address: An L{IAddress} provider that represents this connector's destination. @type address: An L{IAddress} provider. @param state: The state instance @type state: L{_ReconnectingFakeConnectorState} """ super().__init__(address) self._state = state def connect(self): """ A C{connect} implementation that calls C{reconnectCallback} """ super().connect() self._state.notifyAll() def connectedServerAndClient(test, realm=None): """ Connect a client and server L{Broker} together with an L{IOPump} @param realm: realm to use, defaulting to a L{DummyRealm} @returns: a 3-tuple (client, server, pump). """ realm = realm or DummyRealm() checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(guest=b"guest") serverFactory = pb.PBServerFactory(portal.Portal(realm, [checker])) clientFactory = pb.PBClientFactory() return connectServerAndClient(test, clientFactory, serverFactory) class SimpleRemote(pb.Referenceable): def remote_thunk(self, arg): self.arg = arg return arg + 1 def remote_knuth(self, arg): raise Exception() class NestedRemote(pb.Referenceable): def remote_getSimple(self): return SimpleRemote() class SimpleCopy(pb.Copyable): def __init__(self): self.x = 1 self.y = {"Hello": "World"} self.z = ["test"] class SimpleLocalCopy(pb.RemoteCopy): pass pb.setUnjellyableForClass(SimpleCopy, SimpleLocalCopy) class SimpleFactoryCopy(pb.Copyable): """ @cvar allIDs: hold every created instances of this class. @type allIDs: C{dict} """ allIDs: Dict[int, "SimpleFactoryCopy"] = {} def __init__(self, id): self.id = id SimpleFactoryCopy.allIDs[id] = self def createFactoryCopy(state): """ Factory of L{SimpleFactoryCopy}, getting a created instance given the C{id} found in C{state}. """ stateId = state.get("id", None) if stateId is None: raise RuntimeError(f"factory copy state has no 'id' member {repr(state)}") if stateId not in SimpleFactoryCopy.allIDs: raise RuntimeError(f"factory class has no ID: {SimpleFactoryCopy.allIDs}") inst = SimpleFactoryCopy.allIDs[stateId] if not inst: raise RuntimeError("factory method found no object with id") return inst pb.setUnjellyableFactoryForClass(SimpleFactoryCopy, createFactoryCopy) class NestedCopy(pb.Referenceable): def remote_getCopy(self): return SimpleCopy() def remote_getFactory(self, value): return SimpleFactoryCopy(value) class SimpleCache(pb.Cacheable): def __init___(self): self.x = 1 self.y = {"Hello": "World"} self.z = ["test"] class NestedComplicatedCache(pb.Referenceable): def __init__(self): self.c = VeryVeryComplicatedCacheable() def remote_getCache(self): return self.c class VeryVeryComplicatedCacheable(pb.Cacheable): def __init__(self): self.x = 1 self.y = 2 self.foo = 3 def setFoo4(self): self.foo = 4 self.observer.callRemote("foo", 4) def getStateToCacheAndObserveFor(self, perspective, observer): self.observer = observer return {"x": self.x, "y": self.y, "foo": self.foo} def stoppedObserving(self, perspective, observer): log.msg("stopped observing") observer.callRemote("end") if observer == self.observer: self.observer = None class RatherBaroqueCache(pb.RemoteCache): def observe_foo(self, newFoo): self.foo = newFoo def observe_end(self): log.msg("the end of things") pb.setUnjellyableForClass(VeryVeryComplicatedCacheable, RatherBaroqueCache) class SimpleLocalCache(pb.RemoteCache): def setCopyableState(self, state): self.__dict__.update(state) def checkMethod(self): return self.check def checkSelf(self): return self def check(self): return 1 pb.setUnjellyableForClass(SimpleCache, SimpleLocalCache) class NestedCache(pb.Referenceable): def __init__(self): self.x = SimpleCache() def remote_getCache(self): return [self.x, self.x] def remote_putCache(self, cache): return self.x is cache class Observable(pb.Referenceable): def __init__(self): self.observers = [] def remote_observe(self, obs): self.observers.append(obs) def remote_unobserve(self, obs): self.observers.remove(obs) def notify(self, obj): for observer in self.observers: observer.callRemote("notify", self, obj) class DeferredRemote(pb.Referenceable): def __init__(self): self.run = 0 def runMe(self, arg): self.run = arg return arg + 1 def dontRunMe(self, arg): assert 0, "shouldn't have been run!" def remote_doItLater(self): """ Return a L{Deferred} to be fired on client side. When fired, C{self.runMe} is called. """ d = Deferred() d.addCallbacks(self.runMe, self.dontRunMe) self.d = d return d class Observer(pb.Referenceable): notified = 0 obj = None def remote_notify(self, other, obj): self.obj = obj self.notified = self.notified + 1 other.callRemote("unobserve", self) class NewStyleCopy(pb.Copyable, pb.RemoteCopy): def __init__(self, s): self.s = s pb.setUnjellyableForClass(NewStyleCopy, NewStyleCopy) class NewStyleCopy2(pb.Copyable, pb.RemoteCopy): allocated = 0 initialized = 0 value = 1 def __new__(self): NewStyleCopy2.allocated += 1 inst = object.__new__(self) inst.value = 2 return inst def __init__(self): NewStyleCopy2.initialized += 1 pb.setUnjellyableForClass(NewStyleCopy2, NewStyleCopy2) class NewStyleCacheCopy(pb.Cacheable, pb.RemoteCache): def getStateToCacheAndObserveFor(self, perspective, observer): return self.__dict__ pb.setUnjellyableForClass(NewStyleCacheCopy, NewStyleCacheCopy) class Echoer(pb.Root): def remote_echo(self, st): return st def remote_echoWithKeywords(self, st, **kw): return (st, kw) class CachedReturner(pb.Root): def __init__(self, cache): self.cache = cache def remote_giveMeCache(self, st): return self.cache class NewStyleTests(unittest.SynchronousTestCase): def setUp(self): """ Create a pb server using L{Echoer} protocol and connect a client to it. """ self.serverFactory = pb.PBServerFactory(Echoer()) clientFactory = pb.PBClientFactory() client, self.server, self.pump = connectServerAndClient( test=self, clientFactory=clientFactory, serverFactory=self.serverFactory ) self.ref = self.successResultOf(clientFactory.getRootObject()) def tearDown(self): """ Close client and server connections, reset values of L{NewStyleCopy2} class variables. """ NewStyleCopy2.allocated = 0 NewStyleCopy2.initialized = 0 NewStyleCopy2.value = 1 def test_newStyle(self): """ Create a new style object, send it over the wire, and check the result. """ orig = NewStyleCopy("value") d = self.ref.callRemote("echo", orig) self.pump.flush() def cb(res): self.assertIsInstance(res, NewStyleCopy) self.assertEqual(res.s, "value") self.assertFalse(res is orig) # no cheating :) d.addCallback(cb) return d def test_alloc(self): """ Send a new style object and check the number of allocations. """ orig = NewStyleCopy2() self.assertEqual(NewStyleCopy2.allocated, 1) self.assertEqual(NewStyleCopy2.initialized, 1) d = self.ref.callRemote("echo", orig) self.pump.flush() def cb(res): # Receiving the response creates a third one on the way back self.assertIsInstance(res, NewStyleCopy2) self.assertEqual(res.value, 2) self.assertEqual(NewStyleCopy2.allocated, 3) self.assertEqual(NewStyleCopy2.initialized, 1) self.assertIsNot(res, orig) # No cheating :) # Sending the object creates a second one on the far side d.addCallback(cb) return d def test_newStyleWithKeywords(self): """ Create a new style object with keywords, send it over the wire, and check the result. """ orig = NewStyleCopy("value1") d = self.ref.callRemote( "echoWithKeywords", orig, keyword1="one", keyword2="two" ) self.pump.flush() def cb(res): self.assertIsInstance(res, tuple) self.assertIsInstance(res[0], NewStyleCopy) self.assertIsInstance(res[1], dict) self.assertEqual(res[0].s, "value1") self.assertIsNot(res[0], orig) self.assertEqual(res[1], {"keyword1": "one", "keyword2": "two"}) d.addCallback(cb) return d class ConnectionNotifyServerFactory(pb.PBServerFactory): """ A server factory which stores the last connection and fires a L{Deferred} on connection made. This factory can handle only one client connection. @ivar protocolInstance: the last protocol instance. @type protocolInstance: C{pb.Broker} @ivar connectionMade: the deferred fired upon connection. @type connectionMade: C{Deferred} """ protocolInstance = None def __init__(self, root): """ Initialize the factory. """ pb.PBServerFactory.__init__(self, root) self.connectionMade = Deferred() def clientConnectionMade(self, protocol): """ Store the protocol and fire the connection deferred. """ self.protocolInstance = protocol d, self.connectionMade = self.connectionMade, None if d is not None: d.callback(None) class NewStyleCachedTests(unittest.TestCase): def setUp(self): """ Create a pb server using L{CachedReturner} protocol and connect a client to it. """ self.orig = NewStyleCacheCopy() self.orig.s = "value" self.server = reactor.listenTCP( 0, ConnectionNotifyServerFactory(CachedReturner(self.orig)) ) clientFactory = pb.PBClientFactory() reactor.connectTCP("localhost", self.server.getHost().port, clientFactory) def gotRoot(ref): self.ref = ref d1 = clientFactory.getRootObject().addCallback(gotRoot) d2 = self.server.factory.connectionMade return gatherResults([d1, d2]) def tearDown(self): """ Close client and server connections. """ self.server.factory.protocolInstance.transport.loseConnection() self.ref.broker.transport.loseConnection() return self.server.stopListening() def test_newStyleCache(self): """ A new-style cacheable object can be retrieved and re-retrieved over a single connection. The value of an attribute of the cacheable can be accessed on the receiving side. """ d = self.ref.callRemote("giveMeCache", self.orig) def cb(res, again): self.assertIsInstance(res, NewStyleCacheCopy) self.assertEqual("value", res.s) # no cheating :) self.assertIsNot(self.orig, res) if again: # Save a reference so it stays alive for the rest of this test self.res = res # And ask for it again to exercise the special re-jelly logic in # Cacheable. return self.ref.callRemote("giveMeCache", self.orig) d.addCallback(cb, True) d.addCallback(cb, False) return d class BrokerTests(unittest.TestCase): thunkResult = None def tearDown(self): try: # from RemotePublished.getFileName os.unlink("None-None-TESTING.pub") except OSError: pass def thunkErrorBad(self, error): self.fail(f"This should cause a return value, not {error}") def thunkResultGood(self, result): self.thunkResult = result def thunkErrorGood(self, tb): pass def thunkResultBad(self, result): self.fail(f"This should cause an error, not {result}") def test_reference(self): c, s, pump = connectedServerAndClient(test=self) class X(pb.Referenceable): def remote_catch(self, arg): self.caught = arg class Y(pb.Referenceable): def remote_throw(self, a, b): a.callRemote("catch", b) s.setNameForLocal("y", Y()) y = c.remoteForName("y") x = X() z = X() y.callRemote("throw", x, z) pump.pump() pump.pump() pump.pump() self.assertIs(x.caught, z, "X should have caught Z") # make sure references to remote methods are equals self.assertEqual(y.remoteMethod("throw"), y.remoteMethod("throw")) def test_result(self): c, s, pump = connectedServerAndClient(test=self) for x, y in (c, s), (s, c): # test reflexivity foo = SimpleRemote() x.setNameForLocal("foo", foo) bar = y.remoteForName("foo") self.expectedThunkResult = 8 bar.callRemote("thunk", self.expectedThunkResult - 1).addCallbacks( self.thunkResultGood, self.thunkErrorBad ) # Send question. pump.pump() # Send response. pump.pump() # Shouldn't require any more pumping than that... self.assertEqual( self.thunkResult, self.expectedThunkResult, "result wasn't received." ) def refcountResult(self, result): self.nestedRemote = result def test_tooManyRefs(self): l = [] e = [] c, s, pump = connectedServerAndClient(test=self) foo = NestedRemote() s.setNameForLocal("foo", foo) x = c.remoteForName("foo") for igno in range(pb.MAX_BROKER_REFS + 10): if s.transport.closed or c.transport.closed: break x.callRemote("getSimple").addCallbacks(l.append, e.append) pump.pump() expected = pb.MAX_BROKER_REFS - 1 self.assertTrue(s.transport.closed, "transport was not closed") self.assertEqual(len(l), expected, f"expected {expected} got {len(l)}") def test_copy(self): c, s, pump = connectedServerAndClient(test=self) foo = NestedCopy() s.setNameForLocal("foo", foo) x = c.remoteForName("foo") x.callRemote("getCopy").addCallbacks(self.thunkResultGood, self.thunkErrorBad) pump.pump() pump.pump() self.assertEqual(self.thunkResult.x, 1) self.assertEqual(self.thunkResult.y["Hello"], "World") self.assertEqual(self.thunkResult.z[0], "test") def test_observe(self): c, s, pump = connectedServerAndClient(test=self) # this is really testing the comparison between remote objects, to make # sure that you can *UN*observe when you have an observer architecture. a = Observable() b = Observer() s.setNameForLocal("a", a) ra = c.remoteForName("a") ra.callRemote("observe", b) pump.pump() a.notify(1) pump.pump() pump.pump() a.notify(10) pump.pump() pump.pump() self.assertIsNotNone(b.obj, "didn't notify") self.assertEqual(b.obj, 1, "notified too much") def test_defer(self): c, s, pump = connectedServerAndClient(test=self) d = DeferredRemote() s.setNameForLocal("d", d) e = c.remoteForName("d") pump.pump() pump.pump() results = [] e.callRemote("doItLater").addCallback(results.append) pump.pump() pump.pump() self.assertFalse(d.run, "Deferred method run too early.") d.d.callback(5) self.assertEqual(d.run, 5, "Deferred method run too late.") pump.pump() pump.pump() self.assertEqual(results[0], 6, "Incorrect result.") def test_refcount(self): c, s, pump = connectedServerAndClient(test=self) foo = NestedRemote() s.setNameForLocal("foo", foo) bar = c.remoteForName("foo") bar.callRemote("getSimple").addCallbacks( self.refcountResult, self.thunkErrorBad ) # send question pump.pump() # send response pump.pump() # delving into internal structures here, because GC is sort of # inherently internal. rluid = self.nestedRemote.luid self.assertIn(rluid, s.localObjects) del self.nestedRemote # nudge the gc if sys.hexversion >= 0x2000000: gc.collect() # try to nudge the GC even if we can't really pump.pump() pump.pump() pump.pump() self.assertNotIn(rluid, s.localObjects) def test_cache(self): c, s, pump = connectedServerAndClient(test=self) obj = NestedCache() obj2 = NestedComplicatedCache() vcc = obj2.c s.setNameForLocal("obj", obj) s.setNameForLocal("xxx", obj2) o2 = c.remoteForName("obj") o3 = c.remoteForName("xxx") coll = [] o2.callRemote("getCache").addCallback(coll.append).addErrback(coll.append) o2.callRemote("getCache").addCallback(coll.append).addErrback(coll.append) complex = [] o3.callRemote("getCache").addCallback(complex.append) o3.callRemote("getCache").addCallback(complex.append) pump.flush() # `worst things first' self.assertEqual(complex[0].x, 1) self.assertEqual(complex[0].y, 2) self.assertEqual(complex[0].foo, 3) vcc.setFoo4() pump.flush() self.assertEqual(complex[0].foo, 4) self.assertEqual(len(coll), 2) cp = coll[0][0] self.assertIdentical( cp.checkMethod().__self__, cp, "potential refcounting issue" ) self.assertIdentical(cp.checkSelf(), cp, "other potential refcounting issue") col2 = [] o2.callRemote("putCache", cp).addCallback(col2.append) pump.flush() # The objects were the same (testing lcache identity) self.assertTrue(col2[0]) # test equality of references to methods self.assertEqual(o2.remoteMethod("getCache"), o2.remoteMethod("getCache")) # now, refcounting (similar to testRefCount) luid = cp.luid baroqueLuid = complex[0].luid self.assertIn(luid, s.remotelyCachedObjects, "remote cache doesn't have it") del coll del cp pump.flush() del complex del col2 # extra nudge... pump.flush() # del vcc.observer # nudge the gc if sys.hexversion >= 0x2000000: gc.collect() # try to nudge the GC even if we can't really pump.flush() # The GC is done with it. self.assertNotIn(luid, s.remotelyCachedObjects, "Server still had it after GC") self.assertNotIn(luid, c.locallyCachedObjects, "Client still had it after GC") self.assertNotIn( baroqueLuid, s.remotelyCachedObjects, "Server still had complex after GC" ) self.assertNotIn( baroqueLuid, c.locallyCachedObjects, "Client still had complex after GC" ) self.assertIsNone(vcc.observer, "observer was not removed") def test_publishable(self): try: os.unlink("None-None-TESTING.pub") # from RemotePublished.getFileName except OSError: pass # Sometimes it's not there. c, s, pump = connectedServerAndClient(test=self) foo = GetPublisher() # foo.pub.timestamp = 1.0 s.setNameForLocal("foo", foo) bar = c.remoteForName("foo") accum = [] bar.callRemote("getPub").addCallbacks(accum.append, self.thunkErrorBad) pump.flush() obj = accum.pop() self.assertEqual(obj.activateCalled, 1) self.assertEqual(obj.isActivated, 1) self.assertEqual(obj.yayIGotPublished, 1) # timestamp's dirty, we don't have a cache file self.assertEqual(obj._wasCleanWhenLoaded, 0) c, s, pump = connectedServerAndClient(test=self) s.setNameForLocal("foo", foo) bar = c.remoteForName("foo") bar.callRemote("getPub").addCallbacks(accum.append, self.thunkErrorBad) pump.flush() obj = accum.pop() # timestamp's clean, our cache file is up-to-date self.assertEqual(obj._wasCleanWhenLoaded, 1) def gotCopy(self, val): self.thunkResult = val.id def test_factoryCopy(self): c, s, pump = connectedServerAndClient(test=self) ID = 99 obj = NestedCopy() s.setNameForLocal("foo", obj) x = c.remoteForName("foo") x.callRemote("getFactory", ID).addCallbacks(self.gotCopy, self.thunkResultBad) pump.pump() pump.pump() pump.pump() self.assertEqual( self.thunkResult, ID, f"ID not correct on factory object {self.thunkResult}", ) bigString = b"helloworld" * 50 callbackArgs = None callbackKeyword = None def finishedCallback(*args, **kw): global callbackArgs, callbackKeyword callbackArgs = args callbackKeyword = kw class Pagerizer(pb.Referenceable): def __init__(self, callback, *args, **kw): self.callback, self.args, self.kw = callback, args, kw def remote_getPages(self, collector): util.StringPager( collector, bigString, 100, self.callback, *self.args, **self.kw ) self.args = self.kw = None class FilePagerizer(pb.Referenceable): pager = None def __init__(self, filename, callback, *args, **kw): self.filename = filename self.callback, self.args, self.kw = callback, args, kw def remote_getPages(self, collector): self.pager = util.FilePager( collector, open(self.filename, "rb"), self.callback, *self.args, **self.kw ) self.args = self.kw = None class PagingTests(unittest.TestCase): """ Test pb objects sending data by pages. """ def setUp(self): """ Create a file used to test L{util.FilePager}. """ self.filename = self.mktemp() with open(self.filename, "wb") as f: f.write(bigString) def test_pagingWithCallback(self): """ Test L{util.StringPager}, passing a callback to fire when all pages are sent. """ c, s, pump = connectedServerAndClient(test=self) s.setNameForLocal("foo", Pagerizer(finishedCallback, "hello", value=10)) x = c.remoteForName("foo") l = [] util.getAllPages(x, "getPages").addCallback(l.append) while not l: pump.pump() self.assertEqual( b"".join(l[0]), bigString, "Pages received not equal to pages sent!" ) self.assertEqual(callbackArgs, ("hello",), "Completed callback not invoked") self.assertEqual( callbackKeyword, {"value": 10}, "Completed callback not invoked" ) def test_pagingWithoutCallback(self): """ Test L{util.StringPager} without a callback. """ c, s, pump = connectedServerAndClient(test=self) s.setNameForLocal("foo", Pagerizer(None)) x = c.remoteForName("foo") l = [] util.getAllPages(x, "getPages").addCallback(l.append) while not l: pump.pump() self.assertEqual( b"".join(l[0]), bigString, "Pages received not equal to pages sent!" ) def test_emptyFilePaging(self): """ Test L{util.FilePager}, sending an empty file. """ filenameEmpty = self.mktemp() open(filenameEmpty, "w").close() c, s, pump = connectedServerAndClient(test=self) pagerizer = FilePagerizer(filenameEmpty, None) s.setNameForLocal("bar", pagerizer) x = c.remoteForName("bar") l = [] util.getAllPages(x, "getPages").addCallback(l.append) ttl = 10 while not l and ttl > 0: pump.pump() ttl -= 1 if not ttl: self.fail("getAllPages timed out") self.assertEqual(b"".join(l[0]), b"", "Pages received not equal to pages sent!") def test_filePagingWithCallback(self): """ Test L{util.FilePager}, passing a callback to fire when all pages are sent, and verify that the pager doesn't keep chunks in memory. """ c, s, pump = connectedServerAndClient(test=self) pagerizer = FilePagerizer(self.filename, finishedCallback, "frodo", value=9) s.setNameForLocal("bar", pagerizer) x = c.remoteForName("bar") l = [] util.getAllPages(x, "getPages").addCallback(l.append) while not l: pump.pump() self.assertEqual( b"".join(l[0]), bigString, "Pages received not equal to pages sent!" ) self.assertEqual(callbackArgs, ("frodo",), "Completed callback not invoked") self.assertEqual( callbackKeyword, {"value": 9}, "Completed callback not invoked" ) self.assertEqual(pagerizer.pager.chunks, []) def test_filePagingWithoutCallback(self): """ Test L{util.FilePager} without a callback. """ c, s, pump = connectedServerAndClient(test=self) pagerizer = FilePagerizer(self.filename, None) s.setNameForLocal("bar", pagerizer) x = c.remoteForName("bar") l = [] util.getAllPages(x, "getPages").addCallback(l.append) while not l: pump.pump() self.assertEqual( b"".join(l[0]), bigString, "Pages received not equal to pages sent!" ) self.assertEqual(pagerizer.pager.chunks, []) class DumbPublishable(publish.Publishable): def getStateToPublish(self): return {"yayIGotPublished": 1} class DumbPub(publish.RemotePublished): def activated(self): self.activateCalled = 1 class GetPublisher(pb.Referenceable): def __init__(self): self.pub = DumbPublishable("TESTING") def remote_getPub(self): return self.pub pb.setUnjellyableForClass(DumbPublishable, DumbPub) class DisconnectionTests(unittest.TestCase): """ Test disconnection callbacks. """ def error(self, *args): raise RuntimeError(f"I shouldn't have been called: {args}") def gotDisconnected(self): """ Called on broker disconnect. """ self.gotCallback = 1 def objectDisconnected(self, o): """ Called on RemoteReference disconnect. """ self.assertEqual(o, self.remoteObject) self.objectCallback = 1 def test_badSerialization(self): c, s, pump = connectedServerAndClient(test=self) pump.pump() s.setNameForLocal("o", BadCopySet()) g = c.remoteForName("o") l = [] g.callRemote("setBadCopy", BadCopyable()).addErrback(l.append) pump.flush() self.assertEqual(len(l), 1) def test_disconnection(self): c, s, pump = connectedServerAndClient(test=self) pump.pump() s.setNameForLocal("o", SimpleRemote()) # get a client reference to server object r = c.remoteForName("o") pump.pump() pump.pump() pump.pump() # register and then unregister disconnect callbacks # making sure they get unregistered c.notifyOnDisconnect(self.error) self.assertIn(self.error, c.disconnects) c.dontNotifyOnDisconnect(self.error) self.assertNotIn(self.error, c.disconnects) r.notifyOnDisconnect(self.error) self.assertIn(r._disconnected, c.disconnects) self.assertIn(self.error, r.disconnectCallbacks) r.dontNotifyOnDisconnect(self.error) self.assertNotIn(r._disconnected, c.disconnects) self.assertNotIn(self.error, r.disconnectCallbacks) # register disconnect callbacks c.notifyOnDisconnect(self.gotDisconnected) r.notifyOnDisconnect(self.objectDisconnected) self.remoteObject = r # disconnect c.connectionLost(failure.Failure(main.CONNECTION_DONE)) self.assertTrue(self.gotCallback) self.assertTrue(self.objectCallback) class FreakOut(Exception): pass class BadCopyable(pb.Copyable): def getStateToCopyFor(self, p): raise FreakOut() class BadCopySet(pb.Referenceable): def remote_setBadCopy(self, bc): return None class LocalRemoteTest(util.LocalAsRemote): reportAllTracebacks = 0 def sync_add1(self, x): return x + 1 def async_add(self, x=0, y=1): return x + y def async_fail(self): raise RuntimeError() @implementer(pb.IPerspective) class MyPerspective(pb.Avatar): """ @ivar loggedIn: set to C{True} when the avatar is logged in. @type loggedIn: C{bool} @ivar loggedOut: set to C{True} when the avatar is logged out. @type loggedOut: C{bool} """ loggedIn = loggedOut = False def __init__(self, avatarId): self.avatarId = avatarId def perspective_getAvatarId(self): """ Return the avatar identifier which was used to access this avatar. """ return self.avatarId def perspective_getViewPoint(self): return MyView() def perspective_add(self, a, b): """ Add the given objects and return the result. This is a method unavailable on L{Echoer}, so it can only be invoked by authenticated users who received their avatar from L{TestRealm}. """ return a + b def logout(self): self.loggedOut = True class TestRealm: """ A realm which repeatedly gives out a single instance of L{MyPerspective} for non-anonymous logins and which gives out a new instance of L{Echoer} for each anonymous login. @ivar lastPerspective: The L{MyPerspective} most recently created and returned from C{requestAvatar}. @ivar perspectiveFactory: A one-argument callable which will be used to create avatars to be returned from C{requestAvatar}. """ perspectiveFactory = MyPerspective lastPerspective = None def requestAvatar(self, avatarId, mind, interface): """ Verify that the mind and interface supplied have the expected values (this should really be done somewhere else, like inside a test method) and return an avatar appropriate for the given identifier. """ assert interface == pb.IPerspective assert mind == "BRAINS!" if avatarId is checkers.ANONYMOUS: return pb.IPerspective, Echoer(), lambda: None else: self.lastPerspective = self.perspectiveFactory(avatarId) self.lastPerspective.loggedIn = True return (pb.IPerspective, self.lastPerspective, self.lastPerspective.logout) class MyView(pb.Viewable): def view_check(self, user): return isinstance(user, MyPerspective) class LeakyRealm(TestRealm): """ A realm which hangs onto a reference to the mind object in its logout function. """ def __init__(self, mindEater): """ Create a L{LeakyRealm}. @param mindEater: a callable that will be called with the C{mind} object when it is available """ self._mindEater = mindEater def requestAvatar(self, avatarId, mind, interface): self._mindEater(mind) persp = self.perspectiveFactory(avatarId) return (pb.IPerspective, persp, lambda: (mind, persp.logout())) class NewCredLeakTests(unittest.TestCase): """ Tests to try to trigger memory leaks. """ def test_logoutLeak(self): """ The server does not leak a reference when the client disconnects suddenly, even if the cred logout function forms a reference cycle with the perspective. """ # keep a weak reference to the mind object, which we can verify later # evaluates to None, thereby ensuring the reference leak is fixed. self.mindRef = None def setMindRef(mind): self.mindRef = weakref.ref(mind) clientBroker, serverBroker, pump = connectedServerAndClient( test=self, realm=LeakyRealm(setMindRef) ) # log in from the client connectionBroken = [] root = clientBroker.remoteForName("root") d = root.callRemote("login", b"guest") def cbResponse(x): challenge, challenger = x mind = SimpleRemote() return challenger.callRemote( "respond", pb.respond(challenge, b"guest"), mind ) d.addCallback(cbResponse) def connectionLost(_): pump.stop() # don't try to pump data anymore - it won't work connectionBroken.append(1) serverBroker.connectionLost(failure.Failure(RuntimeError("boom"))) d.addCallback(connectionLost) # flush out the response and connectionLost pump.flush() self.assertEqual(connectionBroken, [1]) # and check for lingering references - requestAvatar sets mindRef # to a weakref to the mind; this object should be gc'd, and thus # the ref should return None gc.collect() self.assertIsNone(self.mindRef()) class NewCredTests(unittest.TestCase): """ Tests related to the L{twisted.cred} support in PB. """ def setUp(self): """ Create a portal with no checkers and wrap it around a simple test realm. Set up a PB server on a TCP port which serves perspectives using that portal. """ self.realm = TestRealm() self.portal = portal.Portal(self.realm) self.serverFactory = ConnectionNotifyServerFactory(self.portal) self.clientFactory = pb.PBClientFactory() def establishClientAndServer(self, _ignored=None): """ Connect a client obtained from C{clientFactory} and a server obtained from the current server factory via an L{IOPump}, then assign them to the appropriate instance variables @ivar clientFactory: the broker client factory @ivar clientFactory: L{pb.PBClientFactory} instance @ivar client: the client broker @type client: L{pb.Broker} @ivar server: the server broker @type server: L{pb.Broker} @ivar pump: the IOPump connecting the client and server @type pump: L{IOPump} @ivar connector: A connector whose connect method recreates the above instance variables @type connector: L{twisted.internet.base.IConnector} """ self.client, self.server, self.pump = connectServerAndClient( self, self.clientFactory, self.serverFactory ) self.connectorState = _ReconnectingFakeConnectorState() self.connector = _ReconnectingFakeConnector( address.IPv4Address("TCP", "127.0.0.1", 4321), self.connectorState ) self.connectorState.notifyOnConnect().addCallback(self.establishClientAndServer) def completeClientLostConnection( self, reason=failure.Failure(main.CONNECTION_DONE) ): """ Asserts that the client broker's transport was closed and then mimics the event loop by calling the broker's connectionLost callback with C{reason}, followed by C{self.clientFactory}'s C{clientConnectionLost} @param reason: (optional) the reason to pass to the client broker's connectionLost callback @type reason: L{Failure} """ self.assertTrue(self.client.transport.closed) # simulate the reactor calling back the client's # connectionLost after the loseConnection implied by # clientFactory.disconnect self.client.connectionLost(reason) self.clientFactory.clientConnectionLost(self.connector, reason) def test_getRootObject(self): """ Assert that L{PBClientFactory.getRootObject}'s Deferred fires with a L{RemoteReference}, and that disconnecting it runs its disconnection callbacks. """ self.establishClientAndServer() rootObjDeferred = self.clientFactory.getRootObject() def gotRootObject(rootObj): self.assertIsInstance(rootObj, pb.RemoteReference) return rootObj def disconnect(rootObj): disconnectedDeferred = Deferred() rootObj.notifyOnDisconnect(disconnectedDeferred.callback) self.clientFactory.disconnect() self.completeClientLostConnection() return disconnectedDeferred rootObjDeferred.addCallback(gotRootObject) rootObjDeferred.addCallback(disconnect) return rootObjDeferred def test_deadReferenceError(self): """ Test that when a connection is lost, calling a method on a RemoteReference obtained from it raises L{DeadReferenceError}. """ self.establishClientAndServer() rootObjDeferred = self.clientFactory.getRootObject() def gotRootObject(rootObj): disconnectedDeferred = Deferred() rootObj.notifyOnDisconnect(disconnectedDeferred.callback) def lostConnection(ign): self.assertRaises(pb.DeadReferenceError, rootObj.callRemote, "method") disconnectedDeferred.addCallback(lostConnection) self.clientFactory.disconnect() self.completeClientLostConnection() return disconnectedDeferred return rootObjDeferred.addCallback(gotRootObject) def test_clientConnectionLost(self): """ Test that if the L{reconnecting} flag is passed with a True value then a remote call made from a disconnection notification callback gets a result successfully. """ class ReconnectOnce(pb.PBClientFactory): reconnectedAlready = False def clientConnectionLost(self, connector, reason): reconnecting = not self.reconnectedAlready self.reconnectedAlready = True result = pb.PBClientFactory.clientConnectionLost( self, connector, reason, reconnecting ) if reconnecting: connector.connect() return result self.clientFactory = ReconnectOnce() self.establishClientAndServer() rootObjDeferred = self.clientFactory.getRootObject() def gotRootObject(rootObj): self.assertIsInstance(rootObj, pb.RemoteReference) d = Deferred() rootObj.notifyOnDisconnect(d.callback) # request a disconnection self.clientFactory.disconnect() self.completeClientLostConnection() def disconnected(ign): d = self.clientFactory.getRootObject() def gotAnotherRootObject(anotherRootObj): self.assertIsInstance(anotherRootObj, pb.RemoteReference) d = Deferred() anotherRootObj.notifyOnDisconnect(d.callback) self.clientFactory.disconnect() self.completeClientLostConnection() return d return d.addCallback(gotAnotherRootObject) return d.addCallback(disconnected) return rootObjDeferred.addCallback(gotRootObject) def test_immediateClose(self): """ Test that if a Broker loses its connection without receiving any bytes, it doesn't raise any exceptions or log any errors. """ self.establishClientAndServer() serverProto = self.serverFactory.buildProtocol(("127.0.0.1", 12345)) serverProto.makeConnection(protocol.FileWrapper(StringIO())) serverProto.connectionLost(failure.Failure(main.CONNECTION_DONE)) def test_loginConnectionRefused(self): """ L{PBClientFactory.login} returns a L{Deferred} which is errbacked with the L{ConnectionRefusedError} if the underlying connection is refused. """ clientFactory = pb.PBClientFactory() loginDeferred = clientFactory.login( credentials.UsernamePassword(b"foo", b"bar") ) clientFactory.clientConnectionFailed( None, failure.Failure( ConnectionRefusedError("Test simulated refused connection") ), ) return self.assertFailure(loginDeferred, ConnectionRefusedError) def test_loginLogout(self): """ Test that login can be performed with IUsernamePassword credentials and that when the connection is dropped the avatar is logged out. """ self.portal.registerChecker( checkers.InMemoryUsernamePasswordDatabaseDontUse(user=b"pass") ) creds = credentials.UsernamePassword(b"user", b"pass") # NOTE: real code probably won't need anything where we have the # "BRAINS!" argument, passing None is fine. We just do it here to # test that it is being passed. It is used to give additional info to # the realm to aid perspective creation, if you don't need that, # ignore it. mind = "BRAINS!" loginCompleted = Deferred() d = self.clientFactory.login(creds, mind) def cbLogin(perspective): self.assertTrue(self.realm.lastPerspective.loggedIn) self.assertIsInstance(perspective, pb.RemoteReference) return loginCompleted def cbDisconnect(ignored): self.clientFactory.disconnect() self.completeClientLostConnection() d.addCallback(cbLogin) d.addCallback(cbDisconnect) def cbLogout(ignored): self.assertTrue(self.realm.lastPerspective.loggedOut) d.addCallback(cbLogout) self.establishClientAndServer() self.pump.flush() # The perspective passed to cbLogin has gone out of scope. # Ensure its __del__ runs... gc.collect() # ...and send its decref message to the server self.pump.flush() # Now allow the client to disconnect. loginCompleted.callback(None) return d def test_logoutAfterDecref(self): """ If a L{RemoteReference} to an L{IPerspective} avatar is decrefed and there remain no other references to the avatar on the server, the avatar is garbage collected and the logout method called. """ loggedOut = Deferred() class EventPerspective(pb.Avatar): """ An avatar which fires a Deferred when it is logged out. """ def __init__(self, avatarId): pass def logout(self): loggedOut.callback(None) self.realm.perspectiveFactory = EventPerspective self.portal.registerChecker( checkers.InMemoryUsernamePasswordDatabaseDontUse(foo=b"bar") ) d = self.clientFactory.login( credentials.UsernamePassword(b"foo", b"bar"), "BRAINS!" ) def cbLoggedIn(avatar): # Just wait for the logout to happen, as it should since the # reference to the avatar will shortly no longer exists. return loggedOut d.addCallback(cbLoggedIn) def cbLoggedOut(ignored): # Verify that the server broker's _localCleanup dict isn't growing # without bound. self.assertEqual(self.serverFactory.protocolInstance._localCleanup, {}) d.addCallback(cbLoggedOut) self.establishClientAndServer() # complete authentication self.pump.flush() # _PortalAuthChallenger and our Avatar should be dead by now; # force a collection to trigger their __del__s gc.collect() # push their decref messages through self.pump.flush() return d def test_concurrentLogin(self): """ Two different correct login attempts can be made on the same root object at the same time and produce two different resulting avatars. """ self.portal.registerChecker( checkers.InMemoryUsernamePasswordDatabaseDontUse(foo=b"bar", baz=b"quux") ) firstLogin = self.clientFactory.login( credentials.UsernamePassword(b"foo", b"bar"), "BRAINS!" ) secondLogin = self.clientFactory.login( credentials.UsernamePassword(b"baz", b"quux"), "BRAINS!" ) d = gatherResults([firstLogin, secondLogin]) def cbLoggedIn(result): (first, second) = result return gatherResults( [first.callRemote("getAvatarId"), second.callRemote("getAvatarId")] ) d.addCallback(cbLoggedIn) def cbAvatarIds(x): first, second = x self.assertEqual(first, b"foo") self.assertEqual(second, b"baz") d.addCallback(cbAvatarIds) self.establishClientAndServer() self.pump.flush() return d def test_badUsernamePasswordLogin(self): """ Test that a login attempt with an invalid user or invalid password fails in the appropriate way. """ self.portal.registerChecker( checkers.InMemoryUsernamePasswordDatabaseDontUse(user=b"pass") ) firstLogin = self.clientFactory.login( credentials.UsernamePassword(b"nosuchuser", b"pass") ) secondLogin = self.clientFactory.login( credentials.UsernamePassword(b"user", b"wrongpass") ) self.assertFailure(firstLogin, UnauthorizedLogin) self.assertFailure(secondLogin, UnauthorizedLogin) d = gatherResults([firstLogin, secondLogin]) def cleanup(ignore): errors = self.flushLoggedErrors(UnauthorizedLogin) self.assertEqual(len(errors), 2) d.addCallback(cleanup) self.establishClientAndServer() self.pump.flush() return d def test_anonymousLogin(self): """ Verify that a PB server using a portal configured with a checker which allows IAnonymous credentials can be logged into using IAnonymous credentials. """ self.portal.registerChecker(checkers.AllowAnonymousAccess()) d = self.clientFactory.login(credentials.Anonymous(), "BRAINS!") def cbLoggedIn(perspective): return perspective.callRemote("echo", 123) d.addCallback(cbLoggedIn) d.addCallback(self.assertEqual, 123) self.establishClientAndServer() self.pump.flush() return d def test_anonymousLoginNotPermitted(self): """ Verify that without an anonymous checker set up, anonymous login is rejected. """ self.portal.registerChecker( checkers.InMemoryUsernamePasswordDatabaseDontUse(user="pass") ) d = self.clientFactory.login(credentials.Anonymous(), "BRAINS!") self.assertFailure(d, UnhandledCredentials) def cleanup(ignore): errors = self.flushLoggedErrors(UnhandledCredentials) self.assertEqual(len(errors), 1) d.addCallback(cleanup) self.establishClientAndServer() self.pump.flush() return d def test_anonymousLoginWithMultipleCheckers(self): """ Like L{test_anonymousLogin} but against a portal with a checker for both IAnonymous and IUsernamePassword. """ self.portal.registerChecker(checkers.AllowAnonymousAccess()) self.portal.registerChecker( checkers.InMemoryUsernamePasswordDatabaseDontUse(user=b"pass") ) d = self.clientFactory.login(credentials.Anonymous(), "BRAINS!") def cbLogin(perspective): return perspective.callRemote("echo", 123) d.addCallback(cbLogin) d.addCallback(self.assertEqual, 123) self.establishClientAndServer() self.pump.flush() return d def test_authenticatedLoginWithMultipleCheckers(self): """ Like L{test_anonymousLoginWithMultipleCheckers} but check that username/password authentication works. """ self.portal.registerChecker(checkers.AllowAnonymousAccess()) self.portal.registerChecker( checkers.InMemoryUsernamePasswordDatabaseDontUse(user=b"pass") ) d = self.clientFactory.login( credentials.UsernamePassword(b"user", b"pass"), "BRAINS!" ) def cbLogin(perspective): return perspective.callRemote("add", 100, 23) d.addCallback(cbLogin) d.addCallback(self.assertEqual, 123) self.establishClientAndServer() self.pump.flush() return d def test_view(self): """ Verify that a viewpoint can be retrieved after authenticating with cred. """ self.portal.registerChecker( checkers.InMemoryUsernamePasswordDatabaseDontUse(user=b"pass") ) d = self.clientFactory.login( credentials.UsernamePassword(b"user", b"pass"), "BRAINS!" ) def cbLogin(perspective): return perspective.callRemote("getViewPoint") d.addCallback(cbLogin) def cbView(viewpoint): return viewpoint.callRemote("check") d.addCallback(cbView) d.addCallback(self.assertTrue) self.establishClientAndServer() self.pump.flush() return d @implementer(pb.IPerspective) class NonSubclassingPerspective: def __init__(self, avatarId): pass # IPerspective implementation def perspectiveMessageReceived(self, broker, message, args, kwargs): args = broker.unserialize(args, self) kwargs = broker.unserialize(kwargs, self) return broker.serialize((message, args, kwargs)) # Methods required by TestRealm def logout(self): self.loggedOut = True class NSPTests(unittest.TestCase): """ Tests for authentication against a realm where the L{IPerspective} implementation is not a subclass of L{Avatar}. """ def setUp(self): self.realm = TestRealm() self.realm.perspectiveFactory = NonSubclassingPerspective self.portal = portal.Portal(self.realm) self.checker = checkers.InMemoryUsernamePasswordDatabaseDontUse() self.checker.addUser(b"user", b"pass") self.portal.registerChecker(self.checker) self.factory = WrappingFactory(pb.PBServerFactory(self.portal)) self.port = reactor.listenTCP(0, self.factory, interface="127.0.0.1") self.addCleanup(self.port.stopListening) self.portno = self.port.getHost().port def test_NSP(self): """ An L{IPerspective} implementation which does not subclass L{Avatar} can expose remote methods for the client to call. """ factory = pb.PBClientFactory() d = factory.login(credentials.UsernamePassword(b"user", b"pass"), "BRAINS!") reactor.connectTCP("127.0.0.1", self.portno, factory) d.addCallback(lambda p: p.callRemote("ANYTHING", "here", bar="baz")) d.addCallback(self.assertEqual, ("ANYTHING", ("here",), {"bar": "baz"})) def cleanup(ignored): factory.disconnect() for p in self.factory.protocols: p.transport.loseConnection() d.addCallback(cleanup) return d class IForwarded(Interface): """ Interface used for testing L{util.LocalAsyncForwarder}. """ def forwardMe(): """ Simple synchronous method. """ def forwardDeferred(): """ Simple asynchronous method. """ @implementer(IForwarded) class Forwarded: """ Test implementation of L{IForwarded}. @ivar forwarded: set if C{forwardMe} is called. @type forwarded: C{bool} @ivar unforwarded: set if C{dontForwardMe} is called. @type unforwarded: C{bool} """ forwarded = False unforwarded = False def forwardMe(self): """ Set a local flag to test afterwards. """ self.forwarded = True def dontForwardMe(self): """ Set a local flag to test afterwards. This should not be called as it's not in the interface. """ self.unforwarded = True def forwardDeferred(self): """ Asynchronously return C{True}. """ return succeed(True) class SpreadUtilTests(unittest.TestCase): """ Tests for L{twisted.spread.util}. """ def test_sync(self): """ Call a synchronous method of a L{util.LocalAsRemote} object and check the result. """ o = LocalRemoteTest() self.assertEqual(o.callRemote("add1", 2), 3) def test_async(self): """ Call an asynchronous method of a L{util.LocalAsRemote} object and check the result. """ o = LocalRemoteTest() o = LocalRemoteTest() d = o.callRemote("add", 2, y=4) self.assertIsInstance(d, Deferred) d.addCallback(self.assertEqual, 6) return d def test_asyncFail(self): """ Test an asynchronous failure on a remote method call. """ o = LocalRemoteTest() d = o.callRemote("fail") def eb(f): self.assertIsInstance(f, failure.Failure) f.trap(RuntimeError) d.addCallbacks(lambda res: self.fail("supposed to fail"), eb) return d def test_remoteMethod(self): """ Test the C{remoteMethod} facility of L{util.LocalAsRemote}. """ o = LocalRemoteTest() m = o.remoteMethod("add1") self.assertEqual(m(3), 4) def test_localAsyncForwarder(self): """ Test a call to L{util.LocalAsyncForwarder} using L{Forwarded} local object. """ f = Forwarded() lf = util.LocalAsyncForwarder(f, IForwarded) lf.callRemote("forwardMe") self.assertTrue(f.forwarded) lf.callRemote("dontForwardMe") self.assertFalse(f.unforwarded) rr = lf.callRemote("forwardDeferred") l = [] rr.addCallback(l.append) self.assertEqual(l[0], 1) class PBWithSecurityOptionsTests(unittest.TestCase): """ Test security customization. """ def test_clientDefaultSecurityOptions(self): """ By default, client broker should use C{jelly.globalSecurity} as security settings. """ factory = pb.PBClientFactory() broker = factory.buildProtocol(None) self.assertIs(broker.security, jelly.globalSecurity) def test_serverDefaultSecurityOptions(self): """ By default, server broker should use C{jelly.globalSecurity} as security settings. """ factory = pb.PBServerFactory(Echoer()) broker = factory.buildProtocol(None) self.assertIs(broker.security, jelly.globalSecurity) def test_clientSecurityCustomization(self): """ Check that the security settings are passed from the client factory to the broker object. """ security = jelly.SecurityOptions() factory = pb.PBClientFactory(security=security) broker = factory.buildProtocol(None) self.assertIs(broker.security, security) def test_serverSecurityCustomization(self): """ Check that the security settings are passed from the server factory to the broker object. """ security = jelly.SecurityOptions() factory = pb.PBServerFactory(Echoer(), security=security) broker = factory.buildProtocol(None) self.assertIs(broker.security, security) PK Mb�Z��ʓ; ; spread/test/test_pbfailure.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for error handling in PB. """ from io import StringIO from twisted.internet import defer, reactor from twisted.python import log from twisted.python.reflect import qual from twisted.spread import flavors, jelly, pb from twisted.trial import unittest # Test exceptions class AsynchronousException(Exception): """ Helper used to test remote methods which return Deferreds which fail with exceptions which are not L{pb.Error} subclasses. """ class SynchronousException(Exception): """ Helper used to test remote methods which raise exceptions which are not L{pb.Error} subclasses. """ class AsynchronousError(pb.Error): """ Helper used to test remote methods which return Deferreds which fail with exceptions which are L{pb.Error} subclasses. """ class SynchronousError(pb.Error): """ Helper used to test remote methods which raise exceptions which are L{pb.Error} subclasses. """ class JellyError(flavors.Jellyable, pb.Error, pb.RemoteCopy): pass class SecurityError(pb.Error, pb.RemoteCopy): pass pb.setUnjellyableForClass(JellyError, JellyError) pb.setUnjellyableForClass(SecurityError, SecurityError) pb.globalSecurity.allowInstancesOf(SecurityError) # Server-side class SimpleRoot(pb.Root): def remote_asynchronousException(self): """ Fail asynchronously with a non-pb.Error exception. """ return defer.fail(AsynchronousException("remote asynchronous exception")) def remote_synchronousException(self): """ Fail synchronously with a non-pb.Error exception. """ raise SynchronousException("remote synchronous exception") def remote_asynchronousError(self): """ Fail asynchronously with a pb.Error exception. """ return defer.fail(AsynchronousError("remote asynchronous error")) def remote_synchronousError(self): """ Fail synchronously with a pb.Error exception. """ raise SynchronousError("remote synchronous error") def remote_unknownError(self): """ Fail with error that is not known to client. """ class UnknownError(pb.Error): pass raise UnknownError("I'm not known to client!") def remote_jelly(self): self.raiseJelly() def remote_security(self): self.raiseSecurity() def remote_deferredJelly(self): d = defer.Deferred() d.addCallback(self.raiseJelly) d.callback(None) return d def remote_deferredSecurity(self): d = defer.Deferred() d.addCallback(self.raiseSecurity) d.callback(None) return d def raiseJelly(self, results=None): raise JellyError("I'm jellyable!") def raiseSecurity(self, results=None): raise SecurityError("I'm secure!") class SaveProtocolServerFactory(pb.PBServerFactory): """ A L{pb.PBServerFactory} that saves the latest connected client in C{protocolInstance}. """ protocolInstance = None def clientConnectionMade(self, protocol): """ Keep track of the given protocol. """ self.protocolInstance = protocol class PBConnTestCase(unittest.TestCase): unsafeTracebacks = 0 def setUp(self): self._setUpServer() self._setUpClient() def _setUpServer(self): self.serverFactory = SaveProtocolServerFactory(SimpleRoot()) self.serverFactory.unsafeTracebacks = self.unsafeTracebacks self.serverPort = reactor.listenTCP( 0, self.serverFactory, interface="127.0.0.1" ) def _setUpClient(self): portNo = self.serverPort.getHost().port self.clientFactory = pb.PBClientFactory() self.clientConnector = reactor.connectTCP( "127.0.0.1", portNo, self.clientFactory ) def tearDown(self): if self.serverFactory.protocolInstance is not None: self.serverFactory.protocolInstance.transport.loseConnection() return defer.gatherResults([self._tearDownServer(), self._tearDownClient()]) def _tearDownServer(self): return defer.maybeDeferred(self.serverPort.stopListening) def _tearDownClient(self): self.clientConnector.disconnect() return defer.succeed(None) class PBFailureTests(PBConnTestCase): compare = unittest.TestCase.assertEqual def _exceptionTest(self, method, exceptionType, flush): def eb(err): err.trap(exceptionType) self.compare(err.traceback, "Traceback unavailable\n") if flush: errs = self.flushLoggedErrors(exceptionType) self.assertEqual(len(errs), 1) return (err.type, err.value, err.traceback) d = self.clientFactory.getRootObject() def gotRootObject(root): d = root.callRemote(method) d.addErrback(eb) return d d.addCallback(gotRootObject) return d def test_asynchronousException(self): """ Test that a Deferred returned by a remote method which already has a Failure correctly has that error passed back to the calling side. """ return self._exceptionTest("asynchronousException", AsynchronousException, True) def test_synchronousException(self): """ Like L{test_asynchronousException}, but for a method which raises an exception synchronously. """ return self._exceptionTest("synchronousException", SynchronousException, True) def test_asynchronousError(self): """ Like L{test_asynchronousException}, but for a method which returns a Deferred failing with an L{pb.Error} subclass. """ return self._exceptionTest("asynchronousError", AsynchronousError, False) def test_synchronousError(self): """ Like L{test_asynchronousError}, but for a method which synchronously raises a L{pb.Error} subclass. """ return self._exceptionTest("synchronousError", SynchronousError, False) def _success(self, result, expectedResult): self.assertEqual(result, expectedResult) return result def _addFailingCallbacks(self, remoteCall, expectedResult, eb): remoteCall.addCallbacks(self._success, eb, callbackArgs=(expectedResult,)) return remoteCall def _testImpl(self, method, expected, eb, exc=None): """ Call the given remote method and attach the given errback to the resulting Deferred. If C{exc} is not None, also assert that one exception of that type was logged. """ rootDeferred = self.clientFactory.getRootObject() def gotRootObj(obj): failureDeferred = self._addFailingCallbacks( obj.callRemote(method), expected, eb ) if exc is not None: def gotFailure(err): self.assertEqual(len(self.flushLoggedErrors(exc)), 1) return err failureDeferred.addBoth(gotFailure) return failureDeferred rootDeferred.addCallback(gotRootObj) return rootDeferred def test_jellyFailure(self): """ Test that an exception which is a subclass of L{pb.Error} has more information passed across the network to the calling side. """ def failureJelly(fail): fail.trap(JellyError) self.assertNotIsInstance(fail.type, str) self.assertIsInstance(fail.value, fail.type) return 43 return self._testImpl("jelly", 43, failureJelly) def test_deferredJellyFailure(self): """ Test that a Deferred which fails with a L{pb.Error} is treated in the same way as a synchronously raised L{pb.Error}. """ def failureDeferredJelly(fail): fail.trap(JellyError) self.assertNotIsInstance(fail.type, str) self.assertIsInstance(fail.value, fail.type) return 430 return self._testImpl("deferredJelly", 430, failureDeferredJelly) def test_unjellyableFailure(self): """ A non-jellyable L{pb.Error} subclass raised by a remote method is turned into a Failure with a type set to the FQPN of the exception type. """ def failureUnjellyable(fail): self.assertEqual( fail.type, b"twisted.spread.test.test_pbfailure.SynchronousError" ) return 431 return self._testImpl("synchronousError", 431, failureUnjellyable) def test_unknownFailure(self): """ Test that an exception which is a subclass of L{pb.Error} but not known on the client side has its type set properly. """ def failureUnknown(fail): self.assertEqual( fail.type, b"twisted.spread.test.test_pbfailure.UnknownError" ) return 4310 return self._testImpl("unknownError", 4310, failureUnknown) def test_securityFailure(self): """ Test that even if an exception is not explicitly jellyable (by being a L{pb.Jellyable} subclass), as long as it is an L{pb.Error} subclass it receives the same special treatment. """ def failureSecurity(fail): fail.trap(SecurityError) self.assertNotIsInstance(fail.type, str) self.assertIsInstance(fail.value, fail.type) return 4300 return self._testImpl("security", 4300, failureSecurity) def test_deferredSecurity(self): """ Test that a Deferred which fails with a L{pb.Error} which is not also a L{pb.Jellyable} is treated in the same way as a synchronously raised exception of the same type. """ def failureDeferredSecurity(fail): fail.trap(SecurityError) self.assertNotIsInstance(fail.type, str) self.assertIsInstance(fail.value, fail.type) return 43000 return self._testImpl("deferredSecurity", 43000, failureDeferredSecurity) def test_noSuchMethodFailure(self): """ Test that attempting to call a method which is not defined correctly results in an AttributeError on the calling side. """ def failureNoSuch(fail): fail.trap(pb.NoSuchMethod) self.compare(fail.traceback, "Traceback unavailable\n") return 42000 return self._testImpl("nosuch", 42000, failureNoSuch, AttributeError) def test_copiedFailureLogging(self): """ Test that a copied failure received from a PB call can be logged locally. Note: this test needs some serious help: all it really tests is that log.err(copiedFailure) doesn't raise an exception. """ d = self.clientFactory.getRootObject() def connected(rootObj): return rootObj.callRemote("synchronousException") d.addCallback(connected) def exception(failure): log.err(failure) errs = self.flushLoggedErrors(SynchronousException) self.assertEqual(len(errs), 2) d.addErrback(exception) return d def test_throwExceptionIntoGenerator(self): """ L{pb.CopiedFailure.throwExceptionIntoGenerator} will throw a L{RemoteError} into the given paused generator at the point where it last yielded. """ original = pb.CopyableFailure(AttributeError("foo")) copy = jelly.unjelly(jelly.jelly(original, invoker=DummyInvoker())) exception = [] def generatorFunc(): try: yield None except pb.RemoteError as exc: exception.append(exc) else: self.fail("RemoteError not raised") gen = generatorFunc() gen.send(None) self.assertRaises(StopIteration, copy.throwExceptionIntoGenerator, gen) self.assertEqual(len(exception), 1) exc = exception[0] self.assertEqual(exc.remoteType, qual(AttributeError).encode("ascii")) self.assertEqual(exc.args, ("foo",)) self.assertEqual(exc.remoteTraceback, "Traceback unavailable\n") class PBFailureUnsafeTests(PBFailureTests): compare = unittest.TestCase.failIfEquals unsafeTracebacks = 1 class DummyInvoker: """ A behaviorless object to be used as the invoker parameter to L{jelly.jelly}. """ serializingPerspective = None class FailureJellyingTests(unittest.TestCase): """ Tests for the interaction of jelly and failures. """ def test_unjelliedFailureCheck(self): """ An unjellied L{CopyableFailure} has a check method which behaves the same way as the original L{CopyableFailure}'s check method. """ original = pb.CopyableFailure(ZeroDivisionError()) self.assertIs(original.check(ZeroDivisionError), ZeroDivisionError) self.assertIs(original.check(ArithmeticError), ArithmeticError) copied = jelly.unjelly(jelly.jelly(original, invoker=DummyInvoker())) self.assertIs(copied.check(ZeroDivisionError), ZeroDivisionError) self.assertIs(copied.check(ArithmeticError), ArithmeticError) def test_twiceUnjelliedFailureCheck(self): """ The object which results from jellying a L{CopyableFailure}, unjellying the result, creating a new L{CopyableFailure} from the result of that, jellying it, and finally unjellying the result of that has a check method which behaves the same way as the original L{CopyableFailure}'s check method. """ original = pb.CopyableFailure(ZeroDivisionError()) self.assertIs(original.check(ZeroDivisionError), ZeroDivisionError) self.assertIs(original.check(ArithmeticError), ArithmeticError) copiedOnce = jelly.unjelly(jelly.jelly(original, invoker=DummyInvoker())) derivative = pb.CopyableFailure(copiedOnce) copiedTwice = jelly.unjelly(jelly.jelly(derivative, invoker=DummyInvoker())) self.assertIs(copiedTwice.check(ZeroDivisionError), ZeroDivisionError) self.assertIs(copiedTwice.check(ArithmeticError), ArithmeticError) def test_printTracebackIncludesValue(self): """ When L{CopiedFailure.printTraceback} is used to print a copied failure which was unjellied from a L{CopyableFailure} with C{unsafeTracebacks} set to C{False}, the string representation of the exception value is included in the output. """ original = pb.CopyableFailure(Exception("some reason")) copied = jelly.unjelly(jelly.jelly(original, invoker=DummyInvoker())) output = StringIO() copied.printTraceback(output) exception = qual(Exception) expectedOutput = "Traceback from remote host -- " "{}: some reason\n".format( exception ) self.assertEqual(expectedOutput, output.getvalue()) PK Mb�Ze*9Rn n spread/test/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.spread}. """ PK Mb�Z�TZ-f[ f[ spread/flavors.pynu �[��� # -*- test-case-name: twisted.spread.test.test_pb -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module represents flavors of remotely accessible objects. Currently this is only objects accessible through Perspective Broker, but will hopefully encompass all forms of remote access which can emulate subsets of PB (such as XMLRPC or SOAP). Future Plans: Optimization. Exploitation of new-style object model. Optimizations to this module should not affect external-use semantics at all, but may have a small impact on users who subclass and override methods. @author: Glyph Lefkowitz """ # NOTE: this module should NOT import pb; it is supposed to be a module which # abstractly defines remotely accessible types. Many of these types expect to # be serialized by Jelly, but they ought to be accessible through other # mechanisms (like XMLRPC) import sys from zope.interface import Interface, implementer from twisted.python import log, reflect from twisted.python.compat import cmp, comparable from .jelly import ( Jellyable, Unjellyable, _createBlank, getInstanceState, setInstanceState, setUnjellyableFactoryForClass, setUnjellyableForClass, setUnjellyableForClassTree, unjellyableRegistry, ) # compatibility setCopierForClass = setUnjellyableForClass setCopierForClassTree = setUnjellyableForClassTree setFactoryForClass = setUnjellyableFactoryForClass copyTags = unjellyableRegistry copy_atom = b"copy" cache_atom = b"cache" cached_atom = b"cached" remote_atom = b"remote" class NoSuchMethod(AttributeError): """Raised if there is no such remote method""" class IPBRoot(Interface): """Factory for root Referenceable objects for PB servers.""" def rootObject(broker): """Return root Referenceable for broker.""" class Serializable(Jellyable): """An object that can be passed remotely. I am a style of object which can be serialized by Perspective Broker. Objects which wish to be referenceable or copied remotely have to subclass Serializable. However, clients of Perspective Broker will probably not want to directly subclass Serializable; the Flavors of transferable objects are listed below. What it means to be \"Serializable\" is that an object can be passed to or returned from a remote method. Certain basic types (dictionaries, lists, tuples, numbers, strings) are serializable by default; however, classes need to choose a specific serialization style: L{Referenceable}, L{Viewable}, L{Copyable} or L{Cacheable}. You may also pass C{[lists, dictionaries, tuples]} of L{Serializable} instances to or return them from remote methods, as many levels deep as you like. """ def processUniqueID(self): """Return an ID which uniquely represents this object for this process. By default, this uses the 'id' builtin, but can be overridden to indicate that two values are identity-equivalent (such as proxies for the same object). """ return id(self) class Referenceable(Serializable): perspective = None """I am an object sent remotely as a direct reference. When one of my subclasses is sent as an argument to or returned from a remote method call, I will be serialized by default as a direct reference. This means that the peer will be able to call methods on me; a method call xxx() from my peer will be resolved to methods of the name remote_xxx. """ def remoteMessageReceived(self, broker, message, args, kw): """A remote message has been received. Dispatch it appropriately. The default implementation is to dispatch to a method called 'remote_messagename' and call it with the same arguments. """ args = broker.unserialize(args) kw = broker.unserialize(kw) # Need this to interoperate with Python 2 clients # which may try to send use keywords where keys are of type # bytes. if [key for key in kw.keys() if isinstance(key, bytes)]: kw = {k.decode("utf8"): v for k, v in kw.items()} if not isinstance(message, str): message = message.decode("utf8") method = getattr(self, "remote_%s" % message, None) if method is None: raise NoSuchMethod(f"No such method: remote_{message}") try: state = method(*args, **kw) except TypeError: log.msg(f"{method} didn't accept {args} and {kw}") raise return broker.serialize(state, self.perspective) def jellyFor(self, jellier): """(internal) Return a tuple which will be used as the s-expression to serialize this to a peer. """ return [b"remote", jellier.invoker.registerReference(self)] @implementer(IPBRoot) class Root(Referenceable): """I provide a root object to L{pb.Broker}s for a L{pb.PBClientFactory} or L{pb.PBServerFactory}. When a factory produces a L{pb.Broker}, it supplies that L{pb.Broker} with an object named \"root\". That object is obtained by calling my rootObject method. """ def rootObject(self, broker): """A factory is requesting to publish me as a root object. When a factory is sending me as the root object, this method will be invoked to allow per-broker versions of an object. By default I return myself. """ return self class ViewPoint(Referenceable): """ I act as an indirect reference to an object accessed through a L{pb.IPerspective}. Simply put, I combine an object with a perspective so that when a peer calls methods on the object I refer to, the method will be invoked with that perspective as a first argument, so that it can know who is calling it. While L{Viewable} objects will be converted to ViewPoints by default when they are returned from or sent as arguments to a remote method, any object may be manually proxied as well. (XXX: Now that this class is no longer named C{Proxy}, this is the only occurrence of the term 'proxied' in this docstring, and may be unclear.) This can be useful when dealing with L{pb.IPerspective}s, L{Copyable}s, and L{Cacheable}s. It is legal to implement a method as such on a perspective:: | def perspective_getViewPointForOther(self, name): | defr = self.service.getPerspectiveRequest(name) | defr.addCallbacks(lambda x, self=self: ViewPoint(self, x), log.msg) | return defr This will allow you to have references to Perspective objects in two different ways. One is through the initial 'attach' call -- each peer will have a L{pb.RemoteReference} to their perspective directly. The other is through this method; each peer can get a L{pb.RemoteReference} to all other perspectives in the service; but that L{pb.RemoteReference} will be to a L{ViewPoint}, not directly to the object. The practical offshoot of this is that you can implement 2 varieties of remotely callable methods on this Perspective; view_xxx and C{perspective_xxx}. C{view_xxx} methods will follow the rules for ViewPoint methods (see ViewPoint.L{remoteMessageReceived}), and C{perspective_xxx} methods will follow the rules for Perspective methods. """ def __init__(self, perspective, object): """Initialize me with a Perspective and an Object.""" self.perspective = perspective self.object = object def processUniqueID(self): """Return an ID unique to a proxy for this perspective+object combination.""" return (id(self.perspective), id(self.object)) def remoteMessageReceived(self, broker, message, args, kw): """A remote message has been received. Dispatch it appropriately. The default implementation is to dispatch to a method called 'C{view_messagename}' to my Object and call it on my object with the same arguments, modified by inserting my Perspective as the first argument. """ args = broker.unserialize(args, self.perspective) kw = broker.unserialize(kw, self.perspective) if not isinstance(message, str): message = message.decode("utf8") method = getattr(self.object, "view_%s" % message) try: state = method(*(self.perspective,) + args, **kw) except TypeError: log.msg(f"{method} didn't accept {args} and {kw}") raise rv = broker.serialize(state, self.perspective, method, args, kw) return rv class Viewable(Serializable): """I will be converted to a L{ViewPoint} when passed to or returned from a remote method. The beginning of a peer's interaction with a PB Service is always through a perspective. However, if a C{perspective_xxx} method returns a Viewable, it will be serialized to the peer as a response to that method. """ def jellyFor(self, jellier): """Serialize a L{ViewPoint} for me and the perspective of the given broker.""" return ViewPoint(jellier.invoker.serializingPerspective, self).jellyFor(jellier) class Copyable(Serializable): """Subclass me to get copied each time you are returned from or passed to a remote method. When I am returned from or passed to a remote method call, I will be converted into data via a set of callbacks (see my methods for more info). That data will then be serialized using Jelly, and sent to the peer. The peer will then look up the type to represent this with; see L{RemoteCopy} for details. """ def getStateToCopy(self): """Gather state to send when I am serialized for a peer. I will default to returning self.__dict__. Override this to customize this behavior. """ return self.__dict__ def getStateToCopyFor(self, perspective): """ Gather state to send when I am serialized for a particular perspective. I will default to calling L{getStateToCopy}. Override this to customize this behavior. """ return self.getStateToCopy() def getTypeToCopy(self): """Determine what type tag to send for me. By default, send the string representation of my class (package.module.Class); normally this is adequate, but you may override this to change it. """ return reflect.qual(self.__class__).encode("utf-8") def getTypeToCopyFor(self, perspective): """Determine what type tag to send for me. By default, defer to self.L{getTypeToCopy}() normally this is adequate, but you may override this to change it. """ return self.getTypeToCopy() def jellyFor(self, jellier): """Assemble type tag and state to copy for this broker. This will call L{getTypeToCopyFor} and L{getStateToCopy}, and return an appropriate s-expression to represent me. """ if jellier.invoker is None: return getInstanceState(self, jellier) p = jellier.invoker.serializingPerspective t = self.getTypeToCopyFor(p) state = self.getStateToCopyFor(p) sxp = jellier.prepare(self) sxp.extend([t, jellier.jelly(state)]) return jellier.preserve(self, sxp) class Cacheable(Copyable): """A cached instance. This means that it's copied; but there is some logic to make sure that it's only copied once. Additionally, when state is retrieved, it is passed a "proto-reference" to the state as it will exist on the client. XXX: The documentation for this class needs work, but it's the most complex part of PB and it is inherently difficult to explain. """ def getStateToCacheAndObserveFor(self, perspective, observer): """ Get state to cache on the client and client-cache reference to observe locally. This is similar to getStateToCopyFor, but it additionally passes in a reference to the client-side RemoteCache instance that will be created when it is unserialized. This allows Cacheable instances to keep their RemoteCaches up to date when they change, such that no changes can occur between the point at which the state is initially copied and the client receives it that are not propagated. """ return self.getStateToCopyFor(perspective) def jellyFor(self, jellier): """Return an appropriate tuple to serialize me. Depending on whether this broker has cached me or not, this may return either a full state or a reference to an existing cache. """ if jellier.invoker is None: return getInstanceState(self, jellier) luid = jellier.invoker.cachedRemotelyAs(self, 1) if luid is None: luid = jellier.invoker.cacheRemotely(self) p = jellier.invoker.serializingPerspective type_ = self.getTypeToCopyFor(p) observer = RemoteCacheObserver(jellier.invoker, self, p) state = self.getStateToCacheAndObserveFor(p, observer) l = jellier.prepare(self) jstate = jellier.jelly(state) l.extend([type_, luid, jstate]) return jellier.preserve(self, l) else: return cached_atom, luid def stoppedObserving(self, perspective, observer): """This method is called when a client has stopped observing me. The 'observer' argument is the same as that passed in to getStateToCacheAndObserveFor. """ class RemoteCopy(Unjellyable): """I am a remote copy of a Copyable object. When the state from a L{Copyable} object is received, an instance will be created based on the copy tags table (see setUnjellyableForClass) and sent the L{setCopyableState} message. I provide a reasonable default implementation of that message; subclass me if you wish to serve as a copier for remote data. NOTE: copiers are invoked with no arguments. Do not implement a constructor which requires args in a subclass of L{RemoteCopy}! """ def setCopyableState(self, state): """I will be invoked with the state to copy locally. 'state' is the data returned from the remote object's 'getStateToCopyFor' method, which will often be the remote object's dictionary (or a filtered approximation of it depending on my peer's perspective). """ state = { x.decode("utf8") if isinstance(x, bytes) else x: y for x, y in state.items() } self.__dict__ = state def unjellyFor(self, unjellier, jellyList): if unjellier.invoker is None: return setInstanceState(self, unjellier, jellyList) self.setCopyableState(unjellier.unjelly(jellyList[1])) return self class RemoteCache(RemoteCopy, Serializable): """A cache is a local representation of a remote L{Cacheable} object. This represents the last known state of this object. It may also have methods invoked on it -- in order to update caches, the cached class generates a L{pb.RemoteReference} to this object as it is originally sent. Much like copy, I will be invoked with no arguments. Do not implement a constructor that requires arguments in one of my subclasses. """ def remoteMessageReceived(self, broker, message, args, kw): """A remote message has been received. Dispatch it appropriately. The default implementation is to dispatch to a method called 'C{observe_messagename}' and call it on my with the same arguments. """ if not isinstance(message, str): message = message.decode("utf8") args = broker.unserialize(args) kw = broker.unserialize(kw) method = getattr(self, "observe_%s" % message) try: state = method(*args, **kw) except TypeError: log.msg(f"{method} didn't accept {args} and {kw}") raise return broker.serialize(state, None, method, args, kw) def jellyFor(self, jellier): """serialize me (only for the broker I'm for) as the original cached reference""" if jellier.invoker is None: return getInstanceState(self, jellier) assert ( jellier.invoker is self.broker ), "You cannot exchange cached proxies between brokers." return b"lcache", self.luid def unjellyFor(self, unjellier, jellyList): if unjellier.invoker is None: return setInstanceState(self, unjellier, jellyList) self.broker = unjellier.invoker self.luid = jellyList[1] borgCopy = self._borgify() # XXX questionable whether this was a good design idea... init = getattr(borgCopy, "__init__", None) if init: init() unjellier.invoker.cacheLocally(jellyList[1], self) borgCopy.setCopyableState(unjellier.unjelly(jellyList[2])) # Might have changed due to setCopyableState method; we'll assume that # it's bad form to do so afterwards. self.__dict__ = borgCopy.__dict__ # chomp, chomp -- some existing code uses "self.__dict__ =", some uses # "__dict__.update". This is here in order to handle both cases. self.broker = unjellier.invoker self.luid = jellyList[1] return borgCopy ## def __really_del__(self): ## """Final finalization call, made after all remote references have been lost. ## """ def __cmp__(self, other): """Compare me [to another RemoteCache.""" if isinstance(other, self.__class__): return cmp(id(self.__dict__), id(other.__dict__)) else: return cmp(id(self.__dict__), other) def __hash__(self): """Hash me.""" return int(id(self.__dict__) % sys.maxsize) broker = None luid = None def __del__(self): """Do distributed reference counting on finalize.""" try: # log.msg( ' --- decache: %s %s' % (self, self.luid) ) if self.broker: self.broker.decCacheRef(self.luid) except BaseException: log.deferr() def _borgify(self): """ Create a new object that shares its state (i.e. its C{__dict__}) and type with this object, but does not share its identity. This is an instance of U{the Borg design pattern <https://code.activestate.com/recipes/66531/>} originally described by Alex Martelli, but unlike the example given there, this is not a replacement for a Singleton. Instead, it is for lifecycle tracking (and distributed garbage collection). The purpose of these separate objects is to have a separate object tracking each application-level reference to the root L{RemoteCache} object being tracked by the broker, and to have their C{__del__} methods be invoked. This may be achievable via a weak value dictionary to track the root L{RemoteCache} instances instead, but this implementation strategy predates the availability of weak references in Python. @return: The new instance. @rtype: C{self.__class__} """ blank = _createBlank(self.__class__) blank.__dict__ = self.__dict__ return blank def unjellyCached(unjellier, unjellyList): luid = unjellyList[1] return unjellier.invoker.cachedLocallyAs(luid)._borgify() setUnjellyableForClass("cached", unjellyCached) def unjellyLCache(unjellier, unjellyList): luid = unjellyList[1] obj = unjellier.invoker.remotelyCachedForLUID(luid) return obj setUnjellyableForClass("lcache", unjellyLCache) def unjellyLocal(unjellier, unjellyList): obj = unjellier.invoker.localObjectForID(unjellyList[1]) return obj setUnjellyableForClass("local", unjellyLocal) @comparable class RemoteCacheMethod: """A method on a reference to a L{RemoteCache}.""" def __init__(self, name, broker, cached, perspective): """(internal) initialize.""" self.name = name self.broker = broker self.perspective = perspective self.cached = cached def __cmp__(self, other): return cmp((self.name, self.broker, self.perspective, self.cached), other) def __hash__(self): return hash((self.name, self.broker, self.perspective, self.cached)) def __call__(self, *args, **kw): """(internal) action method.""" cacheID = self.broker.cachedRemotelyAs(self.cached) if cacheID is None: from pb import ProtocolError # type: ignore[import] raise ProtocolError( "You can't call a cached method when the object hasn't been given to the peer yet." ) return self.broker._sendMessage( b"cache", self.perspective, cacheID, self.name, args, kw ) @comparable class RemoteCacheObserver: """I am a reverse-reference to the peer's L{RemoteCache}. I am generated automatically when a cache is serialized. I represent a reference to the client's L{RemoteCache} object that will represent a particular L{Cacheable}; I am the additional object passed to getStateToCacheAndObserveFor. """ def __init__(self, broker, cached, perspective): """(internal) Initialize me. @param broker: a L{pb.Broker} instance. @param cached: a L{Cacheable} instance that this L{RemoteCacheObserver} corresponds to. @param perspective: a reference to the perspective who is observing this. """ self.broker = broker self.cached = cached self.perspective = perspective def __repr__(self) -> str: return "<RemoteCacheObserver({}, {}, {}) at {}>".format( self.broker, self.cached, self.perspective, id(self), ) def __hash__(self): """Generate a hash unique to all L{RemoteCacheObserver}s for this broker/perspective/cached triplet""" return ( (hash(self.broker) % 2 ** 10) + (hash(self.perspective) % 2 ** 10) + (hash(self.cached) % 2 ** 10) ) def __cmp__(self, other): """Compare me to another L{RemoteCacheObserver}.""" return cmp((self.broker, self.perspective, self.cached), other) def callRemote(self, _name, *args, **kw): """(internal) action method.""" cacheID = self.broker.cachedRemotelyAs(self.cached) if isinstance(_name, str): _name = _name.encode("utf-8") if cacheID is None: from pb import ProtocolError raise ProtocolError( "You can't call a cached method when the " "object hasn't been given to the peer yet." ) return self.broker._sendMessage( b"cache", self.perspective, cacheID, _name, args, kw ) def remoteMethod(self, key): """Get a L{pb.RemoteMethod} for this key.""" return RemoteCacheMethod(key, self.broker, self.cached, self.perspective) PK Mb�ZZ?ܦ� � spread/interfaces.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted Spread Interfaces. """ from zope.interface import Interface class IJellyable(Interface): def jellyFor(jellier): """ Jelly myself for jellier. """ class IUnjellyable(Interface): def unjellyFor(jellier, jellyList): """ Unjelly myself for the jellier. @param jellier: A stateful object which exists for the lifetime of a single call to L{unjelly}. @param jellyList: The C{list} which represents the jellied state of the object to be unjellied. @return: The object which results from unjellying. """ PK Mb�Z�yŖ/ �/ spread/banana.pynu �[��� # -*- test-case-name: twisted.spread.test.test_banana -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Banana -- s-exp based protocol. Future Plans: This module is almost entirely stable. The same caveat applies to it as applies to L{twisted.spread.jelly}, however. Read its future plans for more details. @author: Glyph Lefkowitz """ import copy import struct from io import BytesIO from twisted.internet import protocol from twisted.persisted import styles from twisted.python import log from twisted.python.compat import iterbytes from twisted.python.reflect import fullyQualifiedName class BananaError(Exception): pass def int2b128(integer, stream): if integer == 0: stream(b"\0") return assert integer > 0, "can only encode positive integers" while integer: stream(bytes((integer & 0x7F,))) integer = integer >> 7 def b1282int(st): """ Convert an integer represented as a base 128 string into an L{int}. @param st: The integer encoded in a byte string. @type st: L{bytes} @return: The integer value extracted from the byte string. @rtype: L{int} """ e = 1 i = 0 for char in iterbytes(st): n = ord(char) i += n * e e <<= 7 return i # delimiter characters. LIST = b"\x80" INT = b"\x81" STRING = b"\x82" NEG = b"\x83" FLOAT = b"\x84" # "optional" -- these might be refused by a low-level implementation. LONGINT = b"\x85" LONGNEG = b"\x86" # really optional; this is part of the 'pb' vocabulary VOCAB = b"\x87" HIGH_BIT_SET = b"\x80" def setPrefixLimit(limit): """ Set the limit on the prefix length for all Banana connections established after this call. The prefix length limit determines how many bytes of prefix a banana decoder will allow before rejecting a potential object as too large. @type limit: L{int} @param limit: The number of bytes of prefix for banana to allow when decoding. """ global _PREFIX_LIMIT _PREFIX_LIMIT = limit _PREFIX_LIMIT = None setPrefixLimit(64) SIZE_LIMIT = 640 * 1024 # 640k is all you'll ever need :-) class Banana(protocol.Protocol, styles.Ephemeral): """ L{Banana} implements the I{Banana} s-expression protocol, client and server. @ivar knownDialects: These are the profiles supported by this Banana implementation. @type knownDialects: L{list} of L{bytes} """ # The specification calls these profiles but this implementation calls them # dialects instead. knownDialects = [b"pb", b"none"] prefixLimit = None sizeLimit = SIZE_LIMIT def setPrefixLimit(self, limit): """ Set the prefix limit for decoding done by this protocol instance. @see: L{setPrefixLimit} """ self.prefixLimit = limit self._smallestLongInt = -(2 ** (limit * 7)) + 1 self._smallestInt = -(2 ** 31) self._largestInt = 2 ** 31 - 1 self._largestLongInt = 2 ** (limit * 7) - 1 def connectionReady(self): """Surrogate for connectionMade Called after protocol negotiation. """ def _selectDialect(self, dialect): self.currentDialect = dialect self.connectionReady() def callExpressionReceived(self, obj): if self.currentDialect: self.expressionReceived(obj) else: # this is the first message we've received if self.isClient: # if I'm a client I have to respond for serverVer in obj: if serverVer in self.knownDialects: self.sendEncoded(serverVer) self._selectDialect(serverVer) break else: # I can't speak any of those dialects. log.msg( "The client doesn't speak any of the protocols " "offered by the server: disconnecting." ) self.transport.loseConnection() else: if obj in self.knownDialects: self._selectDialect(obj) else: # the client just selected a protocol that I did not suggest. log.msg( "The client selected a protocol the server didn't " "suggest and doesn't know: disconnecting." ) self.transport.loseConnection() def connectionMade(self): self.setPrefixLimit(_PREFIX_LIMIT) self.currentDialect = None if not self.isClient: self.sendEncoded(self.knownDialects) def gotItem(self, item): l = self.listStack if l: l[-1][1].append(item) else: self.callExpressionReceived(item) buffer = b"" def dataReceived(self, chunk): buffer = self.buffer + chunk listStack = self.listStack gotItem = self.gotItem while buffer: assert self.buffer != buffer, "This ain't right: {} {}".format( repr(self.buffer), repr(buffer), ) self.buffer = buffer pos = 0 for ch in iterbytes(buffer): if ch >= HIGH_BIT_SET: break pos = pos + 1 else: if pos > self.prefixLimit: raise BananaError( "Security precaution: more than %d bytes of prefix" % (self.prefixLimit,) ) return num = buffer[:pos] typebyte = buffer[pos : pos + 1] rest = buffer[pos + 1 :] if len(num) > self.prefixLimit: raise BananaError( "Security precaution: longer than %d bytes worth of prefix" % (self.prefixLimit,) ) if typebyte == LIST: num = b1282int(num) if num > SIZE_LIMIT: raise BananaError("Security precaution: List too long.") listStack.append((num, [])) buffer = rest elif typebyte == STRING: num = b1282int(num) if num > SIZE_LIMIT: raise BananaError("Security precaution: String too long.") if len(rest) >= num: buffer = rest[num:] gotItem(rest[:num]) else: return elif typebyte == INT: buffer = rest num = b1282int(num) gotItem(num) elif typebyte == LONGINT: buffer = rest num = b1282int(num) gotItem(num) elif typebyte == LONGNEG: buffer = rest num = b1282int(num) gotItem(-num) elif typebyte == NEG: buffer = rest num = -b1282int(num) gotItem(num) elif typebyte == VOCAB: buffer = rest num = b1282int(num) item = self.incomingVocabulary[num] if self.currentDialect == b"pb": # the sender issues VOCAB only for dialect pb gotItem(item) else: raise NotImplementedError(f"Invalid item for pb protocol {item!r}") elif typebyte == FLOAT: if len(rest) >= 8: buffer = rest[8:] gotItem(struct.unpack("!d", rest[:8])[0]) else: return else: raise NotImplementedError(f"Invalid Type Byte {typebyte!r}") while listStack and (len(listStack[-1][1]) == listStack[-1][0]): item = listStack.pop()[1] gotItem(item) self.buffer = b"" def expressionReceived(self, lst): """Called when an expression (list, string, or int) is received.""" raise NotImplementedError() outgoingVocabulary = { # Jelly Data Types b"None": 1, b"class": 2, b"dereference": 3, b"reference": 4, b"dictionary": 5, b"function": 6, b"instance": 7, b"list": 8, b"module": 9, b"persistent": 10, b"tuple": 11, b"unpersistable": 12, # PB Data Types b"copy": 13, b"cache": 14, b"cached": 15, b"remote": 16, b"local": 17, b"lcache": 18, # PB Protocol Messages b"version": 19, b"login": 20, b"password": 21, b"challenge": 22, b"logged_in": 23, b"not_logged_in": 24, b"cachemessage": 25, b"message": 26, b"answer": 27, b"error": 28, b"decref": 29, b"decache": 30, b"uncache": 31, } incomingVocabulary = {} for k, v in outgoingVocabulary.items(): incomingVocabulary[v] = k def __init__(self, isClient=1): self.listStack = [] self.outgoingSymbols = copy.copy(self.outgoingVocabulary) self.outgoingSymbolCount = 0 self.isClient = isClient def sendEncoded(self, obj): """ Send the encoded representation of the given object: @param obj: An object to encode and send. @raise BananaError: If the given object is not an instance of one of the types supported by Banana. @return: L{None} """ encodeStream = BytesIO() self._encode(obj, encodeStream.write) value = encodeStream.getvalue() self.transport.write(value) def _encode(self, obj, write): if isinstance(obj, (list, tuple)): if len(obj) > SIZE_LIMIT: raise BananaError("list/tuple is too long to send (%d)" % (len(obj),)) int2b128(len(obj), write) write(LIST) for elem in obj: self._encode(elem, write) elif isinstance(obj, int): if obj < self._smallestLongInt or obj > self._largestLongInt: raise BananaError("int is too large to send (%d)" % (obj,)) if obj < self._smallestInt: int2b128(-obj, write) write(LONGNEG) elif obj < 0: int2b128(-obj, write) write(NEG) elif obj <= self._largestInt: int2b128(obj, write) write(INT) else: int2b128(obj, write) write(LONGINT) elif isinstance(obj, float): write(FLOAT) write(struct.pack("!d", obj)) elif isinstance(obj, bytes): # TODO: an API for extending banana... if self.currentDialect == b"pb" and obj in self.outgoingSymbols: symbolID = self.outgoingSymbols[obj] int2b128(symbolID, write) write(VOCAB) else: if len(obj) > SIZE_LIMIT: raise BananaError( "byte string is too long to send (%d)" % (len(obj),) ) int2b128(len(obj), write) write(STRING) write(obj) else: raise BananaError( "Banana cannot send {} objects: {!r}".format( fullyQualifiedName(type(obj)), obj ) ) # For use from the interactive interpreter _i = Banana() _i.connectionMade() _i._selectDialect(b"none") def encode(lst): """Encode a list s-expression.""" encodeStream = BytesIO() _i.transport = encodeStream _i.sendEncoded(lst) return encodeStream.getvalue() def decode(st): """ Decode a banana-encoded string. """ l = [] _i.expressionReceived = l.append try: _i.dataReceived(st) finally: _i.buffer = b"" del _i.expressionReceived return l[0] PK Mb�Z{�ר� � spread/util.pynu �[��� # -*- test-case-name: twisted.test.test_pb -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Utility classes for spread. """ from zope.interface import implementer from twisted.internet import defer, interfaces from twisted.protocols import basic from twisted.python.failure import Failure from twisted.spread import pb class LocalMethod: def __init__(self, local, name): self.local = local self.name = name def __call__(self, *args, **kw): return self.local.callRemote(self.name, *args, **kw) class LocalAsRemote: """ A class useful for emulating the effects of remote behavior locally. """ reportAllTracebacks = 1 def callRemote(self, name, *args, **kw): """ Call a specially-designated local method. self.callRemote('x') will first try to invoke a method named sync_x and return its result (which should probably be a Deferred). Second, it will look for a method called async_x, which will be called and then have its result (or Failure) automatically wrapped in a Deferred. """ if hasattr(self, "sync_" + name): return getattr(self, "sync_" + name)(*args, **kw) try: method = getattr(self, "async_" + name) return defer.succeed(method(*args, **kw)) except BaseException: f = Failure() if self.reportAllTracebacks: f.printTraceback() return defer.fail(f) def remoteMethod(self, name): return LocalMethod(self, name) class LocalAsyncForwarder: """ A class useful for forwarding a locally-defined interface. """ def __init__(self, forwarded, interfaceClass, failWhenNotImplemented=0): assert interfaceClass.providedBy(forwarded) self.forwarded = forwarded self.interfaceClass = interfaceClass self.failWhenNotImplemented = failWhenNotImplemented def _callMethod(self, method, *args, **kw): return getattr(self.forwarded, method)(*args, **kw) def callRemote(self, method, *args, **kw): if self.interfaceClass.queryDescriptionFor(method): result = defer.maybeDeferred(self._callMethod, method, *args, **kw) return result elif self.failWhenNotImplemented: return defer.fail( Failure(NotImplementedError, "No Such Method in Interface: %s" % method) ) else: return defer.succeed(None) class Pager: """ I am an object which pages out information. """ def __init__(self, collector, callback=None, *args, **kw): """ Create a pager with a Reference to a remote collector and an optional callable to invoke upon completion. """ if callable(callback): self.callback = callback self.callbackArgs = args self.callbackKeyword = kw else: self.callback = None self._stillPaging = 1 self.collector = collector collector.broker.registerPageProducer(self) def stillPaging(self): """ (internal) Method called by Broker. """ if not self._stillPaging: self.collector.callRemote("endedPaging", pbanswer=False) if self.callback is not None: self.callback(*self.callbackArgs, **self.callbackKeyword) return self._stillPaging def sendNextPage(self): """ (internal) Method called by Broker. """ self.collector.callRemote("gotPage", self.nextPage(), pbanswer=False) def nextPage(self): """ Override this to return an object to be sent to my collector. """ raise NotImplementedError() def stopPaging(self): """ Call this when you're done paging. """ self._stillPaging = 0 class StringPager(Pager): """ A simple pager that splits a string into chunks. """ def __init__(self, collector, st, chunkSize=8192, callback=None, *args, **kw): self.string = st self.pointer = 0 self.chunkSize = chunkSize Pager.__init__(self, collector, callback, *args, **kw) def nextPage(self): val = self.string[self.pointer : self.pointer + self.chunkSize] self.pointer += self.chunkSize if self.pointer >= len(self.string): self.stopPaging() return val @implementer(interfaces.IConsumer) class FilePager(Pager): """ Reads a file in chunks and sends the chunks as they come. """ def __init__(self, collector, fd, callback=None, *args, **kw): self.chunks = [] Pager.__init__(self, collector, callback, *args, **kw) self.startProducing(fd) def startProducing(self, fd): self.deferred = basic.FileSender().beginFileTransfer(fd, self) self.deferred.addBoth(lambda x: self.stopPaging()) def registerProducer(self, producer, streaming): self.producer = producer if not streaming: self.producer.resumeProducing() def unregisterProducer(self): self.producer = None def write(self, chunk): self.chunks.append(chunk) def sendNextPage(self): """ Get the first chunk read and send it to collector. """ if not self.chunks: return val = self.chunks.pop(0) self.producer.resumeProducing() self.collector.callRemote("gotPage", val, pbanswer=False) # Utility paging stuff. class CallbackPageCollector(pb.Referenceable): """ I receive pages from the peer. You may instantiate a Pager with a remote reference to me. I will call the callback with a list of pages once they are all received. """ def __init__(self, callback): self.pages = [] self.callback = callback def remote_gotPage(self, page): self.pages.append(page) def remote_endedPaging(self): self.callback(self.pages) def getAllPages(referenceable, methodName, *args, **kw): """ A utility method that will call a remote method which expects a PageCollector as the first argument. """ d = defer.Deferred() referenceable.callRemote(methodName, CallbackPageCollector(d.callback), *args, **kw) return d PK Mb�Z��n, , spread/publish.pynu �[��� # -*- test-case-name: twisted.spread.test.test_pb -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Persistently cached objects for PB. Maintainer: Glyph Lefkowitz Future Plans: None known. """ import time from twisted.internet import defer from twisted.spread import banana, flavors, jelly class Publishable(flavors.Cacheable): """An object whose cached state persists across sessions.""" def __init__(self, publishedID): self.republish() self.publishedID = publishedID def republish(self): """Set the timestamp to current and (TODO) update all observers.""" self.timestamp = time.time() def view_getStateToPublish(self, perspective): "(internal)" return self.getStateToPublishFor(perspective) def getStateToPublishFor(self, perspective): """Implement me to special-case your state for a perspective.""" return self.getStateToPublish() def getStateToPublish(self): """Implement me to return state to copy as part of the publish phase.""" raise NotImplementedError("%s.getStateToPublishFor" % self.__class__) def getStateToCacheAndObserveFor(self, perspective, observer): """Get all necessary metadata to keep a clientside cache.""" if perspective: pname = perspective.perspectiveName sname = perspective.getService().serviceName else: pname = "None" sname = "None" return { "remote": flavors.ViewPoint(perspective, self), "publishedID": self.publishedID, "perspective": pname, "service": sname, "timestamp": self.timestamp, } class RemotePublished(flavors.RemoteCache): """The local representation of remote Publishable object.""" isActivated = 0 _wasCleanWhenLoaded = 0 def getFileName(self, ext="pub"): return "{}-{}-{}.{}".format( self.service, self.perspective, str(self.publishedID), ext, ) def setCopyableState(self, state): self.__dict__.update(state) self._activationListeners = [] try: with open(self.getFileName(), "rb") as dataFile: data = dataFile.read() except OSError: recent = 0 else: newself = jelly.unjelly(banana.decode(data)) recent = newself.timestamp == self.timestamp if recent: self._cbGotUpdate(newself.__dict__) self._wasCleanWhenLoaded = 1 else: self.remote.callRemote("getStateToPublish").addCallbacks(self._cbGotUpdate) def __getstate__(self): other = self.__dict__.copy() # Remove PB-specific attributes del other["broker"] del other["remote"] del other["luid"] # remove my own runtime-tracking stuff del other["_activationListeners"] del other["isActivated"] return other def _cbGotUpdate(self, newState): self.__dict__.update(newState) self.isActivated = 1 # send out notifications for listener in self._activationListeners: listener(self) self._activationListeners = [] self.activated() with open(self.getFileName(), "wb") as dataFile: dataFile.write(banana.encode(jelly.jelly(self))) def activated(self): """Implement this method if you want to be notified when your publishable subclass is activated. """ def callWhenActivated(self, callback): """Externally register for notification when this publishable has received all relevant data.""" if self.isActivated: callback(self) else: self._activationListeners.append(callback) def whenReady(d): """ Wrap a deferred returned from a pb method in another deferred that expects a RemotePublished as a result. This will allow you to wait until the result is really available. Idiomatic usage would look like:: publish.whenReady(serverObject.getMeAPublishable()).addCallback(lookAtThePublishable) """ d2 = defer.Deferred() d.addCallbacks(_pubReady, d2.errback, callbackArgs=(d2,)) return d2 def _pubReady(result, d2): "(internal)" result.callWhenActivated(d2.callback) PK Mb�Z�`3�_� _� spread/pb.pynu �[��� # -*- test-case-name: twisted.spread.test.test_pb -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Perspective Broker \"This isn\'t a professional opinion, but it's probably got enough internet to kill you.\" --glyph Introduction ============ This is a broker for proxies for and copies of objects. It provides a translucent interface layer to those proxies. The protocol is not opaque, because it provides objects which represent the remote proxies and require no context (server references, IDs) to operate on. It is not transparent because it does I{not} attempt to make remote objects behave identically, or even similarly, to local objects. Method calls are invoked asynchronously, and specific rules are applied when serializing arguments. To get started, begin with L{PBClientFactory} and L{PBServerFactory}. @author: Glyph Lefkowitz """ import random from hashlib import md5 from zope.interface import Interface, implementer from twisted.cred.credentials import ( Anonymous, IAnonymous, ICredentials, IUsernameHashedPassword, ) from twisted.cred.portal import Portal from twisted.internet import defer, protocol from twisted.persisted import styles # Twisted Imports from twisted.python import failure, log, reflect from twisted.python.compat import cmp, comparable from twisted.python.components import registerAdapter from twisted.spread import banana # These three are backwards compatibility aliases for the previous three. # Ultimately they should be deprecated. -exarkun from twisted.spread.flavors import ( Cacheable, Copyable, IPBRoot, Jellyable, NoSuchMethod, Referenceable, RemoteCache, RemoteCacheObserver, RemoteCopy, Root, Serializable, Viewable, ViewPoint, copyTags, setCopierForClass, setCopierForClassTree, setFactoryForClass, setUnjellyableFactoryForClass, setUnjellyableForClass, setUnjellyableForClassTree, ) from twisted.spread.interfaces import IJellyable, IUnjellyable from twisted.spread.jelly import _newInstance, globalSecurity, jelly, unjelly MAX_BROKER_REFS = 1024 portno = 8787 class ProtocolError(Exception): """ This error is raised when an invalid protocol statement is received. """ class DeadReferenceError(ProtocolError): """ This error is raised when a method is called on a dead reference (one whose broker has been disconnected). """ class Error(Exception): """ This error can be raised to generate known error conditions. When a PB callable method (perspective_, remote_, view_) raises this error, it indicates that a traceback should not be printed, but instead, the string representation of the exception should be sent. """ class RemoteError(Exception): """ This class is used to wrap a string-ified exception from the remote side to be able to reraise it. (Raising string exceptions is no longer possible in Python 2.6+) The value of this exception will be a str() representation of the remote value. @ivar remoteType: The full import path of the exception class which was raised on the remote end. @type remoteType: C{str} @ivar remoteTraceback: The remote traceback. @type remoteTraceback: C{str} @note: It's not possible to include the remoteTraceback if this exception is thrown into a generator. It must be accessed as an attribute. """ def __init__(self, remoteType, value, remoteTraceback): Exception.__init__(self, value) self.remoteType = remoteType self.remoteTraceback = remoteTraceback @comparable class RemoteMethod: """ This is a translucent reference to a remote message. """ def __init__(self, obj, name): """ Initialize with a L{RemoteReference} and the name of this message. """ self.obj = obj self.name = name def __cmp__(self, other): return cmp((self.obj, self.name), other) def __hash__(self): return hash((self.obj, self.name)) def __call__(self, *args, **kw): """ Asynchronously invoke a remote method. """ return self.obj.broker._sendMessage( b"", self.obj.perspective, self.obj.luid, self.name.encode("utf-8"), args, kw, ) class PBConnectionLost(Exception): pass class IPerspective(Interface): """ per*spec*tive, n. : The relationship of aspects of a subject to each other and to a whole: 'a perspective of history'; 'a need to view the problem in the proper perspective'. This is a Perspective Broker-specific wrapper for an avatar. That is to say, a PB-published view on to the business logic for the system's concept of a 'user'. The concept of attached/detached is no longer implemented by the framework. The realm is expected to implement such semantics if needed. """ def perspectiveMessageReceived(broker, message, args, kwargs): """ This method is called when a network message is received. @arg broker: The Perspective Broker. @type message: str @arg message: The name of the method called by the other end. @type args: list in jelly format @arg args: The arguments that were passed by the other end. It is recommend that you use the `unserialize' method of the broker to decode this. @type kwargs: dict in jelly format @arg kwargs: The keyword arguments that were passed by the other end. It is recommended that you use the `unserialize' method of the broker to decode this. @rtype: A jelly list. @return: It is recommended that you use the `serialize' method of the broker on whatever object you need to return to generate the return value. """ @implementer(IPerspective) class Avatar: """ A default IPerspective implementor. This class is intended to be subclassed, and a realm should return an instance of such a subclass when IPerspective is requested of it. A peer requesting a perspective will receive only a L{RemoteReference} to a pb.Avatar. When a method is called on that L{RemoteReference}, it will translate to a method on the remote perspective named 'perspective_methodname'. (For more information on invoking methods on other objects, see L{flavors.ViewPoint}.) """ def perspectiveMessageReceived(self, broker, message, args, kw): """ This method is called when a network message is received. This will call:: self.perspective_%(message)s(*broker.unserialize(args), **broker.unserialize(kw)) to handle the method; subclasses of Avatar are expected to implement methods using this naming convention. """ args = broker.unserialize(args, self) kw = broker.unserialize(kw, self) method = getattr(self, "perspective_%s" % message) try: state = method(*args, **kw) except TypeError: log.msg(f"{method} didn't accept {args} and {kw}") raise return broker.serialize(state, self, method, args, kw) class AsReferenceable(Referenceable): """ A reference directed towards another object. """ def __init__(self, object, messageType="remote"): self.remoteMessageReceived = getattr(object, messageType + "MessageReceived") @implementer(IUnjellyable) @comparable class RemoteReference(Serializable, styles.Ephemeral): """ A translucent reference to a remote object. I may be a reference to a L{flavors.ViewPoint}, a L{flavors.Referenceable}, or an L{IPerspective} implementer (e.g., pb.Avatar). From the client's perspective, it is not possible to tell which except by convention. I am a \"translucent\" reference because although no additional bookkeeping overhead is given to the application programmer for manipulating a reference, return values are asynchronous. See also L{twisted.internet.defer}. @ivar broker: The broker I am obtained through. @type broker: L{Broker} """ def __init__(self, perspective, broker, luid, doRefCount): """(internal) Initialize me with a broker and a locally-unique ID. The ID is unique only to the particular Perspective Broker instance. """ self.luid = luid self.broker = broker self.doRefCount = doRefCount self.perspective = perspective self.disconnectCallbacks = [] def notifyOnDisconnect(self, callback): """ Register a callback to be called if our broker gets disconnected. @param callback: a callable which will be called with one argument, this instance. """ assert callable(callback) self.disconnectCallbacks.append(callback) if len(self.disconnectCallbacks) == 1: self.broker.notifyOnDisconnect(self._disconnected) def dontNotifyOnDisconnect(self, callback): """ Remove a callback that was registered with notifyOnDisconnect. @param callback: a callable """ self.disconnectCallbacks.remove(callback) if not self.disconnectCallbacks: self.broker.dontNotifyOnDisconnect(self._disconnected) def _disconnected(self): """ Called if we are disconnected and have callbacks registered. """ for callback in self.disconnectCallbacks: callback(self) self.disconnectCallbacks = None def jellyFor(self, jellier): """ If I am being sent back to where I came from, serialize as a local backreference. """ if jellier.invoker: assert ( self.broker == jellier.invoker ), "Can't send references to brokers other than their own." return b"local", self.luid else: return b"unpersistable", "References cannot be serialized" def unjellyFor(self, unjellier, unjellyList): self.__init__( unjellier.invoker.unserializingPerspective, unjellier.invoker, unjellyList[1], 1, ) return self def callRemote(self, _name, *args, **kw): """ Asynchronously invoke a remote method. @type _name: L{str} @param _name: the name of the remote method to invoke @param args: arguments to serialize for the remote function @param kw: keyword arguments to serialize for the remote function. @rtype: L{twisted.internet.defer.Deferred} @returns: a Deferred which will be fired when the result of this remote call is received. """ if not isinstance(_name, bytes): _name = _name.encode("utf8") # Note that we use '_name' instead of 'name' so the user can call # remote methods with 'name' as a keyword parameter, like this: # ref.callRemote("getPeopleNamed", count=12, name="Bob") return self.broker._sendMessage( b"", self.perspective, self.luid, _name, args, kw ) def remoteMethod(self, key): """ @param key: The key. @return: A L{RemoteMethod} for this key. """ return RemoteMethod(self, key) def __cmp__(self, other): """ @param other: another L{RemoteReference} to compare me to. """ if isinstance(other, RemoteReference): if other.broker == self.broker: return cmp(self.luid, other.luid) return cmp(self.broker, other) def __hash__(self): """ Hash me. """ return self.luid def __del__(self): """ Do distributed reference counting on finalization. """ if self.doRefCount: self.broker.sendDecRef(self.luid) setUnjellyableForClass("remote", RemoteReference) class Local: """ (internal) A reference to a local object. """ def __init__(self, object, perspective=None): """ Initialize. """ self.object = object self.perspective = perspective self.refcount = 1 def __repr__(self) -> str: return f"<pb.Local {self.object!r} ref:{self.refcount}>" def incref(self): """ Increment the reference count. @return: the reference count after incrementing """ self.refcount = self.refcount + 1 return self.refcount def decref(self): """ Decrement the reference count. @return: the reference count after decrementing """ self.refcount = self.refcount - 1 return self.refcount # Failure class CopyableFailure(failure.Failure, Copyable): """ A L{flavors.RemoteCopy} and L{flavors.Copyable} version of L{twisted.python.failure.Failure} for serialization. """ unsafeTracebacks = 0 def getStateToCopy(self): """ Collect state related to the exception which occurred, discarding state which cannot reasonably be serialized. """ state = self.__dict__.copy() state["tb"] = None state["frames"] = [] state["stack"] = [] state["value"] = str(self.value) # Exception instance if isinstance(self.type, bytes): state["type"] = self.type else: state["type"] = reflect.qual(self.type).encode("utf-8") # Exception class if self.unsafeTracebacks: state["traceback"] = self.getTraceback() else: state["traceback"] = "Traceback unavailable\n" return state class CopiedFailure(RemoteCopy, failure.Failure): """ A L{CopiedFailure} is a L{pb.RemoteCopy} of a L{failure.Failure} transferred via PB. @ivar type: The full import path of the exception class which was raised on the remote end. @type type: C{str} @ivar value: A str() representation of the remote value. @type value: L{CopiedFailure} or C{str} @ivar traceback: The remote traceback. @type traceback: C{str} """ def printTraceback(self, file=None, elideFrameworkCode=0, detail="default"): if file is None: file = log.logfile failureType = self.type if not isinstance(failureType, str): failureType = failureType.decode("utf-8") file.write("Traceback from remote host -- ") file.write(failureType + ": " + self.value) file.write("\n") def throwExceptionIntoGenerator(self, g): """ Throw the original exception into the given generator, preserving traceback information if available. In the case of a L{CopiedFailure} where the exception type is a string, a L{pb.RemoteError} is thrown instead. @return: The next value yielded from the generator. @raise StopIteration: If there are no more values in the generator. @raise RemoteError: The wrapped remote exception. """ return g.throw(RemoteError(self.type, self.value, self.traceback)) printBriefTraceback = printTraceback printDetailedTraceback = printTraceback setUnjellyableForClass(CopyableFailure, CopiedFailure) def failure2Copyable(fail, unsafeTracebacks=0): f = _newInstance(CopyableFailure, fail.__dict__) f.unsafeTracebacks = unsafeTracebacks return f class Broker(banana.Banana): """ I am a broker for objects. """ version = 6 username = None factory = None def __init__(self, isClient=1, security=globalSecurity): banana.Banana.__init__(self, isClient) self.disconnected = 0 self.disconnects = [] self.failures = [] self.connects = [] self.localObjects = {} self.security = security self.pageProducers = [] self.currentRequestID = 0 self.currentLocalID = 0 self.unserializingPerspective = None # Some terms: # PUID: process unique ID; return value of id() function. type "int". # LUID: locally unique ID; an ID unique to an object mapped over this # connection. type "int" # GUID: (not used yet) globally unique ID; an ID for an object which # may be on a redirected or meta server. Type as yet undecided. # Dictionary mapping LUIDs to local objects. # set above to allow root object to be assigned before connection is made # self.localObjects = {} # Dictionary mapping PUIDs to LUIDs. self.luids = {} # Dictionary mapping LUIDs to local (remotely cached) objects. Remotely # cached means that they're objects which originate here, and were # copied remotely. self.remotelyCachedObjects = {} # Dictionary mapping PUIDs to (cached) LUIDs self.remotelyCachedLUIDs = {} # Dictionary mapping (remote) LUIDs to (locally cached) objects. self.locallyCachedObjects = {} self.waitingForAnswers = {} # Mapping from LUIDs to weakref objects with callbacks for performing # any local cleanup which may be necessary for the corresponding # object once it no longer exists. self._localCleanup = {} def resumeProducing(self): """ Called when the consumer attached to me runs out of buffer. """ # Go backwards over the list so we can remove indexes from it as we go for pageridx in range(len(self.pageProducers) - 1, -1, -1): pager = self.pageProducers[pageridx] pager.sendNextPage() if not pager.stillPaging(): del self.pageProducers[pageridx] if not self.pageProducers: self.transport.unregisterProducer() def pauseProducing(self): # Streaming producer method; not necessary to implement. pass def stopProducing(self): # Streaming producer method; not necessary to implement. pass def registerPageProducer(self, pager): self.pageProducers.append(pager) if len(self.pageProducers) == 1: self.transport.registerProducer(self, 0) def expressionReceived(self, sexp): """ Evaluate an expression as it's received. """ if isinstance(sexp, list): command = sexp[0] if not isinstance(command, str): command = command.decode("utf8") methodName = "proto_%s" % command method = getattr(self, methodName, None) if method: method(*sexp[1:]) else: self.sendCall(b"didNotUnderstand", command) else: raise ProtocolError("Non-list expression received.") def proto_version(self, vnum): """ Protocol message: (version version-number) Check to make sure that both ends of the protocol are speaking the same version dialect. @param vnum: The version number. """ if vnum != self.version: raise ProtocolError(f"Version Incompatibility: {self.version} {vnum}") def sendCall(self, *exp): """ Utility method to send an expression to the other side of the connection. @param exp: The expression. """ self.sendEncoded(exp) def proto_didNotUnderstand(self, command): """ Respond to stock 'C{didNotUnderstand}' message. Log the command that was not understood and continue. (Note: this will probably be changed to close the connection or raise an exception in the future.) @param command: The command to log. """ log.msg("Didn't understand command: %r" % command) def connectionReady(self): """ Initialize. Called after Banana negotiation is done. """ self.sendCall(b"version", self.version) for notifier in self.connects: try: notifier() except BaseException: log.deferr() self.connects = None self.factory.clientConnectionMade(self) def connectionFailed(self): # XXX should never get called anymore? check! for notifier in self.failures: try: notifier() except BaseException: log.deferr() self.failures = None waitingForAnswers = None def connectionLost(self, reason): """ The connection was lost. @param reason: message to put in L{failure.Failure} """ self.disconnected = 1 # Nuke potential circular references. self.luids = None if self.waitingForAnswers: for d in self.waitingForAnswers.values(): try: d.errback(failure.Failure(PBConnectionLost(reason))) except BaseException: log.deferr() # Assure all Cacheable.stoppedObserving are called for lobj in self.remotelyCachedObjects.values(): cacheable = lobj.object perspective = lobj.perspective try: cacheable.stoppedObserving( perspective, RemoteCacheObserver(self, cacheable, perspective) ) except BaseException: log.deferr() # Loop on a copy to prevent notifiers to mixup # the list by calling dontNotifyOnDisconnect for notifier in self.disconnects[:]: try: notifier() except BaseException: log.deferr() self.disconnects = None self.waitingForAnswers = None self.localSecurity = None self.remoteSecurity = None self.remotelyCachedObjects = None self.remotelyCachedLUIDs = None self.locallyCachedObjects = None self.localObjects = None def notifyOnDisconnect(self, notifier): """ @param notifier: callback to call when the Broker disconnects. """ assert callable(notifier) self.disconnects.append(notifier) def notifyOnFail(self, notifier): """ @param notifier: callback to call if the Broker fails to connect. """ assert callable(notifier) self.failures.append(notifier) def notifyOnConnect(self, notifier): """ @param notifier: callback to call when the Broker connects. """ assert callable(notifier) if self.connects is None: try: notifier() except BaseException: log.err() else: self.connects.append(notifier) def dontNotifyOnDisconnect(self, notifier): """ @param notifier: callback to remove from list of disconnect callbacks. """ try: self.disconnects.remove(notifier) except ValueError: pass def localObjectForID(self, luid): """ Get a local object for a locally unique ID. @return: An object previously stored with L{registerReference} or L{None} if there is no object which corresponds to the given identifier. """ if isinstance(luid, str): luid = luid.encode("utf8") lob = self.localObjects.get(luid) if lob is None: return return lob.object maxBrokerRefsViolations = 0 def registerReference(self, object): """ Store a persistent reference to a local object and map its id() to a generated, session-unique ID. @param object: a local object @return: the generated ID """ assert object is not None puid = object.processUniqueID() luid = self.luids.get(puid) if luid is None: if len(self.localObjects) > MAX_BROKER_REFS: self.maxBrokerRefsViolations = self.maxBrokerRefsViolations + 1 if self.maxBrokerRefsViolations > 3: self.transport.loseConnection() raise Error("Maximum PB reference count exceeded. " "Goodbye.") raise Error("Maximum PB reference count exceeded.") luid = self.newLocalID() self.localObjects[luid] = Local(object) self.luids[puid] = luid else: self.localObjects[luid].incref() return luid def setNameForLocal(self, name, object): """ Store a special (string) ID for this object. This is how you specify a 'base' set of objects that the remote protocol can connect to. @param name: An ID. @param object: The object. """ if isinstance(name, str): name = name.encode("utf8") assert object is not None self.localObjects[name] = Local(object) def remoteForName(self, name): """ Returns an object from the remote name mapping. Note that this does not check the validity of the name, only creates a translucent reference for it. @param name: The name to look up. @return: An object which maps to the name. """ if isinstance(name, str): name = name.encode("utf8") return RemoteReference(None, self, name, 0) def cachedRemotelyAs(self, instance, incref=0): """ @param instance: The instance to look up. @param incref: Flag to specify whether to increment the reference. @return: An ID that says what this instance is cached as remotely, or L{None} if it's not. """ puid = instance.processUniqueID() luid = self.remotelyCachedLUIDs.get(puid) if (luid is not None) and (incref): self.remotelyCachedObjects[luid].incref() return luid def remotelyCachedForLUID(self, luid): """ @param luid: The LUID to look up. @return: An instance which is cached remotely. """ return self.remotelyCachedObjects[luid].object def cacheRemotely(self, instance): """ XXX @return: A new LUID. """ puid = instance.processUniqueID() luid = self.newLocalID() if len(self.remotelyCachedObjects) > MAX_BROKER_REFS: self.maxBrokerRefsViolations = self.maxBrokerRefsViolations + 1 if self.maxBrokerRefsViolations > 3: self.transport.loseConnection() raise Error("Maximum PB cache count exceeded. " "Goodbye.") raise Error("Maximum PB cache count exceeded.") self.remotelyCachedLUIDs[puid] = luid # This table may not be necessary -- for now, it's to make sure that no # monkey business happens with id(instance) self.remotelyCachedObjects[luid] = Local(instance, self.serializingPerspective) return luid def cacheLocally(self, cid, instance): """(internal) Store a non-filled-out cached instance locally. """ self.locallyCachedObjects[cid] = instance def cachedLocallyAs(self, cid): instance = self.locallyCachedObjects[cid] return instance def serialize(self, object, perspective=None, method=None, args=None, kw=None): """ Jelly an object according to the remote security rules for this broker. @param object: The object to jelly. @param perspective: The perspective. @param method: The method. @param args: Arguments. @param kw: Keyword arguments. """ if isinstance(object, defer.Deferred): object.addCallbacks( self.serialize, lambda x: x, callbackKeywords={ "perspective": perspective, "method": method, "args": args, "kw": kw, }, ) return object # XXX This call is NOT REENTRANT and testing for reentrancy is just # crazy, so it likely won't be. Don't ever write methods that call the # broker's serialize() method recursively (e.g. sending a method call # from within a getState (this causes concurrency problems anyway so # you really, really shouldn't do it)) self.serializingPerspective = perspective self.jellyMethod = method self.jellyArgs = args self.jellyKw = kw try: return jelly(object, self.security, None, self) finally: self.serializingPerspective = None self.jellyMethod = None self.jellyArgs = None self.jellyKw = None def unserialize(self, sexp, perspective=None): """ Unjelly an sexp according to the local security rules for this broker. @param sexp: The object to unjelly. @param perspective: The perspective. """ self.unserializingPerspective = perspective try: return unjelly(sexp, self.security, None, self) finally: self.unserializingPerspective = None def newLocalID(self): """ @return: A newly generated LUID. """ self.currentLocalID = self.currentLocalID + 1 return self.currentLocalID def newRequestID(self): """ @return: A newly generated request ID. """ self.currentRequestID = self.currentRequestID + 1 return self.currentRequestID def _sendMessage(self, prefix, perspective, objectID, message, args, kw): pbc = None pbe = None answerRequired = 1 if "pbcallback" in kw: pbc = kw["pbcallback"] del kw["pbcallback"] if "pberrback" in kw: pbe = kw["pberrback"] del kw["pberrback"] if "pbanswer" in kw: assert (not pbe) and (not pbc), "You can't specify a no-answer requirement." answerRequired = kw["pbanswer"] del kw["pbanswer"] if self.disconnected: raise DeadReferenceError("Calling Stale Broker") try: netArgs = self.serialize(args, perspective=perspective, method=message) netKw = self.serialize(kw, perspective=perspective, method=message) except BaseException: return defer.fail(failure.Failure()) requestID = self.newRequestID() if answerRequired: rval = defer.Deferred() self.waitingForAnswers[requestID] = rval if pbc or pbe: log.msg('warning! using deprecated "pbcallback"') rval.addCallbacks(pbc, pbe) else: rval = None self.sendCall( prefix + b"message", requestID, objectID, message, answerRequired, netArgs, netKw, ) return rval def proto_message( self, requestID, objectID, message, answerRequired, netArgs, netKw ): self._recvMessage( self.localObjectForID, requestID, objectID, message, answerRequired, netArgs, netKw, ) def proto_cachemessage( self, requestID, objectID, message, answerRequired, netArgs, netKw ): self._recvMessage( self.cachedLocallyAs, requestID, objectID, message, answerRequired, netArgs, netKw, ) def _recvMessage( self, findObjMethod, requestID, objectID, message, answerRequired, netArgs, netKw, ): """ Received a message-send. Look up message based on object, unserialize the arguments, and invoke it with args, and send an 'answer' or 'error' response. @param findObjMethod: A callable which takes C{objectID} as argument. @param requestID: The requiest ID. @param objectID: The object ID. @param message: The message. @param answerRequired: @param netArgs: Arguments. @param netKw: Keyword arguments. """ if not isinstance(message, str): message = message.decode("utf8") try: object = findObjMethod(objectID) if object is None: raise Error("Invalid Object ID") netResult = object.remoteMessageReceived(self, message, netArgs, netKw) except Error as e: if answerRequired: # If the error is Jellyable or explicitly allowed via our # security options, send it back and let the code on the # other end deal with unjellying. If it isn't Jellyable, # wrap it in a CopyableFailure, which ensures it can be # unjellied on the other end. We have to do this because # all errors must be sent back. if isinstance(e, Jellyable) or self.security.isClassAllowed( e.__class__ ): self._sendError(e, requestID) else: self._sendError(CopyableFailure(e), requestID) except BaseException: if answerRequired: log.msg("Peer will receive following PB traceback:", isError=True) f = CopyableFailure() self._sendError(f, requestID) log.err() else: if answerRequired: if isinstance(netResult, defer.Deferred): args = (requestID,) netResult.addCallbacks( self._sendAnswer, self._sendFailureOrError, callbackArgs=args, errbackArgs=args, ) # XXX Should this be done somewhere else? else: self._sendAnswer(netResult, requestID) def _sendAnswer(self, netResult, requestID): """ (internal) Send an answer to a previously sent message. @param netResult: The answer. @param requestID: The request ID. """ self.sendCall(b"answer", requestID, netResult) def proto_answer(self, requestID, netResult): """ (internal) Got an answer to a previously sent message. Look up the appropriate callback and call it. @param requestID: The request ID. @param netResult: The answer. """ d = self.waitingForAnswers[requestID] del self.waitingForAnswers[requestID] d.callback(self.unserialize(netResult)) def _sendFailureOrError(self, fail, requestID): """ Call L{_sendError} or L{_sendFailure}, depending on whether C{fail} represents an L{Error} subclass or not. @param fail: The failure. @param requestID: The request ID. """ if fail.check(Error) is None: self._sendFailure(fail, requestID) else: self._sendError(fail, requestID) def _sendFailure(self, fail, requestID): """ Log error and then send it. @param fail: The failure. @param requestID: The request ID. """ log.msg("Peer will receive following PB traceback:") log.err(fail) self._sendError(fail, requestID) def _sendError(self, fail, requestID): """ (internal) Send an error for a previously sent message. @param fail: The failure. @param requestID: The request ID. """ if isinstance(fail, failure.Failure): # If the failures value is jellyable or allowed through security, # send the value if isinstance(fail.value, Jellyable) or self.security.isClassAllowed( fail.value.__class__ ): fail = fail.value elif not isinstance(fail, CopyableFailure): fail = failure2Copyable(fail, self.factory.unsafeTracebacks) if isinstance(fail, CopyableFailure): fail.unsafeTracebacks = self.factory.unsafeTracebacks self.sendCall(b"error", requestID, self.serialize(fail)) def proto_error(self, requestID, fail): """ (internal) Deal with an error. @param requestID: The request ID. @param fail: The failure. """ d = self.waitingForAnswers[requestID] del self.waitingForAnswers[requestID] d.errback(self.unserialize(fail)) def sendDecRef(self, objectID): """ (internal) Send a DECREF directive. @param objectID: The object ID. """ self.sendCall(b"decref", objectID) def proto_decref(self, objectID): """ (internal) Decrement the reference count of an object. If the reference count is zero, it will free the reference to this object. @param objectID: The object ID. """ if isinstance(objectID, str): objectID = objectID.encode("utf8") refs = self.localObjects[objectID].decref() if refs == 0: puid = self.localObjects[objectID].object.processUniqueID() del self.luids[puid] del self.localObjects[objectID] self._localCleanup.pop(puid, lambda: None)() def decCacheRef(self, objectID): """ (internal) Send a DECACHE directive. @param objectID: The object ID. """ self.sendCall(b"decache", objectID) def proto_decache(self, objectID): """ (internal) Decrement the reference count of a cached object. If the reference count is zero, free the reference, then send an 'uncached' directive. @param objectID: The object ID. """ refs = self.remotelyCachedObjects[objectID].decref() # log.msg('decaching: %s #refs: %s' % (objectID, refs)) if refs == 0: lobj = self.remotelyCachedObjects[objectID] cacheable = lobj.object perspective = lobj.perspective # TODO: force_decache needs to be able to force-invalidate a # cacheable reference. try: cacheable.stoppedObserving( perspective, RemoteCacheObserver(self, cacheable, perspective) ) except BaseException: log.deferr() puid = cacheable.processUniqueID() del self.remotelyCachedLUIDs[puid] del self.remotelyCachedObjects[objectID] self.sendCall(b"uncache", objectID) def proto_uncache(self, objectID): """ (internal) Tell the client it is now OK to uncache an object. @param objectID: The object ID. """ # log.msg("uncaching locally %d" % objectID) obj = self.locallyCachedObjects[objectID] obj.broker = None ## def reallyDel(obj=obj): ## obj.__really_del__() ## obj.__del__ = reallyDel del self.locallyCachedObjects[objectID] def respond(challenge, password): """ Respond to a challenge. This is useful for challenge/response authentication. @param challenge: A challenge. @param password: A password. @return: The password hashed twice. """ m = md5() m.update(password) hashedPassword = m.digest() m = md5() m.update(hashedPassword) m.update(challenge) doubleHashedPassword = m.digest() return doubleHashedPassword def challenge(): """ @return: Some random data. """ crap = bytes(random.randint(65, 90) for x in range(random.randrange(15, 25))) crap = md5(crap).digest() return crap class PBClientFactory(protocol.ClientFactory): """ Client factory for PB brokers. As with all client factories, use with reactor.connectTCP/SSL/etc.. getPerspective and getRootObject can be called either before or after the connect. """ protocol = Broker unsafeTracebacks = False def __init__(self, unsafeTracebacks=False, security=globalSecurity): """ @param unsafeTracebacks: if set, tracebacks for exceptions will be sent over the wire. @type unsafeTracebacks: C{bool} @param security: security options used by the broker, default to C{globalSecurity}. @type security: L{twisted.spread.jelly.SecurityOptions} """ self.unsafeTracebacks = unsafeTracebacks self.security = security self._reset() def buildProtocol(self, addr): """ Build the broker instance, passing the security options to it. """ p = self.protocol(isClient=True, security=self.security) p.factory = self return p def _reset(self): self.rootObjectRequests = [] # list of deferred self._broker = None self._root = None def _failAll(self, reason): deferreds = self.rootObjectRequests self._reset() for d in deferreds: d.errback(reason) def clientConnectionFailed(self, connector, reason): self._failAll(reason) def clientConnectionLost(self, connector, reason, reconnecting=0): """ Reconnecting subclasses should call with reconnecting=1. """ if reconnecting: # Any pending requests will go to next connection attempt # so we don't fail them. self._broker = None self._root = None else: self._failAll(reason) def clientConnectionMade(self, broker): self._broker = broker self._root = broker.remoteForName("root") ds = self.rootObjectRequests self.rootObjectRequests = [] for d in ds: d.callback(self._root) def getRootObject(self): """ Get root object of remote PB server. @return: Deferred of the root object. """ if self._broker and not self._broker.disconnected: return defer.succeed(self._root) d = defer.Deferred() self.rootObjectRequests.append(d) return d def disconnect(self): """ If the factory is connected, close the connection. Note that if you set up the factory to reconnect, you will need to implement extra logic to prevent automatic reconnection after this is called. """ if self._broker: self._broker.transport.loseConnection() def _cbSendUsername(self, root, username, password, client): return root.callRemote("login", username).addCallback( self._cbResponse, password, client ) def _cbResponse(self, challenges, password, client): challenge, challenger = challenges return challenger.callRemote("respond", respond(challenge, password), client) def _cbLoginAnonymous(self, root, client): """ Attempt an anonymous login on the given remote root object. @type root: L{RemoteReference} @param root: The object on which to attempt the login, most likely returned by a call to L{PBClientFactory.getRootObject}. @param client: A jellyable object which will be used as the I{mind} parameter for the login attempt. @rtype: L{Deferred} @return: A L{Deferred} which will be called back with a L{RemoteReference} to an avatar when anonymous login succeeds, or which will errback if anonymous login fails. """ return root.callRemote("loginAnonymous", client) def login(self, credentials, client=None): """ Login and get perspective from remote PB server. Currently the following credentials are supported:: L{twisted.cred.credentials.IUsernamePassword} L{twisted.cred.credentials.IAnonymous} @rtype: L{Deferred} @return: A L{Deferred} which will be called back with a L{RemoteReference} for the avatar logged in to, or which will errback if login fails. """ d = self.getRootObject() if IAnonymous.providedBy(credentials): d.addCallback(self._cbLoginAnonymous, client) else: d.addCallback( self._cbSendUsername, credentials.username, credentials.password, client ) return d class PBServerFactory(protocol.ServerFactory): """ Server factory for perspective broker. Login is done using a Portal object, whose realm is expected to return avatars implementing IPerspective. The credential checkers in the portal should accept IUsernameHashedPassword or IUsernameMD5Password. Alternatively, any object providing or adaptable to L{IPBRoot} can be used instead of a portal to provide the root object of the PB server. """ unsafeTracebacks = False # object broker factory protocol = Broker def __init__(self, root, unsafeTracebacks=False, security=globalSecurity): """ @param root: factory providing the root Referenceable used by the broker. @type root: object providing or adaptable to L{IPBRoot}. @param unsafeTracebacks: if set, tracebacks for exceptions will be sent over the wire. @type unsafeTracebacks: C{bool} @param security: security options used by the broker, default to C{globalSecurity}. @type security: L{twisted.spread.jelly.SecurityOptions} """ self.root = IPBRoot(root) self.unsafeTracebacks = unsafeTracebacks self.security = security def buildProtocol(self, addr): """ Return a Broker attached to the factory (as the service provider). """ proto = self.protocol(isClient=False, security=self.security) proto.factory = self proto.setNameForLocal("root", self.root.rootObject(proto)) return proto def clientConnectionMade(self, protocol): # XXX does this method make any sense? pass class IUsernameMD5Password(ICredentials): """ I encapsulate a username and a hashed password. This credential is used for username/password over PB. CredentialCheckers which check this kind of credential must store the passwords in plaintext form or as a MD5 digest. @type username: C{str} or C{Deferred} @ivar username: The username associated with these credentials. """ def checkPassword(password): """ Validate these credentials against the correct password. @type password: C{str} @param password: The correct, plaintext password against which to check. @rtype: C{bool} or L{Deferred} @return: C{True} if the credentials represented by this object match the given password, C{False} if they do not, or a L{Deferred} which will be called back with one of these values. """ def checkMD5Password(password): """ Validate these credentials against the correct MD5 digest of the password. @type password: C{str} @param password: The correct MD5 digest of a password against which to check. @rtype: C{bool} or L{Deferred} @return: C{True} if the credentials represented by this object match the given digest, C{False} if they do not, or a L{Deferred} which will be called back with one of these values. """ @implementer(IPBRoot) class _PortalRoot: """ Root object, used to login to portal. """ def __init__(self, portal): self.portal = portal def rootObject(self, broker): return _PortalWrapper(self.portal, broker) registerAdapter(_PortalRoot, Portal, IPBRoot) class _JellyableAvatarMixin: """ Helper class for code which deals with avatars which PB must be capable of sending to a peer. """ def _cbLogin(self, result): """ Ensure that the avatar to be returned to the client is jellyable and set up disconnection notification to call the realm's logout object. """ (interface, avatar, logout) = result if not IJellyable.providedBy(avatar): avatar = AsReferenceable(avatar, "perspective") puid = avatar.processUniqueID() # only call logout once, whether the connection is dropped (disconnect) # or a logout occurs (cleanup), and be careful to drop the reference to # it in either case logout = [logout] def maybeLogout(): if not logout: return fn = logout[0] del logout[0] fn() self.broker._localCleanup[puid] = maybeLogout self.broker.notifyOnDisconnect(maybeLogout) return avatar class _PortalWrapper(Referenceable, _JellyableAvatarMixin): """ Root Referenceable object, used to login to portal. """ def __init__(self, portal, broker): self.portal = portal self.broker = broker def remote_login(self, username): """ Start of username/password login. @param username: The username. """ c = challenge() return c, _PortalAuthChallenger(self.portal, self.broker, username, c) def remote_loginAnonymous(self, mind): """ Attempt an anonymous login. @param mind: An object to use as the mind parameter to the portal login call (possibly None). @rtype: L{Deferred} @return: A Deferred which will be called back with an avatar when login succeeds or which will be errbacked if login fails somehow. """ d = self.portal.login(Anonymous(), mind, IPerspective) d.addCallback(self._cbLogin) return d @implementer(IUsernameHashedPassword, IUsernameMD5Password) class _PortalAuthChallenger(Referenceable, _JellyableAvatarMixin): """ Called with response to password challenge. """ def __init__(self, portal, broker, username, challenge): self.portal = portal self.broker = broker self.username = username self.challenge = challenge def remote_respond(self, response, mind): self.response = response d = self.portal.login(self, mind, IPerspective) d.addCallback(self._cbLogin) return d def checkPassword(self, password): """ L{IUsernameHashedPassword} @param password: The password. @return: L{_PortalAuthChallenger.checkMD5Password} """ return self.checkMD5Password(md5(password).digest()) def checkMD5Password(self, md5Password): """ L{IUsernameMD5Password} @param md5Password: @rtype: L{bool} @return: L{True} if password matches. """ md = md5() md.update(md5Password) md.update(self.challenge) correct = md.digest() return self.response == correct __all__ = [ # Everything from flavors is exposed publicly here. "IPBRoot", "Serializable", "Referenceable", "NoSuchMethod", "Root", "ViewPoint", "Viewable", "Copyable", "Jellyable", "Cacheable", "RemoteCopy", "RemoteCache", "RemoteCacheObserver", "copyTags", "setUnjellyableForClass", "setUnjellyableFactoryForClass", "setUnjellyableForClassTree", "setCopierForClass", "setFactoryForClass", "setCopierForClassTree", "MAX_BROKER_REFS", "portno", "ProtocolError", "DeadReferenceError", "Error", "PBConnectionLost", "RemoteMethod", "IPerspective", "Avatar", "AsReferenceable", "RemoteReference", "CopyableFailure", "CopiedFailure", "failure2Copyable", "Broker", "respond", "challenge", "PBClientFactory", "PBServerFactory", "IUsernameMD5Password", ] PK Mb�Z�c�� � spread/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted Spread: Spreadable (Distributed) Computing. @author: Glyph Lefkowitz """ PK Mb�Z�jY % __pycache__/copyright.cpython-310.pycnu �[��� o �b� � @ s6 d Z g d�ZddlmZmZ ee�ZdZd� e�Z dS )z$ Copyright information for Twisted. )� copyright� disclaimer� longversion�version� )� __version__r zMCopyright (c) 2001-2022 Twisted Matrix Laboratories. See LICENSE for details.a- Twisted, the Framework of Your Internet {} Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. N) �__doc__�__all__�twistedr r � _longversion�strr r �formatr � r r �3/usr/lib/python3/dist-packages/twisted/copyright.py�<module> s ��PK Mb�Z !|/ $ __pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z ddlmZ e�� ZdS )z* Twisted: The Framework Of Your Internet. � )� __version__N)�__doc__�twisted._versionr �version�short� r r �2/usr/lib/python3/dist-packages/twisted/__init__.py�<module> s PK Mb�ZA9>�� � " __pycache__/plugin.cpython-310.pycnu �[��� o �b ! � @ s< d Z ddlZddlZddlZddlZddlmZmZmZm Z ddl m Z m Z ddl mZ ddlmZ ddlmZ ddlmZ G d d � d e �ZG d d � d �ZG d d� d�Zdd� ZzejZW n eyk d dd�ZY nw dd� Z dej fdd�Z e de d�Z d dee deej dee fd d �Z e Z!d d � Z"d d gZ#dS )!zL Plugin system for Twisted. @author: Jp Calderone @author: Glyph Lefkowitz � N)�Iterable�Optional�Type�TypeVar)� Interface� providedBy)�log)�getAdapterFactory)� getModule)�namedAnyc @ s e Zd ZdZdS )�IPluginz� Interface that must be implemented by all plugins. Only objects which implement this interface will be considered for return by C{getPlugins}. To be useful, plugins should also implement some other application-specific interface. N)�__name__� __module__� __qualname__�__doc__� r r �0/usr/lib/python3/dist-packages/twisted/plugin.pyr s r c @ s8 e Zd Zdd� Zdefdd�Zdd� Zd d d �ZeZdS ) � CachedPluginc C s* || _ || _|| _|| _| j j�| � d S �N)�dropin�name� description�provided�plugins�append)�selfr r r r r r r �__init__' s zCachedPlugin.__init__�returnc C s& d� | j| jjd�dd� | jD ���S )Nz(<CachedPlugin {!r}/{!r} (provides {!r})>z, c S s g | ]}|j �qS r )r )�.0�ir r r � <listcomp>2 s z)CachedPlugin.__repr__.<locals>.<listcomp>)�formatr r � moduleName�joinr �r r r r �__repr__. s �zCachedPlugin.__repr__c C s t | jjd | j �S )N�.)r r r" r r$ r r r �load5 s zCachedPlugin.loadNc C sH | j D ] }|�|�r| �� S t||d �d ur!|| �� |� S q|S r )r � isOrExtendsr' r )r � interface�registry�default�providedInterfacer r r � __conform__8 s �zCachedPlugin.__conform__)NN) r r r r �strr% r' r- � getComponentr r r r r & s r c @ s e Zd ZdZdd� ZdS )� CachedDropina� A collection of L{CachedPlugin} instances from a particular module in a plugin package. @type moduleName: C{str} @ivar moduleName: The fully qualified name of the plugin module this represents. @type description: C{str} or L{None} @ivar description: A brief explanation of this collection of plugins (probably the plugin module's docstring). @type plugins: C{list} @ivar plugins: The L{CachedPlugin} instances which were loaded from this dropin. c C s || _ || _g | _d S r )r" r r )r r" r r r r r V s zCachedDropin.__init__N)r r r r r r r r r r0 D s r0 c C sP t | j| j�}| j�� D ]\}}t|d �}|d ur%t|||jtt|��� q |S r ) r0 r r �__dict__�itemsr r �listr )�providerr �k�v�pluginr r r �_generateCacheEntry\ s �r8 c C s i }| D ]}|||< q|S r r )�keys�value�dr5 r r r �fromkeysj s r< c C s� i }t | j�}i }|�� D ]}|j�� }||vr g ||< || }|�|� q |�� D ]�\}}|�d�}z |�� } |� d�� } t � | �} W d � n1 sMw Y W n t y` i } d} Y nw d} i } |D ]7}|j �d�d }d| |< || vs�|j�� | kr�d} z|� � }W n t y� t�� Y qgw t|�}|| |< qgt| �� �D ] }|| vr�| |= d} q�| r�z |�t �| �� W n* ty� } ztjd |j|jd � W Y d}~nd}~w t y� t�dd � Y nw |�| � q*|S ) a; Compute all the possible loadable plugins, while loading as few as possible and hitting the filesystem as little as possible. @param module: a Python module object. This represents a package to search for plugins. @return: a dictionary mapping module names to L{CachedDropin} instances. z dropin.cache�rNr Fr& ���Tz@Unable to write to plugin cache %(path)s: error number %(errno)d)r! �path�errnoz)Unexpected error while writing cache file)r r � iterModules�filePath�parentr r2 �child�getModificationTime�open�pickler' � BaseExceptionr �splitr �errr8 r3 r9 � setContent�dumps�OSError�msgr? r@ �update)�module�allCachesCombined�mod�buckets�plugmod�fpp�bucket�pseudoPackagePath� dropinPath� lastCached�f�dropinDotCache� needsWrite� existingKeys� pluginModule� pluginKeyr4 �entry�er r r �getCacheq sr �� � ����� � rb r c C s dd l m} | S )Nr )�twisted.pluginsr ��packager r r �_pluginsPackage� s rf � _TInterface)�boundr) re c c sr � |du rt � }t|�}|�� D ]&\}}|jD ] }z| |d�}W n ty- t�� Y qw |dur5|V qqdS )ac Retrieve all plugins implementing the given interface beneath the given module. @param interface: An interface class. Only plugins which implement this interface will be returned. @param package: A package beneath which plugins are installed. For most uses, the default value is correct. @return: An iterator of plugins. N)rf rb r2 r rH r rJ )r) re � allDropins�keyr r7 �adaptedr r r � getPlugins� s � ����rl c s | � d�� � fdd�tjD �S )a� Return a list of additional directories which should be searched for modules to be included as part of the named plugin package. @type name: C{str} @param name: The fully-qualified Python name of a plugin package, eg C{'twisted.plugins'}. @rtype: C{list} of C{str} @return: The absolute paths to other directories which may contain plugin modules for the named plugin package. r& c sJ g | ]!}t j�t jj|g� d g �R � �st j�t jj|g� �R � ��qS )z __init__.py)�osr? �existsr# �abspath)r �xrd r r r � s ��z&pluginPackagePaths.<locals>.<listcomp>)rI �sysr? )r r rd r �pluginPackagePaths� s �rr r )$r rm rG rq �types�typingr r r r �zope.interfacer r �twisted.pythonr �twisted.python.componentsr �twisted.python.modulesr �twisted.python.reflectr r r r0 r8 �dictr< �AttributeErrorrb � ModuleTyperf rg rl � getPlugInsrr �__all__r r r r �<module> sD � L ��� � PK Mb�ZJ���5 5 $ __pycache__/__main__.cpython-310.pycnu �[��� o �b� � @ s8 d dl Z d dlmZ edkre �eddd�� � dS dS )� N)�load_entry_point�__main__�Twisted�console_scripts�twist)�sys� pkg_resourcesr �__name__�exit� r r �2/usr/lib/python3/dist-packages/twisted/__main__.py�<module> s �PK Mb�Z�Y\�8 8 $ __pycache__/_version.cpython-310.pycnu �[��� o �b � @ s( d Z ddlmZ edddd�ZdgZdS )z' Provides Twisted version information. � )�Version�Twisted� � � __version__N)�__doc__� incrementalr r �__all__� r r �2/usr/lib/python3/dist-packages/twisted/_version.py�<module> s PK Mb�Z՟��R �R scripts/trial.pynu �[��� # -*- test-case-name: twisted.trial.test.test_script -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import gc import inspect import os import pdb import random import sys import time import warnings from twisted import plugin from twisted.application import app from twisted.internet import defer from twisted.python import failure, reflect, usage from twisted.python.filepath import FilePath from twisted.python.reflect import namedModule from twisted.trial import itrial, reporter, runner # Yea, this is stupid. Leave it for command-line compatibility for a # while, though. TBFORMAT_MAP = { "plain": "default", "default": "default", "emacs": "brief", "brief": "brief", "cgitb": "verbose", "verbose": "verbose", } def _parseLocalVariables(line): """ Accepts a single line in Emacs local variable declaration format and returns a dict of all the variables {name: value}. Raises ValueError if 'line' is in the wrong format. See http://www.gnu.org/software/emacs/manual/html_node/File-Variables.html """ paren = "-*-" start = line.find(paren) + len(paren) end = line.rfind(paren) if start == -1 or end == -1: raise ValueError(f"{line!r} not a valid local variable declaration") items = line[start:end].split(";") localVars = {} for item in items: if len(item.strip()) == 0: continue split = item.split(":") if len(split) != 2: raise ValueError(f"{line!r} contains invalid declaration {item!r}") localVars[split[0].strip()] = split[1].strip() return localVars def loadLocalVariables(filename): """ Accepts a filename and attempts to load the Emacs variable declarations from that file, simulating what Emacs does. See http://www.gnu.org/software/emacs/manual/html_node/File-Variables.html """ with open(filename) as f: lines = [f.readline(), f.readline()] for line in lines: try: return _parseLocalVariables(line) except ValueError: pass return {} def getTestModules(filename): testCaseVar = loadLocalVariables(filename).get("test-case-name", None) if testCaseVar is None: return [] return testCaseVar.split(",") def isTestFile(filename): """ Returns true if 'filename' looks like a file containing unit tests. False otherwise. Doesn't care whether filename exists. """ basename = os.path.basename(filename) return basename.startswith("test_") and os.path.splitext(basename)[1] == (".py") def _reporterAction(): return usage.CompleteList([p.longOpt for p in plugin.getPlugins(itrial.IReporter)]) def _maybeFindSourceLine(testThing): """ Try to find the source line of the given test thing. @param testThing: the test item to attempt to inspect @type testThing: an L{TestCase}, test method, or module, though only the former two have a chance to succeed @rtype: int @return: the starting source line, or -1 if one couldn't be found """ # an instance of L{TestCase} -- locate the test it will run method = getattr(testThing, "_testMethodName", None) if method is not None: testThing = getattr(testThing, method) # If it's a function, we can get the line number even if the source file no # longer exists code = getattr(testThing, "__code__", None) if code is not None: return code.co_firstlineno try: return inspect.getsourcelines(testThing)[1] except (OSError, TypeError): # either testThing is a module, which raised a TypeError, or the file # couldn't be read return -1 # orders which can be passed to trial --order _runOrders = { "alphabetical": ( "alphabetical order for test methods, arbitrary order for test cases", runner.name, ), "toptobottom": ( "attempt to run test cases and methods in the order they were defined", _maybeFindSourceLine, ), } def _checkKnownRunOrder(order): """ Check that the given order is a known test running order. Does nothing else, since looking up the appropriate callable to sort the tests should be done when it actually will be used, as the default argument will not be coerced by this function. @param order: one of the known orders in C{_runOrders} @return: the order unmodified """ if order not in _runOrders: raise usage.UsageError( "--order must be one of: %s. See --help-orders for details" % (", ".join(repr(order) for order in _runOrders),) ) return order class _BasicOptions: """ Basic options shared between trial and its local workers. """ longdesc = ( "trial loads and executes a suite of unit tests, obtained " "from modules, packages and files listed on the command line." ) optFlags = [ ["help", "h"], ["no-recurse", "N", "Don't recurse into packages"], ["help-orders", None, "Help on available test running orders"], ["help-reporters", None, "Help on available output plugins (reporters)"], [ "rterrors", "e", "realtime errors, print out tracebacks as " "soon as they occur", ], ["unclean-warnings", None, "Turn dirty reactor errors into warnings"], [ "force-gc", None, "Have Trial run gc.collect() before and " "after each test case.", ], [ "exitfirst", "x", "Exit after the first non-successful result (cannot be " "specified along with --jobs).", ], ] optParameters = [ [ "order", "o", None, "Specify what order to run test cases and methods. " "See --help-orders for more info.", _checkKnownRunOrder, ], ["random", "z", None, "Run tests in random order using the specified seed"], [ "temp-directory", None, "_trial_temp", "Path to use as working directory for tests.", ], [ "reporter", None, "verbose", "The reporter to use for this test run. See --help-reporters for " "more info.", ], ] compData = usage.Completions( optActions={ "order": usage.CompleteList(_runOrders), "reporter": _reporterAction, "logfile": usage.CompleteFiles(descr="log file name"), "random": usage.Completer(descr="random seed"), }, extraActions=[ usage.CompleteFiles( "*.py", descr="file | module | package | TestCase | testMethod", repeat=True, ) ], ) fallbackReporter = reporter.TreeReporter tracer = None def __init__(self): self["tests"] = [] usage.Options.__init__(self) def getSynopsis(self): executableName = reflect.filenameToModuleName(sys.argv[0]) if executableName.endswith(".__main__"): executableName = "{} -m {}".format( os.path.basename(sys.executable), executableName.replace(".__main__", ""), ) return """{} [options] [[file|package|module|TestCase|testmethod]...] """.format( executableName, ) def coverdir(self): """ Return a L{FilePath} representing the directory into which coverage results should be written. """ coverdir = "coverage" result = FilePath(self["temp-directory"]).child(coverdir) print(f"Setting coverage directory to {result.path}.") return result # TODO: Some of the opt_* methods on this class have docstrings and some do # not. This is mostly because usage.Options's currently will replace # any intended output in optFlags and optParameters with the # docstring. See #6427. When that is fixed, all methods should be # given docstrings (and it should be verified that those with # docstrings already have content suitable for printing as usage # information). def opt_coverage(self): """ Generate coverage information in the coverage file in the directory specified by the temp-directory option. """ import trace self.tracer = trace.Trace(count=1, trace=0) sys.settrace(self.tracer.globaltrace) self["coverage"] = True def opt_testmodule(self, filename): """ Filename to grep for test cases (-*- test-case-name). """ # If the filename passed to this parameter looks like a test module # we just add that to the test suite. # # If not, we inspect it for an Emacs buffer local variable called # 'test-case-name'. If that variable is declared, we try to add its # value to the test suite as a module. # # This parameter allows automated processes (like Buildbot) to pass # a list of files to Trial with the general expectation of "these files, # whatever they are, will get tested" if not os.path.isfile(filename): sys.stderr.write(f"File {filename!r} doesn't exist\n") return filename = os.path.abspath(filename) if isTestFile(filename): self["tests"].append(filename) else: self["tests"].extend(getTestModules(filename)) def opt_spew(self): """ Print an insanely verbose log of everything that happens. Useful when debugging freezes or locks in complex code. """ from twisted.python.util import spewer sys.settrace(spewer) def opt_help_orders(self): synopsis = ( "Trial can attempt to run test cases and their methods in " "a few different orders. You can select any of the " "following options using --order=<foo>.\n" ) print(synopsis) for name, (description, _) in sorted(_runOrders.items()): print(" ", name, "\t", description) sys.exit(0) def opt_help_reporters(self): synopsis = ( "Trial's output can be customized using plugins called " "Reporters. You can\nselect any of the following " "reporters using --reporter=<foo>\n" ) print(synopsis) for p in plugin.getPlugins(itrial.IReporter): print(" ", p.longOpt, "\t", p.description) sys.exit(0) def opt_disablegc(self): """ Disable the garbage collector """ self["disablegc"] = True gc.disable() def opt_tbformat(self, opt): """ Specify the format to display tracebacks with. Valid formats are 'plain', 'emacs', and 'cgitb' which uses the nicely verbose stdlib cgitb.text function """ try: self["tbformat"] = TBFORMAT_MAP[opt] except KeyError: raise usage.UsageError("tbformat must be 'plain', 'emacs', or 'cgitb'.") def opt_recursionlimit(self, arg): """ see sys.setrecursionlimit() """ try: sys.setrecursionlimit(int(arg)) except (TypeError, ValueError): raise usage.UsageError("argument to recursionlimit must be an integer") else: self["recursionlimit"] = int(arg) def opt_random(self, option): try: self["random"] = int(option) except ValueError: raise usage.UsageError("Argument to --random must be a positive integer") else: if self["random"] < 0: raise usage.UsageError( "Argument to --random must be a positive integer" ) elif self["random"] == 0: self["random"] = int(time.time() * 100) def opt_without_module(self, option): """ Fake the lack of the specified modules, separated with commas. """ self["without-module"] = option for module in option.split(","): if module in sys.modules: warnings.warn( "Module '%s' already imported, " "disabling anyway." % (module,), category=RuntimeWarning, ) sys.modules[module] = None def parseArgs(self, *args): self["tests"].extend(args) def _loadReporterByName(self, name): for p in plugin.getPlugins(itrial.IReporter): qual = f"{p.module}.{p.klass}" if p.longOpt == name: return reflect.namedAny(qual) raise usage.UsageError( "Only pass names of Reporter plugins to " "--reporter. See --help-reporters for " "more info." ) def postOptions(self): # Only load reporters now, as opposed to any earlier, to avoid letting # application-defined plugins muck up reactor selecting by importing # t.i.reactor and causing the default to be installed. self["reporter"] = self._loadReporterByName(self["reporter"]) if "tbformat" not in self: self["tbformat"] = "default" if self["order"] is not None and self["random"] is not None: raise usage.UsageError("You can't specify --random when using --order") class Options(_BasicOptions, usage.Options, app.ReactorSelectionMixin): """ Options to the trial command line tool. @ivar _workerFlags: List of flags which are accepted by trial distributed workers. This is used by C{_getWorkerArguments} to build the command line arguments. @type _workerFlags: C{list} @ivar _workerParameters: List of parameter which are accepted by trial distributed workers. This is used by C{_getWorkerArguments} to build the command line arguments. @type _workerParameters: C{list} """ optFlags = [ [ "debug", "b", "Run tests in a debugger. If that debugger is " "pdb, will load '.pdbrc' from current directory if it exists.", ], [ "debug-stacktraces", "B", "Report Deferred creation and " "callback stack traces", ], [ "nopm", None, "don't automatically jump into debugger for " "postmorteming of exceptions", ], ["dry-run", "n", "do everything but run the tests"], ["profile", None, "Run tests under the Python profiler"], ["until-failure", "u", "Repeat test until it fails"], ] optParameters = [ [ "debugger", None, "pdb", "the fully qualified name of a debugger to " "use if --debug is passed", ], ["logfile", "l", "test.log", "log file name"], ["jobs", "j", None, "Number of local workers to run"], ] compData = usage.Completions( optActions={ "tbformat": usage.CompleteList(["plain", "emacs", "cgitb"]), "reporter": _reporterAction, }, ) _workerFlags = ["disablegc", "force-gc", "coverage"] _workerParameters = ["recursionlimit", "reactor", "without-module"] fallbackReporter = reporter.TreeReporter extra = None tracer = None def opt_jobs(self, number): """ Number of local workers to run, a strictly positive integer. """ try: number = int(number) except ValueError: raise usage.UsageError( "Expecting integer argument to jobs, got '%s'" % number ) if number <= 0: raise usage.UsageError( "Argument to jobs must be a strictly positive integer" ) self["jobs"] = number def _getWorkerArguments(self): """ Return a list of options to pass to distributed workers. """ args = [] for option in self._workerFlags: if self.get(option) is not None: if self[option]: args.append(f"--{option}") for option in self._workerParameters: if self.get(option) is not None: args.extend([f"--{option}", str(self[option])]) return args def postOptions(self): _BasicOptions.postOptions(self) if self["jobs"]: conflicts = ["debug", "profile", "debug-stacktraces", "exitfirst"] for option in conflicts: if self[option]: raise usage.UsageError( "You can't specify --%s when using --jobs" % option ) if self["nopm"]: if not self["debug"]: raise usage.UsageError("You must specify --debug when using " "--nopm ") failure.DO_POST_MORTEM = False def _initialDebugSetup(config): # do this part of debug setup first for easy debugging of import failures if config["debug"]: failure.startDebugMode() if config["debug"] or config["debug-stacktraces"]: defer.setDebugging(True) def _getSuite(config): loader = _getLoader(config) recurse = not config["no-recurse"] return loader.loadByNames(config["tests"], recurse=recurse) def _getLoader(config): loader = runner.TestLoader() if config["random"]: randomer = random.Random() randomer.seed(config["random"]) loader.sorter = lambda x: randomer.random() print("Running tests shuffled with seed %d\n" % config["random"]) elif config["order"]: _, sorter = _runOrders[config["order"]] loader.sorter = sorter if not config["until-failure"]: loader.suiteFactory = runner.DestructiveTestSuite return loader def _wrappedPdb(): """ Wrap an instance of C{pdb.Pdb} with readline support and load any .rcs. """ dbg = pdb.Pdb() try: namedModule("readline") except ImportError: print("readline module not available") for path in (".pdbrc", "pdbrc"): if os.path.exists(path): try: rcFile = open(path) except OSError: pass else: with rcFile: dbg.rcLines.extend(rcFile.readlines()) return dbg class _DebuggerNotFound(Exception): """ A debugger import failed. Used to allow translating these errors into usage error messages. """ def _makeRunner(config): """ Return a trial runner class set up with the parameters extracted from C{config}. @return: A trial runner instance. @rtype: L{runner.TrialRunner} or C{DistTrialRunner} depending on the configuration. """ cls = runner.TrialRunner args = { "reporterFactory": config["reporter"], "tracebackFormat": config["tbformat"], "realTimeErrors": config["rterrors"], "uncleanWarnings": config["unclean-warnings"], "logfile": config["logfile"], "workingDirectory": config["temp-directory"], } if config["dry-run"]: args["mode"] = runner.TrialRunner.DRY_RUN elif config["jobs"]: from twisted.trial._dist.disttrial import DistTrialRunner cls = DistTrialRunner args["workerNumber"] = config["jobs"] args["workerArguments"] = config._getWorkerArguments() else: if config["debug"]: args["mode"] = runner.TrialRunner.DEBUG debugger = config["debugger"] if debugger != "pdb": try: args["debugger"] = reflect.namedAny(debugger) except reflect.ModuleNotFound: raise _DebuggerNotFound( f"{debugger!r} debugger could not be found." ) else: args["debugger"] = _wrappedPdb() args["exitFirst"] = config["exitfirst"] args["profile"] = config["profile"] args["forceGarbageCollection"] = config["force-gc"] return cls(**args) def run(): if len(sys.argv) == 1: sys.argv.append("--help") config = Options() try: config.parseOptions() except usage.error as ue: raise SystemExit(f"{sys.argv[0]}: {ue}") _initialDebugSetup(config) try: trialRunner = _makeRunner(config) except _DebuggerNotFound as e: raise SystemExit(f"{sys.argv[0]}: {str(e)}") suite = _getSuite(config) if config["until-failure"]: test_result = trialRunner.runUntilFailure(suite) else: test_result = trialRunner.run(suite) if config.tracer: sys.settrace(None) results = config.tracer.results() results.write_results( show_missing=1, summary=False, coverdir=config.coverdir().path ) sys.exit(not test_result.wasSuccessful()) PK Mb�ZO� zX X , scripts/__pycache__/__init__.cpython-310.pycnu �[��� o �b � @ s d Z dS )z� Subpackage containing the modules that implement the command line tools. Note that these are imported by top-level scripts which are intended to be invoked directly from a shell. N)�__doc__� r r �:/usr/lib/python3/dist-packages/twisted/scripts/__init__.py�<module> s PK Mb�Zf�q� � * scripts/__pycache__/twistd.cpython-310.pycnu �[��� o �bg � @ sb d Z ddlmZ ddlmZ edkrddlmZmZ nddl mZm Z dd� Z d d � Z d dgZ d S ) zU The Twisted Daemon: platform-independent interface. @author: Christopher Armstrong � )�app)� platformType�win32)� ServerOptions�WindowsApplicationRunner)r �UnixApplicationRunnerc C s. t | �}|�� |jd urt�|j� d S d S �N)�_SomeApplicationRunner�run� _exitSignalr �_exitWithSignal)�config�runner� r �8/usr/lib/python3/dist-packages/twisted/scripts/twistd.py�runApp s �r c C s t �tt� d S r )r r r r r r r r r " s r N)�__doc__�twisted.applicationr �twisted.python.runtimer �twisted.scripts._twistwr r r � twisted.scripts._twistd_unixr r r �__all__r r r r �<module> s PK Mb�ZX�qy y + scripts/__pycache__/_twistw.cpython-310.pycnu �[��� o �b � @ sd d dl Z d dlZd dlmZ d dlmZmZmZ d dlm Z G dd� dej �Z G dd� dej �Z dS ) � N)� copyright)�app�internet�service)�logc @ s" e Zd ZdZg d�gZdd� ZdS )� ServerOptionszUsage: twistd [options])�nodaemon�nz (for backwards compatibility).c C s2 t dtj� �| jd� t tj| jd� t�� dS )z5 Print version information and exit. z$twistd (the Twisted Windows runner) )�fileN)�printr �version�stdout�sys�exit��self� r �9/usr/lib/python3/dist-packages/twisted/scripts/_twistw.py� opt_version s � zServerOptions.opt_versionN)�__name__� __module__� __qualname__�synopsis�optFlagsr r r r r r s � r c @ s e Zd ZdZdd� Zdd� ZdS )�WindowsApplicationRunnerzn An ApplicationRunner which avoids unix-specific things. No forking, no PID files, no privileges. c C s$ t j| _t j| _t�| jd � dS )z4 Do pre-application-creation setup. �rundirN)r r � oldstdout�stderr� oldstderr�os�chdir�configr r r r �preApplication' s z'WindowsApplicationRunner.preApplicationc C s^ t �| j��� t�| j| jd � t�t�ddd� �d� | � d| j | j � t � d� dS )z< Start the application and run the reactor. �no_saveg�������?c S s d S )Nr r r r r �<lambda>5 s z:WindowsApplicationRunner.postApplication.<locals>.<lambda>r NzServer Shut Down.)r �IService� application�privilegedStartServicer �startApplicationr! r � TimerService� startReactorr r r �msgr r r r �postApplication/ s z(WindowsApplicationRunner.postApplicationN)r r r �__doc__r" r, r r r r r ! s r ) r r �twistedr �twisted.applicationr r r �twisted.pythonr r �ApplicationRunnerr r r r r �<module> s PK Mb�Z�b�* , scripts/__pycache__/htmlizer.cpython-310.pycnu �[��� o �b" � @ sj d Z ddd� ZddlZddlZddlmZ ddlmZmZ dZ d Z d Z d Z G d d � d ej �Z dd� ZdS )z. HTML pretty-printing for Python source code. z$Revision: 1.8 $� ���� N)� copyright)�htmlizer�usagez�<html><head> <title>%(title)s</title> <meta name="Generator" content="%(generator)s" /> %(alternate)s %(stylesheet)s </head> <body> z</body>z3<link rel="stylesheet" href="%s" type="text/css" />z?<link rel="alternate" href="%(source)s" type="text/x-python" />c @ sJ e Zd Zd�ej�ejd ��Z dgZ e j e j ddd�gd�Zdd � Zd S ) �Optionsz{} [options] source.py r )� stylesheet�sNz URL of stylesheet to link to.z*.pyzsource python file)�descr)� extraActionsc C s || d< d S )N�filename� )�selfr r r �:/usr/lib/python3/dist-packages/twisted/scripts/htmlizer.py� parseArgs/ s zOptions.parseArgsN)�__name__� __module__� __qualname__�format�os�path�basename�sys�argv�synopsis� optParametersr � Completions� CompleteFiles�compDatar r r r r r ! s ���� r c C s* t � } z| �� W n tjy' } ztt|�� t�d� W Y d }~nd }~ww | d }| �d�d ur;t | d f }nd}t |d d��G}t |dt j � �td|i |d � }|�|�d �� t |d ��}t�||tj� W d � n1 svw Y |�t�d �� W d � d S 1 s�w Y d S ) N� r r � z.html�wbz htmlizer/�source)�title� generator� alternater zutf-8�rb)r � parseOptionsr � UsageError�print�strr �exit�get� styleLink�open�headerr � longversion� alternateLink�write�encoder �filter�SmallerHTMLWriter�footer)�options�er r �output� outHeader�fr r r �run3 s2 �� � �"�r< )�__doc__� __version__r r �twistedr �twisted.pythonr r r/ r6 r- r1 r r< r r r r �<module> s PK Mb�Zj��6 �6 0 scripts/__pycache__/_twistd_unix.cpython-310.pycnu �[��� o �b�> � @ s� d dl Z d dlZd dlZd dlZd dlZd dlmZmZ d dlm Z m Z d dl m Z d dl mZmZmZ d dlmZ d dlmZmZmZmZ edkrNed ��d d � ZG d d � d e j�Zdd� ZG dd� de j �Z dd� Z G dd� de j �Z dS )� N)� copyright�logger)�app�service)�IReactorDaemonize)�log�logfile�usage)� platformType)� gidFromString� switchUID� uidFromString�untilConcludes�win32z%_twistd_unix doesn't work on Windows.c C s t | d�S )N� )�int)�value� r �>/usr/lib/python3/dist-packages/twisted/scripts/_twistd_unix.py�_umask s r c @ s� e Zd ZdZg d�g d�g d�g d�gZg d�g d�g d�d d d d egd dd degdd d deggZe j e � d�e j dd�e j dd�e jdd�e jdd�d�d�Zdd� Zd d � Zd S ) � ServerOptionszUsage: twistd [options])�nodaemon�nz0don't daemonize, don't use default umask of 0077)� originalnameNz$Don't try to change the process name)�syslogNzLog to syslog, not to file)�euid� a Set only effective user-id rather than real user-id. (This option has no effect unless the server is running as root, in which case it means not to shed all privileges after binding ports, retaining the option to regain privileges in cases such as spawning processes. Use with caution.))�prefixN�twistedz$use the given prefix when syslogging)�pidfiler z twistd.pidzName of the pidfile)�chrootNNz-Chroot to a supplied directory before running�uid�uNzThe uid to run as.�gid�gzbThe gid to run as. If not specified, the default gid associated with the specified --uid is used.�umaskz(The (octal) file creation mask to apply.z*.pidzchroot directory)�descrz gid to run asz uid to run asz syslog prefix)r r r# r! r )� optActionsc C s2 t dtj� �| jd� t tj| jd� t�� dS )z5 Print version information and exit. z twistd (the Twisted daemon) )�fileN)�printr �version�stdout�sys�exit��selfr r r � opt_versionH s zServerOptions.opt_versionc C s0 t j�| � | d rtj�| d �| d< d S d S )Nr )r r � postOptions�os�path�abspathr. r r r r1 P s �zServerOptions.postOptions)�__name__� __module__� __qualname__�synopsis�optFlagsr r r � optParametersr � Completions� CompleteFiles� CompleteDirs�CompleteGroups�CompleteUsernames� Completer�compDatar0 r1 r r r r r s: � � � �� r c C s | sd S t j�| �r�z t| ��}t|�� �}W d � n1 s w Y W n ty8 t�d| � d�� Y nw zt � |d� W n: t y{ } z.|j t j kr_t jd| � �dd� t �| � nt�d�|| |�� W Y d }~d S W Y d }~d S d }~ww t�d�|�� d S d S ) NzPidfile z contains non-numeric valuer zRemoving stale pidfile T)�isErrorz0Can't check status of PID {} from pidfile {}: {}a Another twistd server is running, PID {} This could either be a previously started instance of your application or a different application entirely. To start a new one, either run it in some other directory, or use the --pidfile and --logfile parameters to avoid clashes. )r2 r3 �exists�openr �read� ValueErrorr, r- �kill�OSError�errno�ESRCHr �msg�remove�format)r �f�pid�whyr r r �checkPIDV s@ �� � ����� ���rQ c @ s e Zd ZdZdd� Zdd� ZdS )� UnixAppLoggera� A logger able to log to syslog, to files, and to stdout. @ivar _syslog: A flag indicating whether to use syslog instead of file logging. @type _syslog: C{bool} @ivar _syslogPrefix: If C{sysLog} is C{True}, the string prefix to use for syslog messages. @type _syslogPrefix: C{str} @ivar _nodaemon: A flag indicating the process will not be daemonizing. @type _nodaemon: C{bool} c C s< t j�| |� |�dd�| _|�dd�| _|�dd�| _d S )Nr Fr r r )r � AppLogger�__init__�get�_syslog� _syslogPrefix� _nodaemon)r/ �optionsr r r rT � s zUnixAppLogger.__init__c s� | j rddlm} |�| j�jS | jdkr!| js t� d� tj � n:| jr+| js+tj � n0| js1d| _t j � | j�� zddl}W n tyG Y nw |�|j�s[� fdd�}|�|j|� t�� �S ) a� Create and return a suitable log observer for the given configuration. The observer will go to syslog using the prefix C{_syslogPrefix} if C{_syslog} is true. Otherwise, it will go to the file named C{_logfilename} or, if C{_nodaemon} is true and C{_logfilename} is C{"-"}, to stdout. @return: An object suitable to be passed to C{log.addObserver}. r )r �-z&Daemons cannot log to stdout, exiting!z twistd.logNc s ddl m} |�� j� d S )Nr ��reactor)�twisted.internetr\ �callFromThread�rotate)�signal�framer\ ��logFiler r � rotateLog� s z0UnixAppLogger._getLogObserver.<locals>.rotateLog)rV �twisted.pythonr �SyslogObserverrW �emit� _logfilenamerX r, r- r+ r �LogFile� fromFullPathr` � ImportError� getsignal�SIGUSR1r �textFileLogObserver)r/ r r` rd r rb r �_getLogObserver� s* � z UnixAppLogger._getLogObserverN)r5 r6 r7 �__doc__rT ro r r r r rR y s rR c C s` | r,| t jd kr.tj�t j�}t�d| � t�|| t jd dgt jdd � � d S d S d S )Nr zChanging process name to z--originalname� ) r, �argvr2 r3 �realpath� executabler rK �execv)�name�exer r r �launchWithName� s *�rx c @ sf e Zd ZdZeZdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z de de fdd�Z dd� Zdd� ZdS )�UnixApplicationRunnerzx An ApplicationRunner which does Unix-specific things, like fork, shed privileges, and maintain a PID file. c C s< t | jd � | jd p| jd | jd< tj| _tj| _dS )z4 Do pre-application-creation setup. r r �debugN)rQ �configr, r+ � oldstdout�stderr� oldstderrr. r r r �preApplication� s z$UnixApplicationRunner.preApplicationc C s8 t �|j|�d }d|�� � �}|�dd�}|dd� S )aC Format the C{exception} in preparation for writing to the status pipe. This does the right thing on Python 2 if the exception's message is Unicode, and in all cases limits the length of the message afte* encoding to 100 bytes. This means the returned message may be truncated in the middle of a unicode escape. @type exception: L{Exception} @param exception: The exception to format. @return: The formatted message, suitable for writing to the status pipe. @rtype: L{bytes} ���z1 �ascii�backslashreplaceN�d )� traceback�format_exception_only� __class__�strip�encode)r/ � exception� exceptionLine�formattedMessager r r �_formatChildException� s � z+UnixApplicationRunner._formatChildExceptionc C s� z| � | j� W n2 ty: } z&| j�dd�}|dur-| �|�}ttj||� ttj |� | � | jd � � d}~ww | j�dd�}|durSttj|d� ttj |� | � d| j | j � | � | jd � dS )z� To be called after the application is created: start the application and run the reactor. After the reactor stops, clean up PID files and such. � statusPipeNr � 0)�startApplication� application� Exceptionr{ rU r� r r2 �write�close� removePID� startReactorr| r~ )r/ �exr� �messager r r �postApplication� s$ �� z%UnixApplicationRunner.postApplicationc C s� |sdS zt �|� W dS ty> } z&|jtjks |jtjkr&t�d� n t�|d� W Y d}~dS W Y d}~dS d}~w t yM t�dd� Y dS w )z� Remove the specified PID file, if possible. Errors are logged, not raised. @type pidfile: C{str} @param pidfile: The path to the PID tracking file. Nz)Warning: No permission to delete pid filezFailed to unlink PID file:) r2 �unlinkrH rI �EACCES�EPERMr rK �err� BaseException)r/ r �er r r r� s �� �z UnixApplicationRunner.removePIDc C s� | }|durt �|� |dkrd}t �|� |r |du r d}|dur(t �|� |r8ddlm} | �|�| jd< |r\t|d��}|� d t � � f � W d � dS 1 sUw Y dS dS ) a� Set the filesystem root, the working directory, and daemonize. @type chroot: C{str} or L{None} @param chroot: If not None, a path to use as the filesystem root (using L{os.chroot}). @type rundir: C{str} @param rundir: The path to set as the working directory. @type nodaemon: C{bool} @param nodaemon: A flag which, if set, indicates that daemonization should not be done. @type umask: C{int} or L{None} @param umask: The value to which to change the process umask. @type pidfile: C{str} or L{None} @param pidfile: If not L{None}, the path to a file into which to put the PID of this process. N�.�/�? r r[ r� �wbs %d) r2 r �chdirr% r] r\ � daemonizer{ rD r� �getpid) r/ r �rundirr r% r �daemonr\ rN r r r �setupEnvironment# s$ "��z&UnixApplicationRunner.setupEnvironmentc C s� t �|�r |�� t�� \}}t�� r"| �|�}t�|� t�|� t� � t�� r/t�d� t� dtj �}t d�D ]#}zt� ||� W q: ty] } z |jtjkrS� W Y d}~q:d}~ww t�|� t �|�rl|�� |S )a7 Daemonizes the application on Unix. This is done by the usual double forking approach. @see: U{http://code.activestate.com/recipes/278731/} @see: W. Richard Stevens, "Advanced Programming in the Unix Environment", 1992, Addison-Wesley, ISBN 0-201-56317-7 @param reactor: The reactor in use. If it provides L{IReactorDaemonize}, its daemonization-related callbacks will be invoked. @return: A writable pipe to be used to report errors. @rtype: C{int} r z /dev/null� N)r � providedBy�beforeDaemonizer2 �pipe�fork� _waitForStartr� �_exit�setsidrD �O_RDWR�range�dup2rH rI �EBADF�afterDaemonize)r/ r\ �r�w�code�null�ir� r r r r� L s0 ��� z UnixApplicationRunner.daemonize�readPipe�returnc C sF t tj|d�}t|dd� �}|dkr!d�|�}t tjj|� dS dS )a Wait for the daemonization success. @param readPipe: file descriptor to read start information from. @type readPipe: C{int} @return: code to be passed to C{os._exit}: 0 for success, 1 for error. @rtype: C{int} r� � Nr� zHAn error has occurred: {} Please look at log file for more information. rq r )r r2 rE �reprrM r, � __stderr__r� )r/ r� �data�dataReprrK r r r r� x s �z#UnixApplicationRunner._waitForStartc C s� |dus|durO|r dp d}|� d|� d|� d|� �}zt |||� W n! tyD } zt�d�||�� t�d� W Y d}~dS d}~ww t�d |� �� dS dS ) a� Change the UID and GID or the EUID and EGID of this process. @type euid: C{bool} @param euid: A flag which, if set, indicates that only the I{effective} UID and GID should be set. @type uid: C{int} or L{None} @param uid: If not L{None}, the UID to which to switch. @type gid: C{int} or L{None} @param gid: If not L{None}, the GID to which to switch. Nr� r zuid/zgid r� z0failed to set {}: {} (are you root?) -- exiting.rq zset )r rH r rK rM r, r- )r/ r r! r# �extra�descr� r r r �shedPrivileges� s ����z$UnixApplicationRunner.shedPrivilegesc C s� t �|�}| jd st|j� | �| jd | jd | jd | jd | jd � t �|��� | jd | jd }}|d u r@|j}|d u rG|j }|d urU|d u rUt � |�j }| � | jd ||� t�|| jd � d S ) z� Configure global process state based on the given application and run the application. @param application: An object which can be adapted to L{service.IProcess} and L{service.IService}. r r r� r r% r r! r# Nr �no_save)r �IProcessr{ rx � processNamer� �IService�privilegedStartServicer! r# �pwd�getpwuid�pw_gidr� r r� )r/ r� �processr! r# r r r r� � s( � z&UnixApplicationRunner.startApplicationN)r5 r6 r7 rp rR � loggerFactoryr r� r� r� r� r� r r� r� r� r r r r ry � s %), ry )!rI r2 r� r, r� r r r �twisted.applicationr r �twisted.internet.interfacesr re r r r �twisted.python.runtimer �twisted.python.utilr r r r rk r r rQ rS rR rx �ApplicationRunnerry r r r r �<module> s& ;#APK Mb�Z���T�G �G ) scripts/__pycache__/trial.cpython-310.pycnu �[��� o �b�R � @ sl d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlm Z d dl m Z d dl m Z d dlmZmZmZ d dlmZ d dlmZ d dlmZmZmZ d d d d d d d �Zd d� Zdd� Z dd� Z dd� Z dd� Z dd� Z dej!fde fd�Z"d d � Z#G d d � d �Z$G d d!� d!e$ej%e j&�Z%d"d#� Z'd$d%� Z(d&d'� Z)d(d)� Z*G d*d+� d+e+�Z,d,d-� Z-d.d/� Z.dS )0� N)�plugin)�app)�defer)�failure�reflect�usage)�FilePath)� namedModule)�itrial�reporter�runner�default�brief�verbose)�plainr �emacsr �cgitbr c C s� d}| � |�t|� }| �|�}|dks|dkr t| �d���| ||� �d�}i }|D ]+}t|�� �dkr7q,|�d�}t|�dkrKt| �d|����|d �� ||d �� < q,|S ) a Accepts a single line in Emacs local variable declaration format and returns a dict of all the variables {name: value}. Raises ValueError if 'line' is in the wrong format. See http://www.gnu.org/software/emacs/manual/html_node/File-Variables.html z-*-���z' not a valid local variable declaration�;r �:� z contains invalid declaration � )�find�len�rfind� ValueError�split�strip)�line�paren�start�end�items� localVars�itemr � r% �7/usr/lib/python3/dist-packages/twisted/scripts/trial.py�_parseLocalVariables# s r' c C sf t | ��}|�� |�� g}W d � n1 sw Y |D ]}zt|�W S ty0 Y q w i S )z� Accepts a filename and attempts to load the Emacs variable declarations from that file, simulating what Emacs does. See http://www.gnu.org/software/emacs/manual/html_node/File-Variables.html N)�open�readliner' r )�filename�f�linesr r% r% r& �loadLocalVariables< s � �r- c C s& t | ��dd �}|d u rg S |�d�S )Nztest-case-name�,)r- �getr )r* � testCaseVarr% r% r& �getTestModulesM s r1 c C s* t j�| �}|�d�ot j�|�d dkS )z� Returns true if 'filename' looks like a file containing unit tests. False otherwise. Doesn't care whether filename exists. �test_r z.py)�os�path�basename� startswith�splitext)r* r5 r% r% r& � isTestFileT s r8 c C s t �dd� t�tj�D ��S )Nc S s g | ]}|j �qS r% )�longOpt)�.0�pr% r% r& � <listcomp>^ s z#_reporterAction.<locals>.<listcomp>)r � CompleteListr � getPluginsr � IReporterr% r% r% r& �_reporterAction] s r@ c C sb t | dd�}|durt | |�} t | dd�}|dur |jS zt�| �d W S ttfy0 Y dS w )aH Try to find the source line of the given test thing. @param testThing: the test item to attempt to inspect @type testThing: an L{TestCase}, test method, or module, though only the former two have a chance to succeed @rtype: int @return: the starting source line, or -1 if one couldn't be found �_testMethodNameN�__code__r r )�getattr�co_firstlineno�inspect�getsourcelines�OSError� TypeError)� testThing�method�coder% r% r& �_maybeFindSourceLinea s �rL zCalphabetical order for test methods, arbitrary order for test caseszDattempt to run test cases and methods in the order they were defined)� alphabetical� toptobottomc C s, | t vrt�dd�dd� t D ��f ��| S )ai Check that the given order is a known test running order. Does nothing else, since looking up the appropriate callable to sort the tests should be done when it actually will be used, as the default argument will not be coerced by this function. @param order: one of the known orders in C{_runOrders} @return: the order unmodified z9--order must be one of: %s. See --help-orders for detailsz, c s s � | ]}t |�V qd S �N)�repr)r: �orderr% r% r& � <genexpr>� s � z&_checkKnownRunOrder.<locals>.<genexpr>)� _runOrdersr � UsageError�join)rQ r% r% r& �_checkKnownRunOrder� s ��rV c @ s0 e Zd ZdZdZddgg d�g d�g d�g d�g d �g d �g d �gZd d ddegg d�g d�g d�gZej e� e �e ej dd�ejdd�d�ej dddd�gd�ZejZdZd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Z d.d/� Z d0d1� Z d2d3� Z d4d5� Z d6d7� Z!d8d9� Z"d:d;� Z#dS )<� _BasicOptionszC Basic options shared between trial and its local workers. zutrial loads and executes a suite of unit tests, obtained from modules, packages and files listed on the command line.�help�h)� no-recurse�NzDon't recurse into packages)z help-ordersNz%Help on available test running orders)zhelp-reportersNz,Help on available output plugins (reporters))�rterrors�ez;realtime errors, print out tracebacks as soon as they occur)�unclean-warningsNz'Turn dirty reactor errors into warnings)�force-gcNz<Have Trial run gc.collect() before and after each test case.)� exitfirst�xzSExit after the first non-successful result (cannot be specified along with --jobs).rQ �oNzRSpecify what order to run test cases and methods. See --help-orders for more info.)�random�zNz2Run tests in random order using the specified seed)�temp-directoryN� _trial_tempz+Path to use as working directory for tests.)r Nr zKThe reporter to use for this test run. See --help-reporters for more info.� log file name)�descrz random seed)rQ r �logfilerc z*.pyz/file | module | package | TestCase | testMethodT)rh �repeat)� optActions� extraActionsc C s g | d< t j�| � d S �N�tests)r �Options�__init__��selfr% r% r& rp � s z_BasicOptions.__init__c C sB t �tjd �}|�d�r d�tj�tj �|� dd��}d�|�S )Nr z .__main__z{} -m {}� zD{} [options] [[file|package|module|TestCase|testmethod]...] ) r �filenameToModuleName�sys�argv�endswith�formatr3 r4 r5 � executable�replace)rr �executableNamer% r% r& � getSynopsis� s ���z_BasicOptions.getSynopsisc C s, d}t | d ��|�}td|j� d�� |S )zx Return a L{FilePath} representing the directory into which coverage results should be written. �coveragere z Setting coverage directory to �.)r �child�printr4 )rr �coverdir�resultr% r% r& r� � s z_BasicOptions.coverdirc C s2 ddl }|jddd�| _t�| jj� d| d< dS )z� Generate coverage information in the coverage file in the directory specified by the temp-directory option. r Nr )�count�traceTr} )r� �Trace�tracerru �settrace� globaltrace)rr r� r% r% r& � opt_coverage s z_BasicOptions.opt_coveragec C s` t j�|�stj�d|�d�� dS t j�|�}t|�r%| d �|� dS | d � t |�� dS )zG Filename to grep for test cases (-*- test-case-name). zFile z doesn't exist Nrn ) r3 r4 �isfileru �stderr�write�abspathr8 �append�extendr1 )rr r* r% r% r& �opt_testmodule s z _BasicOptions.opt_testmodulec C s ddl m} t�|� dS )z� Print an insanely verbose log of everything that happens. Useful when debugging freezes or locks in complex code. r )�spewerN)�twisted.python.utilr� ru r� )rr r� r% r% r& �opt_spew3 s z_BasicOptions.opt_spewc C sB d}t |� tt�� �D ] \}\}}t d|d|� q t�d� d S )Nz�Trial can attempt to run test cases and their methods in a few different orders. You can select any of the following options using --order=<foo>. � � r )r� �sortedrS r" ru �exit)rr �synopsis�name� description�_r% r% r& �opt_help_orders< s �z _BasicOptions.opt_help_ordersc C s> d}t |� t�tj�D ] }t d|jd|j� q t�d� d S )Nz�Trial's output can be customized using plugins called Reporters. You can select any of the following reporters using --reporter=<foo> r� r� r ) r� r r> r r? r9 r� ru r� )rr r� r; r% r% r& �opt_help_reportersH s �z _BasicOptions.opt_help_reportersc C s d| d< t �� dS )z/ Disable the garbage collector T� disablegcN)�gc�disablerq r% r% r& � opt_disablegcS s z_BasicOptions.opt_disablegcc C s, z t | | d< W dS ty t�d��w )z� Specify the format to display tracebacks with. Valid formats are 'plain', 'emacs', and 'cgitb' which uses the nicely verbose stdlib cgitb.text function �tbformatz.tbformat must be 'plain', 'emacs', or 'cgitb'.N)� TBFORMAT_MAP�KeyErrorr rT )rr �optr% r% r& � opt_tbformatZ s �z_BasicOptions.opt_tbformatc C s@ z t �t|�� W n ttfy t�d��w t|�| d< dS )z- see sys.setrecursionlimit() z-argument to recursionlimit must be an integer�recursionlimitN)ru �setrecursionlimit�intrH r r rT )rr �argr% r% r& �opt_recursionlimite s �z _BasicOptions.opt_recursionlimitc C sh zt |�| d< W n ty t�d��w | d dk r t�d��| d dkr2t t�� d �| d< d S d S )Nrc z/Argument to --random must be a positive integerr �d )r� r r rT �time)rr �optionr% r% r& � opt_randomp s � � �z_BasicOptions.opt_randomc C sD || d< |� d�D ]}|tjv rtjd|f td� dtj|< q dS )zP Fake the lack of the specified modules, separated with commas. �without-moduler. z/Module '%s' already imported, disabling anyway.)�categoryN)r ru �modules�warnings�warn�RuntimeWarning)rr r� �moduler% r% r& �opt_without_module} s � �z _BasicOptions.opt_without_modulec G s | d � |� d S rm )r� )rr �argsr% r% r& � parseArgs� s z_BasicOptions.parseArgsc C sF t �tj�D ]}|j� d|j� �}|j|kr t�|� S qt � d��)Nr~ zVOnly pass names of Reporter plugins to --reporter. See --help-reporters for more info.) r r> r r? r� �klassr9 r �namedAnyr rT )rr r� r; �qualr% r% r& �_loadReporterByName� s ��z!_BasicOptions._loadReporterByNamec C sL | � | d �| d< d| vrd| d< | d d ur"| d d ur$t�d��d S d S )Nr r� r rQ rc z-You can't specify --random when using --order)r� r rT rq r% r% r& � postOptions� s �z_BasicOptions.postOptions)$�__name__� __module__� __qualname__�__doc__�longdesc�optFlagsrV � optParametersr � Completionsr= rS r@ � CompleteFiles� Completer�compDatar � TreeReporter�fallbackReporterr� rp r| r� r� r� r� r� r� r� r� r� r� r� r� r� r� r% r% r% r& rW � sl ���� ���� rW c @ s� e Zd ZdZg d�g d�g d�g d�g d�g d�gZg d�g d �g d �gZeje�g d ��e d �d �Z g d�Z g d�Z e jZdZdZdd� Zdd� Zdd� ZdS )ro a� Options to the trial command line tool. @ivar _workerFlags: List of flags which are accepted by trial distributed workers. This is used by C{_getWorkerArguments} to build the command line arguments. @type _workerFlags: C{list} @ivar _workerParameters: List of parameter which are accepted by trial distributed workers. This is used by C{_getWorkerArguments} to build the command line arguments. @type _workerParameters: C{list} )�debug�bziRun tests in a debugger. If that debugger is pdb, will load '.pdbrc' from current directory if it exists.)�debug-stacktraces�Bz2Report Deferred creation and callback stack traces)�nopmNzFdon't automatically jump into debugger for postmorteming of exceptions)�dry-run�nz do everything but run the tests)�profileNz#Run tests under the Python profiler)� until-failure�uzRepeat test until it fails)�debuggerN�pdbzBthe fully qualified name of a debugger to use if --debug is passed)ri �lztest.logrg )�jobs�jNz Number of local workers to run)r r r )r� r )rk )r� r_ r} )r� �reactorr� Nc C sH zt |�}W n ty t�d| ��w |dkr t�d��|| d< dS )zN Number of local workers to run, a strictly positive integer. z,Expecting integer argument to jobs, got '%s'r z4Argument to jobs must be a strictly positive integerr� N)r� r r rT )rr �numberr% r% r& �opt_jobs� s ��� zOptions.opt_jobsc C sp g }| j D ]}| �|�dur| | r|�d|� �� q| jD ]}| �|�dur5|�d|� �t| | �g� q |S )zJ Return a list of options to pass to distributed workers. Nz--)� _workerFlagsr/ r� �_workerParametersr� �str)rr r� r� r% r% r& �_getWorkerArguments� s � �zOptions._getWorkerArgumentsc C sb t �| � | d r g d�}|D ] }| | r t�d| ��q| d r/| d s*t�d��dt_d S d S )Nr� )r� r� r� r` z(You can't specify --%s when using --jobsr� r� z+You must specify --debug when using --nopm F)rW r� r rT r �DO_POST_MORTEM)rr � conflictsr� r% r% r& r� � s �� �zOptions.postOptions)r� r� r� r� r� r� r r� r= r@ r� r� r� r r� r� �extrar� r� r� r� r% r% r% r& ro � s4 �� �� ro c C s2 | d rt �� | d s| d rt�d� d S d S )Nr� r� T)r �startDebugModer � setDebugging)�configr% r% r& �_initialDebugSetup s �r� c C s$ t | �}| d }|j| d |d�S )NrZ rn )�recurse)� _getLoader� loadByNames)r� �loaderr� r% r% r& � _getSuite s r� c sx t �� }| d r#t�� � � �| d � � fdd�|_td| d � n| d r2t| d \}}||_| d s:t j|_ |S )Nrc c s � � � S rO )rc )ra ��randomerr% r& �<lambda>! s z _getLoader.<locals>.<lambda>z$Running tests shuffled with seed %d rQ r� ) r � TestLoaderrc �Random�seed�sorterr� rS �DestructiveTestSuite� suiteFactory)r� r� r� r� r% r� r& r� s r� c C s� t �� } ztd� W n ty td� Y nw dD ]2}tj�|�rLzt|�}W n t y1 Y qw |� | j � |� � � W d � n1 sGw Y q| S )zR Wrap an instance of C{pdb.Pdb} with readline support and load any .rcs. r) z readline module not available)z.pdbrc�pdbrcN) r� �Pdbr � ImportErrorr� r3 r4 �existsr( rG �rcLinesr� � readlines)�dbgr4 �rcFiler% r% r& � _wrappedPdb+ s$ � � ��r� c @ s e Zd ZdZdS )�_DebuggerNotFoundzk A debugger import failed. Used to allow translating these errors into usage error messages. N)r� r� r� r� r% r% r% r& r B s r c C s t j}| d | d | d | d | d | d d�}| d r#t jj|d < n[| d r<d d lm} |}| d |d < | �� |d< nB| d rlt jj|d < | d }|dkrgz t�|�|d< W n tj yf t |�d���w t � |d< | d |d< | d |d< | d |d< |di |��S )z� Return a trial runner class set up with the parameters extracted from C{config}. @return: A trial runner instance. @rtype: L{runner.TrialRunner} or C{DistTrialRunner} depending on the configuration. r r� r\ r^ ri re )�reporterFactory�tracebackFormat�realTimeErrors�uncleanWarningsri �workingDirectoryr� �moder� r )�DistTrialRunner� workerNumber�workerArgumentsr� r� r� z debugger could not be found.r` � exitFirstr� r_ �forceGarbageCollectionNr% ) r � TrialRunner�DRY_RUN� twisted.trial._dist.disttrialr r� �DEBUGr r� �ModuleNotFoundr r� )r� �clsr� r r� r% r% r& � _makeRunnerK s> � �� r c C s t tj�dkr tj�d� t� } z| �� W n tjy/ } z ttjd � d|� ���d }~ww t | � zt | �}W n t yT } zttjd � dt |�� ���d }~ww t | �}| d rc|�|�}n|�|�}| jr�t�d � | j�� }|jdd| �� jd� t�|�� � d S )Nr z--helpr z: r� F)� show_missing�summaryr� )r ru rv r� ro � parseOptionsr �error� SystemExitr� r r r� r� �runUntilFailure�runr� r� �results� write_resultsr� r4 r� � wasSuccessful)r� �ue� trialRunnerr] �suite� test_resultr r% r% r& r { s6 �� �� �r )/r� rE r3 r� rc ru r� r� �twistedr �twisted.applicationr �twisted.internetr �twisted.pythonr r r �twisted.python.filepathr �twisted.python.reflectr � twisted.trialr r r r� r' r- r1 r8 r@ rL r� rS rV rW ro �ReactorSelectionMixinr� r� r� r� � Exceptionr r r r% r% r% r& �<module> s^ � !��� k 0PK Mb�Z�i��> �> scripts/_twistd_unix.pynu �[��� # -*- test-case-name: twisted.test.test_twistd -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import errno import os import pwd import sys import traceback from twisted import copyright, logger from twisted.application import app, service from twisted.internet.interfaces import IReactorDaemonize from twisted.python import log, logfile, usage from twisted.python.runtime import platformType from twisted.python.util import gidFromString, switchUID, uidFromString, untilConcludes if platformType == "win32": raise ImportError("_twistd_unix doesn't work on Windows.") def _umask(value): return int(value, 8) class ServerOptions(app.ServerOptions): synopsis = "Usage: twistd [options]" optFlags = [ ["nodaemon", "n", "don't daemonize, don't use default umask of 0077"], ["originalname", None, "Don't try to change the process name"], ["syslog", None, "Log to syslog, not to file"], [ "euid", "", "Set only effective user-id rather than real user-id. " "(This option has no effect unless the server is running as " "root, in which case it means not to shed all privileges " "after binding ports, retaining the option to regain " "privileges in cases such as spawning processes. " "Use with caution.)", ], ] optParameters = [ ["prefix", None, "twisted", "use the given prefix when syslogging"], ["pidfile", "", "twistd.pid", "Name of the pidfile"], ["chroot", None, None, "Chroot to a supplied directory before running"], ["uid", "u", None, "The uid to run as.", uidFromString], [ "gid", "g", None, "The gid to run as. If not specified, the default gid " "associated with the specified --uid is used.", gidFromString, ], ["umask", None, None, "The (octal) file creation mask to apply.", _umask], ] compData = usage.Completions( optActions={ "pidfile": usage.CompleteFiles("*.pid"), "chroot": usage.CompleteDirs(descr="chroot directory"), "gid": usage.CompleteGroups(descr="gid to run as"), "uid": usage.CompleteUsernames(descr="uid to run as"), "prefix": usage.Completer(descr="syslog prefix"), }, ) def opt_version(self): """ Print version information and exit. """ print(f"twistd (the Twisted daemon) {copyright.version}", file=self.stdout) print(copyright.copyright, file=self.stdout) sys.exit() def postOptions(self): app.ServerOptions.postOptions(self) if self["pidfile"]: self["pidfile"] = os.path.abspath(self["pidfile"]) def checkPID(pidfile): if not pidfile: return if os.path.exists(pidfile): try: with open(pidfile) as f: pid = int(f.read()) except ValueError: sys.exit(f"Pidfile {pidfile} contains non-numeric value") try: os.kill(pid, 0) except OSError as why: if why.errno == errno.ESRCH: # The pid doesn't exist. log.msg(f"Removing stale pidfile {pidfile}", isError=True) os.remove(pidfile) else: sys.exit( "Can't check status of PID {} from pidfile {}: {}".format( pid, pidfile, why ) ) else: sys.exit( """\ Another twistd server is running, PID {}\n This could either be a previously started instance of your application or a different application entirely. To start a new one, either run it in some other directory, or use the --pidfile and --logfile parameters to avoid clashes. """.format( pid ) ) class UnixAppLogger(app.AppLogger): """ A logger able to log to syslog, to files, and to stdout. @ivar _syslog: A flag indicating whether to use syslog instead of file logging. @type _syslog: C{bool} @ivar _syslogPrefix: If C{sysLog} is C{True}, the string prefix to use for syslog messages. @type _syslogPrefix: C{str} @ivar _nodaemon: A flag indicating the process will not be daemonizing. @type _nodaemon: C{bool} """ def __init__(self, options): app.AppLogger.__init__(self, options) self._syslog = options.get("syslog", False) self._syslogPrefix = options.get("prefix", "") self._nodaemon = options.get("nodaemon", False) def _getLogObserver(self): """ Create and return a suitable log observer for the given configuration. The observer will go to syslog using the prefix C{_syslogPrefix} if C{_syslog} is true. Otherwise, it will go to the file named C{_logfilename} or, if C{_nodaemon} is true and C{_logfilename} is C{"-"}, to stdout. @return: An object suitable to be passed to C{log.addObserver}. """ if self._syslog: from twisted.python import syslog return syslog.SyslogObserver(self._syslogPrefix).emit if self._logfilename == "-": if not self._nodaemon: sys.exit("Daemons cannot log to stdout, exiting!") logFile = sys.stdout elif self._nodaemon and not self._logfilename: logFile = sys.stdout else: if not self._logfilename: self._logfilename = "twistd.log" logFile = logfile.LogFile.fromFullPath(self._logfilename) try: import signal except ImportError: pass else: # Override if signal is set to None or SIG_DFL (0) if not signal.getsignal(signal.SIGUSR1): def rotateLog(signal, frame): from twisted.internet import reactor reactor.callFromThread(logFile.rotate) signal.signal(signal.SIGUSR1, rotateLog) return logger.textFileLogObserver(logFile) def launchWithName(name): if name and name != sys.argv[0]: exe = os.path.realpath(sys.executable) log.msg("Changing process name to " + name) os.execv(exe, [name, sys.argv[0], "--originalname"] + sys.argv[1:]) class UnixApplicationRunner(app.ApplicationRunner): """ An ApplicationRunner which does Unix-specific things, like fork, shed privileges, and maintain a PID file. """ loggerFactory = UnixAppLogger def preApplication(self): """ Do pre-application-creation setup. """ checkPID(self.config["pidfile"]) self.config["nodaemon"] = self.config["nodaemon"] or self.config["debug"] self.oldstdout = sys.stdout self.oldstderr = sys.stderr def _formatChildException(self, exception): """ Format the C{exception} in preparation for writing to the status pipe. This does the right thing on Python 2 if the exception's message is Unicode, and in all cases limits the length of the message afte* encoding to 100 bytes. This means the returned message may be truncated in the middle of a unicode escape. @type exception: L{Exception} @param exception: The exception to format. @return: The formatted message, suitable for writing to the status pipe. @rtype: L{bytes} """ # On Python 2 this will encode Unicode messages with the ascii # codec and the backslashreplace error handler. exceptionLine = traceback.format_exception_only(exception.__class__, exception)[ -1 ] # remove the trailing newline formattedMessage = f"1 {exceptionLine.strip()}" # On Python 3, encode the message the same way Python 2's # format_exception_only does formattedMessage = formattedMessage.encode("ascii", "backslashreplace") # By this point, the message has been encoded, if appropriate, # with backslashreplace on both Python 2 and Python 3. # Truncating the encoded message won't make it completely # unreadable, and the reader should print out the repr of the # message it receives anyway. What it will do, however, is # ensure that only 100 bytes are written to the status pipe, # ensuring that the child doesn't block because the pipe's # full. This assumes PIPE_BUF > 100! return formattedMessage[:100] def postApplication(self): """ To be called after the application is created: start the application and run the reactor. After the reactor stops, clean up PID files and such. """ try: self.startApplication(self.application) except Exception as ex: statusPipe = self.config.get("statusPipe", None) if statusPipe is not None: message = self._formatChildException(ex) untilConcludes(os.write, statusPipe, message) untilConcludes(os.close, statusPipe) self.removePID(self.config["pidfile"]) raise else: statusPipe = self.config.get("statusPipe", None) if statusPipe is not None: untilConcludes(os.write, statusPipe, b"0") untilConcludes(os.close, statusPipe) self.startReactor(None, self.oldstdout, self.oldstderr) self.removePID(self.config["pidfile"]) def removePID(self, pidfile): """ Remove the specified PID file, if possible. Errors are logged, not raised. @type pidfile: C{str} @param pidfile: The path to the PID tracking file. """ if not pidfile: return try: os.unlink(pidfile) except OSError as e: if e.errno == errno.EACCES or e.errno == errno.EPERM: log.msg("Warning: No permission to delete pid file") else: log.err(e, "Failed to unlink PID file:") except BaseException: log.err(None, "Failed to unlink PID file:") def setupEnvironment(self, chroot, rundir, nodaemon, umask, pidfile): """ Set the filesystem root, the working directory, and daemonize. @type chroot: C{str} or L{None} @param chroot: If not None, a path to use as the filesystem root (using L{os.chroot}). @type rundir: C{str} @param rundir: The path to set as the working directory. @type nodaemon: C{bool} @param nodaemon: A flag which, if set, indicates that daemonization should not be done. @type umask: C{int} or L{None} @param umask: The value to which to change the process umask. @type pidfile: C{str} or L{None} @param pidfile: If not L{None}, the path to a file into which to put the PID of this process. """ daemon = not nodaemon if chroot is not None: os.chroot(chroot) if rundir == ".": rundir = "/" os.chdir(rundir) if daemon and umask is None: umask = 0o077 if umask is not None: os.umask(umask) if daemon: from twisted.internet import reactor self.config["statusPipe"] = self.daemonize(reactor) if pidfile: with open(pidfile, "wb") as f: f.write(b"%d" % (os.getpid(),)) def daemonize(self, reactor): """ Daemonizes the application on Unix. This is done by the usual double forking approach. @see: U{http://code.activestate.com/recipes/278731/} @see: W. Richard Stevens, "Advanced Programming in the Unix Environment", 1992, Addison-Wesley, ISBN 0-201-56317-7 @param reactor: The reactor in use. If it provides L{IReactorDaemonize}, its daemonization-related callbacks will be invoked. @return: A writable pipe to be used to report errors. @rtype: C{int} """ # If the reactor requires hooks to be called for daemonization, call # them. Currently the only reactor which provides/needs that is # KQueueReactor. if IReactorDaemonize.providedBy(reactor): reactor.beforeDaemonize() r, w = os.pipe() if os.fork(): # launch child and... code = self._waitForStart(r) os.close(r) os._exit(code) # kill off parent os.setsid() if os.fork(): # launch child and... os._exit(0) # kill off parent again. null = os.open("/dev/null", os.O_RDWR) for i in range(3): try: os.dup2(null, i) except OSError as e: if e.errno != errno.EBADF: raise os.close(null) if IReactorDaemonize.providedBy(reactor): reactor.afterDaemonize() return w def _waitForStart(self, readPipe: int) -> int: """ Wait for the daemonization success. @param readPipe: file descriptor to read start information from. @type readPipe: C{int} @return: code to be passed to C{os._exit}: 0 for success, 1 for error. @rtype: C{int} """ data = untilConcludes(os.read, readPipe, 100) dataRepr = repr(data[2:]) if data != b"0": msg = ( "An error has occurred: {}\nPlease look at log " "file for more information.\n".format(dataRepr) ) untilConcludes(sys.__stderr__.write, msg) return 1 return 0 def shedPrivileges(self, euid, uid, gid): """ Change the UID and GID or the EUID and EGID of this process. @type euid: C{bool} @param euid: A flag which, if set, indicates that only the I{effective} UID and GID should be set. @type uid: C{int} or L{None} @param uid: If not L{None}, the UID to which to switch. @type gid: C{int} or L{None} @param gid: If not L{None}, the GID to which to switch. """ if uid is not None or gid is not None: extra = euid and "e" or "" desc = f"{extra}uid/{extra}gid {uid}/{gid}" try: switchUID(uid, gid, euid) except OSError as e: log.msg( "failed to set {}: {} (are you root?) -- " "exiting.".format(desc, e) ) sys.exit(1) else: log.msg(f"set {desc}") def startApplication(self, application): """ Configure global process state based on the given application and run the application. @param application: An object which can be adapted to L{service.IProcess} and L{service.IService}. """ process = service.IProcess(application) if not self.config["originalname"]: launchWithName(process.processName) self.setupEnvironment( self.config["chroot"], self.config["rundir"], self.config["nodaemon"], self.config["umask"], self.config["pidfile"], ) service.IService(application).privilegedStartService() uid, gid = self.config["uid"], self.config["gid"] if uid is None: uid = process.uid if gid is None: gid = process.gid if uid is not None and gid is None: gid = pwd.getpwuid(uid).pw_gid self.shedPrivileges(self.config["euid"], uid, gid) app.startApplication(application, not self.config["no_save"]) PK Mb�Z��A�" " scripts/htmlizer.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # """ HTML pretty-printing for Python source code. """ __version__ = "$Revision: 1.8 $"[11:-2] import os import sys from twisted import copyright from twisted.python import htmlizer, usage header = """<html><head> <title>%(title)s</title> <meta name=\"Generator\" content="%(generator)s" /> %(alternate)s %(stylesheet)s </head> <body> """ footer = """</body>""" styleLink = '<link rel="stylesheet" href="%s" type="text/css" />' alternateLink = '<link rel="alternate" href="%(source)s" type="text/x-python" />' class Options(usage.Options): synopsis = """{} [options] source.py """.format( os.path.basename(sys.argv[0]), ) optParameters = [ ("stylesheet", "s", None, "URL of stylesheet to link to."), ] compData = usage.Completions( extraActions=[usage.CompleteFiles("*.py", descr="source python file")] ) def parseArgs(self, filename): self["filename"] = filename def run(): options = Options() try: options.parseOptions() except usage.UsageError as e: print(str(e)) sys.exit(1) filename = options["filename"] if options.get("stylesheet") is not None: stylesheet = styleLink % (options["stylesheet"],) else: stylesheet = "" with open(filename + ".html", "wb") as output: outHeader = header % { "title": filename, "generator": f"htmlizer/{copyright.longversion}", "alternate": alternateLink % {"source": filename}, "stylesheet": stylesheet, } output.write(outHeader.encode("utf-8")) with open(filename, "rb") as f: htmlizer.filter(f, output, htmlizer.SmallerHTMLWriter) output.write(footer.encode("utf-8")) PK Mb�Z M+� � scripts/test/test_scripts.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for the command-line scripts in the top-level I{bin/} directory. Tests for actual functionality belong elsewhere, written in a way that doesn't involve launching child processes. """ from os import chdir, devnull, getcwd from subprocess import PIPE, Popen from sys import executable from twisted.python.filepath import FilePath from twisted.python.modules import getModule from twisted.python.test.test_shellcomp import ZshScriptTestMixin from twisted.trial.unittest import SkipTest, TestCase def outputFromPythonScript(script, *args): """ Synchronously run a Python script, with the same Python interpreter that ran the process calling this function, using L{Popen}, using the given command-line arguments, with standard input and standard error both redirected to L{os.devnull}, and return its output as a string. @param script: The path to the script. @type script: L{FilePath} @param args: The command-line arguments to follow the script in its invocation (the desired C{sys.argv[1:]}). @type args: L{tuple} of L{str} @return: the output passed to the proces's C{stdout}, without any messages from C{stderr}. @rtype: L{bytes} """ with open(devnull, "rb") as nullInput, open(devnull, "wb") as nullError: process = Popen( [executable, script.path] + list(args), stdout=PIPE, stderr=nullError, stdin=nullInput, ) stdout = process.communicate()[0] return stdout class ScriptTestsMixin: """ Mixin for L{TestCase} subclasses which defines a helper function for testing a Twisted-using script. """ bin = getModule("twisted").pathEntry.filePath.child("bin") def scriptTest(self, name): """ Verify that the given script runs and uses the version of Twisted currently being tested. This only works when running tests against a vcs checkout of Twisted, since it relies on the scripts being in the place they are kept in version control, and exercises their logic for finding the right version of Twisted to use in that situation. @param name: A path fragment, relative to the I{bin} directory of a Twisted source checkout, identifying a script to test. @type name: C{str} @raise SkipTest: if the script is not where it is expected to be. """ script = self.bin.preauthChild(name) if not script.exists(): raise SkipTest("Script tests do not apply to installed configuration.") from twisted.copyright import version scriptVersion = outputFromPythonScript(script, "--version") self.assertIn(str(version), scriptVersion) class ScriptTests(TestCase, ScriptTestsMixin): """ Tests for the core scripts. """ def test_twistd(self): self.scriptTest("twistd") def test_twistdPathInsert(self): """ The twistd script adds the current working directory to sys.path so that it's able to import modules from it. """ script = self.bin.child("twistd") if not script.exists(): raise SkipTest("Script tests do not apply to installed configuration.") cwd = getcwd() self.addCleanup(chdir, cwd) testDir = FilePath(self.mktemp()) testDir.makedirs() chdir(testDir.path) testDir.child("bar.tac").setContent("import sys\n" "print sys.path\n") output = outputFromPythonScript(script, "-ny", "bar.tac") self.assertIn(repr(testDir.path), output) def test_trial(self): self.scriptTest("trial") def test_trialPathInsert(self): """ The trial script adds the current working directory to sys.path so that it's able to import modules from it. """ script = self.bin.child("trial") if not script.exists(): raise SkipTest("Script tests do not apply to installed configuration.") cwd = getcwd() self.addCleanup(chdir, cwd) testDir = FilePath(self.mktemp()) testDir.makedirs() chdir(testDir.path) testDir.child("foo.py").setContent("") output = outputFromPythonScript(script, "foo") self.assertIn("PASSED", output) def test_pyhtmlizer(self): self.scriptTest("pyhtmlizer") class ZshIntegrationTests(TestCase, ZshScriptTestMixin): """ Test that zsh completion functions are generated without error """ generateFor = [ ("twistd", "twisted.scripts.twistd.ServerOptions"), ("trial", "twisted.scripts.trial.Options"), ("pyhtmlizer", "twisted.scripts.htmlizer.Options"), ] PK Mb�Z��.� � 1 scripts/test/__pycache__/__init__.cpython-310.pycnu �[��� o �bv � @ s d Z dS )z& Test package for L{twisted.scripts}. N)�__doc__� r r �?/usr/lib/python3/dist-packages/twisted/scripts/test/__init__.py�<module> s PK Mb�Z�&M�� � 5 scripts/test/__pycache__/test_scripts.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZmZmZ ddlmZmZ ddlm Z ddl m Z ddl m Z ddlmZ ddlmZmZ d d � ZG d d � d �ZG d d� dee�ZG dd� dee�ZdS )z� Tests for the command-line scripts in the top-level I{bin/} directory. Tests for actual functionality belong elsewhere, written in a way that doesn't involve launching child processes. � )�chdir�devnull�getcwd)�PIPE�Popen)� executable)�FilePath)� getModule)�ZshScriptTestMixin)�SkipTest�TestCasec G s� t td��;}t td�� }tt| jgt|� t||d�}|�� d }W d � n1 s+w Y W d � |S W d � |S 1 sCw Y |S )a� Synchronously run a Python script, with the same Python interpreter that ran the process calling this function, using L{Popen}, using the given command-line arguments, with standard input and standard error both redirected to L{os.devnull}, and return its output as a string. @param script: The path to the script. @type script: L{FilePath} @param args: The command-line arguments to follow the script in its invocation (the desired C{sys.argv[1:]}). @type args: L{tuple} of L{str} @return: the output passed to the proces's C{stdout}, without any messages from C{stderr}. @rtype: L{bytes} �rb�wb)�stdout�stderr�stdinr N)�openr r r �path�listr � communicate)�script�args� nullInput� nullError�processr � r �C/usr/lib/python3/dist-packages/twisted/scripts/test/test_scripts.py�outputFromPythonScript s �(� ��r c @ s* e Zd ZdZed�jj�d�Zdd� Z dS )�ScriptTestsMixinzr Mixin for L{TestCase} subclasses which defines a helper function for testing a Twisted-using script. �twisted�binc C sF | j �|�}|�� std��ddlm} t|d�}| �t|�|� dS )a� Verify that the given script runs and uses the version of Twisted currently being tested. This only works when running tests against a vcs checkout of Twisted, since it relies on the scripts being in the place they are kept in version control, and exercises their logic for finding the right version of Twisted to use in that situation. @param name: A path fragment, relative to the I{bin} directory of a Twisted source checkout, identifying a script to test. @type name: C{str} @raise SkipTest: if the script is not where it is expected to be. �5Script tests do not apply to installed configuration.r )�versionz --versionN) r � preauthChild�existsr �twisted.copyrightr" r �assertIn�str)�self�namer r" � scriptVersionr r r � scriptTest: s zScriptTestsMixin.scriptTestN) �__name__� __module__� __qualname__�__doc__r � pathEntry�filePath�childr r+ r r r r r 2 s r c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � ScriptTestsz% Tests for the core scripts. c C � | � d� d S )N�twistd�r+ �r( r r r � test_twistdZ � zScriptTests.test_twistdc C s~ | j �d�}|�� std��t� }| �t|� t| �� �}|� � t|j � |�d�� d� t |dd�}| � t|j �|� dS )z� The twistd script adds the current working directory to sys.path so that it's able to import modules from it. r5 r! zbar.taczimport sys print sys.path z-nyN)r r2 r$ r r � addCleanupr r �mktemp�makedirsr � setContentr r& �repr�r( r �cwd�testDir�outputr r r �test_twistdPathInsert] s z!ScriptTests.test_twistdPathInsertc C r4 )N�trialr6 r7 r r r � test_trialn r9 zScriptTests.test_trialc C sv | j �d�}|�� std��t� }| �t|� t| �� �}|� � t|j � |�d�� d� t |d�}| � d|� dS )z� The trial script adds the current working directory to sys.path so that it's able to import modules from it. rD r! zfoo.py� �foo�PASSEDN)r r2 r$ r r r: r r r; r< r r= r r& r? r r r �test_trialPathInsertq s z ScriptTests.test_trialPathInsertc C r4 )N� pyhtmlizerr6 r7 r r r �test_pyhtmlizer� r9 zScriptTests.test_pyhtmlizerN) r, r- r. r/ r8 rC rE rI rK r r r r r3 U s r3 c @ s e Zd ZdZg d�ZdS )�ZshIntegrationTestszH Test that zsh completion functions are generated without error ))r5 z$twisted.scripts.twistd.ServerOptions)rD z twisted.scripts.trial.Options)rJ z twisted.scripts.htmlizer.OptionsN)r, r- r. r/ � generateForr r r r rL � s rL N)r/ �osr r r � subprocessr r �sysr �twisted.python.filepathr �twisted.python.modulesr �"twisted.python.test.test_shellcompr �twisted.trial.unittestr r r r r3 rL r r r r �<module> s #1PK Mb�Z��^v v scripts/test/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test package for L{twisted.scripts}. """ PK Mb�Z�ja� scripts/_twistw.pynu �[��� # -*- test-case-name: twisted.test.test_twistd -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import os import sys from twisted import copyright from twisted.application import app, internet, service from twisted.python import log class ServerOptions(app.ServerOptions): synopsis = "Usage: twistd [options]" optFlags = [ ["nodaemon", "n", "(for backwards compatibility)."], ] def opt_version(self): """ Print version information and exit. """ print( f"twistd (the Twisted Windows runner) {copyright.version}", file=self.stdout, ) print(copyright.copyright, file=self.stdout) sys.exit() class WindowsApplicationRunner(app.ApplicationRunner): """ An ApplicationRunner which avoids unix-specific things. No forking, no PID files, no privileges. """ def preApplication(self): """ Do pre-application-creation setup. """ self.oldstdout = sys.stdout self.oldstderr = sys.stderr os.chdir(self.config["rundir"]) def postApplication(self): """ Start the application and run the reactor. """ service.IService(self.application).privilegedStartService() app.startApplication(self.application, not self.config["no_save"]) app.startApplication(internet.TimerService(0.1, lambda: None), 0) self.startReactor(None, self.oldstdout, self.oldstderr) log.msg("Server Shut Down.") PK Mb�Z��!mg g scripts/twistd.pynu �[��� # -*- test-case-name: twisted.test.test_twistd -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ The Twisted Daemon: platform-independent interface. @author: Christopher Armstrong """ from twisted.application import app from twisted.python.runtime import platformType if platformType == "win32": from twisted.scripts._twistw import ( ServerOptions, WindowsApplicationRunner as _SomeApplicationRunner, ) else: from twisted.scripts._twistd_unix import ( # type: ignore[misc] ServerOptions, UnixApplicationRunner as _SomeApplicationRunner, ) def runApp(config): runner = _SomeApplicationRunner(config) runner.run() if runner._exitSignal is not None: app._exitWithSignal(runner._exitSignal) def run(): app.run(runApp, ServerOptions) __all__ = ["run", "runApp"] PK Mb�Z�99� scripts/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Subpackage containing the modules that implement the command line tools. Note that these are imported by top-level scripts which are intended to be invoked directly from a shell. """ PK Mb�Zr �1 ! ! plugin.pynu �[��� # -*- test-case-name: twisted.test.test_plugin -*- # Copyright (c) 2005 Divmod, Inc. # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Plugin system for Twisted. @author: Jp Calderone @author: Glyph Lefkowitz """ import os import pickle import sys import types from typing import Iterable, Optional, Type, TypeVar from zope.interface import Interface, providedBy from twisted.python import log from twisted.python.components import getAdapterFactory from twisted.python.modules import getModule from twisted.python.reflect import namedAny class IPlugin(Interface): """ Interface that must be implemented by all plugins. Only objects which implement this interface will be considered for return by C{getPlugins}. To be useful, plugins should also implement some other application-specific interface. """ class CachedPlugin: def __init__(self, dropin, name, description, provided): self.dropin = dropin self.name = name self.description = description self.provided = provided self.dropin.plugins.append(self) def __repr__(self) -> str: return "<CachedPlugin {!r}/{!r} (provides {!r})>".format( self.name, self.dropin.moduleName, ", ".join([i.__name__ for i in self.provided]), ) def load(self): return namedAny(self.dropin.moduleName + "." + self.name) def __conform__(self, interface, registry=None, default=None): for providedInterface in self.provided: if providedInterface.isOrExtends(interface): return self.load() if getAdapterFactory(providedInterface, interface, None) is not None: return interface(self.load(), default) return default # backwards compat HOORJ getComponent = __conform__ class CachedDropin: """ A collection of L{CachedPlugin} instances from a particular module in a plugin package. @type moduleName: C{str} @ivar moduleName: The fully qualified name of the plugin module this represents. @type description: C{str} or L{None} @ivar description: A brief explanation of this collection of plugins (probably the plugin module's docstring). @type plugins: C{list} @ivar plugins: The L{CachedPlugin} instances which were loaded from this dropin. """ def __init__(self, moduleName, description): self.moduleName = moduleName self.description = description self.plugins = [] def _generateCacheEntry(provider): dropin = CachedDropin(provider.__name__, provider.__doc__) for k, v in provider.__dict__.items(): plugin = IPlugin(v, None) if plugin is not None: # Instantiated for its side-effects. CachedPlugin(dropin, k, v.__doc__, list(providedBy(plugin))) return dropin try: fromkeys = dict.fromkeys except AttributeError: def fromkeys(keys, value=None): d = {} for k in keys: d[k] = value return d def getCache(module): """ Compute all the possible loadable plugins, while loading as few as possible and hitting the filesystem as little as possible. @param module: a Python module object. This represents a package to search for plugins. @return: a dictionary mapping module names to L{CachedDropin} instances. """ allCachesCombined = {} mod = getModule(module.__name__) # don't want to walk deep, only immediate children. buckets = {} # Fill buckets with modules by related entry on the given package's # __path__. There's an abstraction inversion going on here, because this # information is already represented internally in twisted.python.modules, # but it's simple enough that I'm willing to live with it. If anyone else # wants to fix up this iteration so that it's one path segment at a time, # be my guest. --glyph for plugmod in mod.iterModules(): fpp = plugmod.filePath.parent() if fpp not in buckets: buckets[fpp] = [] bucket = buckets[fpp] bucket.append(plugmod) for pseudoPackagePath, bucket in buckets.items(): dropinPath = pseudoPackagePath.child("dropin.cache") try: lastCached = dropinPath.getModificationTime() with dropinPath.open("r") as f: dropinDotCache = pickle.load(f) except BaseException: dropinDotCache = {} lastCached = 0 needsWrite = False existingKeys = {} for pluginModule in bucket: pluginKey = pluginModule.name.split(".")[-1] existingKeys[pluginKey] = True if (pluginKey not in dropinDotCache) or ( pluginModule.filePath.getModificationTime() >= lastCached ): needsWrite = True try: provider = pluginModule.load() except BaseException: # dropinDotCache.pop(pluginKey, None) log.err() else: entry = _generateCacheEntry(provider) dropinDotCache[pluginKey] = entry # Make sure that the cache doesn't contain any stale plugins. for pluginKey in list(dropinDotCache.keys()): if pluginKey not in existingKeys: del dropinDotCache[pluginKey] needsWrite = True if needsWrite: try: dropinPath.setContent(pickle.dumps(dropinDotCache)) except OSError as e: log.msg( format=( "Unable to write to plugin cache %(path)s: error " "number %(errno)d" ), path=dropinPath.path, errno=e.errno, ) except BaseException: log.err(None, "Unexpected error while writing cache file") allCachesCombined.update(dropinDotCache) return allCachesCombined def _pluginsPackage() -> types.ModuleType: import twisted.plugins as package return package _TInterface = TypeVar("_TInterface", bound=Interface) def getPlugins( interface: Type[_TInterface], package: Optional[types.ModuleType] = None ) -> Iterable[_TInterface]: """ Retrieve all plugins implementing the given interface beneath the given module. @param interface: An interface class. Only plugins which implement this interface will be returned. @param package: A package beneath which plugins are installed. For most uses, the default value is correct. @return: An iterator of plugins. """ if package is None: package = _pluginsPackage() allDropins = getCache(package) for key, dropin in allDropins.items(): for plugin in dropin.plugins: try: adapted = interface(plugin, None) except BaseException: log.err() else: if adapted is not None: yield adapted # Old, backwards compatible name. Don't use this. getPlugIns = getPlugins def pluginPackagePaths(name): """ Return a list of additional directories which should be searched for modules to be included as part of the named plugin package. @type name: C{str} @param name: The fully-qualified Python name of a plugin package, eg C{'twisted.plugins'}. @rtype: C{list} of C{str} @return: The absolute paths to other directories which may contain plugin modules for the named plugin package. """ package = name.split(".") # Note that this may include directories which do not exist. It may be # preferable to remove such directories at this point, rather than allow # them to be searched later on. # # Note as well that only '__init__.py' will be considered to make a # directory a package (and thus exclude it from this list). This means # that if you create a master plugin package which has some other kind of # __init__ (eg, __init__.pyc) it will be incorrectly treated as a # supplementary plugin directory. return [ os.path.abspath(os.path.join(x, *package)) for x in sys.path if not os.path.exists(os.path.join(x, *package + ["__init__.py"])) ] __all__ = ["getPlugins", "pluginPackagePaths"] PK Mb�Z�� {+ {+ internet/asyncioreactor.pynu �[��� # -*- test-case-name: twisted.test.test_internet -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ asyncio-based reactor implementation. """ import errno import sys from asyncio import AbstractEventLoop, get_event_loop from typing import Dict, Optional, Type from zope.interface import implementer from twisted.internet.abstract import FileDescriptor from twisted.internet.interfaces import IReactorFDSet from twisted.internet.posixbase import ( _NO_FILEDESC, PosixReactorBase, _ContinuousPolling, ) from twisted.logger import Logger from twisted.python.log import callWithLogger @implementer(IReactorFDSet) class AsyncioSelectorReactor(PosixReactorBase): """ Reactor running on top of L{asyncio.SelectorEventLoop}. On POSIX platforms, the default event loop is L{asyncio.SelectorEventLoop}. On Windows, the default event loop on Python 3.7 and older is C{asyncio.WindowsSelectorEventLoop}, but on Python 3.8 and newer the default event loop is C{asyncio.WindowsProactorEventLoop} which is incompatible with L{AsyncioSelectorReactor}. Applications that use L{AsyncioSelectorReactor} on Windows with Python 3.8+ must call C{asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())} before instantiating and running L{AsyncioSelectorReactor}. """ _asyncClosed = False _log = Logger() def __init__(self, eventloop: Optional[AbstractEventLoop] = None): if eventloop is None: _eventloop: AbstractEventLoop = get_event_loop() else: _eventloop = eventloop # On Python 3.8+, asyncio.get_event_loop() on # Windows was changed to return a ProactorEventLoop # unless the loop policy has been changed. if sys.platform == "win32": from asyncio import ProactorEventLoop if isinstance(_eventloop, ProactorEventLoop): raise TypeError( f"ProactorEventLoop is not supported, got: {_eventloop}" ) self._asyncioEventloop: AbstractEventLoop = _eventloop self._writers: Dict[Type[FileDescriptor], int] = {} self._readers: Dict[Type[FileDescriptor], int] = {} self._continuousPolling = _ContinuousPolling(self) self._scheduledAt = None self._timerHandle = None super().__init__() def _unregisterFDInAsyncio(self, fd): """ Compensate for a bug in asyncio where it will not unregister a FD that it cannot handle in the epoll loop. It touches internal asyncio code. A description of the bug by markrwilliams: The C{add_writer} method of asyncio event loops isn't atomic because all the Selector classes in the selector module internally record a file object before passing it to the platform's selector implementation. If the platform's selector decides the file object isn't acceptable, the resulting exception doesn't cause the Selector to un-track the file object. The failing/hanging stdio test goes through the following sequence of events (roughly): * The first C{connection.write(intToByte(value))} call hits the asyncio reactor's C{addWriter} method. * C{addWriter} calls the asyncio loop's C{add_writer} method, which happens to live on C{_BaseSelectorEventLoop}. * The asyncio loop's C{add_writer} method checks if the file object has been registered before via the selector's C{get_key} method. * It hasn't, so the KeyError block runs and calls the selector's register method * Code examples that follow use EpollSelector, but the code flow holds true for any other selector implementation. The selector's register method first calls through to the next register method in the MRO * That next method is always C{_BaseSelectorImpl.register} which creates a C{SelectorKey} instance for the file object, stores it under the file object's file descriptor, and then returns it. * Control returns to the concrete selector implementation, which asks the operating system to track the file descriptor using the right API. * The operating system refuses! An exception is raised that, in this case, the asyncio reactor handles by creating a C{_ContinuousPolling} object to watch the file descriptor. * The second C{connection.write(intToByte(value))} call hits the asyncio reactor's C{addWriter} method, which hits the C{add_writer} method. But the loop's selector's get_key method now returns a C{SelectorKey}! Now the asyncio reactor's C{addWriter} method thinks the asyncio loop will watch the file descriptor, even though it won't. """ try: self._asyncioEventloop._selector.unregister(fd) except BaseException: pass def _readOrWrite(self, selectable, read): method = selectable.doRead if read else selectable.doWrite if selectable.fileno() == -1: self._disconnectSelectable(selectable, _NO_FILEDESC, read) return try: why = method() except Exception as e: why = e self._log.failure(None) if why: self._disconnectSelectable(selectable, why, read) def addReader(self, reader): if reader in self._readers.keys() or reader in self._continuousPolling._readers: return fd = reader.fileno() try: self._asyncioEventloop.add_reader( fd, callWithLogger, reader, self._readOrWrite, reader, True ) self._readers[reader] = fd except OSError as e: self._unregisterFDInAsyncio(fd) if e.errno == errno.EPERM: # epoll(7) doesn't support certain file descriptors, # e.g. filesystem files, so for those we just poll # continuously: self._continuousPolling.addReader(reader) else: raise def addWriter(self, writer): if writer in self._writers.keys() or writer in self._continuousPolling._writers: return fd = writer.fileno() try: self._asyncioEventloop.add_writer( fd, callWithLogger, writer, self._readOrWrite, writer, False ) self._writers[writer] = fd except PermissionError: self._unregisterFDInAsyncio(fd) # epoll(7) doesn't support certain file descriptors, # e.g. filesystem files, so for those we just poll # continuously: self._continuousPolling.addWriter(writer) except BrokenPipeError: # The kqueuereactor will raise this if there is a broken pipe self._unregisterFDInAsyncio(fd) except BaseException: self._unregisterFDInAsyncio(fd) raise def removeReader(self, reader): # First, see if they're trying to remove a reader that we don't have. if not ( reader in self._readers.keys() or self._continuousPolling.isReading(reader) ): # We don't have it, so just return OK. return # If it was a cont. polling reader, check there first. if self._continuousPolling.isReading(reader): self._continuousPolling.removeReader(reader) return fd = reader.fileno() if fd == -1: # If the FD is -1, we want to know what its original FD was, to # remove it. fd = self._readers.pop(reader) else: self._readers.pop(reader) self._asyncioEventloop.remove_reader(fd) def removeWriter(self, writer): # First, see if they're trying to remove a writer that we don't have. if not ( writer in self._writers.keys() or self._continuousPolling.isWriting(writer) ): # We don't have it, so just return OK. return # If it was a cont. polling writer, check there first. if self._continuousPolling.isWriting(writer): self._continuousPolling.removeWriter(writer) return fd = writer.fileno() if fd == -1: # If the FD is -1, we want to know what its original FD was, to # remove it. fd = self._writers.pop(writer) else: self._writers.pop(writer) self._asyncioEventloop.remove_writer(fd) def removeAll(self): return ( self._removeAll(self._readers.keys(), self._writers.keys()) + self._continuousPolling.removeAll() ) def getReaders(self): return list(self._readers.keys()) + self._continuousPolling.getReaders() def getWriters(self): return list(self._writers.keys()) + self._continuousPolling.getWriters() def iterate(self, timeout): self._asyncioEventloop.call_later(timeout + 0.01, self._asyncioEventloop.stop) self._asyncioEventloop.run_forever() def run(self, installSignalHandlers=True): self.startRunning(installSignalHandlers=installSignalHandlers) self._asyncioEventloop.run_forever() if self._justStopped: self._justStopped = False def stop(self): super().stop() # This will cause runUntilCurrent which in its turn # will call fireSystemEvent("shutdown") self.callLater(0, lambda: None) def crash(self): super().crash() self._asyncioEventloop.stop() def _onTimer(self): self._scheduledAt = None self.runUntilCurrent() self._reschedule() def _reschedule(self): timeout = self.timeout() if timeout is not None: abs_time = self._asyncioEventloop.time() + timeout self._scheduledAt = abs_time if self._timerHandle is not None: self._timerHandle.cancel() self._timerHandle = self._asyncioEventloop.call_at(abs_time, self._onTimer) def _moveCallLaterSooner(self, tple): PosixReactorBase._moveCallLaterSooner(self, tple) self._reschedule() def callLater(self, seconds, f, *args, **kwargs): dc = PosixReactorBase.callLater(self, seconds, f, *args, **kwargs) abs_time = self._asyncioEventloop.time() + self.timeout() if self._scheduledAt is None or abs_time < self._scheduledAt: self._reschedule() return dc def callFromThread(self, f, *args, **kwargs): g = lambda: self.callLater(0, f, *args, **kwargs) self._asyncioEventloop.call_soon_threadsafe(g) def install(eventloop=None): """ Install an asyncio-based reactor. @param eventloop: The asyncio eventloop to wrap. If default, the global one is selected. """ reactor = AsyncioSelectorReactor(eventloop) from twisted.internet.main import installReactor installReactor(reactor) PK Mb�Z��`�� � internet/threads.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Extended thread dispatching support. For basic support see reactor threading API docs. """ import queue as Queue from twisted.internet import defer from twisted.python import failure def deferToThreadPool(reactor, threadpool, f, *args, **kwargs): """ Call the function C{f} using a thread from the given threadpool and return the result as a Deferred. This function is only used by client code which is maintaining its own threadpool. To run a function in the reactor's threadpool, use C{deferToThread}. @param reactor: The reactor in whose main thread the Deferred will be invoked. @param threadpool: An object which supports the C{callInThreadWithCallback} method of C{twisted.python.threadpool.ThreadPool}. @param f: The function to call. @param args: positional arguments to pass to f. @param kwargs: keyword arguments to pass to f. @return: A Deferred which fires a callback with the result of f, or an errback with a L{twisted.python.failure.Failure} if f throws an exception. """ d = defer.Deferred() def onResult(success, result): if success: reactor.callFromThread(d.callback, result) else: reactor.callFromThread(d.errback, result) threadpool.callInThreadWithCallback(onResult, f, *args, **kwargs) return d def deferToThread(f, *args, **kwargs): """ Run a function in a thread and return the result as a Deferred. @param f: The function to call. @param args: positional arguments to pass to f. @param kwargs: keyword arguments to pass to f. @return: A Deferred which fires a callback with the result of f, or an errback with a L{twisted.python.failure.Failure} if f throws an exception. """ from twisted.internet import reactor return deferToThreadPool(reactor, reactor.getThreadPool(), f, *args, **kwargs) def _runMultiple(tupleList): """ Run a list of functions. """ for f, args, kwargs in tupleList: f(*args, **kwargs) def callMultipleInThread(tupleList): """ Run a list of functions in the same thread. tupleList should be a list of (function, argsList, kwargsDict) tuples. """ from twisted.internet import reactor reactor.callInThread(_runMultiple, tupleList) def blockingCallFromThread(reactor, f, *a, **kw): """ Run a function in the reactor from a thread, and wait for the result synchronously. If the function returns a L{Deferred}, wait for its result and return that. @param reactor: The L{IReactorThreads} provider which will be used to schedule the function call. @param f: the callable to run in the reactor thread @type f: any callable. @param a: the arguments to pass to C{f}. @param kw: the keyword arguments to pass to C{f}. @return: the result of the L{Deferred} returned by C{f}, or the result of C{f} if it returns anything other than a L{Deferred}. @raise Exception: If C{f} raises a synchronous exception, C{blockingCallFromThread} will raise that exception. If C{f} returns a L{Deferred} which fires with a L{Failure}, C{blockingCallFromThread} will raise that failure's exception (see L{Failure.raiseException}). """ queue = Queue.Queue() def _callFromThread(): result = defer.maybeDeferred(f, *a, **kw) result.addBoth(queue.put) reactor.callFromThread(_callFromThread) result = queue.get() if isinstance(result, failure.Failure): result.raiseException() return result __all__ = [ "deferToThread", "deferToThreadPool", "callMultipleInThread", "blockingCallFromThread", ] PK Mb�Z�µ� � � internet/base.pynu �[��� # -*- test-case-name: twisted.test.test_internet,twisted.internet.test.test_core -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Very basic functionality for a Reactor implementation. """ import builtins import socket # needed only for sync-dns import warnings from abc import ABC, abstractmethod from heapq import heapify, heappop, heappush from traceback import format_stack from types import FrameType from typing import ( TYPE_CHECKING, Any, Callable, Dict, List, NewType, Optional, Sequence, Set, Tuple, Union, cast, ) from zope.interface import classImplements, implementer from twisted.internet import abstract, defer, error, fdesc, main, threads from twisted.internet._resolver import ( ComplexResolverSimplifier as _ComplexResolverSimplifier, GAIResolver as _GAIResolver, SimpleResolverComplexifier as _SimpleResolverComplexifier, ) from twisted.internet.defer import Deferred, DeferredList from twisted.internet.interfaces import ( IAddress, IConnector, IDelayedCall, IHostnameResolver, IProtocol, IReactorCore, IReactorPluggableNameResolver, IReactorPluggableResolver, IReactorThreads, IReactorTime, IReadDescriptor, IResolverSimple, IWriteDescriptor, _ISupportsExitSignalCapturing, ) from twisted.internet.protocol import ClientFactory from twisted.python import log, reflect from twisted.python.failure import Failure from twisted.python.runtime import platform, seconds as runtimeSeconds if TYPE_CHECKING: from twisted.internet.tcp import Client # This import is for side-effects! Even if you don't see any code using it # in this module, don't delete it. from twisted.python import threadable if platform.supportsThreads(): from twisted.python.threadpool import ThreadPool else: ThreadPool = None # type: ignore[misc, assignment] @implementer(IDelayedCall) class DelayedCall: # enable .debug to record creator call stack, and it will be logged if # an exception occurs while the function is being run debug = False _repr: Optional[str] = None def __init__( self, time: float, func: Callable[..., Any], args: Sequence[object], kw: Dict[str, object], cancel: Callable[["DelayedCall"], None], reset: Callable[["DelayedCall"], None], seconds: Callable[[], float] = runtimeSeconds, ) -> None: """ @param time: Seconds from the epoch at which to call C{func}. @param func: The callable to call. @param args: The positional arguments to pass to the callable. @param kw: The keyword arguments to pass to the callable. @param cancel: A callable which will be called with this DelayedCall before cancellation. @param reset: A callable which will be called with this DelayedCall after changing this DelayedCall's scheduled execution time. The callable should adjust any necessary scheduling details to ensure this DelayedCall is invoked at the new appropriate time. @param seconds: If provided, a no-argument callable which will be used to determine the current time any time that information is needed. """ self.time, self.func, self.args, self.kw = time, func, args, kw self.resetter = reset self.canceller = cancel self.seconds = seconds self.cancelled = self.called = 0 self.delayed_time = 0.0 if self.debug: self.creator = format_stack()[:-2] def getTime(self) -> float: """ Return the time at which this call will fire @return: The number of seconds after the epoch at which this call is scheduled to be made. """ return self.time + self.delayed_time def cancel(self) -> None: """ Unschedule this call @raise AlreadyCancelled: Raised if this call has already been unscheduled. @raise AlreadyCalled: Raised if this call has already been made. """ if self.cancelled: raise error.AlreadyCancelled elif self.called: raise error.AlreadyCalled else: self.canceller(self) self.cancelled = 1 if self.debug: self._repr = repr(self) del self.func, self.args, self.kw def reset(self, secondsFromNow: float) -> None: """ Reschedule this call for a different time @param secondsFromNow: The number of seconds from the time of the C{reset} call at which this call will be scheduled. @raise AlreadyCancelled: Raised if this call has been cancelled. @raise AlreadyCalled: Raised if this call has already been made. """ if self.cancelled: raise error.AlreadyCancelled elif self.called: raise error.AlreadyCalled else: newTime = self.seconds() + secondsFromNow if newTime < self.time: self.delayed_time = 0.0 self.time = newTime self.resetter(self) else: self.delayed_time = newTime - self.time def delay(self, secondsLater: float) -> None: """ Reschedule this call for a later time @param secondsLater: The number of seconds after the originally scheduled time for which to reschedule this call. @raise AlreadyCancelled: Raised if this call has been cancelled. @raise AlreadyCalled: Raised if this call has already been made. """ if self.cancelled: raise error.AlreadyCancelled elif self.called: raise error.AlreadyCalled else: self.delayed_time += secondsLater if self.delayed_time < 0.0: self.activate_delay() self.resetter(self) def activate_delay(self) -> None: self.time += self.delayed_time self.delayed_time = 0.0 def active(self) -> bool: """Determine whether this call is still pending @return: True if this call has not yet been made or cancelled, False otherwise. """ return not (self.cancelled or self.called) def __le__(self, other: object) -> bool: """ Implement C{<=} operator between two L{DelayedCall} instances. Comparison is based on the C{time} attribute (unadjusted by the delayed time). """ if isinstance(other, DelayedCall): return self.time <= other.time else: return NotImplemented def __lt__(self, other: object) -> bool: """ Implement C{<} operator between two L{DelayedCall} instances. Comparison is based on the C{time} attribute (unadjusted by the delayed time). """ if isinstance(other, DelayedCall): return self.time < other.time else: return NotImplemented def __repr__(self) -> str: """ Implement C{repr()} for L{DelayedCall} instances. @returns: String containing details of the L{DelayedCall}. """ if self._repr is not None: return self._repr if hasattr(self, "func"): # This code should be replaced by a utility function in reflect; # see ticket #6066: func = getattr(self.func, "__qualname__", None) if func is None: func = getattr(self.func, "__name__", None) if func is not None: imClass = getattr(self.func, "im_class", None) if imClass is not None: func = f"{imClass}.{func}" if func is None: func = reflect.safe_repr(self.func) else: func = None now = self.seconds() L = [ "<DelayedCall 0x%x [%ss] called=%s cancelled=%s" % (id(self), self.time - now, self.called, self.cancelled) ] if func is not None: L.extend((" ", func, "(")) if self.args: L.append(", ".join([reflect.safe_repr(e) for e in self.args])) if self.kw: L.append(", ") if self.kw: L.append( ", ".join( [f"{k}={reflect.safe_repr(v)}" for (k, v) in self.kw.items()] ) ) L.append(")") if self.debug: L.append("\n\ntraceback at creation: \n\n%s" % (" ".join(self.creator))) L.append(">") return "".join(L) @implementer(IResolverSimple) class ThreadedResolver: """ L{ThreadedResolver} uses a reactor, a threadpool, and L{socket.gethostbyname} to perform name lookups without blocking the reactor thread. It also supports timeouts indepedently from whatever timeout logic L{socket.gethostbyname} might have. @ivar reactor: The reactor the threadpool of which will be used to call L{socket.gethostbyname} and the I/O thread of which the result will be delivered. """ def __init__(self, reactor: "ReactorBase") -> None: self.reactor = reactor self._runningQueries: Dict[ Deferred[str], Tuple[Deferred[str], IDelayedCall] ] = {} def _fail(self, name: str, err: str) -> Failure: lookupError = error.DNSLookupError(f"address {name!r} not found: {err}") return Failure(lookupError) def _cleanup(self, name: str, lookupDeferred: Deferred[str]) -> None: userDeferred, cancelCall = self._runningQueries[lookupDeferred] del self._runningQueries[lookupDeferred] userDeferred.errback(self._fail(name, "timeout error")) def _checkTimeout( self, result: str, name: str, lookupDeferred: Deferred[str] ) -> None: try: userDeferred, cancelCall = self._runningQueries[lookupDeferred] except KeyError: pass else: del self._runningQueries[lookupDeferred] cancelCall.cancel() if isinstance(result, Failure): userDeferred.errback(self._fail(name, result.getErrorMessage())) else: userDeferred.callback(result) def getHostByName( self, name: str, timeout: Sequence[int] = (1, 3, 11, 45) ) -> Deferred[str]: """ See L{twisted.internet.interfaces.IResolverSimple.getHostByName}. Note that the elements of C{timeout} are summed and the result is used as a timeout for the lookup. Any intermediate timeout or retry logic is left up to the platform via L{socket.gethostbyname}. """ if timeout: timeoutDelay = sum(timeout) else: timeoutDelay = 60 userDeferred: Deferred[str] = Deferred() lookupDeferred = threads.deferToThreadPool( self.reactor, cast(IReactorThreads, self.reactor).getThreadPool(), socket.gethostbyname, name, ) cancelCall = cast(IReactorTime, self.reactor).callLater( timeoutDelay, self._cleanup, name, lookupDeferred ) self._runningQueries[lookupDeferred] = (userDeferred, cancelCall) lookupDeferred.addBoth(self._checkTimeout, name, lookupDeferred) return userDeferred @implementer(IResolverSimple) class BlockingResolver: def getHostByName( self, name: str, timeout: Sequence[int] = (1, 3, 11, 45) ) -> Deferred[str]: try: address = socket.gethostbyname(name) except OSError: msg = f"address {name!r} not found" err = error.DNSLookupError(msg) return defer.fail(err) else: return defer.succeed(address) _ThreePhaseEventTriggerCallable = Callable[..., Any] _ThreePhaseEventTrigger = Tuple[ _ThreePhaseEventTriggerCallable, Tuple[object, ...], Dict[str, object] ] _ThreePhaseEventTriggerHandle = NewType( "_ThreePhaseEventTriggerHandle", Tuple[str, _ThreePhaseEventTriggerCallable, Tuple[object, ...], Dict[str, object]], ) class _ThreePhaseEvent: """ Collection of callables (with arguments) which can be invoked as a group in a particular order. This provides the underlying implementation for the reactor's system event triggers. An instance of this class tracks triggers for all phases of a single type of event. @ivar before: A list of the before-phase triggers containing three-tuples of a callable, a tuple of positional arguments, and a dict of keyword arguments @ivar finishedBefore: A list of the before-phase triggers which have already been executed. This is only populated in the C{'BEFORE'} state. @ivar during: A list of the during-phase triggers containing three-tuples of a callable, a tuple of positional arguments, and a dict of keyword arguments @ivar after: A list of the after-phase triggers containing three-tuples of a callable, a tuple of positional arguments, and a dict of keyword arguments @ivar state: A string indicating what is currently going on with this object. One of C{'BASE'} (for when nothing in particular is happening; this is the initial value), C{'BEFORE'} (when the before-phase triggers are in the process of being executed). """ def __init__(self) -> None: self.before: List[_ThreePhaseEventTrigger] = [] self.during: List[_ThreePhaseEventTrigger] = [] self.after: List[_ThreePhaseEventTrigger] = [] self.state = "BASE" def addTrigger( self, phase: str, callable: _ThreePhaseEventTriggerCallable, *args: object, **kwargs: object, ) -> _ThreePhaseEventTriggerHandle: """ Add a trigger to the indicate phase. @param phase: One of C{'before'}, C{'during'}, or C{'after'}. @param callable: An object to be called when this event is triggered. @param args: Positional arguments to pass to C{callable}. @param kwargs: Keyword arguments to pass to C{callable}. @return: An opaque handle which may be passed to L{removeTrigger} to reverse the effects of calling this method. """ if phase not in ("before", "during", "after"): raise KeyError("invalid phase") getattr(self, phase).append((callable, args, kwargs)) return _ThreePhaseEventTriggerHandle((phase, callable, args, kwargs)) def removeTrigger(self, handle: _ThreePhaseEventTriggerHandle) -> None: """ Remove a previously added trigger callable. @param handle: An object previously returned by L{addTrigger}. The trigger added by that call will be removed. @raise ValueError: If the trigger associated with C{handle} has already been removed or if C{handle} is not a valid handle. """ getattr(self, "removeTrigger_" + self.state)(handle) def removeTrigger_BASE(self, handle: _ThreePhaseEventTriggerHandle) -> None: """ Just try to remove the trigger. @see: removeTrigger """ try: phase, callable, args, kwargs = handle except (TypeError, ValueError): raise ValueError("invalid trigger handle") else: if phase not in ("before", "during", "after"): raise KeyError("invalid phase") getattr(self, phase).remove((callable, args, kwargs)) def removeTrigger_BEFORE(self, handle: _ThreePhaseEventTriggerHandle) -> None: """ Remove the trigger if it has yet to be executed, otherwise emit a warning that in the future an exception will be raised when removing an already-executed trigger. @see: removeTrigger """ phase, callable, args, kwargs = handle if phase != "before": return self.removeTrigger_BASE(handle) if (callable, args, kwargs) in self.finishedBefore: warnings.warn( "Removing already-fired system event triggers will raise an " "exception in a future version of Twisted.", category=DeprecationWarning, stacklevel=3, ) else: self.removeTrigger_BASE(handle) def fireEvent(self) -> None: """ Call the triggers added to this event. """ self.state = "BEFORE" self.finishedBefore = [] beforeResults: List[Deferred[object]] = [] while self.before: callable, args, kwargs = self.before.pop(0) self.finishedBefore.append((callable, args, kwargs)) try: result = callable(*args, **kwargs) except BaseException: log.err() else: if isinstance(result, Deferred): beforeResults.append(result) DeferredList(beforeResults).addCallback(self._continueFiring) def _continueFiring(self, ignored: object) -> None: """ Call the during and after phase triggers for this event. """ self.state = "BASE" self.finishedBefore = [] for phase in self.during, self.after: while phase: callable, args, kwargs = phase.pop(0) try: callable(*args, **kwargs) except BaseException: log.err() @implementer(IReactorPluggableNameResolver, IReactorPluggableResolver) class PluggableResolverMixin: """ A mixin which implements the pluggable resolver reactor interfaces. @ivar resolver: The installed L{IResolverSimple}. @ivar _nameResolver: The installed L{IHostnameResolver}. """ resolver: IResolverSimple = BlockingResolver() _nameResolver: IHostnameResolver = _SimpleResolverComplexifier(resolver) # IReactorPluggableResolver def installResolver(self, resolver: IResolverSimple) -> IResolverSimple: """ See L{IReactorPluggableResolver}. @param resolver: see L{IReactorPluggableResolver}. @return: see L{IReactorPluggableResolver}. """ assert IResolverSimple.providedBy(resolver) oldResolver = self.resolver self.resolver = resolver self._nameResolver = _SimpleResolverComplexifier(resolver) return oldResolver # IReactorPluggableNameResolver def installNameResolver(self, resolver: IHostnameResolver) -> IHostnameResolver: """ See L{IReactorPluggableNameResolver}. @param resolver: See L{IReactorPluggableNameResolver}. @return: see L{IReactorPluggableNameResolver}. """ previousNameResolver = self._nameResolver self._nameResolver = resolver self.resolver = _ComplexResolverSimplifier(resolver) return previousNameResolver @property def nameResolver(self) -> IHostnameResolver: """ Implementation of read-only L{IReactorPluggableNameResolver.nameResolver}. """ return self._nameResolver _SystemEventID = NewType("_SystemEventID", Tuple[str, _ThreePhaseEventTriggerHandle]) _ThreadCall = Tuple[Callable[..., Any], Tuple[object, ...], Dict[str, object]] @implementer(IReactorCore, IReactorTime, _ISupportsExitSignalCapturing) class ReactorBase(PluggableResolverMixin): """ Default base class for Reactors. @ivar _stopped: A flag which is true between paired calls to C{reactor.run} and C{reactor.stop}. This should be replaced with an explicit state machine. @ivar _justStopped: A flag which is true between the time C{reactor.stop} is called and the time the shutdown system event is fired. This is used to determine whether that event should be fired after each iteration through the mainloop. This should be replaced with an explicit state machine. @ivar _started: A flag which is true from the time C{reactor.run} is called until the time C{reactor.run} returns. This is used to prevent calls to C{reactor.run} on a running reactor. This should be replaced with an explicit state machine. @ivar running: See L{IReactorCore.running} @ivar _registerAsIOThread: A flag controlling whether the reactor will register the thread it is running in as the I/O thread when it starts. If C{True}, registration will be done, otherwise it will not be. @ivar _exitSignal: See L{_ISupportsExitSignalCapturing._exitSignal} """ _registerAsIOThread = True _stopped = True installed = False usingThreads = False _exitSignal = None __name__ = "twisted.internet.reactor" def __init__(self) -> None: super().__init__() self.threadCallQueue: List[_ThreadCall] = [] self._eventTriggers: Dict[str, _ThreePhaseEvent] = {} self._pendingTimedCalls: List[DelayedCall] = [] self._newTimedCalls: List[DelayedCall] = [] self._cancellations = 0 self.running = False self._started = False self._justStopped = False self._startedBefore = False # reactor internal readers, e.g. the waker. # Using Any as the type here… unable to find a suitable defined interface self._internalReaders: Set[Any] = set() self.waker: Any = None # Arrange for the running attribute to change to True at the right time # and let a subclass possibly do other things at that time (eg install # signal handlers). self.addSystemEventTrigger("during", "startup", self._reallyStartRunning) self.addSystemEventTrigger("during", "shutdown", self.crash) self.addSystemEventTrigger("during", "shutdown", self.disconnectAll) if platform.supportsThreads(): self._initThreads() self.installWaker() # override in subclasses _lock = None def installWaker(self) -> None: raise NotImplementedError( reflect.qual(self.__class__) + " did not implement installWaker" ) def wakeUp(self) -> None: """ Wake up the event loop. """ if self.waker: self.waker.wakeUp() # if the waker isn't installed, the reactor isn't running, and # therefore doesn't need to be woken up def doIteration(self, delay: Optional[float]) -> None: """ Do one iteration over the readers and writers which have been added. """ raise NotImplementedError( reflect.qual(self.__class__) + " did not implement doIteration" ) def addReader(self, reader: IReadDescriptor) -> None: raise NotImplementedError( reflect.qual(self.__class__) + " did not implement addReader" ) def addWriter(self, writer: IWriteDescriptor) -> None: raise NotImplementedError( reflect.qual(self.__class__) + " did not implement addWriter" ) def removeReader(self, reader: IReadDescriptor) -> None: raise NotImplementedError( reflect.qual(self.__class__) + " did not implement removeReader" ) def removeWriter(self, writer: IWriteDescriptor) -> None: raise NotImplementedError( reflect.qual(self.__class__) + " did not implement removeWriter" ) def removeAll(self) -> List[Union[IReadDescriptor, IWriteDescriptor]]: raise NotImplementedError( reflect.qual(self.__class__) + " did not implement removeAll" ) def getReaders(self) -> List[IReadDescriptor]: raise NotImplementedError( reflect.qual(self.__class__) + " did not implement getReaders" ) def getWriters(self) -> List[IWriteDescriptor]: raise NotImplementedError( reflect.qual(self.__class__) + " did not implement getWriters" ) # IReactorCore def resolve( self, name: str, timeout: Sequence[int] = (1, 3, 11, 45) ) -> Deferred[str]: """ Return a Deferred that will resolve a hostname.""" if not name: # XXX - This is *less than* '::', and will screw up IPv6 servers return defer.succeed("0.0.0.0") if abstract.isIPAddress(name): return defer.succeed(name) return self.resolver.getHostByName(name, timeout) def stop(self) -> None: """ See twisted.internet.interfaces.IReactorCore.stop. """ if self._stopped: raise error.ReactorNotRunning("Can't stop reactor that isn't running.") self._stopped = True self._justStopped = True self._startedBefore = True def crash(self) -> None: """ See twisted.internet.interfaces.IReactorCore.crash. Reset reactor state tracking attributes and re-initialize certain state-transition helpers which were set up in C{__init__} but later destroyed (through use). """ self._started = False self.running = False self.addSystemEventTrigger("during", "startup", self._reallyStartRunning) def sigInt(self, number: int, frame: Optional[FrameType] = None) -> None: """ Handle a SIGINT interrupt. @param number: See handler specification in L{signal.signal} @param frame: See handler specification in L{signal.signal} """ log.msg("Received SIGINT, shutting down.") self.callFromThread(self.stop) self._exitSignal = number def sigBreak(self, number: int, frame: Optional[FrameType] = None) -> None: """ Handle a SIGBREAK interrupt. @param number: See handler specification in L{signal.signal} @param frame: See handler specification in L{signal.signal} """ log.msg("Received SIGBREAK, shutting down.") self.callFromThread(self.stop) self._exitSignal = number def sigTerm(self, number: int, frame: Optional[FrameType] = None) -> None: """ Handle a SIGTERM interrupt. @param number: See handler specification in L{signal.signal} @param frame: See handler specification in L{signal.signal} """ log.msg("Received SIGTERM, shutting down.") self.callFromThread(self.stop) self._exitSignal = number def disconnectAll(self) -> None: """Disconnect every reader, and writer in the system.""" selectables = self.removeAll() for reader in selectables: log.callWithLogger( reader, reader.connectionLost, Failure(main.CONNECTION_LOST) ) def iterate(self, delay: float = 0.0) -> None: """ See twisted.internet.interfaces.IReactorCore.iterate. """ self.runUntilCurrent() self.doIteration(delay) def fireSystemEvent(self, eventType: str) -> None: """ See twisted.internet.interfaces.IReactorCore.fireSystemEvent. """ event = self._eventTriggers.get(eventType) if event is not None: event.fireEvent() def addSystemEventTrigger( self, phase: str, eventType: str, callable: Callable[..., Any], *args: object, **kwargs: object, ) -> _SystemEventID: """ See twisted.internet.interfaces.IReactorCore.addSystemEventTrigger. """ assert builtins.callable(callable), f"{callable} is not callable" if eventType not in self._eventTriggers: self._eventTriggers[eventType] = _ThreePhaseEvent() return _SystemEventID( ( eventType, self._eventTriggers[eventType].addTrigger( phase, callable, *args, **kwargs ), ) ) def removeSystemEventTrigger(self, triggerID: _SystemEventID) -> None: """ See twisted.internet.interfaces.IReactorCore.removeSystemEventTrigger. """ eventType, handle = triggerID self._eventTriggers[eventType].removeTrigger(handle) def callWhenRunning( self, callable: Callable[..., Any], *args: object, **kwargs: object ) -> Optional[_SystemEventID]: """ See twisted.internet.interfaces.IReactorCore.callWhenRunning. """ if self.running: callable(*args, **kwargs) return None else: return self.addSystemEventTrigger( "after", "startup", callable, *args, **kwargs ) def startRunning(self) -> None: """ Method called when reactor starts: do some initialization and fire startup events. Don't call this directly, call reactor.run() instead: it should take care of calling this. This method is somewhat misnamed. The reactor will not necessarily be in the running state by the time this method returns. The only guarantee is that it will be on its way to the running state. """ if self._started: raise error.ReactorAlreadyRunning() if self._startedBefore: raise error.ReactorNotRestartable() self._started = True self._stopped = False if self._registerAsIOThread: threadable.registerAsIOThread() self.fireSystemEvent("startup") def _reallyStartRunning(self) -> None: """ Method called to transition to the running state. This should happen in the I{during startup} event trigger phase. """ self.running = True def run(self) -> None: # IReactorCore.run raise NotImplementedError() # IReactorTime seconds = staticmethod(runtimeSeconds) def callLater( self, delay: float, callable: Callable[..., Any], *args: object, **kw: object ) -> DelayedCall: """ See twisted.internet.interfaces.IReactorTime.callLater. """ assert builtins.callable(callable), f"{callable} is not callable" assert delay >= 0, f"{delay} is not greater than or equal to 0 seconds" delayedCall = DelayedCall( self.seconds() + delay, callable, args, kw, self._cancelCallLater, self._moveCallLaterSooner, seconds=self.seconds, ) self._newTimedCalls.append(delayedCall) return delayedCall def _moveCallLaterSooner(self, delayedCall: DelayedCall) -> None: # Linear time find: slow. heap = self._pendingTimedCalls try: pos = heap.index(delayedCall) # Move elt up the heap until it rests at the right place. elt = heap[pos] while pos != 0: parent = (pos - 1) // 2 if heap[parent] <= elt: break # move parent down heap[pos] = heap[parent] pos = parent heap[pos] = elt except ValueError: # element was not found in heap - oh well... pass def _cancelCallLater(self, delayedCall: DelayedCall) -> None: self._cancellations += 1 def getDelayedCalls(self) -> Sequence[IDelayedCall]: """ See L{twisted.internet.interfaces.IReactorTime.getDelayedCalls} """ return [ x for x in (self._pendingTimedCalls + self._newTimedCalls) if not x.cancelled ] def _insertNewDelayedCalls(self) -> None: for call in self._newTimedCalls: if call.cancelled: self._cancellations -= 1 else: call.activate_delay() heappush(self._pendingTimedCalls, call) self._newTimedCalls = [] def timeout(self) -> Optional[float]: """ Determine the longest time the reactor may sleep (waiting on I/O notification, perhaps) before it must wake up to service a time-related event. @return: The maximum number of seconds the reactor may sleep. """ # insert new delayed calls to make sure to include them in timeout value self._insertNewDelayedCalls() if not self._pendingTimedCalls: return None delay = self._pendingTimedCalls[0].time - self.seconds() # Pick a somewhat arbitrary maximum possible value for the timeout. # This value is 2 ** 31 / 1000, which is the number of seconds which can # be represented as an integer number of milliseconds in a signed 32 bit # integer. This particular limit is imposed by the epoll_wait(3) # interface which accepts a timeout as a C "int" type and treats it as # representing a number of milliseconds. longest = 2147483 # Don't let the delay be in the past (negative) or exceed a plausible # maximum (platform-imposed) interval. return max(0, min(longest, delay)) def runUntilCurrent(self) -> None: """ Run all pending timed calls. """ if self.threadCallQueue: # Keep track of how many calls we actually make, as we're # making them, in case another call is added to the queue # while we're in this loop. count = 0 total = len(self.threadCallQueue) for (f, a, kw) in self.threadCallQueue: try: f(*a, **kw) except BaseException: log.err() count += 1 if count == total: break del self.threadCallQueue[:count] if self.threadCallQueue: self.wakeUp() # insert new delayed calls now self._insertNewDelayedCalls() now = self.seconds() while self._pendingTimedCalls and (self._pendingTimedCalls[0].time <= now): call = heappop(self._pendingTimedCalls) if call.cancelled: self._cancellations -= 1 continue if call.delayed_time > 0.0: call.activate_delay() heappush(self._pendingTimedCalls, call) continue try: call.called = 1 call.func(*call.args, **call.kw) except BaseException: log.deferr() if hasattr(call, "creator"): e = "\n" e += ( " C: previous exception occurred in " + "a DelayedCall created here:\n" ) e += " C:" e += "".join(call.creator).rstrip().replace("\n", "\n C:") e += "\n" log.msg(e) if ( self._cancellations > 50 and self._cancellations > len(self._pendingTimedCalls) >> 1 ): self._cancellations = 0 self._pendingTimedCalls = [ x for x in self._pendingTimedCalls if not x.cancelled ] heapify(self._pendingTimedCalls) if self._justStopped: self._justStopped = False self.fireSystemEvent("shutdown") # IReactorThreads if platform.supportsThreads(): assert ThreadPool is not None threadpool = None # ID of the trigger starting the threadpool _threadpoolStartupID = None # ID of the trigger stopping the threadpool threadpoolShutdownID = None def _initThreads(self) -> None: self.installNameResolver(_GAIResolver(self, self.getThreadPool)) self.usingThreads = True # `IReactorFromThreads` defines the first named argument as # `callable: Callable[..., Any]` but this defines it as `f` # really both should be defined using py3.8 positional only def callFromThread( # type: ignore[override] self, f: Callable[..., Any], *args: object, **kwargs: object ) -> None: """ See L{twisted.internet.interfaces.IReactorFromThreads.callFromThread}. """ assert callable(f), f"{f} is not callable" # lists are thread-safe in CPython, but not in Jython # this is probably a bug in Jython, but until fixed this code # won't work in Jython. self.threadCallQueue.append((f, args, kwargs)) self.wakeUp() def _initThreadPool(self) -> None: """ Create the threadpool accessible with callFromThread. """ self.threadpool = ThreadPool(0, 10, "twisted.internet.reactor") self._threadpoolStartupID = self.callWhenRunning(self.threadpool.start) self.threadpoolShutdownID = self.addSystemEventTrigger( "during", "shutdown", self._stopThreadPool ) def _uninstallHandler(self) -> None: pass def _stopThreadPool(self) -> None: """ Stop the reactor threadpool. This method is only valid if there is currently a threadpool (created by L{_initThreadPool}). It is not intended to be called directly; instead, it will be called by a shutdown trigger created in L{_initThreadPool}. """ triggers = [self._threadpoolStartupID, self.threadpoolShutdownID] for trigger in filter(None, triggers): try: self.removeSystemEventTrigger(trigger) except ValueError: pass self._threadpoolStartupID = None self.threadpoolShutdownID = None assert self.threadpool is not None self.threadpool.stop() self.threadpool = None def getThreadPool(self) -> ThreadPool: """ See L{twisted.internet.interfaces.IReactorThreads.getThreadPool}. """ if self.threadpool is None: self._initThreadPool() assert self.threadpool is not None return self.threadpool # `IReactorInThreads` defines the first named argument as # `callable: Callable[..., Any]` but this defines it as `_callable` # really both should be defined using py3.8 positional only def callInThread( # type: ignore[override] self, _callable: Callable[..., Any], *args: object, **kwargs: object ) -> None: """ See L{twisted.internet.interfaces.IReactorInThreads.callInThread}. """ self.getThreadPool().callInThread(_callable, *args, **kwargs) def suggestThreadPoolSize(self, size: int) -> None: """ See L{twisted.internet.interfaces.IReactorThreads.suggestThreadPoolSize}. """ self.getThreadPool().adjustPoolsize(maxthreads=size) else: # This is for signal handlers. def callFromThread( self, f: Callable[..., Any], *args: object, **kwargs: object ) -> None: assert callable(f), f"{f} is not callable" # See comment in the other callFromThread implementation. self.threadCallQueue.append((f, args, kwargs)) if platform.supportsThreads(): classImplements(ReactorBase, IReactorThreads) @implementer(IConnector) class BaseConnector(ABC): """ Basic implementation of L{IConnector}. State can be: "connecting", "connected", "disconnected" """ timeoutID = None factoryStarted = 0 def __init__( self, factory: ClientFactory, timeout: float, reactor: ReactorBase ) -> None: self.state = "disconnected" self.reactor = reactor self.factory = factory self.timeout = timeout def disconnect(self) -> None: """Disconnect whatever our state is.""" if self.state == "connecting": self.stopConnecting() elif self.state == "connected": assert self.transport is not None self.transport.loseConnection() @abstractmethod def _makeTransport(self) -> "Client": pass def connect(self) -> None: """Start connection to remote server.""" if self.state != "disconnected": raise RuntimeError("can't connect in this state") self.state = "connecting" if not self.factoryStarted: self.factory.doStart() self.factoryStarted = 1 self.transport: Optional[Client] = self._makeTransport() if self.timeout is not None: self.timeoutID = self.reactor.callLater( self.timeout, self.transport.failIfNotConnected, error.TimeoutError() ) self.factory.startedConnecting(self) def stopConnecting(self) -> None: """Stop attempting to connect.""" if self.state != "connecting": raise error.NotConnectingError("we're not trying to connect") assert self.transport is not None self.state = "disconnected" self.transport.failIfNotConnected(error.UserError()) del self.transport def cancelTimeout(self) -> None: if self.timeoutID is not None: try: self.timeoutID.cancel() except ValueError: pass del self.timeoutID def buildProtocol(self, addr: IAddress) -> Optional[IProtocol]: self.state = "connected" self.cancelTimeout() return self.factory.buildProtocol(addr) def connectionFailed(self, reason: Failure) -> None: self.cancelTimeout() self.transport = None self.state = "disconnected" self.factory.clientConnectionFailed(self, reason) if self.state == "disconnected": # factory hasn't called our connect() method self.factory.doStop() self.factoryStarted = 0 def connectionLost(self, reason: Failure) -> None: self.state = "disconnected" self.factory.clientConnectionLost(self, reason) if self.state == "disconnected": # factory hasn't called our connect() method self.factory.doStop() self.factoryStarted = 0 def getDestination(self) -> IAddress: raise NotImplementedError( reflect.qual(self.__class__) + " did not implement " "getDestination" ) def __repr__(self) -> str: return "<{} instance at 0x{:x} {} {}>".format( reflect.qual(self.__class__), id(self), self.state, self.getDestination(), ) class BasePort(abstract.FileDescriptor): """Basic implementation of a ListeningPort. Note: This does not actually implement IListeningPort. """ addressFamily: socket.AddressFamily = None # type: ignore[assignment] socketType: socket.SocketKind = None # type: ignore[assignment] def createInternetSocket(self) -> socket.socket: s = socket.socket(self.addressFamily, self.socketType) s.setblocking(False) fdesc._setCloseOnExec(s.fileno()) return s def doWrite(self) -> Optional[Failure]: """Raises a RuntimeError""" raise RuntimeError("doWrite called on a %s" % reflect.qual(self.__class__)) class _SignalReactorMixin: """ Private mixin to manage signals: it installs signal handlers at start time, and define run method. It can only be used mixed in with L{ReactorBase}, and has to be defined first in the inheritance (so that method resolution order finds startRunning first). @ivar _installSignalHandlers: A flag which indicates whether any signal handlers will be installed during startup. This includes handlers for SIGCHLD to monitor child processes, and SIGINT, SIGTERM, and SIGBREAK to stop the reactor. """ _installSignalHandlers = False def _handleSignals(self) -> None: """ Install the signal handlers for the Twisted event loop. """ try: import signal except ImportError: log.msg( "Warning: signal module unavailable -- " "not installing signal handlers." ) return reactorBaseSelf = cast(ReactorBase, self) if signal.getsignal(signal.SIGINT) == signal.default_int_handler: # only handle if there isn't already a handler, e.g. for Pdb. signal.signal(signal.SIGINT, reactorBaseSelf.sigInt) signal.signal(signal.SIGTERM, reactorBaseSelf.sigTerm) # Catch Ctrl-Break in windows SIGBREAK = getattr(signal, "SIGBREAK", None) if SIGBREAK is not None: signal.signal(SIGBREAK, reactorBaseSelf.sigBreak) def startRunning(self, installSignalHandlers: bool = True) -> None: """ Extend the base implementation in order to remember whether signal handlers should be installed later. @param installSignalHandlers: A flag which, if set, indicates that handlers for a number of (implementation-defined) signals should be installed during startup. """ self._installSignalHandlers = installSignalHandlers ReactorBase.startRunning(cast(ReactorBase, self)) def _reallyStartRunning(self) -> None: """ Extend the base implementation by also installing signal handlers, if C{self._installSignalHandlers} is true. """ ReactorBase._reallyStartRunning(cast(ReactorBase, self)) if self._installSignalHandlers: # Make sure this happens before after-startup events, since the # expectation of after-startup is that the reactor is fully # initialized. Don't do it right away for historical reasons # (perhaps some before-startup triggers don't want there to be a # custom SIGCHLD handler so that they can run child processes with # some blocking api). self._handleSignals() def run(self, installSignalHandlers: bool = True) -> None: self.startRunning(installSignalHandlers=installSignalHandlers) self.mainLoop() def mainLoop(self) -> None: reactorBaseSelf = cast(ReactorBase, self) while reactorBaseSelf._started: try: while reactorBaseSelf._started: # Advance simulation time in delayed event # processors. reactorBaseSelf.runUntilCurrent() t2 = reactorBaseSelf.timeout() t = reactorBaseSelf.running and t2 reactorBaseSelf.doIteration(t) except BaseException: log.msg("Unexpected error in main loop.") log.err() else: log.msg("Main loop terminated.") # type:ignore[unreachable] __all__: List[str] = [] PK Mb�Z�%�V V internet/pollreactor.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ A poll() based implementation of the twisted main loop. To install the event loop (and you should do this before any connections, listeners or connectors are added):: from twisted.internet import pollreactor pollreactor.install() """ # System imports import errno from select import ( POLLERR, POLLHUP, POLLIN, POLLNVAL, POLLOUT, error as SelectError, poll, ) from zope.interface import implementer from twisted.internet import posixbase from twisted.internet.interfaces import IReactorFDSet # Twisted imports from twisted.python import log @implementer(IReactorFDSet) class PollReactor(posixbase.PosixReactorBase, posixbase._PollLikeMixin): """ A reactor that uses poll(2). @ivar _poller: A L{select.poll} which will be used to check for I/O readiness. @ivar _selectables: A dictionary mapping integer file descriptors to instances of L{FileDescriptor} which have been registered with the reactor. All L{FileDescriptor}s which are currently receiving read or write readiness notifications will be present as values in this dictionary. @ivar _reads: A dictionary mapping integer file descriptors to arbitrary values (this is essentially a set). Keys in this dictionary will be registered with C{_poller} for read readiness notifications which will be dispatched to the corresponding L{FileDescriptor} instances in C{_selectables}. @ivar _writes: A dictionary mapping integer file descriptors to arbitrary values (this is essentially a set). Keys in this dictionary will be registered with C{_poller} for write readiness notifications which will be dispatched to the corresponding L{FileDescriptor} instances in C{_selectables}. """ _POLL_DISCONNECTED = POLLHUP | POLLERR | POLLNVAL _POLL_IN = POLLIN _POLL_OUT = POLLOUT def __init__(self): """ Initialize polling object, file descriptor tracking dictionaries, and the base class. """ self._poller = poll() self._selectables = {} self._reads = {} self._writes = {} posixbase.PosixReactorBase.__init__(self) def _updateRegistration(self, fd): """Register/unregister an fd with the poller.""" try: self._poller.unregister(fd) except KeyError: pass mask = 0 if fd in self._reads: mask = mask | POLLIN if fd in self._writes: mask = mask | POLLOUT if mask != 0: self._poller.register(fd, mask) else: if fd in self._selectables: del self._selectables[fd] def _dictRemove(self, selectable, mdict): try: # the easy way fd = selectable.fileno() # make sure the fd is actually real. In some situations we can get # -1 here. mdict[fd] except BaseException: # the hard way: necessary because fileno() may disappear at any # moment, thanks to python's underlying sockets impl for fd, fdes in self._selectables.items(): if selectable is fdes: break else: # Hmm, maybe not the right course of action? This method can't # fail, because it happens inside error detection... return if fd in mdict: del mdict[fd] self._updateRegistration(fd) def addReader(self, reader): """Add a FileDescriptor for notification of data available to read.""" fd = reader.fileno() if fd not in self._reads: self._selectables[fd] = reader self._reads[fd] = 1 self._updateRegistration(fd) def addWriter(self, writer): """Add a FileDescriptor for notification of data available to write.""" fd = writer.fileno() if fd not in self._writes: self._selectables[fd] = writer self._writes[fd] = 1 self._updateRegistration(fd) def removeReader(self, reader): """Remove a Selectable for notification of data available to read.""" return self._dictRemove(reader, self._reads) def removeWriter(self, writer): """Remove a Selectable for notification of data available to write.""" return self._dictRemove(writer, self._writes) def removeAll(self): """ Remove all selectables, and return a list of them. """ return self._removeAll( [self._selectables[fd] for fd in self._reads], [self._selectables[fd] for fd in self._writes], ) def doPoll(self, timeout): """Poll the poller for new events.""" if timeout is not None: timeout = int(timeout * 1000) # convert seconds to milliseconds try: l = self._poller.poll(timeout) except SelectError as e: if e.args[0] == errno.EINTR: return else: raise _drdw = self._doReadOrWrite for fd, event in l: try: selectable = self._selectables[fd] except KeyError: # Handles the infrequent case where one selectable's # handler disconnects another. continue log.callWithLogger(selectable, _drdw, selectable, fd, event) doIteration = doPoll def getReaders(self): return [self._selectables[fd] for fd in self._reads] def getWriters(self): return [self._selectables[fd] for fd in self._writes] def install(): """Install the poll() reactor.""" p = PollReactor() from twisted.internet.main import installReactor installReactor(p) __all__ = ["PollReactor", "install"] PK Mb�Zl�ߍ[D [D internet/cfreactor.pynu �[��� # -*- test-case-name: twisted.internet.test.test_core -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ A reactor for integrating with U{CFRunLoop<http://bit.ly/cfrunloop>}, the CoreFoundation main loop used by macOS. This is useful for integrating Twisted with U{PyObjC<http://pyobjc.sf.net/>} applications. """ __all__ = ["install", "CFReactor"] import sys from zope.interface import implementer from CFNetwork import ( # type: ignore[import] CFSocketCreateRunLoopSource, CFSocketCreateWithNative, CFSocketDisableCallBacks, CFSocketEnableCallBacks, CFSocketInvalidate, CFSocketSetSocketFlags, kCFSocketAutomaticallyReenableReadCallBack, kCFSocketAutomaticallyReenableWriteCallBack, kCFSocketConnectCallBack, kCFSocketReadCallBack, kCFSocketWriteCallBack, ) from CoreFoundation import ( # type: ignore[import] CFAbsoluteTimeGetCurrent, CFRunLoopAddSource, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRemoveSource, CFRunLoopRun, CFRunLoopStop, CFRunLoopTimerCreate, CFRunLoopTimerInvalidate, kCFAllocatorDefault, kCFRunLoopCommonModes, ) from twisted.internet.interfaces import IReactorFDSet from twisted.internet.posixbase import _NO_FILEDESC, PosixReactorBase, _Waker from twisted.python import log _READ = 0 _WRITE = 1 _preserveSOError = 1 << 6 class _WakerPlus(_Waker): """ The normal Twisted waker will simply wake up the main loop, which causes an iteration to run, which in turn causes L{ReactorBase.runUntilCurrent} to get invoked. L{CFReactor} has a slightly different model of iteration, though: rather than have each iteration process the thread queue, then timed calls, then file descriptors, each callback is run as it is dispatched by the CFRunLoop observer which triggered it. So this waker needs to not only unblock the loop, but also make sure the work gets done; so, it reschedules the invocation of C{runUntilCurrent} to be immediate (0 seconds from now) even if there is no timed call work to do. """ def doRead(self): """ Wake up the loop and force C{runUntilCurrent} to run immediately in the next timed iteration. """ result = _Waker.doRead(self) self.reactor._scheduleSimulate(True) return result @implementer(IReactorFDSet) class CFReactor(PosixReactorBase): """ The CoreFoundation reactor. You probably want to use this via the L{install} API. @ivar _fdmap: a dictionary, mapping an integer (a file descriptor) to a 4-tuple of: - source: a C{CFRunLoopSource}; the source associated with this socket. - socket: a C{CFSocket} wrapping the file descriptor. - descriptor: an L{IReadDescriptor} and/or L{IWriteDescriptor} provider. - read-write: a 2-C{list} of booleans: respectively, whether this descriptor is currently registered for reading or registered for writing. @ivar _idmap: a dictionary, mapping the id() of an L{IReadDescriptor} or L{IWriteDescriptor} to a C{fd} in L{_fdmap}. Implemented in this manner so that we don't have to rely (even more) on the hashability of L{IReadDescriptor} providers, and we know that they won't be collected since these are kept in sync with C{_fdmap}. Necessary because the .fileno() of a file descriptor may change at will, so we need to be able to look up what its file descriptor I{used} to be, so that we can look it up in C{_fdmap} @ivar _cfrunloop: the C{CFRunLoop} pyobjc object wrapped by this reactor. @ivar _inCFLoop: Is C{CFRunLoopRun} currently running? @type _inCFLoop: L{bool} @ivar _currentSimulator: if a CFTimer is currently scheduled with the CF run loop to run Twisted callLater calls, this is a reference to it. Otherwise, it is L{None} """ def __init__(self, runLoop=None, runner=None): self._fdmap = {} self._idmap = {} if runner is None: runner = CFRunLoopRun self._runner = runner if runLoop is None: runLoop = CFRunLoopGetMain() self._cfrunloop = runLoop PosixReactorBase.__init__(self) def installWaker(self): """ Override C{installWaker} in order to use L{_WakerPlus}; otherwise this should be exactly the same as the parent implementation. """ if not self.waker: self.waker = _WakerPlus(self) self._internalReaders.add(self.waker) self.addReader(self.waker) def _socketCallback( self, cfSocket, callbackType, ignoredAddress, ignoredData, context ): """ The socket callback issued by CFRunLoop. This will issue C{doRead} or C{doWrite} calls to the L{IReadDescriptor} and L{IWriteDescriptor} registered with the file descriptor that we are being notified of. @param cfSocket: The C{CFSocket} which has got some activity. @param callbackType: The type of activity that we are being notified of. Either C{kCFSocketReadCallBack} or C{kCFSocketWriteCallBack}. @param ignoredAddress: Unused, because this is not used for either of the callback types we register for. @param ignoredData: Unused, because this is not used for either of the callback types we register for. @param context: The data associated with this callback by C{CFSocketCreateWithNative} (in C{CFReactor._watchFD}). A 2-tuple of C{(int, CFRunLoopSource)}. """ (fd, smugglesrc) = context if fd not in self._fdmap: # Spurious notifications seem to be generated sometimes if you # CFSocketDisableCallBacks in the middle of an event. I don't know # about this FD, any more, so let's get rid of it. CFRunLoopRemoveSource(self._cfrunloop, smugglesrc, kCFRunLoopCommonModes) return src, skt, readWriteDescriptor, rw = self._fdmap[fd] def _drdw(): why = None isRead = False try: if readWriteDescriptor.fileno() == -1: why = _NO_FILEDESC else: isRead = callbackType == kCFSocketReadCallBack # CFSocket seems to deliver duplicate read/write # notifications sometimes, especially a duplicate # writability notification when first registering the # socket. This bears further investigation, since I may # have been mis-interpreting the behavior I was seeing. # (Running the full Twisted test suite, while thorough, is # not always entirely clear.) Until this has been more # thoroughly investigated , we consult our own # reading/writing state flags to determine whether we # should actually attempt a doRead/doWrite first. -glyph if isRead: if rw[_READ]: why = readWriteDescriptor.doRead() else: if rw[_WRITE]: why = readWriteDescriptor.doWrite() except BaseException: why = sys.exc_info()[1] log.err() if why: self._disconnectSelectable(readWriteDescriptor, why, isRead) log.callWithLogger(readWriteDescriptor, _drdw) def _watchFD(self, fd, descr, flag): """ Register a file descriptor with the C{CFRunLoop}, or modify its state so that it's listening for both notifications (read and write) rather than just one; used to implement C{addReader} and C{addWriter}. @param fd: The file descriptor. @type fd: L{int} @param descr: the L{IReadDescriptor} or L{IWriteDescriptor} @param flag: the flag to register for callbacks on, either C{kCFSocketReadCallBack} or C{kCFSocketWriteCallBack} """ if fd == -1: raise RuntimeError("Invalid file descriptor.") if fd in self._fdmap: src, cfs, gotdescr, rw = self._fdmap[fd] # do I need to verify that it's the same descr? else: ctx = [] ctx.append(fd) cfs = CFSocketCreateWithNative( kCFAllocatorDefault, fd, kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack, self._socketCallback, ctx, ) CFSocketSetSocketFlags( cfs, kCFSocketAutomaticallyReenableReadCallBack | kCFSocketAutomaticallyReenableWriteCallBack | # This extra flag is to ensure that CF doesn't (destructively, # because destructively is the only way to do it) retrieve # SO_ERROR and thereby break twisted.internet.tcp.BaseClient, # which needs SO_ERROR to tell it whether or not it needs to # call connect_ex a second time. _preserveSOError, ) src = CFSocketCreateRunLoopSource(kCFAllocatorDefault, cfs, 0) ctx.append(src) CFRunLoopAddSource(self._cfrunloop, src, kCFRunLoopCommonModes) CFSocketDisableCallBacks( cfs, kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack, ) rw = [False, False] self._idmap[id(descr)] = fd self._fdmap[fd] = src, cfs, descr, rw rw[self._flag2idx(flag)] = True CFSocketEnableCallBacks(cfs, flag) def _flag2idx(self, flag): """ Convert a C{kCFSocket...} constant to an index into the read/write state list (C{_READ} or C{_WRITE}) (the 4th element of the value of C{self._fdmap}). @param flag: C{kCFSocketReadCallBack} or C{kCFSocketWriteCallBack} @return: C{_READ} or C{_WRITE} """ return {kCFSocketReadCallBack: _READ, kCFSocketWriteCallBack: _WRITE}[flag] def _unwatchFD(self, fd, descr, flag): """ Unregister a file descriptor with the C{CFRunLoop}, or modify its state so that it's listening for only one notification (read or write) as opposed to both; used to implement C{removeReader} and C{removeWriter}. @param fd: a file descriptor @type fd: C{int} @param descr: an L{IReadDescriptor} or L{IWriteDescriptor} @param flag: C{kCFSocketWriteCallBack} C{kCFSocketReadCallBack} """ if id(descr) not in self._idmap: return if fd == -1: # need to deal with it in this case, I think. realfd = self._idmap[id(descr)] else: realfd = fd src, cfs, descr, rw = self._fdmap[realfd] CFSocketDisableCallBacks(cfs, flag) rw[self._flag2idx(flag)] = False if not rw[_READ] and not rw[_WRITE]: del self._idmap[id(descr)] del self._fdmap[realfd] CFRunLoopRemoveSource(self._cfrunloop, src, kCFRunLoopCommonModes) CFSocketInvalidate(cfs) def addReader(self, reader): """ Implement L{IReactorFDSet.addReader}. """ self._watchFD(reader.fileno(), reader, kCFSocketReadCallBack) def addWriter(self, writer): """ Implement L{IReactorFDSet.addWriter}. """ self._watchFD(writer.fileno(), writer, kCFSocketWriteCallBack) def removeReader(self, reader): """ Implement L{IReactorFDSet.removeReader}. """ self._unwatchFD(reader.fileno(), reader, kCFSocketReadCallBack) def removeWriter(self, writer): """ Implement L{IReactorFDSet.removeWriter}. """ self._unwatchFD(writer.fileno(), writer, kCFSocketWriteCallBack) def removeAll(self): """ Implement L{IReactorFDSet.removeAll}. """ allDesc = {descr for src, cfs, descr, rw in self._fdmap.values()} allDesc -= set(self._internalReaders) for desc in allDesc: self.removeReader(desc) self.removeWriter(desc) return list(allDesc) def getReaders(self): """ Implement L{IReactorFDSet.getReaders}. """ return [descr for src, cfs, descr, rw in self._fdmap.values() if rw[_READ]] def getWriters(self): """ Implement L{IReactorFDSet.getWriters}. """ return [descr for src, cfs, descr, rw in self._fdmap.values() if rw[_WRITE]] def _moveCallLaterSooner(self, tple): """ Override L{PosixReactorBase}'s implementation of L{IDelayedCall.reset} so that it will immediately reschedule. Normally C{_moveCallLaterSooner} depends on the fact that C{runUntilCurrent} is always run before the mainloop goes back to sleep, so this forces it to immediately recompute how long the loop needs to stay asleep. """ result = PosixReactorBase._moveCallLaterSooner(self, tple) self._scheduleSimulate() return result _inCFLoop = False def mainLoop(self): """ Run the runner (C{CFRunLoopRun} or something that calls it), which runs the run loop until C{crash()} is called. """ self._inCFLoop = True try: self._runner() finally: self._inCFLoop = False _currentSimulator = None def _scheduleSimulate(self, force=False): """ Schedule a call to C{self.runUntilCurrent}. This will cancel the currently scheduled call if it is already scheduled. @param force: Even if there are no timed calls, make sure that C{runUntilCurrent} runs immediately (in a 0-seconds-from-now C{CFRunLoopTimer}). This is necessary for calls which need to trigger behavior of C{runUntilCurrent} other than running timed calls, such as draining the thread call queue or calling C{crash()} when the appropriate flags are set. @type force: C{bool} """ if self._currentSimulator is not None: CFRunLoopTimerInvalidate(self._currentSimulator) self._currentSimulator = None timeout = self.timeout() if force: timeout = 0.0 if timeout is not None: fireDate = CFAbsoluteTimeGetCurrent() + timeout def simulate(cftimer, extra): self._currentSimulator = None self.runUntilCurrent() self._scheduleSimulate() c = self._currentSimulator = CFRunLoopTimerCreate( kCFAllocatorDefault, fireDate, 0, 0, 0, simulate, None ) CFRunLoopAddTimer(self._cfrunloop, c, kCFRunLoopCommonModes) def callLater(self, _seconds, _f, *args, **kw): """ Implement L{IReactorTime.callLater}. """ delayedCall = PosixReactorBase.callLater(self, _seconds, _f, *args, **kw) self._scheduleSimulate() return delayedCall def stop(self): """ Implement L{IReactorCore.stop}. """ PosixReactorBase.stop(self) self._scheduleSimulate(True) def crash(self): """ Implement L{IReactorCore.crash} """ wasStarted = self._started PosixReactorBase.crash(self) if self._inCFLoop: self._stopNow() else: if wasStarted: self.callLater(0, self._stopNow) def _stopNow(self): """ Immediately stop the CFRunLoop (which must be running!). """ CFRunLoopStop(self._cfrunloop) def iterate(self, delay=0): """ Emulate the behavior of C{iterate()} for things that want to call it, by letting the loop run for a little while and then scheduling a timed call to exit it. """ self.callLater(delay, self._stopNow) self.mainLoop() def install(runLoop=None, runner=None): """ Configure the twisted mainloop to be run inside CFRunLoop. @param runLoop: the run loop to use. @param runner: the function to call in order to actually invoke the main loop. This will default to C{CFRunLoopRun} if not specified. However, this is not an appropriate choice for GUI applications, as you need to run NSApplicationMain (or something like it). For example, to run the Twisted mainloop in a PyObjC application, your C{main.py} should look something like this:: from PyObjCTools import AppHelper from twisted.internet.cfreactor import install install(runner=AppHelper.runEventLoop) # initialize your application reactor.run() @return: The installed reactor. @rtype: C{CFReactor} """ reactor = CFReactor(runLoop=runLoop, runner=runner) from twisted.internet.main import installReactor installReactor(reactor) return reactor PK Mb�Z(�$[ [ internet/glib2reactor.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module provides support for Twisted to interact with the glib mainloop. This is like gtk2, but slightly faster and does not require a working $DISPLAY. However, you cannot run GUIs under this reactor: for that you must use the gtk2reactor instead. In order to use this support, simply do the following:: from twisted.internet import glib2reactor glib2reactor.install() Then use twisted.internet APIs as usual. The other methods here are not intended to be called directly. """ from twisted.internet import gtk2reactor class Glib2Reactor(gtk2reactor.Gtk2Reactor): """ The reactor using the glib mainloop. """ def __init__(self): """ Override init to set the C{useGtk} flag. """ gtk2reactor.Gtk2Reactor.__init__(self, useGtk=False) def install(): """ Configure the twisted mainloop to be run inside the glib mainloop. """ reactor = Glib2Reactor() from twisted.internet.main import installReactor installReactor(reactor) __all__ = ["install"] PK Mb�Z ǫb! ! internet/_resolver.pynu �[��� # -*- 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 socket import ( AF_INET, AF_INET6, AF_UNSPEC, SOCK_DGRAM, SOCK_STREAM, gaierror, getaddrinfo, ) from zope.interface import implementer from twisted.internet._idna import _idnaBytes from twisted.internet.address import IPv4Address, IPv6Address from twisted.internet.defer import Deferred from twisted.internet.error import DNSLookupError from twisted.internet.interfaces import ( IHostnameResolver, IHostResolution, IResolutionReceiver, IResolverSimple, ) from twisted.internet.threads import deferToThreadPool from twisted.logger import Logger from twisted.python.compat import nativeString @implementer(IHostResolution) class HostResolution: """ The in-progress resolution of a given hostname. """ def __init__(self, name): """ Create a L{HostResolution} with the given name. """ self.name = name def cancel(self): # IHostResolution.cancel raise NotImplementedError() _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: """ 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: """ 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 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 """ # 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: """ 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: """ 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 PK Mb�Z|�1�� � internet/serialport.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Serial Port Protocol """ # http://twistedmatrix.com/trac/ticket/3725#comment:24 # Apparently applications use these names even though they should # be imported from pyserial __all__ = [ "serial", "PARITY_ODD", "PARITY_EVEN", "PARITY_NONE", "STOPBITS_TWO", "STOPBITS_ONE", "FIVEBITS", "EIGHTBITS", "SEVENBITS", "SIXBITS", # Name this module is actually trying to export "SerialPort", ] # all of them require pyserial at the moment, so check that first import serial # type: ignore[import] from serial import ( EIGHTBITS, FIVEBITS, PARITY_EVEN, PARITY_NONE, PARITY_ODD, SEVENBITS, SIXBITS, STOPBITS_ONE, STOPBITS_TWO, ) from twisted.python.runtime import platform class BaseSerialPort: """ Base class for Windows and POSIX serial ports. @ivar _serialFactory: a pyserial C{serial.Serial} factory, used to create the instance stored in C{self._serial}. Overrideable to enable easier testing. @ivar _serial: a pyserial C{serial.Serial} instance used to manage the options on the serial port. """ _serialFactory = serial.Serial def setBaudRate(self, baudrate): if hasattr(self._serial, "setBaudrate"): self._serial.setBaudrate(baudrate) else: self._serial.setBaudRate(baudrate) def inWaiting(self): return self._serial.inWaiting() def flushInput(self): self._serial.flushInput() def flushOutput(self): self._serial.flushOutput() def sendBreak(self): self._serial.sendBreak() def getDSR(self): return self._serial.getDSR() def getCD(self): return self._serial.getCD() def getRI(self): return self._serial.getRI() def getCTS(self): return self._serial.getCTS() def setDTR(self, on=1): self._serial.setDTR(on) def setRTS(self, on=1): self._serial.setRTS(on) # Expert appropriate implementation of SerialPort. if platform.isWindows(): from twisted.internet._win32serialport import SerialPort else: from twisted.internet._posixserialport import SerialPort # type: ignore[misc] PK Mb�Z@Þ�� � internet/fdesc.pynu �[��� # -*- test-case-name: twisted.test.test_fdesc -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Utility functions for dealing with POSIX file descriptors. """ import errno import os try: import fcntl as _fcntl except ImportError: fcntl = None else: fcntl = _fcntl # twisted imports from twisted.internet.main import CONNECTION_DONE, CONNECTION_LOST def setNonBlocking(fd): """ Set the file description of the given file descriptor to non-blocking. """ flags = fcntl.fcntl(fd, fcntl.F_GETFL) flags = flags | os.O_NONBLOCK fcntl.fcntl(fd, fcntl.F_SETFL, flags) def setBlocking(fd): """ Set the file description of the given file descriptor to blocking. """ flags = fcntl.fcntl(fd, fcntl.F_GETFL) flags = flags & ~os.O_NONBLOCK fcntl.fcntl(fd, fcntl.F_SETFL, flags) if fcntl is None: # fcntl isn't available on Windows. By default, handles aren't # inherited on Windows, so we can do nothing here. _setCloseOnExec = _unsetCloseOnExec = lambda fd: None else: def _setCloseOnExec(fd): """ Make a file descriptor close-on-exec. """ flags = fcntl.fcntl(fd, fcntl.F_GETFD) flags = flags | fcntl.FD_CLOEXEC fcntl.fcntl(fd, fcntl.F_SETFD, flags) def _unsetCloseOnExec(fd): """ Make a file descriptor close-on-exec. """ flags = fcntl.fcntl(fd, fcntl.F_GETFD) flags = flags & ~fcntl.FD_CLOEXEC fcntl.fcntl(fd, fcntl.F_SETFD, flags) def readFromFD(fd, callback): """ Read from file descriptor, calling callback with resulting data. If successful, call 'callback' with a single argument: the resulting data. Returns same thing FileDescriptor.doRead would: CONNECTION_LOST, CONNECTION_DONE, or None. @type fd: C{int} @param fd: non-blocking file descriptor to be read from. @param callback: a callable which accepts a single argument. If data is read from the file descriptor it will be called with this data. Handling exceptions from calling the callback is up to the caller. Note that if the descriptor is still connected but no data is read, None will be returned but callback will not be called. @return: CONNECTION_LOST on error, CONNECTION_DONE when fd is closed, otherwise None. """ try: output = os.read(fd, 8192) except OSError as ioe: if ioe.args[0] in (errno.EAGAIN, errno.EINTR): return else: return CONNECTION_LOST if not output: return CONNECTION_DONE callback(output) def writeToFD(fd, data): """ Write data to file descriptor. Returns same thing FileDescriptor.writeSomeData would. @type fd: C{int} @param fd: non-blocking file descriptor to be written to. @type data: C{str} or C{buffer} @param data: bytes to write to fd. @return: number of bytes written, or CONNECTION_LOST. """ try: return os.write(fd, data) except OSError as io: if io.errno in (errno.EAGAIN, errno.EINTR): return 0 return CONNECTION_LOST __all__ = ["setNonBlocking", "setBlocking", "readFromFD", "writeToFD"] PK Mb�Z��gA� � internet/selectreactor.pynu �[��� # -*- test-case-name: twisted.test.test_internet -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Select reactor """ import select import sys from errno import EBADF, EINTR from time import sleep from typing import Type from zope.interface import implementer from twisted.internet import posixbase from twisted.internet.interfaces import IReactorFDSet from twisted.python import log from twisted.python.runtime import platformType def win32select(r, w, e, timeout=None): """Win32 select wrapper.""" if not (r or w): # windows select() exits immediately when no sockets if timeout is None: timeout = 0.01 else: timeout = min(timeout, 0.001) sleep(timeout) return [], [], [] # windows doesn't process 'signals' inside select(), so we set a max # time or ctrl-c will never be recognized if timeout is None or timeout > 0.5: timeout = 0.5 r, w, e = select.select(r, w, w, timeout) return r, w + e, [] if platformType == "win32": _select = win32select else: _select = select.select try: from twisted.internet.win32eventreactor import _ThreadedWin32EventsMixin except ImportError: _extraBase: Type[object] = object else: _extraBase = _ThreadedWin32EventsMixin @implementer(IReactorFDSet) class SelectReactor(posixbase.PosixReactorBase, _extraBase): # type: ignore[misc,valid-type] """ A select() based reactor - runs on all POSIX platforms and on Win32. @ivar _reads: A set containing L{FileDescriptor} instances which will be checked for read events. @ivar _writes: A set containing L{FileDescriptor} instances which will be checked for writability. """ def __init__(self): """ Initialize file descriptor tracking dictionaries and the base class. """ self._reads = set() self._writes = set() posixbase.PosixReactorBase.__init__(self) def _preenDescriptors(self): log.msg("Malformed file descriptor found. Preening lists.") readers = list(self._reads) writers = list(self._writes) self._reads.clear() self._writes.clear() for selSet, selList in ((self._reads, readers), (self._writes, writers)): for selectable in selList: try: select.select([selectable], [selectable], [selectable], 0) except Exception as e: log.msg("bad descriptor %s" % selectable) self._disconnectSelectable(selectable, e, False) else: selSet.add(selectable) def doSelect(self, timeout): """ Run one iteration of the I/O monitor loop. This will run all selectables who had input or output readiness waiting for them. """ try: r, w, ignored = _select(self._reads, self._writes, [], timeout) except ValueError: # Possibly a file descriptor has gone negative? self._preenDescriptors() return except TypeError: # Something *totally* invalid (object w/o fileno, non-integral # result) was passed log.err() self._preenDescriptors() return except OSError as se: # select(2) encountered an error, perhaps while calling the fileno() # method of a socket. (Python 2.6 socket.error is an IOError # subclass, but on Python 2.5 and earlier it is not.) if se.args[0] in (0, 2): # windows does this if it got an empty list if (not self._reads) and (not self._writes): return else: raise elif se.args[0] == EINTR: return elif se.args[0] == EBADF: self._preenDescriptors() return else: # OK, I really don't know what's going on. Blow up. raise _drdw = self._doReadOrWrite _logrun = log.callWithLogger for selectables, method, fdset in ( (r, "doRead", self._reads), (w, "doWrite", self._writes), ): for selectable in selectables: # if this was disconnected in another thread, kill it. # ^^^^ --- what the !@#*? serious! -exarkun if selectable not in fdset: continue # This for pausing input when we're not ready for more. _logrun(selectable, _drdw, selectable, method) doIteration = doSelect def _doReadOrWrite(self, selectable, method): try: why = getattr(selectable, method)() except BaseException: why = sys.exc_info()[1] log.err() if why: self._disconnectSelectable(selectable, why, method == "doRead") def addReader(self, reader): """ Add a FileDescriptor for notification of data available to read. """ self._reads.add(reader) def addWriter(self, writer): """ Add a FileDescriptor for notification of data available to write. """ self._writes.add(writer) def removeReader(self, reader): """ Remove a Selectable for notification of data available to read. """ self._reads.discard(reader) def removeWriter(self, writer): """ Remove a Selectable for notification of data available to write. """ self._writes.discard(writer) def removeAll(self): return self._removeAll(self._reads, self._writes) def getReaders(self): return list(self._reads) def getWriters(self): return list(self._writes) def install(): """Configure the twisted mainloop to be run using the select() reactor.""" reactor = SelectReactor() from twisted.internet.main import installReactor installReactor(reactor) __all__ = ["install"] PK Mb�Zϊ�� 1 internet/__pycache__/epollreactor.cpython-310.pycnu �[��� o �b�" � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z ze ed�Z e ed�Z e ed �Ze ed �Ze ed �ZW n eyM Z zee��dZ[ww ee�G d d � d ejej��Zdd� Zd dgZdS )z� An epoll() based implementation of the twisted main loop. To install the event loop (and you should do this before any connections, listeners or connectors are added):: from twisted.internet import epollreactor epollreactor.install() � N)� implementer)� posixbase)� IReactorFDSet)�log�epoll�EPOLLHUP�EPOLLERR�EPOLLIN�EPOLLOUTc @ s| e Zd ZdZeeB ZeZe Z dd� Z dd� Z dd� Z dd � Zd d � Zd d � Zdd� Zdd� Zdd� Zdd� Zdd� ZeZdS )� EPollReactora� A reactor that uses epoll(7). @ivar _poller: A C{epoll} which will be used to check for I/O readiness. @ivar _selectables: A dictionary mapping integer file descriptors to instances of C{FileDescriptor} which have been registered with the reactor. All C{FileDescriptors} which are currently receiving read or write readiness notifications will be present as values in this dictionary. @ivar _reads: A set containing integer file descriptors. Values in this set will be registered with C{_poller} for read readiness notifications which will be dispatched to the corresponding C{FileDescriptor} instances in C{_selectables}. @ivar _writes: A set containing integer file descriptors. Values in this set will be registered with C{_poller} for write readiness notifications which will be dispatched to the corresponding C{FileDescriptor} instances in C{_selectables}. @ivar _continuousPolling: A L{_ContinuousPolling} instance, used to handle file descriptors (e.g. filesystem files) that are not supported by C{epoll(7)}. c C s< t d�| _t� | _t� | _i | _t�| �| _tj � | � dS )zm Initialize epoll object, file descriptor tracking dictionaries, and the base class. i N) r �_poller�set�_reads�_writes� _selectablesr �_ContinuousPolling�_continuousPolling�PosixReactorBase�__init__��self� r �?/usr/lib/python3/dist-packages/twisted/internet/epollreactor.pyr G s zEPollReactor.__init__c C s\ |� � }||vr,|}||v r||O }| j�||� n| j�||� |�|� |||< dS dS )z� Private method for adding a descriptor from the event loop. It takes care of adding it if new or modifying it if already added for another state (read -> read/write for example). N)�filenor �modify�register�add) r �xer�primary�other� selectables�event� antievent�fd�flagsr r r �_addV s �zEPollReactor._addc C �d z| � || j| j| jtt� W dS ty1 } z|jtjkr%| j � |� n� W Y d}~dS d}~ww )zR Add a FileDescriptor for notification of data available to read. N) r% r r r r r �OSError�errno�EPERMr � addReader)r �reader�er r r r* p � � ���zEPollReactor.addReaderc C r& )zS Add a FileDescriptor for notification of data available to write. N) r% r r r r r r' r( r) r � addWriter)r �writerr, r r r r. � r- zEPollReactor.addWriterc C sz |� � }|dkr|�� D ] \}}||u r nq dS ||v r;||v r+|} | j�|| � n ||= | j�|� |�|� dS dS )z� Private method for removing a descriptor from the event loop. It does the inverse job of _add, and also add a check in case of the fd has gone away. ���N)r �itemsr r � unregister�remove) r r r r r r! r" r# �fdesr$ r r r �_remove� s � �zEPollReactor._removec C �: | j �|�r| j �|� dS | �|| j| j| jtt� dS )zQ Remove a Selectable for notification of data available to read. N) r � isReading� removeReaderr5 r r r r r )r r+ r r r r8 � � �zEPollReactor.removeReaderc C r6 )zR Remove a Selectable for notification of data available to write. N) r � isWriting� removeWriterr5 r r r r r )r r/ r r r r; � r9 zEPollReactor.removeWriterc s6 � � � fdd�� jD �� fdd�� jD ��� j�� S )zD Remove all selectables, and return a list of them. c � g | ]}� j | �qS r �r ��.0r# r r r � <listcomp>� � z*EPollReactor.removeAll.<locals>.<listcomp>c r< r r= r> r r r r@ � rA )� _removeAllr r r � removeAllr r r r rC � s ���zEPollReactor.removeAllc � � fdd�� j D �� j�� S )Nc r< r r= r> r r r r@ � � �z+EPollReactor.getReaders.<locals>.<listcomp>)r r � getReadersr r r r rF � � ��zEPollReactor.getReadersc rD )Nc r< r r= r> r r r r@ � rE z+EPollReactor.getWriters.<locals>.<listcomp>)r r � getWritersr r r r rH � rG zEPollReactor.getWritersc C s� |du rd}z | j �|t| j��}W n ty, } z|jtjkr'W Y d}~dS � d}~ww | j}|D ] \}}z| j| }W n tyF Y q2w t � |||||� q2dS )z1 Poll the poller for new events. Nr0 ) r �poll�lenr r' r( �EINTR�_doReadOrWrite�KeyErrorr �callWithLogger)r �timeout�l�err�_drdwr# r! � selectabler r r �doPoll� s& �� ��zEPollReactor.doPollN)�__name__� __module__� __qualname__�__doc__r r �_POLL_DISCONNECTEDr �_POLL_INr � _POLL_OUTr r% r* r. r5 r8 r; rC rF rH rT � doIterationr r r r r % s" r c C s t � } ddlm} || � dS )z& Install the epoll() reactor. r )�installReactorN)r �twisted.internet.mainr] )�pr] r r r �install� s r` )rX r( �select�zope.interfacer �twisted.internetr �twisted.internet.interfacesr �twisted.pythonr �getattrr r r r r �AttributeErrorr, � ImportErrorr �_PollLikeMixinr r` �__all__r r r r �<module> s, �� T PK Mb�Z�b�'�w �w - internet/__pycache__/protocol.cpython-310.pycnu �[��� o �b�j � @ s� d Z ddlZddlmZmZ ddlmZ ddlmZm Z m Z ddl m Z m Z ddlmZ ddlmZmZmZ ee je j�G d d � d ��ZG d d � d e�ZG d d� de�ZG dd� d�ZG dd� de�ZG dd� de�ZG dd� d�Z e� e � � �Z e � � ee j!e j�G dd� de ��Z"ee j#�G dd� dej$��Z%e�&e%e j!e j#� ee j!�G dd � d ej$��Z'e�&e'e j#e j!� ee j(�G d d � d e ��Z)G d d � d �Z*ee j�G d!d"� d"e*��Z+G d#d$� d$e+�Z,ee j �G d%d&� d&��Z-g d'�Z.dS )(z� Standard implementations of Twisted protocol-related interfaces. Start here if you are looking to write a new protocol implementation for Twisted. The Protocol class contains some introductory material. � N)�Callable�Optional)� implementer)�defer�error� interfaces)�IAddress� ITransport)� _loggerFor)� components�failure�logc @ sl e Zd ZU dZdZded< dZdZedd� �Z d d � Z d d � Z d d� Z dd� Z dd� Zdeddfdd�ZdS )�Factoryz� This is a factory which produces protocols. By default, buildProtocol will create a protocol of the class given in self.protocol. Nz Optional[Callable[[], Protocol]]�protocolr Tc O s | |i |��}||_ |S )a� Create a factory for the given protocol. It sets the C{protocol} attribute and returns the constructed factory instance. @param protocol: A L{Protocol} subclass @param args: Positional arguments for the factory. @param kwargs: Keyword arguments for the factory. @return: A L{Factory} instance wired up to C{protocol}. )r )�clsr �args�kwargs�factory� r �;/usr/lib/python3/dist-packages/twisted/internet/protocol.py� forProtocol& s zFactory.forProtocolc C � | j jS )z9 Describe this factory for log messages. �� __class__�__name__��selfr r r � logPrefix: s zFactory.logPrefixc C s6 | j s| jrt| �jd| d� | �� | j d | _ dS )zl Make sure startFactory is called. Users should not call this function themselves! z Starting factory {factory!r}�r � N)�numPorts�noisyr �info� startFactoryr r r r �doStart@ s zFactory.doStartc C sH | j dkrdS | j d | _ | j s"| jr t| �jd| d� | �� dS dS )zk Make sure stopFactory is called. Users should not call this function themselves! r Nr z Stopping factory {factory!r}r )r r! r r" � stopFactoryr r r r �doStopL s �zFactory.doStopc C � dS )ay This will be called before I begin listening on a Port or Connector. It will only be called once, even if the factory is connected to multiple ports. This can be used to perform 'unserialization' tasks that are best put off until things are actually running, such as connecting to a database, opening files, etcetera. Nr r r r r r# \ � zFactory.startFactoryc C r' )a� This will be called before I stop listening on all Ports/Connectors. This can be overridden to perform 'shutdown' tasks such as disconnecting database connections, closing files, etc. It will be called, for example, before an application shuts down, if it was connected to a port. User code should not call this function directly. Nr r r r r r% h r( zFactory.stopFactory�addr�returnzOptional[Protocol]c C s | j dusJ �| � � }| |_|S )a� Create an instance of a subclass of Protocol. The returned instance will handle input on an incoming server connection, and an attribute "factory" pointing to the creating factory. Alternatively, L{None} may be returned to immediately close the new connection. Override this method to alter how Protocol instances get created. @param addr: an object implementing L{IAddress} N)r r )r r) �pr r r � buildProtocolt s zFactory.buildProtocol)r � __module__� __qualname__�__doc__r �__annotations__r r! � classmethodr r r$ r& r# r% r r, r r r r r s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � ClientFactoryz} A Protocol factory for clients. This can be used together with the various connectXXX methods in reactors. c C r' )z� Called when a connection has been started. You can call connector.stopConnecting() to stop the connection attempt. @param connector: a Connector object. Nr )r � connectorr r r �startedConnecting� r( z ClientFactory.startedConnectingc C r' )z� Called when a connection has failed to connect. It may be useful to call connector.connect() - this will reconnect. @type reason: L{twisted.python.failure.Failure} Nr �r r3 �reasonr r r �clientConnectionFailed� r( z$ClientFactory.clientConnectionFailedc C r' )z� Called when an established connection is lost. It may be useful to call connector.connect() - this will reconnect. @type reason: L{twisted.python.failure.Failure} Nr r5 r r r �clientConnectionLost� r( z"ClientFactory.clientConnectionLostN)r r- r. r/ r4 r7 r8 r r r r r2 � s r2 c @ sF e Zd ZdZdZdZdd� Zdefdd�Zd d � Z d d � Z d d� Z dS )�_InstanceFactoryaP Factory used by ClientCreator. @ivar deferred: The L{Deferred} which represents this connection attempt and which will be fired when it succeeds or fails. @ivar pending: After a connection attempt succeeds or fails, a delayed call which will fire the L{Deferred} representing this connection attempt. FNc C s || _ || _|| _d S �N)�reactor�instance�deferred)r r; r< r= r r r �__init__� s z_InstanceFactory.__init__r* c C s d| j �d�S )Nz<ClientCreator factory: �>)r< r r r r �__repr__� s z_InstanceFactory.__repr__c C s( | j �d| j| jj| j�| _d| _| jS )z� Return the pre-constructed protocol instance and arrange to fire the waiting L{Deferred} to indicate success establishing the connection. r N)r; � callLater�firer= �callbackr< �pending)r r) r r r r, � s �z _InstanceFactory.buildProtocolc C s$ | j �d| j| jj|�| _d| _dS )z� Arrange to fire the waiting L{Deferred} with the given failure to indicate the connection could not be established. r N)r; rA rB r= �errbackrD r5 r r r r7 � s � z'_InstanceFactory.clientConnectionFailedc C s d| _ ||� dS )zo Clear C{self.pending} to avoid a reference cycle and then invoke func with the value. N)rD )r �func�valuer r r rB � s z_InstanceFactory.fire) r r- r. r/ r! rD r> �strr@ r, r7 rB r r r r r9 � s r9 c @ s> e Zd ZdZdd� Zdd� Zddd �Zdd d �Zdd d�ZdS )� ClientCreatora� Client connections that do not require a factory. The various connect* methods create a protocol instance using the given protocol class and arguments, and connect it, returning a Deferred of the resulting protocol instance. Useful for cases when we don't really need a factory. Mainly this is when there is no shared state between protocol instances, and no need to reconnect. The C{connectTCP}, C{connectUNIX}, and C{connectSSL} methods each return a L{Deferred} which will fire with an instance of the protocol class passed to L{ClientCreator.__init__}. These Deferred can be cancelled to abort the connection attempt (in a very unlikely case, cancelling the Deferred may not prevent the protocol from being instantiated and connected to a transport; if this happens, it will be disconnected immediately afterwards and the Deferred will still errback with L{CancelledError}). c O s || _ || _|| _|| _d S r: )r; � protocolClassr r )r r; rJ r r r r r r> � s zClientCreator.__init__c sL � �fdd�}t �|�}t| j| j| ji | j��|��||d�i|��� |S )a0 Initiate a connection attempt. @param method: A callable which will actually start the connection attempt. For example, C{reactor.connectTCP}. @param args: Positional arguments to pass to C{method}, excluding the factory. @param kwargs: Keyword arguments to pass to C{method}. @return: A L{Deferred} which fires with an instance of the protocol class passed to this L{ClientCreator}'s initializer or fails if the connection cannot be set up for some reason. c s$ � � � �jd ur�j�� d S d S r: )� disconnectrD �cancel)r= �r3 �fr r � cancelConnect s �z-ClientCreator._connect.<locals>.cancelConnectr )r �Deferredr9 r; rJ r r )r �methodr r rO �dr rM r �_connect� s �zClientCreator._connect� Nc C s | j | jj||||d�S )a Connect to a TCP server. The parameters are all the same as to L{IReactorTCP.connectTCP} except that the factory parameter is omitted. @return: A L{Deferred} which fires with an instance of the protocol class passed to this L{ClientCreator}'s initializer or fails if the connection cannot be set up for some reason. )�timeout� bindAddress)rS r; � connectTCP)r �host�portrU rV r r r rW s �zClientCreator.connectTCPFc C s | j | jj|||d�S )a� Connect to a Unix socket. The parameters are all the same as to L{IReactorUNIX.connectUNIX} except that the factory parameter is omitted. @return: A L{Deferred} which fires with an instance of the protocol class passed to this L{ClientCreator}'s initializer or fails if the connection cannot be set up for some reason. )rU �checkPID)rS r; � connectUNIX)r �addressrU rZ r r r r[ , s �zClientCreator.connectUNIXc C s | j | jj|||||d�S )a� Connect to an SSL server. The parameters are all the same as to L{IReactorSSL.connectSSL} except that the factory parameter is omitted. @return: A L{Deferred} which fires with an instance of the protocol class passed to this L{ClientCreator}'s initializer or fails if the connection cannot be set up for some reason. )�contextFactoryrU rV )rS r; � connectSSL)r rX rY r] rU rV r r r r^ ; s �zClientCreator.connectSSL)rT N)rT F) r r- r. r/ r> rS rW r[ r^ r r r r rI � s rI c @ sn e Zd ZdZdZdZdZdZeZdZ dZ dZ dZ dZ dZd d � Zd d � Zdd d�Zdd� Zdd� Zdd� ZdS )�ReconnectingClientFactorya� Factory which auto-reconnects clients with an exponential back-off. Note that clients should call my resetDelay method after they have connected successfully. @ivar maxDelay: Maximum number of seconds between connection attempts. @ivar initialDelay: Delay for the first reconnection attempt. @ivar factor: A multiplicitive factor by which the delay grows @ivar jitter: Percentage of randomness to introduce into the delay length to prevent stampeding. @ivar clock: The clock used to schedule reconnection. It's mainly useful to be parametrized in tests. If the factory is serialized, this attribute will not be serialized, and the default value (the reactor) will be restored when deserialized. @type clock: L{IReactorTime} @ivar maxRetries: Maximum number of consecutive unsuccessful connection attempts, after which no further connection attempts will be made. If this is not explicitly set, no maximum is applied. i g �?giW� �@g6Q�؟�?r Nr c C � | j r || _| �� d S d S r: ��continueTryingr3 �retryr5 r r r r7 ~ � �z0ReconnectingClientFactory.clientConnectionFailedc C r` r: ra )r r3 � unused_reasonr r r r8 � rd z.ReconnectingClientFactory.clientConnectionLostc s �j s�jrt�d� � d�� dS � du r!�jdu r td���j� � jd7 _�jdurB�j�jkrB�jr@t�d� �jf � dS t�j �j �j ��_ �j r\t ��j �j �j ��_ �jrit�d� �j f � � �fdd �}�jdu r~d d lm} |�_�j��j |��_dS ) zL Have this connector connect again, after a suitable delay. z Abandoning z on explicit requestNzno connector to retryr z Abandoning %s after %d retries.z%s will retry in %d secondsc s d �_ � �� d S r: )�_callID�connectr �r3 r r r � reconnector� s z4ReconnectingClientFactory.retry.<locals>.reconnectorr )r; )rb r! r �msgr3 � ValueError�retries� maxRetries�min�delay�factor�maxDelay�jitter�random� normalvariate�clock�twisted.internetr; rA rf )r r3 ri r; r rh r rc � s: ��� z ReconnectingClientFactory.retryc C sN | j r | j �� d| _ d| _| jr%z| j�� W dS tjy$ Y dS w dS )zE Put a stop to any attempt to reconnect in progress. Nr )rf rL rb r3 �stopConnectingr �NotConnectingErrorr r r r � stopTrying� s ��z$ReconnectingClientFactory.stopTryingc C s | j | _d| _d| _d| _dS )zt Call this method after a successful connection: it resets the delay and the retry counter. r Nr )� initialDelayro rl rf rb r r r r � resetDelay� s z$ReconnectingClientFactory.resetDelayc C s& | j �� }dD ] }||v r||= q|S )a- Remove all of the state which is mutated by connection attempts and failures, returning just the state which describes how reconnections should be attempted. This will make the unserialized instance behave just as this one did when it was first instantiated. )r3 rl ro rb rf ru ��__dict__�copy)r �state�keyr r r � __getstate__� s �z&ReconnectingClientFactory.__getstate__r: )r r- r. r/ rq rz rp rr ro rl rm rf r3 ru rb r7 r8 rc ry r{ r� r r r r r_ P s& , r_ c @ s e Zd ZdZdS )� ServerFactoryzZ Subclass this to indicate that your protocol.Factory is only usable for servers. N)r r- r. r/ r r r r r� � s r� c @ s6 e Zd ZU dZdZdZee ed< dd� Z dd� Z dS ) � BaseProtocola This is the abstract superclass of all protocols. Some methods have helpful default implementations here so that they can easily be shared, but otherwise the direct subclasses of this class are more interesting, L{Protocol} and L{ProcessProtocol}. r N� transportc C s d| _ || _| �� dS )z� Make a connection to a transport and a server. This sets the 'transport' attribute of this Protocol, and calls the connectionMade() callback. r N)� connectedr� �connectionMade�r r� r r r �makeConnection� s zBaseProtocol.makeConnectionc C r' )a� Called when a connection is made. This may be considered the initializer of the protocol, because it is called when the connection is completed. For clients, this is called once the connection to the server has been established; for servers, this is called after an accept() call stops blocking and a socket has been received. If you need to send any greeting or initial message, do it here. Nr r r r r r� � r( zBaseProtocol.connectionMade) r r- r. r/ r� r� r r r0 r� r� r r r r r� � s r� c @ sL e Zd ZU dZdZee ed< dd� Zde fdd�Z e fd e j fd d �ZdS ) �Protocola� This is the base class for streaming connection-oriented protocols. If you are going to write a new connection-oriented protocol for Twisted, start here. Any protocol implementation, either client or server, should be a subclass of this class. The API is quite simple. Implement L{dataReceived} to handle both event-based and synchronous input; output can be sent through the 'transport' attribute, which is to be an instance that implements L{twisted.internet.interfaces.ITransport}. Override C{connectionLost} to be notified when the connection ends. Some subclasses exist already to help you write common types of protocols: see the L{twisted.protocols.basic} module for a few of them. Nr c C r �z~ Return a prefix matching the class name, to identify log messages related to this protocol instance. r r r r r r % � zProtocol.logPrefix�datac C r' )aF Called whenever data is received. Use this method to translate to a higher-level message. Usually, some callback will be made upon the receipt of each complete protocol message. @param data: a string of indeterminate length. Please keep in mind that you will probably need to buffer some data, as partial (or multiple) protocol messages may be received! I recommend that unit tests for protocols call through to this method with differing chunk sizes, down to one byte at a time. Nr �r r� r r r � dataReceived, r( zProtocol.dataReceivedr6 c C r' )z� Called when the connection is shut down. Clear any circular references here, and any external references to this Protocol. The connection has been closed. @type reason: L{twisted.python.failure.Failure} Nr �r r6 r r r �connectionLost; r( zProtocol.connectionLost)r r- r. r/ r r r r0 r �bytesr� �connectionDoner �Failurer� r r r r r� s r� c @ s* e Zd Zdefdd�Zdd� Zdd� ZdS ) �ProtocolToConsumerAdapterr� c C � | j �|� d S r: )�originalr� r� r r r �writeH � z ProtocolToConsumerAdapter.writec C � d S r: r �r �producer� streamingr r r �registerProducerK � z*ProtocolToConsumerAdapter.registerProducerc C r� r: r r r r r �unregisterProducerN r� z,ProtocolToConsumerAdapter.unregisterProducerN)r r- r. r� r� r� r� r r r r r� F s r� c @ s: e Zd Zdefdd�Zdejfdd�Zdd� Zd d � Z d S ) �ConsumerToProtocolAdapterr� c C r� r: )r� r� r� r r r r� Y r� z&ConsumerToProtocolAdapter.dataReceivedr6 c C r� r: r r� r r r r� \ r� z(ConsumerToProtocolAdapter.connectionLostc C r� r: r r� r r r r� _ r� z(ConsumerToProtocolAdapter.makeConnectionc C r� r: r r r r r r� b r� z(ConsumerToProtocolAdapter.connectionMadeN) r r- r. r� r� r r� r� r� r� r r r r r� W s r� c @ s� e Zd ZdZdedefdd�Zdefdd�Zdefdd �Zdefd d �Z d d � Z dd� Z dd� Z de jfdd�Zde jfdd�ZdS )�ProcessProtocolz� Base process protocol implementation which does simple dispatching for stdin, stdout, and stderr file descriptors. �childFDr� c C s0 |dkr | � |� d S |dkr| �|� d S d S )Nr � )� outReceived� errReceived)r r� r� r r r �childDataReceivedr s �z!ProcessProtocol.childDataReceivedc C r' )z5 Some data was received from stdout. Nr r� r r r r� x r( zProcessProtocol.outReceivedc C r' )z5 Some data was received from stderr. Nr r� r r r r� } r( zProcessProtocol.errReceivedc C s@ |dkr | � � d S |dkr| �� d S |dkr | �� d S d S )Nr r r� )�inConnectionLost�outConnectionLost�errConnectionLost)r r� r r r �childConnectionLost� s �z#ProcessProtocol.childConnectionLostc C r' )z; This will be called when stdin is closed. Nr r r r r r� � r( z ProcessProtocol.inConnectionLostc C r' )z< This will be called when stdout is closed. Nr r r r r r� � r( z!ProcessProtocol.outConnectionLostc C r' )z< This will be called when stderr is closed. Nr r r r r r� � r( z!ProcessProtocol.errConnectionLostr6 c C r' )zy This will be called when the subprocess exits. @type reason: L{twisted.python.failure.Failure} Nr r� r r r � processExited� r( z ProcessProtocol.processExitedc C r' )z� Called when the child process exits and all file descriptors associated with it have been closed. @type reason: L{twisted.python.failure.Failure} Nr r� r r r � processEnded� r( z ProcessProtocol.processEndedN)r r- r. r/ �intr� r� r� r� r� r� r� r� r r� r� r� r r r r r� k s r� c @ sZ e Zd ZdZdZdZdZdd� Zdd� Zd d � Z d d � Z d d� Z dd� Z de fdd�ZdS )�AbstractDatagramProtocolzZ Abstract protocol for datagram-oriented transports, e.g. IP, ICMP, ARP, UDP. Nr Tc C s | j �� }d |d< |S )Nr� r| )r rR r r r r� � s z%AbstractDatagramProtocol.__getstate__c C s2 | j s| jr t�d| � | �� | j d | _ dS )z� Make sure startProtocol is called. This will be called by makeConnection(), users should not call it. zStarting protocol %sr N)r r! r rj � startProtocolr r r r r$ � s z AbstractDatagramProtocol.doStartc C sJ | j dksJ �| j d | _ d| _| j s#| jr t�d| � | �� dS dS )zw Make sure stopProtocol is called. This will be called by the port, users should not call it. r r NzStopping protocol %s)r r� r! r rj � stopProtocolr r r r r& � s �z AbstractDatagramProtocol.doStopc C r' )z� Called when a transport is connected to this protocol. Will only be called once, even if multiple ports are connected. Nr r r r r r� � r( z&AbstractDatagramProtocol.startProtocolc C r' )z� Called when the transport is disconnected. Will only be called once, after all ports are disconnected. Nr r r r r r� � r( z%AbstractDatagramProtocol.stopProtocolc C s | j dksJ �|| _ | �� dS )z� Make a connection to a transport and a server. This sets the 'transport' attribute of this DatagramProtocol, and calls the doStart() callback. N)r� r$ r� r r r r� � s z'AbstractDatagramProtocol.makeConnection�datagramc C r' )z� Called when a datagram is received. @param datagram: the bytes received from the transport. @param addr: tuple of source of datagram. Nr )r r� r) r r r �datagramReceived� r( z)AbstractDatagramProtocol.datagramReceived)r r- r. r/ r� r r! r� r$ r& r� r� r� r� r� r r r r r� � s r� c @ s e Zd ZdZdd� Zdd� ZdS )�DatagramProtocola Protocol for datagram-oriented transport, e.g. UDP. @type transport: L{None} or L{IUDPTransport<twisted.internet.interfaces.IUDPTransport>} provider @ivar transport: The transport with which this protocol is associated, if it is associated with one. c C r r� r r r r r r � r� zDatagramProtocol.logPrefixc C r' )z� Called due to error from write in connected mode. Note this is a result of ICMP message generated by *previous* write. Nr r r r r �connectionRefused r( z"DatagramProtocol.connectionRefusedN)r r- r. r/ r r� r r r r r� � s r� c @ s( e Zd ZdZdd� Zdejfdd�ZdS )�ConnectedDatagramProtocolz_ Protocol for connected datagram-oriented transport. No longer necessary for UDP. c C r' )zw Called when a datagram is received. @param datagram: the string received from the transport. Nr )r r� r r r r� r( z*ConnectedDatagramProtocol.datagramReceivedr c C r' )zi Called if connecting failed. Usually this will be due to a DNS lookup failure. Nr )r r r r r �connectionFailed r( z*ConnectedDatagramProtocol.connectionFailedN)r r- r. r/ r� r r� r� r r r r r� s r� c @ s� e Zd ZdZdZdZdZdZdd� Zde fdd�Z d d � Z d d � Z d d� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � ZdS )!� FileWrapperz� A wrapper around a file-like object to make it behave as a Transport. This doesn't actually stream the file to the attached protocol, and is thus useful mainly as a utility for debugging protocols. r Nc C s || _ d S r: )�file)r r� r r r r> 3 � zFileWrapper.__init__r� c C s0 z | j �|� W d S ty | �� Y d S w r: )r� r� � BaseException�handleExceptionr� r r r r� 6 s �zFileWrapper.writec C s | j r | j �� d S d S r: )r� �resumeProducingr r r r �_checkProducer< s �zFileWrapper._checkProducerc C s || _ || _|s|�� dS dS )z. From abstract.FileDescriptor N)r� �streamingProducerr� r� r r r r� B s �z FileWrapper.registerProducerc C s d | _ d S r: )r� r r r r r� K r� z FileWrapper.unregisterProducerc C s | � � | �� d S r: )r� �loseConnectionr r r r � stopConsumingN s zFileWrapper.stopConsumingc C s | � d�|�� d S )N� )r� �join)r �iovecr r r � writeSequenceR s zFileWrapper.writeSequencec C s4 d| _ z| j�� W d S ty | �� Y d S w )Nr )�closedr� �close�OSErrorr� r r r r r� U s �zFileWrapper.loseConnectionc C r' )N)r� r� r r r r r �getPeer\ � zFileWrapper.getPeerc C r' )Nr� r r r r r �getHosta r� zFileWrapper.getHostc C r� r: r r r r r r� f r� zFileWrapper.handleExceptionc C r� r: r r r r r r� i � zFileWrapper.resumeProducingc C r� r: r r r r r �pauseProducingm r� zFileWrapper.pauseProducingc C s | � � d S r: )r� r r r r � stopProducingq s zFileWrapper.stopProducing)r r- r. r/ r� � disconnectingr� r� r> r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� % s( r� ) r r2 r_ r� r� r� r� r� r� r� r� rI )/r/ rs �typingr r �zope.interfacer rv r r r �twisted.internet.interfacesr r �twisted.loggerr �twisted.pythonr r r �IProtocolFactory�ILoggingContextr r2 r9 rI r_ r� r� r� �ConnectionDoner� � cleanFailure� IProtocolr� � IConsumer�Adapterr� �registerAdapterr� �IProcessProtocolr� r� r� r� r� �__all__r r r r �<module> sP p$4o $ 5 � �=K OPK Mb�Z��C� C� , internet/__pycache__/testing.cpython-310.pycnu �[��� o �b0r � @ sL d Z ddlmZ ddlmZ ddlmZmZ ddlm Z m Z ddl m Z m Z ddlmZ ddlmZmZmZmZ dd lmZmZ dd lmZmZmZ dd l m Z dd l m Z dd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2 ddl3m4Z4 g d�Z5G dd� dej6�Z7G dd� de2j8�Z9G dd� d�Z:e e,e"e%�G dd� d��Z;G dd � d e;�Z<G d d � d e�Z=e e#�G d d � d ��Z>e e!�G d!d"� d"��Z?e e&e*e)e+e(e'�G d#d$� d$��Z@e e@�D ]ZAeeAe@� q�G d%d&� d&e@e.�ZBe e*e)e+e(�G d'd(� d(��ZCG d)d*� d*�ZDd+d,� ZEe e0�G d-d.� d.e��ZFd/S )0zJ Assorted functionality which is commonly useful when writing unit tests. � )�Sequence)�BytesIO)�AF_INET�AF_INET6)�Any�Callable)� implementedBy� implementer)� verifyClass)�address�error�protocol�task)�_dataMustBeBytes� isIPv6Address)� IPv4Address� IPv6Address� UNIXAddress)�Deferred)�UnsupportedAddressFamily) � IConnector� IConsumer�IListeningPort� IProtocol� IPushProducer� IReactorCore� IReactorFDSet�IReactorSocket� IReactorSSL� IReactorTCP� IReactorUNIX� ITransport)�Clock)� ILogObserver)�basic)�failure)�AccumulatingProtocol�LineSendingProtocol�FakeDatagramTransport�StringTransport� StringTransportWithDisconnection�StringIOWithoutClosing�_FakeConnector� _FakePort� MemoryReactor�MemoryReactorClock�RaisingMemoryReactor�NonStreamingProducer�waitUntilAllDisconnected�EventLoggingObserverc @ s@ e Zd ZdZd ZZdZdZdZdZ dd� Z dd� Z d d � Z dS ) r& ad L{AccumulatingProtocol} is an L{IProtocol} implementation which collects the data delivered to it and can fire a Deferred when it is connected or disconnected. @ivar made: A flag indicating whether C{connectionMade} has been called. @ivar data: Bytes giving all the data passed to C{dataReceived}. @ivar closed: A flag indicated whether C{connectionLost} has been called. @ivar closedReason: The value of the I{reason} parameter passed to C{connectionLost}. @ivar closedDeferred: If set to a L{Deferred}, this will be fired when C{connectionLost} is called. r N� c C sB d| _ | jd ur | jjd ur | jj}d | j_|�| � d S d S d S �N� )�made�factory�protocolConnectionMade�callback��self�d� r> �:/usr/lib/python3/dist-packages/twisted/internet/testing.py�connectionMadeT s �z#AccumulatingProtocol.connectionMadec C s | j |7 _ d S �N)�data�r< rB r> r> r? � dataReceived[ s z!AccumulatingProtocol.dataReceivedc C s6 d| _ || _| jd ur| jd }| _|�d � d S d S r5 )�closed� closedReason�closedDeferredr: )r< �reasonr= r> r> r? �connectionLost^ s �z#AccumulatingProtocol.connectionLost) �__name__� __module__� __qualname__�__doc__r7 rE rF rG rB r8 r@ rD rI r> r> r> r? r& < s r& c @ s2 e Zd ZdZd dd�Zdd� Zdd� Zd d � Zd S ) r' FTc C s |d d � | _ g | _|| _d S rA )�lines�response�start)r< rN rP r> r> r? �__init__i s z LineSendingProtocol.__init__c C s$ | j r| jD ] }| �|� qd S d S rA )rP rN �sendLine�r< �liner> r> r? r@ n s �z"LineSendingProtocol.connectionMadec C s2 | j s| jD ]}| �|� qg | _| j�|� d S rA )rP rN rR rO �appendrS r> r> r? � lineReceiveds s z LineSendingProtocol.lineReceivedc C � d| _ d S �NT)�lostConn)r< rH r> r> r? rI z � z"LineSendingProtocol.connectionLostN)T)rJ rK rL rY rQ r@ rV rI r> r> r> r? r' f s r' c @ s& e Zd Ze� Zdd� Zefdd�ZdS )r( c C � g | _ d S rA )�written�r< r> r> r? rQ � rZ z FakeDatagramTransport.__init__c C s | j �||f� d S rA )r\ rU )r< �packet�addrr> r> r? �write� s zFakeDatagramTransport.writeN)rJ rK rL �object�noAddrrQ r` r> r> r> r? r( ~ s r( c @ s� e Zd ZdZdZdZdZdZdZdZ dZ d#dd�Z dd� Z d d � Z d d � Zd d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� ZdS )$r) a� A transport implementation which buffers data in memory and keeps track of its other state without providing any behavior. L{StringTransport} has a number of attributes which are not part of any of the interfaces it claims to implement. These attributes are provided for testing purposes. Implementation code should not use any of these attributes; they are not provided by other transports. @ivar disconnecting: A C{bool} which is C{False} until L{loseConnection} is called, then C{True}. @ivar disconnected: A C{bool} which is C{False} until L{abortConnection} is called, then C{True}. @ivar producer: If a producer is currently registered, C{producer} is a reference to it. Otherwise, L{None}. @ivar streaming: If a producer is currently registered, C{streaming} refers to the value of the second parameter passed to C{registerProducer}. @ivar hostAddr: L{None} or an object which will be returned as the host address of this transport. If L{None}, a nasty tuple will be returned instead. @ivar peerAddr: L{None} or an object which will be returned as the peer address of this transport. If L{None}, a nasty tuple will be returned instead. @ivar producerState: The state of this L{StringTransport} in its capacity as an L{IPushProducer}. One of C{'producing'}, C{'paused'}, or C{'stopped'}. @ivar io: A L{io.BytesIO} which holds the data which has been written to this transport since the last call to L{clear}. Use L{value} instead of accessing this directly. @ivar _lenient: By default L{StringTransport} enforces that L{resumeProducing} is not called after the connection is lost. This is to ensure that any code that does call L{resumeProducing} after the connection is lost is not blindly expecting L{resumeProducing} to have any impact. However, if your test case is calling L{resumeProducing} after connection close on purpose, and you know it won't block expecting further data to show up, this flag may safely be set to L{True}. Defaults to L{False}. @type lenient: L{bool} FN� producingc C s4 | � � |d ur || _|d ur|| _d| _|| _d S rX )�clear�hostAddr�peerAddr� connected�_lenient)r< � hostAddress� peerAddress�lenientr> r> r? rQ � s zStringTransport.__init__c C s t � | _dS )z� Discard all data written to this transport so far. This is not a transport method. It is intended for tests. Do not use it in implementation code. N)r �ior] r> r> r? rd � s zStringTransport.clearc C s | j �� S )aN Retrieve all data which has been buffered by this transport. This is not a transport method. It is intended for tests. Do not use it in implementation code. @return: A C{bytes} giving all data written to this transport since the last call to L{clear}. @rtype: C{bytes} )rl �getvaluer] r> r> r? �value� s zStringTransport.valuec C s t |� | j�|� d S rA )r rl r` rC r> r> r? r` � s zStringTransport.writec C s | j �d�|�� d S )Nr4 )rl r` �joinrC r> r> r? � writeSequence� s z StringTransport.writeSequencec C � d| _ dS )z~ Close the connection. Does nothing besides toggle the C{disconnecting} instance variable to C{True}. TN)� disconnectingr] r> r> r? �loseConnection� � z StringTransport.loseConnectionc C � d| _ | �� dS )z� Abort the connection. Same as C{loseConnection}, but also toggles the C{aborted} instance variable to C{True}. TN)� disconnectedrs r] r> r> r? �abortConnection� s z StringTransport.abortConnectionc C � | j d u r t�ddd�S | j S )N�TCPz 192.168.1.1i1� )rf r r r] r> r> r? �getPeer� � zStringTransport.getPeerc C rx )Nry z10.0.0.1i90 )re r r r] r> r> r? �getHost r{ zStringTransport.getHostc C s" | j d ur td��|| _ || _d S )Nz Cannot register two producers��producer� RuntimeError� streaming)r< r~ r� r> r> r? �registerProducer � z StringTransport.registerProducerc C s" | j d u r td��d | _ d | _d S )Nz5Cannot unregister a producer unless one is registeredr} r] r> r> r? �unregisterProducer r� z"StringTransport.unregisterProducerc C s* | j r | js td��| jdkrtd��d S )Nz,Cannot resume producing after loseConnection�stoppedz Cannot resume a stopped producer)rr rh r � producerStater] r> r> r? � _checkState s �zStringTransport._checkStatec C � | � � d| _d S )N�paused�r� r� r] r> r> r? �pauseProducing � z StringTransport.pauseProducingc C rW )Nr� )r� r] r> r> r? � stopProducing rZ z StringTransport.stopProducingc C r� )Nrc r� r] r> r> r? �resumeProducing# r� z StringTransport.resumeProducing)NNF)rJ rK rL rM rr rv r~ r� re rf r� rQ rd rn r` rp rs rw rz r| r� r� r� r� r� r� r> r> r> r? r) � s0 3 r) c @ s" e Zd ZU dZeed< dd� ZdS )r* zt A L{StringTransport} which on disconnection will trigger the connection lost on the attached protocol. r c C s, | j rd| _ | j�t�t�d��� d S d S )NFzBye.)rg r rI r% �Failurer �ConnectionDoner] r> r> r? rs 0 s �z/StringTransportWithDisconnection.loseConnectionN)rJ rK rL rM r �__annotations__rs r> r> r> r? r* ( s r* c @ s e Zd ZdZdd� ZdS )r+ z) A BytesIO that can't be closed. c C � dS )z Do nothing. Nr> r] r> r> r? �close; � z StringIOWithoutClosing.closeN)rJ rK rL rM r� r> r> r> r? r+ 6 s r+ c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) r- z� A fake L{IListeningPort} to be used in tests. @ivar _hostAddress: The L{IAddress} this L{IListeningPort} is pretending to be listening on. c C � || _ dS )zz @param hostAddress: An L{IAddress} this L{IListeningPort} should pretend to be listening on. N�� _hostAddress)r< ri r> r> r? rQ J rt z_FakePort.__init__c C r� )zQ Fake L{IListeningPort.startListening} that doesn't do anything. Nr> r] r> r> r? �startListeningQ r� z_FakePort.startListeningc C r� )zP Fake L{IListeningPort.stopListening} that doesn't do anything. Nr> r] r> r> r? � stopListeningV r� z_FakePort.stopListeningc C � | j S )zN Fake L{IListeningPort.getHost} that returns our L{IAddress}. r� r] r> r> r? r| [ � z_FakePort.getHostN)rJ rK rL rM rQ r� r� r| r> r> r> r? r- A s r- c @ s@ e Zd ZdZdZdZdd� Zdd� Zdd� Zd d � Z d d � Z d S )r, a' A fake L{IConnector} that allows us to inspect if it has been told to stop connecting. @ivar stoppedConnecting: has this connector's L{_FakeConnector.stopConnecting} method been invoked yet? @ivar _address: An L{IAddress} provider that represents our destination. Fc C r� )zs @param address: An L{IAddress} provider that represents this connector's destination. N��_address)r< r r> r> r? rQ q rt z_FakeConnector.__init__c C rq )zw Implement L{IConnector.stopConnecting} and set L{_FakeConnector.stoppedConnecting} to C{True} TN)�stoppedConnectingr] r> r> r? �stopConnectingx rt z _FakeConnector.stopConnectingc C rq )z@ Implement L{IConnector.disconnect} as a no-op. TN)� _disconnectedr] r> r> r? � disconnect � z_FakeConnector.disconnectc C r� )z= Implement L{IConnector.connect} as a no-op. Nr> r] r> r> r? �connect� r� z_FakeConnector.connectc C r� )zp Implement L{IConnector.getDestination} to return the C{address} passed to C{__init__}. r� r] r> r> r? �getDestination� � z _FakeConnector.getDestinationN) rJ rK rL rM r� r� rQ r� r� r� r� r> r> r> r? r, b s r, c @ s e Zd ZdZdd� Zdd� ZdDdd�Zd d � Zd d � Zd d� Z dEdd�Z dd� Z de de de def fdd�Zdd� Zde def fd d �Zd d � Zd d!� ZdFd#d$�ZdGd'd(�ZdHd+d,�ZdGd-d.�Z *dHd/d0�ZdId2d3�ZdJd4d5�Zd6d7� Zd8d9� Z d:d;� Z d<d=� Z d>d?� Z d@dA� Z dBdC� Z!d*S )Kr. a: A fake reactor to be used in tests. This reactor doesn't actually do much that's useful yet. It accepts TCP connection setup attempts, but they will never succeed. @ivar hasInstalled: Keeps track of whether this reactor has been installed. @type hasInstalled: L{bool} @ivar running: Keeps track of whether this reactor is running. @type running: L{bool} @ivar hasStopped: Keeps track of whether this reactor has been stopped. @type hasStopped: L{bool} @ivar hasCrashed: Keeps track of whether this reactor has crashed. @type hasCrashed: L{bool} @ivar whenRunningHooks: Keeps track of hooks registered with C{callWhenRunning}. @type whenRunningHooks: L{list} @ivar triggers: Keeps track of hooks registered with C{addSystemEventTrigger}. @type triggers: L{dict} @ivar tcpClients: Keeps track of connection attempts (ie, calls to C{connectTCP}). @type tcpClients: L{list} @ivar tcpServers: Keeps track of server listen attempts (ie, calls to C{listenTCP}). @type tcpServers: L{list} @ivar sslClients: Keeps track of connection attempts (ie, calls to C{connectSSL}). @type sslClients: L{list} @ivar sslServers: Keeps track of server listen attempts (ie, calls to C{listenSSL}). @type sslServers: L{list} @ivar unixClients: Keeps track of connection attempts (ie, calls to C{connectUNIX}). @type unixClients: L{list} @ivar unixServers: Keeps track of server listen attempts (ie, calls to C{listenUNIX}). @type unixServers: L{list} @ivar adoptedPorts: Keeps track of server listen attempts (ie, calls to C{adoptStreamPort}). @ivar adoptedStreamConnections: Keeps track of stream-oriented connections added using C{adoptStreamConnection}. c C st d| _ d| _d| _d| _d| _g | _i | _g | _g | _g | _ g | _ g | _ g | _ g | _ g | _g | _t� | _t� | _dS )z0 Initialize the tracking lists. FTN)� hasInstalled�running�hasRun� hasStopped� hasCrashed�whenRunningHooks�triggers� tcpClients� tcpServers� sslClients� sslServers� unixClients� unixServers� adoptedPorts�adoptedStreamConnections� connectors�set�readers�writersr] r> r> r? rQ � s$ zMemoryReactor.__init__c C rq )zO Fake install callable to emulate reactor module installation. TN)r� r] r> r> r? �install� r� zMemoryReactor.install� c C � t � ��zA Not implemented; raises L{NotImplementedError}. ��NotImplementedError)r< �name�timeoutr> r> r? �resolve� r� zMemoryReactor.resolvec C sF | j du sJ �d| _ d| _| jD ] \}}}||i |�� q| �� dS )a Fake L{IReactorCore.run}. Sets C{self.running} to L{True}, runs all of the hooks passed to C{self.callWhenRunning}, then calls C{self.stop} to simulate a request to stop the reactor. Sets C{self.hasRun} to L{True}. FTN)r� r� r� �stop)r< �f�args�kwargsr> r> r? �run� s zMemoryReactor.runc C s d| _ d| _dS )z� Fake L{IReactorCore.run}. Sets C{self.running} to L{False}. Sets C{self.hasStopped} to L{True}. FTN)r� r� r] r> r> r? r� � zMemoryReactor.stopc C s d| _ d| _dS )z� Fake L{IReactorCore.crash}. Sets C{self.running} to L{None}, because that feels crashy. Sets C{self.hasCrashed} to L{True}. NT)r� r� r] r> r> r? �crash r� zMemoryReactor.crashr c C r� r� r� )r< �delayr> r> r? �iterate r� zMemoryReactor.iteratec C r� r� r� )r< � eventTyper> r> r? �fireSystemEvent r� z MemoryReactor.fireSystemEvent�phaser� �callable.c O s. | j �|i �}|�|g �}|�|||f� dS )z� Fake L{IReactorCore.run}. Keep track of trigger by appending it to self.triggers[phase][eventType]. N)r� � setdefaultrU )r< r� r� r� r� �kw� phaseTriggers�eventTypeTriggersr> r> r? �addSystemEventTrigger% s z#MemoryReactor.addSystemEventTriggerc C r� r� r� )r< � triggerIDr> r> r? �removeSystemEventTrigger1 r� z&MemoryReactor.removeSystemEventTriggerc O � | j �|||f� dS )z� Fake L{IReactorCore.callWhenRunning}. Keeps a list of invocations to make in C{self.whenRunningHooks}. N)r� rU )r< r� r� r� r> r> r? �callWhenRunning7 s z MemoryReactor.callWhenRunningc C sL |t kr tddd�}n|tkrtddd�}nt� �| j�|||f� t|�S )zv Fake L{IReactorSocket.adoptStreamPort}, that logs the call and returns an L{IListeningPort}. ry �0.0.0.0�� �::�r r r r r r� rU r- )r< �fileno� addressFamilyr8 r_ r> r> r? �adoptStreamPort> s z MemoryReactor.adoptStreamPortc C r� )z� Record the given stream connection in C{adoptedStreamConnections}. @see: L{twisted.internet.interfaces.IReactorSocket.adoptStreamConnection} N)r� rU �r< �fileDescriptorr� r8 r> r> r? �adoptStreamConnectionM s z#MemoryReactor.adoptStreamConnection� c C sN |t kr tddd�}n|tkrtddd�}nt� �| j�||||f� t|�S )z� Fake L{IReactorSocket.adoptDatagramPort}, that logs the call and returns a fake L{IListeningPort}. @see: L{twisted.internet.interfaces.IReactorSocket.adoptDatagramPort} �UDPr� r� r� r� )r< r� r� r � maxPacketSizer_ r> r> r? �adoptDatagramPortV s z MemoryReactor.adoptDatagramPort�2 � c C sD | j �||||f� t|�rtd||�}t|�S tdd|�}t|�S )zm Fake L{IReactorTCP.listenTCP}, that logs the call and returns an L{IListeningPort}. ry r� )r� rU r r r r- )r< �portr8 �backlog� interfacer r> r> r? � listenTCPg s �zMemoryReactor.listenTCP� Nc C sZ | j �|||||f� t|�rttd||��}nttd||��}|�|� | j�|� |S )zj Fake L{IReactorTCP.connectTCP}, that logs the call and returns an L{IConnector}. ry )r� rU r r, r r �startedConnectingr� )r< �hostr� r8 r� � bindAddress�connr> r> r? � connectTCPs s zMemoryReactor.connectTCPc C s& | j �|||||f� ttdd|��S )zm Fake L{IReactorSSL.listenSSL}, that logs the call and returns an L{IListeningPort}. ry r� )r� rU r- r �r< r� r8 �contextFactoryr� r� r> r> r? � listenSSL� s zMemoryReactor.listenSSLc C sB | j �||||||f� ttd||��}|�|� | j�|� |S )zj Fake L{IReactorSSL.connectSSL}, that logs the call and returns an L{IConnector}. ry )r� rU r, r r� r� )r< r� r� r8 r� r� r� r� r> r> r? � connectSSL� s � zMemoryReactor.connectSSL� c C s" | j �|||||f� tt|��S )zo Fake L{IReactorUNIX.listenUNIX}, that logs the call and returns an L{IListeningPort}. )r� rU r- r �r< r r8 r� �mode�wantPIDr> r> r? � listenUNIX� s zMemoryReactor.listenUNIXc C s: | j �||||f� tt|��}|�|� | j�|� |S )zl Fake L{IReactorUNIX.connectUNIX}, that logs the call and returns an L{IConnector}. )r� rU r, r r� r� )r< r r8 r� �checkPIDr� r> r> r? � connectUNIX� s zMemoryReactor.connectUNIXc C � | j �|� dS )zW Fake L{IReactorFDSet.addReader} which adds the reader to a local set. N)r� �add�r< �readerr> r> r? � addReader� � zMemoryReactor.addReaderc C r� )zg Fake L{IReactorFDSet.removeReader} which removes the reader from a local set. N)r� �discardr� r> r> r? � removeReader� � zMemoryReactor.removeReaderc C r� )zW Fake L{IReactorFDSet.addWriter} which adds the writer to a local set. N)r� r� �r< �writerr> r> r? � addWriter� r zMemoryReactor.addWriterc C r� )zg Fake L{IReactorFDSet.removeWriter} which removes the writer from a local set. N)r� r r r> r> r? � removeWriter� r zMemoryReactor.removeWriterc C � t | j�S )zn Fake L{IReactorFDSet.getReaders} which returns a list of readers from the local set. )�listr� r] r> r> r? � getReaders� rt zMemoryReactor.getReadersc C r )zn Fake L{IReactorFDSet.getWriters} which returns a list of writers from the local set. )r r� r] r> r> r? � getWriters� rt zMemoryReactor.getWritersc C s | j �� | j�� dS )zt Fake L{IReactorFDSet.removeAll} which removed all readers and writers from the local sets. N)r� rd r� r] r> r> r? � removeAll� s zMemoryReactor.removeAll)r� )r )r� �r� r� �r� N�r� r� r �r� r )"rJ rK rL rM rQ r� r� r� r� r� r� r� �strr r r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r> r> r> r? r. � sH 8 �� � � r. c @ s e Zd Zdd� ZdS )r/ c C s t �| � t�| � d S rA )r. rQ r" r] r> r> r? rQ � s zMemoryReactorClock.__init__N)rJ rK rL rQ r> r> r> r? r/ � s r/ c @ sp e Zd ZdZd dd�Zdd� Zd d d �Zd d d �Zd dd�Z d dd�Z d dd�Z d dd�Z dd� Z dd� Z dS )!r0 z� A fake reactor to be used in tests. It accepts TCP connection setup attempts, but they will fail. @ivar _listenException: An instance of an L{Exception} @ivar _connectException: An instance of an L{Exception} Nc C s || _ || _dS )z� @param listenException: An instance of an L{Exception} to raise when any C{listen} method is called. @param connectException: An instance of an L{Exception} to raise when any C{connect} method is called. N)�_listenException�_connectException)r< �listenException�connectExceptionr> r> r? rQ � s z RaisingMemoryReactor.__init__c C � | j �)zb Fake L{IReactorSocket.adoptStreamPort}, that raises L{_listenException}. �r )r< r� r� r8 r> r> r? r� � r� z$RaisingMemoryReactor.adoptStreamPortr� r� c C r )zQ Fake L{IReactorTCP.listenTCP}, that raises L{_listenException}. r )r< r� r8 r� r� r> r> r? r� r� z RaisingMemoryReactor.listenTCPr� c C r )zS Fake L{IReactorTCP.connectTCP}, that raises L{_connectException}. �r )r< r� r� r8 r� r� r> r> r? r� r� z RaisingMemoryReactor.connectTCPc C r )zQ Fake L{IReactorSSL.listenSSL}, that raises L{_listenException}. r r� r> r> r? r� r� z RaisingMemoryReactor.listenSSLc C r )zS Fake L{IReactorSSL.connectSSL}, that raises L{_connectException}. r )r< r� r� r8 r� r� r� r> r> r? r� s z RaisingMemoryReactor.connectSSLr� r c C r )zS Fake L{IReactorUNIX.listenUNIX}, that raises L{_listenException}. r r� r> r> r? r� r� z RaisingMemoryReactor.listenUNIXc C r )zU Fake L{IReactorUNIX.connectUNIX}, that raises L{_connectException}. r )r< r r8 r� r� r> r> r? r� " r� z RaisingMemoryReactor.connectUNIXc C r )ze Fake L{IReactorSocket.adoptDatagramPort}, that raises L{_connectException}. r )r< r� r� r r� r> r> r? r� ( r� z&RaisingMemoryReactor.adoptDatagramPortc C r )zi Fake L{IReactorSocket.adoptStreamConnection}, that raises L{_connectException}. r r� r> r> r? r� / r� z*RaisingMemoryReactor.adoptStreamConnection)NNr r r r )rJ rK rL rM rQ r� r� r� r� r� r� r� r� r� r> r> r> r? r0 � s � r0 c @ s@ e Zd ZdZdZdZdd� Zdd� Zdd � Zd d � Z d d � Z dS )r1 z5 A pull producer which writes 10 times only. r Fc C s || _ t� | _d S rA )�consumerr �result)r< r r> r> r? rQ ? s z NonStreamingProducer.__init__c C sb | j du s | jdkrtd��| j �d| jf � | jd7 _| jdkr/| j �� | �� dS dS )z/ Write the counter value once. Nr� z"BUG: resume after unregister/stop.s %dr6 )r �counterr r` r� �_doner] r> r> r? r� C s �z$NonStreamingProducer.resumeProducingc C s t d��)z� An implementation of C{IPushProducer.pauseProducing}. This should never be called on a pull producer, so this just raises an error. z"BUG: pause should never be called.)r r] r> r> r? r� P s z#NonStreamingProducer.pauseProducingc C s d| _ | j}| `|�d� dS )zQ Fire a L{Deferred} so that users can wait for this to complete. N)r r r: r; r> r> r? r W s zNonStreamingProducer._donec C ru )z& Stop all production. TN)r� r r] r> r> r? r� ` s z"NonStreamingProducer.stopProducingN) rJ rK rL rM r r� rQ r� r� r r� r> r> r> r? r1 7 s r1 c s0 d� � �fdd�}t �|�� | � _� jddd�S )a� Take a list of disconnecting protocols, callback a L{Deferred} when they're all done. This is a hack to make some older tests less flaky, as L{ITransport.loseConnection} is not atomic on all reactors (for example, the CoreFoundation, which sometimes takes a reactor turn for CFSocket to realise). New tests should either not use real sockets in testing, or take the advice in I{https://jml.io/pages/how-to-disconnect-in-twisted-really.html} to heart. @param reactor: The reactor to schedule the checks on. @type reactor: L{IReactorTime} @param protocols: The protocols to wait for disconnecting. @type protocols: A L{list} of L{IProtocol}s. Nc s" ddd� �D �vr� � � d S d S )NTc S s g | ]}|j j�qS r> )� transportrg )�.0�xr> r> r? � <listcomp>} s z<waitUntilAllDisconnected.<locals>._check.<locals>.<listcomp>)r� r> ��lc� protocolsr> r? �_check| s �z(waitUntilAllDisconnected.<locals>._checkg{�G�z�?T)�now)r � LoopingCall�clockrP )�reactorr$ r% r> r" r? r2 h s r2 c @ sD e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Ze d d � �Z dS )r3 a� L{ILogObserver} That stores its events in a list for later inspection. This class is similar to L{LimitedHistoryLogObserver} save that the internal buffer is public and intended for external inspection. The observer implements the sequence protocol to ease iteration of the events. @ivar _events: The events captured by this observer @type _events: L{list} c C r[ rA ��_eventsr] r> r> r? rQ � rZ z EventLoggingObserver.__init__c C r rA )�lenr+ r] r> r> r? �__len__� rZ z EventLoggingObserver.__len__c C s | j | S rA r* )r< �indexr> r> r? � __getitem__� rZ z EventLoggingObserver.__getitem__c C r rA )�iterr+ r] r> r> r? �__iter__� rZ z EventLoggingObserver.__iter__c C r� )z' @see: L{ILogObserver} N)r+ rU )r< �eventr> r> r? �__call__� r z EventLoggingObserver.__call__c s( | � � �� � � |�� �fdd�� � S )a- Create an L{EventLoggingObserver} instance that observes the provided publisher and will be cleaned up with addCleanup(). @param testInstance: Test instance in which this logger is used. @type testInstance: L{twisted.trial.unittest.TestCase} @param publisher: Log publisher to observe. @type publisher: twisted.logger.LogPublisher @return: An EventLoggingObserver configured to observe the provided publisher. @rtype: L{twisted.test.proto_helpers.EventLoggingObserver} c s �� � �S rA )�removeObserverr> ��obs� publisherr> r? �<lambda>� s z8EventLoggingObserver.createWithCleanup.<locals>.<lambda>)� addObserver� addCleanup)�cls� testInstancer7 r> r5 r? �createWithCleanup� s z&EventLoggingObserver.createWithCleanupN) rJ rK rL rM rQ r- r/ r1 r3 � classmethodr= r> r> r> r? r3 � s r3 N)GrM �collections.abcr rl r �socketr r �typingr r �zope.interfacer r �zope.interface.verifyr �twisted.internetr r r r �twisted.internet.abstractr r �twisted.internet.addressr r r �twisted.internet.deferr �twisted.internet.errorr �twisted.internet.interfacesr r r r r r r r r r r r! �twisted.internet.taskr" �twisted.loggerr# �twisted.protocolsr$ �twisted.pythonr% �__all__�Protocolr& � LineReceiverr' r( r) r* r+ r- r, r. �ifacer/ r0 r1 r2 r3 r> r> r> r? �<module> sZ 8 * / � I P1 PK Mb�Z�7D�k- k- 3 internet/__pycache__/_dumbwin32proc.cpython-310.pycnu �[��� o �b�1 � @ s� d Z ddlZddlZddlmZ ddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZmZ ddlmZ ddlmZmZmZ ddlmZ e �� Zde_d d � ZG d d � d ej �Z d d� Z dd� Z eeee�G dd� dej e��Z!dS )z< Windows Process Management, used with reactor.spawnProcess � N)� implementer)� _pollingfile�error)� BaseProcess)� IConsumer�IProcessTransport� IProducer)�quoteArguments� c C s t | � tj�� d S �N)�print�sys�stdout�flush)�msg� r �A/usr/lib/python3/dist-packages/twisted/internet/_dumbwin32proc.py�debug$ s r c @ s e Zd Zdd� Zdd� ZdS )�_Reaperc C s || _ d S r )�proc)�selfr r r r �__init__* s z_Reaper.__init__c C s@ t �| jjd�t jkr dS t�| jj�}| �� | j�|� dS �Nr ) � win32event�WaitForSingleObjectr �hProcess� WAIT_OBJECT_0� win32process�GetExitCodeProcess� deactivate� processEnded)r �exitCoder r r � checkWork- s � z_Reaper.checkWorkN)�__name__� __module__� __qualname__r r" r r r r r ) s r c C s^ t | ��!}|�d�dkr |�d��d�}|W d � S W d � dS 1 s(w Y dS )a Look for a #! line, and return the value following the #! if one exists, or None if this file is not a script. I don't know if there are any conventions for quoting in Windows shebang lines, so this doesn't support any; therefore, you may not pass any arguments to scripts invoked as filters. That's probably wrong, so if somebody knows more about the cultural expectations on Windows, please feel free to fix. This shebang line support was added in support of the CGI tests; appropriately enough, I determined that shebang lines are culturally accepted in the Windows world through this page:: http://www.cgi101.com/learn/connect/winxp.html @param filename: str representing a filename @return: a str representing another filename. � z#!i � N)�open�read�readline�strip)�filename�f�exer r r � _findShebang9 s �"�r/ c C s | j d dkS )z� Determine if a pywintypes.error is telling us that the given process is 'not a valid win32 application', i.e. not a PE format executable. @param pywinerr: a pywintypes.error instance raised by CreateProcess @return: a boolean r � )�args)�pywinerrr r r �_invalidWin32AppT s r3 c @ s� e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1e fd2d3�Z d4S )5�Processa� A process that integrates with the Twisted event loop. If your subprocess is a python program, you need to: - Run python.exe with the '-u' command line option - this turns on unbuffered I/O. Buffering stdout/err/in can cause problems, see e.g. http://support.microsoft.com/default.aspx?scid=kb;EN-US;q1903 - If you don't want Windows messing with data passed over stdin/out/err, set the pipes to be in binary mode:: import os, sys, mscvrt msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY) msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY) r c s t j��|� t��|� t�� }d|_t�|d�\�_ }t�|d�\�_ } t�|d�\} �_ t� �j tj dd� t�� � |� _| � _| � _tj� _t�� } t�| �j | ddtj�} t��j � | �_ t�| �j | ddtj�} t��j � | �_ t�| �j | ddtj�} t��j � | �_ t j � � ��� |p�i � dd� �� � D ��dd� |D �}t!|���r�t �"��n���r�t �"��n��� �����fdd �} z| � W na t#j$�y0 } zSt%|�s�t&|��t'��}|du r�t&d � ��t(|�}|�)d�� t!|���}|�z| � W n t#j$�y% } zt%|��r t&d ||f ��t&|��d}~ww W Y d}~nd}~ww t�| � t�|� t�| � t �*�j �fd d ��j+��_,t �*�j �fdd ��j-��_.t �/�j �j0��_1�j,�j.�j1fD ]}��2|� �qm�j3�4�� ��2t5��� dS )z- Create a new child process. r r Nc S s" i | ] \}}t �|�t �|��qS r ��os�fsdecode)�.0�key�valuer r r � <dictcomp>� s " z$Process.__init__.<locals>.<dictcomp>c S s g | ]}t �|��qS r r5 )r8 �xr r r � <listcomp>� s z$Process.__init__.<locals>.<listcomp>c s2 t j} t���d d d| ��� � \�_�_�_}d S �Nr )�win32con�CREATE_NO_WINDOWr � CreateProcessr �hThread�pid)�flags�dwTid�� StartupInfo�cmdline�command�env�pathr r r �doCreate� s �z"Process.__init__.<locals>.doCreatezD%r is neither a Windows executable, nor a script with a shebang linez<%r has an invalid shebang line: %r is not a valid executablec � � j �d| �S r> ��proto�childDataReceived��data�r r r �<lambda>� � z"Process.__init__.<locals>.<lambda>c rM �Nr& rN rQ rS r r rT � rU )6r � _PollingTimerr r � win32security�SECURITY_ATTRIBUTES�bInheritHandle� win32pipe� CreatePipe�hStdoutR�hStderrR�hStdinW�SetNamedPipeHandleState� PIPE_NOWAITr � STARTUPINFO� hStdOutput� hStdError� hStdInput�STARTF_USESTDHANDLES�dwFlags�win32api�GetCurrentProcess�DuplicateHandler? �DUPLICATE_SAME_ACCESS� win32file� CloseHandler6 �environ�copy�update�itemsr r7 � pywintypesr r3 �OSErrorr/ �list�insert�_PollableReadPipe�outConnectionLostr �errConnectionLost�stderr�_PollableWritePipe�inConnectionLost�stdin�_addPollableResourcerO �makeConnectionr )r �reactor�protocolrI r1 � environmentrK �sAttrs�hStdoutW�hStderrW�hStdinR� currentPid�tmprL �pwte�sheb�origcmd�pwte2� pipewatcherr rF r r | s� �� � � �� ���� ��� ! � �� zProcess.__init__c C s0 | j d u r t�� �|dv rt�| jd� d S d S )N)�INT�TERM�KILLr )rC r �ProcessExitedAlreadyr �TerminateProcessr )r �signalIDr r r � signalProcess s �zProcess.signalProcessc C s |dkr t �|�S t �|�S r )r � ProcessDone�ProcessTerminated)r �statusr r r � _getReason s zProcess._getReasonc C � | j �|� dS )zQ Write data to the process' stdin. @type data: C{bytes} N)r| �write)r rR r r r r� � z Process.writec C r� )z[ Write data to the process' stdin. @type seq: C{list} of C{bytes} N)r| � writeSequence)r �seqr r r r� r� zProcess.writeSequencec C s |dkr | j �|� dS t|��)a; Similar to L{ITransport.write} but also allows the file descriptor in the child process which will receive the bytes to be specified. This implementation is limited to writing to the child's standard input. @param fd: The file descriptor to which to write. Only stdin (C{0}) is supported. @type fd: C{int} @param data: The bytes to write. @type data: C{bytes} @return: L{None} @raise KeyError: If C{fd} is anything other than the stdin file descriptor (C{0}). r N)r| r� �KeyError)r �fdrR r r r � writeToChild s zProcess.writeToChildc C sD |dkr | � � d S |dkr| �� d S |dkr | �� d S td��)Nr r r& z4Only standard-IO file descriptors available on win32)� closeStdin� closeStdout� closeStderr�NotImplementedError)r r� r r r � closeChildFD7 s �zProcess.closeChildFDc C s | j �� dS )zClose the process' stdin.N)r| �closerS r r r r� C s zProcess.closeStdinc C � | j �� d S r )ry r� rS r r r r� G � zProcess.closeStderrc C r� r )r r� rS r r r r� J r� zProcess.closeStdoutc C s | � � | �� | �� dS )z8 Close the process' stdout, in and err. N)r� r� r� rS r r r �loseConnectionM s zProcess.loseConnectionc C � | j �d� | �� d S r> �rO �childConnectionLost�connectionLostNotifyrS r r r rw U � zProcess.outConnectionLostc C r� rV r� rS r r r rx Y r� zProcess.errConnectionLostc C r� r r� rS r r r r{ ] r� zProcess.inConnectionLostc C s | j d7 _ | �� dS )zS Will be called 3 times, by stdout/err threads and process handle. r N)�closedNotifies�maybeCallProcessEndedrS r r r r� a s z Process.connectionLostNotifyc C sJ | j dkr!| jr#t�| j� t�| j� d | _d | _t�| � d S d S d S )N� )r� � lostProcessrl rm r rB r r� rS r r r r� h s �z Process.maybeCallProcessEndedc C s | j �||� d S r )r| �registerProducer)r �producer� streamingr r r r� q s zProcess.registerProducerc C r� r )r| �unregisterProducerrS r r r r� t r� zProcess.unregisterProducerc C � | � � d S r )�_pauserS r r r �pauseProducingx � zProcess.pauseProducingc C r� r )�_unpauserS r r r �resumeProducing{ r� zProcess.resumeProducingc C r� r )r� rS r r r � stopProducing~ r� zProcess.stopProducingc C � t d��)Nz Unimplemented: Process.getHost�r� rS r r r �getHost� � zProcess.getHostc C r� )Nz Unimplemented: Process.getPeerr� rS r r r �getPeer� r� zProcess.getPeer�returnc C s d| j j� d| j� d�S )z@ Return a string representation of the process. �<z pid=�>)� __class__r# rC rS r r r �__repr__� s zProcess.__repr__N) r# r$ r% �__doc__r� r r� r� r� r� r� r� r� r� r� r� rw rx r{ r� r� r� r� r� r� r� r� r� �strr� r r r r r4 e s8 r4 )"r� r6 r �zope.interfacer rr rh r? r rl r[ r rX �twisted.internetr r � twisted.internet._baseprocessr �twisted.internet.interfacesr r r �twisted.python.win32r rY �PIPE_ATTRS_INHERITABLErZ r �_PollableResourcer r/ r3 rW r4 r r r r �<module> s0 PK Mb�Z]��de e * internet/__pycache__/fdesc.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZzddlZW n ey dZY nw eZddlmZmZ dd� Z dd� Z edu r9dd � Z Z nd d � Z d d � Z dd� Z dd� Zg d�ZdS )z< Utility functions for dealing with POSIX file descriptors. � N)�CONNECTION_DONE�CONNECTION_LOSTc C s, t � | t j�}|tjB }t � | t j|� dS )zP Set the file description of the given file descriptor to non-blocking. N��fcntl�F_GETFL�os� O_NONBLOCK�F_SETFL��fd�flags� r �8/usr/lib/python3/dist-packages/twisted/internet/fdesc.py�setNonBlocking � r c C s. t � | t j�}|tj @ }t � | t j|� dS )zL Set the file description of the given file descriptor to blocking. Nr r r r r � setBlocking! � r c C s d S )Nr )r r r r �<lambda>- s r c C s, t � | t j�}|t jB }t � | t j|� dS �z7 Make a file descriptor close-on-exec. N�r �F_GETFD� FD_CLOEXEC�F_SETFDr r r r �_setCloseOnExec0 r r c C s. t � | t j�}|t j @ }t � | t j|� dS r r r r r r �_unsetCloseOnExec8 r r c C sr zt �| d�}W n& ty. } z|jd tjtjfv r"W Y d}~dS tW Y d}~S d}~ww |s3tS ||� dS )a Read from file descriptor, calling callback with resulting data. If successful, call 'callback' with a single argument: the resulting data. Returns same thing FileDescriptor.doRead would: CONNECTION_LOST, CONNECTION_DONE, or None. @type fd: C{int} @param fd: non-blocking file descriptor to be read from. @param callback: a callable which accepts a single argument. If data is read from the file descriptor it will be called with this data. Handling exceptions from calling the callback is up to the caller. Note that if the descriptor is still connected but no data is read, None will be returned but callback will not be called. @return: CONNECTION_LOST on error, CONNECTION_DONE when fd is closed, otherwise None. i r N) r �read�OSError�args�errno�EAGAIN�EINTRr r )r �callback�output�ioer r r � readFromFDA s �� r$ c C sX zt �| |�W S ty+ } z|jtjtjfv r W Y d}~dS tW Y d}~S d}~ww )a> Write data to file descriptor. Returns same thing FileDescriptor.writeSomeData would. @type fd: C{int} @param fd: non-blocking file descriptor to be written to. @type data: C{str} or C{buffer} @param data: bytes to write to fd. @return: number of bytes written, or CONNECTION_LOST. Nr )r �writer r r r r )r �data�ior r r � writeToFDd s ��r( )r r r$ r( )�__doc__r r r �_fcntl� ImportError�twisted.internet.mainr r r r r r r$ r( �__all__r r r r �<module> s& � # PK Mb�Z%sw�} �} ) internet/__pycache__/task.cpython-310.pycnu �[��� o �bH� � @ s~ d Z ddlZddlZddlZddlmZmZmZmZm Z m Z m Z m Z m Z mZmZ ddlmZ ddlmZ ddlmZ ddlmZmZmZ ddlmZ dd l m Z m Z m Z dd l m!Z!m"Z" dd l#m$Z$ dd l%m&Z& e d �Z'G dd� d�Z(G dd� de)�Z*G dd� de*�Z+G dd� de*�Z,G dd� de,�Z-G dd� de,�Z.G dd� de,�Z/G d d � d e*�Z0G d d � d �Z1d Z2d!eg df d"e fd#d$�Z3e d%�Z4G d&d'� d'�Z5G d(d)� d)�Z6e6� Z7d*ee' d"eee' fd+d,�Z8d*ee' d"e5fd-d.�Z9ee �G d/d0� d0��Z: d@d1e d2e;d!e ed3e'f d4e<d5e<d"ee' f d6d7�Z= 8 dAd9ed3eee' ed:e<e'f f f d;ee' d<e e d"e fd=d>�Z>g d?�Z?dS )Bz) Scheduling utility methods and classes. � N) �Callable� Coroutine�Iterable�Iterator�List�NoReturn�Optional�Sequence�TypeVar�Union�cast)� implementer)�Version)� DelayedCall)�Deferred�ensureDeferred� maybeDeferred)�ReactorNotRunning)� IDelayedCall� IReactorCore� IReactorTime)�log�reflect)� _getDeprecationWarningString)�Failure�_Tc @ s6 e Zd ZU dZdZee ed< dZdZ ee d ed< dZ ee ed< dZ dZee ed< dZee ed< d ed ef d ed ed dfdd�Zed ee d fdd��Zedeegef d d fdd��Zde d efdd�Zd'de ded e d fdd�Zd(d d �Zd(d d �Z d(d d!�Z d"e d dfd#d$�Z d e fd%d&�Z dS ))� LoopingCalla� Call a function repeatedly. If C{f} returns a deferred, rescheduling will not take place until the deferred has fired. The result value is ignored. @ivar f: The function to call. @ivar a: A tuple of arguments to pass the function. @ivar kw: A dictionary of keyword arguments to pass to the function. @ivar clock: A provider of L{twisted.internet.interfaces.IReactorTime}. The default is L{twisted.internet.reactor}. Feel free to set this to something else, but it probably ought to be set *before* calling L{start}. @ivar running: A flag which is C{True} while C{f} is scheduled to be called (or is currently being called). It is set to C{True} when L{start} is called and set to C{False} when L{stop} is called or if C{f} raises an exception. In either case, it will be C{False} by the time the C{Deferred} returned by L{start} fires its callback or errback. @ivar _realLastTime: When counting skips, the time at which the skip counter was last invoked. @ivar _runAtStart: A flag indicating whether the 'now' argument was passed to L{LoopingCall.start}. N�callF� _deferred�interval� starttime� _realLastTime�f.�a�kw�returnc O s. || _ || _|| _ddlm} tt|�| _d S �Nr ��reactor)r" r# r$ �twisted.internetr( r r �clock)�selfr" r# r$ r( � r, �7/usr/lib/python3/dist-packages/twisted/internet/task.py�__init__N s zLoopingCall.__init__c C s. t dtdddd�dd�}tj|tdd� | jS ) z� DEPRECATED. L{Deferred} fired when loop stops or fails. Use the L{Deferred} returned by L{LoopingCall.start}. z*twisted.internet.task.LoopingCall.deferred�Twisted� r z the deferred returned by start())� replacement� )� stacklevel)r r �warnings�warn�DeprecationWarningr )r+ � warningStringr, r, r- �deferredV s �zLoopingCall.deferred� countCallablec s dt f� �fdd� }| |���S )a� An alternate constructor for L{LoopingCall} that makes available the number of calls which should have occurred since it was last invoked. Note that this number is an C{int} value; It represents the discrete number of calls that should have been made. For example, if you are using a looping call to display an animation with discrete frames, this number would be the number of frames to advance. The count is normally 1, but can be higher. For example, if the reactor is blocked and takes too long to invoke the L{LoopingCall}, a Deferred returned from a previous call is not fired before an interval has elapsed, or if the callable itself blocks for longer than an interval, preventing I{itself} from being called. When running with an interval of 0, count will be always 1. @param countCallable: A callable that will be invoked each time the resulting LoopingCall is run, with an integer specifying the number of calls that should have been invoked. @return: An instance of L{LoopingCall} with call counting enabled, which provides the count as the first positional argument. @since: 9.0 r% c s� �j �� } �jdkr| �_� d�S �j}|d u r5�jd us!J d���j}�jr5�jd us0J d��|�j8 }��|�}��| �}|| }|dkrN| �_� |�S d S )Nr � z(LoopingCall called before it was startedz&Looping call called with None interval)r* �secondsr r! r � _runAtStart� _intervalOf)�now�lastTime� lastInterval� thisInterval�count�r9 r+ r, r- �counter� s, � � z&LoopingCall.withCount.<locals>.counter)�object)�clsr9 rD r, rC r- � withCountf s zLoopingCall.withCount�tc C s8 | j dusJ �| jdusJ �|| j }t|| j �}|S )aD Determine the number of intervals passed as of the given point in time. @param t: The specified time (from the start of the L{LoopingCall}) to be measured in intervals @return: The C{int} number of intervals which have passed as of the given point in time. N)r r �int)r+ rH � elapsedTime� intervalNumr, r, r- r= � s zLoopingCall._intervalOfTr> c C sf | j rJ d��|dk rtd��d| _ t� }| _| j�� | _|| _|| _|r+| � |S | � | j� |S )a� Start running function every interval seconds. @param interval: The number of seconds between calls. May be less than one. Precision will depend on the underlying platform, the available hardware, and the load on the system. @param now: If True, run this call right now. Otherwise, wait until the interval has elapsed before beginning. @return: A Deferred whose callback will be invoked with C{self} when C{self.stop} is called, or whose errback will be invoked when the function raises an exception or returned a deferred that has its errback invoked. z.Tried to start an already running LoopingCall.r zinterval must be >= 0T) �running� ValueErrorr r r* r; r r r< � _scheduleFrom)r+ r r> r8 r, r, r- �start� s �zLoopingCall.startc C sZ | j sJ d��d| _ | jdur+| j�� d| _| jd}| _|dus$J �|�| � dS dS )zStop running function.z1Tried to stop a LoopingCall that was not running.FN)rL r �cancelr �callback�r+ �dr, r, r- �stop� s �zLoopingCall.stopc C sH | j sJ d��| jdur"| j�� d| _| j�� | _| �| j� dS dS )zT Skip the next iteration and reset the timer. @since: 11.1 z2Tried to reset a LoopingCall that was not running.N)rL r rP r* r; r rN �r+ r, r, r- �reset� s �zLoopingCall.resetc sf dt dd f� fdd� }dtdd f� fdd� }d � _t� jg� j�R i � j��}|�|� |�|� d S )N�resultr% c sB � j r � �� j�� � d S � jd }� _|d usJ �|�� � d S �N)rL rN r* r; r rQ )rW rS rU r, r- �cb� s z LoopingCall.__call__.<locals>.cb�failurec s. d� _ � jd }� _|d usJ �|�| � d S )NF)rL r �errback)rZ rS rU r, r- �eb� s z LoopingCall.__call__.<locals>.eb) rE r r r r" r# r$ � addCallback� addErrback)r+ rY r\ rS r, rU r- �__call__� s zLoopingCall.__call__�whenc s* dt f� �fdd� }� j�|� � �� _dS )z� Schedule the next iteration of this looping call. @param when: The present time from whence the call is scheduled. r% c sZ � j dkrdS � jd usJ ��� j } � j d usJ �� j | � j }��| kr+� j S |S )Nr )r r )� runningFor�untilNextInterval�r+ r` r, r- �howLong s z*LoopingCall._scheduleFrom.<locals>.howLongN)�floatr* � callLaterr )r+ r` rd r, rc r- rN � s zLoopingCall._scheduleFromc C s� t | jdd �}|d u r(t | jdd �}|d ur(t | jdd �}|d ur(|� d|� �}|d u r2t�| j�}d�| j|t�| j�t�| j��S )N� __qualname__�__name__�im_class�.z LoopingCall<{!r}>({}, *{}, **{}))�getattrr" r � safe_repr�formatr r# r$ )r+ �func�imClassr, r, r- �__repr__% s �zLoopingCall.__repr__)T�r% N)!rh � __module__rg �__doc__r r r �__annotations__rL r r r re r< r r! r rE r. �propertyr8 � classmethodrI rG r= �boolrO rT rV r_ rN �strrp r, r, r, r- r * s* " ; &r c @ � e Zd ZdZdS )�SchedulerErrorz� The operation could not be completed because the scheduler or one of its tasks was in an invalid state. This exception should not be raised directly, but is a superclass of various scheduler-state-related exceptions. N�rh rr rg rs r, r, r, r- rz : � rz c @ ry )�SchedulerStoppedzt The operation could not complete because the scheduler was stopped in progress or was already stopped. Nr{ r, r, r, r- r} C r| r} c @ ry )� TaskFinishedz� The operation could not complete because the task was already completed, stopped, encountered an error or otherwise permanently stopped running. Nr{ r, r, r, r- r~ J r| r~ c @ ry )�TaskDonezR The operation could not complete because the task was already completed. Nr{ r, r, r, r- r Q r| r c @ ry )� TaskStoppedzH The operation could not complete because the task was stopped. Nr{ r, r, r, r- r� W r| r� c @ ry )� TaskFailedz] The operation could not complete because the task died with an unhandled error. Nr{ r, r, r, r- r� ] r| r� c @ ry )� NotPausedz^ This exception is raised when a task is resumed which was not previously paused. Nr{ r, r, r, r- r� d r| r� c @ s( e Zd ZdZddd�Zdefdd�ZdS ) �_Timerg{�G�z�?r% Nc C s t � � | j | _d S rX )�time� MAX_SLICE�endrU r, r, r- r. n s z_Timer.__init__c C s t � � | jkS rX )r� r� rU r, r, r- r_ q s z_Timer.__call__rq )rh rr rg r� r. rw r_ r, r, r, r- r� k s r� g:�0�yE>�callabler% c C s ddl m} tt|��t| �S r& )r) r( r r rf �_EPSILON)r� r( r, r, r- �_defaultSchedulerx s r� � _TaskResultTc @ s� e Zd ZdZdee ddddfdd�Zdeee fd d �Zdd d �Z dd d�Z de de ee e f ddfdd�Zddd�Zddd�Zddd�ZdS )�CooperativeTaskaU A L{CooperativeTask} is a task object inside a L{Cooperator}, which can be paused, resumed, and stopped. It can also have its completion (or termination) monitored. @see: L{Cooperator.cooperate} @ivar _iterator: the iterator to iterate when this L{CooperativeTask} is asked to do work. @ivar _cooperator: the L{Cooperator} that this L{CooperativeTask} participates in, which is used to re-insert it upon resume. @ivar _deferreds: the list of L{Deferred}s to fire when this task completes, fails, or finishes. @ivar _pauseCount: the number of times that this L{CooperativeTask} has been paused; if 0, it is running. @ivar _completionState: The completion-state of this L{CooperativeTask}. L{None} if the task is not yet completed, an instance of L{TaskStopped} if C{stop} was called to stop this task early, of L{TaskFailed} if the application code in the iterator raised an exception which caused it to terminate, and of L{TaskDone} if it terminated normally via raising C{StopIteration}. �iterator� cooperator� Cooperatorr% Nc C s2 || _ || _g | _d| _d| _d| _|�| � dS )zq A private constructor: to create a new L{CooperativeTask}, see L{Cooperator.cooperate}. r N)� _iterator� _cooperator� _deferreds� _pauseCount�_completionState�_completionResult�_addTask)r+ r� r� r, r, r- r. � s zCooperativeTask.__init__c C s> t � }| jdu r| j�|� |S | jdusJ �|�| j� |S )a� Get a L{Deferred} notification of when this task is complete. @return: a L{Deferred} that fires with the C{iterator} that this L{CooperativeTask} was created with when the iterator has been exhausted (i.e. its C{next} method has raised C{StopIteration}), or fails with the exception raised by C{next} if it raises some other exception. @rtype: L{Deferred} N)r r� r� �appendr� rQ rR r, r, r- �whenDone� s � zCooperativeTask.whenDonec C s4 | � � | jd7 _| jdkr| j�| � dS dS )a@ Pause this L{CooperativeTask}. Stop doing work until L{CooperativeTask.resume} is called. If C{pause} is called more than once, C{resume} must be called an equal number of times to resume this task. @raise TaskFinished: if this task has already finished or completed. r: N)� _checkFinishr� r� � _removeTaskrU r, r, r- �pause� s �zCooperativeTask.pausec C sJ | j dkrt� �| j d8 _ | j dkr!| jdu r#| j�| � dS dS dS )z� Resume processing of a paused L{CooperativeTask}. @raise NotPaused: if this L{CooperativeTask} is not paused. r r: N)r� r� r� r� r� rU r, r, r- �resume� s �zCooperativeTask.resume�completionState�deferredResultc C s8 || _ || _| js| j�| � | jD ]}|�|� qdS )a @param completionState: a L{SchedulerError} exception or a subclass thereof, indicating what exception should be raised when subsequent operations are performed. @param deferredResult: the result to fire all the deferreds with. N)r� r� r� r� r� r� rQ )r+ r� r� rS r, r, r- � _completeWith� s �z CooperativeTask._completeWithc C s | � � | �t� tt� �� dS )z� Stop further processing of this task. @raise TaskFinished: if this L{CooperativeTask} has previously completed, via C{stop}, completion, or failure. N)r� r� r� r rU r, r, r- rT � s zCooperativeTask.stopc C s | j dur| j �dS )zk If this task has been stopped, raise the appropriate subclass of L{TaskFinished}. N)r� rU r, r, r- r� � s �z CooperativeTask._checkFinishc s� zt � j�}W n# ty � �t� � j� Y dS ty* � �t� t� � Y dS w t|t �rK� � � dtddf� fdd� }|� � fdd�|� dS dS )z� Perform one unit of work for this task, retrieving one item from its iterator, stopping if there are no further items in the iterator, and pausing if the result was a L{Deferred}. rZ r% Nc s � � t� | � d S rX )r� r� )rZ rU r, r- � failLater s z/CooperativeTask._oneWorkUnit.<locals>.failLaterc s � � � S rX )r� �rW rU r, r- �<lambda> � z.CooperativeTask._oneWorkUnit.<locals>.<lambda>) �nextr� � StopIterationr� r � BaseExceptionr� r � isinstancer r� � addCallbacks)r+ rW r� r, rU r- � _oneWorkUnit s � �z CooperativeTask._oneWorkUnitrq )rh rr rg rs r r� r. r r� r� r� rz r r r� rT r� r� r, r, r, r- r� � s, �� � �� � r� c @ s e Zd ZdZeedfdeg eg ef f deeg df gef defdd�Z d"d e e d e e e e d e e e fd d �Zd e e d efdd�Zded dfdd�Zded dfdd�Zd ee fdd�Zd#dd�ZdZd#dd�Zd#d d �Zd#d d �Zed efd d!��ZdS )$r� a� Cooperative task scheduler. A cooperative task is an iterator where each iteration represents an atomic unit of work. When the iterator yields, it allows the L{Cooperator} to decide which of its tasks to execute next. If the iterator yields a L{Deferred} then work will pause until the L{Deferred} fires and completes its callback chain. When a L{Cooperator} has more than one task, it distributes work between all tasks. There are two ways to add tasks to a L{Cooperator}, L{cooperate} and L{coiterate}. L{cooperate} is the more useful of the two, as it returns a L{CooperativeTask}, which can be L{paused<CooperativeTask.pause>}, L{resumed<CooperativeTask.resume>} and L{waited on<CooperativeTask.whenDone>}. L{coiterate} has the same effect, but returns only a L{Deferred} that fires when the task is done. L{Cooperator} can be used for many things, including but not limited to: - running one or more computationally intensive tasks without blocking - limiting parallelism by running a subset of the total tasks simultaneously - doing one thing, waiting for a L{Deferred} to fire, doing the next thing, repeat (i.e. serializing a sequence of asynchronous tasks) Multiple L{Cooperator}s do not cooperate with each other, so for most cases you should use the L{global cooperator<task.cooperate>}. T�terminationPredicateFactory� schedulerN�startedc C s2 g | _ td�| _|| _|| _d| _d| _|| _dS )aA Create a scheduler-like object to which iterators may be added. @param terminationPredicateFactory: A no-argument callable which will be invoked at the beginning of each step and should return a no-argument callable which will return True when the step should be terminated. The default factory is time-based and allows iterators to run for 1/100th of a second at a time. @param scheduler: A one-argument callable which takes a no-argument callable and should invoke it at some future point. This will be used to schedule each step of this Cooperator. @param started: A boolean which indicates whether iterators should be stepped as soon as they are added, or if they will be queued up until L{Cooperator.start} is called. r, NF)�_tasks�iter� _metarator� _terminationPredicateFactory� _scheduler� _delayedCall�_stopped�_started)r+ r� r� r� r, r, r- r. > s zCooperator.__init__r� � doneDeferredr% c C s& |du rt � }t|| ��� �|� |S )a� Add an iterator to the list of iterators this L{Cooperator} is currently running. Equivalent to L{cooperate}, but returns a L{Deferred} that will be fired when the task is done. @param doneDeferred: If specified, this will be the Deferred used as the completion deferred. It is suggested that you use the default, which creates a new Deferred for you. @return: a Deferred that will fire when the iterator finishes. N)r r� r� � chainDeferred)r+ r� r� r, r, r- � coiterate] s zCooperator.coiteratec C s t || �S )a Start running the given iterator as a long-running cooperative task, by calling next() on it as a periodic timed event. @param iterator: the iterator to invoke. @return: a L{CooperativeTask} object representing this task. )r� )r+ r� r, r, r- � cooperatet s zCooperator.cooperate�taskc C sB | j r| j�|� |�t� tt� �� dS | j�|� | �� dS )zH Add a L{CooperativeTask} object to this L{Cooperator}. N)r� r� r� r� r} r � _reschedule�r+ r� r, r, r- r� s zCooperator._addTaskc C s4 | j �|� | j s| jr| j�� d| _dS dS dS )zF Remove a L{CooperativeTask} from this L{Cooperator}. N)r� �remover� rP r� r, r, r- r� � s �zCooperator._removeTaskc c sH � | � � }| jr"| jD ] }|V |� r dS q t| j�| _| jsdS dS )z� Yield all L{CooperativeTask} objects in a loop as long as this L{Cooperator}'s termination condition has not been met. N)r� r� r� r� )r+ � terminatorrH r, r, r- �_tasksWhileNotStopped� s � � �z Cooperator._tasksWhileNotStoppedc C s( d| _ | �� D ]}|�� q| �� dS )z) Run one scheduler tick. N)r� r� r� r� �r+ �taskObjr, r, r- �_tick� s zCooperator._tickFc C s: | j sd| _d S | jd u r| jr| �| j�| _d S d S d S �NT)r� �_mustScheduleOnStartr� r� r� r� rU r, r, r- r� � s �zCooperator._reschedulec C s& d| _ d| _| jr| `| �� dS dS )z) Begin scheduling steps. FTN)r� r� r� r� rU r, r, r- rO � s �zCooperator.startc C sN d| _ | jD ] }|�t� tt� �� qg | _| jdur%| j�� d| _dS dS )z� Stop scheduling steps. Errback the completion Deferreds of all iterators which have been added and forget about them. TN)r� r� r� r} r r� rP r� r, r, r- rT � s �zCooperator.stopc C s | j o| j S )z� Is this L{Cooperator} is currently running? @return: C{True} if the L{Cooperator} is running, C{False} otherwise. @rtype: C{bool} )r� r� rU r, r, r- rL � s zCooperator.runningrX rq ) rh rr rg rs r� r� r rw r r. r r� r r r� r� r� r� r� r r� r� r� r� rO rT ru rL r, r, r, r- r� s> "��� �"��� � r� r� c C � t �| �S )a% Cooperatively iterate over the given iterator, dividing runtime between it and all other iterators which have been passed to this function and not yet exhausted. @param iterator: the iterator to invoke. @return: a Deferred that will fire when the iterator finishes. )�_theCooperatorr� �r� r, r, r- r� � s r� c C r� )aS Start running the given iterator as a long-running cooperative task, by calling next() on it as a periodic timed event. This is very useful if you have computationally expensive tasks that you want to run without blocking the reactor. Just break each task up so that it yields frequently, pass it in here and the global L{Cooperator} will make sure work is distributed between them without blocking longer than a single iteration of a single task. @param iterator: the iterator to invoke. @return: a L{CooperativeTask} object representing this task. )r� r� r� r, r, r- r� � s r� c @ s� e Zd ZdZdZddd�Zdefdd�Zdd d �Zd ed e d e f de de de f dd�Z de e fdd�Zdeddfdd�Zdee ddfdd�ZdS )�Clockz� Provide a deterministic, easily-controlled implementation of L{IReactorTime.callLater}. This is commonly useful for writing deterministic unit tests for code which schedules events using this API. g r% Nc C s g | _ d S rX ��callsrU r, r, r- r. s zClock.__init__c C � | j S )a Pretend to be time.time(). This is used internally when an operation such as L{IDelayedCall.reset} needs to determine a time value relative to the current time. @return: The time which should be considered the current time. )�rightNowrU r, r, r- r; s z Clock.secondsc C s | j jdd� d� dS )zR Sort the pending calls according to the time they are scheduled. c S s | � � S rX )�getTime)r# r, r, r- r� r� z"Clock._sortCalls.<locals>.<lambda>)�keyN)r� �sortrU r, r, r- � _sortCalls s zClock._sortCalls�delayr� .�argsr$ c O s> t | �� | |||| jjdd� | j�}| j�|� | �� |S )zL See L{twisted.internet.interfaces.IReactorTime.callLater}. c S s d S rX r, )�cr, r, r- r� ! s z!Clock.callLater.<locals>.<lambda>)r r; r� r� r� r� )r+ r� r� r� r$ �dcr, r, r- rf s � zClock.callLaterc C r� )zQ See L{twisted.internet.interfaces.IReactorTime.getDelayedCalls} r� rU r, r, r- �getDelayedCalls( s zClock.getDelayedCalls�amountc C s� | j |7 _ | �� | jr@| jd �� | �� krD| j�d�}d|_|j|ji |j �� | �� | jrB| jd �� | �� ksdS dS dS dS )z� Move time on this clock forward by the given amount and run whatever pending calls should be run. @param amount: The number of seconds which to advance this clock's time. r r: N) r� r� r� r� r; �pop�calledrn r� r$ )r+ r� r r, r, r- �advance. s ,�z Clock.advance�timingsc C s |D ]}| � |� qdS )zB Advance incrementally by the given set of times. N)r� )r+ r� r� r, r, r- �pump> s �z Clock.pumprq )rh rr rg rs r� r. re r; r� r rE r rf r r� r� r r� r, r, r, r- r� � s( � ��� �r� r* r� .r� r$ c sZ dt t ddf�fdd� }dtdtf� ��fdd� }t |�}|�|� | �||jd��|S ) a+ Call the given function after a certain period of time has passed. @param clock: The object which will be used to schedule the delayed call. @param delay: The number of seconds to wait before calling the function. @param callable: The callable to call after the delay, or C{None}. @param args: The positional arguments to pass to C{callable}. @param kw: The keyword arguments to pass to C{callable}. @return: A deferred that fires with the result of the callable when the specified time has elapsed. r8 r% Nc s � � � d S rX )rP )r8 )� delayedCallr, r- �deferLaterCancel_ s z$deferLater.<locals>.deferLaterCancelrW c s �d u rd S �� i ���S rX r, r� )r� r� r$ r, r- rY b s zdeferLater.<locals>.cb)r rE r r] rf rQ )r* r� r� r� r$ r� rY rS r, )r� r� r� r$ r- � deferLaterF s r� r, �mainz Deferred[_T]�argv�_reactorc s� � du rddl m} tt|�� t| � g|�R � �}d�d�d�fdd� }� �dd |� d td tddf� �fd d � �d tddf� ��fdd� }|�|� � � � t � �� dS )a� Call C{main} and run the reactor until the L{Deferred} it returns fires or the coroutine it returns completes. This is intended as the way to start up an application with a well-defined completion condition. Use it to write clients or one-off asynchronous operations. Prefer this to calling C{reactor.run} directly, as this function will also: - Take care to call C{reactor.stop} once and only once, and at the right time. - Log any failures from the C{Deferred} returned by C{main}. - Exit the application when done, with exit code 0 in case of success and 1 in case of failure. If C{main} fails with a C{SystemExit} error, the code returned is used. The following demonstrates the signature of a C{main} function which can be used with L{react}:: async def main(reactor, username, password): return "ok" task.react(main, ("alice", "secret")) @param main: A callable which returns a L{Deferred} or coroutine. It should take the reactor as its first parameter, followed by the elements of C{argv}. @param argv: A list of arguments to pass to C{main}. If omitted the callable will be invoked with no additional arguments. @param _reactor: An implementation detail to allow easier unit testing. Do not supply this parameter. @since: 12.3 Nr r' Fr% c s d� d S r� r, r, )�stoppingr, r- � onShutdown� s zreact.<locals>.onShutdown�before�shutdownrW � stopReactorc sl |r� d usJ �z� � � W n ty Y nw t| t�r4| �t�d ur*| jj�d S t� | d� d�d S d S )Nz main function encountered errorr: ) rT r r� r �check� SystemExit�value�coder �err)rW r� )r� r� r, r- rT � s � �zreact.<locals>.stopc s0 �r �| d� d S � d usJ �� � �| d� d S )NFT)�callWhenRunningr� )r� rT r� r, r- �cbFinish� s zreact.<locals>.cbFinishrq ) r) r( r r r �addSystemEventTriggerrE rw �addBoth�run�sys�exit)r� r� r� r( �finishedr� r� r, )r� r� rT r� r- �reactm s + r� )r r� r} r� r� r� r� rX )r, N)@rs r� r� r4 �typingr r r r r r r r r r r �zope.interfacer � incrementalr �twisted.internet.baser �twisted.internet.deferr r r �twisted.internet.errorr �twisted.internet.interfacesr r r �twisted.pythonr r �twisted.python.deprecater �twisted.python.failurer r r � Exceptionrz r} r~ r r� r� r� r� r� r� r� r� r� r� r� r� r� re rE r� r� �__all__r, r, r, r- �<module> s� 4 : P������ �,������ � WPK Mb�Z�2� � . internet/__pycache__/_resolver.cpython-310.pycnu �[��� o �b! � @ s` d Z ddlmZmZmZmZmZmZmZ ddl m Z ddl m Z ddl mZmZ ddlmZ ddlmZ ddlmZmZmZmZ dd lmZ dd lm Z dd l m Z e e�G d d � d ��Z e eeg�Z!e eg�ee eg�ee!eiZ"eeeeiZ#eed�Z$edediZ%e e�G dd� d��Z&e e�G dd� d��Z'e e�G dd� d��Z(e e�G dd� 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 e Zd ZdZdd� Zdd� ZdS )�HostResolutionz9 The in-progress resolution of a given hostname. c C � || _ dS )zA Create a L{HostResolution} with the given name. N)�name)�selfr � r �</usr/lib/python3/dist-packages/twisted/internet/_resolver.py�__init__- � zHostResolution.__init__c C s t � ��N)�NotImplementedError�r r r r �cancel3 s zHostResolution.cancelN)�__name__� __module__� __qualname__�__doc__r r! r r r r r ' s r )�TCP�UDPr& r' c @ s. e Zd ZdZdefdd�Z d dd�ZdS ) � GAIResolverzp L{IHostnameResolver} implementation that resolves hostnames by calling L{getaddrinfo} in a thread. Nc C s$ || _ |du r |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* r r r r r W s � zGAIResolver.__init__r r& c sr �� � }t|du r tnt|� � 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 Nc s* z �� ��� ��W S ty g Y S w r )r, r r )� addressFamily�hostName� portNumberr � socketTyper r �get� s � �z(GAIResolver.resolveHostName.<locals>.getc sF | D ]\}}}}}t | }� �|t�|d�g|�R � � q� �� d S �Nr& )� _afToType�addressResolved�_socktypeToTyper3 �resolutionComplete)�result�family�socktype�proto� cannoname�sockaddr�addrType��resolutionReceiverr r �deliverResults� s � z3GAIResolver.resolveHostName.<locals>.deliverResults) r+ � _typesToAF�_any� frozenset�_transportToSocketr r) r �resolutionBegan� addCallback) r rA r0 r1 � addressTypes�transportSemantics�poolr3 �d� resolutionrB r )r/ r0 r1 rA r r2 r �resolveHostNamen s � zGAIResolver.resolveHostName�r Nr& )r" r# r$ r% r r rN r r r r r( P s �r( c @ s. e Zd ZdZe� Zdd� Z d dd�ZdS ) �SimpleResolverComplexifierzF A converter from L{IResolverSimple} to L{IHostnameResolver}. c C r )zW Construct a L{SimpleResolverComplexifier} with an L{IResolverSimple}. N)�_simpleResolver)r �simpleResolverr r r r � r z#SimpleResolverComplexifier.__init__r Nr& c s� z� � d�� W n ty t� �� Y nw t� �� t� �}��|� �j�� �}��fdd�}� �fdd�} |�|| � �fdd�} |� | � |S )r. �asciic s �� td| � �� d S r4 )r6 r )�address)r1 rA r r �addressReceived� s zCSimpleResolverComplexifier.resolveHostName.<locals>.addressReceivedc s( | � t�s�jjd| � �jd� d S d S )Nz'while looking up {name} with {resolver})r �resolver)�checkr �_log�failurerQ )�error)r0 r r r � errorReceived� s ��zASimpleResolverComplexifier.resolveHostName.<locals>.errorReceivedc s � � � d S r )r8 )r9 r@ r r �finish� s z:SimpleResolverComplexifier.resolveHostName.<locals>.finish) �encode�UnicodeEncodeErrorr r r rG rQ � getHostByName� addCallbacksrH ) r rA r0 r1 rI rJ rM � onAddressrU r[ r\ r )r0 r1 rA r r rN � s � z*SimpleResolverComplexifier.resolveHostNamerO )r" r# r$ r% r rX r rN r r r r rP � s �rP c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � FirstOneWinszT An L{IResolutionReceiver} which fires a L{Deferred} with its first result. c C s || _ d| _dS )zp @param deferred: The L{Deferred} to fire when the first resolution result arrives. FN)� _deferred� _resolved)r �deferredr r r r � s zFirstOneWins.__init__c C r )z� See L{IResolutionReceiver.resolutionBegan} @param resolution: See L{IResolutionReceiver.resolutionBegan} N)� _resolution)r rM r r r rG � � z FirstOneWins.resolutionBeganc C s" | j rdS d| _ | j�|j� dS )z� See L{IResolutionReceiver.addressResolved} @param address: See L{IResolutionReceiver.addressResolved} NT)rd rc �callback�host)r rT r r r r6 s z FirstOneWins.addressResolvedc C s" | j rdS | j�t| jj�� dS )z? See L{IResolutionReceiver.resolutionComplete} N)rd rc �errbackr rf r r r r r r8 s z FirstOneWins.resolutionCompleteN)r" r# r$ r% r rG r6 r8 r r r r rb � s rb c @ s" e Zd ZdZdd� Zddd�ZdS ) �ComplexResolverSimplifierzE A converter from L{IHostnameResolver} to L{IResolverSimple} c C r )z� Create a L{ComplexResolverSimplifier} with an L{IHostnameResolver}. @param nameResolver: The L{IHostnameResolver} to use. N)� _nameResolver)r � nameResolverr r r r rg z"ComplexResolverSimplifier.__init__r c C s" 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 rl rN rb r )r r �timeoutsr9 r r r r_ & s z'ComplexResolverSimplifier.getHostByNameN)r )r" r# r$ r% r r_ r r r r rk s rk N)*r% �socketr r r r r r r �zope.interfacer �twisted.internet._idnar �twisted.internet.addressr r �twisted.internet.deferr �twisted.internet.errorr �twisted.internet.interfacesr r r r �twisted.internet.threadsr �twisted.loggerr �twisted.python.compatr r rE rD rC r5 rF r7 r( rP rb rk r r r r �<module> sF $ ����RJ)PK Mb�Z�1�96 96 6 internet/__pycache__/win32eventreactor.cpython-310.pycnu �[��� o �b�; � @ sJ d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z m Z m Z m Z mZ zddl mZ W n eyJ ddlZejded � d d � ZY nw ddlZdd lmZmZmZmZmZ dd lm Z ddl m Z m Z ddl m!Z! ddl"m#Z#m$Z$m%Z% ee e �G dd� de j&��Z'G dd� d�Z(ee �G dd� d��Z)dd� Z*ddgZ+dS )a� A win32event based implementation of the Twisted main loop. This requires pywin32 (formerly win32all) or ActivePython to be installed. To install the event loop (and you should do this before any connections, listeners or connectors are added):: from twisted.internet import win32eventreactor win32eventreactor.install() LIMITATIONS: 1. WaitForMultipleObjects and thus the event loop can only handle 64 objects. 2. Process running has some problems (see L{twisted.internet.process} docstring). TODO: 1. Event loop handling of writes is *very* problematic (this is causing failed tests). Switch to doing it the correct way, whatever that means (see below). 2. Replace icky socket loopback waker with event based waker (use dummyEvent object) 3. Switch everyone to using Free Software so we don't have to deal with proprietary APIs. ALTERNATIVE SOLUTIONS: - IIRC, sockets can only be registered once. So we switch to a structure like the poll() reactor, thus allowing us to deal with write events in a decent fashion. This should allow us to pass tests, but we're still limited to 64 events. Or: - Instead of doing a reactor, we make this an addon to the select reactor. The WFMO event loop runs in a separate thread. This means no need to maintain separate code for networking, 64 event limit doesn't apply to sockets, we can run processes and other win32 stuff in default event loop. The only problem is that we're stuck with the icky socket based waker. Another benefit is that this could be extended to support >64 events in a simpler manner than the previous solution. The 2nd solution is probably what will get implemented. � N)�Thread)�WeakKeyDictionary)� implementer)� FD_ACCEPT�FD_CLOSE� FD_CONNECT�FD_READ�WSAEventSelect)�WSAEnumNetworkEventszAReliable disconnection notification requires pywin32 215 or later)�categoryc C s t hS �N)r )�fd�event� r �D/usr/lib/python3/dist-packages/twisted/internet/win32eventreactor.pyr L s r )� QS_ALLINPUT� WAIT_OBJECT_0� WAIT_TIMEOUT� CreateEvent�MsgWaitForMultipleObjects)� posixbase)� IReactorFDSet�IReactorWin32Events)�blockingCallFromThread)�failure�log� threadablec @ s� e Zd ZdZedddd�Zdd� Zdd� Zdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zd d � Zd d � ZeZdS ) � Win32Reactora� Reactor that uses Win32 event APIs. @ivar _reads: A dictionary mapping L{FileDescriptor} instances to a win32 event object used to check for read events for that descriptor. @ivar _writes: A dictionary mapping L{FileDescriptor} instances to a arbitrary value. Keys in this dictionary will be given a chance to write out their data. @ivar _events: A dictionary mapping win32 event object to tuples of L{FileDescriptor} instances and event masks. @ivar _closedAndReading: Along with C{_closedAndNotReading}, keeps track of descriptors which have had close notification delivered from the OS but which we have not finished reading data from. MsgWaitForMultipleObjects will only deliver close notification to us once, so we remember it in these two dictionaries until we're ready to act on it. The OS has delivered close notification for each descriptor in this dictionary, and the descriptors are marked as allowed to handle read events in the reactor, so they can be processed. When a descriptor is marked as not allowed to handle read events in the reactor (ie, it is passed to L{IReactorFDSet.removeReader}), it is moved out of this dictionary and into C{_closedAndNotReading}. The descriptors are keys in this dictionary. The values are arbitrary. @type _closedAndReading: C{dict} @ivar _closedAndNotReading: These descriptors have had close notification delivered from the OS, but are not marked as allowed to handle read events in the reactor. They are saved here to record their closed state, but not processed at all. When one of these descriptors is passed to L{IReactorFDSet.addReader}, it is moved out of this dictionary and into C{_closedAndReading}. The descriptors are keys in this dictionary. The values are arbitrary. This is a weak key dictionary so that if an application tells the reactor to stop reading from a descriptor and then forgets about that descriptor itself, the reactor will also forget about it. @type _closedAndNotReading: C{WeakKeyDictionary} Nr c C s0 i | _ i | _i | _i | _t� | _tj�| � d S r ) �_reads�_writes�_events�_closedAndReadingr �_closedAndNotReadingr �PosixReactorBase�__init__��selfr r r r$ � s zWin32Reactor.__init__c C s, t dddd�}t|||� ||f| j|< |S )z9 Make a win32 event object for a socket. Nr )r r r )r& r �action�whyr r r r �_makeSocketEvent� s z Win32Reactor._makeSocketEventc C s ||f| j |< dS )z: Add a new win32 event to the event loop. N�r �r& r r r' r r r �addEvent� s zWin32Reactor.addEventc C s | j |= dS )z" Remove an event. Nr* �r& r r r r � removeEvent� s zWin32Reactor.removeEventc C sR || j vr%| �|dttB tB tB �| j |< || jv r'd| j|< | j|= dS dS dS )zY Add a socket FileDescriptor for notification of data available to read. �doReadTN)r r) r r r r r" r! �r& �readerr r r � addReader� s � �zWin32Reactor.addReaderc C s || j vr d| j |< dS dS )zZ Add a socket FileDescriptor for notification of data available to write. � N�r �r& �writerr r r � addWriter� s �zWin32Reactor.addWriterc C sH || j v r | j| j | = | j |= || jv r"d| j|< | j|= dS dS dS )z?Remove a Selectable for notification of data available to read.TN)r r r! r" r0 r r r � removeReader� s �zWin32Reactor.removeReaderc C s || j v r | j |= dS dS )z@Remove a Selectable for notification of data available to write.Nr4 r5 r r r � removeWriter� s �zWin32Reactor.removeWriterc C s | � | j| j�S )zD Remove all selectables, and return a list of them. )� _removeAllr r r% r r r � removeAll� s zWin32Reactor.removeAllc C � t | j�� �S r )�listr �keysr% r r r � getReaders� � zWin32Reactor.getReadersc C r< r )r= r r> r% r r r � getWriters� r@ zWin32Reactor.getWritersc C s� t jdd| d� |d u rd}d}t| j�� �D ] }d}| �d|� qt| j�� �D ] }d}t �|| j|� q)|r:d}| j sG| jsGt � |� d S t| j �� �pQ| j g}t |d �}t|d|t�}|tkred S |tt|� kr~t�� }|r|| �d| j� d S d S |tkr�|tt|� k r�||t }| j | \}} || jv r�|�� } | d kr�| �|tjd� d S t | |�} t | v r�d| j|< t �|| j| |� d S d S d S ) N�system� iteration)�channelr �reactor�d FTr/ r i� ���) r �msgr= r! r> � _runActionr �callWithLogger� _runWriter �time�sleep� dummyEvent�intr r r r �len�win32gui�PumpWaitingMessages� callLater�stopr �fileno�_disconnectSelectabler � _NO_FILEDESCr r ) r& �timeout� ranUserCoder1 r �handles�val�exitr r' rU �eventsr r r �doWaitForMultipleEvents� sN � �z$Win32Reactor.doWaitForMultipleEventsc C s� d}z|� � }W n ty t�� d }t�� Y nw |rB| �|� | �|� z |�t � |�� W d S tyA t�� Y d S w |d u rHdS d S )Nr r3 ) �doWrite� BaseException�sys�exc_infor �deferrr8 r9 �connectionLostr �Failure)r& r �closedr r r rK s$ � ��zWin32Reactor._runWritec C sV zt ||�� }W n ty t�� d }t�� Y nw |r)| �|||dk� d S d S )Nr3 r/ )�getattrr` ra rb r rc rV )r& r' r rf r r r rI - s ��zWin32Reactor._runAction)�__name__� __module__� __qualname__�__doc__r rN r$ r) r, r. r2 r7 r8 r9 r; r? rA r^ rK rI � doIterationr r r r r ` s$ ( @ r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �_ThreadFDWrappera7 This wraps an event handler and translates notification in the helper L{Win32Reactor} thread into a notification in the primary reactor thread. @ivar _reactor: The primary reactor, the one to which event notification will be sent. @ivar _fd: The L{FileDescriptor} to which the event will be dispatched. @ivar _action: A C{str} giving the method of C{_fd} which handles the event. @ivar _logPrefix: The pre-fetched log prefix string for C{_fd}, so that C{_fd.logPrefix} does not need to be called in a non-main thread. c C s || _ || _|| _|| _d S r )�_reactor�_fd�_action� _logPrefix)r& rE r r' � logPrefixr r r r$ I s z_ThreadFDWrapper.__init__c C s | j S )zc Return the original handler's log prefix, as it was given to C{__init__}. )rq r% r r r rr O s z_ThreadFDWrapper.logPrefixc s t � j� fdd��S )a- Callback fired when the associated event is set. Run the C{action} callback on the wrapped descriptor in the main reactor thread and raise or return whatever it raises or returns to cause this event handler to be removed from C{self._reactor} if appropriate. c s t � j� j�� S r )rg ro rp r r% r r �<lambda>^ s z+_ThreadFDWrapper._execute.<locals>.<lambda>)r rn r% r r% r �_executeV s �z_ThreadFDWrapper._executec C s | j �| jj|� dS )z� Pass through to the wrapped descriptor, but in the main reactor thread instead of the helper C{Win32Reactor} thread. N)rn �callFromThreadro rd )r& �reasonr r r rd a s z _ThreadFDWrapper.connectionLostN)rh ri rj rk r$ rr rt rd r r r r rm 9 s rm c @ s8 e Zd ZdZdZdZdd� Zdd� Zdd� Zd d � Z dS ) �_ThreadedWin32EventsMixina� This mixin implements L{IReactorWin32Events} for another reactor by running a L{Win32Reactor} in a separate thread and dispatching work to it. @ivar _reactor: The L{Win32Reactor} running in the other thread. This is L{None} until it is actually needed. @ivar _reactorThread: The L{threading.Thread} which is running the L{Win32Reactor}. This is L{None} until it is actually needed. Nc C s | j �| j j� d| _ dS )zP Stop and discard the reactor started by C{_makeHelperReactor}. N)rn ru rT r% r r r �_unmakeHelperReactory s z._ThreadedWin32EventsMixin._unmakeHelperReactorc C s@ t � | _d| j_t| jjdd�| _| �dd| j� | j�� dS )z� Create and (in a new thread) start a L{Win32Reactor} instance to use for the implementation of L{IReactorWin32Events}. F)F)�target�args�after�shutdownN) r rn �_registerAsIOThreadr �run�_reactorThread�addSystemEventTriggerrx �startr% r r r �_makeHelperReactor� s z,_ThreadedWin32EventsMixin._makeHelperReactorc C s: | j du r | �� | j �| j j|t| |||�� �d� dS )�. @see: L{IReactorWin32Events} Nrt )rn r� ru r, rm rr r+ r r r r, � s �z"_ThreadedWin32EventsMixin.addEventc C s | j �| j j|� dS )r� N)rn ru r. r- r r r r. � s z%_ThreadedWin32EventsMixin.removeEvent) rh ri rj rk rn r rx r� r, r. r r r r rw i s rw c C s* t �d� t� } ddlm} |�| � d S )Nr3 )�main)r �initr � r� �installReactor)�rr� r r r �install� s r� ),rk ra rL � threadingr �weakrefr �zope.interfacer � win32filer r r r r r � ImportError�warnings�warn� UserWarningrQ � win32eventr r r r r �twisted.internetr �twisted.internet.interfacesr r �twisted.internet.threadsr �twisted.pythonr r r r# r rm rw r� �__all__r r r r �<module> s> * � � Y07 PK Mb�Z�9^= = . internet/__pycache__/cfreactor.cpython-310.pycnu �[��� o �b[D � @ s� d Z ddgZddlZddlmZ ddlmZmZmZm Z m Z m Z m Z m Z mZmZmZ ddlmZmZmZmZmZmZmZmZmZmZm Z ddl m Z dd l m Z m!Z!m"Z" dd l#m$Z$ dZ%d Z&d Z'G d d� de"�Z(ee �G dd� de!��Z)ddd�Z*dS )z� A reactor for integrating with U{CFRunLoop<http://bit.ly/cfrunloop>}, the CoreFoundation main loop used by macOS. This is useful for integrating Twisted with U{PyObjC<http://pyobjc.sf.net/>} applications. �install� CFReactor� N)� implementer) �CFSocketCreateRunLoopSource�CFSocketCreateWithNative�CFSocketDisableCallBacks�CFSocketEnableCallBacks�CFSocketInvalidate�CFSocketSetSocketFlags�*kCFSocketAutomaticallyReenableReadCallBack�+kCFSocketAutomaticallyReenableWriteCallBack�kCFSocketConnectCallBack�kCFSocketReadCallBack�kCFSocketWriteCallBack) �CFAbsoluteTimeGetCurrent�CFRunLoopAddSource�CFRunLoopAddTimer�CFRunLoopGetMain�CFRunLoopRemoveSource� CFRunLoopRun� CFRunLoopStop�CFRunLoopTimerCreate�CFRunLoopTimerInvalidate�kCFAllocatorDefault�kCFRunLoopCommonModes)� IReactorFDSet)� _NO_FILEDESC�PosixReactorBase�_Waker)�log� �@ c @ s e Zd ZdZdd� ZdS )� _WakerPlusa� The normal Twisted waker will simply wake up the main loop, which causes an iteration to run, which in turn causes L{ReactorBase.runUntilCurrent} to get invoked. L{CFReactor} has a slightly different model of iteration, though: rather than have each iteration process the thread queue, then timed calls, then file descriptors, each callback is run as it is dispatched by the CFRunLoop observer which triggered it. So this waker needs to not only unblock the loop, but also make sure the work gets done; so, it reschedules the invocation of C{runUntilCurrent} to be immediate (0 seconds from now) even if there is no timed call work to do. c C s t �| �}| j�d� |S )zw Wake up the loop and force C{runUntilCurrent} to run immediately in the next timed iteration. T)r �doRead�reactor�_scheduleSimulate)�self�result� r( �</usr/lib/python3/dist-packages/twisted/internet/cfreactor.pyr# H s z_WakerPlus.doReadN)�__name__� __module__� __qualname__�__doc__r# r( r( r( r) r" 7 s r" c @ s� e Zd ZdZd/dd�Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd Zd d!� ZdZd0d"d#�Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd1d-d.�ZdS )2r a& The CoreFoundation reactor. You probably want to use this via the L{install} API. @ivar _fdmap: a dictionary, mapping an integer (a file descriptor) to a 4-tuple of: - source: a C{CFRunLoopSource}; the source associated with this socket. - socket: a C{CFSocket} wrapping the file descriptor. - descriptor: an L{IReadDescriptor} and/or L{IWriteDescriptor} provider. - read-write: a 2-C{list} of booleans: respectively, whether this descriptor is currently registered for reading or registered for writing. @ivar _idmap: a dictionary, mapping the id() of an L{IReadDescriptor} or L{IWriteDescriptor} to a C{fd} in L{_fdmap}. Implemented in this manner so that we don't have to rely (even more) on the hashability of L{IReadDescriptor} providers, and we know that they won't be collected since these are kept in sync with C{_fdmap}. Necessary because the .fileno() of a file descriptor may change at will, so we need to be able to look up what its file descriptor I{used} to be, so that we can look it up in C{_fdmap} @ivar _cfrunloop: the C{CFRunLoop} pyobjc object wrapped by this reactor. @ivar _inCFLoop: Is C{CFRunLoopRun} currently running? @type _inCFLoop: L{bool} @ivar _currentSimulator: if a CFTimer is currently scheduled with the CF run loop to run Twisted callLater calls, this is a reference to it. Otherwise, it is L{None} Nc C s@ i | _ i | _|d u r t}|| _|d u rt� }|| _t�| � d S �N)�_fdmap�_idmapr �_runnerr � _cfrunloopr �__init__)r& �runLoop�runnerr( r( r) r3 z s zCFReactor.__init__c C s2 | j st| �| _ | j�| j � | �| j � dS dS )z� Override C{installWaker} in order to use L{_WakerPlus}; otherwise this should be exactly the same as the parent implementation. N)�wakerr" �_internalReaders�add� addReader�r& r( r( r) � installWaker� s �zCFReactor.installWakerc sX |\}}|�j vrt�j|t� dS �j | \}} ��� ���fdd�} t��| � dS )a� The socket callback issued by CFRunLoop. This will issue C{doRead} or C{doWrite} calls to the L{IReadDescriptor} and L{IWriteDescriptor} registered with the file descriptor that we are being notified of. @param cfSocket: The C{CFSocket} which has got some activity. @param callbackType: The type of activity that we are being notified of. Either C{kCFSocketReadCallBack} or C{kCFSocketWriteCallBack}. @param ignoredAddress: Unused, because this is not used for either of the callback types we register for. @param ignoredData: Unused, because this is not used for either of the callback types we register for. @param context: The data associated with this callback by C{CFSocketCreateWithNative} (in C{CFReactor._watchFD}). A 2-tuple of C{(int, CFRunLoopSource)}. Nc s� d } d}z"�� � dkrt} n� tk}|r �t r ��� } n�t r%��� } W n ty9 t� � d } t � � Y nw | rE�� �| |� d S d S )NF���r ) �filenor r �_READr# �_WRITE�doWrite� BaseException�sys�exc_infor �err�_disconnectSelectable)�why�isRead�� callbackType�readWriteDescriptor�rwr& r( r) �_drdw� s( �� ��z(CFReactor._socketCallback.<locals>._drdw)r/ r r2 r r �callWithLogger) r& �cfSocketrI �ignoredAddress� ignoredData�context�fd� smugglesrc�src�sktrL r( rH r) �_socketCallback� s zCFReactor._socketCallbackc C s� |dkrt d��|| jv r| j| \}}}}nLg }|�|� tt|ttB tB | j|�}t |t t B t B � t t|d�}|�|� t| j|t� t|ttB tB � ddg}|| jt|�< ||||f| j|< d|| �|�< t||� dS )a� Register a file descriptor with the C{CFRunLoop}, or modify its state so that it's listening for both notifications (read and write) rather than just one; used to implement C{addReader} and C{addWriter}. @param fd: The file descriptor. @type fd: L{int} @param descr: the L{IReadDescriptor} or L{IWriteDescriptor} @param flag: the flag to register for callbacks on, either C{kCFSocketReadCallBack} or C{kCFSocketWriteCallBack} r< zInvalid file descriptor.r FTN)� RuntimeErrorr/ �appendr r r r r rV r r r �_preserveSOErrorr r r2 r r r0 �id� _flag2idxr ) r& rR �descr�flagrT �cfs�gotdescrrK �ctxr( r( r) �_watchFD� sR ��� ��� ���zCFReactor._watchFDc C s t ttti| S )a- Convert a C{kCFSocket...} constant to an index into the read/write state list (C{_READ} or C{_WRITE}) (the 4th element of the value of C{self._fdmap}). @param flag: C{kCFSocketReadCallBack} or C{kCFSocketWriteCallBack} @return: C{_READ} or C{_WRITE} )r r> r r? )r& r] r( r( r) r[ s zCFReactor._flag2idxc C s� t |�| jvr dS |dkr| jt |� }n|}| j| \}}}}t||� d|| �|�< |t sK|t sM| jt |�= | j|= t| j|t � t |� dS dS dS )a� Unregister a file descriptor with the C{CFRunLoop}, or modify its state so that it's listening for only one notification (read or write) as opposed to both; used to implement C{removeReader} and C{removeWriter}. @param fd: a file descriptor @type fd: C{int} @param descr: an L{IReadDescriptor} or L{IWriteDescriptor} @param flag: C{kCFSocketWriteCallBack} C{kCFSocketReadCallBack} Nr< F) rZ r0 r/ r r[ r> r? r r2 r r )r& rR r\ r] �realfdrT r^ rK r( r( r) � _unwatchFD s �zCFReactor._unwatchFDc C � | � |�� |t� dS )z7 Implement L{IReactorFDSet.addReader}. N)ra r= r �r& �readerr( r( r) r9 7 � zCFReactor.addReaderc C rd )z7 Implement L{IReactorFDSet.addWriter}. N)ra r= r �r& �writerr( r( r) � addWriter= rg zCFReactor.addWriterc C rd )z: Implement L{IReactorFDSet.removeReader}. N)rc r= r re r( r( r) � removeReaderC rg zCFReactor.removeReaderc C rd )z: Implement L{IReactorFDSet.removeWriter}. N)rc r= r rh r( r( r) � removeWriterI rg zCFReactor.removeWriterc C sH dd� | j �� D �}|t| j�8 }|D ] }| �|� | �|� qt|�S )z7 Implement L{IReactorFDSet.removeAll}. c S s h | ]\}}}}|�qS r( r( ��.0rT r^ r\ rK r( r( r) � <setcomp>S s z&CFReactor.removeAll.<locals>.<setcomp>)r/ �values�setr7 rk rl �list)r& �allDesc�descr( r( r) � removeAllO s zCFReactor.removeAllc C � dd� | j �� D �S )z8 Implement L{IReactorFDSet.getReaders}. c S � g | ] \}}}}|t r|�qS r( )r> rm r( r( r) � <listcomp>^ � z(CFReactor.getReaders.<locals>.<listcomp>�r/ rp r: r( r( r) � getReadersZ � zCFReactor.getReadersc C rv )z8 Implement L{IReactorFDSet.getWriters}. c S rw r( )r? rm r( r( r) rx d ry z(CFReactor.getWriters.<locals>.<listcomp>rz r: r( r( r) � getWriters` r| zCFReactor.getWritersc C s t �| |�}| �� |S )aw Override L{PosixReactorBase}'s implementation of L{IDelayedCall.reset} so that it will immediately reschedule. Normally C{_moveCallLaterSooner} depends on the fact that C{runUntilCurrent} is always run before the mainloop goes back to sleep, so this forces it to immediately recompute how long the loop needs to stay asleep. )r �_moveCallLaterSoonerr% )r& �tpler' r( r( r) r~ f s z CFReactor._moveCallLaterSoonerFc C s$ d| _ z | �� W d| _ dS d| _ w )z� Run the runner (C{CFRunLoopRun} or something that calls it), which runs the run loop until C{crash()} is called. TFN)� _inCFLoopr1 r: r( r( r) �mainLoopt s zCFReactor.mainLoopc sx � j dur t� j � d� _ � �� }|rd}|dur:t� | }� fdd�}tt|ddd|d� }� _ t� j|t� dS dS )aV Schedule a call to C{self.runUntilCurrent}. This will cancel the currently scheduled call if it is already scheduled. @param force: Even if there are no timed calls, make sure that C{runUntilCurrent} runs immediately (in a 0-seconds-from-now C{CFRunLoopTimer}). This is necessary for calls which need to trigger behavior of C{runUntilCurrent} other than running timed calls, such as draining the thread call queue or calling C{crash()} when the appropriate flags are set. @type force: C{bool} Ng c s d � _ � �� � �� d S r. )�_currentSimulator�runUntilCurrentr% )�cftimer�extrar: r( r) �simulate� s z-CFReactor._scheduleSimulate.<locals>.simulater ) r� r �timeoutr r r r r2 r )r& �forcer� �fireDater� �cr( r: r) r% � s ��zCFReactor._scheduleSimulatec O s( t j| ||g|�R i |��}| �� |S )z6 Implement L{IReactorTime.callLater}. )r � callLaterr% )r& �_seconds�_f�args�kw� delayedCallr( r( r) r� � s zCFReactor.callLaterc C s t �| � | �d� dS )z1 Implement L{IReactorCore.stop}. TN)r �stopr% r: r( r( r) r� � s zCFReactor.stopc C s< | j }t�| � | jr| �� dS |r | �d| j� dS dS )z1 Implement L{IReactorCore.crash} r N)�_startedr �crashr� �_stopNowr� )r& � wasStartedr( r( r) r� � s �zCFReactor.crashc C s t | j� dS )zJ Immediately stop the CFRunLoop (which must be running!). N)r r2 r: r( r( r) r� � s zCFReactor._stopNowr c C s | � || j� | �� dS )z� Emulate the behavior of C{iterate()} for things that want to call it, by letting the loop run for a little while and then scheduling a timed call to exit it. N)r� r� r� )r& �delayr( r( r) �iterate� s zCFReactor.iterate�NN)F)r )r* r+ r, r- r3 r; rV ra r[ rc r9 rj rk rl ru r{ r} r~ r� r� r� r% r� r� r� r� r� r( r( r( r) r R s2 & B; ! c C s$ t | |d�}ddlm} ||� |S )a6 Configure the twisted mainloop to be run inside CFRunLoop. @param runLoop: the run loop to use. @param runner: the function to call in order to actually invoke the main loop. This will default to C{CFRunLoopRun} if not specified. However, this is not an appropriate choice for GUI applications, as you need to run NSApplicationMain (or something like it). For example, to run the Twisted mainloop in a PyObjC application, your C{main.py} should look something like this:: from PyObjCTools import AppHelper from twisted.internet.cfreactor import install install(runner=AppHelper.runEventLoop) # initialize your application reactor.run() @return: The installed reactor. @rtype: C{CFReactor} )r4 r5 r )�installReactor)r �twisted.internet.mainr� )r4 r5 r$ r� r( r( r) r � s r� )+r- �__all__rB �zope.interfacer � CFNetworkr r r r r r r r r r r �CoreFoundationr r r r r r r r r r r �twisted.internet.interfacesr �twisted.internet.posixbaser r r �twisted.pythonr r> r? rY r" r r r( r( r( r) �<module> s$ 44 |PK Mb�Z[B�� - internet/__pycache__/_signals.cpython-310.pycnu �[��� o �bn � @ s d Z ddlZdd� Zdd� ZdS )a9 This module is used to integrate child process termination into a reactor event loop. This is a challenging feature to provide because most platforms indicate process termination via SIGCHLD and do not provide a way to wait for that signal and arbitrary I/O events at the same time. The naive implementation involves installing a Python SIGCHLD handler; unfortunately this leads to other syscalls being interrupted (whenever SIGCHLD is received) and failing with EINTR (which almost no one is prepared to handle). This interruption can be disabled via siginterrupt(2) (or one of the equivalent mechanisms); however, if the SIGCHLD is delivered by the platform to a non-main thread (not a common occurrence, but difficult to prove impossible), the main thread (waiting on select() or another event notification API) may not wake up leading to an arbitrary delay before the child termination is noticed. The basic solution to all these issues involves enabling SA_RESTART (ie, disabling system call interruption) and registering a C signal handler which writes a byte to a pipe. The other end of the pipe is registered with the event loop, allowing it to wake up shortly after SIGCHLD is received. See L{twisted.internet.posixbase._SIGCHLDWaker} for the implementation of the event loop side of this solution. The use of a pipe this way is known as the U{self-pipe trick<http://cr.yp.to/docs/selfpipe.html>}. From Python version 2.6, C{signal.siginterrupt} and C{signal.set_wakeup_fd} provide the necessary C signal handler which writes to the pipe to be registered with C{SA_RESTART}. � Nc C sH | dkr t � t jt j� ndd� }t � t j|� t �t jd� t �| �S )a� Install a signal handler which will write a byte to C{fd} when I{SIGCHLD} is received. This is implemented by installing a SIGCHLD handler that does nothing, setting the I{SIGCHLD} handler as not allowed to interrupt system calls, and using L{signal.set_wakeup_fd} to do the actual writing. @param fd: The file descriptor to which to write when I{SIGCHLD} is received. @type fd: C{int} ���c W s d S )N� )�argsr r �;/usr/lib/python3/dist-packages/twisted/internet/_signals.py�noopSignalHandler8 s z)installHandler.<locals>.noopSignalHandlerF)�signal�SIGCHLD�SIG_DFL� siginterrupt� set_wakeup_fd)�fdr r r r �installHandler' s r c C s t �t j�t jkS )zI Determine whether the I{SIGCHLD} handler is the default or not. )r � getsignalr r r r r r �isDefaultHandler@ s r )�__doc__r r r r r r r �<module> s PK Mb�Z��Y� � 1 internet/__pycache__/glib2reactor.cpython-310.pycnu �[��� o �b[ � @ s4 d Z ddlmZ G dd� dej�Zdd� ZdgZdS )a� This module provides support for Twisted to interact with the glib mainloop. This is like gtk2, but slightly faster and does not require a working $DISPLAY. However, you cannot run GUIs under this reactor: for that you must use the gtk2reactor instead. In order to use this support, simply do the following:: from twisted.internet import glib2reactor glib2reactor.install() Then use twisted.internet APIs as usual. The other methods here are not intended to be called directly. � )� gtk2reactorc @ s e Zd ZdZdd� ZdS )� Glib2Reactorz. The reactor using the glib mainloop. c C s t jj| dd� dS )z: Override init to set the C{useGtk} flag. F)�useGtkN)r � Gtk2Reactor�__init__)�self� r �?/usr/lib/python3/dist-packages/twisted/internet/glib2reactor.pyr s zGlib2Reactor.__init__N)�__name__� __module__� __qualname__�__doc__r r r r r r s r c C s t � } ddlm} || � dS )zL Configure the twisted mainloop to be run inside the glib mainloop. r )�installReactorN)r �twisted.internet.mainr )�reactorr r r r �install" s r N)r �twisted.internetr r r r �__all__r r r r �<module> s PK Mb�Z��B " " , internet/__pycache__/_newtls.cpython-310.pycnu �[��� o �b�# � @ s| d Z ddlmZ ddlmZ ddlmZ ddlmZm Z G dd� d�Z dd � Z G d d � d �Z G d d � d �Z G dd� d�ZdS )z� This module implements memory BIO based TLS support. It is the preferred implementation and will be used whenever pyOpenSSL 0.10 or newer is installed (whenever L{twisted.protocols.tls} is importable). @since: 11.1 � )�directlyProvides)�FileDescriptor)� ISSLTransport)�TLSMemoryBIOFactory�TLSMemoryBIOProtocolc @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )� _BypassTLSa L{_BypassTLS} is used as the transport object for the TLS protocol object used to implement C{startTLS}. Its methods skip any TLS logic which C{startTLS} enables. @ivar _base: A transport class L{_BypassTLS} has been mixed in with to which methods will be forwarded. This class is only responsible for sending bytes over the connection, not doing TLS. @ivar _connection: A L{Connection} which TLS has been started on which will be proxied to by this object. Any method which has its behavior altered after C{startTLS} will be skipped in favor of the base class's implementation. This allows the TLS protocol object to have direct access to the transport, necessary to actually implement TLS. c C s || _ || _d S )N)�_base� _connection)�self�base� connection� r �:/usr/lib/python3/dist-packages/twisted/internet/_newtls.py�__init__& s z_BypassTLS.__init__c C s t | j|�S )z� Forward any extra attribute access to the original transport object. For example, this exposes C{getHost}, the behavior of which does not change after TLS is enabled. )�getattrr )r �namer r r � __getattr__* s z_BypassTLS.__getattr__c C � | j �| j|�S )z> Write some bytes directly to the connection. )r �writer )r �datar r r r 2 � z_BypassTLS.writec C r )z@ Write a some bytes directly to the connection. )r � writeSequencer �r �iovecr r r r 8 r z_BypassTLS.writeSequencec O s | j j| jg|�R i |��S )z2 Close the underlying connection. )r �loseConnectionr )r �args�kwargsr r r r > s z_BypassTLS.loseConnectionc C s | j �| j||�S )zE Register a producer with the underlying connection. )r �registerProducerr �r �producer� streamingr r r r D � z_BypassTLS.registerProducerc C s | j �| j�S )zG Unregister a producer with the underlying connection. )r �unregisterProducerr �r r r r r" J s z _BypassTLS.unregisterProducerN) �__name__� __module__� __qualname__�__doc__r r r r r r r" r r r r r s r c C s� |r| j }n| j }d\}}| jdur | j| j}}| �� t||d�}t|| jd�}|| _|j| _|j| _t | t � d| _ | j� t || �� |rQ| �||� dS dS )a` Add a layer of SSL to a transport. @param transport: The transport which will be modified. This can either by a L{FileDescriptor<twisted.internet.abstract.FileDescriptor>} or a L{FileHandle<twisted.internet.iocpreactor.abstract.FileHandle>}. The actual requirements of this instance are that it have: - a C{_tlsClientDefault} attribute indicating whether the transport is a client (C{True}) or a server (C{False}) - a settable C{TLS} attribute which can be used to mark the fact that SSL has been started - settable C{getHandle} and C{getPeerCertificate} attributes so these L{ISSLTransport} methods can be added to it - a C{protocol} attribute referring to the L{IProtocol} currently connected to the transport, which can also be set to a new L{IProtocol} for the transport to deliver data to @param contextFactory: An SSL context factory defining SSL parameters for the new SSL layer. @type contextFactory: L{twisted.internet.interfaces.IOpenSSLContextFactory} @param normal: A flag indicating whether SSL will go in the same direction as the underlying transport goes. That is, if the SSL client will be the underlying client and the SSL server will be the underlying server. C{True} means it is the same, C{False} means they are switched. @type normal: L{bool} @param bypass: A transport base class to call methods on to bypass the new SSL layer (so that the SSL layer itself can send its bytes). @type bypass: L{type} )NNNFT)�_tlsClientDefaultr �streamingProducerr" r r �protocol� getHandle�getPeerCertificater r �TLS�makeConnectionr r ) � transport�contextFactory�normal�bypass�clientr r � tlsFactory� tlsProtocolr r r �startTLSQ s$ % �r6 c @ sF e Zd ZdZdZddd�Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�ConnectionMixinaN A mixin for L{twisted.internet.abstract.FileDescriptor} which adds an L{ITLSTransport} implementation. @ivar TLS: A flag indicating whether TLS is currently in use on this transport. This is not a good way for applications to check for TLS, instead use L{twisted.internet.interfaces.ISSLTransport}. FTc C s t | ||t� dS )z1 @see: L{ITLSTransport.startTLS} N)r6 r )r �ctxr1 r r r r6 � r! zConnectionMixin.startTLSc C �0 | j r| jr| j�|� dS dS t�| |� dS )z� Write some bytes to this connection, passing them through a TLS layer if necessary, or discarding them if the connection has already been lost. N)r- � connectedr* r r )r �bytesr r r r � s �zConnectionMixin.writec C r9 )z� Write some bytes to this connection, scatter/gather-style, passing them through a TLS layer if necessary, or discarding them if the connection has already been lost. N)r- r: r* r r r r r r r � s �z ConnectionMixin.writeSequencec C s6 | j r| jr| js| j�� dS dS dS t�| � dS )z� Close this connection after writing all pending data. If TLS has been negotiated, perform a TLS shutdown. N)r- r: � disconnectingr* r r r# r r r r � s �z ConnectionMixin.loseConnectionc C s* | j r | j�||� dS t�| ||� dS )zc Register a producer. If TLS is enabled, the TLS connection handles this. N)r- r* r r r r r r r � s z ConnectionMixin.registerProducerc C s" | j r | j�� dS t�| � dS )ze Unregister a producer. If TLS is enabled, the TLS connection handles this. N)r- r* r" r r# r r r r" � s z"ConnectionMixin.unregisterProducerN)T) r$ r% r& r' r- r6 r r r r r" r r r r r7 � s r7 c @ � e Zd ZdZdZdS )� ClientMixina= A mixin for L{twisted.internet.tcp.Client} which just marks it as a client for the purposes of the default TLS handshake. @ivar _tlsClientDefault: Always C{True}, indicating that this is a client connection, and by default when TLS is negotiated this class will act as a TLS client. TN�r$ r% r& r' r( r r r r r> � � r> c @ r= )� ServerMixina> A mixin for L{twisted.internet.tcp.Server} which just marks it as a server for the purposes of the default TLS handshake. @ivar _tlsClientDefault: Always C{False}, indicating that this is a server connection, and by default when TLS is negotiated this class will act as a TLS server. FNr? r r r r rA � r@ rA N)r' �zope.interfacer �twisted.internet.abstractr �twisted.internet.interfacesr �twisted.protocols.tlsr r r r6 r7 r> rA r r r r �<module> s <GP PK Mb�Z���W\� \� ( internet/__pycache__/tcp.cpython-310.pycnu �[��� o 5�@g�� � @ s d Z ddlZddlZddlZddlZddlmZmZmZm Z m Z ddl m Z m Z ddlZddlmZmZmZmZ ddlmZmZmZ ddlmZmZ ddlm Z dd l m Z zdd l m Z!m"Z#m$Z% dd lm&Z& W n e'y� e Z&G d d � d �Z#G dd� d�Z!G dd� d�Z%Y nw e dkr�e(� Z)ddl*m+Z,m-Z.m/Z0m1Z2m3Z4m5Z6m7Z8 e(� Z9e(� Z:e8Z;ddl*m<Z= ddl>m?Z@ nNddl*m)Z) ddl*m0Z0 ddl*m8Z8 ddl*m.Z. ddl*m,Z, ddl*m2Z2 dd l*m6Z6 dd l*m4Z4 dd l*m9Z9 dd l*m:Z: dd l*m;Z; dd!l*m=Z= dd"lm@Z@ dd#l*mAZA dd$lBmCZCmDZDmEZEmFZFmGZGmHZH dd%lImJZJ dd&lKm Z dd'lLmMZM dd(lmNZNmOZOmPZP dd)lQmRZR eSed*d�ZTd+d,� ZUd-d.� ZVd/d0� ZWG d1d2� d2�ZXG d3d4� d4�ZYe e&ee�G d5d6� d6e#eCjZeXeY��Z[G d7d8� d8�Z\G d9d:� d:e\e!e[�Z]ej^eTB Z_d;d<� Z`G d=d>� d>�ZaG d?d@� d@eae]�ZbG dAdB� dBe%e[�ZcG dCdD� dDe �ZdG dEdF� dFe �Zee ed�ejfdGdH�G dIdJ� dJ���Zge ed�G dKdL� dL��Zhe dk�r�eh� ZinegdMdN� �Zie4e6e9e:e=fZjejfdGdH�G dOdP� dP��ZkdQdR� Zle e�G dSdT� dTeEjmeX��ZnG dUdV� dVeEjo�ZpdS )Wzt Various asynchronous TCP/IP classes. End users shouldn't use this module directly - use the reactor APIs instead. � N)�Callable�ClassVar�List�Optional�Protocol)� Interface� implementer)�IHalfCloseableProtocol�IListeningPort� ISystemHandle� ITCPTransport)� ILogObserver�LogEvent�Logger)� deprecate�versions)� lazyByteSlice)� platformType)� ClientMixin�ConnectionMixin� ServerMixin)� ITLSTransportc @ � e Zd ZdZdS )�_TLSConnectionMixinFN)�__name__� __module__� __qualname__�TLS� r r �6/usr/lib/python3/dist-packages/twisted/internet/tcp.pyr / � r c @ � e Zd ZdS )�_TLSClientMixinN�r r r r r r r r" 2 � r" c @ r! )�_TLSServerMixinNr# r r r r r% 5 r$ r% �win32)� WSAEALREADY�WSAEINPROGRESS� WSAEINVAL� WSAEISCONN� WSAEMFILE� WSAENOBUFS�WSAEWOULDBLOCK)� WSAECONNRESET)� formatError)�EPERM)�EINVAL)� EWOULDBLOCK)� EINPROGRESS)�EALREADY)�EISCONN)�ENOBUFS)�EMFILE)�ENFILE)�ENOMEM)�EAGAIN)� ECONNABORTED)�strerror)� errorcode)�abstract�address�base�error�fdesc�main)�CannotListenError)r )� deferLater)�failure�log�reflect)�untilConcludes�AI_NUMERICSERVc C sJ t | �dkr t�| tjtjB �d }t|gt| dd� � �S | dd� S )ai Return a 2-tuple of socket IP and port for IPv4 and a 4-tuple of socket IP, port, flowInfo, and scopeID for IPv6. For IPv6, it returns the interface portion (the part after the %) as a part of the IPv6 address, which Python 3.7+ does not include. @param addr: A 2-tuple for IPv4 information or a 4-tuple for IPv6 information. � r � N� )�len�socket� getnameinfo�NI_NUMERICHOST�NI_NUMERICSERV�tuple�list)�addr�hostr r r � _getrealnamem s � rW c C � t | �� �S �z See L{_getrealname}. )rW � getpeername��sktr r r � _getpeername� � r] c C rX rY )rW � getsocknamer[ r r r � _getsockname� r^ r` c @ � e Zd ZdZdZdd� ZdS )� _SocketCloserz� @ivar _shouldShutdown: Set to C{True} if C{shutdown} should be called before calling C{close} on the underlying socket. @type _shouldShutdown: C{bool} Tc C sv | j }z |r| jr|�d� n| j �t jt jt�ddd�� W n ty( Y nw z|� � W d S ty: Y d S w )NrM �iirL r ) rO �_shouldShutdown�shutdown� setsockopt� SOL_SOCKET� SO_LINGER�struct�pack�OSError�close)�self�orderlyr\ r r r � _closeSocket� s$ ��� � �z_SocketCloser._closeSocketN)r r r �__doc__rd ro r r r r rb � s rb c @ ra )�_AbortingMixinz� Common implementation of C{abortConnection}. @ivar _aborting: Set to C{True} when C{abortConnection} is called. @type _aborting: C{bool} Fc C sZ | j s| jrdS d| _| �� | �� dd� | _dd� | _| j�d| jt � t � � �� dS )zf Aborts the connection immediately, dropping any buffered data. @since: 11.1 NTc _ � d S �Nr ��args�kwargsr r r �<lambda>� � z0_AbortingMixin.abortConnection.<locals>.<lambda>c _ rr rs r rt r r r rw � rx r ) � disconnected� _aborting� stopReading� stopWriting�doRead�doWrite�reactor� callLater�connectionLostrF �FailurerA �ConnectionAborted�rm r r r �abortConnection� s �z _AbortingMixin.abortConnectionN)r r r rp rz r� r r r r rq � s rq c @ s~ e Zd ZdZd dd�Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dZ dd� Z dd� Zdd� Zdd� Zd d � ZdS ) � Connectiona Superclass of all socket-based FileDescriptors. This is an abstract superclass of all objects which represent a TCP/IP connection based socket. @ivar logstr: prefix used when logging events related to this connection. @type logstr: C{str} Nc C s4 t jj| |d� || _| j�d� |j| _|| _d S )N�r r )r> �FileDescriptor�__init__rO � setblocking�fileno�protocol)rm r\ r� r r r r r� � s zConnection.__init__c C � | j S )z&Return the socket for this connection.)rO r� r r r � getHandle� � zConnection.getHandlec C sd z | j �| j�}W n# ty, } z|jd tkr W Y d}~dS tjW Y d}~S d}~ww | �|�S )a\ Calls self.protocol.dataReceived with all available data. This reads up to self.bufferSize bytes of data from its socket, then calls self.dataReceived(data) to process it. If the connection is not lost through an error in the physical recv(), this function will return the result of the dataReceived call. r N) rO �recv� bufferSizerk ru r2 rC �CONNECTION_LOST� _dataReceived)rm �data�ser r r r} � s �� zConnection.doReadc C sV |st jS | j�|�}|d ur)| jj}d}tj|t�dddd�|d�}t�||� |S )NzPReturning a value other than None from %(fqpn)s is deprecated since %(version)s.�Twisted� r )�format) rC �CONNECTION_DONEr� � dataReceivedr �getDeprecationWarningStringr �Version�warnAboutFunction)rm r� �rval�offender� warningFormat� warningStringr r r r� � s �� zConnection._dataReceivedc C sj t |d| j�}zt| jj|�W S ty4 } z|jd ttfv r'W Y d}~dS t j W Y d}~S d}~ww )a Write as much as possible of the given data to this TCP connection. This sends up to C{self.SEND_LIMIT} bytes from C{data}. If the connection is lost, an exception is returned. Otherwise, the number of bytes successfully written is returned. r N) r � SEND_LIMITrI rO �sendrk ru r2 r6 rC r� )rm r� � limitedDatar� r r r � writeSomeData s ��zConnection.writeSomeDatac C sv z| j �d� W n ty Y nw t| jd �}|r9z|�� W d S ty8 t�� }t � � | � |� Y d S w d S �NrL ) rO re rk r r� �writeConnectionLost� BaseExceptionrF r� rG �errr� )rm �p�fr r r �_closeWriteConnection s � ��z Connection._closeWriteConnectionc C sX t | jd �}|r%z|�� W d S ty$ t�� | �t�� � Y d S w | �|� d S rs ) r r� �readConnectionLostr� rG r� r� rF r� )rm �reasonr� r r r r� + s �z Connection.readConnectionLostc C sP t | d�sdS tj�| |� | �|�tj� � | j}| `| ` | ` |�|� dS )z-See abstract.FileDescriptor.connectionLost().rO N) �hasattrr> r� r� ro �checkrA r� r� rO r� )rm r� r� r r r r� 6 s zConnection.connectionLost� Uninitializedc C r� )z<Return the prefix to log with when I own the logging thread.)�logstrr� r r r � logPrefixI r� zConnection.logPrefixc C � t | j�tjtj��S rs )�boolrO � getsockopt� IPPROTO_TCP� TCP_NODELAYr� r r r � getTcpNoDelayM � zConnection.getTcpNoDelayc C � | j �t jt j|� d S rs )rO rf r� r� �rm �enabledr r r � setTcpNoDelayP � zConnection.setTcpNoDelayc C r� rs )r� rO r� rg � SO_KEEPALIVEr� r r r �getTcpKeepAliveS r� zConnection.getTcpKeepAlivec C r� rs )rO rf rg r� r� r r r �setTcpKeepAliveV r� zConnection.setTcpKeepAlivers )r r r rp r� r� r} r� r� r� r� r� r� r� r� r� r� r� r r r r r� � s r� c @ sL e Zd ZdZejZejZdd� Z dd� Z dd� Z dd � Z d d � Z d d � ZdS )�_BaseBaseClienta� Code shared with other (non-POSIX) reactors for management of general outgoing connections. Requirements upon subclasses are documented as instance variables rather than abstract methods, in order to avoid MRO confusion, since this base is mixed in to unfortunately weird and distinctive multiple-inheritance hierarchies and many of these attributes are provided by peer classes rather than descendant classes in those hierarchies. @ivar addressFamily: The address family constant (C{socket.AF_INET}, C{socket.AF_INET6}, C{socket.AF_UNIX}) of the underlying socket of this client connection. @type addressFamily: C{int} @ivar socketType: The socket type constant (C{socket.SOCK_STREAM} or C{socket.SOCK_DGRAM}) of the underlying socket. @type socketType: C{int} @ivar _requiresResolution: A flag indicating whether the address of this client will require name resolution. C{True} if the hostname of said address indicates a name that must be resolved by hostname lookup, C{False} if it indicates an IP address literal. @type _requiresResolution: C{bool} @cvar _commonConnection: Subclasses must provide this attribute, which indicates the L{Connection}-alike class to invoke C{__init__} and C{connectionLost} on. @type _commonConnection: C{type} @ivar _stopReadingAndWriting: Subclasses must implement in order to remove this transport from its reactor's notifications in response to a terminated connection attempt. @type _stopReadingAndWriting: 0-argument callable returning L{None} @ivar _closeSocket: Subclasses must implement in order to close the socket in response to a terminated connection attempt. @type _closeSocket: 1-argument callable; see L{_SocketCloser._closeSocket} @ivar _collectSocketDetails: Clean up references to the attached socket in its underlying OS resource (such as a file descriptor or file handle), as part of post connection-failure cleanup. @type _collectSocketDetails: 0-argument callable returning L{None}. @ivar reactor: The class pointed to by C{_commonConnection} should set this attribute in its constructor. @type reactor: L{twisted.internet.interfaces.IReactorTime}, L{twisted.internet.interfaces.IReactorCore}, L{twisted.internet.interfaces.IReactorFDSet} c C s: |r| j �| |d|� |�d|� dS |�d| j|� dS )ax Called by subclasses to continue to the stage of initialization where the socket connect attempt is made. @param whenDone: A 0-argument callable to invoke once the connection is set up. This is L{None} if the connection could not be prepared due to a previous error. @param skt: The socket object to use to perform the connection. @type skt: C{socket._socketobject} @param error: The error to fail the connection with. @param reactor: The reactor to use for this client. @type reactor: L{twisted.internet.interfaces.IReactorTime} Nr )�_commonConnectionr� r� �failIfNotConnected)rm �whenDoner\ rA r r r r � _finishInit� s z_BaseBaseClient._finishInitc sN � j r � j�� jd �}|�� fdd�� |�� j� j� dS � �� j� dS )a� Resolve the name that was passed to this L{_BaseBaseClient}, if necessary, and then move on to attempting the connection once an address has been determined. (The connection will be attempted immediately within this function if either name resolution can be synchronous or the address was an IP address literal.) @note: You don't want to call this method from outside, as it won't do anything useful; it's just part of the connection bootstrapping process. Also, although this method is on L{_BaseBaseClient} for historical reasons, it's not used anywhere except for L{Client} itself. @return: L{None} r c s | f� j dd � S r� )rU )�nr� r r rw � s z0_BaseBaseClient.resolveAddress.<locals>.<lambda>N)�_requiresResolutionr �resolverU � addCallback� addCallbacks�_setRealAddressr� )rm �dr r� r �resolveAddress� s z _BaseBaseClient.resolveAddressc C sT t |�dkr!t�|tjtjB �d }t|gt|dd� � �| _n|| _| �� dS )a� Set the resolved address of this L{_BaseBaseClient} and initiate the connection attempt. @param address: Depending on whether this is an IPv4 or IPv6 connection attempt, a 2-tuple of C{(host, port)} or a 4-tuple of C{(host, port, flow, scope)}. At this point it is a fully resolved address, and the 'host' portion will always be an IP address, not a DNS name. rK r rL N) rN rO rP rQ rR rS rT � realAddress� doConnect)rm r? �hostnamer r r r� � s �� z _BaseBaseClient._setRealAddressc C sf | j s | js t| d�s dS | �� z| �d� W n ty! Y nw | �� | j�t � |�� | `dS )z� Generic method called when the attempts to connect failed. It basically cleans everything it can: call connectionFailed, stop read and write, delete socket related members. � connectorNT) � connectedry r� �_stopReadingAndWritingro �AttributeError�_collectSocketDetailsr� �connectionFailedrF r� )rm r� r r r r� � s �z"_BaseBaseClient.failIfNotConnectedc C s | � t�� � dS )z� If a connection attempt is still outstanding (i.e. no connection is yet established), immediately stop attempting to connect. N)r� rA � UserErrorr� r r r �stopConnecting� s z _BaseBaseClient.stopConnectingc C s: | j s| �tj|d�� dS | j�| |� | j�|� dS )a� Invoked by lower-level logic when it's time to clean the socket up. Depending on the state of the connection, either inform the attached L{Connector} that the connection attempt has failed, or inform the connected L{IProtocol} that the established connection has been lost. @param reason: the reason that the connection was terminated @type reason: L{Failure} ��stringN)r� r� rA � ConnectErrorr� r� r� �rm r� r r r r� � s z _BaseBaseClient.connectionLostN)r r r rp rO �AF_INET� addressFamily� SOCK_STREAM� socketTyper� r� r� r� r� r� r r r r r� Z s 3 r� c @ s@ e Zd ZdZeZeZdd� Zdd� Zdd� Z dd � Z d d � Z d S ) � BaseClienta� A base class for client TCP (and similar) sockets. @ivar realAddress: The address object that will be used for socket.connect; this address is an address tuple (the number of elements dependent upon the address family) which does not contain any names which need to be resolved. @type realAddress: C{tuple} @ivar _base: L{Connection}, which is the base class of this class which has all of the useful file descriptor methods. This is used by L{_TLSServerMixin} to call the right methods to directly manipulate the transport, as is necessary for writing TLS-encrypted bytes (whereas those methods on L{Server} will go through another layer of TLS if it has been enabled). c C s" t | d�r| �� | �� dS dS )z� Implement the POSIX-ish (i.e. L{twisted.internet.interfaces.IReactorFDSet}) method of detaching this socket from the reactor for L{_BaseBaseClient}. r N)r� r{ r| r� r r r r� s �z!BaseClient._stopReadingAndWritingc C s | ` | `dS )zn Clean up references to the socket and its file descriptor. @see: L{_BaseBaseClient} N)rO r� r� r r r r� s z BaseClient._collectSocketDetailsc C s, t � | j| j�}|�d� t�|�� � |S )zc(internal) Create a non-blocking socket using self.addressFamily, self.socketType. r )rO r� r� r� rB �_setCloseOnExecr� �rm �sr r r �createInternetSocket' s z BaseClient.createInternetSocketc C s | j | _| j | _t| d�sdS | j�tjtj�}|r(| �t � |t |�f�� dS z | j� | j �}W n tyH } z |jd }W Y d}~nd}~ww |rw|tkrPn'|tttfv s_|tkritdkri| �� | �� dS | �t � |t |�f�� dS | `| `| �� | �� | �� dS )z� Initiate the outgoing connection attempt. @note: Applications do not need to call this method; it will be invoked internally as part of L{IReactorTCP.connectTCP}. r� Nr r& )r� r~ r} r� rO r� rg �SO_ERRORr� rA �getConnectErrorr< � connect_exr� rk ru r5 r2 r3 r4 r1 r � startReading� startWritingr{ r| � _connectDone)rm r� � connectResultr� r r r r� 0 s> ��� zBaseClient.doConnectc C sd | j �| �� �| _d| _| �| j�}d| | _| jdu r&t� | _| �� dS | � � | j� | � dS )a� This is a hook for when a connection attempt has succeeded. Here, we build the protocol from the L{twisted.internet.protocol.ClientFactory} that was passed in, compute a log string, begin reading so as to send traffic to the newly built protocol, and finally hook up the protocol itself. This hook is overridden by L{ssl.Client} to initiate the TLS protocol. rL z %s,clientN) r� � buildProtocol�getPeerr� r� � _getLogPrefixr� r �loseConnectionr� �makeConnection)rm r� r r r r� h s zBaseClient._connectDoneN) r r r rp r� �_baser� r� r� r� r� r� r r r r r� � s 8r� c C s t �| |dddt�d d S )av Resolve an IPv6 literal into an IPv6 address. This is necessary to resolve any embedded scope identifiers to the relevant C{sin6_scope_id} for use with C{socket.connect()}, C{socket.listen()}, or C{socket.bind()}; see U{RFC 3493 <https://tools.ietf.org/html/rfc3493>} for more information. @param ip: An IPv6 address literal. @type ip: C{str} @param port: A port number. @type port: C{int} @return: a 4-tuple of C{(host, port, flow, scope)}, suitable for use as an IPv6 address. @raise socket.gaierror: if either the IP or port is not numeric as it should be. r rK )rO � getaddrinfo� _NUMERIC_ONLY)�ip�portr r r � _resolveIPv6� s r� c @ s> e Zd ZdZejZd dd�Zdd� Zdd� Z d e fd d �Z dS ) �_BaseTCPClienta� Code shared with other (non-POSIX) reactors for management of outgoing TCP connections (both TCPv4 and TCPv6). @note: In order to be functional, this class must be mixed into the same hierarchy as L{_BaseBaseClient}. It would subclass L{_BaseBaseClient} directly, but the class hierarchy here is divided in strange ways out of the need to share code along multiple axes; specifically, with the IOCP reactor and also with UNIX clients in other reactors. @ivar _addressType: The Twisted _IPAddress implementation for this client @type _addressType: L{IPv4Address} or L{IPv6Address} @ivar connector: The L{Connector} which is driving this L{_BaseTCPClient}'s connection attempt. @ivar addr: The address that this socket will be connecting to. @type addr: If IPv4, a 2-C{tuple} of C{(str host, int port)}. If IPv6, a 4-C{tuple} of (C{str host, int port, int ignored, int scope}). @ivar createInternetSocket: Subclasses must implement this as a method to create a python socket object of the appropriate address family and socket type. @type createInternetSocket: 0-argument callable returning C{socket._socketobject}. Nc C s> || _ ||f| _| j}d }d }t�|�rd| _nt�|�r/d| _t||�| _tj | _ t j | _ nd| _z| �� }W n tyX } zt�| jd | jd �}d }W Y d } ~ nd } ~ ww |r�|d ur�zt�|d �rlt|� } n|} |�| � W n ty� } zt�| jd | jd �}d }W Y d } ~ nd } ~ ww | �||||� d S )NFTr rL )r� rU r� r> � isIPAddressr� � isIPv6Addressr� rO �AF_INET6r� r? � IPv6Address� _addressTyper� rk rA �ConnectBindErrorru �bindr� ) rm rV r� � bindAddressr� r r� r� r\ r� �bindinfor r r r� � s@ �� ��z_BaseTCPClient.__init__c C s | j dgt| j��R � S )z~ Returns an L{IPv4Address} or L{IPv6Address}. This indicates the address from which I am connecting. �TCP)r� r` rO r� r r r �getHost� s z_BaseTCPClient.getHostc C � | j dg| j�R � S )zz Returns an L{IPv4Address} or L{IPv6Address}. This indicates the address that I am connected to. r )r� r� r� r r r r� � � z_BaseTCPClient.getPeer�returnc C s& d| j � d| j� dt| �d�d�}|S )N�<z to z at �x�>)� __class__rU �idr� r r r �__repr__� s "z_BaseTCPClient.__repr__rs ) r r r rp r? � IPv4Addressr� r� r r� �strr r r r r r� � s #r� c @ r )�Clientz� A transport for a TCP protocol; either TCPv4 or TCPv6. Do not create these directly; use L{IReactorTCP.connectTCP}. N)r r r rp r r r r r � r r c @ sL e Zd ZdZeZejZdd� Z de fdd�Z e dd� �Z d d � Zd d � Zd S )�Servera< Serverside socket-stream connection class. This is a serverside network connection transport; a socket which came from an accept() on a server. @ivar _base: L{Connection}, which is the base class of this class which has all of the useful file descriptor methods. This is used by L{_TLSServerMixin} to call the right methods to directly manipulate the transport, as is necessary for writing TLS-encrypted bytes (whereas those methods on L{Server} will go through another layer of TLS if it has been enabled). c C s� t �| |||� t|�dkrtj| _|| _|| _|| _|d | _ | � | j �}|� d|� d| j � �| _ | jdurEd� | j jj| j| jj�| _| �� d| _dS )a Server(sock, protocol, client, server, sessionno) Initialize it with a socket, a protocol, a descriptor for my peer (a tuple of host, port describing the other end of the connection), an instance of Port, and a session number. rM r �,N�<{} #{} on {}>rL )r� r� rN r? r� r� �server�client� sessionnor� r� r� r� r� r r �_realPortNumber�repstrr� r� )rm �sockr� r r r r r� r r r r� s" � zServer.__init__r c C r� )z= A string representation of this connection. )r r� r r r r , s zServer.__repr__c C s� t j}|tjkr t j}t�||tj�}t|�}|dg|�R � }|�� d } |� |�} | du r4|� � dS | || |d|d |�} d� | j j j| j| �| _| �| � | S )a� Create a new L{Server} based on an existing connected I{SOCK_STREAM} socket. Arguments are the same as to L{Server.__init__}, except where noted. @param fileDescriptor: An integer file descriptor associated with a connected socket. The socket must be in non-blocking mode. Any additional attributes desired, such as I{FD_CLOEXEC}, must also be set already. @param addressFamily: The address family (sometimes called I{domain}) of the existing socket. For example, L{socket.AF_INET}. @return: A new instance of C{cls} wrapping the socket given by C{fileDescriptor}. r rL Nr )r? r rO r� r� �fromfdr� r] r_ r� rl r� r� r r r r r� ) �cls�fileDescriptorr� �factoryr � addressTyper\ rU � protocolAddr� localPortr� rm r r r �_fromConnectedSocket2 s& � zServer._fromConnectedSocketc C � t | j�}| jdg|�R � S )zl Returns an L{IPv4Address} or L{IPv6Address}. This indicates the server's address. r �r` rO r� �rm rU r r r r [ s zServer.getHostc C r )zl Returns an L{IPv4Address} or L{IPv6Address}. This indicates the client's address. r )r� r r� r r r r� d r zServer.getPeerN)r r r rp r� r� r? r r� r� r r � classmethodr" r r� r r r r r � s ( r c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �_IFileDescriptorReservationaT An open file that represents an emergency reservation in the process' file descriptor table. If L{Port} encounters C{EMFILE} on C{accept(2)}, it can close this file descriptor, retry the C{accept} so that the incoming connection occupies this file descriptor's space, and then close that connection and reopen this one. Calling L{_IFileDescriptorReservation.reserve} attempts to open the reserve file descriptor if it is not already open. L{_IFileDescriptorReservation.available} returns L{True} if the underlying file is open and its descriptor claimed. L{_IFileDescriptorReservation} instances are context managers; entering them releases the underlying file descriptor, while exiting them attempts to reacquire it. The block can take advantage of the free slot in the process' file descriptor table accept and close a client connection. Because another thread might open a file descriptor between the time the context manager is entered and the time C{accept} is called, opening the reserve descriptor is best-effort only. c C � dS )z� Is the reservation available? @return: L{True} if the reserved file descriptor is open and can thus be closed to allow a new file to be opened in its place; L{False} if it is not open. Nr r r r r � available� rx z%_IFileDescriptorReservation.availablec C r) )a! Attempt to open the reserved file descriptor; if this fails because of C{EMFILE}, internal state is reset so that another reservation attempt can be made. @raises Exception: Any exception except an L{OSError} whose errno is L{EMFILE}. Nr r r r r �reserve� rx z#_IFileDescriptorReservation.reservec C r) )z} Release the underlying file descriptor so that code within the context manager can open a new file. Nr r r r r � __enter__� rx z%_IFileDescriptorReservation.__enter__c C r) )z� Attempt to re-open the reserved file descriptor. See L{reserve} for caveats. @param excType: See L{object.__exit__} @param excValue: See L{object.__exit__} @param traceback: See L{object.__exit__} Nr )�excType�excValue� tracebackr r r �__exit__� rx z$_IFileDescriptorReservation.__exit__N�r r r rp r* r+ r, r0 r r r r r( m s r( c @ s e Zd Zdefdd�ZdS )� _HasCloser c C rr rs r r� r r r rl � s z_HasClose.closeN)r r r �objectrl r r r r r2 � s r2 T)� auto_attribsc @ sn e Zd ZU dZe� Zee ed< eg e f ed< e j ddd�Z e e ed< dd � Zd d � Zd d � Zdd� ZdS )�_FileDescriptorReservationa L{_IFileDescriptorReservation} implementation. @ivar fileFactory: A factory that will be called to reserve a file descriptor. @type fileFactory: A L{callable} that accepts no arguments and returns an object with a C{close} method. �_log� _fileFactoryFN)�init�default�_fileDescriptorc C s | j duS )z� See L{_IFileDescriptorReservation.available}. @return: L{True} if the reserved file descriptor is open and can thus be closed to allow a new file to be opened in its place; L{False} if it is not open. N)r: r� r r r r* � s z$_FileDescriptorReservation.availablec C sf | j du r1z| �� }W n ty+ } z|jtkr | j�d� n� W Y d}~dS d}~ww || _ dS dS )z= See L{_IFileDescriptorReservation.reserve}. Nz2Could not reserve EMFILE recovery file descriptor.)r: r7 rk �errnor7 r6 rF )rm r �er r r r+ � s ���� �z"_FileDescriptorReservation.reservec C s& | j du r td��| j �� d| _ dS )z? See L{_IFileDescriptorReservation.__enter__}. Nz5No file reserved. Have you called my reserve method?)r: � RuntimeErrorrl r� r r r r, � s z$_FileDescriptorReservation.__enter__c C s0 z| � � W dS ty | j�d� Y dS w )z> See L{_IFileDescriptorReservation.__exit__}. z5Could not re-reserve EMFILE recovery file descriptor.N)r+ � Exceptionr6 rF �rm r- r. r/ r r r r0 � s �z#_FileDescriptorReservation.__exit__)r r r rp r r6 r �__annotations__r r2 �attr�ibr: r r* r+ r, r0 r r r r r5 � s r5 c @ r' ) � _NullFileDescriptorReservationzB A null implementation of L{_IFileDescriptorReservation}. c C r) )z� The reserved file is never available. See L{_IFileDescriptorReservation.available}. @return: L{False} Fr r� r r r r* � s z(_NullFileDescriptorReservation.availablec C r) )zJ Do nothing. See L{_IFileDescriptorReservation.reserve}. Nr r� r r r r+ � rx z&_NullFileDescriptorReservation.reservec C r) )ze Do nothing. See L{_IFileDescriptorReservation.__enter__} @return: L{False} Nr r� r r r r, rx z(_NullFileDescriptorReservation.__enter__c C r) )z� Do nothing. See L{_IFileDescriptorReservation.__exit__}. @param excType: See L{object.__exit__} @param excValue: See L{object.__exit__} @param traceback: See L{object.__exit__} Nr r? r r r r0 rx z'_NullFileDescriptorReservation.__exit__Nr1 r r r r rC � s rC c C s t tj�S rs )�open�os�devnullr r r r rw 1 s rw c @ sP e Zd ZU dZeed< eed< eje� e �d�Z e e ed< dd� Zdd � Zd S ) � _BuffersLogsa@ A context manager that buffers any log events until after its block exits. @ivar _namespace: The namespace of the buffered events. @type _namespace: L{str}. @ivar _observer: The observer to which buffered log events will be written @type _observer: L{twisted.logger.ILogObserver}. � _namespace� _observer)r9 �_logsc C s t | j| jjd�S )z Enter a log buffering context. @return: A logger that buffers log events. @rtype: L{Logger}. )� namespace�observer)r rH rJ �appendr� r r r r, X s z_BuffersLogs.__enter__c C s | j D ]}| �|� qdS )z� Exit a log buffering context and log all buffered events to the provided observer. @param excType: See L{object.__exit__} @param excValue: See L{object.__exit__} @param traceback: See L{object.__exit__} N)rJ rI )rm r. r- r/ �eventr r r r0 a s �z_BuffersLogs.__exit__N)r r r rp r r@ r rA rB �FactoryrT rJ r r r, r0 r r r r rG F s rG c c sH � |D ]�}z|� � \}}W n� ty� } z�|jd ttfv r&W Y d}~ dS |jd tkr3W Y d}~q|jd tkr{|�� r{| �d� |�& t | |||�}|D ]\} } | � � | jd| d� qO| �d� W d � n1 snw Y W Y d}~ dS |jd t v r�| jdt |jd d� W Y d}~ dS � d}~ww ||fV qdS ) a� Return a generator that yields client sockets from the provided listening socket until there are none left or an unrecoverable error occurs. @param logger: A logger to which C{accept}-related events will be logged. This should not log to arbitrary observers that might open a file descriptor to avoid claiming the C{EMFILE} file descriptor on UNIX-like systems. @type logger: L{Logger} @param accepts: An iterable iterated over to limit the number consecutive C{accept}s. @type accepts: An iterable. @param listener: The listening socket. @type listener: L{socket.socket} @param reservedFD: A reserved file descriptor that can be used to recover from C{EMFILE} on UNIX-like systems. @type reservedFD: L{_IFileDescriptorReservation} @return: A generator that yields C{(socket, addr)} tuples from L{socket.socket.accept} r Nz7EMFILE encountered; releasing reserved file descriptor.z-EMFILE recovery: Closed socket from {address})r? z-Re-reserving EMFILE recovery file descriptor.z/Could not accept new connection ({acceptError}))� acceptError) �acceptrk ru r2 r: r0 r7 r* �info�_acceptrl �_ACCEPT_ERRORSr= ) �logger�accepts�listener� reservedFD�_r r? r< �clientsToClose� clientToClose� closedAddressr r r rS n sF � � � � ��� )�rS c @ s� e Zd ZU dZejZeZdZ dZ dZ dZ dZ ee ed< dZejZejZe� Zd!dd �Zed d � �Zd e fd d�Z dd� Z dd� Z dd� Z dd� Z!e"�#e$j%�fdd�Z&e&Z'dd� Z(dd � Z)d d � Z*d d � Z+dS )"�Porta. A TCP server port, listening for connections. When a connection is accepted, this will call a factory's buildProtocol with the incoming address as an argument, according to the specification described in L{twisted.internet.interfaces.IProtocolFactory}. If you wish to change the sort of transport that will be used, the C{transport} attribute will be called with the signature expected for C{Server.__init__}, so it can be replaced. @ivar deferred: a deferred created when L{stopListening} is called, and that will fire when connection is lost. This is not to be used it directly: prefer the deferred returned by L{stopListening} instead. @type deferred: L{defer.Deferred} @ivar disconnecting: flag indicating that the L{stopListening} method has been called and that no connections should be accepted anymore. @type disconnecting: C{bool} @ivar connected: flag set once the listen has successfully been called on the socket. @type connected: C{bool} @ivar _type: A string describing the connections which will be created by this port. Normally this is C{"TCP"}, since this is a TCP port, but when the TLS implementation re-uses this class it overrides the value with C{"TLS"}. Only used for logging. @ivar _preexistingSocket: If not L{None}, a L{socket.socket} instance which was created and initialized outside of the reactor and will be used to listen for connections (instead of a new socket being created by this L{Port}). r � �2 r Nr c C sF t jj| |d� || _|| _|| _t�|�r tj | _ t j | _ || _dS )z,Initialize with a numeric port to listen on.r� N)r@ �BasePortr� r� r �backlogr> r� rO r� r� r? r� r� � interface)rm r� r ra rb r r r r r� � s z Port.__init__c C s6 t �||| j�}t|�d }| d|d||�}||_|S )a} Create a new L{Port} based on an existing listening I{SOCK_STREAM} socket. Arguments are the same as to L{Port.__init__}, except where noted. @param fd: An integer file descriptor associated with a listening socket. The socket must be in non-blocking mode. Any additional attributes desired, such as I{FD_CLOEXEC}, must also be set already. @param addressFamily: The address family (sometimes called I{domain}) of the existing socket. For example, L{socket.AF_INET}. @return: A new instance of C{cls} wrapping the socket given by C{fd}. r N)rO r r� r` �_preexistingSocket)r r �fdr� r r� rb rm r r r �_fromListeningDescriptor� s z Port._fromListeningDescriptorr c C s2 | j d urd�| j| jj| j �S d�| j| jj�S )Nz<{} of {} on {}>z<{} of {} (not listening)>)r r� r r r� r r r r s ��z Port.__repr__c C s4 t j�| �}tdkrtjdkr|�tjtj d� |S )N�posix�cygwinrL ) r@ r` r� r �sys�platformrf rO rg � SO_REUSEADDRr� r r r r� s zPort.createInternetSocketc C s� t �� | jdu rDz | �� }| jtjkr t| j| j �}n| j| j f}|� |� W n t y< } zt | j| j |��d}~ww |� | j� n | j}d| _d| _|�� d | _t�d| �| j�| jf � | j�� d| _|| _| jj| _d| _| �� dS )z�Create and bind my socket, and begin listening on it. This is called on unserialization, and must be called after creating a server to begin listening on the specified port. NFrL z%s starting on %sT�d )� _reservedFDr+ rc r� r� rO r� r� rb r� r rk rD �listenra rd r_ r rG �msgr� r �doStartr� r� � numberAcceptsr� )rm r\ rU �ler r r �startListening& s8 ���� zPort.startListeningc C s | j dg|�R � S )Nr )r� )rm r? r r r � _buildAddrS s zPort._buildAddrc C sd z�t dkr | j}nd}t| jj| jj��p}d}t|t|�| jt �}t |d�D ]V\}\}}t � |� � � t|�dkrRt�|tjtjB �}t|d gt|dd� � �}| j�| �|��}|du rd|�� q&| j} | d | _| �|||| | | j�} |�| � q&W d � n1 s�w Y || jkr�| jd7 _W dS t d|�| _W dS t y� t � � Y dS w )z� Called when my socket is ready for reading. This accepts a connection and calls self.protocol() to handle the wire-level protocol. rf rL r rK N� ) r rp rG �_loggerrK rL rS �rangerO rl � enumeraterB r� r� rN rP rQ rR rS rT r r� rs rl r � transportr r� �maxr� rG �deferr) rm � numAccepts�bufferingLogger�accepted�clientsr\ rU rV r� r� rx r r r r} V sJ �� � � � � " �z Port.doReadc C s2 d| _ | �� | jrt| jd| j|�| _| jS dS )a Stop accepting connections on this port. This will shut down the socket and call self.connectionLost(). It returns a deferred which will fire successfully when the port is actually closed, or with a failure if an error occurs shutting down. Tr N)� disconnectingr{ r� rE r r� �deferred)rm �connDoner r r r� � s �zPort.loseConnectionc C s t �d| j� d| j� d�� dS )z. Log message for closing port �(z Port z Closed)N)rG rn �_typer r� r r r �_logConnectionLostMsg� s zPort._logConnectionLostMsgc C sT | � � d| _tj�| |� d| _| �d� | `| `z | j � � W d| _ dS d| _ w )z' Cleans up the socket. NFT) r� r r@ r` r� r� ro rO r� r �doStopr r� r r r r� � s zPort.connectionLostc C s t �| jj�S )z9Returns the name of my class, to prefix log entries with.)rH �qualr r r� r r r r� � s zPort.logPrefixc C r# )zs Return an L{IPv4Address} or L{IPv6Address} indicating the listening address of this port. r r$ r% r r r r � s z Port.getHost)r_ r^ N),r r r rp rO r� r� r rx r rb ra r� r r �intr@ rc r� r� r? r r� r ru r� r& re r r r� rr rs r} rF r� rC r� r� � stopListeningr� r� r� r r r r r r] � s6 # -A r] c @ s0 e Zd ZdZejZd dd�Zdd� Zdd� Z dS ) � Connectora6 A L{Connector} provides of L{twisted.internet.interfaces.IConnector} for all POSIX-style reactors. @ivar _addressType: the type returned by L{Connector.getDestination}. Either L{IPv4Address} or L{IPv6Address}, depending on the type of address. @type _addressType: C{type} Nc C s� t |t�r&zt�|d�}W n ty% } z tj|� d|�d�d��d }~ww ||| _| _t � |�r6t j | _ || _tj�| |||� d S )N�tcpz (�)r� )� isinstancer rO � getservbynamerk rA �ServiceNameUnknownErrorrV r� r> r� r? r� r� r r@ � BaseConnectorr� )rm rV r� r �timeoutr r r< r r r r� � s �� zConnector.__init__c C s t | j| j| j| | j�S )z| Create a L{Client} bound to this L{Connector}. @return: a new L{Client} @rtype: L{Client} )r rV r� r r r� r r r �_makeTransport� s zConnector._makeTransportc C s | � d| j| j�S )zQ @see: L{twisted.internet.interfaces.IConnector.getDestination}. r )r� rV r� r� r r r �getDestination� s zConnector.getDestinationrs ) r r r rp r? r r� r� r� r� r r r r r� � s r� )qrp rE rO ri rh �typingr r r r r �zope.interfacer r rA �twisted.internet.interfacesr r r r �twisted.loggerr r r �twisted.pythonr r �twisted.python.compatr �twisted.python.runtimer �twisted.internet._newtlsr r" r r r r% r � ImportErrorr3 r0 r; r' r4 r( r3 r) r1 r* r5 r+ r7 r, r6 r- r2 r8 r9 r: r. r; �twisted.python.win32r/ r< r= �twisted.internetr> r? r@ rA rB rC �twisted.internet.errorrD �twisted.internet.protocol�twisted.internet.taskrE rF rG rH �twisted.python.utilrI �getattr�_AI_NUMERICSERVrW r] r` rb rq r� r� r� r� �AI_NUMERICHOSTr� r� r� r r r( r2 r� r5 rC rl rT rG rS r` r] r� r� r r r r �<module> s� �$ # � & Vo= = ? 'I PK Mb�Z��`� . internet/__pycache__/gireactor.cpython-310.pycnu �[��� o �b � @ s� d Z ddlZddlmZ ddlmZ ddlmZ ddl m Z dZ ej � � eedd�dur1e�� G d d � d ej�ZG d d � d ej�Zddd�ZdgZdS )a� This module provides support for Twisted to interact with the glib mainloop via GObject Introspection. In order to use this support, simply do the following:: from twisted.internet import gireactor gireactor.install() If you wish to use a GApplication, register it with the reactor:: from twisted.internet import reactor reactor.registerGApplication(app) Then use twisted.internet APIs as usual. On Python 3, pygobject v3.4 or later is required. � N)�GLib)� _glibbase)�ReactorAlreadyRunning)�runtimeT� threads_initc @ s^ e Zd ZdZejjejjB ejjB Z ejj Z ejj Z e e B Ze e B ZdZddd�Zdd� ZdS ) � GIReactorz� GObject-introspection event loop reactor. @ivar _gapplication: A C{Gio.Application} instance that was registered with C{registerGApplication}. NFc C �0 d }|du r ddl m} tjj| t||d� d S �NTr )�Gtk��useGtk)� gi.repositoryr r �GlibReactorBase�__init__r ��selfr �_gtk� r �</usr/lib/python3/dist-packages/twisted/internet/gireactor.pyr E � zGIReactor.__init__c sV | j dur td��| jrtd��t� d�std��� | _ � fdd�}|| _� j| _dS )a� Register a C{Gio.Application} or C{Gtk.Application}, whose main loop will be used instead of the default one. We will C{hold} the application so it doesn't exit on its own. In versions of C{python-gi} 3.2 and later, we exit the event loop using the C{app.quit} method which overrides any holds. Older versions are not supported. Nz2Can't register more than one application instance.z5Can't register application after reactor was started.�quitzPApplication registration is not supported in versions of PyGObject prior to 3.2.c s � � � � �d � d S )N)�hold�runr ��appr r r c s z+GIReactor.registerGApplication.<locals>.run)� _gapplication� RuntimeError�_startedr �hasattr�_runr �_crash)r r r r r r �registerGApplicationL s � � z GIReactor.registerGApplication�F)�__name__� __module__� __qualname__�__doc__r � IOCondition�HUP�ERR�NVAL�_POLL_DISCONNECTED�IN�_POLL_IN�OUT� _POLL_OUT�INFLAGS�OUTFLAGSr r r! r r r r r . s � r c @ s" e Zd ZdZddd�Zdd� ZdS ) �PortableGIReactorz< Portable GObject Introspection event loop reactor. Fc C r r )r r r �PortableGlibReactorBaser r r r r r r q r zPortableGIReactor.__init__c C s t d��)z� Register a C{Gio.Application} or C{Gtk.Application}, whose main loop will be used instead of the default one. z3GApplication is not currently supported on Windows.)�NotImplementedError)r r r r r r! x s z&PortableGIReactor.registerGApplicationNr" )r# r$ r% r& r r! r r r r r2 l s r2 Fc C s< t j�� dkr t| d�}nt| d�}ddlm} ||� |S )z� Configure the twisted mainloop to be run inside the glib mainloop. @param useGtk: should GTK+ rather than glib event loop be used (this will be slightly slower but does support GUI). �posixr r )�installReactor)r �platform�getTyper r2 �twisted.internet.mainr6 )r �reactorr6 r r r �install� s r; r" )r& �gi.pygtkcompat�gir r �twisted.internetr �twisted.internet.errorr �twisted.pythonr �_pygtkcompatPresent� pygtkcompat�enable�getattrr r r r3 r2 r; �__all__r r r r �<module> s > PK Mb�Z��wH H 0 internet/__pycache__/pollreactor.cpython-310.pycnu �[��� o �bV � @ s� d Z ddlZddlmZmZmZmZmZmZ m Z ddl m Z ddl mZ ddlmZ ddlmZ e e�G dd � d ejej��Zd d � Zd d gZdS ) z� A poll() based implementation of the twisted main loop. To install the event loop (and you should do this before any connections, listeners or connectors are added):: from twisted.internet import pollreactor pollreactor.install() � N)�POLLERR�POLLHUP�POLLIN�POLLNVAL�POLLOUT�error�poll)� implementer)� posixbase)� IReactorFDSet)�logc @ s� e Zd ZdZeeB eB ZeZ e Z dd� Z dd� Z dd� Zdd � Zd d � Zd d � Zdd� Zdd� Zdd� ZeZdd� Zdd� ZdS )� PollReactora^ A reactor that uses poll(2). @ivar _poller: A L{select.poll} which will be used to check for I/O readiness. @ivar _selectables: A dictionary mapping integer file descriptors to instances of L{FileDescriptor} which have been registered with the reactor. All L{FileDescriptor}s which are currently receiving read or write readiness notifications will be present as values in this dictionary. @ivar _reads: A dictionary mapping integer file descriptors to arbitrary values (this is essentially a set). Keys in this dictionary will be registered with C{_poller} for read readiness notifications which will be dispatched to the corresponding L{FileDescriptor} instances in C{_selectables}. @ivar _writes: A dictionary mapping integer file descriptors to arbitrary values (this is essentially a set). Keys in this dictionary will be registered with C{_poller} for write readiness notifications which will be dispatched to the corresponding L{FileDescriptor} instances in C{_selectables}. c C s* t � | _i | _i | _i | _tj�| � dS )zo Initialize polling object, file descriptor tracking dictionaries, and the base class. N)r �_poller� _selectables�_reads�_writesr �PosixReactorBase�__init__��self� r �>/usr/lib/python3/dist-packages/twisted/internet/pollreactor.pyr C s zPollReactor.__init__c C s� z| j �|� W n ty Y nw d}|| jv r |tB }|| jv r&|tB }|dkr3| j �||� dS || jv r>| j|= dS dS )z*Register/unregister an fd with the poller.r N) r � unregister�KeyErrorr r r r �registerr )r �fd�maskr r r �_updateRegistrationN s � �z PollReactor._updateRegistrationc C sn z |� � }|| W n ty& | j�� D ] \}}||u r nqY d S Y nw ||v r5||= | �|� d S d S )N)�fileno� BaseExceptionr �itemsr )r � selectable�mdictr �fdesr r r � _dictRemove` s ��� �zPollReactor._dictRemovec C �8 |� � }|| jvr|| j|< d| j|< | �|� dS dS )z@Add a FileDescriptor for notification of data available to read.� N)r r r r )r �readerr r r r � addReaderu � �zPollReactor.addReaderc C r% )zAAdd a FileDescriptor for notification of data available to write.r& N)r r r r )r �writerr r r r � addWriter} r) zPollReactor.addWriterc C � | � || j�S )z?Remove a Selectable for notification of data available to read.)r$ r )r r' r r r � removeReader� � zPollReactor.removeReaderc C r, )z@Remove a Selectable for notification of data available to write.)r$ r )r r* r r r � removeWriter� r. zPollReactor.removeWriterc s, � � � fdd�� jD �� fdd�� jD ��S )zD Remove all selectables, and return a list of them. c � g | ]}� j | �qS r �r ��.0r r r r � <listcomp>� � z)PollReactor.removeAll.<locals>.<listcomp>c r0 r r1 r2 r r r r4 � r5 )� _removeAllr r r r r r � removeAll� s �zPollReactor.removeAllc C s� |dur t |d �}z| j�|�}W n ty. } z|jd tjkr)W Y d}~dS � d}~ww | j}|D ] \}}z| j| }W n t yH Y q4w t � |||||� q4dS )z Poll the poller for new events.Ni� r ) �intr r � SelectError�args�errno�EINTR�_doReadOrWriter r r �callWithLogger)r �timeout�l�e�_drdwr �eventr! r r r �doPoll� s& �� ��zPollReactor.doPollc � � fdd�� j D �S )Nc r0 r r1 r2 r r r r4 � r5 z*PollReactor.getReaders.<locals>.<listcomp>)r r r r r � getReaders� � zPollReactor.getReadersc rE )Nc r0 r r1 r2 r r r r4 � r5 z*PollReactor.getWriters.<locals>.<listcomp>)r r r r r � getWriters� rG zPollReactor.getWritersN)�__name__� __module__� __qualname__�__doc__r r r �_POLL_DISCONNECTEDr �_POLL_INr � _POLL_OUTr r r$ r( r+ r- r/ r7 rD � doIterationrF rH r r r r r $ s" r c C s t � } ddlm} || � dS )zInstall the poll() reactor.r )�installReactorN)r �twisted.internet.mainrQ )�prQ r r r �install� s rT )rL r; �selectr r r r r r r9 r �zope.interfacer �twisted.internetr �twisted.internet.interfacesr �twisted.pythonr r �_PollLikeMixinr rT �__all__r r r r �<module> s $ PK Mb�Z��b� � 0 internet/__pycache__/_win32stdio.cpython-310.pycnu �[��� o �bD � @ s� d Z ddlZddlZddlmZ ddlZddlmZmZ ddl m Z m Z m Z m Z mZ ddlmZ ee �G dd� d��Zeee e �G d d � d ej��ZdS ) zM Windows-specific implementation of the L{twisted.internet.stdio} interface. � N)� implementer)� _pollingfile�main)�IAddress� IConsumer�IHalfCloseableProtocol� IPushProducer� ITransport)�Failurec @ s e Zd ZdS )�Win32PipeAddressN)�__name__� __module__� __qualname__� r r �>/usr/lib/python3/dist-packages/twisted/internet/_win32stdio.pyr s r c @ s� e Zd ZdZdZd"dd�Zdd� Zdd� Zd d � Zd Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� ZdS )#� StandardIOFNc C s� |du r ddl m} tddd�D ] }t�|tj� qtj� | |� || _ t � t j �}t � t j�}t�|| j| j�| _t�|| j�| _| �| j� | �| j� | j �| � dS )z� Start talking to standard IO with the given protocol. Also, put it stdin/stdout/stderr into binary mode. Nr )�reactor� � )�twisted.internetr �range�msvcrt�setmode�os�O_BINARYr � _PollingTimer�__init__�proto�win32api� GetStdHandle�STD_INPUT_HANDLE�STD_OUTPUT_HANDLE�_PollableReadPipe� dataReceived�readConnectionLost�stdin�_PollableWritePipe�writeConnectionLost�stdout�_addPollableResource�makeConnection)�selfr r �stdfd�hstdin�hstdoutr r r r % s � zStandardIO.__init__c C � | j �|� d S �N)r r# �r+ �datar r r r# B � zStandardIO.dataReceivedc C �" t �| j�r | j�� | �� d S r0 )r � providedByr r$ � checkConnLost�r+ r r r r$ E � z StandardIO.readConnectionLostc C r4 r0 )r r5 r r' r6 r7 r r r r' J r8 z StandardIO.writeConnectionLostr c C s> | j d7 _ | j dkr d| _d| _| j�ttj�� d S d S )Nr r T)� connsLost� disconnecting� disconnectedr �connectionLostr r �CONNECTION_DONEr7 r r r r6 Q s �zStandardIO.checkConnLostc C r/ r0 )r( �writer1 r r r r> Z r3 zStandardIO.writec C s | j �d�|�� d S )N� )r( r> �join)r+ �seqr r r � writeSequence] s zStandardIO.writeSequencec C s d| _ | j�� | j�� d S )NT)r: r% �closer( r7 r r r �loseConnection` s zStandardIO.loseConnectionc C � t � S r0 �r r7 r r r �getPeere � zStandardIO.getPeerc C rE r0 rF r7 r r r �getHosth rH zStandardIO.getHostc C s | j �||�S r0 )r( �registerProducer)r+ �producer� streamingr r r rJ m � zStandardIO.registerProducerc C s | j �� S r0 )r( �unregisterProducerr7 r r r rN p s z StandardIO.unregisterProducerc C � | j �� d S r0 )r% � stopProducingr7 r r r rP w rM zStandardIO.stopProducingc C rO r0 )r% �pauseProducingr7 r r r rQ | rM zStandardIO.pauseProducingc C rO r0 )r% �resumeProducingr7 r r r rR rM zStandardIO.resumeProducingr0 )r r r r: r; r r# r$ r' r9 r6 r> rB rD rG rI rJ rN rP rQ rR r r r r r s& r )�__doc__r r �zope.interfacer r r r r �twisted.internet.interfacesr r r r r �twisted.python.failurer r r r r r r r �<module> s PK Mb�Z��-ـ � , internet/__pycache__/reactor.cpython-310.pycnu �[��� o �b � @ s, d Z ddlZejd= ddlmZ e�� dS )aV The reactor is the Twisted event loop within Twisted, the loop which drives applications using Twisted. The reactor provides APIs for networking, threading, dispatching events, and more. The default reactor depends on the platform and will be installed if this module is imported without another reactor being explicitly installed beforehand. Regardless of which reactor is installed, importing this module is the correct way to get a reference to it. New application code should prefer to pass and accept the reactor as a parameter where it is needed, rather than relying on being able to import this module to get a reference. This simplifies unit testing and may make it easier to one day support multiple reactors (as a performance enhancement), though this is not currently possible. @see: L{IReactorCore<twisted.internet.interfaces.IReactorCore>} @see: L{IReactorTime<twisted.internet.interfaces.IReactorTime>} @see: L{IReactorProcess<twisted.internet.interfaces.IReactorProcess>} @see: L{IReactorTCP<twisted.internet.interfaces.IReactorTCP>} @see: L{IReactorSSL<twisted.internet.interfaces.IReactorSSL>} @see: L{IReactorUDP<twisted.internet.interfaces.IReactorUDP>} @see: L{IReactorMulticast<twisted.internet.interfaces.IReactorMulticast>} @see: L{IReactorUNIX<twisted.internet.interfaces.IReactorUNIX>} @see: L{IReactorUNIXDatagram<twisted.internet.interfaces.IReactorUNIXDatagram>} @see: L{IReactorFDSet<twisted.internet.interfaces.IReactorFDSet>} @see: L{IReactorThreads<twisted.internet.interfaces.IReactorThreads>} @see: L{IReactorPluggableResolver<twisted.internet.interfaces.IReactorPluggableResolver>} � Nztwisted.internet.reactor)�default)�__doc__�sys�modules�twisted.internetr �install� r r �:/usr/lib/python3/dist-packages/twisted/internet/reactor.py�<module> s PK Mb�Z��M �& �& 3 internet/__pycache__/asyncioreactor.cpython-310.pycnu �[��� o �b{+ � @ s� d Z ddlZddlZddlmZmZ ddlmZmZm Z ddl m Z ddl m Z ddlmZ ddlmZmZmZ dd lmZ dd lmZ e e�G d d � d e��Zdd d�ZdS )z' asyncio-based reactor implementation. � N)�AbstractEventLoop�get_event_loop)�Dict�Optional�Type)� implementer)�FileDescriptor)� IReactorFDSet)� _NO_FILEDESC�PosixReactorBase�_ContinuousPolling)�Logger)�callWithLoggerc s� e Zd ZdZdZe� Zd,dee f� fdd� Z dd� Z d d � Z d d � Z d d� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd-d d �Z� fd d �Z� fd d!�Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Z� Z S ).�AsyncioSelectorReactora� Reactor running on top of L{asyncio.SelectorEventLoop}. On POSIX platforms, the default event loop is L{asyncio.SelectorEventLoop}. On Windows, the default event loop on Python 3.7 and older is C{asyncio.WindowsSelectorEventLoop}, but on Python 3.8 and newer the default event loop is C{asyncio.WindowsProactorEventLoop} which is incompatible with L{AsyncioSelectorReactor}. Applications that use L{AsyncioSelectorReactor} on Windows with Python 3.8+ must call C{asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())} before instantiating and running L{AsyncioSelectorReactor}. FN� eventloopc sx |d u rt � }n|}tjdkr!ddlm} t||�r!td|� ���|| _i | _i | _ t | �| _ d | _ d | _ t� �� d S )N�win32r )�ProactorEventLoopz)ProactorEventLoop is not supported, got: )r �sys�platform�asyncior � isinstance� TypeError�_asyncioEventloop�_writers�_readersr �_continuousPolling� _scheduledAt� _timerHandle�super�__init__)�selfr � _eventloopr �� __class__� �A/usr/lib/python3/dist-packages/twisted/internet/asyncioreactor.pyr 0 s � z AsyncioSelectorReactor.__init__c C s* z | j j�|� W dS ty Y dS w )am Compensate for a bug in asyncio where it will not unregister a FD that it cannot handle in the epoll loop. It touches internal asyncio code. A description of the bug by markrwilliams: The C{add_writer} method of asyncio event loops isn't atomic because all the Selector classes in the selector module internally record a file object before passing it to the platform's selector implementation. If the platform's selector decides the file object isn't acceptable, the resulting exception doesn't cause the Selector to un-track the file object. The failing/hanging stdio test goes through the following sequence of events (roughly): * The first C{connection.write(intToByte(value))} call hits the asyncio reactor's C{addWriter} method. * C{addWriter} calls the asyncio loop's C{add_writer} method, which happens to live on C{_BaseSelectorEventLoop}. * The asyncio loop's C{add_writer} method checks if the file object has been registered before via the selector's C{get_key} method. * It hasn't, so the KeyError block runs and calls the selector's register method * Code examples that follow use EpollSelector, but the code flow holds true for any other selector implementation. The selector's register method first calls through to the next register method in the MRO * That next method is always C{_BaseSelectorImpl.register} which creates a C{SelectorKey} instance for the file object, stores it under the file object's file descriptor, and then returns it. * Control returns to the concrete selector implementation, which asks the operating system to track the file descriptor using the right API. * The operating system refuses! An exception is raised that, in this case, the asyncio reactor handles by creating a C{_ContinuousPolling} object to watch the file descriptor. * The second C{connection.write(intToByte(value))} call hits the asyncio reactor's C{addWriter} method, which hits the C{add_writer} method. But the loop's selector's get_key method now returns a C{SelectorKey}! Now the asyncio reactor's C{addWriter} method thinks the asyncio loop will watch the file descriptor, even though it won't. N)r � _selector� unregister� BaseException)r �fdr$ r$ r% �_unregisterFDInAsyncioK s 2 �z-AsyncioSelectorReactor._unregisterFDInAsyncioc C s� |r|j n|j}|�� dkr| �|t|� d S z|� }W n ty6 } z|}| j�d � W Y d }~nd }~ww |rB| �|||� d S d S �N���)�doRead�doWrite�fileno�_disconnectSelectabler � Exception�_log�failure)r � selectable�read�method�why�er$ r$ r% � _readOrWrite� s ���z#AsyncioSelectorReactor._readOrWritec C s� || j �� v s || jj v rd S |�� }z| j�|t|| j|d� || j |< W d S tyM } z| � |� |j t j krA| j� |� n� W Y d }~d S d }~ww )NT) r �keysr r/ r � add_readerr r9 �OSErrorr* �errno�EPERM� addReader)r �readerr) r8 r$ r$ r% r? � s � ���z AsyncioSelectorReactor.addReaderc C s� || j �� v s || jj v rd S |�� }z| j�|t|| j|d� || j |< W d S ty< | � |� | j� |� Y d S t yJ | � |� Y d S t yV | � |� � w )NF) r r: r r/ r � add_writerr r9 �PermissionErrorr* � addWriter�BrokenPipeErrorr( �r �writerr) r$ r$ r% rC � s" � �z AsyncioSelectorReactor.addWriterc C �t || j �� v s| j�|�sd S | j�|�r | j�|� d S |�� }|dkr,| j �|�}n| j �|� | j�|� d S r+ ) r r: r � isReading� removeReaderr/ �popr � remove_reader)r r@ r) r$ r$ r% rI � s z#AsyncioSelectorReactor.removeReaderc C rG r+ ) r r: r � isWriting� removeWriterr/ rJ r � remove_writerrE r$ r$ r% rM � s z#AsyncioSelectorReactor.removeWriterc C s" | � | j�� | j�� �| j�� S �N)� _removeAllr r: r r � removeAll�r r$ r$ r% rQ � s ��z AsyncioSelectorReactor.removeAllc C � t | j�� �| j�� S rO )�listr r: r � getReadersrR r$ r$ r% rU � � z!AsyncioSelectorReactor.getReadersc C rS rO )rT r r: r � getWritersrR r$ r$ r% rW � rV z!AsyncioSelectorReactor.getWritersc C s$ | j �|d | j j� | j �� d S )Ng{�G�z�?)r � call_later�stop� run_forever)r �timeoutr$ r$ r% �iterate� s z AsyncioSelectorReactor.iterateTc C s* | j |d� | j�� | jrd| _d S d S )N)�installSignalHandlersF)� startRunningr rZ � _justStopped)r r] r$ r$ r% �run� s �zAsyncioSelectorReactor.runc s t � �� | �ddd� � d S )Nr c S s d S rO r$ r$ r$ r$ r% �<lambda> s z-AsyncioSelectorReactor.stop.<locals>.<lambda>)r rY � callLaterrR r" r$ r% rY s zAsyncioSelectorReactor.stopc s t � �� | j�� d S rO )r �crashr rY rR r" r$ r% rc s z AsyncioSelectorReactor.crashc C s d | _ | �� | �� d S rO )r �runUntilCurrent� _reschedulerR r$ r$ r% �_onTimer s z AsyncioSelectorReactor._onTimerc C sR | � � }|d ur'| j�� | }|| _| jd ur | j�� | j�|| j�| _d S d S rO )r[ r �timer r �cancel�call_atrf )r r[ �abs_timer$ r$ r% re s �z"AsyncioSelectorReactor._reschedulec C s t �| |� | �� d S rO )r �_moveCallLaterSoonerre )r �tpler$ r$ r% rk s z+AsyncioSelectorReactor._moveCallLaterSoonerc O sN t j| ||g|�R i |��}| j�� | �� }| jd u s!|| jk r%| �� |S rO )r rb r rg r[ r re )r �seconds�f�args�kwargs�dcrj r$ r$ r% rb s z AsyncioSelectorReactor.callLaterc s" � ���fdd�}�j �|� d S )Nc s �j d�g� �R i ���S )Nr )rb r$ �ro rn rp r r$ r% ra ' s z7AsyncioSelectorReactor.callFromThread.<locals>.<lambda>)r �call_soon_threadsafe)r rn ro rp �gr$ rr r% �callFromThread& s z%AsyncioSelectorReactor.callFromThreadrO )T) �__name__� __module__� __qualname__�__doc__� _asyncClosedr r2 r r r r* r9 r? rC rI rM rQ rU rW r\ r` rY rc rf re rk rb ru � __classcell__r$ r$ r" r% r s. 7 r c C s t | �}ddlm} ||� dS )z� Install an asyncio-based reactor. @param eventloop: The asyncio eventloop to wrap. If default, the global one is selected. r )�installReactorN)r �twisted.internet.mainr| )r �reactorr| r$ r$ r% �install+ s r rO )ry r= r r r r �typingr r r �zope.interfacer �twisted.internet.abstractr �twisted.internet.interfacesr �twisted.internet.posixbaser r r �twisted.loggerr �twisted.python.logr r r r$ r$ r$ r% �<module> s PK Mb�Z����" �" ( internet/__pycache__/ssl.cpython-310.pycnu �[��� o �b�! � @ sD d Z ddlmZmZmZ ddlmZ ddlmZm Z dZ eej �G dd� d��Z G dd � d e �Z eej �G d d � d ��Zeejgd d � ee j�D ��R � G dd� de j��Zeej�G dd� de j��ZG dd� de j�ZG dd� de j�ZddlmZmZmZmZmZmZm Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( g d�Z)dS )a This module implements Transport Layer Security (TLS) support for Twisted. It requires U{PyOpenSSL <https://pypi.python.org/pypi/pyOpenSSL>}. If you wish to establish a TLS connection, please use one of the following APIs: - SSL endpoints for L{servers <twisted.internet.endpoints.SSL4ServerEndpoint>} and L{clients <twisted.internet.endpoints.SSL4ClientEndpoint>} - L{startTLS <twisted.internet.interfaces.ITLSTransport.startTLS>} - L{connectSSL <twisted.internet.interfaces.IReactorSSL.connectSSL>} - L{listenSSL <twisted.internet.interfaces.IReactorSSL.listenSSL>} These APIs all require a C{contextFactory} argument that specifies their security properties, such as certificate, private key, certificate authorities to verify the peer, allowed TLS protocol versions, cipher suites, and so on. The recommended value for this argument is a L{CertificateOptions} instance; see its documentation for an explanation of the available options. The C{contextFactory} name is a bit of an anachronism now, as context factories have been replaced with "connection creators", but these objects serve the same role. Be warned that implementing your own connection creator (i.e.: value for the C{contextFactory}) is both difficult and dangerous; the Twisted team has worked hard to make L{CertificateOptions}' API comprehensible and unsurprising, and the Twisted team is actively maintaining it to ensure that it becomes more secure over time. If you are really absolutely sure that you want to take on the risk of implementing your own connection creator based on the pyOpenSSL API, see the L{server connection creator <twisted.internet.interfaces.IOpenSSLServerConnectionCreator>} and L{client connection creator <twisted.internet.interfaces.IOpenSSLServerConnectionCreator>} interfaces. Developers using Twisted, please ignore the L{Port}, L{Connector}, and L{Client} classes defined here, as these are details of certain reactors' TLS implementations, exposed by accident (and remaining here only for compatibility reasons). If you wish to establish a TLS connection, please use one of the APIs listed above. @note: "SSL" (Secure Sockets Layer) is an antiquated synonym for "TLS" (Transport Layer Security). You may see these terms used interchangeably throughout the documentation. � )� implementedBy� implementer�implementer_only)�SSL)� interfaces�tcpTc @ s e Zd ZdZdZdd� ZdS )�ContextFactoryz>A factory for SSL context objects, for server SSL connections.r c C s t �)z4Return a SSL.Context object. override in subclasses.��NotImplementedError��self� r �6/usr/lib/python3/dist-packages/twisted/internet/ssl.py� getContextJ s zContextFactory.getContextN)�__name__� __module__� __qualname__�__doc__�isClientr r r r r r D s r c @ sF e Zd ZdZdZejejfdd�Zdd� Z dd� Z d d � Z d d � Z dS ) � DefaultOpenSSLContextFactoryaQ L{DefaultOpenSSLContextFactory} is a factory for server-side SSL context objects. These objects define certain parameters related to SSL handshakes and the subsequent connection. @ivar _contextFactory: A callable which will be used to create new context objects. This is typically L{OpenSSL.SSL.Context}. Nc C s$ || _ || _|| _|| _| �� dS )z� @param privateKeyFileName: Name of a file containing a private key @param certificateFileName: Name of a file containing a certificate @param sslmethod: The SSL method to use N)�privateKeyFileName�certificateFileName� sslmethod�_contextFactory� cacheContext)r r r r r r r r �__init__[ s z%DefaultOpenSSLContextFactory.__init__c C sH | j d u r"| �| j�}|�tj� |�| j� |�| j � || _ d S d S �N) �_contextr r � set_optionsr � OP_NO_SSLv2�use_certificate_filer �use_privatekey_filer �r �ctxr r r r q s �z)DefaultOpenSSLContextFactory.cacheContextc C s | j �� }|d= |S )Nr )�__dict__�copy)r �dr r r � __getstate__{ s z)DefaultOpenSSLContextFactory.__getstate__c C s || _ d S r )r$ )r �stater r r � __setstate__� s z)DefaultOpenSSLContextFactory.__setstate__c C s | j S )z( Return an SSL context. )r r r r r r � s z'DefaultOpenSSLContextFactory.getContext) r r r r r r � SSLv23_METHOD�Contextr r r' r) r r r r r r O s � r c @ s( e Zd ZdZdZejZejZ dd� Z dS )�ClientContextFactoryz"A context factory for SSL clients.� c C s | � | j�}|�tj� |S r )r �methodr r r r" r r r r � s z ClientContextFactory.getContextN) r r r r r r r* r. r+ r r r r r r r, � s r, c c s � | ] }|t jkr|V qd S r )r � ITLSTransport)�.0�ir r r � <genexpr>� s � r2 c @ s" e Zd ZdZddd�Zdd� ZdS )�Clientz I am an SSL client. Nc C s || _ tj�| |||||� d S r )� ctxFactoryr r3 r )r �host�port� bindAddressr4 � connector�reactorr r r r � s zClient.__init__c C s$ | � | j� | �� tj�| � d S r )�startTLSr4 � startWritingr r3 � _connectDoner r r r r< � s zClient._connectDoner )r r r r r r< r r r r r3 � s r3 c @ s e Zd ZdZdd� Zdd� ZdS )�Serverz I am an SSL server. c O s, t jj| g|�R i |�� | �| jj� d S r )r r= r r: �serverr4 )r �args�kwargsr r r r � s zServer.__init__c C s t d��)N�Server.getPeerCertificater r r r r �getPeerCertificate� s rA N)r r r r r rB r r r r r= � s r= c @ s, e Zd ZdZeZdZ d dd�Zdd � ZdS ) �Portz I am an SSL port. �TLS�2 � Nc C s t j�| |||||� || _d S r )r rC r r4 )r r6 �factoryr4 �backlog� interfacer9 r r r r � s z Port.__init__c C s t j�| |�d S )z| Override the normal prefix to include an annotation indicating this is a port for TLS connections. z (TLS))r rC � _getLogPrefix)r rG r r r rJ � s zPort._getLogPrefix)rE rF N) r r r r r= � transport�_typer rJ r r r r rC � s � rC c @ s e Zd Z ddd�Zdd� ZdS )� ConnectorNc C s* || _ tj�| ||||||� |�� d S r )�contextFactoryr rM r r )r r5 r6 rG rN �timeoutr7 r9 r r r r � s zConnector.__init__c C s t | j| j| j| j| | j�S r )r3 r5 r6 r7 rN r9 r r r r �_makeTransport� s �zConnector._makeTransportr )r r r r rP r r r r rM � s � rM )�DN� Certificate�CertificateRequest�DistinguishedName�KeyPair�OpenSSLAcceptableCiphers�OpenSSLCertificateOptions�OpenSSLDefaultPaths� OpenSSLDiffieHellmanParameters�PrivateCertificate�ProtocolNegotiationSupport� TLSVersion�VerificationError�optionsForClientTLS� platformTrust� protocolNegotiationMechanisms�trustRootFromCertificates)r r r, rT rQ rR rS rZ rU �AcceptableCiphers�CertificateOptions�DiffieHellmanParametersr_ rX r\ r] r^ r[ r` ra N)*r �zope.interfacer r r �OpenSSLr �twisted.internetr r � supported�IOpenSSLContextFactoryr r r, � ISSLTransportr3 r= rC rM �twisted.internet._sslverifyrQ rR rS rT rU rV rb rW rc rX rY rd rZ r[ r\ r] r^ r_ r` ra �__all__r r r r �<module> s, 4 ;��L PK Mb�Z��,l� � 2 internet/__pycache__/selectreactor.cpython-310.pycnu �[��� o �b� � @ s� U d Z ddlZddlZddlmZmZ ddlmZ ddlm Z ddl m Z ddl m Z ddlmZ dd lmZ dd lmZ dd d �Zed krIeZnejZzddlmZ W n eye eZe e ed< Y nw eZe e�G dd� de j e��Z dd� Z dgZ dS )z Select reactor � N)�EBADF�EINTR)�sleep)�Type)� implementer)� posixbase)� IReactorFDSet)�log)� platformTypec C sj | s|s|du r d}nt |d�}t|� g g g fS |du s!|dkr#d}t�| |||�\} }}| || g fS )zWin32 select wrapper.Ng{�G�z�?g����MbP?g �?)�minr �select)�r�w�e�timeout� r �@/usr/lib/python3/dist-packages/twisted/internet/selectreactor.py� win32select s r �win32)�_ThreadedWin32EventsMixin� _extraBasec @ sl e Zd ZdZdd� Zdd� Zdd� ZeZdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� ZdS )� SelectReactora- A select() based reactor - runs on all POSIX platforms and on Win32. @ivar _reads: A set containing L{FileDescriptor} instances which will be checked for read events. @ivar _writes: A set containing L{FileDescriptor} instances which will be checked for writability. c C s t � | _t � | _tj�| � dS )zV Initialize file descriptor tracking dictionaries and the base class. N)�set�_reads�_writesr �PosixReactorBase�__init__��selfr r r r D s zSelectReactor.__init__c C s� t �d� t| j�}t| j�}| j�� | j�� | j|f| j|ffD ]<\}}|D ]5}z t�|g|g|gd� W n tyX } zt �d| � | �||d� W Y d }~q)d }~ww |� |� q)q#d S )Nz1Malformed file descriptor found. Preening lists.r zbad descriptor %sF) r �msg�listr r �clearr � Exception�_disconnectSelectable�add)r �readers�writers�selSet�selList� selectabler r r r �_preenDescriptorsL s" �� ��z SelectReactor._preenDescriptorsc C s4 zt | j| jg |�\}}}W n` ty | �� Y dS ty- t�� | �� Y dS tyn } z6|j d dv rI| jsH| jsHW Y d}~dS � |j d t krWW Y d}~dS |j d t kri| �� W Y d}~dS � d}~ww | j }tj }|d| jf|d| jffD ]\}} } |D ]} | | vr�q�|| || | � q�q�dS )z� Run one iteration of the I/O monitor loop. This will run all selectables who had input or output readiness waiting for them. Nr )r � �doRead�doWrite)�_selectr r � ValueErrorr* � TypeErrorr �err�OSError�argsr r �_doReadOrWrite�callWithLogger) r r r r �ignored�se�_drdw�_logrun� selectables�method�fdsetr) r r r �doSelect\ sB �� ���zSelectReactor.doSelectc C sV zt ||�� }W n ty t�� d }t�� Y nw |r)| �|||dk� d S d S )N� r, )�getattr� BaseException�sys�exc_infor r1 r# )r r) r; �whyr r r r4 � s ��z SelectReactor._doReadOrWritec C � | j �|� dS )zR Add a FileDescriptor for notification of data available to read. N)r r$ �r �readerr r r � addReader� � zSelectReactor.addReaderc C rD )zS Add a FileDescriptor for notification of data available to write. N)r r$ �r �writerr r r � addWriter� rH zSelectReactor.addWriterc C rD )zQ Remove a Selectable for notification of data available to read. N)r �discardrE r r r � removeReader� rH zSelectReactor.removeReaderc C rD )zR Remove a Selectable for notification of data available to write. N)r rL rI r r r � removeWriter� rH zSelectReactor.removeWriterc C s | � | j| j�S �N)� _removeAllr r r r r r � removeAll� s zSelectReactor.removeAllc C � t | j�S rO )r r r r r r � getReaders� � zSelectReactor.getReadersc C rR rO )r r r r r r � getWriters� rT zSelectReactor.getWritersN)�__name__� __module__� __qualname__�__doc__r r* r= � doIterationr4 rG rK rM rN rQ rS rU r r r r r 8 s 4 r c C s t � } ddlm} || � dS )zDConfigure the twisted mainloop to be run using the select() reactor.r )�installReactorN)r �twisted.internet.mainr[ )�reactorr[ r r r �install� s r^ rO ) rY r rA �errnor r �timer �typingr �zope.interfacer �twisted.internetr �twisted.internet.interfacesr �twisted.pythonr �twisted.python.runtimer r r. �"twisted.internet.win32eventreactorr � ImportError�objectr �__annotations__r r r^ �__all__r r r r �<module> s4 � PK Mb�Z���ن! �! . internet/__pycache__/kqreactor.cpython-310.pycnu �[��� o �bB* � @ s d Z ddlZddlZddlmZmZmZmZ ddlm Z m Z ddl m Z m Z ddlmZmZ zeed�Zeed�Zeed �Zeed �Zeed �ZW n eyY Z zee��dZ[ww G d d � d e�Ze�ee� ee e �G dd� de j ��Z dd� Z ddgZ dS )am A kqueue()/kevent() based implementation of the Twisted main loop. To use this reactor, start your application specifying the kqueue reactor:: twistd --reactor kqueue ... To install the event loop from code (and you should do this before any connections, listeners or connectors are added):: from twisted.internet import kqreactor kqreactor.install() � N)� Attribute� Interface� declarations� implementer)�main� posixbase)�IReactorDaemonize� IReactorFDSet)�failure�log� KQ_EV_ADD� KQ_EV_DELETE� KQ_EV_EOF�KQ_FILTER_READ�KQ_FILTER_WRITEc @ s e Zd ZdZed�Zed�ZdS )�_IKQueuez2 An interface for KQueue implementations. z An implementation of kqueue(2).z An implementation of kevent(2).N)�__name__� __module__� __qualname__�__doc__r �kqueue�kevent� r r �</usr/lib/python3/dist-packages/twisted/internet/kqreactor.pyr * s r c @ s� e Zd ZdZefdd�Zdd� Zdd� Zdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� ZeZd S ) � KQueueReactoram A reactor that uses kqueue(2)/kevent(2) and relies on Python 2.6 or higher which has built in support for kqueue in the select module. @ivar _kq: A C{kqueue} which will be used to check for I/O readiness. @ivar _impl: The implementation of L{_IKQueue} to use. @ivar _selectables: A dictionary mapping integer file descriptors to instances of L{FileDescriptor} which have been registered with the reactor. All L{FileDescriptor}s which are currently receiving read or write readiness notifications will be present as values in this dictionary. @ivar _reads: A set containing integer file descriptors. Values in this set will be registered with C{_kq} for read readiness notifications which will be dispatched to the corresponding L{FileDescriptor} instances in C{_selectables}. @ivar _writes: A set containing integer file descriptors. Values in this set will be registered with C{_kq} for write readiness notifications which will be dispatched to the corresponding L{FileDescriptor} instances in C{_selectables}. c C s8 || _ | j �� | _t� | _t� | _i | _tj� | � dS )a� Initialize kqueue object, file descriptor tracking dictionaries, and the base class. See: - http://docs.python.org/library/select.html - www.freebsd.org/cgi/man.cgi?query=kqueue - people.freebsd.org/~jlemon/papers/kqueue.pdf @param _kqueueImpl: The implementation of L{_IKQueue} to use. A hook for testing. N) �_implr �_kq�set�_reads�_writes� _selectablesr �PosixReactorBase�__init__)�self� _kqueueImplr r r r" Q s zKQueueReactor.__init__c C s" | j �| j�|||�gdd� dS )z� Private method for changing kqueue registration on a given FD filtering for events given filter/op. This will never block and returns nothing. r N)r �controlr r )r# �fd�filter�opr r r �_updateRegistratione s "z!KQueueReactor._updateRegistrationc C s | j �� d| _ dS )zA Implement L{IReactorDaemonize.beforeDaemonize}. N)r �close�r# r r r �beforeDaemonizem s z KQueueReactor.beforeDaemonizec C sD | j �� | _| jD ] }| �|tt� q | jD ] }| �|tt� qdS )z@ Implement L{IReactorDaemonize.afterDaemonize}. N) r r r r r) r r r r )r# r& r r r �afterDaemonize} s �z KQueueReactor.afterDaemonizec C � |� � }|| jvrEz/z | �|tt� W n ty Y nw W || j|< | j�|� dS W || j|< | j�|� dS || j|< | j�|� w dS )z7 Implement L{IReactorFDSet.addReader}. N)�filenor r) r r �OSErrorr �add)r# �readerr& r r r � addReader� � �� � ��zKQueueReactor.addReaderc C r. )z7 Implement L{IReactorFDSet.addWriter}. N)r/ r r) r r r0 r r1 )r# �writerr& r r r � addWriter� r4 zKQueueReactor.addWriterc C � d}z|� � }W n ty d}Y nw |dkr,| j�� D ] \}}||u r)d} nq dS || jv rW| j�|� || jvr@| j|= |sYz | �|tt � W dS t yV Y dS w dS dS )z: Implement L{IReactorFDSet.removeReader}. F���TN) r/ � BaseExceptionr �itemsr �remover r) r r r0 )r# r2 �wasLostr& �fdesr r r � removeReader� �2 �� ��zKQueueReactor.removeReaderc C r7 )z: Implement L{IReactorFDSet.removeWriter}. Fr8 TN) r/ r9 r r: r r; r r) r r r0 )r# r5 r< r& r= r r r � removeWriter� r? zKQueueReactor.removeWriterc s, � � � fdd�� jD �� fdd�� jD ��S )z7 Implement L{IReactorFDSet.removeAll}. c � g | ]}� j | �qS r �r ��.0r& r+ r r � <listcomp>� � z+KQueueReactor.removeAll.<locals>.<listcomp>c rA r rB rC r+ r r rE � rF )� _removeAllr r r+ r r+ r � removeAll� s �zKQueueReactor.removeAllc � � fdd�� j D �S )z8 Implement L{IReactorFDSet.getReaders}. c rA r rB rC r+ r r rE � rF z,KQueueReactor.getReaders.<locals>.<listcomp>)r r+ r r+ r � getReaders� � zKQueueReactor.getReadersc rI )z8 Implement L{IReactorFDSet.getWriters}. c rA r rB rC r+ r r rE � rF z,KQueueReactor.getWriters.<locals>.<listcomp>)r r+ r r+ r � getWriters� rK zKQueueReactor.getWritersc C s� |du rd}z | j �g t| j�|�}W n ty- } z|jtjkr(W Y d}~dS � d}~ww | j}|D ] }|j}z| j| }W n t yH Y q3w t � |||||� q3dS )z1 Poll the kqueue for new events. N� ) r r% �lenr r0 �errno�EINTR�_doWriteOrRead�ident�KeyErrorr �callWithLogger)r# �timeout�events�e�_drdw�eventr& � selectabler r r �doKEvent� s( �� ��zKQueueReactor.doKEventc C s� d}d}|j |j|j|jf\}}}} |t@ r |r | r tj}n6z"|�� dkr+d}tj }n|t kr5d}|� � }|t kr?d}|� � }W n tyS t�� }t�|d� Y nw |r_| �|||� dS dS )z� Private method called when a FD is ready for reading, writing or was lost. Do the work and raise errors where necessary. NFr8 TzSAn exception was raised from application code while processing a reactor selectable)r' �flags�data�fflagsr r �CONNECTION_LOSTr/ r � _NO_FILEDESCr �doReadr �doWriter9 r �Failurer �err�_disconnectSelectable) r# rZ r& rY �why�inReadr' r\ r] r^ r r r rQ s< � � �� �z KQueueReactor._doWriteOrReadN)r r r r �selectr" r) r, r- r3 r6 r> r@ rH rJ rL r[ rQ � doIterationr r r r r 6 s )r c C s t � } ddlm} || � dS )z' Install the kqueue() reactor. r )�installReactorN)r �twisted.internet.mainrj )�prj r r r �install: s rm ) r rO rh �zope.interfacer r r r �twisted.internetr r �twisted.internet.interfacesr r �twisted.pythonr r �getattrr r r r r �AttributeErrorrW � ImportErrorr �directlyProvidesr! r rm �__all__r r r r �<module> s2 �� PK Mb�Z~�*� � * internet/__pycache__/stdio.cpython-310.pycnu �[��� o �b� � @ sF d Z ddlmZ e�� rddlmZmZ nddlmZmZ ddgZ dS )a! Standard input/out/err support. This module exposes one name, StandardIO, which is a factory that takes an IProtocol provider as an argument. It connects that protocol to standard input and output on the current process. It should work on any UNIX and also on Win32 (with some caveats: due to platform limitations, it will perform very poorly on Win32). Future Plans:: support for stderr, perhaps Rewrite to use the reactor instead of an ad-hoc mechanism for connecting protocols to transport. Maintainer: James Y Knight � )�platform)� StandardIO�Win32PipeAddress)� PipeAddressr r r N) �__doc__�twisted.python.runtimer � isWindows� twisted.internet._win32stdior r r � twisted.internet._posixstdio�__all__� r r �8/usr/lib/python3/dist-packages/twisted/internet/stdio.py�<module> s PK Mb�ZDu��D �D - internet/__pycache__/abstract.cpython-310.pycnu �[��� o �b_K � @ s� d Z ddlmZmZmZ ddlmZmZmZ ddl m Z ddl m Z m Z ddlmZmZ ddlmZ dd � Zd d � ZG d d � d �Ze e j�G dd� d��Ze e je je je je j �G dd� dee��Z efde de de fdd�Z!de de fdd�Z"g d�Z#dS )z+ Support for generic select()able objects. � )�AF_INET�AF_INET6� inet_pton)�Iterable�List�Optional)� implementer)� interfaces�main)�failure�reflect)� lazyByteSlicec C s t | t�s td��d S )NzData must be bytes)� isinstance�bytes� TypeError)�obj� r �;/usr/lib/python3/dist-packages/twisted/internet/abstract.py�_dataMustBeBytes s �r c C s d� t| �|d � g| �S )N� )�join� memoryview)�bObj�offset�bArrayr r r � _concatenate s r c @ s4 e Zd ZdZdZdZdZdd� Zdd� Zdd � Z dS ) �_ConsumerMixina� L{IConsumer} implementations can mix this in to get C{registerProducer} and C{unregisterProducer} methods which take care of keeping track of a producer's state. Subclasses must provide three attributes which L{_ConsumerMixin} will read but not write: - connected: A C{bool} which is C{True} as long as the consumer has someplace to send bytes (for example, a TCP connection), and then C{False} when it no longer does. - disconnecting: A C{bool} which is C{False} until something like L{ITransport.loseConnection} is called, indicating that the send buffer should be flushed and the connection lost afterwards. Afterwards, C{True}. - disconnected: A C{bool} which is C{False} until the consumer no longer has a place to send bytes, then C{True}. Subclasses must also override the C{startWriting} method. @ivar producer: L{None} if no producer is registered, otherwise the registered producer. @ivar producerPaused: A flag indicating whether the producer is currently paused. @type producerPaused: L{bool} @ivar streamingProducer: A flag indicating whether the producer was registered as a streaming (ie push) producer or not (ie a pull producer). This will determine whether the consumer may ever need to pause and resume it, or if it can merely call C{resumeProducing} on it when buffer space is available. @ivar streamingProducer: C{bool} or C{int} NFc C s t d��)a Override in a subclass to cause the reactor to monitor this selectable for write events. This will be called once in C{unregisterProducer} if C{loseConnection} has previously been called, so that the connection can actually close. z!%r did not implement startWriting��NotImplementedError��selfr r r � startWritingL s z_ConsumerMixin.startWritingc C sN | j durtd|| j f ��| jr|�� dS || _ || _|s%|�� dS dS )a" Register to receive data from a producer. This sets this selectable to be a consumer for a producer. When this selectable runs out of data on a write() call, it will ask the producer to resumeProducing(). When the FileDescriptor's internal data buffer is filled, it will ask the producer to pauseProducing(). If the connection is lost, FileDescriptor calls producer's stopProducing() method. If streaming is true, the producer should provide the IPushProducer interface. Otherwise, it is assumed that producer provides the IPullProducer interface. In this case, the producer won't be asked to pauseProducing(), but it has to be careful to write() data only when its resumeProducing() method is called. NzHCannot register producer %s, because producer %s was never unregistered.)�producer� RuntimeError� disconnected� stopProducing�streamingProducer�resumeProducing)r r" � streamingr r r �registerProducerU s �� �z _ConsumerMixin.registerProducerc C s& d| _ | jr| jr| �� dS dS dS )zM Stop consuming data from a producer, without disconnecting. N)r" � connected� disconnectingr! r r r r �unregisterProducerr s �z!_ConsumerMixin.unregisterProducer) �__name__� __module__� __qualname__�__doc__r" �producerPausedr& r! r) r, r r r r r ! s & r c @ s* e Zd ZdZdedefdd�Zdd� ZdS ) � _LogOwnerz� Mixin to help implement L{interfaces.ILoggingContext} for transports which have a protocol, the log prefix of which should also appear in the transport's log prefix. �applicationObject�returnc C s t j�|�r |�� S |jjS )z� Determine the log prefix to use for messages related to C{applicationObject}, which may or may not be an L{interfaces.ILoggingContext} provider. @return: A C{str} giving the log prefix to use. )r �ILoggingContext� providedBy� logPrefix� __class__r- )r r3 r r r � _getLogPrefix� s z_LogOwner._getLogPrefixc C � dS )z� Override this method to insert custom logging behavior. Its return value will be inserted in front of every line. It may be called more times than the number of output lines. �-r r r r r r7 � � z_LogOwner.logPrefixN)r- r. r/ r0 �object�strr9 r7 r r r r r2 { s r2 c @ sD e Zd ZdZdZdZdZdZdZdZ dZ dZ dAde e j fdd �Zd d � Zd ed dfdd�Zdd� Zdd� Zdd� Zdd� Zdd� Zdejd dfdd �Zd d � Zd d � Z d!d"� Z d#d$� Z d ed dfd%d&�Z d'e e d dfd(d)�Z!d*d+� Z"d,d-� Z#d.d/� Z$d0d1� Z%d2d3� Z&d4d5� Z'dZ(d6Z)d7d8� Z*d9d:� Z+d;d<� Z,d=d>� Z-d?d@� Z.dS )B�FileDescriptorz� An object which can be operated on by select(). This is an abstract superclass of all objects which may be notified when they are readable or writable; e.g. they have a file-descriptor that is valid to be passed to select(2). r Fr i N�reactorc C s* |s ddl m} |}|| _g | _d| _dS )z� @param reactor: An L{IReactorFDSet} provider which this descriptor will use to get readable and writeable event notifications. If no value is given, the global reactor will be used. r )r@ N)�twisted.internetr@ �_tempDataBuffer� _tempDataLen)r r@ �_reactorr r r �__init__� s zFileDescriptor.__init__c C s: d| _ d| _| jdur| j�� d| _| �� | �� dS )az The connection was lost. This is called when the connection on a selectable object has been lost. It will be called whether the connection was closed explicitly, an exception occurred in an event handler, or the other end of the connection closed it first. Clean up state here, but make sure to call back up to FileDescriptor. � r N)r$ r* r" r% � stopReading� stopWriting�r �reasonr r r �connectionLost� s z FileDescriptor.connectionLost�datar4 c C � t dt�| j� ��)a� Write as much as possible of the given data, immediately. This is called to invoke the lower-level writing functionality, such as a socket's send() method, or a file's write(); this method returns an integer or an exception. If an integer, it is the number of bytes written (possibly zero); if an exception, it indicates the connection was lost. z#%s does not implement writeSomeData�r r �qualr8 �r rL r r r � writeSomeData� s �z FileDescriptor.writeSomeDatac C rM )z� Called when data is available for reading. Subclasses must override this method. The result will be interpreted in the same way as a result of doWrite(). z %s does not implement doReadrN r r r r �doRead� s �zFileDescriptor.doReadc C s t | j�| j | jk r t| j| j| j�| _d| _g | _d| _| jr,| �t| j| j��}n| �| j�}t |t �s;|dk r=|S | j|7 _| jt | j�kr�| js�d| _d| _| � � | j durn| j rd| jrnd| _| j �� dS | jru| �� S | jr�d| _| �� }|S dS )z� Called when data can be written. @return: L{None} on success, an exception or a negative integer on failure. @see: L{twisted.internet.interfaces.IWriteDescriptor.doWrite}. r r NFT)�len� dataBufferr � SEND_LIMITr rB rC rQ r r � ExceptionrH r" r& r1 r' r+ �_postLoseConnection�_writeDisconnecting�_writeDisconnected�_closeWriteConnection)r �l�resultr r r �doWrite� s@ � �� �zFileDescriptor.doWritec C s t jS )z�Called after a loseConnection(), when all data has been written. Whatever this returns is then returned by doWrite. )r �CONNECTION_DONEr r r r rW ' s z"FileDescriptor._postLoseConnectionc C s d S �Nr r r r r rZ / s z$FileDescriptor._closeWriteConnectionc C � | � |� d S r_ �rK rI r r r �writeConnectionLost3 � z"FileDescriptor.writeConnectionLostrJ c C r` r_ ra rI r r r �readConnectionLost7 rc z!FileDescriptor.readConnectionLostc C � t � �r_ r r r r r �getHost; � zFileDescriptor.getHostc C re r_ r r r r r �getPeer? rg zFileDescriptor.getPeerc C s t | j�| j | jkS )ay Determine whether the user-space send buffer for this transport is full or not. When the buffer contains more than C{self.bufferSize} bytes, it is considered full. This might be improved by considering the size of the kernel send buffer and how much of it is free. @return: C{True} if it is full, C{False} otherwise. )rS rT rC � bufferSizer r r r �_isSendBufferFullC s z FileDescriptor._isSendBufferFullc C s8 | j dur| jr| �� rd| _| j �� dS dS dS dS )zY Possibly pause a producer, if there is one and the send buffer is full. NT)r" r& rj r1 �pauseProducingr r r r �_maybePauseProducerP s �z"FileDescriptor._maybePauseProducerc C sR t |� | jr | jr dS |r'| j�|� | jt|�7 _| �� | �� dS dS )a7 Reliably write some data. The data is buffered until the underlying file descriptor is ready for writing. If there is more than C{self.bufferSize} data in the buffer and this descriptor has a registered streaming producer, its C{pauseProducing()} method will be called. N) r r* rY rB �appendrC rS rl r! rP r r r �write\ s �zFileDescriptor.write�iovecc C sb |D ]}t |� q| jr|r| jrdS | j�|� |D ] }| jt|�7 _q| �� | �� dS )a Reliably write a sequence of data. Currently, this is a convenience method roughly equivalent to:: for chunk in iovec: fd.write(chunk) It may have a more efficient implementation at a later time or in a different reactor. As with the C{write()} method, if a buffer size limit is reached and a streaming producer is registered, it will be paused until the buffered data is written to the underlying file descriptor. N) r r* rY rB �extendrC rS rl r! )r ro �ir r r � writeSequencem s z FileDescriptor.writeSequencec C sZ | j r)| js+| jr | �� | �� | �t�tj �� dS | �� | � � d| _dS dS dS )a[ Close the connection at the next available opportunity. Call this to cause this FileDescriptor to lose its connection. It will first write any data that it has buffered. If there is data buffered yet to be written, this method will cause the transport to lose its connection as soon as it's done flushing its write buffer. If you have a producer registered, the connection won't be closed until the producer is finished. Therefore, make sure you unregister your producer when it's finished, or the connection will never close. rF N) r* r+ rY rG rH rK r �Failurer r^ r! r r r r �loseConnection� s �z FileDescriptor.loseConnectionc C s d| _ | �� d S )NT)rX r! r r r r �loseWriteConnection� s z"FileDescriptor.loseWriteConnectionc C � | j �| � dS )z�Stop waiting for read availability. Call this to remove this selectable from being notified when it is ready for reading. N)r@ � removeReaderr r r r rG � � zFileDescriptor.stopReadingc C rv )z�Stop waiting for write availability. Call this to remove this selectable from being notified when it is ready for writing. N)r@ � removeWriterr r r r rH � rx zFileDescriptor.stopWritingc C rv )z$Start waiting for read availability.N)r@ � addReaderr r r r � startReading� s zFileDescriptor.startReadingc C rv )z�Start waiting for write availability. Call this to have this FileDescriptor be notified whenever it is ready for writing. N)r@ � addWriterr r r r r! � rx zFileDescriptor.startWritingi c C s | � � | �� dS )z�Stop consuming data. This is called when a producer has lost its connection, to tell the consumer to go lose its connection (and break potential circular references). N)r, rt r r r r � stopConsuming� s z FileDescriptor.stopConsumingc C s | j r | js| �� d S d S d S r_ )r* r+ r{ r r r r r' � s �z FileDescriptor.resumeProducingc C � | � � d S r_ )rG r r r r rk � � z FileDescriptor.pauseProducingc C r~ r_ )rt r r r r r% � r z FileDescriptor.stopProducingc C r: )z�File Descriptor number for select(). This method must be overridden or assigned in subclasses to indicate a valid file descriptor for the operating system. ���r r r r r �fileno� r< zFileDescriptor.filenor_ )/r- r. r/ r0 r* r$ r+ rX rY rT r rU r r � IReactorFDSetrE rK r rQ rR r] rW rZ rb r rs rd rf rh rj rl rn r rr rt ru rG rH r{ r! r" ri r} r' rk r% r� r r r r r? � sL ; r? �addr�familyr4 c C s� t | t�rz| �d�} W n ty Y dS w |tkr$| �dd�d } n|tkr2| �d�dkr1dS ntd|����zt || � W d S tt fyM Y dS w ) a> Determine whether the given string represents an IP address of the given family; by default, an IPv4 address. @param addr: A string which may or may not be the decimal dotted representation of an IPv4 address. @param family: The address family to test for; one of the C{AF_*} constants from the L{socket} module. (This parameter has only been available since Twisted 17.1.0; previously L{isIPAddress} could only test for IPv4 addresses.) @return: C{True} if C{addr} represents an IPv4 address, C{False} otherwise. �asciiF�%rF r �.� zunknown address family T) r r �decode�UnicodeDecodeErrorr �splitr �count� ValueErrorr �OSError)r� r� r r r � isIPAddress� s& �� ��r� c C s t | t�S )a2 Determine whether the given string represents an IPv6 address. @param addr: A string which may or may not be the hex representation of an IPv6 address. @type addr: C{str} @return: C{True} if C{addr} represents an IPv6 address, C{False} otherwise. @rtype: C{bool} )r� r )r� r r r � isIPv6Address s r� )r? r� r� N)$r0 �socketr r r �typingr r r �zope.interfacer rA r r �twisted.pythonr r �twisted.python.compatr r r r r5 r2 � IPushProducer�IReadWriteDescriptor� IConsumer� ITransport�IHalfCloseableDescriptorr? r> �int�boolr� r� �__all__r r r r �<module> s2 Z � J( PK Mb�Z434B`* `* , internet/__pycache__/inotify.cpython-310.pycnu �[��� o �b<8 � @ s| d Z ddlZddlZddlmZ ddlmZ ddlmZm Z dZ dZ dZ d Z d Zd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZ dZ e eB Z eeB Z e e B Z e e B eB eB eB eB eB eB eB Z!e dfe dfe d fe d fed fed fed fed!fed"fed#fed$fed%fed&fed'fed(fed)fed*fed+fe d,fe d-fgZ"d.d/� Z#G d0d1� d1�Z$G d2d3� d3e�Z%ej&Z&g d4�Z'dS )5a This module provides support for Twisted to linux inotify API. In order to use this support, simply do the following (and start a reactor at some point):: from twisted.internet import inotify from twisted.python import filepath def notify(ignored, filepath, mask): """ For historical reasons, an opaque handle is passed as first parameter. This object should never be used. @param filepath: FilePath on which the event happened. @param mask: inotify event as hexadecimal masks """ print("event %s on %s" % ( ', '.join(inotify.humanReadableMask(mask)), filepath)) notifier = inotify.INotify() notifier.startReading() notifier.watch(filepath.FilePath("/some/directory"), callbacks=[notify]) notifier.watch(filepath.FilePath(b"/some/directory2"), callbacks=[notify]) Note that in the above example, a L{FilePath} which is a L{bytes} path name or L{str} path name may be used. However, no matter what type of L{FilePath} is passed to this module, internally the L{FilePath} is converted to L{bytes} according to L{sys.getfilesystemencoding}. For any L{FilePath} returned by this module, the caller is responsible for converting from a L{bytes} path name to a L{str} path name. @since: 10.1 � N)�fdesc)�FileDescriptor)�_inotify�log� � � � � � �@ � � i i i i i @ i � i i i i @l �access�modify�attrib� close_write� close_nowrite�open� moved_from�moved_to�create�delete� delete_self� move_self�unmount�queue_overflow�ignored�only_dir� dont_follow�mask_add�is_dir�one_shotc C s( g }t D ] \}}|| @ r|�|� q|S )zh Auxiliary function that converts a hexadecimal mask into a series of human readable flags. )�_FLAG_TO_HUMAN�append)�mask�s�k�v� r) �:/usr/lib/python3/dist-packages/twisted/internet/inotify.py�humanReadableMaskq s �r+ c @ s( e Zd ZdZeddfdd�Zdd� ZdS )�_Watcha� Watch object that represents a Watch point in the filesystem. The user should let INotify to create these objects @ivar path: The path over which this watch point is monitoring @ivar mask: The events monitored by this watchpoint @ivar autoAdd: Flag that determines whether this watch point should automatically add created subdirectories @ivar callbacks: L{list} of callback functions that will be called when an event occurs on this watch. FNc C s, |� � | _|| _|| _|d u rg }|| _d S �N)� asBytesMode�pathr% �autoAdd� callbacks)�selfr/ r% r0 r1 r) r) r* �__init__� s z_Watch.__init__c C s$ |� � }| jD ]}|| ||� qdS )zL Callback function used by L{INotify} to dispatch an event. N)r. r1 )r2 �filepath�events�callbackr) r) r* �_notify� s �z_Watch._notify)�__name__� __module__� __qualname__�__doc__� IN_WATCH_MASKr3 r7 r) r) r) r* r, } s r, c @ sx e Zd ZdZeZddd�Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z e dddfdd�Zdd� Zdd� ZdS )�INotifya� The INotify file descriptor, it basically does everything related to INotify, from reading to notifying watch points. @ivar _buffer: a L{bytes} containing the data read from the inotify fd. @ivar _watchpoints: a L{dict} that maps from inotify watch ids to watchpoints objects @ivar _watchpaths: a L{dict} that maps from watched paths to the inotify watch ids Nc C sT t j| |d� | j�� | _t�| j� t�| j� d| _d| _ d| _ i | _ i | _ d S )N)�reactorr T� ) r r3 r �init�_fdr �setNonBlocking�_setCloseOnExec� connected�_writeDisconnected�_buffer� _watchpoints� _watchpaths)r2 r> r) r) r* r3 � s zINotify.__init__c C s@ |� � }| j�| j||�}t||||�}|| j|< || j|< |S )a~ Private helper that abstracts the use of ctypes. Calls the internal inotify API and checks for any errors after the call. If there's an error L{INotify._addWatch} can raise an INotifyError. If there's no error it proceeds creating a watchpoint and adding a watchpath for inverse lookup of the file descriptor from the path. )r. r �addrA r, rG rH )r2 r/ r% r0 r1 �wd�iwpr) r) r* � _addWatch� s zINotify._addWatchc C s. | j �| j|� | j�|�}| j�|j� dS )a Private helper that abstracts the use of ctypes. Calls the internal inotify API to remove an fd from inotify then removes the corresponding watchpoint from the internal mapping together with the file descriptor from the watchpath. N)r �removerA rG �poprH r/ )r2 rJ rK r) r) r* �_rmWatch� s zINotify._rmWatchc C s` t �| |� | jdkr.z t�| j� W dS ty- } z t�|d� W Y d}~dS d}~ww dS )zR Release the inotify file descriptor and do the necessary cleanup r z'Couldn't close INotify file descriptor.N)r �connectionLostrA �os�close�OSErrorr �err)r2 �reason�er) r) r* rP � s ���zINotify.connectionLostc C s | j S )z� Get the underlying file descriptor from this inotify observer. Required by L{abstract.FileDescriptor} subclasses. )rA �r2 r) r) r* �fileno� s zINotify.filenoc C s t �| j| j� dS )zC Read some data from the observed file descriptors N)r � readFromFDrA �_doReadrW r) r) r* �doRead� s zINotify.doReadc C s* | j |7 _ t| j �dkr�t�d| j dd� �\}}}}|r,| j dd| � �d�}nd}| j d| d� | _ z| j| }W n tyH Y qw |j�� }|rU|� |�}|� ||� |j r}|t @ r}|t @ r}| j||jd|jd�} | j�d| j| j| � |t@ r�| �|� | �� t| j �dksdS dS )zF Work on the data just read from the file descriptor. r z=LLLLr � NT�r% r0 r1 )rF �len�struct�unpack�rstriprG �KeyErrorr/ r. �childr7 r0 �IN_ISDIR� IN_CREATE�watchr% r1 r> � callLater� _addChildren�IN_DELETE_SELFrO �loseConnection) r2 �in_rJ r% �cookie�size�namerK r/ �new_wdr) r) r* rZ � s2 � � �zINotify._doReadc C s� z|j �� }W n ty Y dS w |D ]1}|�� r9| j||jd|jd�}|�|tt B � | j � d| j | j | � |�� rE|�|t tB � qdS )a� This is a very private method, please don't even think about using it. Note that this is a fricking hack... it's because we cannot be fast enough in adding a watch to a directory and so we basically end up getting here too late if some operations have already been going on in the subdir, we basically need to catchup. This eventually ends up meaning that we generate double events, your app must be resistant. NTr] r )r/ �childrenrS �isdirrf r% r1 r7 rd re r> rg rh rG �isfile�IN_CLOSE_WRITE)r2 rK �listdir�frJ r) r) r* rh $ s � ��zINotify._addChildrenFc C s\ |r|� � D ]}|�� r| j||||dd� qdS | �|�}|r"|S |tB }| �||||�S )aL Watch the 'mask' events in given path. Can raise C{INotifyError} when there's a problem while adding a directory. @param path: The path needing monitoring @type path: L{FilePath} @param mask: The events that should be watched @type mask: L{int} @param autoAdd: if True automatically add newly created subdirectories @type autoAdd: L{bool} @param callbacks: A list of callbacks that should be called when an event happens in the given path. The callback should accept 3 arguments: (ignored, filepath, mask) @type callbacks: L{list} of callables @param recursive: Also add all the subdirectories in this path @type recursive: L{bool} F)� recursiveN)�walkrq rf � _isWatchedri rL )r2 r/ r% r0 r1 rv rc rJ r) r) r* rf F s �� z INotify.watchc C s6 |� � }| �|�}|du rt|�d���| �|� dS )z� Remove the watch point monitoring the given path @param path: The path that should be ignored @type path: L{FilePath} Nz is not watched)r. rx rb rO )r2 r/ rJ r) r) r* �ignores s zINotify.ignorec C s |� � }| j�|d�S )z� Helper function that checks if the path is already monitored and returns its watchdescriptor if so or None otherwise. @param path: The path that should be checked @type path: L{FilePath} N)r. rH �get)r2 r/ r) r) r* rx � s zINotify._isWatchedr- )r8 r9 r: r; r r3 rL rO rP rX r[ rZ rh r< rf ry rx r) r) r) r* r= � s ,# �- r= )r= r+ r< � IN_ACCESS� IN_MODIFY� IN_ATTRIB�IN_CLOSE_NOWRITErs �IN_OPEN� IN_MOVED_FROM� IN_MOVED_TOre � IN_DELETEri � IN_MOVE_SELF� IN_UNMOUNT� IN_Q_OVERFLOW� IN_IGNORED� IN_ONLYDIR�IN_DONT_FOLLOW� IN_MASK_ADDrd � IN_ONESHOT�IN_CLOSE�IN_MOVED� IN_CHANGED)(r; rQ r_ �twisted.internetr �twisted.internet.abstractr �twisted.pythonr r r{ r| r} rs r~ r r� r� re r� ri r� r� r� r� r� r� r� rd r� r� r� r� r< r# r+ r, r= � INotifyError�__all__r) r) r) r* �<module> s� $ ���������� s PK Mb�Z�` ` - internet/__pycache__/__init__.cpython-310.pycnu �[��� o �b � @ s d Z dS )a� Twisted Internet: Asynchronous I/O and Events. Twisted Internet is a collection of compatible event-loops for Python. It contains the code to dispatch events to interested observers and a portable API so that observers need not care about which event loop is running. Thus, it is possible to use the same code for different loops, from Twisted's basic, yet portable, select-based loop to the loops of various GUI toolkits like GTK+ or Tk. N)�__doc__� r r �;/usr/lib/python3/dist-packages/twisted/internet/__init__.py�<module> s PK Mb�Z�Q�� 6 internet/__pycache__/_producer_helpers.cpython-310.pycnu �[��� o �bE � @ sx U d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z g Z ee ed< ee�G d d � d ��Zd S ) z% Helpers for working with producers. � )�List)� implementer)� IPushProducer)� cooperate)�log)�safe_str�__all__c @ sL e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dS )� _PullToPusha� An adapter that converts a non-streaming to a streaming producer. Because of limitations of the producer API, this adapter requires the cooperation of the consumer. When the consumer's C{registerProducer} is called with a non-streaming producer, it must wrap it with L{_PullToPush} and then call C{startStreaming} on the resulting object. When the consumer's C{unregisterProducer} is called, it must call C{stopStreaming} on the L{_PullToPush} instance. If the underlying producer throws an exception from C{resumeProducing}, the producer will be unregistered from the consumer. @ivar _producer: the underling non-streaming producer. @ivar _consumer: the consumer with which the underlying producer was registered. @ivar _finished: C{bool} indicating whether the producer has finished. @ivar _coopTask: the result of calling L{cooperate}, the task driving the streaming producer. Fc C s || _ || _d S )N)� _producer� _consumer)�self� pullProducer�consumer� r �D/usr/lib/python3/dist-packages/twisted/internet/_producer_helpers.py�__init__2 s z_PullToPush.__init__c c s� � z| j �� W n7 ty@ t�ddt| j �f � z| j�� W n ty= t�ddt| j�f � d| _Y Y dS w Y nw dV q)z� A generator that calls C{resumeProducing} on the underlying producer forever. If C{resumeProducing} throws an exception, the producer is unregistered, which should result in streaming stopping. TNz%%s failed, producing will be stopped:z!%s failed to unregister producer:) r �resumeProducing� BaseExceptionr �errr r �unregisterProducer� _finished�r r r r �_pull6 s6 � �� ������z_PullToPush._pullc C s t | �� �| _dS )z� This should be called by the consumer when the producer is registered. Start streaming data to the consumer. N)r r � _coopTaskr r r r �startStreamingW s z_PullToPush.startStreamingc C s | j rdS d| _ | j�� dS )z� This should be called by the consumer when the producer is unregistered. Stop streaming data to the consumer. NT)r r �stopr r r r � stopStreaming_ s z_PullToPush.stopStreamingc C � | j �� dS )z7 @see: C{IPushProducer.pauseProducing} N)r �pauser r r r �pauseProducingk � z_PullToPush.pauseProducingc C r )z8 @see: C{IPushProducer.resumeProducing} N)r �resumer r r r r q r z_PullToPush.resumeProducingc C s | � � | j�� dS )z6 @see: C{IPushProducer.stopProducing} N)r r � stopProducingr r r r r" w s z_PullToPush.stopProducingN) �__name__� __module__� __qualname__�__doc__r r r r r r r r" r r r r r s ! r N)r& �typingr �zope.interfacer �twisted.internet.interfacesr �twisted.internet.taskr �twisted.pythonr �twisted.python.reflectr r �str�__annotations__r r r r r �<module> s PK Mb�Z4.a�� � ) internet/__pycache__/main.cpython-310.pycnu �[��� o �b� � @ s8 d Z ddlmZ e�d�Ze�d�Zdd� Zg d�ZdS ) z� Backwards compatibility, and utility functions. In general, this module should not be used, other than by reactor authors who need to use the 'installReactor' method. � )�errorzConnection donezConnection lostc C s: ddl }ddl}d|jv rt�d��| |j_| |jd< dS )zt Install reactor C{reactor}. @param reactor: An object that provides one or more IReactor* interfaces. r Nztwisted.internet.reactorzreactor already installed)�sys�twisted.internet�modulesr � ReactorAlreadyInstalledError�internet�reactor)r r �twisted� r �7/usr/lib/python3/dist-packages/twisted/internet/main.py�installReactor s r )�CONNECTION_LOST�CONNECTION_DONEr N) �__doc__r r �ConnectionDoner �ConnectionLostr r �__all__r r r r �<module> s PK Mb�Z���o�[ �[ . internet/__pycache__/posixbase.cpython-310.pycnu �[��� o �b�k � @ s� d Z ddlZddlZddlZddlZddlZddlmZ ddlm Z m Z m Z m Z ddl mZmZmZ ddlmZmZ ddlmZmZmZmZmZmZmZm Z m Z m Z ddl m Z m!Z! dd l"m#Z#m$Z$m%Z% dd l&m'Z'm(Z( e�)d �Z*e�)d �Z+zdd l,m-Z. W n e/y� dZ-Y nw e.Z-zddl m0Z1 W n e/y� dZ0Y nw e1Z0e(dkZ2dZ3e2r�ddl m4Z4m5Z5m6Z6m7Z7 dZ3e'�8� r�zddl9Z9dZ3W n e/y� dZ9Y nw G dd� de �Z:e e:�G dd� de$j;��Z<G dd� de$j;�Z=e e:�G dd� de=��Z>e(dk�re>Z?ne<Z?G dd � d e=�Z@G d d � d �ZAe ee e�G d d � d eeAe��ZBG d!d"� d"�ZCe e�G d#d$� d$eCeA��ZDe-du�sAe0du�rFe eBe� e2�rOe eBe e � e3�rWe eBe� eEed%d�du�ree eBe� d gZFdS )&z Posix reactor base class � N)�Sequence)� Attribute� Interface�classImplements� implementer)�error�tcp�udp)� ReactorBase�_SignalReactorMixin) �IHalfCloseableDescriptor� IReactorFDSet�IReactorMulticast�IReactorProcess�IReactorSocket� IReactorSSL� IReactorTCP� IReactorUDP� IReactorUNIX�IReactorUNIXDatagram)�CONNECTION_DONE�CONNECTION_LOST)�failure�log�util)�platform� platformTypez Handler has no fileno methodzFile descriptor lost)�tls)�ssl�posixF)�_signals�fdesc�process�unixTc @ s8 e Zd ZdZed�Zdd� Zdd� Zdej fdd �Z d S ) �_IWakeraQ Interface to wake up the event loop based on the self-pipe trick. The U{I{self-pipe trick}<http://cr.yp.to/docs/selfpipe.html>}, used to wake up the main loop from another thread or a signal handler. This is why we have wakeUp together with doRead This is used by threads or signals to wake up the event loop. � c C � dS )z: Called when the event should be wake up. N� r' r' r' �</usr/lib/python3/dist-packages/twisted/internet/posixbase.py�wakeUpW � z_IWaker.wakeUpc C r& )zC Read some data from my connection and discard it. Nr' r' r' r' r( �doRead\ r* z_IWaker.doRead�reasonc C r& )zB Called when connection was closed and the pipes. Nr' )r, r' r' r( �connectionLosta r* z_IWaker.connectionLostN) �__name__� __module__� __qualname__�__doc__r � disconnectedr) r+ r �Failurer- r' r' r' r( r$ J s r$ c @ s4 e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd S ) � _SocketWakerz� The I{self-pipe trick<http://cr.yp.to/docs/selfpipe.html>}, implemented using a pair of sockets rather than pipes (due to the lack of support in select() on Windows for pipes), used to wake up the main loop from another thread. r c C s� || _ t�tjtj�}|�tjtjd� t�t�tjtj��� }|� d� |� d� |� |� � � |� � \}}W d � n1 sAw Y |�d� |�d� || _|| _| jj| _dS )� Initialize.� )z 127.0.0.1r Nr )�reactor�socket�AF_INET� SOCK_STREAM� setsockopt� IPPROTO_TCP� TCP_NODELAY� contextlib�closing�bind�listen�connect� getsockname�accept� setblocking�r�w�fileno)�selfr7 �client�server�reader� clientaddrr' r' r( �__init__r s" � � z_SocketWaker.__init__c C sP z t �| jjd� W dS ty' } z|jd tjkr � W Y d}~dS d}~ww )z Send a byte to my connection.� xr N)r �untilConcludesrG �send�OSError�args�errno�WSAEWOULDBLOCK�rI �er' r' r( r) � s ���z_SocketWaker.wakeUpc C s( z | j �d� W dS ty Y dS w )z4 Read some data from my connection. � N)rF �recvrR �rI r' r' r( r+ � s �z_SocketWaker.doReadc C s | j �� | j�� d S �N)rF �closerG )rI r, r' r' r( r- � s z_SocketWaker.connectionLostN) r. r/ r0 r1 r2 rN r) r+ r- r' r' r' r( r4 g s r4 c @ s4 e Zd ZdZdZdZdZdd� Zdd� Zdd � Z dS ) �_FDWakera� The I{self-pipe trick<http://cr.yp.to/docs/selfpipe.html>}, used to wake up the main loop from another thread or a signal handler. L{_FDWaker} is a base class for waker implementations based on writing to a pipe being monitored by the reactor. @ivar o: The file descriptor for the end of the pipe which can be written to wake up a reactor monitoring this waker. @ivar i: The file descriptor which should be monitored in order to be awoken by this waker. r Nc sX |� _ t�� \� _� _t�� j� t�� j� t�� j� t�� j� � fdd�� _dS )r5 c s � j S r[ )�ir' rZ r' r( �<lambda>� s z#_FDWaker.__init__.<locals>.<lambda>N) r7 �os�piper^ �or! �setNonBlocking�_setCloseOnExecrH �rI r7 r' rZ r( rN � s z_FDWaker.__init__c C s t �| �� dd� � dS )zA Read some bytes from the pipe and discard them. c S s d S r[ r' )�datar' r' r( r_ � r* z!_FDWaker.doRead.<locals>.<lambda>N)r! � readFromFDrH rZ r' r' r( r+ � s z_FDWaker.doReadc C sL t | d�sdS | j| jfD ]}zt�|� W q ty Y q w | `| `dS )zClose both ends of my pipe.rb N)�hasattrr^ rb r` r\ rR )rI r, �fdr' r' r( r- � s � z_FDWaker.connectionLost) r. r/ r0 r1 r2 r^ rb rN r+ r- r' r' r' r( r] � s r] c @ � e Zd ZdZdd� ZdS )� _UnixWakerz� This class provides a simple interface to wake up the event loop. This is used by threads or signals to wake up the event loop. c C s\ | j dur,z t�tj| j d� W dS ty+ } z|jtjkr � W Y d}~dS d}~ww dS )z)Write one byte to the pipe, and flush it.NrO )rb r rP r` �writerR rT �EAGAINrV r' r' r( r) � s ����z_UnixWaker.wakeUpN)r. r/ r0 r1 r) r' r' r' r( rk � s rk c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � _SIGCHLDWakerz} L{_SIGCHLDWaker} can wake up a reactor whenever C{SIGCHLD} is received. @see: L{twisted.internet._signals} c C s t �| |� d S r[ )r] rN re r' r' r( rN � s z_SIGCHLDWaker.__init__c C s t �| j� dS )zJ Install the handler necessary to make this waker active. N)r �installHandlerrb rZ r' r' r( �install� s z_SIGCHLDWaker.installc C s t �d� dS )zC Remove the handler which makes this waker active. ���N)r ro rZ r' r' r( � uninstall� s z_SIGCHLDWaker.uninstallc C s t �| � t�� dS )a Having woken up the reactor in response to receipt of C{SIGCHLD}, reap the process which exited. This is called whenever the reactor notices the waker pipe is writeable, which happens soon after any call to the C{wakeUp} method. N)r] r+ r" �reapAllProcessesrZ r' r' r( r+ � s z_SIGCHLDWaker.doReadN)r. r/ r0 r1 rN rp rr r+ r' r' r' r( rn � s rn c @ s< e Zd ZdZeje�e�� �eje�e�� �ifdd�Z dS )�_DisconnectSelectableMixinz> Mixin providing the C{_disconnectSelectable} method. c C sx | � |� |�|j�}|r-|r!|jtjkr!t�|�r!|�|� dS | �|� |� |� dS | �|� |� t � |�� dS )z� Utility function for disconnecting a selectable. Supports half-close notification, isRead should be boolean indicating whether error resulted from doRead(). N) � removeReader�get� __class__r �ConnectionDoner � providedBy�readConnectionLost� removeWriterr- r r3 )rI � selectable�why�isRead�faildict�fr' r' r( �_disconnectSelectable s � � z0_DisconnectSelectableMixin._disconnectSelectableN) r. r/ r0 r1 r rx r r3 �ConnectionLostr� r' r' r' r( rt s ��rt c @ s e Zd ZU dZeZdd� ZdZdd� Zdd� Z d i dddd dfd d �Z d0dd�Z d1dd�Z d2dd�Z d3dd�Zd4dd �Z d5d d �ZerUejejejfZeej ed < nejejfZd d!� Zd"d#� Z d6d$d%�Z d7d&d'�Z d8d(d)�Z d8d*d+�Z d7d,d-�Z d.d/� Z!dS )9�PosixReactorBasez� A basis for reactors that use file descriptors. @ivar _childWaker: L{None} or a reference to the L{_SIGCHLDWaker} which is used to properly notice child process termination. c C s4 | j s| �| �| _ | j�| j � | �| j � dS dS )z� Install a `waker' to allow threads and signals to wake up the IO thread. We use the self-pipe trick (http://cr.yp.to/docs/selfpipe.html) to wake the reactor. On Windows we use a pair of sockets. N)�waker� _wakerFactory�_internalReaders�add� addReaderrZ r' r' r( � installWaker? s �z PosixReactorBase.installWakerNc C s^ t �| � tdkr+tr-| js t| �| _| j�| j� | �| j� | j� � t � � dS dS dS )z� Extend the basic signal handling logic to also support handling SIGCHLD to know when to try to reap child processes. r N) r �_handleSignalsr �processEnabled� _childWakerrn r� r� r� rp r" rs rZ r' r' r( r� M s �z PosixReactorBase._handleSignalsc C s | j r | j �� dS dS )a� If a child waker was created and installed, uninstall it now. Since this disables reactor functionality and is only called when the reactor is stopping, it doesn't provide any directly useful functionality, but the cleanup of reactor-related process-global state that it does helps in unit tests involving multiple reactors and is generally just a nice thing. N)r� rr rZ r' r' r( �_uninstallHandler` s �z"PosixReactorBase._uninstallHandlerr' r c C s� t dkr(|r| d urtd��t�| ||||||||� S t�| |||||||| � S t dkr]|d ur4td��|d ur<td��|rBtd��| rHtd��trYdd lm} | | |||||�S td ��td ��) Nr z1Using childFDs is not supported with usePTY=True.�win32z,Setting UID is unsupported on this platform.z,Setting GID is unsupported on this platform.z1The usePTY parameter is not supported on Windows.z1Customizing childFDs is not supported on Windows.r )�Processz:spawnProcess not available since pywin32 is not installed.z0spawnProcess only available on Windows or POSIX.)r � ValueErrorr" � PTYProcessr� � win32process� twisted.internet._dumbwin32proc�NotImplementedError) rI �processProtocol� executablerS �env�path�uid�gid�usePTY�childFDsr� r' r' r( � spawnProcesss sL ��� ��z PosixReactorBase.spawnProcessr% rX c C � t �||||| �}|�� |S )z�Connects a given L{DatagramProtocol} to the given numeric UDP port. @returns: object conforming to L{IListeningPort}. )r �Port�startListening)rI �port�protocol� interface� maxPacketSize�pr' r' r( � listenUDP� s zPosixReactorBase.listenUDPFc C s t �||||| |�}|�� |S )z�Connects a given DatagramProtocol to the given numeric UDP port. EXPERIMENTAL. @returns: object conforming to IListeningPort. )r � MulticastPortr� )rI r� r� r� r� �listenMultipler� r' r' r( �listenMulticast� s �z PosixReactorBase.listenMulticast� c C s* t sJ d��t�|||| |�}|�� |S �N�UNIX support is not present)� unixEnabledr# � ConnectorrB )rI �address�factory�timeout�checkPID�cr' r' r( � connectUNIX� s z PosixReactorBase.connectUNIX�2 � c C s, t sJ d��t�||||| |�}|�� |S r� )r� r# r� r� )rI r� r� �backlog�mode�wantPIDr� r' r' r( � listenUNIX� s zPosixReactorBase.listenUNIXc C s* t sJ d��t�||||| �}|�� |S )z� Connects a given L{DatagramProtocol} to the given path. EXPERIMENTAL. @returns: object conforming to L{IListeningPort}. r� )r� r# � DatagramPortr� )rI r� r� r� r� r� r' r' r( �listenUNIXDatagram� s z#PosixReactorBase.listenUNIXDatagramc C s, t sJ d��t�|||||| �}|�� |S )zd Connects a L{ConnectedDatagramProtocol} instance to a path. EXPERIMENTAL. r� )r� r# �ConnectedDatagramPortr� )rI r� r� r� r� � bindAddressr� r' r' r( �connectUNIXDatagram� s �z$PosixReactorBase.connectUNIXDatagram�_supportedAddressFamiliesc C sR || j vr t�|��tr|tjkrtj�| ||�}n t j�| |||�}|� � |S )a0 Create a new L{IListeningPort} from an already-initialized socket. This just dispatches to a suitable port implementation (eg from L{IReactorTCP}, etc) based on the specified C{addressFamily}. @see: L{twisted.internet.interfaces.IReactorSocket.adoptStreamPort} ) r� r �UnsupportedAddressFamilyr� r8 �AF_UNIXr# r� �_fromListeningDescriptorr r� )rI �fileDescriptor� addressFamilyr� r� r' r' r( �adoptStreamPort s �z PosixReactorBase.adoptStreamPortc C sD || j vr t�|��tr|tjkrtj�||| �S t j�|||| �S )zg @see: L{twisted.internet.interfaces.IReactorSocket.adoptStreamConnection} ) r� r r� r� r8 r� r# �Server�_fromConnectedSocketr )rI r� r� r� r' r' r( �adoptStreamConnection s �z&PosixReactorBase.adoptStreamConnectionc C s< |t jt jfvr t�|��tjj| ||||d�}|�� |S )N)r� ) r8 r9 �AF_INET6r r� r r� r� r� )rI r� r� r� r� r� r' r' r( �adoptDatagramPort% s �z"PosixReactorBase.adoptDatagramPortc C r� r[ )r r� r� )rI r� r� r� r� r� r' r' r( � listenTCP3 s zPosixReactorBase.listenTCPc C s t �|||||| �}|�� |S r[ )r r� rB )rI �hostr� r� r� r� r� r' r' r( � connectTCP8 s zPosixReactorBase.connectTCPc C sZ t d urt �|d|�}| �|||||�S td ur)t�||||||| �}|�� |S J d��)NTF�SSL support is not present)r �TLSMemoryBIOFactoryr� r r� rB ) rI r� r� r� �contextFactoryr� r� � tlsFactoryr� r' r' r( � connectSSL? s �zPosixReactorBase.connectSSLc C s` t d urt �|d|�}| �||||�}d|_|S td ur,t�|||||| �}|�� |S J d��)NF�TLSr� )r r� r� �_typer r� r� )rI r� r� r� r� r� r� r� r' r' r( � listenSSLN s zPosixReactorBase.listenSSLc C sJ t |�| j }|D ]}| �|� q t |�}|D ]}| �|� qt||B �S )ag Remove all readers and writers, and list of removed L{IReadDescriptor}s and L{IWriteDescriptor}s. Meant for calling from subclasses, to implement removeAll, like:: def removeAll(self): return self._removeAll(self._reads, self._writes) where C{self._reads} and C{self._writes} are iterables. )�setr� ru r{ �list)rI �readers�writers�removedReadersrL �removedWriters�writerr' r' r( � _removeAll[ s zPosixReactorBase._removeAll)r% rX )r% rX F)r� r )r� r� r )rX r� )rX r� N)rX )r� r% )r� N)"r. r/ r0 r1 �_Wakerr� r� r� r� r� r� r� r� r� r� r� r� r� r8 r9 r� r� r� r � AddressFamily�__annotations__r� r� r� r� r� r� r� r� r' r' r' r( r� 2 sR � : � ��� � � r� c @ rj )�_PollLikeMixina� Mixin for poll-like reactors. Subclasses must define the following attributes:: - _POLL_DISCONNECTED - Bitmask for events indicating a connection was lost. - _POLL_IN - Bitmask for events indicating there is input to read. - _POLL_OUT - Bitmask for events indicating output can be written. Must be mixed in to a subclass of PosixReactorBase (for _disconnectSelectable). c C s� d}d}|| j @ r|| j@ s|| jv rd}t}n:t}n7z#|�� dkr%t}n|| j@ r0|�� }d}|s=|| j@ r=|� � }d}W n t yQ t � � d }t �� Y nw |r]| �|||� dS dS )zg fd is available for read or write, do the work and raise errors if necessary. NFTrq r6 )�_POLL_DISCONNECTED�_POLL_IN�_readsr r rH � _NO_FILEDESCr+ � _POLL_OUT�doWrite� BaseException�sys�exc_infor �errr� )rI r| ri �eventr} �inReadr' r' r( �_doReadOrWrite� s0 � ��z _PollLikeMixin._doReadOrWriteN)r. r/ r0 r1 r� r' r' r' r( r� r s r� c @ s| e Zd ZdZdZdZdZdd� Zdd� Zd d � Z d d � Z d d� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd � Zd S ) �_ContinuousPollinga� Schedule reads and writes based on the passage of time, rather than notification. This is useful for supporting polling filesystem files, which C{epoll(7)} does not support. The implementation uses L{_PollLikeMixin}, which is a bit hacky, but re-implementing and testing the relevant code yet again is unappealing. @ivar _reactor: The L{EPollReactor} that is using this instance. @ivar _loop: A C{LoopingCall} that drives the polling, or L{None}. @ivar _readers: A C{set} of C{FileDescriptor} objects that should be read from. @ivar _writers: A C{set} of C{FileDescriptor} objects that should be written to. r6 � � c C s || _ d | _t� | _t� | _d S r[ )�_reactor�_loopr� �_readers�_writersre r' r' r( rN � s z_ContinuousPolling.__init__c C sr | j s| jr*| jdu r(ddlm}m} || j�| _| j| j_| jj |dd� dS dS | jr7| j� � d| _dS dS )zh Start or stop a C{LoopingCall} based on whether there are readers and writers. Nr )�_EPSILON� LoopingCallF)�now) r� r� r� �twisted.internet.taskr� r� �iterater� �clock�start�stop)rI r� r� r' r' r( � _checkLoop� s � �z _ContinuousPolling._checkLoopc C sD t | j�D ] }| �||| j� qt | j�D ] }| �||| j� qdS )zX Call C{doRead} and C{doWrite} on all readers and writers respectively. N)r� r� r� r� r� r� )rI rL r� r' r' r( r� � s �z_ContinuousPolling.iteratec C � | j �|� | �� dS )zU Add a C{FileDescriptor} for notification of data available to read. N)r� r� r� �rI rL r' r' r( r� � � z _ContinuousPolling.addReaderc C r )zV Add a C{FileDescriptor} for notification of data available to write. N)r� r� r� �rI r� r' r' r( � addWriter� r z _ContinuousPolling.addWriterc C �2 z| j �|� W n ty Y dS w | �� dS )zY Remove a C{FileDescriptor} from notification of data available to read. N)r� �remove�KeyErrorr� r r' r' r( ru s � z _ContinuousPolling.removeReaderc C r )zb Remove a C{FileDescriptor} from notification of data available to write. N)r� r r r� r r' r' r( r{ s � z _ContinuousPolling.removeWriterc C s( t | j| jB �}| j�� | j�� |S )z1 Remove all readers and writers. )r� r� r� �clear)rI �resultr' r' r( � removeAll s z _ContinuousPolling.removeAllc C � t | j�S )z/ Return a list of the readers. )r� r� rZ r' r' r( � getReaders& � z _ContinuousPolling.getReadersc C r )z/ Return a list of the writers. )r� r� rZ r' r' r( � getWriters, r z _ContinuousPolling.getWritersc C � || j v S )aj Checks if the file descriptor is currently being observed for read readiness. @param fd: The file descriptor being checked. @type fd: L{twisted.internet.abstract.FileDescriptor} @return: C{True} if the file descriptor is being observed for read readiness, C{False} otherwise. @rtype: C{bool} )r� �rI ri r' r' r( � isReading2 � z _ContinuousPolling.isReadingc C r )al Checks if the file descriptor is currently being observed for write readiness. @param fd: The file descriptor being checked. @type fd: L{twisted.internet.abstract.FileDescriptor} @return: C{True} if the file descriptor is being observed for write readiness, C{False} otherwise. @rtype: C{bool} )r� r r' r' r( � isWriting? r z _ContinuousPolling.isWritingN)r. r/ r0 r1 r� r� r� rN r� r� r� r ru r{ r r r r r r' r' r' r( r� � s" r� �fromfd)Gr1 r> rT r` r8 r� �typingr �zope.interfacer r r r �twisted.internetr r r �twisted.internet.baser r �twisted.internet.interfacesr r r r r r r r r r �twisted.internet.mainr r �twisted.pythonr r r �twisted.python.runtimer r �ConnectionFdescWentAway� _NO_FILENOr� �twisted.protocolsr �_tls� ImportErrorr �_sslr� r� r r! r" r# � isWindowsr� r$ �Loggerr4 r] rk r� rn rt r� r� r� �getattr�__all__r' r' r' r( �<module> s� 0 � � � 30 $ & AI PK Mb�Z��:�{ { 5 internet/__pycache__/_win32serialport.cpython-310.pycnu �[��� o �b2 � @ sl d Z ddlZddlZddlmZ ddlmZmZ ddlmZ ddl m Z ddl m Z G dd � d e e j �ZdS ) zB Serial port support for Windows. Requires PySerial and pywin32. � N)� PARITY_NONE)� EIGHTBITS� STOPBITS_ONE)�to_bytes)�abstract)�BaseSerialPortc @ sZ e Zd ZdZdZdeeeddfdd�Zdd� Z d d � Z d d � Z d d� Z dd� Z dd� ZdS )� SerialPortz@A serial device, acting as a transport, that uses a win32 event.� i�% r c C s� | j |||||d || d�| _| �� | �� || _|| _g | _d| _d| _d| _ || _t � � | _ t �d ddd �| j _t � � | _t �d ddd �| j_| j�| j j| d� | j�| jj| d� | j�| � | �� d S )N)�baudrate�bytesize�parity�stopbits�timeout�xonxoff�rtsctsr r �serialReadEvent�serialWriteEvent)�_serialFactory�_serial� flushInput� flushOutput�reactor�protocol�outQueue�closed�closedNotifies�writeInProgress� win32file� OVERLAPPED�_overlappedRead� win32event� CreateEvent�hEvent�_overlappedWrite�addEvent�makeConnection�_finishPortSetup) �selfr �deviceNameOrPortNumberr r r r r r r � r) �C/usr/lib/python3/dist-packages/twisted/internet/_win32serialport.py�__init__! s6 � zSerialPort.__init__c C s0 | � � \}}t�| jjt�d�| j�\}| _dS )zn Finish setting up the serial port. This is a separate method to facilitate testing. r N)�_clearCommErrorr �ReadFiler � _port_handle�AllocateReadBufferr �read_buf)r' �flags�comstat�rcr) r) r* r& L s �zSerialPort._finishPortSetupc C s t �| jj�S )N)r �ClearCommErrorr r. )r' r) r) r* r, Y s zSerialPort._clearCommErrorc C s� t �| jj| jd�}t| jd |� �}| �� \}}|jrLt � | jj � t � | jjt � |j�| j�\}}t �| jj| jd�}| j�|t|d |� � � n| j�|� t � | jj � t � | jjt � d�| j�\}| _d S )Nr r )r �GetOverlappedResultr r. r r r0 r, �cbInQuer � ResetEventr" r- r/ r � dataReceived)r' �n�firstr1 r2 r3 �bufr) r) r* r \ s. � � � �zSerialPort.serialReadEventc C s< |r | j r | j�|� d S d| _ t�| jj|| j� d S d S )Nr )r r �appendr � WriteFiler r. r# )r' �datar) r) r* �write| s ��zSerialPort.writec C sD z| j �d�}W n ty d| _Y d S w t�| jj|| j� d S )Nr ) r �pop� IndexErrorr r r= r r. r# )r' � dataToWriter) r) r* r � s � �zSerialPort.serialWriteEventc C sH | j �| jj� | j �| jj� tj�| |� | j� � | j �|� dS )z� Called when the serial port disconnects. Will call C{connectionLost} on the protocol that is handling the serial data. N) r � removeEventr r" r# r �FileDescriptor�connectionLostr �closer )r' �reasonr) r) r* rE � s zSerialPort.connectionLostN)�__name__� __module__� __qualname__�__doc__� connectedr r r r+ r& r, r r? r rE r) r) r) r* r s �+ r )rK r r �serialr r r �serial.serialutilr �twisted.internetr �twisted.internet.serialportr rD r r) r) r) r* �<module> s PK Mb�Z!��p p , internet/__pycache__/threads.cpython-310.pycnu �[��� o �b� � @ sX d Z ddlZddlmZ ddlmZ dd� Zdd� Zd d � Z d d � Z d d� Z g d�Z dS )zY Extended thread dispatching support. For basic support see reactor threading API docs. � N)�defer)�failurec s4 t �� � � �fdd�}|j||g|�R i |�� � S )a3 Call the function C{f} using a thread from the given threadpool and return the result as a Deferred. This function is only used by client code which is maintaining its own threadpool. To run a function in the reactor's threadpool, use C{deferToThread}. @param reactor: The reactor in whose main thread the Deferred will be invoked. @param threadpool: An object which supports the C{callInThreadWithCallback} method of C{twisted.python.threadpool.ThreadPool}. @param f: The function to call. @param args: positional arguments to pass to f. @param kwargs: keyword arguments to pass to f. @return: A Deferred which fires a callback with the result of f, or an errback with a L{twisted.python.failure.Failure} if f throws an exception. c s( | r �� � j|� d S �� � j|� d S �N)�callFromThread�callback�errback)�success�result��d�reactor� �:/usr/lib/python3/dist-packages/twisted/internet/threads.py�onResult* s z#deferToThreadPool.<locals>.onResult)r �Deferred�callInThreadWithCallback)r � threadpool�f�args�kwargsr r r r �deferToThreadPool s r c O s* ddl m} t||�� | g|�R i |��S )at Run a function in a thread and return the result as a Deferred. @param f: The function to call. @param args: positional arguments to pass to f. @param kwargs: keyword arguments to pass to f. @return: A Deferred which fires a callback with the result of f, or an errback with a L{twisted.python.failure.Failure} if f throws an exception. r �r )�twisted.internetr r � getThreadPool)r r r r r r r � deferToThread5 s r c C s" | D ] \}}}||i |�� qdS )z" Run a list of functions. Nr )� tupleListr r r r r r � _runMultipleF s �r c C s ddl m} |�t| � dS )z� Run a list of functions in the same thread. tupleList should be a list of (function, argsList, kwargsDict) tuples. r r N)r r � callInThreadr )r r r r r �callMultipleInThreadN s r c sD t � � �� ���fdd�}| �|� ��� }t|tj�r |�� |S )a� Run a function in the reactor from a thread, and wait for the result synchronously. If the function returns a L{Deferred}, wait for its result and return that. @param reactor: The L{IReactorThreads} provider which will be used to schedule the function call. @param f: the callable to run in the reactor thread @type f: any callable. @param a: the arguments to pass to C{f}. @param kw: the keyword arguments to pass to C{f}. @return: the result of the L{Deferred} returned by C{f}, or the result of C{f} if it returns anything other than a L{Deferred}. @raise Exception: If C{f} raises a synchronous exception, C{blockingCallFromThread} will raise that exception. If C{f} returns a L{Deferred} which fires with a L{Failure}, C{blockingCallFromThread} will raise that failure's exception (see L{Failure.raiseException}). c s( t j�g� �R i ���} | ��j� d S r )r � maybeDeferred�addBoth�put)r ��ar �kw�queuer r �_callFromThreadq s z/blockingCallFromThread.<locals>._callFromThread)�Queuer �get� isinstancer �Failure�raiseException)r r r# r$ r& r r r" r �blockingCallFromThreadY s r, )r r r r, ) �__doc__r% r' r r �twisted.pythonr r r r r r, �__all__r r r r �<module> s $ #PK Mb�Z���� � / internet/__pycache__/serialport.cpython-310.pycnu �[��� o �b� � @ s� d Z g d�ZddlZddlmZmZmZmZmZmZm Z m Z m Z ddl m Z G dd� d�Ze �� r9ddlmZ dS ddlmZ dS ) z Serial Port Protocol ) �serial� PARITY_ODD� PARITY_EVEN� PARITY_NONE� STOPBITS_TWO� STOPBITS_ONE�FIVEBITS� EIGHTBITS� SEVENBITS�SIXBITS� SerialPort� N) r r r r r r r r r )�platformc @ sr e Zd ZdZejZdd� Zdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zddd�Zddd�ZdS )�BaseSerialPortaV Base class for Windows and POSIX serial ports. @ivar _serialFactory: a pyserial C{serial.Serial} factory, used to create the instance stored in C{self._serial}. Overrideable to enable easier testing. @ivar _serial: a pyserial C{serial.Serial} instance used to manage the options on the serial port. c C s, t | jd�r| j�|� d S | j�|� d S )N� setBaudrate)�hasattr�_serialr � setBaudRate)�self�baudrate� r �=/usr/lib/python3/dist-packages/twisted/internet/serialport.pyr ; s zBaseSerialPort.setBaudRatec C � | j �� S �N)r � inWaiting�r r r r r A � zBaseSerialPort.inWaitingc C � | j �� d S r )r � flushInputr r r r r D � zBaseSerialPort.flushInputc C r r )r � flushOutputr r r r r G r zBaseSerialPort.flushOutputc C r r )r � sendBreakr r r r r J r zBaseSerialPort.sendBreakc C r r )r �getDSRr r r r r! M r zBaseSerialPort.getDSRc C r r )r �getCDr r r r r" P r zBaseSerialPort.getCDc C r r )r �getRIr r r r r# S r zBaseSerialPort.getRIc C r r )r �getCTSr r r r r$ V r zBaseSerialPort.getCTS� c C � | j �|� d S r )r �setDTR�r �onr r r r' Y � zBaseSerialPort.setDTRc C r& r )r �setRTSr( r r r r+ \ r* zBaseSerialPort.setRTSN)r% )�__name__� __module__� __qualname__�__doc__r �Serial�_serialFactoryr r r r r r! r" r# r$ r' r+ r r r r r - s r )r )r/ �__all__r r r r r r r r r r �twisted.python.runtimer r � isWindows�!twisted.internet._win32serialportr �!twisted.internet._posixserialportr r r r �<module> s , 4PK Mb�Z���R& & , internet/__pycache__/address.cpython-310.pycnu �[��� o 5�@g| � @ s& d Z ddlZddlmZmZmZ ddlmZ ddlm Z ddl Z ddl m Z ddl mZmZ ddlmZ e e �e jd d d �G d d � d ���Ze e �e jd d d �G d d� d���Ze e �G dd� d��Ze jd d d �e e �G dd� d���Ze jdddd d�e e �G dd� d���ZG dd� de�ZdS )z* Address objects for network connections. � N)�Literal�Optional�Union)�warn)� implementer)�IAddress)�_asFilesystemBytes�_coerceToFilesystemEncoding)�platformT)�hash� auto_attribsc @ sR e Zd ZU dZejej�ddg�d�Ze e d e d f e d< e e d< e e d< dS ) � IPv4Addressat An L{IPv4Address} represents the address of an IPv4 socket endpoint. @ivar type: A string describing the type of transport, either 'TCP' or 'UDP'. @ivar host: A string containing a dotted-quad IPv4 address; for example, "127.0.0.1". @type host: C{str} @ivar port: An integer representing the port number. @type port: C{int} �TCP�UDP�� validator�type�host�portN)�__name__� __module__� __qualname__�__doc__�attr�ib� validators�in_r r r �__annotations__�str�int� r r �:/usr/lib/python3/dist-packages/twisted/internet/address.pyr s � r c @ sr e Zd ZU dZejej�ddg�d�Ze e d e d f e d< e e d< e e d< dZe e d < dZe e e f e d < d S ) � IPv6Addressa� An L{IPv6Address} represents the address of an IPv6 socket endpoint. @ivar type: A string describing the type of transport, either 'TCP' or 'UDP'. @ivar host: A string containing a colon-separated, hexadecimal formatted IPv6 address; for example, "::1". @type host: C{str} @ivar port: An integer representing the port number. @type port: C{int} @ivar flowInfo: the IPv6 flow label. This can be used by QoS routers to identify flows of traffic; you may generally safely ignore it. @type flowInfo: L{int} @ivar scopeID: the IPv6 scope identifier - roughly analagous to what interface traffic destined for this address must be transmitted over. @type scopeID: L{int} or L{str} r r r r r r r �flowInfo�scopeIDN)r r r r r r r r r r r r r r r# r$ r r r r! r" . s � r" c @ s e Zd ZdZdS )�_ProcessAddresszD An L{interfaces.IAddress} provider for process transports. N)r r r r r r r r! r% P s r% c @ s" e Zd ZU dZeed< eed< dS )�HostnameAddressa A L{HostnameAddress} represents the address of a L{HostnameEndpoint}. @ivar hostname: A hostname byte string; for example, b"example.com". @type hostname: L{bytes} @ivar port: An integer representing the port number. @type port: L{int} �hostnamer N)r r r r �bytesr r r r r r! r& W s r& F)r �repr�eqr c @ s� e Zd ZU dZejej�e�d�Z e e e d< e ejdd�dur*dedefdd �Zn dedefd d �Zdefd d �Zd d� ZdS )� UNIXAddressz� Object representing a UNIX socket endpoint. @ivar name: The filename associated with this socket. @type name: C{bytes} )� converter�name�samefileN�other�returnc C s� t || j�stS | j|jk}|sE| jrE|jrEz tj�| j|j�W S ty* Y |S tt fyD } z t � � s9|�W Y d}~|S d}~ww |S )z� Overriding C{attrs} to ensure the os level samefile check is done if the name attributes do not match. N) � isinstance� __class__�NotImplementedr- �os�pathr. �OSError� TypeError� ValueErrorr �isLinux)�selfr/ �res�er r r! �__eq__x s" � ���zUNIXAddress.__eq__c C s t || j�r | j|jkS tS �N)r1 r2 r- r3 )r: r/ r r r! r= � s c C s" | j }|r td| j �}d|�d�S )N� z UNIXAddress(�))r- r )r: r- r r r! �__repr__� s zUNIXAddress.__repr__c C sT | j d u r t| jd f�S zt�| j �}t|j|jf�W S ty) t| j � Y S w r> )r- r r2 r4 �stat�st_ino�st_devr6 )r: �s1r r r! �__hash__� s �zUNIXAddress.__hash__)r r r r r r � converters�optionalr r- r r( r �getattrr4 r5 �object�boolr= r rA rF r r r r! r+ h s � r+ c @ s" e Zd ZdZdedefdd�ZdS )�_ServerFactoryIPv4Addressz@Backwards compatibility hack. Just like IPv4Address in practice.r/ r0 c C s^ t |t�rtdtdd� | j| jf|kS t |t�r-| j| j| jf}|j|j|jf}||kS tS )Nz?IPv4Address.__getitem__ is deprecated. Use attributes instead.� )�category� stacklevel) r1 �tupler �DeprecationWarningr r r r r3 )r: r/ �a�br r r! r= � s � z _ServerFactoryIPv4Address.__eq__N)r r r r rJ rK r= r r r r! rL � s rL )r r4 �typingr r r �warningsr �zope.interfacer r �twisted.internet.interfacesr �twisted.python.filepathr r �twisted.python.runtimer �sr r" r% r& r+ rL r r r r! �<module> s0 =PK Mb�Z�\/�o �o , internet/__pycache__/process.cpython-310.pycnu �[��� o �bt� � @ s� U d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z ddl mZ ddlmZmZmZ ddlmZ ddlmZ ddlmZmZ dd lmZm Z dd l m Z dd l m Z e �!� rme"d ��zddl#Z$W n e"y~ dZ#Y nw e$Z#z ddl%Z&ddl'Z'W n e"y� dZ%Y nw e&Z%ej(Z(i Z)e e*e f e+d < dd� Z,dd� Z-dd� Z.G dd� dej/�Z0G dd� dej/�Z1G dd� de�Z2G dd� d�Z3e3� Z4d d � Z5ee�G d d � d e2��Z6ee�G d d!� d!ej/e2��Z7dS )"z� UNIX Process management. Do NOT use this module directly - use reactor.spawnProcess() instead. Maintainer: Itamar Shtull-Trauring � N)�Callable�Dict�Optional)� implementer)�abstract�error�fdesc)� BaseProcess)�IProcessTransport)�CONNECTION_DONE�CONNECTION_LOST)�failure�log)�platform)� switchUIDz^twisted.internet.process does not work on Windows. Use the reactor.spawnProcess() API instead.�reapProcessHandlersc C s t t�� �D ]} | �� qdS )z( Reap all registered processes. N)�listr �values� reapProcess)�process� r �:/usr/lib/python3/dist-packages/twisted/internet/process.py�reapAllProcesses= s �r c C s� | t v rtd��z t�| tj�\}}W n ty2 t�d| � d�� t�� | du r.Y dS d}Y nw |r<|� |� dS |t | < dS )z� Register a process handler for the given pid, in case L{reapAllProcesses} is called. @param pid: the pid of the process. @param process: a process handler. z.Try to register an already registered process.�Failed to reap �:N) r � RuntimeError�os�waitpid�WNOHANG� BaseExceptionr �msg�err� processEnded)�pidr �auxPID�statusr r r �registerReapProcessHandlerG s � r& c C s& | t v r t | |kstd��t | = dS )zd Unregister a process handler previously registered with L{registerReapProcessHandler}. z+Try to unregister a process not registered.N)r r )r# r r r r � unregisterReapProcessHandlerb s r' c @ sN e Zd ZdZdZdZdZddd�Zdd� Zd d � Z d d � Z d d� Z dd� Z dS )� ProcessWritera� (Internal) Helper class to write into a Process's input pipe. I am a helper which describes a selectable asynchronous writer to a process's input pipe, including stdin. @ivar enableReadHack: A flag which determines how readability on this write descriptor will be handled. If C{True}, then readability may indicate the reader for this write descriptor has been closed (ie, the connection has been lost). If C{False}, then readability events are ignored. � r Fc C s� t j�| |� t�|� || _|| _|| _t� t � | � � �j �s$d| _n |r*d| _nz t �| � � d� W n ty@ d| _Y nw | jrJ| �� dS dS )zJ Initialize, specifying a Process instance to connect to. FTr N)r �FileDescriptor�__init__r �setNonBlocking�proc�name�fd�stat�S_ISFIFOr �fstat�fileno�st_mode�enableReadHack�read�OSError� startReading)�self�reactorr- r. r3 � forceReadHackr r r r+ ~ s" � �zProcessWriter.__init__c C � | j S )z< Return the fileno() of my process's stdin. �r/ �r9 r r r r3 � � zProcessWriter.filenoc C s, t �| j|�}|t|�kr| jr| �� |S �z6 Write some data to the open process. )r � writeToFDr/ �lenr5 r8 )r9 �data�rvr r r � writeSomeData� s zProcessWriter.writeSomeDatac C s | � � tj�| |� d S �N)� stopReadingr r* �write�r9 rC r r r rH � s zProcessWriter.writec C s | j rtS | �� dS )a� The only way a write pipe can become "readable" is at EOF, because the child has closed it, and we're using a reactor which doesn't distinguish between readable and closed (such as the select reactor). Except that's not true on linux < 2.6.11. It has the following characteristics: write pipe is completely empty => POLLOUT (writable in select), write pipe is not completely empty => POLLIN (readable in select), write pipe's reader closed => POLLIN|POLLERR (readable and writable in select) That's what this funky code is for. If linux was not broken, this function could be simply "return CONNECTION_LOST". N)r5 r rG r> r r r �doRead� s zProcessWriter.doReadc C s. t �| j� tj�| |� | j�| j|� dS )z= See abstract.FileDescriptor.connectionLost. N) r � setBlockingr/ r r* �connectionLostr- �childConnectionLostr. �r9 �reasonr r r rL � s z ProcessWriter.connectionLostN)F) �__name__� __module__� __qualname__�__doc__� connected�icr5 r+ r3 rE rH rJ rL r r r r r( l s r( c @ sL e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dS )� ProcessReaderzx ProcessReader I am a selectable representation of a process's output pipe, such as stdout and stderr. Tc C s6 t j�| |� t�|� || _|| _|| _| �� dS )zA Initialize, specifying a process to connect to. N) r r* r+ r r, r- r. r/ r8 )r9 r: r- r. r3 r r r r+ � s zProcessReader.__init__c C r< )z= Return the fileno() of my process's stderr. r= r> r r r r3 � r? zProcessReader.filenoc C s |dksJ �t S )N� )r rI r r r rE � s zProcessReader.writeSomeDatac C s t �| j| j�S )z@ This is called when the pipe becomes readable. )r � readFromFDr/ � dataReceivedr> r r r rJ � s zProcessReader.doReadc C s | j �| j|� d S rF )r- �childDataReceivedr. rI r r r rY � � zProcessReader.dataReceivedc C s> | j r| js d| _| �� | j�d| jt�t�� d S d S d S )Nr) r ) rT � disconnectingrG r: � callLaterrL r �Failurer r> r r r �loseConnection� s ��z ProcessReader.loseConnectionc C s" t j�| |� | j�| j|� dS )zk Close my end of the pipe, signal the Process (which signals the ProcessProtocol). N)r r* rL r- rM r. rN r r r rL � z ProcessReader.connectionLostN) rP rQ rR rS rT r+ r3 rE rJ rY r_ rL r r r r rV � s rV c @ sl e Zd ZU dZdZee ed< dZdd� Z dd� Z dd � Z d d � Z d d � Z dd� Zdd� Zdefdd�ZdS )� _BaseProcessz0 Base class for Process and PTYProcess. Nr% c C s� z+z t �| jt j�\}}W n ty) } z|jtjkr d}n� W Y d}~nd}~ww W n tyD t� d| j� d�� t� � d}Y nw |rSt || � | � |� dS dS )a Try to reap a process (without blocking) via waitpid. This is called when sigchild is caught or a Process object loses its "connection" (stdout is closed) This ought to result in reaping all zombie processes, since it will be called twice as often as it needs to be. (Unfortunately, this is a slightly experimental approach, since UNIX has no way to be really sure that your process is going to go away w/o blocking. I don't want to block.) Nr r ) r r r# r r7 �errno�ECHILDr r r r! r' r" )r9 r# r% �er r r r s( ���� � �z_BaseProcess.reapProcessc C sH d }}t �|�rt �|�}nt �|�}|s|r t�|||�S t�|�S rF )r � WIFEXITED� WEXITSTATUS�WTERMSIGr �ProcessTerminated� ProcessDone)r9 r% �exitCode�sigr r r � _getReason6 s z_BaseProcess._getReasonc C sj |dv r t td|� ��}| jdu rt� �z t�| j|� W dS ty4 } z |jtjkr/t� �� d}~ww )a* Send the given signal C{signalID} to the process. It'll translate a few signals ('HUP', 'STOP', 'INT', 'KILL', 'TERM') from a string representation to its int value, otherwise it'll pass directly the value provided @type signalID: C{str} or C{int} )�HUP�STOP�INT�KILL�TERM�SIGN) �getattr�signalr# �ProcessExitedAlreadyr �killr7 rb �ESRCH)r9 �signalIDrd r r r � signalProcess@ s ��z_BaseProcess.signalProcessc C s4 t dtj�D ]}t�|�tjkrt�|tj� qd S �Nr) )�rangert �NSIG� getsignal�SIG_IGN�SIG_DFL)r9 � signalnumr r r �_resetSignalDispositionU s ��z$_BaseProcess._resetSignalDispositionc K s& t �� }t �� zt�� | _W n ty |r t �� � w | jdkr�zt� d� | j d i |�� | � ||||||� W nF ty� z3t j t�dd�dd�} d�|t|�t|��} | �| � tj| d� | �� td �D ]} t�| � qmW n ty Y nw Y nw t�d � |r�t �� d | _dS ) a� Fork and then exec sub-process. @param path: the path where to run the new process. @type path: L{bytes} or L{unicode} @param uid: if defined, the uid used to run the new process. @type uid: L{int} @param gid: if defined, the gid used to run the new process. @type gid: L{int} @param executable: the executable to run in a new process. @type executable: L{str} @param args: arguments used to create the new process. @type args: L{list}. @param environment: environment used for the new process. @type environment: L{dict}. @param kwargs: keyword arguments to L{_setupChild} method. r N� �wbzutf-8)�encodingz)Upon execvpe {} {} in environment id {} :��file� r) ���r )�gc� isenabled�disabler �forkr# r �enable�sys�settrace� _setupChild� _execChild�io� TextIOWrapper�fdopen�format�str�idrH � traceback� print_exc�flushr{ �close�_exitr% ) r9 �path�uid�gid� executable�args� environment�kwargs�collectorEnabled�stderrr r/ r r r �_fork` sF � � � ��� * z_BaseProcess._forkc O � t � �)zB Setup the child process. Override in subclasses. ��NotImplementedError)r9 r� r� r r r r� � r? z_BaseProcess._setupChildc C sn |rt �|� |dus|dur.|du rt �� }|du r t �� }t �d� t �d� t||� t �|||� dS )z? The exec() which is done in the forked child. Nr )r �chdir�geteuid�getegid�setuid�setgidr �execvpe)r9 r� r� r� r� r� r� r r r r� � s z_BaseProcess._execChild�returnc C s d� | jj| j| j�S )z5 String representation of a process. z<{} pid={} status={}>)r� � __class__rP r# r% r> r r r �__repr__� s �z_BaseProcess.__repr__)rP rQ rR rS r% r �int�__annotations__r# r rl ry r� r� r� r� r� r� r r r r ra s _ra c @ sP e Zd ZdZejZejZeZdd� Z dd� Z dd� Z dd � Z d d � Z d d � ZdS )� _FDDetectorav This class contains the logic necessary to decide which of the available system techniques should be used to detect the open file descriptors for the current process. The chosen technique gets monkey-patched into the _listOpenFDs method of this class so that the detection only needs to occur once. @ivar listdir: The implementation of listdir to use. This gets overwritten by the test cases. @ivar getpid: The implementation of getpid to use, returns the PID of the running process. @ivar openfile: The implementation of open() to use, by default the Python builtin. c C s | j | j| jg| _d S rF )�_procFDImplementation�_devFDImplementation�_fallbackFDImplementation�_implementationsr> r r r r+ � s �z_FDDetector.__init__c C s | � � | _| �� S )z� Return an iterable of file descriptors which I{may} be open in this process. This will try to return the fewest possible descriptors without missing any. )�_getImplementation� _listOpenFDsr> r r r r� � s z_FDDetector._listOpenFDsc C sp | j D ]2}z|� }W n ty Y qw | �dd�� |� }W d � n1 s(w Y ||kr5| S q|S )a� Pick a method which gives correct results for C{_listOpenFDs} in this runtime environment. This involves a lot of very platform-specific checks, some of which may be relatively expensive. Therefore the returned method should be saved and re-used, rather than always calling this method to determine what it is. See the implementation for the details of how a method is selected. z /dev/null�rN)r� r �openfile)r9 �impl�before�afterr r r r� s � ��z _FDDetector._getImplementationc C s d}dd� | � |�D �}|S )z� Simple implementation for systems where /dev/fd actually works. See: http://www.freebsd.org/cgi/man.cgi?fdescfs z/dev/fdc S � g | ]}t |��qS r �r� ��.0r/ r r r � <listcomp>+ � z4_FDDetector._devFDImplementation.<locals>.<listcomp>)�listdir)r9 �dname�resultr r r r� % s z _FDDetector._devFDImplementationc C s" d| � � f }dd� | �|�D �S )zk Simple implementation for systems where /proc/pid/fd exists (we assume it works). z /proc/%d/fdc S r� r r� r� r r r r� 4 r� z5_FDDetector._procFDImplementation.<locals>.<listcomp>)�getpidr� )r9 r� r r r r� . r` z!_FDDetector._procFDImplementationc C sH zddl }W n ty d}Y t|�S w td|�|j�d �}t|�S )au Fallback implementation where either the resource module can inform us about the upper bound of how many FDs to expect, or where we just guess a constant maximum if there is no resource module. All possible file descriptors from 0 to that upper bound are returned with no attempt to exclude invalid file descriptor values. r Ni r) )�resource� ImportError�min� getrlimit� RLIMIT_NOFILEr{ )r9 r� �maxfdsr r r r� 6 s �z%_FDDetector._fallbackFDImplementationN)rP rQ rR rS r r� r� �openr� r+ r� r� r� r� r� r r r r r� � s r� c C s t �� S )zZ Use the global detector object to figure out which FD implementation to use. )�detectorr� r r r r r� N s r� c @ s� e Zd ZdZdZdZdZdZeZ e Z d+dd�Z dd� Z d d � Zd d � Zd d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Z d'd(� Z d)d*� Z dS ),�Processa� An operating-system Process. This represents an operating-system process with arbitrary input/output pipes connected to it. Those pipes may represent standard input, standard output, and standard error, or any other file descriptor. On UNIX, this is implemented using fork(), exec(), pipe() and fcntl(). These calls may not exist elsewhere so this code is not cross-platform. (also, windows can only select on sockets...) Fr� Nc sJ |sd| � � vs J �d| � � vsJ �t�| |� i | _i } | du r'dddd�} | j} | r1td| � g � � fdd�} i } zw| �� D ]V\}}| rMtd| |� |dkri| � \}}| r`td ||f � || |< || |< q@|dkr�| � \}}| r|td ||f � || |< || |< q@t|�tks�J |�d ���|| |< q@| r�td | � | r�td | � | j ||||||| d � W n t y� � D ]} t � | � q�� w || _ | �� D ]3\}}t � | | � | | dkr�| �|| ||�}|| j|< | | dkr�| j|| ||dd�}|| j|< q�z| j du�r | j �| � W n t �y t�� Y nw t| j| � dS )� Spawn an operating-system process. This is where the hard work of disconnecting all currently open files / forking / executing the new process happens. (This is executed automatically when a Process is instantiated.) This will also run the subprocess as a given user ID and group ID, if specified. (Implementation Note: this doesn't support all the arcane nuances of setXXuid on UNIX: it will assume that either your effective or real UID is 0.) r� �wN)r r) r� �childFDsc s" t �� \} }� �| |g� | |fS rF )r �pipe�extend)r� r� �� _openedPipesr r r� � s z Process.__init__.<locals>.pipez[%d]zreadFD=%d, writeFD=%dz should be an int�fdmap�helpers)r� T)r; )r ra r+ �pipes�debug�print�items�typer� r� r r r� �proto�processReaderFactory�processWriterFactory�makeConnectionr r! r& r# )r9 r: r� r� r� r� r� r� r� r� r� r� r� r� �childFD�target�readFD�writeFD�parentFD�reader�writerr r� r r+ n s� � � � � � �zProcess.__init__c C s� | j }|r tj}|�d� |�� }t� D ] }||v rq|r$||�� kr$qzt�|� W q t y4 Y qw |r>t d||d� t |� � �D ][}|| }||kr^|rXt d| |d� t �|� qD||�� v r�t�|�}|rut d||f |d� t�|� t|�� �D ] \} } | |kr�||| < q�|r�t d||f |d� t�||� qDg } |�� D ]}|| vr�||� � vr�| �|� q�|r�t d| |d� | D ]}t�|� q�| �� dS ) a fdmap[childFD] = parentFD The child wants to end up with 'childFD' attached to what used to be the parent's parentFD. As an example, a bash command run like 'command 2>&1' would correspond to an fdmap of {0:0, 1:1, 2:1}. 'command >foo.txt' would be {0:0, 1:os.open('foo.txt'), 2:2}. This is accomplished in two steps:: 1. close all file descriptors that aren't values of fdmap. This means 0 .. maxfds (or just the open fds within that range, if the platform supports '/proc/<pid>/fd'). 2. for each childFD:: - if fdmap[childFD] == childFD, the descriptor is already in place. Make sure the CLOEXEC flag is not set, then delete the entry from fdmap. - if childFD is in fdmap.values(), then the target descriptor is busy. Use os.dup() to move it elsewhere, update all fdmap[childFD] items that point to it, then close the original. Then fall through to the next case. - now fdmap[childFD] is not in fdmap.values(), and is free. Use os.dup2() to move it to the right place, then close the original. zstarting _setupChild r� r� z%d already in placezos.dup(%d) -> %dzos.dup2(%d,%d)�oldN)� debug_childr� r� rH r r� r3 r r� r r� �sorted�keysr �_unsetCloseOnExec�dupr r� �dup2�appendr� ) r9 r� r� �errfd�destListr/ �childr� � newtarget�c�pr� r r r r� � s\ � � � zProcess._setupChildc C s | j | �|� d S rF �r� rH �r9 r� rC r r r � writeToChildE r[ zProcess.writeToChildc C s || j v r| j | �� d S d S rF )r� r_ )r9 r� r r r � closeChildFDH s �zProcess.closeChildFDc C �& | j �� D ] }t|t�r|�� qd S rF )r� r � isinstancerV rG �r9 r� r r r �pauseProducingP � ��zProcess.pauseProducingc C r� rF )r� r r rV r8 r r r r �resumeProducingU r zProcess.resumeProducingc C s | � d� dS )zD Call this to close standard input on this process. r N�r� r> r r r � closeStdin[ � zProcess.closeStdinc C � | � d� d S rz r r> r r r � closeStdouta � zProcess.closeStdoutc C r �Nr� r r> r r r � closeStderrd r zProcess.closeStderrc C s | � � | �� | �� d S rF )r r r r> r r r r_ g s zProcess.loseConnectionc C �" d| j v r| j d �|� dS dS �z� Call this to write to standard input on this process. NOTE: This will silently lose data if there is no standard input. r Nr� rI r r r rH l � �z Process.writec C s, d| j v r| j d �||� dS |�� dS )z� Call this to register producer for standard input. If there is no standard input producer.stopProducing() will be called immediately. r N)r� �registerProducer� stopProducing)r9 �producer� streamingr r r r u s zProcess.registerProducerc C s d| j v r| j d �� dS dS )z= Call this to unregister producer for standard input.r N)r� �unregisterProducerr> r r r r � s �zProcess.unregisterProducerc C r r )r� � writeSequence)r9 �seqr r r r � r zProcess.writeSequencec C s | j �||� d S rF �r� rZ )r9 r. rC r r r rZ � s zProcess.childDataReceivedc C sT t �| j| �� � | j|= z| j�|� W n ty# t�� Y nw | � � d S rF ) r r� r� r3 r� rM r r r! �maybeCallProcessEnded)r9 r� rO r r r rM � s � zProcess.childConnectionLostc C s* | j rd S | js| �� d S t�| � d S rF )r� � lostProcessr ra r r> r r r r � s z Process.maybeCallProcessEndedc C r� rF r� r> r r r �getHost� � zProcess.getHostc C r� rF r� r> r r r �getPeer� r zProcess.getPeer�NNN) rP rQ rR rS r� r� r% r# r( r� rV r� r+ r� r� r� r r r r r r_ rH r r r rZ rM r r r r r r r r� V s< �w` r� c @ s� e Zd ZdZdZdZ d dd�Zdd� Zdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� ZdS ) � PTYProcessz< An operating-system Process that uses PTY support. r� Nc C s t du rt| ttf�std��tj�| |� t�| |� t| ttf�r)| \} } } nt � � \} } z| j ||||||| | d� W n t yW t| ttf�sVt � | � t � | � � w t � | � t�| � | | _| �� d| _d| _z| j�| � W n t y� t�� Y nw t| j| � dS )r� Nz:cannot use PTYProcess on platforms without the pty module.)�masterfd�slavefdr) r� )�ptyr �tupler r� r r* r+ ra �openptyr� r r r� r r, r/ r8 rT r% r� r� r r! r& r# ) r9 r: r� r� r� r� r� r� r� �usePTYr r �_r r r r+ � sL � � � �zPTYProcess.__init__c C s� t �|� t �� t�|tjd� td�D ] }||kr t �|� qt �|d� t �|d� t �|d� t � D ]}|dkrMzt �|� W q6 t yL Y q6w q6| � � dS )a9 Set up child process after C{fork()} but before C{exec()}. This involves: - closing C{masterfd}, since it is not used in the subprocess - creating a new session with C{os.setsid} - changing the controlling terminal of the process (and the new session) to point at C{slavefd} - duplicating C{slavefd} to standard input, output, and error - closing all other open file descriptors (according to L{_listOpenFDs}) - re-setting all signal handlers to C{SIG_DFL} @param masterfd: The master end of a PTY file descriptors opened with C{openpty}. @type masterfd: L{int} @param slavefd: The slave end of a PTY opened with C{openpty}. @type slavefd: L{int} � r� r r) r� N) r r� �setsid�fcntl�ioctl�termios� TIOCSCTTYr{ r� r� r r� )r9 r r r/ r r r r� s& � �� zPTYProcess._setupChildc C � d S rF r r> r r r r 0 s zPTYProcess.closeStdinc C r, rF r r> r r r r 5 � zPTYProcess.closeStdoutc C r, rF r r> r r r r 8 r- zPTYProcess.closeStderrc s t �� j� fdd��S )zM Called when my standard output stream is ready for reading. c s � j �d| �S rz r )rC r> r r �<lambda>@ s z#PTYProcess.doRead.<locals>.<lambda>)r rX r/ r> r r> r rJ ; s �zPTYProcess.doReadc C r< )zR This returns the file number of standard output on this process. r= r> r r r r3 C r? zPTYProcess.filenoc C s | j dkr t�| � d S d S r )r ra r r> r r r r I s �z PTYProcess.maybeCallProcessEndedc C s4 t j�| |� t�| j� | jd7 _| �� dS )zU I call this to clean up when one or all of my connections has died. r) N)r r* rL r r� r/ r r rN r r r rL S s zPTYProcess.connectionLostc C s t �| j|�S r@ )r rA r/ rI r r r rE \ r zPTYProcess.writeSomeDatac C r� rF r� )r9 � descriptorr r r r� b r zPTYProcess.closeChildFDc C r� rF r� r� r r r r� f r zPTYProcess.writeToChildr )rP rQ rR rS r% r# r+ r� r r r rJ r3 r rL rE r� r� r r r r r � s& �C0 r )8rS rb r� r� r rt r0 r� r� �typingr r r �zope.interfacer �twisted.internetr r r � twisted.internet._baseprocessr �twisted.internet.interfacesr �twisted.internet.mainr r �twisted.pythonr r �twisted.python.runtimer �twisted.python.utilr � isWindowsr� r! �_ptyr( �_fcntlr* ru r r� r� r r& r' r* r( rV ra r� r� r� r� r r r r r �<module> sj � � � h< Rj _PK Mb�ZKSK�� � 0 internet/__pycache__/_posixstdio.cpython-310.pycnu �[��� o �b� � @ st d Z ddlmZ ddlmZmZmZ ddlmZm Z eej �G dd� d��Z eej ej ejej�G dd� d��Zd S ) z�Standard input/out/err support. Future Plans:: support for stderr, perhaps Rewrite to use the reactor instead of an ad-hoc mechanism for connecting protocols to transport. Maintainer: James Y Knight � )� implementer)�error� interfaces�process)�failure�logc @ s e Zd ZdS )� PipeAddressN)�__name__� __module__� __qualname__� r r �>/usr/lib/python3/dist-packages/twisted/internet/_posixstdio.pyr s r c @ s� e Zd ZdZdZdZdZd/dd�Zdd� Zd d � Z d d � Z d d� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� ZdS )0� StandardIONFr � c C sX |d u r ddl m} || _t�|| d|�| _t�|| d|�| _| j�� | j� | � d S )Nr )�reactor�write�read) �twisted.internetr �protocolr � ProcessWriter�_writer� ProcessReader�_reader� startReading�makeConnection)�self�proto�stdin�stdoutr r r r �__init__& s zStandardIO.__init__c C � | j d ur | j �� d S d S �N)r �loseConnection�r r r r �loseWriteConnection3 � �z StandardIO.loseWriteConnectionc C � | j d ur | j �|� d S d S r! )r r �r �datar r r r 7 � �zStandardIO.writec C r& r! )r � writeSequencer' r r r r* ; r) zStandardIO.writeSequencec C s6 d| _ | jd ur | j�� | jd ur| j�� d S d S �NT)� disconnectingr r" r � stopReadingr# r r r r" ? s �zStandardIO.loseConnectionc C � t � S r! �r r# r r r �getPeerH � zStandardIO.getPeerc C r. r! r/ r# r r r �getHostK r1 zStandardIO.getHostc C s | j �|� d S r! )r � dataReceived)r �fdr( r r r �childDataReceivedO s z StandardIO.childDataReceivedc C sJ | j rd S |jjtjkr |dkr| �|� d S | �|� d S | �|� d S )Nr )� disconnected�value� __class__r �ConnectionDone�_readConnectionLost�_writeConnectionLost�connectionLost)r r4 �reasonr r r �childConnectionLostR s z StandardIO.childConnectionLostc C s� d| _ | j}| j}| j}d | _| _d | _|d ur!|j s!|�|� |d ur-|j s-|�|� z|�|� W d S tyC t�� Y d S w r+ )r6 r r r r< � BaseExceptionr �err)r r= r r r r r r r< _ s �zStandardIO.connectionLostc C sj d | _ | jr | �|� d S t�| jd �}|r3z|�� W d S ty2 t� � | �t � � � Y d S w d S r! ) r r, r< r �IHalfCloseableProtocolr �writeConnectionLostr? r r@ r �Failure�r r= �pr r r r; t s ��z StandardIO._writeConnectionLostc C s` d | _ t�| jd �}|r)z|�� W d S ty( t�� | �t � � � Y d S w | �|� d S r! ) r r rA r �readConnectionLostr? r r@ r< r rC rD r r r r: � s �z StandardIO._readConnectionLostc C s( | j d u r |�� d S | j �||� d S r! )r � stopProducing�registerProducer)r �producer� streamingr r r rH � s zStandardIO.registerProducerc C r r! )r �unregisterProducerr# r r r rK � r% z StandardIO.unregisterProducerc C s | � � d S r! )r" r# r r r rG � s zStandardIO.stopProducingc C r r! )r �pauseProducingr# r r r rL � r% zStandardIO.pauseProducingc C r r! )r �resumeProducingr# r r r rM � r% zStandardIO.resumeProducingc C � | � � dS )z3Compatibility only, don't use. Call pauseProducing.N)rL r# r r r r- � � zStandardIO.stopReadingc C rN )z4Compatibility only, don't use. Call resumeProducing.N)rM r# r r r r � rO zStandardIO.startReadingc C � t � �r! ��NotImplementedError�r r= r r r rF � � z StandardIO.readConnectionLostc C rP r! rQ rS r r r rB � rT z StandardIO.writeConnectionLost)r r N) r r r r r r6 r, r r$ r r* r" r0 r2 r5 r> r< r; r: rH rK rG rL rM r- r rF rB r r r r r s4 r N)�__doc__�zope.interfacer r r r r �twisted.pythonr r �IAddressr � ITransport� IProducer� IConsumer�IHalfCloseableDescriptorr r r r r �<module> s �PK Mb�Z� M � � 5 internet/__pycache__/_posixserialport.cpython-310.pycnu �[��� o �b! � @ sT d Z ddlmZ ddlmZmZ ddlmZmZ ddlm Z G dd� de ej �Z dS ) z Serial Port Protocol � )� PARITY_NONE)� EIGHTBITS� STOPBITS_ONE)�abstract�fdesc)�BaseSerialPortc @ sL e Zd ZdZdZdeeedddfdd�Zdd� Z d d � Z d d � Z d d� Z dS )� SerialPortz> A select()able serial device, acting as a transport. � i�% r c C s^ t j�| |� | j||||||| | d�| _|| _| �� | �� || _| j� | � | � � d S )N)�baudrate�bytesize�parity�stopbits�timeout�xonxoff�rtscts) r �FileDescriptor�__init__�_serialFactory�_serial�reactor� flushInput� flushOutput�protocol�makeConnection� startReading) �selfr �deviceNameOrPortNumberr r r r r r r r � r �C/usr/lib/python3/dist-packages/twisted/internet/_posixserialport.pyr s" � zSerialPort.__init__c C s | j jS )N)r �fd�r r r r �fileno9 s zSerialPort.filenoc C s t �| �� |�S )z7 Write some data to the serial device. )r � writeToFDr! )r �datar r r � writeSomeData< s zSerialPort.writeSomeDatac C s t �| �� | jj�S )z: Some data's readable from serial device. )r � readFromFDr! r � dataReceivedr r r r �doReadB s zSerialPort.doReadc C s( t j�| |� | j�� | j�|� dS )z� Called when the serial port disconnects. Will call C{connectionLost} on the protocol that is handling the serial data. N)r r �connectionLostr �closer )r �reasonr r r r( H s zSerialPort.connectionLostN) �__name__� __module__� __qualname__�__doc__� connectedr r r r r! r$ r' r( r r r r r s � r N) r. �serialr r r �twisted.internetr r �twisted.internet.serialportr r r r r r r �<module> s PK Mb�Z� �. . . internet/__pycache__/_glibbase.cpython-310.pycnu �[��� o �b�1 � @ s� d Z ddlZddlmZ ddlmZmZmZ ddlm Z ddl m Z g fdd�Z G d d � d ej �Zee �G d d � d ejej��ZG d d� dej�ZdS )aC This module provides base support for Twisted to interact with the glib/gtk mainloops. The classes in this module should not be used directly, but rather you should import gireactor or gtk3reactor for GObject Introspection based applications, or glib2reactor or gtk2reactor for applications using legacy static bindings. � N)� implementer)�base� posixbase� selectreactor)� IReactorFDSet)�logc C s: | D ]}t j�|�durt|��q|D ]}dt j|< qdS )a[ Check whether the given modules were imported, and if requested, ensure they will not be importable in the future. @param moduleNames: A list of module names we make sure aren't imported. @type moduleNames: C{list} of C{str} @param preventImports: A list of module name whose future imports should be prevented. @type preventImports: C{list} of C{str} @param errorMessage: Message to use when raising an C{ImportError}. @type errorMessage: C{str} @raise ImportError: with given error message if a given module name has already been imported. N)�sys�modules�get� ImportError)� moduleNames� errorMessage�preventImports�name� r �</usr/lib/python3/dist-packages/twisted/internet/_glibbase.py�ensureNotImported s � �r c @ s e Zd ZdZdd� ZdS )� GlibWakerz/ Run scheduled events after waking up. c C s t j�| � | j�� d S �N)r � _UnixWaker�doRead�reactor� _simulate��selfr r r r 8 s zGlibWaker.doReadN)�__name__� __module__� __qualname__�__doc__r r r r r r 3 s r c @ s� e Zd ZdZeZd.dd�Zdd� Zdd� Zd d � Z d d � Z d d� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd � Zd/d d �Zd d!� Zd"d#� Zd0d%d&�Zd'd(� Zd)d*� Zd+d,� Zd-S )1�GlibReactorBasea7 Base class for GObject event loop reactors. Notification for I/O events (reads and writes on file descriptors) is done by the gobject-based event loop. File descriptors are registered with gobject with the appropriate flags for read/write/disconnect notification. Time-based events, the results of C{callLater} and C{callFromThread}, are handled differently. Rather than registering each event with gobject, a single gobject timeout is registered for the earliest scheduled event, the output of C{reactor.timeout()}. For example, if there are timeouts in 1, 2 and 3.4 seconds, a single timeout is registered for 1 second in the future. When this timeout is hit, C{_simulate} is called, which calls the appropriate Twisted-level handlers, and a new timeout is added to gobject by the C{_reschedule} method. To handle C{callFromThread} events, we use a custom waker that calls C{_simulate} whenever it wakes up. @ivar _sources: A dictionary mapping L{FileDescriptor} instances to GSource handles. @ivar _reads: A set of L{FileDescriptor} instances currently monitored for reading. @ivar _writes: A set of L{FileDescriptor} instances currently monitored for writing. @ivar _simtag: A GSource handle for the next L{simulate} call. Fc s� d � _ t� � _t� � _i � _|� _|� _tj� � � � jj � _ � jj � _ � fdd�}|r@� jj� _� jj� _|� _� jj� _d S � j�� � _� jj� _� jj� _� j�� � _� fdd�� _� jj� _d S )Nc � � j �� r � j �� d S d S r ��_gtk� main_level� main_quitr r r r � _mainquitn � �z+GlibReactorBase.__init__.<locals>._mainquitc � � j �� jj�S r ��_glib�idle_add�loop�quitr r r r �<lambda>| � z*GlibReactorBase.__init__.<locals>.<lambda>) �_simtag�set�_reads�_writes�_sourcesr) r" r �PosixReactorBase�__init__� source_remove�_source_remove� timeout_add� _timeout_add�events_pending�_pending�main_iteration_do� _iteration�_crash�main�_run�main_context_default�context�pending� iteration�MainLoopr+ �run�r � glib_module� gtk_module�useGtkr% r r r r5 b s* zGlibReactorBase.__init__c C s" t j�| � | �dtjj| � d S )Nr )r �_SignalReactorMixin�_handleSignals� callLaterr r4 r r r r rL s z GlibReactorBase._handleSignalsc sB t �d�r� �fdd�}��� }n�}� }| jj|||| jjd�S )N�filenoc s � �|�S r r )�ignored� condition��callback�sourcer r �wrapper� s z*GlibReactorBase.input_add.<locals>.wrapper��priority)�hasattrrN r) � io_add_watch�PRIORITY_DEFAULT_IDLE)r rS rP rR rT rN r rQ r � input_add� s �zGlibReactorBase.input_addc C s t �|| j|||� dS )z@ Called by event loop when an I/O event occurs. T)r �callWithLogger�_doReadOrWrite)r rS rP r r r �_ioEventCallback� s z GlibReactorBase._ioEventCallbackc C sT ||v rdS |}||v r| � | j| � ||O }| �||| j�| j|< |�|� dS )a Add the given L{FileDescriptor} for monitoring either for reading or writing. If the file is already monitored for the other operation, we delete the previous registration and re-register it for both reading and writing. N)r7 r3 rZ r] �add)r rS �primary�other� primaryFlag� otherFlag�flagsr r r �_add� s zGlibReactorBase._addc C � | � || j| j| j| j� dS )zS Add a L{FileDescriptor} for monitoring of data available to read. N)rd r1 r2 �INFLAGS�OUTFLAGS�r �readerr r r � addReader� � zGlibReactorBase.addReaderc C re )zO Add a L{FileDescriptor} for monitoring ability to write data. N)rd r2 r1 rg rf �r �writerr r r � addWriter� rk zGlibReactorBase.addWriterc C � t | j�S )zW Retrieve the list of current L{FileDescriptor} monitored for reading. )�listr1 r r r r � getReaders� � zGlibReactorBase.getReadersc C ro )zW Retrieve the list of current L{FileDescriptor} monitored for writing. )rp r2 r r r r � getWriters� rr zGlibReactorBase.getWritersc C s | � | j| j�S )zJ Remove monitoring for all registered L{FileDescriptor}s. )� _removeAllr1 r2 r r r r � removeAll� s zGlibReactorBase.removeAllc C sX ||vrdS | � | j| � |�|� ||v r$| �||| j�| j|< dS | j�|� dS )z� Remove monitoring the given L{FileDescriptor} for either reading or writing. If it's still monitored for the other operation, we re-register the L{FileDescriptor} for only that operation. N)r7 r3 �removerZ r] �pop)r rS r_ r` rc r r r �_remove� s zGlibReactorBase._removec C � | � || j| j| j� dS )zJ Stop monitoring the given L{FileDescriptor} for reading. N)rx r1 r2 rg rh r r r � removeReader� � z GlibReactorBase.removeReaderc C ry )zJ Stop monitoring the given L{FileDescriptor} for writing. N)rx r2 r1 rf rl r r r � removeWriter� r{ z GlibReactorBase.removeWriterr c C s* | � � | �� r| �d� | �� sdS dS )zv One iteration of the event loop, for trial's use. This is not used for actual reactor runs. r N)�runUntilCurrentr; r= )r �delayr r r �iterate� s �zGlibReactorBase.iteratec C � t j�| � | �� dS )z$ Crash the reactor. N)r r4 �crashr> r r r r r� � s zGlibReactorBase.crashc C r� )z# Stop the reactor. N)r r4 �stop�wakeUpr r r r r� s zGlibReactorBase.stopTc C s. | � | j� | j|d� | jr| �� dS dS )z" Run the reactor. ��installSignalHandlersN)�callWhenRunning� _reschedule� startRunning�_startedr@ �r r� r r r rF s �zGlibReactorBase.runc O s& t jj| g|�R i |��}| �� |S )z, Schedule a C{DelayedCall}. )r r4 rM r� )r �args�kwargs�resultr r r rM s zGlibReactorBase.callLaterc C sT | j dur| �| j � d| _ | �� }|dur(| jt|d �| j| jjd�| _ dS dS )z; Schedule a glib timeout for C{_simulate}. N�� rU )r/ r7 �timeoutr9 �intr r) rY �r r� r r r r� ! s ��zGlibReactorBase._reschedulec C s | � � | �� dS )zX Run timers, and then reschedule glib timeout for next scheduled event. N)r} r� r r r r r 0 s zGlibReactorBase._simulateN�F)r �T)r r r r r � _wakerFactoryr5 rL rZ r] rd rj rn rq rs ru rx rz r| r r� r� rF rM r� r r r r r r = s. ! r c @ s4 e Zd ZdZd dd�Zdd� Zddd �Zd d � Zd S )�PortableGlibReactorBasez� Base class for GObject event loop reactors that works on Windows. Sockets aren't supported by GObject's input_add on Win32. Fc s~ d � _ |� _|� _tj�� � � jj� _� jj� _ � fdd�}|r+|� _ � jj � _ d S � j� � � _� fdd�� _ � jj� _ d S )Nc r r r! r r r r r% H r& z3PortableGlibReactorBase.__init__.<locals>._mainquitc r' r r( r r r r r- Q r. z2PortableGlibReactorBase.__init__.<locals>.<lambda>)r/ r) r" r � SelectReactorr5 r6 r7 r8 r9 r> r? r@ rE r+ rF rG r r r r5 ? s z PortableGlibReactorBase.__init__c C s t j�| � | �� d S r )r r� r� r> r r r r r� T s z PortableGlibReactorBase.crashTc C s0 | j |d� | �d| j� | jr| �� d S d S )Nr� r )r� r9 �simulater� r@ r� r r r rF X s �zPortableGlibReactorBase.runc C s\ | j dur | �| j � | �� t| �� d�}|du r d}| jt|d �| j| jj d�| _ dS )z@ Run simulation loops and reschedule callbacks. Ng{�G�z�?r� rU ) r/ r7 r �minr� r9 r� r� r) rY r� r r r r� ^ s �z PortableGlibReactorBase.simulateNr� r� )r r r r r5 r� rF r� r r r r r� 8 s r� )r r �zope.interfacer �twisted.internetr r r �twisted.internet.interfacesr �twisted.pythonr r r r r4 �_PollLikeMixinr r� r� r r r r �<module> s {PK Mb�Zn��$M M 0 internet/__pycache__/gtk3reactor.cpython-310.pycnu �[��� o �b� � @ sR d Z ddlmZ ddlmZ G dd� dej�ZG dd� dej�Zdd � Z d gZ d S ) a� This module provides support for Twisted to interact with the gtk3 mainloop via Gobject introspection. This is like gi, but slightly slower and requires a working $DISPLAY. In order to use this support, simply do the following:: from twisted.internet import gtk3reactor gtk3reactor.install() If you wish to use a GApplication, register it with the reactor:: from twisted.internet import reactor reactor.registerGApplication(app) Then use twisted.internet APIs as usual. � )� gireactor)�runtimec @ � e Zd ZdZdd� ZdS )� Gtk3Reactorz/ A reactor using the gtk3+ event loop. c C � t jj| dd� dS �z: Override init to set the C{useGtk} flag. T)�useGtkN)r � GIReactor�__init__��self� r �>/usr/lib/python3/dist-packages/twisted/internet/gtk3reactor.pyr � zGtk3Reactor.__init__N��__name__� __module__� __qualname__�__doc__r r r r r r � r c @ r )�PortableGtk3Reactorz$ Portable GTK+ 3.x reactor. c C r r )r �PortableGIReactorr r r r r r + r z PortableGtk3Reactor.__init__Nr r r r r r & r r c C s4 t j�� dkr t� } nt� } ddlm} || � | S )zM Configure the Twisted mainloop to be run inside the gtk3+ mainloop. �posixr )�installReactor)r �platform�getTyper r �twisted.internet.mainr )�reactorr r r r �install2 s r N) r �twisted.internetr �twisted.pythonr r r r r r �__all__r r r r �<module> s PK Mb�Z�{�! ! . internet/__pycache__/wxreactor.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZmZ z ddlmZmZm Z W n e y) ddl mZmZm Z Y nw ddl mZ ddlmZmZ G dd� de �ZG d d � d ej�Zd d � Zd gZd S )aa This module provides wxPython event loop support for Twisted. In order to use this support, simply do the following:: | from twisted.internet import wxreactor | wxreactor.install() Then, when your root wxApp has been created:: | from twisted.internet import reactor | reactor.registerWxApp(yourApp) | reactor.run() Then use twisted.internet APIs as usual. Stop the event loop using reactor.stop(), not yourApp.ExitMainLoop(). IMPORTANT: tests will fail when run under this reactor. This is expected and probably does not reflect on the reactor's ability to run real applications. � )�Empty�Queue)� CallAfter� PySimpleApp�Timer)� wxPySimpleApp� wxCallAfter�wxTimer)�_threadedselect)�log�runtimec @ s e Zd ZdZdd� Zdd� ZdS )�ProcessEventsTimerz� Timer that tells wx to process pending events. This is necessary on macOS, probably due to a bug in wx, if we want wxCallAfters to be handled when modal dialogs, menus, etc. are open. c C s t �| � || _d S �N)r �__init__�wxapp��selfr � r �</usr/lib/python3/dist-packages/twisted/internet/wxreactor.pyr 2 s zProcessEventsTimer.__init__c C s | j �� dS )z5 Called repeatedly by wx event loop. N)r �ProcessPendingEvents�r r r r �Notify6 s zProcessEventsTimer.NotifyN)�__name__� __module__� __qualname__�__doc__r r r r r r r * s r c @ sF e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z ddd�Z dS )� WxReactorz[ wxPython reactor. wxPython drives the event loop, select() runs in a thread. Fc C s || _ dS )z; Register wxApp instance with the reactor. N)r r r r r � registerWxAppF s zWxReactor.registerWxAppc C s> zddl }|� |j|j� W n ty Y dS w | �� dS )zO wx sometimes removes our own signal handlers, so re-add them. r N)�signal�SIGINT�default_int_handler� ImportError�_handleSignals)r r r r r �_installSignalHandlersAgainL s � z%WxReactor._installSignalHandlersAgainc C s | j rdS d| _ tj�| � dS )z# Stop the reactor. NT)� _stoppingr �ThreadedSelectReactor�stopr r r r r& Y s zWxReactor.stopc C s& t | d�r t|� dS | j�|� dS )zm Schedule function to run in main wx/Twisted thread. Called by the select() thread. r N)�hasattrr � _postQueue�put)r �fr r r �_runInMainThreadb s zWxReactor._runInMainThreadc C s t | d�r | j�� dS dS )z Stop the wx event loop if it hasn't already been stopped. Called during Twisted event loop shutdown. r N)r' r � ExitMainLoopr r r r �_stopWxn s �zWxReactor._stopWxTc s t � � _t� d�st�d� � �t� � � j� j|d� |r%� � d� j � � � dd� j � � � dd� fdd�� t j�� rGt� j�}|�d � � j�� � j}� `� js�� �� |�� z � jjd d �}W n tyo Y q\w |d u rvd S z|� W n ty� t�� Y nw q]d S )z$ Start the reactor. r zMregisterWxApp() was not called on reactor, registering my own wxApp instance.)�installSignalHandlersr �after�shutdownc s � j �d �S r )r( r) r r r r �<lambda>� s z WxReactor.run.<locals>.<lambda>� � g{�G�z�?)�timeoutN)r r( r' r �msgr r � interleaver+ � callLaterr# �addSystemEventTriggerr- r �platform�isMacOSXr r �Start�MainLoopr$ r& r �getr � BaseException�err)r r. �tr r* r r r �runw sN � �� � ���z WxReactor.runN)T) r r r r r$ r r# r& r+ r- rA r r r r r = s r c C s t � } ddlm} || � | S )zP Configure the twisted mainloop to be run inside the wxPython mainloop. r )�installReactor)r �twisted.internet.mainrB )�reactorrB r r r �install� s rE N)r �queuer r �wxr r r r r r r! � wxPython.wx�twisted.internetr �twisted.pythonr r r r% r rE �__all__r r r r �<module> s � t PK Mb�Z�(X�o$ o$ * internet/__pycache__/utils.cpython-310.pycnu �[��� o �b�! � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZm Z ddl m Z d dd �Z G d d � d e �ZG d d � d e j�Zdi dddfdd�ZG dd� de j�Zdi ddfdd�ZG dd� de j�Zdi dddfdd�Zdd� Zdd� Zd d � Zg d �ZdS ) z Utility methods. � N��wraps)�BytesIO)�defer�protocol)�failure� c C sL |d u r ddl m} t�� }| |g|�R � }|�|||ft|� ||� |S )Nr )�reactor)�twisted.internetr r �Deferred� spawnProcess�tuple) r � executable�args�env�pathr � protoArgs�d�pr r �8/usr/lib/python3/dist-packages/twisted/internet/utils.py�_callProtocolWithDeferred s r c @ s e Zd ZdZdd� ZdS )�_UnexpectedErrorOutputay Standard error data was received where it was not expected. This is a subclass of L{IOError} to preserve backward compatibility with the previous error behavior of L{getProcessOutput}. @ivar processEnded: A L{Deferred} which will fire when the process which produced the data on stderr has ended (exited and all file descriptors closed). c C s t �| d|��� || _d S )Nz got stderr: )�IOError�__init__� processEnded)�self�textr r r r r * s z _UnexpectedErrorOutput.__init__N)�__name__� __module__� __qualname__�__doc__r r r r r r s r c @ s: e Zd ZdZddd�Zdd� Zdd� Zd d � Zd d � Zd S )� _BackRelaya� Trivial protocol for communicating with a process and turning its output into the result of a L{Deferred}. @ivar deferred: A L{Deferred} which will be called back with all of stdout and, if C{errortoo} is true, all of stderr as well (mixed together in one string). If C{errortoo} is false and any bytes are received over stderr, this will fire with an L{_UnexpectedErrorOutput} instance and the attribute will be set to L{None}. @ivar onProcessEnded: If C{errortoo} is false and bytes are received over stderr, this attribute will refer to a L{Deferred} which will be called back when the process ends. This C{Deferred} is also associated with the L{_UnexpectedErrorOutput} which C{deferred} fires with earlier in this case so that users can determine when the process has actually ended, in addition to knowing when bytes have been received via stderr. r c C s* || _ t� | _|r| j| _d S | j| _d S �N)�deferredr �s�errReceivedIsGood� errReceived�errReceivedIsBad)r r# �errortoor r r r B s z_BackRelay.__init__c C sJ | j d ur#t�� | _t|| j�}| j �t�|�� d | _ | j� � d S d S r" ) r# r r �onProcessEndedr �errbackr �Failure� transport�loseConnection)r r �errr r r r' J s �z_BackRelay.errReceivedIsBadc C � | j �|� d S r" �r$ �write�r r r r r r% R � z _BackRelay.errReceivedIsGoodc C r/ r" r0 r2 r r r � outReceivedU r3 z_BackRelay.outReceivedc C s> | j d ur| j �| j�� � d S | jd ur | j�|� d S d S r" )r# �callbackr$ �getvaluer) r* �r �reasonr r r r X s �z_BackRelay.processEndedN)r ) r r r r r r' r% r4 r r r r r r! / s r! c s t � fdd�| ||||�S )a� Spawn a process and return its output as a deferred returning a L{bytes}. @param executable: The file name to run and get the output of - the full path should be used. @param args: the command line arguments to pass to the process; a sequence of strings. The first string should B{NOT} be the executable's name. @param env: the environment variables to pass to the process; a dictionary of strings. @param path: the path to run the subprocess in - defaults to the current directory. @param reactor: the reactor to use - defaults to the default reactor @param errortoo: If true, include stderr in the result. If false, if stderr is received the returned L{Deferred} will errback with an L{IOError} instance with a C{processEnded} attribute. The C{processEnded} attribute refers to a L{Deferred} which fires when the executed process ends. c s t | � d�S )N�r( )r! )r r9 r r �<lambda>y s z"getProcessOutput.<locals>.<lambda>)r )r r r r r r( r r9 r �getProcessOutput_ s �r; c @ s e Zd Zdd� Zdd� ZdS )� _ValueGetterc C s || _ d S r" )r# )r r# r r r r ~ s z_ValueGetter.__init__c C s | j �|jj� d S r" )r# r5 �value�exitCoder7 r r r r � s z_ValueGetter.processEndedN)r r r r r r r r r r< } s r< c C s t t| ||||�S )z7Spawn a process and return its exit code as a Deferred.)r r< )r r r r r r r r �getProcessValue� s r? c @ s& e Zd Zddd�Zdd� Zdd� ZdS ) �_EverythingGetterNc C s4 || _ t� | _t� | _| jj| _| jj| _|| _d S r" )r# r �outBuf�errBufr1 r4 r& � stdinBytes)r r# rC r r r r � s z_EverythingGetter.__init__c C s, | j d ur| j�d| j � | j�� d S d S )Nr )rC r, � writeToChild� closeStdin)r r r r �connectionMade� s �z _EverythingGetter.connectionMadec C sT | j �� }| j�� }|j}|j}|jr | j�|||jf� d S | j�|||f� d S r" ) rA r6 rB r= r> �signalr# r* r5 )r r8 �outr. �e�coder r r r � s z _EverythingGetter.processEndedr" )r r r r rF r r r r r r@ � s r@ c C s t t| |||||fd�S )a. Spawn a process and returns a Deferred that will be called back with its output (from stdout and stderr) and it's exit code as (out, err, code) If a signal is raised, the Deferred will errback with the stdout and stderr up to that point, along with the signal, as (out, err, signalNum) )r )r r@ )r r r r r rC r r r �getProcessOutputAndValue� s �rK c C s0 |D ]}zt j�|� W q ty Y qw | S r" )�warnings�filters�remove� ValueError)� passthrough� addedFilters�fr r r �_resetWarningFilters� s �rS c O s� | D ] \}}t j|i |�� qt jdt| �� }z ||i |��}W n ty: t�� }td|� |d �|d ��w t |t j �rI|� t|� |S td|� |S )a} Run the function I{f}, but with some warnings suppressed. This calls L{warnings.filterwarnings} to add warning filters before invoking I{f}. If I{f} returns a L{Deferred} then the added filters are removed once the deferred fires. Otherwise they are removed immediately. Note that the list of warning filters is a process-wide resource, so calling this function will affect all threads. @param suppressedWarnings: A list of arguments to pass to L{warnings.filterwarnings}, a sequence of (args, kwargs) 2-tuples. @param f: A callable, which may return a L{Deferred}. @param a: Positional arguments passed to I{f} @param kw: Keyword arguments passed to I{f} @return: The result of C{f(*a, **kw)} @seealso: L{twisted.python.util.runWithWarningsSuppressed} functions similarly, but doesn't handled L{Deferred}s. N� � ) rL �filterwarningsrM �len� BaseException�sys�exc_inforS �with_traceback� isinstancer r �addBoth) �suppressedWarningsrR �a�kwr �kwargsrQ �resultrZ r r r �runWithWarningsSuppressed� s � �rc c s t � �� �fdd��}|S )z� Wrap C{f} in a callable which suppresses the indicated warnings before invoking C{f} and unsuppresses them afterwards. If f returns a Deferred, warnings will remain suppressed until the Deferred fires. c s t �� g| �R i |��S r" )rc )r_ r` �rR r^ r r �warningSuppressingWrapper� s z3suppressWarnings.<locals>.warningSuppressingWrapperr )rR r^ re r rd r �suppressWarnings� s rf )rc rf r; r? rK )Nr )r rY rL � functoolsr �ior r r r �twisted.pythonr r r r �ProcessProtocolr! r; r< r? r@ rK rS rc rf �__all__r r r r �<module> s* � 0 � + PK Mb�Zi呹� � . internet/__pycache__/wxsupport.cpython-310.pycnu �[��� o �b � @ sB d Z ddlZe�d� ddlmZ G dd� d�Zdd� ZdgZdS ) a� Old method of wxPython support for Twisted. twisted.internet.wxreactor is probably a better choice. To use:: | # given a wxApp instance called myWxAppInstance: | from twisted.internet import wxsupport | wxsupport.install(myWxAppInstance) Use Twisted's APIs for running and stopping the event loop, don't use wxPython's methods. On Windows the Twisted event loop might block when dialogs are open or menus are selected. Maintainer: Itamar Shtull-Trauring � NzBwxsupport is not fully functional on Windows, wxreactor is better.)�reactorc @ s e Zd ZdZdd� Zdd� ZdS )�wxRunnerz!Make sure GUI events are handled.c C s || _ d S )N)�app)�selfr � r �</usr/lib/python3/dist-packages/twisted/internet/wxsupport.py�__init__" s zwxRunner.__init__c C s: | j �� r| j �� | j �� s| j �� t�d| j� dS )z^ Execute pending WX events followed by WX idle events and reschedule. �{�G�z�?N)r �Pending�Dispatch� ProcessIdler � callLater�run)r r r r r % s � z wxRunner.runN)�__name__� __module__� __qualname__�__doc__r r r r r r r s r c C s t | �}t�d|j� dS )z4Install the wxPython support, given a wxApp instancer N)r r r r )r �runnerr r r �install3 s r )r �warnings�warn�twisted.internetr r r �__all__r r r r �<module> s PK Mb�Z��E�� � 0 internet/__pycache__/pyuisupport.cpython-310.pycnu �[��� o �bK � @ s0 d Z ddlZdd� Zdddi fdd�ZdgZdS ) z� This module integrates PyUI with twisted.internet's mainloop. Maintainer: Jp Calderone See doc/examples/pyuidemo.py for example usage. � Nc C s< t �� t �� dkrt �� | �� d S | �|t| |� d S )Nr )�pyui�draw�update�quit�stop� callLater� _guiUpdate)�reactor�delay� r �>/usr/lib/python3/dist-packages/twisted/internet/pyuisupport.pyr s r � r c C s6 t j|i |��}|du rddlm} t|| d � |S )z� Schedule PyUI's display to be updated approximately every C{ms} milliseconds, and initialize PyUI with the specified arguments. Nr )r g @�@)r �init�twisted.internetr r )�msr �args�kw�dr r r �install s r )�__doc__r r r �__all__r r r r �<module> s PK Mb�Z�n= �� ) internet/__pycache__/base.cpython-310.pycnu �[��� o �b � � @ s U d Z ddlZddlZddlZddlmZmZ ddlmZm Z m Z ddl m Z ddl mZ ddlmZmZmZmZmZmZmZmZmZmZmZmZ ddl m Z m Z dd l m Z m!Z!m"Z"m#Z#m$Z$m%Z% dd l&m'Z(m)Z*m+Z, dd l-m.Z.m/Z/ dd l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z> dd l?m@Z@ ddlAmBZBmCZC ddlDmEZE ddlFmGZGmHZI er�ddlJmKZK ddlAmLZL eG�M� r�ddlNmOZO ndZOe e3�G dd� d��ZPe e<�G dd� d��ZQe e<�G dd� d��ZRedef ZSeeSeeTdf eeUeTf f ZVedeeUeSeeTdf eeUeTf f �ZWG d d � d �ZXe e7e8�G d d � d ��ZYed eeUeWf �ZZeedef eeTdf eeUeTf f Z[e e6e:e>�G d!d"� d"eY��Z\eG�M� �rZe e\e9� e e2�G d#d$� d$e��Z]G d%d&� d&e j^�Z_G d'd(� d(�Z`g ZaeeU ebd)< dS )*z8 Very basic functionality for a Reactor implementation. � N)�ABC�abstractmethod)�heapify�heappop�heappush)� format_stack)� FrameType) � TYPE_CHECKING�Any�Callable�Dict�List�NewType�Optional�Sequence�Set�Tuple�Union�cast)�classImplements� implementer)�abstract�defer�error�fdesc�main�threads)�ComplexResolverSimplifier� GAIResolver�SimpleResolverComplexifier)�Deferred� DeferredList)�IAddress� IConnector� IDelayedCall�IHostnameResolver� IProtocol� IReactorCore� IReactorPluggableNameResolver�IReactorPluggableResolver�IReactorThreads� IReactorTime�IReadDescriptor�IResolverSimple�IWriteDescriptor� _ISupportsExitSignalCapturing)� ClientFactory)�log�reflect)�Failure)�platform�seconds)�Client)� threadable)� ThreadPoolc @ s e Zd ZU dZdZee ed< efde de de f de e deee f d e d gdf d e d gdf d e g e f d dfd d�Zd e fdd�Zd$dd�Zde d dfdd�Zde d dfdd�Zd$dd�Zd efdd �Zd e d efd d �Zd e d efd d!�Zd efd"d#�ZdS )%� DelayedCallFN�_repr�time�func.�args�kw�cancel�resetr5 �returnc C s^ ||||f\| _ | _| _| _|| _|| _|| _d | _| _d| _ | j r-t � dd� | _ dS dS )aR @param time: Seconds from the epoch at which to call C{func}. @param func: The callable to call. @param args: The positional arguments to pass to the callable. @param kw: The keyword arguments to pass to the callable. @param cancel: A callable which will be called with this DelayedCall before cancellation. @param reset: A callable which will be called with this DelayedCall after changing this DelayedCall's scheduled execution time. The callable should adjust any necessary scheduling details to ensure this DelayedCall is invoked at the new appropriate time. @param seconds: If provided, a no-argument callable which will be used to determine the current time any time that information is needed. r � N���) r; r< r= r> �resetter� cancellerr5 � cancelled�called� delayed_time�debugr �creator)�selfr; r< r= r> r? r@ r5 � rL �7/usr/lib/python3/dist-packages/twisted/internet/base.py�__init__S s �zDelayedCall.__init__c C s | j | j S )z� Return the time at which this call will fire @return: The number of seconds after the epoch at which this call is scheduled to be made. �r; rH �rK rL rL rM �getTimev s zDelayedCall.getTimec C sH | j rtj�| jr tj�| �| � d| _ | jr t| �| _| ` | ` | ` dS )z� Unschedule this call @raise AlreadyCancelled: Raised if this call has already been unscheduled. @raise AlreadyCalled: Raised if this call has already been made. � N) rF r �AlreadyCancelledrG � AlreadyCalledrE rI �reprr: r< r= r> rP rL rL rM r? s zDelayedCall.cancel�secondsFromNowc C sX | j rtj�| jr tj�| �� | }|| jk r$d| _|| _| �| � dS || j | _dS )aY Reschedule this call for a different time @param secondsFromNow: The number of seconds from the time of the C{reset} call at which this call will be scheduled. @raise AlreadyCancelled: Raised if this call has been cancelled. @raise AlreadyCalled: Raised if this call has already been made. rB N) rF r rS rG rT r5 r; rH rD )rK rV �newTimerL rL rM r@ � s zDelayedCall.reset� secondsLaterc C sJ | j rtj�| jr tj�| j|7 _| jdk r#| �� | �| � dS dS )aQ Reschedule this call for a later time @param secondsLater: The number of seconds after the originally scheduled time for which to reschedule this call. @raise AlreadyCancelled: Raised if this call has been cancelled. @raise AlreadyCalled: Raised if this call has already been made. rB N)rF r rS rG rT rH �activate_delayrD )rK rX rL rL rM �delay� s �zDelayedCall.delayc C s | j | j7 _ d| _d S )NrB rO rP rL rL rM rY � s zDelayedCall.activate_delayc C s | j p| j S )z�Determine whether this call is still pending @return: True if this call has not yet been made or cancelled, False otherwise. )rF rG rP rL rL rM �active� s zDelayedCall.active�otherc C s t |t�r | j|jkS tS )z� Implement C{<=} operator between two L{DelayedCall} instances. Comparison is based on the C{time} attribute (unadjusted by the delayed time). �� isinstancer9 r; �NotImplemented�rK r\ rL rL rM �__le__� � zDelayedCall.__le__c C s t |t�r | j|jk S tS )z� Implement C{<} operator between two L{DelayedCall} instances. Comparison is based on the C{time} attribute (unadjusted by the delayed time). r] r` rL rL rM �__lt__� rb zDelayedCall.__lt__c C sV | j dur| j S t| d�r@t| jdd�}|du r5t| jdd�}|dur5t| jdd�}|dur5|� d|� �}|du r?t�| j�}nd}| �� }dt| �| j| | j | j f g}|dur�|� d|d f� | j r{|� d �d d � | j D ��� | jr{|� d � | jr�|� d �d d � | j�� D ��� |� d� | jr�|� dd�| j� � |� d� d�|�S )z� Implement C{repr()} for L{DelayedCall} instances. @returns: String containing details of the L{DelayedCall}. Nr< � __qualname__�__name__�im_class�.z.<DelayedCall 0x%x [%ss] called=%s cancelled=%s� �(z, c S s g | ]}t �|��qS rL �r2 � safe_repr)�.0�erL rL rM � <listcomp> s z(DelayedCall.__repr__.<locals>.<listcomp>c S s$ g | ]\}}|� d t �|�� ��qS )�=rj )rl �k�vrL rL rM rn s $ �)z traceback at creation: %sz �>� )r: �hasattr�getattrr< r2 rk r5 �idr; rG rF �extendr= �append�joinr> �itemsrI rJ )rK r< �imClass�now�LrL rL rM �__repr__� sH ��� �� zDelayedCall.__repr__�rA N)re � __module__rd rI r: r �str�__annotations__�runtimeSeconds�floatr r r �objectr rN rQ r? r@ rZ rY �boolr[ ra rc r rL rL rL rM r9 K s< �� �� � � � � �# r9 c @ s� e Zd ZdZddd�Zded edefd d �Zded ee ddfd d�Z deded ee ddfdd�Z ddede e dee fdd�Z dS )�ThreadedResolvera� L{ThreadedResolver} uses a reactor, a threadpool, and L{socket.gethostbyname} to perform name lookups without blocking the reactor thread. It also supports timeouts indepedently from whatever timeout logic L{socket.gethostbyname} might have. @ivar reactor: The reactor the threadpool of which will be used to call L{socket.gethostbyname} and the I/O thread of which the result will be delivered. �reactor� ReactorBaserA Nc C s || _ i | _d S �N)r� �_runningQueries)rK r� rL rL rM rN s �zThreadedResolver.__init__�name�errc C s t �d|�d|� ��}t|�S )N�address z not found: )r �DNSLookupErrorr3 )rK r� r� � lookupErrorrL rL rM �_fail& s zThreadedResolver._fail�lookupDeferredc C s, | j | \}}| j |= |�| �|d�� d S )Nz timeout error)r� �errbackr� )rK r� r� � userDeferred� cancelCallrL rL rM �_cleanup* s zThreadedResolver._cleanup�resultc C sj z | j | \}}W n ty Y d S w | j |= |�� t|t�r.|�| �||�� �� d S |�|� d S r� ) r� �KeyErrorr? r^ r3 r� r� �getErrorMessage�callback)rK r� r� r� r� r� rL rL rM � _checkTimeout/ s � z ThreadedResolver._checkTimeout�rR � � �- �timeoutc C st |rt |�}nd}t� }t�| jtt| j��� tj |�}tt | j�� || j ||�}||f| j |< |�| j||� |S )a1 See L{twisted.internet.interfaces.IResolverSimple.getHostByName}. Note that the elements of C{timeout} are summed and the result is used as a timeout for the lookup. Any intermediate timeout or retry logic is left up to the platform via L{socket.gethostbyname}. �< )�sumr r �deferToThreadPoolr� r r* � getThreadPool�socket� gethostbynamer+ � callLaterr� r� �addBothr� )rK r� r� � timeoutDelayr� r� r� rL rL rM � getHostByName? s � �z ThreadedResolver.getHostByName)r� r� rA N�r� )re r� rd �__doc__rN r� r3 r� r r� r� r �intr� rL rL rL rM r� s, ��� �����r� c @ s. e Zd Z ddedee dee fdd�ZdS ) �BlockingResolverr� r� r� rA c C sL zt �|�}W n ty d|�d�}t�|�}t�|� Y S w t�|�S )Nr� z not found)r� r� �OSErrorr r� r �fail�succeed)rK r� r� �address�msgr� rL rL rM r� ^ s � z BlockingResolver.getHostByNameNr� )re r� rd r� r r� r r� rL rL rL rM r� \ s ����r� .� _ThreePhaseEventTriggerHandlec @ s� e Zd ZdZddd�Zdededed edef d d �Z d eddfd d�Z d eddfdd�Z d eddfdd�Z ddd�Z deddfdd�ZdS )�_ThreePhaseEventa� Collection of callables (with arguments) which can be invoked as a group in a particular order. This provides the underlying implementation for the reactor's system event triggers. An instance of this class tracks triggers for all phases of a single type of event. @ivar before: A list of the before-phase triggers containing three-tuples of a callable, a tuple of positional arguments, and a dict of keyword arguments @ivar finishedBefore: A list of the before-phase triggers which have already been executed. This is only populated in the C{'BEFORE'} state. @ivar during: A list of the during-phase triggers containing three-tuples of a callable, a tuple of positional arguments, and a dict of keyword arguments @ivar after: A list of the after-phase triggers containing three-tuples of a callable, a tuple of positional arguments, and a dict of keyword arguments @ivar state: A string indicating what is currently going on with this object. One of C{'BASE'} (for when nothing in particular is happening; this is the initial value), C{'BEFORE'} (when the before-phase triggers are in the process of being executed). rA Nc C s g | _ g | _g | _d| _d S )N�BASE)�before�during�after�staterP rL rL rM rN � s z_ThreePhaseEvent.__init__�phase�callabler= �kwargsc O s6 |dvrt d��t| |��|||f� t||||f�S )a� Add a trigger to the indicate phase. @param phase: One of C{'before'}, C{'during'}, or C{'after'}. @param callable: An object to be called when this event is triggered. @param args: Positional arguments to pass to C{callable}. @param kwargs: Keyword arguments to pass to C{callable}. @return: An opaque handle which may be passed to L{removeTrigger} to reverse the effects of calling this method. �r� r� r� � invalid phase)r� rv ry r� )rK r� r� r= r� rL rL rM � addTrigger� s z_ThreePhaseEvent.addTrigger�handlec C s t | d| j �|� dS )aS Remove a previously added trigger callable. @param handle: An object previously returned by L{addTrigger}. The trigger added by that call will be removed. @raise ValueError: If the trigger associated with C{handle} has already been removed or if C{handle} is not a valid handle. �removeTrigger_N)rv r� )rK r� rL rL rM � removeTrigger� s z _ThreePhaseEvent.removeTriggerc C sV z|\}}}}W n t tfy td��w |dvr td��t| |��|||f� dS )zN Just try to remove the trigger. @see: removeTrigger zinvalid trigger handler� r� N)� TypeError� ValueErrorr� rv �remove�rK r� r� r� r= r� rL rL rM �removeTrigger_BASE� s �z#_ThreePhaseEvent.removeTrigger_BASEc C sP |\}}}}|dkr| � |�S |||f| jv r!tjdtdd� dS | � |� dS )z� Remove the trigger if it has yet to be executed, otherwise emit a warning that in the future an exception will be raised when removing an already-executed trigger. @see: removeTrigger r� zdRemoving already-fired system event triggers will raise an exception in a future version of Twisted.r� )�category� stacklevelN)r� �finishedBefore�warnings�warn�DeprecationWarningr� rL rL rM �removeTrigger_BEFORE� s �z%_ThreePhaseEvent.removeTrigger_BEFOREc C s� d| _ g | _g }| jrA| j�d�\}}}| j�|||f� z ||i |��}W n ty3 t�� Y n w t|t �r>|�|� | js t |�� | j � dS )z8 Call the triggers added to this event. �BEFOREr N) r� r� r� �popry � BaseExceptionr1 r� r^ r r! � addCallback�_continueFiring)rK � beforeResultsr� r= r� r� rL rL rM � fireEvent� s � � z_ThreePhaseEvent.fireEvent�ignoredc C sh d| _ g | _| j| jfD ]%}|r1|�d�\}}}z ||i |�� W n ty. t�� Y nw |sq dS )zJ Call the during and after phase triggers for this event. r� r N)r� r� r� r� r� r� r1 r� )rK r� r� r� r= r� rL rL rM r� � s ����z _ThreePhaseEvent._continueFiringr� )re r� rd r� rN r� � _ThreePhaseEventTriggerCallabler� r� r� r� r� r� r� r� rL rL rL rM r� u s& ���� � r� c @ sf e Zd ZU dZe� Zeed< ee�Z e ed< dedefdd�Z de de fdd�Z e de fd d ��Zd S ) �PluggableResolverMixinz� A mixin which implements the pluggable resolver reactor interfaces. @ivar resolver: The installed L{IResolverSimple}. @ivar _nameResolver: The installed L{IHostnameResolver}. �resolver� _nameResolverrA c C s( t �|�sJ �| j}|| _t|�| _|S )z� See L{IReactorPluggableResolver}. @param resolver: see L{IReactorPluggableResolver}. @return: see L{IReactorPluggableResolver}. )r- � providedByr� �_SimpleResolverComplexifierr� )rK r� � oldResolverrL rL rM �installResolver s z&PluggableResolverMixin.installResolverc C s | j }|| _ t|�| _|S )z� See L{IReactorPluggableNameResolver}. @param resolver: See L{IReactorPluggableNameResolver}. @return: see L{IReactorPluggableNameResolver}. )r� �_ComplexResolverSimplifierr� )rK r� �previousNameResolverrL rL rM �installNameResolver s z*PluggableResolverMixin.installNameResolverc C s | j S )zd Implementation of read-only L{IReactorPluggableNameResolver.nameResolver}. )r� rP rL rL rM � nameResolver, s z#PluggableResolverMixin.nameResolverN)re r� rd r� r� r� r- r� r� r� r% r� r� �propertyr� rL rL rL rM r� s r� �_SystemEventIDc s� e Zd ZdZdZdZdZdZdZdZ do� fdd� Z dZ dod d �Z dod d �Z d e e ddfdd�Zdeddfdd�Zdeddfdd�Zdeddfdd�Zdeddfdd�Zdeeeef fdd�Zdee fd d �Zdee fd d �Z dpd!ed"e e de e fd#d$�Z dod%d&�Z dod'd(�Z!dqd)e d*e e" ddfd+d,�Z#dqd)e d*e e" ddfd-d.�Z$dqd)e d*e e" ddfd/d0�Z%dod1d2�Z&drd eddfd4d5�Z'd6eddfd7d8�Z(d9ed6ed:e)d;e*f d<e+d=e+de,f d>d?�Z-d@e,ddfdAdB�Z.d:e)d;e*f d<e+d=e+de e, fdCdD�Z/dodEdF�Z0dodGdH�Z1dodIdJ�Z2e3e4�Z5d ed:e)d;e*f d<e+dKe+de6f dLdM�Z7dNe6ddfdOdP�Z8dNe6ddfdQdR�Z9de e: fdSdT�Z;dodUdV�Z<de e fdWdX�Z=dodYdZ�Z>e?�@� �r�eAdu�saJ �dZBdZCdZDdod[d\�ZEd]e)d;e*f d<e+d=e+ddfd^d_�ZFdod`da�ZGdodbdc�ZHdoddde�ZIdeAfdfdg�ZJdhe)d;e*f d<e+d=e+ddfdidj�ZKdke ddfdldm�ZL� ZMS d]e)d;e*f d<e+d=e+ddfdnd_�ZF� ZMS )sr� a� Default base class for Reactors. @ivar _stopped: A flag which is true between paired calls to C{reactor.run} and C{reactor.stop}. This should be replaced with an explicit state machine. @ivar _justStopped: A flag which is true between the time C{reactor.stop} is called and the time the shutdown system event is fired. This is used to determine whether that event should be fired after each iteration through the mainloop. This should be replaced with an explicit state machine. @ivar _started: A flag which is true from the time C{reactor.run} is called until the time C{reactor.run} returns. This is used to prevent calls to C{reactor.run} on a running reactor. This should be replaced with an explicit state machine. @ivar running: See L{IReactorCore.running} @ivar _registerAsIOThread: A flag controlling whether the reactor will register the thread it is running in as the I/O thread when it starts. If C{True}, registration will be done, otherwise it will not be. @ivar _exitSignal: See L{_ISupportsExitSignalCapturing._exitSignal} TFN�twisted.internet.reactorrA c s� t � �� g | _i | _g | _g | _d| _d| _d| _d| _ d| _ t � | _ d | _ | �dd| j� | �dd| j� | �dd| j� t�� rG| �� | �� d S )Nr Fr� �startup�shutdown)�superrN �threadCallQueue�_eventTriggers�_pendingTimedCalls�_newTimedCalls�_cancellations�running�_started� _justStopped�_startedBefore�set�_internalReaders�waker�addSystemEventTrigger�_reallyStartRunning�crash� disconnectAllr4 �supportsThreads� _initThreads� installWakerrP �� __class__rL rM rN Z s$ zReactorBase.__init__c C � t t�| j�d ��)Nz did not implement installWaker��NotImplementedErrorr2 �qualr� rP rL rL rM r� y � �zReactorBase.installWakerc C s | j r | j �� dS dS )z) Wake up the event loop. N)r� �wakeUprP rL rL rM r ~ s �zReactorBase.wakeUprZ c C r )zV Do one iteration over the readers and writers which have been added. z did not implement doIterationr �rK rZ rL rL rM � doIteration� s �zReactorBase.doIteration�readerc C r )Nz did not implement addReaderr �rK r rL rL rM � addReader� r zReactorBase.addReader�writerc C r )Nz did not implement addWriterr �rK r rL rL rM � addWriter� r zReactorBase.addWriterc C r )Nz did not implement removeReaderr r rL rL rM � removeReader� r zReactorBase.removeReaderc C r )Nz did not implement removeWriterr r rL rL rM � removeWriter� r zReactorBase.removeWriterc C r )Nz did not implement removeAllr rP rL rL rM � removeAll� r zReactorBase.removeAllc C r )Nz did not implement getReadersr rP rL rL rM � getReaders� r zReactorBase.getReadersc C r )Nz did not implement getWritersr rP rL rL rM � getWriters� r zReactorBase.getWritersr� r� r� c C s0 |st �d�S t�|�rt �|�S | j�||�S )z8 Return a Deferred that will resolve a hostname.z0.0.0.0)r r� r � isIPAddressr� r� )rK r� r� rL rL rM �resolve� s zReactorBase.resolvec C s& | j rt�d��d| _ d| _d| _dS )zD See twisted.internet.interfaces.IReactorCore.stop. z&Can't stop reactor that isn't running.TN)�_stoppedr �ReactorNotRunningr� r� rP rL rL rM �stop� s zReactorBase.stopc C s d| _ d| _| �dd| j� dS )z� See twisted.internet.interfaces.IReactorCore.crash. Reset reactor state tracking attributes and re-initialize certain state-transition helpers which were set up in C{__init__} but later destroyed (through use). Fr� r� N)r� r� r� r� rP rL rL rM r� � s zReactorBase.crash�number�framec C � t �d� | �| j� || _dS )z� Handle a SIGINT interrupt. @param number: See handler specification in L{signal.signal} @param frame: See handler specification in L{signal.signal} z Received SIGINT, shutting down.N�r1 r� �callFromThreadr � _exitSignal�rK r r rL rL rM �sigInt� � zReactorBase.sigIntc C r )z� Handle a SIGBREAK interrupt. @param number: See handler specification in L{signal.signal} @param frame: See handler specification in L{signal.signal} z!Received SIGBREAK, shutting down.Nr r rL rL rM �sigBreak� r zReactorBase.sigBreakc C r )z� Handle a SIGTERM interrupt. @param number: See handler specification in L{signal.signal} @param frame: See handler specification in L{signal.signal} z Received SIGTERM, shutting down.Nr r rL rL rM �sigTerm� r zReactorBase.sigTermc C s, | � � }|D ] }t�||jttj�� qdS )z2Disconnect every reader, and writer in the system.N)r r1 �callWithLogger�connectionLostr3 r �CONNECTION_LOST)rK � selectablesr rL rL rM r� � s ��zReactorBase.disconnectAllrB c C s | � � | �|� dS )zG See twisted.internet.interfaces.IReactorCore.iterate. N)�runUntilCurrentr r rL rL rM �iterate� s zReactorBase.iterate� eventTypec C s$ | j �|�}|dur|�� dS dS )zO See twisted.internet.interfaces.IReactorCore.fireSystemEvent. N)r� �getr� )rK r) �eventrL rL rM �fireSystemEvent s �zReactorBase.fireSystemEventr� r� .r= r� c O sV t �|�s J |� d���|| jvrt� | j|< t|| j| j||g|�R i |��f�S )zU See twisted.internet.interfaces.IReactorCore.addSystemEventTrigger. � is not callable)�builtinsr� r� r� r� r� )rK r� r) r� r= r� rL rL rM r� s �����z!ReactorBase.addSystemEventTrigger� triggerIDc C s |\}}| j | �|� dS )zX See twisted.internet.interfaces.IReactorCore.removeSystemEventTrigger. N)r� r� )rK r/ r) r� rL rL rM �removeSystemEventTrigger$ s z$ReactorBase.removeSystemEventTriggerc O s4 | j r ||i |�� dS | jdd|g|�R i |��S )zO See twisted.internet.interfaces.IReactorCore.callWhenRunning. Nr� r� )r� r� )rK r� r= r� rL rL rM �callWhenRunning+ s ���zReactorBase.callWhenRunningc C sD | j rt�� �| jrt�� �d| _ d| _| jrt�� | � d� dS )a� Method called when reactor starts: do some initialization and fire startup events. Don't call this directly, call reactor.run() instead: it should take care of calling this. This method is somewhat misnamed. The reactor will not necessarily be in the running state by the time this method returns. The only guarantee is that it will be on its way to the running state. TFr� N) r� r �ReactorAlreadyRunningr� �ReactorNotRestartabler �_registerAsIOThreadr7 �registerAsIOThreadr, rP rL rL rM � startRunning9 s zReactorBase.startRunningc C s d| _ dS )z� Method called to transition to the running state. This should happen in the I{during startup} event trigger phase. TN)r� rP rL rL rM r� O s z ReactorBase._reallyStartRunningc C s t � �r� )r rP rL rL rM �runV s zReactorBase.runr> c O sb t �|�s J |� d���|dksJ |� d���t| �� | |||| j| j| jd�}| j�|� |S )zI See twisted.internet.interfaces.IReactorTime.callLater. r- r z* is not greater than or equal to 0 seconds)r5 )r. r� r9 r5 �_cancelCallLater�_moveCallLaterSoonerr� ry )rK rZ r� r= r> � delayedCallrL rL rM r� ^ s � zReactorBase.callLaterr: c C sv | j }z-|�|�}|| }|dkr*|d d }|| |kr n || ||< |}|dks|||< W d S ty: Y d S w )Nr rR � )r� �indexr� )rK r: �heap�pos�elt�parentrL rL rM r9 r s � �z ReactorBase._moveCallLaterSoonerc C s | j d7 _ d S �NrR )r� )rK r: rL rL rM r8 � s z ReactorBase._cancelCallLaterc C s dd� | j | j D �S )zQ See L{twisted.internet.interfaces.IReactorTime.getDelayedCalls} c S � g | ]}|j s|�qS rL �rF �rl �xrL rL rM rn � s ��z/ReactorBase.getDelayedCalls.<locals>.<listcomp>)r� r� rP rL rL rM �getDelayedCalls� s �zReactorBase.getDelayedCallsc C s@ | j D ]}|jr| jd8 _q|�� t| j|� qg | _ d S rA )r� rF r� rY r r� )rK �callrL rL rM �_insertNewDelayedCalls� s z"ReactorBase._insertNewDelayedCallsc C s: | � � | js dS | jd j| �� }d}tdt||��S )z� Determine the longest time the reactor may sleep (waiting on I/O notification, perhaps) before it must wake up to service a time-related event. @return: The maximum number of seconds the reactor may sleep. Nr i�� )rH r� r; r5 �max�min)rK rZ �longestrL rL rM r� � s zReactorBase.timeoutc C s� | j rAd}t| j �}| j D ]&\}}}z ||i |�� W n ty( t�� Y nw |d7 }||kr3 nq | j d|�= | j rA| �� | �� | �� }| jr�| jd j |kr�t | j�}|j rd| j d8 _ qI|j dkrt|�� t| j|� qIzd|_|j|ji |j�� W n3 ty� t�� t|d�r�d}|d7 }|d7 }|d �|j��� �dd �7 }|d7 }t�|� Y nw | jr�| jd j |ksT| j d kr�| j t| j�d? kr�d| _ d d � | jD �| _t| j� | j r�d| _ | � d� dS dS )z. Run all pending timed calls. r rR NrB rJ � z? C: previous exception occurred in a DelayedCall created here: z C:rt z C:�2 c S rB rL rC rD rL rL rM rn � s ��z/ReactorBase.runUntilCurrent.<locals>.<listcomp>Fr� ) r� �lenr� r1 r� r rH r5 r� r; r rF r� rH rY r rG r< r= r> �deferrru rz rJ �rstrip�replacer� r r� r, ) rK �count�total�f�ar> r} rG rm rL rL rM r' � sn �� � ��� � �zReactorBase.runUntilCurrentc C s | � t| | j�� d| _d S )NT)r� � _GAIResolverr� � usingThreadsrP rL rL rM r� s zReactorBase._initThreadsrT c O s4 t |�s J |� d���| j�|||f� | �� dS )zl See L{twisted.internet.interfaces.IReactorFromThreads.callFromThread}. r- N)r� r� ry r �rK rT r= r� rL rL rM r s zReactorBase.callFromThreadc C s4 t ddd�| _| �| jj�| _| �dd| j�| _dS )zO Create the threadpool accessible with callFromThread. r � r� r� r� N)r8 � threadpoolr1 �start�_threadpoolStartupIDr� �_stopThreadPool�threadpoolShutdownIDrP rL rL rM �_initThreadPool s �zReactorBase._initThreadPoolc C � d S r� rL rP rL rL rM �_uninstallHandler$ s z ReactorBase._uninstallHandlerc C sj | j | jg}td|�D ]}z| �|� W q ty Y q w d| _ d| _| jdus+J �| j�� d| _dS )a4 Stop the reactor threadpool. This method is only valid if there is currently a threadpool (created by L{_initThreadPool}). It is not intended to be called directly; instead, it will be called by a shutdown trigger created in L{_initThreadPool}. N)r\ r^ �filterr0 r� rZ r )rK �triggers�triggerrL rL rM r] ' s � zReactorBase._stopThreadPoolc C s& | j du r| �� | j dusJ �| j S )z[ See L{twisted.internet.interfaces.IReactorThreads.getThreadPool}. N)rZ r_ rP rL rL rM r� : s zReactorBase.getThreadPool� _callablec O s | � � j|g|�R i |�� dS )z\ See L{twisted.internet.interfaces.IReactorInThreads.callInThread}. N)r� � callInThread)rK re r= r� rL rL rM rf F s zReactorBase.callInThread�sizec C s | � � j|d� dS )zc See L{twisted.internet.interfaces.IReactorThreads.suggestThreadPoolSize}. )� maxthreadsN)r� �adjustPoolsize)rK rg rL rL rM �suggestThreadPoolSizeN s z!ReactorBase.suggestThreadPoolSizec O s, t |�s J |� d���| j�|||f� d S )Nr- )r� r� ry rX rL rL rM r V s r� r� r� )rB )Nre r� rd r� r4 r � installedrW r rN �_lockr� r r r� r r, r r. r r r r r r r r r� r r� r r r r� r r r! r" r� r( r, r r r� r� r� r0 r1 r6 r� r7 � staticmethodr� r5 r9 r� r9 r8 r$ rF rH r� r' r4 r� r8 rZ r\ r^ r� r r_ ra r] r� rf rj � __classcell__rL rL r� rM r� 9 s� ��� � �� ��� � ��� � � ��� � D ��� � ��� � ����r� c @ s� e Zd ZdZdZdZdedededdfdd �Z d!d d �Z e d"d d��Z d!dd�Z d!dd�Zd!dd�Zdedee fdd�Zdeddfdd�Zdeddfdd �Zdefd d �Zdefd d �ZdS )#� BaseConnectorzm Basic implementation of L{IConnector}. State can be: "connecting", "connected", "disconnected" Nr �factoryr� r� rA c C s d| _ || _|| _|| _d S )N� disconnected)r� r� rp r� )rK rp r� r� rL rL rM rN m s zBaseConnector.__init__c C s@ | j dkr | �� dS | j dkr | jdusJ �| j�� dS dS )z!Disconnect whatever our state is.� connecting� connectedN)r� �stopConnecting� transport�loseConnectionrP rL rL rM � disconnectu s �zBaseConnector.disconnectr6 c C r` r� rL rP rL rL rM �_makeTransport} s z BaseConnector._makeTransportc C sn | j dkr td��d| _ | js| j�� d| _| �� | _| jdur/| j� | j| jj t � � �| _ | j�| � dS )z"Start connection to remote server.rq zcan't connect in this staterr rR N)r� � RuntimeError�factoryStartedrp �doStartrx ru r� r� r� �failIfNotConnectedr � TimeoutError� timeoutID�startedConnectingrP rL rL rM �connect� s �zBaseConnector.connectc C s@ | j dkr t�d��| jdusJ �d| _ | j�t�� � | `dS )zStop attempting to connect.rr zwe're not trying to connectNrq )r� r �NotConnectingErrorru r| � UserErrorrP rL rL rM rt � s z BaseConnector.stopConnectingc C s8 | j d urz| j �� W n ty Y nw | ` d S d S r� )r~ r? r� rP rL rL rM � cancelTimeout� s ��zBaseConnector.cancelTimeout�addrc C s d| _ | �� | j�|�S )Nrs )r� r� rp � buildProtocol)rK r� rL rL rM r� � s zBaseConnector.buildProtocol�reasonc C sD | � � d | _d| _| j�| |� | jdkr | j�� d| _d S d S �Nrq r )r� ru r� rp �clientConnectionFailed�doStoprz �rK r� rL rL rM �connectionFailed� s �z BaseConnector.connectionFailedc C s6 d| _ | j�| |� | j dkr| j�� d| _d S d S r� )r� rp �clientConnectionLostr� rz r� rL rL rM r$ � s �z BaseConnector.connectionLostc C r )Nz! did not implement getDestinationr rP rL rL rM �getDestination� r z BaseConnector.getDestinationc C s" d� t�| j�t| �| j| �� �S )Nz <{} instance at 0x{:x} {} {}>)�formatr2 r r� rw r� r� rP rL rL rM r � s �zBaseConnector.__repr__r� )rA r6 )re r� rd r� r~ rz r0 r� r� rN rw r rx r� rt r� r" r r& r� r3 r� r$ r� r� r rL rL rL rM ro b s0 ��� � ro c @ sP e Zd ZU dZdZejed< dZej ed< dejfdd�Z de e fdd �Z dS ) �BasePortziBasic implementation of a ListeningPort. Note: This does not actually implement IListeningPort. N� addressFamily� socketTyperA c C s, t � | j| j�}|�d� t�|�� � |S )NF)r� r� r� � setblockingr �_setCloseOnExec�fileno)rK �srL rL rM �createInternetSocket� s z BasePort.createInternetSocketc C s t dt�| j� ��)zRaises a RuntimeErrorzdoWrite called on a %s)ry r2 r r� rP rL rL rM �doWrite� s zBasePort.doWrite)re r� rd r� r� r� � AddressFamilyr� r� � SocketKindr� r r3 r� rL rL rL rM r� � s r� c @ sZ e Zd ZdZdZddd�Zddeddfd d �Zdd d �Zddeddfd d�Z ddd�Z dS )�_SignalReactorMixina! Private mixin to manage signals: it installs signal handlers at start time, and define run method. It can only be used mixed in with L{ReactorBase}, and has to be defined first in the inheritance (so that method resolution order finds startRunning first). @ivar _installSignalHandlers: A flag which indicates whether any signal handlers will be installed during startup. This includes handlers for SIGCHLD to monitor child processes, and SIGINT, SIGTERM, and SIGBREAK to stop the reactor. FrA Nc C s� zddl }W n ty t�d� Y dS w tt| �}|�|j�|jkr,|� |j|j � |� |j |j � t |dd�}|durG|� ||j � dS dS )zI Install the signal handlers for the Twisted event loop. r NzEWarning: signal module unavailable -- not installing signal handlers.�SIGBREAK)�signal� ImportErrorr1 r� r r� � getsignal�SIGINT�default_int_handlerr �SIGTERMr" rv r! )rK r� �reactorBaseSelfr� rL rL rM �_handleSignals� s �� �z"_SignalReactorMixin._handleSignalsT�installSignalHandlersc C s || _ t�tt| �� dS )aB Extend the base implementation in order to remember whether signal handlers should be installed later. @param installSignalHandlers: A flag which, if set, indicates that handlers for a number of (implementation-defined) signals should be installed during startup. N)�_installSignalHandlersr� r6 r �rK r� rL rL rM r6 s z _SignalReactorMixin.startRunningc C s& t �tt | �� | jr| �� dS dS )z� Extend the base implementation by also installing signal handlers, if C{self._installSignalHandlers} is true. N)r� r� r r� r� rP rL rL rM r� s �z'_SignalReactorMixin._reallyStartRunningc C s | j |d� | �� d S )N)r� )r6 �mainLoopr� rL rL rM r7 ! s z_SignalReactorMixin.runc C s� t t| �}|jr?z|jr!|�� |�� }|jo|}|�|� |js W n ty4 t� d� t� � Y nw t� d� |jsd S d S )Nz Unexpected error in main loop.zMain loop terminated.) r r� r� r' r� r� r r� r1 r� r� )rK r� �t2�trL rL rM r� % s �� � �z _SignalReactorMixin.mainLoopr� )T) re r� rd r� r� r� r� r6 r� r7 r� rL rL rL rM r� � s r� �__all__)cr� r. r� r� �abcr r �heapqr r r � tracebackr �typesr �typingr r r r r r r r r r r r �zope.interfacer r �twisted.internetr r r r r r �twisted.internet._resolverr r� r rV r r� �twisted.internet.deferr r! �twisted.internet.interfacesr" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ �twisted.internet.protocolr0 �twisted.pythonr1 r2 �twisted.python.failurer3 �twisted.python.runtimer4 r5 r� �twisted.internet.tcpr6 r7 r� �twisted.python.threadpoolr8 r9 r� r� r� r� r� �_ThreePhaseEventTriggerr� r� r� r� � _ThreadCallr� ro �FileDescriptorr� r� r� r� rL rL rL rM �<module> st 8 @ HH � � 1& ( e\PK Mb�Z܈?� � . internet/__pycache__/endpoints.cpython-310.pycnu �[��� o �b�. � @ sL d Z ddlZddlZddlZddlZddlmZ ddlmZm Z m Z ddl m Z m Z ddlmZ ddlmZmZmZmZmZ ddlmZmZ dd lmZmZm Z m Z dd l m Z m Z m!Z!m"Z"m#Z# dd l$m%Z%m&Z&m'Z'm(Z( z dd l)m*Z*m+Z+ W n e,y� dZ+dZ*Y nw dd l-m.Z. ddl/m0Z0 ddl1m2Z2 ddl3m4Z4 ddl5m6Z6m7Z7 ddl8m9Z9m:Z: ddl;m<Z<m=Z=m>Z> ddl?m@Z@ ddlAmBZB ddlCmDZD ddlEmFZF ddlGmHZHmIZI z ddlJmKZL ddlMmNZNmOZOmPZPmQZQmRZRmSZS dd lTmUZV W n e,y� dZUY nw eVZUg d �ZWG d d � d e(�ZXG d d!� d!e%�ZYe ejZ�G d"d#� d#��Z[G d$d%� d%ej\ej]ej^�Z_G d&d'� d'e@e_d(��Z`G d)d*� d*e'�ZaG d+d,� d,e �Zbe ejc�G d-d.� d.��Zde ejZ�G d/d0� d0��ZeG d1d2� d2ee�ZfG d3d4� d4ee�Zge ejc�G d5d6� d6��Zhe ejc�G d7d8� d8��Zie e �G d9d:� d:��Zje ejc�G d;d<� d<��Zke ejZ�G d=d>� d>��Zle ejc�G d?d@� d@��Zme ejZ�G dAdB� dB��Zne ejc�G dCdD� dD��Zoe ejZ�G dEdF� dF��Zpd�dIdJ�Zqd�dMdN�Zr O G H d�dPdQ�Zse e6e#�G dRdS� dS��Zte e6e#�G dTdU� dU��Zue e6e#�G dVdW� dW��ZveqeresdX�ZwexdY�\ZyZzdZd[� Z{d\d]� Z|efelend^�Z}ehemeod^�Z~d_d`� Zdadb� Z�dcdd� Z�dedf� Z�dgdh� Z�didj� Z�dkdl� Z�dmdn� Z�dodp� Z�dqdr� Z�dsdt� Z�e�e�e�d^�Z�dudv� Z�dwdx� Z�e ejc�G dydz� dz��Z�e ejZ�G d{d|� d|��Z�d}d~� Z� d�d�d��Z�e e6e"�G d�d�� d���Z�dS )�a7 Implementations of L{IStreamServerEndpoint} and L{IStreamClientEndpoint} that wrap the L{IReactorTCP}, L{IReactorSSL}, and L{IReactorUNIX} interfaces. This also implements an extensible mini-language for describing endpoints, parsed by the L{clientFromString} and L{serverFromString} functions. @since: 10.1 � N)� normalize)�directlyProvides� implementer�provider)� NamedConstant�Names)�Version)�defer�error�fdesc� interfaces�threads)� isIPAddress� isIPv6Address)�HostnameAddress� IPv4Address� IPv6Address�_ProcessAddress)�IHostnameResolver� IReactorPluggableNameResolver�IResolutionReceiver�,IStreamClientEndpointStringParserWithReactor�!IStreamServerEndpointStringParser)� ClientFactory�Factory�ProcessProtocol�Protocol)� PipeAddress� StandardIO)�HostResolution)�Deferred)� LoopingCall)�Logger)�IPlugin� getPlugins)� deprecate�log)�_matchingString� iterbytes� nativeString)�proxyForInterface)�Failure)�FilePath)� ListenFDs� )� _idnaBytes� _idnaText)�Error)� Certificate�CertificateOptions�KeyPair�PrivateCertificate�optionsForClientTLS�trustRootFromCertificates��TLSMemoryBIOFactory)�clientFromString�serverFromString�TCP4ServerEndpoint�TCP6ServerEndpoint�TCP4ClientEndpoint�TCP6ClientEndpoint�UNIXServerEndpoint�UNIXClientEndpoint�SSL4ServerEndpoint�SSL4ClientEndpoint�AdoptedStreamServerEndpoint�StandardIOEndpoint�ProcessEndpoint�HostnameEndpoint�StandardErrorBehavior�connectProtocol� wrapClientTLSc @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�_WrappingProtocolz_ Wrap another protocol in order to notify my user when a connection has been made. c C s< || _ || _tjtjtjfD ] }|�| j�rt| |� qdS )z� @param connectedDeferred: The L{Deferred} that will callback with the C{wrappedProtocol} when it is connected. @param wrappedProtocol: An L{IProtocol} provider that will be connected. N)�_connectedDeferred�_wrappedProtocolr �IHalfCloseableProtocol�IFileDescriptorReceiver�IHandshakeListener� providedByr )�self�connectedDeferred�wrappedProtocol�iface� rV �</usr/lib/python3/dist-packages/twisted/internet/endpoints.py�__init__l s � ��z_WrappingProtocol.__init__c C s" t j�| j�r | j�� S | jjjS )zO Transparently pass through the wrapped protocol's log prefix. )r �ILoggingContextrQ rM � logPrefix� __class__�__name__�rR rV rV rW rZ s z_WrappingProtocol.logPrefixc C s | j �| j� | j�| j � dS )z� Connect the C{self._wrappedProtocol} to our C{self.transport} and callback C{self._connectedDeferred} with the C{self._wrappedProtocol} N)rM �makeConnection� transportrL �callbackr] rV rV rW �connectionMade� s z _WrappingProtocol.connectionMadec C � | j �|�S )zM Proxy C{dataReceived} calls to our C{self._wrappedProtocol} )rM � dataReceived)rR �datarV rV rW rc � � z _WrappingProtocol.dataReceivedc C rb )zW Proxy C{fileDescriptorReceived} calls to our C{self._wrappedProtocol} )rM �fileDescriptorReceived)rR � descriptorrV rV rW rf � re z(_WrappingProtocol.fileDescriptorReceivedc C rb )zO Proxy C{connectionLost} calls to our C{self._wrappedProtocol} )rM �connectionLost�rR �reasonrV rV rW rh � re z _WrappingProtocol.connectionLostc C � | j �� dS )zl Proxy L{IHalfCloseableProtocol.readConnectionLost} to our C{self._wrappedProtocol} N)rM �readConnectionLostr] rV rV rW rl � � z$_WrappingProtocol.readConnectionLostc C rk )zm Proxy L{IHalfCloseableProtocol.writeConnectionLost} to our C{self._wrappedProtocol} N)rM �writeConnectionLostr] rV rV rW rn � rm z%_WrappingProtocol.writeConnectionLostc C rk )za Proxy L{interfaces.IHandshakeListener} to our C{self._wrappedProtocol}. N)rM �handshakeCompletedr] rV rV rW ro � rm z$_WrappingProtocol.handshakeCompletedN) r\ � __module__� __qualname__�__doc__rX rZ ra rc rf rh rl rn ro rV rV rV rW rK f s rK c @ sL e Zd ZdZeZdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dS )�_WrappingFactorya� Wrap a factory in order to wrap the protocols it builds. @ivar _wrappedFactory: A provider of I{IProtocolFactory} whose buildProtocol method will be called and whose resulting protocol will be wrapped. @ivar _onConnection: A L{Deferred} that fires when the protocol is connected @ivar _connector: A L{connector <twisted.internet.interfaces.IConnector>} that is managing the current or previous connection attempt. c C s || _ tj| jd�| _dS )z� @param wrappedFactory: A provider of I{IProtocolFactory} whose buildProtocol method will be called and whose resulting protocol will be wrapped. �� cancellerN)�_wrappedFactoryr r � _canceller� _onConnection)rR �wrappedFactoryrV rV rW rX � s z_WrappingFactory.__init__c C � || _ dS )z~ A connection attempt was started. Remember the connector which started said attempt, for use later. N)� _connector)rR � connectorrV rV rW �startedConnecting� s z"_WrappingFactory.startedConnectingc C s$ |� t�| j�� �� | j�� dS )a; The outgoing connection attempt was cancelled. Fail that L{Deferred} with an L{error.ConnectingCancelledError}. @param deferred: The L{Deferred <defer.Deferred>} that was cancelled; should be the same as C{self._onConnection}. @type deferred: L{Deferred <defer.Deferred>} @note: This relies on startedConnecting having been called, so it may seem as though there's a race condition where C{_connector} may not have been set. However, using public APIs, this condition is impossible to catch, because a connection API (C{connectTCP}/C{SSL}/C{UNIX}) is always invoked before a L{_WrappingFactory}'s L{Deferred <defer.Deferred>} is returned to C{connect()}'s caller. @return: L{None} N)�errbackr �ConnectingCancelledErrorr{ �getDestination�stopConnecting)rR �deferredrV rV rW rw � s �z_WrappingFactory._cancellerc C rk )zY Start notifications are passed straight through to the wrapped factory. N)rv �doStartr] rV rV rW r� � � z_WrappingFactory.doStartc C rk )zX Stop notifications are passed straight through to the wrapped factory. N)rv �doStopr] rV rV rW r� � r� z_WrappingFactory.doStopc C sN z| j �|�}|du rt�� �W n ty | j�� Y dS w | �| j|�S )a Proxy C{buildProtocol} to our C{self._wrappedFactory} or errback the C{self._onConnection} L{Deferred} if the wrapped factory raises an exception or returns L{None}. @return: An instance of L{_WrappingProtocol} or L{None} N)rv � buildProtocolr � NoProtocol� BaseExceptionrx r~ �protocol)rR �addr�protorV rV rW r� � s � �z _WrappingFactory.buildProtocolc C s | j js | j �|� dS dS )zi Errback the C{self._onConnection} L{Deferred} when the client connection fails. N)rx �calledr~ )rR r| rj rV rV rW �clientConnectionFailed s �z'_WrappingFactory.clientConnectionFailedN) r\ rp rq rr rK r� rX r} rw r� r� r� r� rV rV rV rW rs � s rs c @ s$ e Zd ZdZeZdd� Zdd� ZdS )rE z� A Standard Input/Output endpoint @ivar _stdio: a callable, like L{stdio.StandardIO}, which takes an L{IProtocol} provider and a C{reactor} keyword argument (interface dependent upon your platform). c C rz )z? @param reactor: The reactor for the endpoint. N)�_reactor�rR �reactorrV rV rW rX " � zStandardIOEndpoint.__init__c C s t j| j|�t� �| jd�S )zU Implement L{IStreamServerEndpoint.listen} to listen on stdin/stdout )r� )r �execute�_stdior� r r� )rR �stdioProtocolFactoryrV rV rW �listen( s �zStandardIOEndpoint.listenN)r\ rp rq rr r r� rX r� rV rV rV rW rE s rE c @ � e Zd ZdZdS )�)_IProcessTransportWithConsumerAndProducera) An L{_IProcessTransportWithConsumerAndProducer} combines various interfaces to work around the issue that L{interfaces.IProcessTransport} is incompletely defined and doesn't specify flow-control interfaces, and that L{proxyForInterface} doesn't allow for multiple interfaces. N�r\ rp rq rr rV rV rV rW r� 3 s r� c @ r� )�_ProcessEndpointTransportaj An L{ITransport}, L{IProcessTransport}, L{IConsumer}, and L{IPushProducer} provider for the L{IProtocol} instance passed to the process endpoint. @ivar _process: An active process transport which will be used by write methods on this object to write data to a child process. @type _process: L{interfaces.IProcessTransport} provider Nr� rV rV rV rW r� > s r� �_processc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �_WrapIProtocolz� An L{IProcessProtocol} provider that wraps an L{IProtocol}. @ivar transport: A L{_ProcessEndpointTransport} provider that is hooked to the wrapped L{IProtocol} provider. @see: L{protocol.ProcessProtocol} c C s || _ || _|| _dS )z� @param proto: An L{IProtocol} provider. @param errFlag: A constant belonging to L{StandardErrorBehavior} that determines if stderr is logged or dropped. @param executable: The file name (full path) to spawn. N)r� �errFlag� executable)rR r� r� r� rV rV rW rX X s z_WrapIProtocol.__init__c C s t |�| _| j�| j�S )z� Call L{IProtocol} provider's makeConnection method with an L{ITransport} provider. @param process: An L{IProcessTransport} provider. )r� r_ r� r^ )rR �processrV rV rW r^ c s z _WrapIProtocol.makeConnectionc C sJ |dkr | j �|�S |dkr!| jtjkr#tjd| j| j |d� dS dS dS )z� This is called with data from the process's stdout or stderr pipes. It checks the status of the errFlag to setermine if stderr should be logged (default) or dropped. r. � zGProcess %(executable)r wrote stderr unhandled by %(protocol)s: %(data)s)�formatr� r� rd N)r� rc r� rH �LOGr& �msgr� )rR �childFDrd rV rV rW �childDataReceivedm s ��z _WrapIProtocol.childDataReceivedc C s> |� tj�tjkr|jjdkr| j�tt�� ��S | j�|�S )z� If the process ends with L{error.ProcessDone}, this method calls the L{IProtocol} provider's L{connectionLost} with a L{error.ConnectionDone} @see: L{ProcessProtocol.processEnded} r ) �checkr � ProcessDone�value�statusr� rh r+ �ConnectionDoneri rV rV rW � processEnded~ s z_WrapIProtocol.processEndedN)r\ rp rq rr rX r^ r� r� rV rV rV rW r� N s r� c @ s e Zd ZdZe� Ze� ZdS )rH z� Constants used in ProcessEndpoint to decide what to do with stderr. @cvar LOG: Indicates that stderr is to be logged. @cvar DROP: Indicates that stderr is to be dropped (and not logged). @since: 13.1 N)r\ rp rq rr r r� �DROPrV rV rV rW rH � s rH c @ s4 e Zd ZdZdi dddddejfdd�Zdd� ZdS ) rF z� An endpoint for child processes @ivar _spawnProcess: A hook used for testing the spawning of child process. @since: 13.1 rV Nr c C sJ || _ || _|| _|| _|| _|| _|| _|| _| | _| | _ | j j | _ dS )z� See L{IReactorProcess.spawnProcess}. @param errFlag: Determines if stderr should be logged. @type errFlag: L{endpoints.StandardErrorBehavior} N) r� � _executable�_args�_env�_path�_uid�_gid�_usePTY� _childFDs�_errFlag� spawnProcess� _spawnProcess) rR r� r� �args�env�path�uid�gid�usePTY�childFDsr� rV rV rW rX � s zProcessEndpoint.__init__c C sl |� t� �}z | �t|| j| j�| j| j| j| j| j | j | j | j � W n t y0 t�� Y S w t�|�S )a3 Implement L{IStreamClientEndpoint.connect} to launch a child process and connect it to a protocol created by C{protocolFactory}. @param protocolFactory: A factory for an L{IProtocol} provider which will be notified of all events related to the created process. )r� r r� r� r� r� r� r� r� r� r� r� r� r� r �fail�succeed)rR �protocolFactoryr� rV rV rW �connect� s" � � zProcessEndpoint.connect)r\ rp rq rr rH r� rX r� rV rV rV rW rF � s � rF c @ � e Zd ZdZdd� Zdd� ZdS )�_TCPServerEndpointz) A TCP server endpoint interface c C � || _ || _|| _|| _dS )a+ @param reactor: An L{IReactorTCP} provider. @param port: The port number used for listening @type port: int @param backlog: Size of the listen queue @type backlog: int @param interface: The hostname to bind to @type interface: str N)r� �_port�_backlog� _interface�rR r� �port�backlog� interfacerV rV rW rX � s z_TCPServerEndpoint.__init__c C s t j| jj| j|| j| jd�S )z] Implement L{IStreamServerEndpoint.listen} to listen on a TCP socket )r� r� )r r� r� � listenTCPr� r� r� �rR r� rV rV rW r� � s �z_TCPServerEndpoint.listenN�r\ rp rq rr rX r� rV rV rV rW r� � s r� c @ � e Zd ZdZddd�ZdS )r< zC Implements TCP server endpoint with an IPv4 configuration �2 � c C � t �| ||||� dS )aA @param reactor: An L{IReactorTCP} provider. @param port: The port number used for listening @type port: int @param backlog: Size of the listen queue @type backlog: int @param interface: The hostname to bind to, defaults to '' (all) @type interface: str N�r� rX r� rV rV rW rX � zTCP4ServerEndpoint.__init__N�r� r� �r\ rp rq rr rX rV rV rV rW r< � r< c @ r� )r= zC Implements TCP server endpoint with an IPv6 configuration r� �::c C r� )aD @param reactor: An L{IReactorTCP} provider. @param port: The port number used for listening @type port: int @param backlog: Size of the listen queue @type backlog: int @param interface: The hostname to bind to, defaults to C{::} (all) @type interface: str Nr� r� rV rV rW rX r� zTCP6ServerEndpoint.__init__N�r� r� r� rV rV rV rW r= r� r= c @ s" e Zd ZdZddd�Zdd� ZdS ) r> z9 TCP client endpoint with an IPv4 configuration. � Nc C �" || _ || _|| _|| _|| _dS )a� @param reactor: An L{IReactorTCP} provider @param host: A hostname, used when connecting @type host: str @param port: The port number, used when connecting @type port: int @param timeout: The number of seconds to wait before assuming the connection has failed. @type timeout: L{float} or L{int} @param bindAddress: A (host, port) tuple of local address to bind to, or None. @type bindAddress: tuple N�r� �_hostr� �_timeout� _bindAddress�rR r� �hostr� �timeout� bindAddressrV rV rW rX 6 s zTCP4ClientEndpoint.__init__c C sJ zt |�}| jj| j| j|| j| jd� |jW S ty$ t � � Y S w )zP Implement L{IStreamClientEndpoint.connect} to connect via TCP. �r� r� ) rs r� � connectTCPr� r� r� r� rx r� r r� �rR r� �wfrV rV rW r� N s � �zTCP4ClientEndpoint.connect�r� N�r\ rp rq rr rX r� rV rV rV rW r> 0 s r> c @ sN e Zd ZdZeej�Zeej �Z dZ dZ ddd�Z dd � Zd d � Zd d � ZdS )r? a� TCP client endpoint with an IPv6 configuration. @ivar _getaddrinfo: A hook used for testing name resolution. @ivar _deferToThread: A hook used for testing deferToThread. @ivar _GAI_ADDRESS: Index of the address portion in result of getaddrinfo to be used. @ivar _GAI_ADDRESS_HOST: Index of the actual host-address in the 5-tuple L{_GAI_ADDRESS}. � r r� Nc C r� )z� @param host: An IPv6 address literal or a hostname with an IPv6 address @see: L{twisted.internet.interfaces.IReactorTCP.connectTCP} Nr� r� rV rV rW rX u s zTCP6ClientEndpoint.__init__c sL t � j�r� �� j|�}|S � �� j�}|�� fdd�� |�� j|� |S )z~ Implement L{IStreamClientEndpoint.connect} to connect via TCP, once the hostname resolution is done. c s | d � j � j S )Nr )� _GAI_ADDRESS�_GAI_ADDRESS_HOST��resultr] rV rW �<lambda>� s z,TCP6ClientEndpoint.connect.<locals>.<lambda>)r r� �_resolvedHostConnect�_nameResolution� addCallback)rR r� �drV r] rW r� � s � �zTCP6ClientEndpoint.connectc C s | � | j|dtj�S )zd Resolve the hostname string into a tuple containing the host IPv6 address. r )�_deferToThread� _getaddrinfo�socket�AF_INET6�rR r� rV rV rW r� � s z"TCP6ClientEndpoint._nameResolutionc C sH zt |�}| jj|| j|| j| jd� |jW S ty# t� � Y S w )zD Connect to the server using the resolved hostname. r� ) rs r� r� r� r� r� rx r� r r� )rR � resolvedHostr� r� rV rV rW r� � s � �z'TCP6ClientEndpoint._resolvedHostConnectr� )r\ rp rq rr � staticmethodr� � getaddrinfor� r � deferToThreadr� r� r� rX r� r� r� rV rV rV rW r? ` s r? c @ s. e Zd ZdZe� Zdd� Z d dd�ZdS ) �_SimpleHostnameResolvera^ An L{IHostnameResolver} provider that invokes a provided callable to resolve hostnames. @ivar _nameResolution: the callable L{resolveHostName} invokes to resolve hostnames. @type _nameResolution: A L{callable} that accepts two arguments: the host to resolve and the port number to include in the result. c C rz )z? Create a L{_SimpleHostnameResolver} instance. N)r� )rR �nameResolutionrV rV rW rX � r� z _SimpleHostnameResolver.__init__r N�TCPc s^ �� t� �� ��� |�}�fdd�}� �fdd�}|�|� |�|� |��fdd�� �S )a Initiate a hostname resolution. @param resolutionReceiver: an object that will receive each resolved address as it arrives. @type resolutionReceiver: L{IResolutionReceiver} @param hostName: see interface @param portNumber: see interface @param addressTypes: Ignored in this implementation. @param transportSemantics: Ignored in this implementation. @return: The resolution in progress. @rtype: L{IResolutionReceiver} c sZ | D ](\}}}}}|t jkr� �tdg|�R � � q|t jkr*� �tdg|�R � � qd S )Nr� )r� r� �addressResolvedr �AF_INETr )� gairesult�family�socktyper� � canonname�sockaddr��resolutionReceiverrV rW � cbDeliver� s ��z:_SimpleHostnameResolver.resolveHostName.<locals>.cbDeliverc s �j jd| � �jd� d S )Nz'while looking up {name} with {callable})�name�callable)�_log�failurer� )r )�hostNamerR rV rW �ebLog� s �z6_SimpleHostnameResolver.resolveHostName.<locals>.ebLogc s � � � S �N)�resolutionComplete��ignoredr rV rW r� � s z9_SimpleHostnameResolver.resolveHostName.<locals>.<lambda>)�resolutionBeganr r� r� � addErrback�addBoth) rR r r � portNumber� addressTypes�transportSemanticsr� r r rV )r r rR rW �resolveHostName� s z'_SimpleHostnameResolver.resolveHostName)r Nr� )r\ rp rq rr r" r rX r rV rV rV rW r� � s �r� c @ sf e Zd ZdZeej�Zeej �Z dZ ddd�Z de fdd �Zd d � Zed d � �Zdd� Zdd� ZdS )rG aB A name-based endpoint that connects to the fastest amongst the resolved host addresses. @cvar _DEFAULT_ATTEMPT_DELAY: The default time to use between attempts, in seconds, when no C{attemptDelay} is given to L{HostnameEndpoint.__init__}. @ivar _hostText: the textual representation of the hostname passed to the constructor. Used to pass to the reactor's hostname resolver. @type _hostText: L{unicode} @ivar _hostBytes: the encoded bytes-representation of the hostname passed to the constructor. Used to construct the L{HostnameAddress} associated with this endpoint. @type _hostBytes: L{bytes} @ivar _hostStr: the native-string representation of the hostname passed to the constructor, used for exception construction @type _hostStr: native L{str} @ivar _badHostname: a flag - hopefully false! - indicating that an invalid hostname was passed to the constructor. This might be a textual hostname that isn't valid IDNA, or non-ASCII bytes. @type _badHostname: L{bool} g333333�?r� Nc C sh || _ | �|�| _| �|�\| _| _| _ttu r| jn| j| _ || _ || _ || _ |du r/| j }|| _dS )a� Create a L{HostnameEndpoint}. @param reactor: The reactor to use for connections and delayed calls. @type reactor: provider of L{IReactorTCP}, L{IReactorTime} and either L{IReactorPluggableNameResolver} or L{IReactorPluggableResolver}. @param host: A hostname to connect to. @type host: L{bytes} or L{unicode} @param port: The port number to connect to. @type port: L{int} @param timeout: For each individual connection attempt, the number of seconds to wait before assuming the connection has failed. @type timeout: L{float} or L{int} @param bindAddress: the local address of the network interface to make the connections from. @type bindAddress: L{bytes} @param attemptDelay: The number of seconds to delay between connection attempts. @type attemptDelay: L{float} @see: L{twisted.internet.interfaces.IReactorTCP.connectTCP} N)r� � _getNameResolverAndMaybeWarn� _nameResolver�_hostAsBytesAndText� _badHostname� _hostBytes� _hostText�bytes�str�_hostStrr� r� r� �_DEFAULT_ATTEMPT_DELAY� _attemptDelay)rR r� r� r� r� r� � attemptDelayrV rV rW rX s � zHostnameEndpoint.__init__�returnc C sL | j r| j}nt| j�rd| j� d�}nt| j�}d�d|dt| j�dg�S )zh Produce a string representation of the L{HostnameEndpoint}. @return: A L{str} �[�]r� z<HostnameEndpoint �:�>)r r# r r) r �joinr" r� r� rV rV rW �__repr__> s zHostnameEndpoint.__repr__c C sH t �|�s!tj|jtdddd�ddd�}tj|tdd � t | j �S |j S ) a Retrieve a C{nameResolver} callable and warn the caller's caller that using a reactor which doesn't provide L{IReactorPluggableNameResolver} is deprecated. @param reactor: The reactor to check. @return: A L{IHostnameResolver} provider. �Twisted� � r zPassing HostnameEndpoint a reactor that does not provide IReactorPluggableNameResolver (%(fqpn)s) was deprecated in %(version)sz5a reactor that provides IReactorPluggableNameResolver)r� � replacement� )� stacklevel) r rQ r% �getDeprecationWarningStringr[ r �warnings�warn�DeprecationWarningr� �_fallbackNameResolution� nameResolver)rR r� � warningStringrV rV rW r R s � z-HostnameEndpoint._getNameResolverAndMaybeWarnc C s� t | t�r,t| �s t| �rd| | �d�fS zd| t| �fW S ty+ | �d�} Y n(w td| �} t| �s9t| �rAd| �d�| fS zdt | �| fW S tyR Y nw | �dd�}d||�d�fS )a� For various reasons (documented in the C{@ivar}'s in the class docstring) we need both a textual and a binary representation of the hostname given to the constructor. For compatibility and convenience, we accept both textual and binary representations of the hostname, save the form that was passed, and convert into the other form. This is mostly just because L{HostnameAddress} chose somewhat poorly to define its attribute as bytes; hopefully we can find a compatible way to clean this up in the future and just operate in terms of text internally. @param host: A hostname to convert. @type host: L{bytes} or C{str} @return: a 3-tuple of C{(invalid, bytes, text)} where C{invalid} is a boolean indicating the validity of the hostname, C{bytes} is a binary representation of C{host}, and C{text} is a textual representation of C{host}. F�ascii�charmap�NFC�backslashreplaceT) � isinstancer! r r �decoder0 � UnicodeErrorr �encoder/ )r� � asciibytesrV rV rW r m s$ � � z$HostnameEndpoint._hostAsBytesAndTextc s� �j rt�td�j� ���S t� �g �tt�G ��fdd�d��}�jj |�j �j d� �� �fdd�� �j �fdd��}�� t� �fd d �� �j � ��fd d ��}�S ) a� Attempts a connection to each resolved address, and returns a connection which is established first. @param protocolFactory: The protocol factory whose protocol will be connected. @type protocolFactory: L{IProtocolFactory<twisted.internet.interfaces.IProtocolFactory>} @return: A L{Deferred} that fires with the connected protocol or fails a connection-related error. zinvalid hostname: c s: e Zd Zedd� �Ze� fdd��Ze� �fdd��ZdS )z2HostnameEndpoint.connect.<locals>.EndpointReceiverc S s d S r rV )�resolutionInProgressrV rV rW r � s zBHostnameEndpoint.connect.<locals>.EndpointReceiver.resolutionBeganc � � � | � d S r ��append)�address)� addressesrV rW r � � zBHostnameEndpoint.connect.<locals>.EndpointReceiver.addressResolvedc s �� � � d S r �r` rV �rI r� rV rW r � rJ zEHostnameEndpoint.connect.<locals>.EndpointReceiver.resolutionCompleteN)r\ rp rq r� r r r rV rL rV rW �EndpointReceiver� s rM )r c s t �t�d� j� d���S )Nz Couldn't find the hostname '�')r r� r �DNSLookupErrorr# r r] rV rW r� � s �z*HostnameEndpoint.connect.<locals>.<lambda>c 3 s\ � | D ](}t |t�rt� j|j|j� j� j�V t |t�r+t � j|j|j� j� j�V qd S r ) r? r r? r� r� r� r� r� r r> )rI � eachAddressr] rV rW � resolvedAddressesToEndpoints� s( � � ���z>HostnameEndpoint.connect.<locals>.resolvedAddressesToEndpointsc s | � t�t� j� j��� d S r )r~ r r r r r� )r� r] rV rW rw � s ��z,HostnameEndpoint.connect.<locals>._cancellerc s� | s t �d�j� ���t| ��g �g �tj�d��� ���fdd�� d� _d� _t� �����fdd����j �_ �� �j � �j � ��fd d ��}�S ) aQ Given a sequence of endpoints obtained via name resolution, start connecting to a new one every C{self._attemptDelay} seconds until one of the connections succeeds, all of them fail, or the attempt is cancelled. @param endpoints: a list of all the endpoints we might try to connect to, as determined by name resolution. @type endpoints: L{list} of L{IStreamServerEndpoint} @return: a Deferred that fires with the result of the C{endpoint.connect} method that completes the fastest, or fails with the first connection error it encountered if none of them succeed. @rtype: L{Deferred} failing with L{error.ConnectingCancelledError} or firing with L{IProtocol} z no results for hostname lookup: rt c s& �s� j s� jr d S ����� � d S r )� completed� endpointsLeftr~ �poprV )� checkDone�failures�pending�winnerrV rW rU s zLHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.checkDoneFTc st t �d �} | d u rd�_�� d S | ���� ��� � � j� �fdd��}� j�fdd��}� j��fdd��}d S )NFc s �� � � | S r )�remover� )� eachAttemptrW rV rW �noLongerPending s zkHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.iterateEndpoint.<locals>.noLongerPendingc rE r rK r� )rX rV rW � succeeded rJ zeHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.iterateEndpoint.<locals>.succeededc s �� | � � � d S r rF )rj )rU rV rV rW �failed! s zbHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.iterateEndpoint.<locals>.failed)�nextrS r� rG r r� r )�endpointr[ r\ r] )rU rV � iterEndpointsrW r� rX )rZ rW �iterateEndpoint s zRHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.iterateEndpointc s2 d� _ �d d � D ]}|�� q �jr��� | S �NT)rR �cancel�running�stop)r� � remaining)rU ra rW rV rW �cancelRemainingPending) s zYHostnameEndpoint.connect.<locals>.startConnectionAttempts.<locals>.cancelRemainingPending)r rO r# �iterr r rR rS r! r� �clock�startr% r )� endpointsrg )rw r� rR )rU rV r` ra rW rX rW �startConnectionAttempts� s$ � z9HostnameEndpoint.connect.<locals>.startConnectionAttempts)r r r� � ValueErrorr# r r r r r r r� r r� �list)rR r� rM rQ rl rV )rw rI r� r� rR rW r� � s& � � KzHostnameEndpoint.connectc C s | � | j||dtj�S )a� Resolve the hostname string into a tuple containing the host address. This is method is only used when the reactor does not provide L{IReactorPluggableNameResolver}. @param host: A unicode hostname to resolve. @param port: The port to include in the resolution. @return: A L{Deferred} that fires with L{_getaddrinfo}'s return value. r )r� r� r� � SOCK_STREAM)rR r� r� rV rV rW r8 6 r� z(HostnameEndpoint._fallbackNameResolution)r� NN)r\ rp rq rr r� r� r� r� r r� r� r$ rX r" r- r r r� r8 rV rV rV rW rG � s �, , rG c @ �" e Zd ZdZd dd�Zdd� ZdS ) rB zE SSL secured TCP server endpoint with an IPv4 configuration. r� r� c C r� )a� @param reactor: An L{IReactorSSL} provider. @param port: The port number used for listening @type port: int @param sslContextFactory: An instance of L{interfaces.IOpenSSLContextFactory}. @param backlog: Size of the listen queue @type backlog: int @param interface: The hostname to bind to, defaults to '' (all) @type interface: str N)r� r� �_sslContextFactoryr� r� )rR r� r� �sslContextFactoryr� r� rV rV rW rX L s zSSL4ServerEndpoint.__init__c C �" t j| jj| j|| j| j| jd�S )zf Implement L{IStreamServerEndpoint.listen} to listen for SSL on a TCP socket. )�contextFactoryr� r� )r r� r� � listenSSLr� rq r� r� r� rV rV rW r� b s �zSSL4ServerEndpoint.listenNr� r� rV rV rV rW rB F s rB c @ s$ e Zd ZdZ ddd�Zdd� ZdS ) rC zD SSL secured TCP client endpoint with an IPv4 configuration r� Nc C s( || _ || _|| _|| _|| _|| _dS )ao @param reactor: An L{IReactorSSL} provider. @param host: A hostname, used when connecting @type host: str @param port: The port number, used when connecting @type port: int @param sslContextFactory: SSL Configuration information as an instance of L{interfaces.IOpenSSLContextFactory}. @param timeout: Number of seconds to wait before assuming the connection has failed. @type timeout: int @param bindAddress: A (host, port) tuple of local address to bind to, or None. @type bindAddress: tuple N)r� r� r� rq r� r� )rR r� r� r� rr r� r� rV rV rW rX w s zSSL4ClientEndpoint.__init__c C sN zt |�}| jj| j| j|| j| j| jd� |jW S t y& t � � Y S w )zb Implement L{IStreamClientEndpoint.connect} to connect with SSL over TCP. r� ) rs r� � connectSSLr� r� rq r� r� rx r� r r� r� rV rV rW r� � s � �zSSL4ClientEndpoint.connectr� r� rV rV rV rW rC q s � rC c @ s" e Zd ZdZd dd�Zdd� Zd S ) r@ z% UnixSocket server endpoint. r� � r c C r� )a� @param reactor: An L{IReactorUNIX} provider. @param address: The path to the Unix socket file, used when listening @param backlog: number of connections to allow in backlog. @param mode: mode to set on the unix socket. This parameter is deprecated. Permissions should be set on the directory which contains the UNIX socket. @param wantPID: If True, create a pidfile for the socket. N)r� �_addressr� �_mode�_wantPID)rR r� rH r� �mode�wantPIDrV rV rW rX � s zUNIXServerEndpoint.__init__c C rs )zW Implement L{IStreamServerEndpoint.listen} to listen on a UNIX socket. )r� r{ r| )r r� r� � listenUNIXrx r� ry rz r� rV rV rW r� � s �zUNIXServerEndpoint.listenN)r� rw r r� rV rV rV rW r@ � s r@ c @ rp ) rA z% UnixSocket client endpoint. r� r c C r� )a� @param reactor: An L{IReactorUNIX} provider. @param path: The path to the Unix socket file, used when connecting @type path: str @param timeout: Number of seconds to wait before assuming the connection has failed. @type timeout: int @param checkPID: If True, check for a pid file to verify that a server is listening. @type checkPID: bool N)r� r� r� � _checkPID)rR r� r� r� �checkPIDrV rV rW rX � s zUNIXClientEndpoint.__init__c C sF zt |�}| jj| j|| j| jd� |jW S ty" t� � Y S w )za Implement L{IStreamClientEndpoint.connect} to connect via a UNIX Socket )r� r ) rs r� � connectUNIXr� r� r~ rx r� r r� r� rV rV rW r� � s � �zUNIXClientEndpoint.connectN)r� r r� rV rV rV rW rA � s rA c @ s0 e Zd ZdZejZeej �Z dd� Z dd� Z dS )rD z� An endpoint for listening on a file descriptor initialized outside of Twisted. @ivar _used: A C{bool} indicating whether this endpoint has been used to listen with a factory yet. C{True} if so. c C s || _ || _|| _d| _dS )a @param reactor: An L{IReactorSocket} provider. @param fileno: An integer file descriptor corresponding to a listening I{SOCK_STREAM} socket. @param addressFamily: The address family of the socket given by C{fileno}. FN)r� �fileno� addressFamily�_used)rR r� r� r� rV rV rW rX s z$AdoptedStreamServerEndpoint.__init__c C sp | j r t�t�� �S d| _ z| �| j� | j�| j| j |�}| � | j� W n t y2 t�� Y S w t� |�S )z{ Implement L{IStreamServerEndpoint.listen} to start listening on, and then close, C{self._fileno}. T) r� r r� r �AlreadyListened�_setNonBlockingr� r� �adoptStreamPortr� �_closer� r� )rR �factoryr� rV rV rW r� s � � z"AdoptedStreamServerEndpoint.listenN) r\ rp rq rr �os�closer� r� r �setNonBlockingr� rX r� rV rV rV rW rD � s rD r� r� c C s t |�| f|t |�d�fS )a Internal parser function for L{_parseServer} to convert the string arguments for a TCP(IPv4) stream endpoint into the structured arguments. @param factory: the protocol factory being parsed, or L{None}. (This was a leftover argument from when this code was in C{strports}, and is now mostly None and unused.) @type factory: L{IProtocolFactory} or L{None} @param port: the integer port number to bind @type port: C{str} @param interface: the interface IP to listen on @param backlog: the length of the listen queue @type backlog: C{str} @return: a 2-tuple of (args, kwargs), describing the parameters to L{IReactorTCP.listenTCP} (or, modulo argument 2, the factory, arguments to L{TCP4ServerEndpoint}. �r� r� )�int)r� r� r� r� rV rV rW � _parseTCP& s r� �666Tc C s& || ft |d�t |�tt |��d�fS )a� Internal parser function for L{_parseServer} to convert the string arguments for a UNIX (AF_UNIX/SOCK_STREAM) stream endpoint into the structured arguments. @param factory: the protocol factory being parsed, or L{None}. (This was a leftover argument from when this code was in C{strports}, and is now mostly None and unused.) @type factory: L{IProtocolFactory} or L{None} @param address: the pathname of the unix socket @type address: C{str} @param backlog: the length of the listen queue @type backlog: C{str} @param lockfile: A string '0' or '1', mapping to True and False respectively. See the C{wantPID} argument to C{listenUNIX} @return: a 2-tuple of (args, kwargs), describing the parameters to L{twisted.internet.interfaces.IReactorUNIX.listenUNIX} (or, modulo argument 2, the factory, arguments to L{UNIXServerEndpoint}. � )r{ r� r| )r� �bool)r� rH r{ r� �lockfilerV rV rW � _parseUNIX? s �r� � server.pemc s ddl m� |du r |}i } |durt� j|�| d< t|��� } t|��� } � j�| d | �} |durVtj dt t|��� �tj d�} � fdd �| D �}|sUt d |f ��nd}|durd� j �t|��}� jd | jj| j||d �| ��}t|�| |f|t|�d �fS )a� Internal parser function for L{_parseServer} to convert the string arguments for an SSL (over TCP/IPv4) stream endpoint into the structured arguments. @param factory: the protocol factory being parsed, or L{None}. (This was a leftover argument from when this code was in C{strports}, and is now mostly None and unused.) @type factory: L{IProtocolFactory} or L{None} @param port: the integer port number to bind @type port: C{str} @param interface: the interface IP to listen on @param backlog: the length of the listen queue @type backlog: C{str} @param privateKey: The file name of a PEM format private key file. @type privateKey: C{str} @param certKey: The file name of a PEM format certificate file. @type certKey: C{str} @param sslmethod: The string name of an SSL method, based on the name of a constant in C{OpenSSL.SSL}. Must be one of: "SSLv23_METHOD", "SSLv2_METHOD", "SSLv3_METHOD", "TLSv1_METHOD". @type sslmethod: C{str} @param extraCertChain: The path of a file containing one or more certificates in PEM format that establish the chain from a root CA to the CA that signed your C{certKey}. @type extraCertChain: L{str} @param dhParameters: The file name of a file containing parameters that are required for Diffie-Hellman key exchange. If this is not specified, the forward secret C{DHE} ciphers aren't available for servers. @type dhParameters: L{str} @return: a 2-tuple of (args, kwargs), describing the parameters to L{IReactorSSL.listenSSL} (or, modulo argument 2, the factory, arguments to L{SSL4ServerEndpoint}. r ��sslN�method� z=(-----BEGIN CERTIFICATE-----\n.+?\n-----END CERTIFICATE-----))�flagsc s g | ] }� j �|�j�qS rV )r2 �loadPEM�original)�.0� chainCertPEMr� rV rW � <listcomp>� s �z _parseSSL.<locals>.<listcomp>zOSpecified chain file '%s' doesn't contain any valid certificates in PEM format.)� privateKey� certificate�extraCertChain� dhParametersr� rV )�twisted.internetr� �getattr�SSLr, � getContentr5 r� �re�findallr) �DOTALLrm �DiffieHellmanParameters�fromFiler3 r� r� r� )r� r� r� �certKey� sslmethodr� r� r� r� �kw�certPEM�keyPEM�privateCertificate�matches�chainCertificates�cfrV r� rW � _parseSSL^ sN 5 � ������� r� c @ s$ e Zd ZdZdZdd� Zdd� ZdS )�_StandardIOParserz� Stream server endpoint string parser for the Standard I/O type. @ivar prefix: See L{IStreamServerEndpointStringParser.prefix}. �stdioc C s t |�S )z� Internal parser function for L{_parseServer} to convert the string arguments into structured arguments for the L{StandardIOEndpoint} @param reactor: Reactor for the endpoint )rE r� rV rV rW � _parseServer� s z _StandardIOParser._parseServerc O s | � |�S r �r� �rR r� r� �kwargsrV rV rW �parseStreamServer� s z#_StandardIOParser.parseStreamServerN�r\ rp rq rr �prefixr� r� rV rV rV rW r� � s r� c @ s, e Zd ZdZe�� ZdZdd� Zdd� Z dS )�_SystemdParsera Stream server endpoint string parser for the I{systemd} endpoint type. @ivar prefix: See L{IStreamServerEndpointStringParser.prefix}. @ivar _sddaemon: A L{ListenFDs} instance used to translate an index into an actual file descriptor. �systemdc C s0 t |�}| j�� | }ttd| �}t|||�S )a| Internal parser function for L{_parseServer} to convert the string arguments for a systemd server endpoint into structured arguments for L{AdoptedStreamServerEndpoint}. @param reactor: An L{IReactorSocket} provider. @param domain: The domain (or address family) of the socket inherited from systemd. This is a string like C{"INET"} or C{"UNIX"}, ie the name of an address family from the L{socket} module, without the C{"AF_"} prefix. @type domain: C{str} @param index: An offset into the list of file descriptors inherited from systemd. @type index: C{str} @return: A two-tuple of parsed positional arguments and parsed keyword arguments (a tuple and a dictionary). These can be used to construct an L{AdoptedStreamServerEndpoint}. �AF_)r� � _sddaemon�inheritedDescriptorsr� r� rD )rR r� �domain�indexr� r� rV rV rW r� � s z_SystemdParser._parseServerc O � | j |g|�R i |��S r r� r� rV rV rW r� � s z _SystemdParser.parseStreamServerN) r\ rp rq rr r- �fromEnvironmentr� r� r� r� rV rV rV rW r� � s r� c @ s& e Zd ZdZdZd dd�Zdd� Zd S ) �_TCP6ServerParserz� Stream server endpoint string parser for the TCP6ServerEndpoint type. @ivar prefix: See L{IStreamServerEndpointStringParser.prefix}. �tcp6r� r� c C s t |�}t |�}t||||�S )a� Internal parser function for L{_parseServer} to convert the string arguments into structured arguments for the L{TCP6ServerEndpoint} @param reactor: An L{IReactorTCP} provider. @param port: The port number used for listening @type port: int @param backlog: Size of the listen queue @type backlog: int @param interface: The hostname to bind to @type interface: str )r� r= r� rV rV rW r� s z _TCP6ServerParser._parseServerc O r� r r� r� rV rV rW r� & s z#_TCP6ServerParser.parseStreamServerNr� r� rV rV rV rW r� s � r� )�tcp�unixr� r� c c s� � t d| �}t d| �}t d| �}t d| �}|}|| }||| ||i}tt| ��}|D ](} | t|�v rDt|fV t| fV |}|| }q+| |krO|t|�7 }q+|| 7 }q+t|fV dS )a� Tokenize a strports string and yield each token. @param description: a string as described by L{serverFromString} or L{clientFromString}. @type description: L{str} or L{bytes} @return: an iterable of 2-tuples of (C{_OP} or C{_STRING}, string). Tuples starting with C{_OP} will contain a second element of either ':' (i.e. 'next parameter') or '=' (i.e. 'assign parameter value'). For example, the string 'hello:greeting=world' would result in a generator yielding these values:: _STRING, 'hello' _OP, ':' _STRING, 'greet=ing' _OP, '=' _STRING, 'world' r� r* �=�\N)r' rh r( �_STRING�_OPr^ ) � description�empty�colon�equals� backslash�current�ops�nextOps�iterdesc�nrV rV rW � _tokenize5 s& � r� c sp g i � �t d| �}� �fdd�}d}t| �D ]\}}|tu r%||f7 }q||kr/||� d}q||� � �fS )a Convert a description string into a list of positional and keyword parameters, using logic vaguely like what Python does. @param description: a string as described by L{serverFromString} or L{clientFromString}. @return: a 2-tuple of C{(args, kwargs)}, where 'args' is a list of all ':'-separated C{str}s not containing an '=' and 'kwargs' is a map of all C{str}s which do contain an '='. For example, the result of C{_parse('a:b:d=1:c')} would be C{(['a', 'b', 'c'], {'d': '1'})}. r* c s6 t | �dkr� �| d � d S | d �t| d �< d S )Nr. r )�lenrG r) )�sofar�r� r� rV rW �addo s z_parse.<locals>.addrV )r' r� r� )r� r� r� r� �typer� rV r� rW �_parse_ s �r� )r� r� �UNIXc C sn t | �\}}|d }t�|�}|du r#ttt�|�}||dd� |fS |�� f||g|dd� �R i |�� S )a� Parse a strports description into a 2-tuple of arguments and keyword values. @param description: A description in the format explained by L{serverFromString}. @type description: C{str} @param factory: A 'factory' argument; this is left-over from twisted.application.strports, it's not really used. @type factory: L{IProtocolFactory} or L{None} @return: a 3-tuple of (plugin or name, arguments, keyword arguments) r Nr. )r� �_serverParsers�get�_matchPluginToPrefixr$ r �upper)r� r� r� r� � endpointType�parser�pluginrV rV rW r� � s �(r� c C s> |� � }| D ]}t|j� � |�|kr| S qtd|� d���)z! Match plugin to prefix. zUnknown endpoint type: 'rN )�lowerr' r� rm )�pluginsr� r� rV rV rW r� � s �r� c C sn t |d�\}}}t|�tur |}|j| g|�R i |��S |}|dd� |dd� }t| | g|�R i |��S )a_ Construct a stream server endpoint from an endpoint description string. The format for server endpoint descriptions is a simple byte string. It is a prefix naming the type of endpoint, then a colon, then the arguments for that endpoint. For example, you can call it like this to create an endpoint that will listen on TCP port 80:: serverFromString(reactor, "tcp:80") Additional arguments may be specified as keywords, separated with colons. For example, you can specify the interface for a TCP server endpoint to bind to like this:: serverFromString(reactor, "tcp:80:interface=127.0.0.1") SSL server endpoints may be specified with the 'ssl' prefix, and the private key and certificate files may be specified by the C{privateKey} and C{certKey} arguments:: serverFromString( reactor, "ssl:443:privateKey=key.pem:certKey=crt.pem") If a private key file name (C{privateKey}) isn't provided, a "server.pem" file is assumed to exist which contains the private key. If the certificate file name (C{certKey}) isn't provided, the private key file is assumed to contain the certificate as well. You may escape colons in arguments with a backslash, which you will need to use if you want to specify a full pathname argument on Windows:: serverFromString(reactor, "ssl:443:privateKey=C\:/key.pem:certKey=C\:/cert.pem") finally, the 'unix' prefix may be used to specify a filesystem UNIX socket, optionally with a 'mode' argument to specify the mode of the socket file created by C{listen}:: serverFromString(reactor, "unix:/var/run/finger") serverFromString(reactor, "unix:/var/run/finger:mode=660") This function is also extensible; new endpoint types may be registered as L{IStreamServerEndpointStringParser} plugins. See that interface for more information. @param reactor: The server endpoint will be constructed with this reactor. @param description: The strports description to parse. @type description: L{str} @return: A new endpoint which can be used to listen with the parameters given by C{description}. @rtype: L{IStreamServerEndpoint<twisted.internet.interfaces.IStreamServerEndpoint>} @raise ValueError: when the 'description' string cannot be parsed. @since: 10.2 Nr. r� )r� r� r" r� �_endpointServerFactories)r� r� � nameOrPluginr� r� r� r rV rV rW r; � s > r; c C s* d\}}||fD ] }| � ||| �} q| S )a� Quote an argument to L{serverFromString} and L{clientFromString}. Since arguments are separated with colons and colons are escaped with backslashes, some care is necessary if, for example, you have a pathname, you may be tempted to interpolate into a string like this:: serverFromString(reactor, "ssl:443:privateKey=%s" % (myPathName,)) This may appear to work, but will have portability issues (Windows pathnames, for example). Usually you should just construct the appropriate endpoint type rather than interpolating strings, which in this case would be L{SSL4ServerEndpoint}. There are some use-cases where you may need to generate such a string, though; for example, a tool to manipulate a configuration file which has strports descriptions in it. To be correct in those cases, do this instead:: serverFromString(reactor, "ssl:443:privateKey=%s" % (quoteStringArgument(myPathName),)) @param argument: The part of the endpoint description string you want to pass through. @type argument: C{str} @return: The quoted argument. @rtype: C{str} z\:)�replace)�argumentr� r� �crV rV rW �quoteStringArgument� s r� c O s� t | �dkrt| d �|d< | d |d< nt | �dkr.d|v r(t| d �|d< n| d |d< z t|d �|d< W n tyA Y nw z t|d �|d< W n tyU Y nw z |d df|d< W |S tyk Y |S w )a$ Perform any argument value coercion necessary for TCP client parameters. Valid positional arguments to this function are host and port. Valid keyword arguments to this function are all L{IReactorTCP.connectTCP} arguments. @return: The coerced values as a C{dict}. r� r. r� r r� r� r� )r� r� �KeyError�r� r� rV rV rW �_parseClientTCP! s0 � � ��r� c C s� i }| � � D ]9}|�� �� �d�d �� dksqz|�� }W n ty' Y qw zt�|�}W n t y8 Y qw |||� � < qt |� � �S )z� Load certificate-authority certificate objects in a given directory. @param directoryPath: a L{unicode} or L{bytes} pointing at a directory to load .pem files from, or L{None}. @return: an L{IOpenSSLTrustRoot} provider. �.����pem) �children� asTextMode�basename�splitr� r� �OSErrorr2 r� �SSLError�digestr7 �values)� directoryPath�caCerts�childrd �theCertrV rV rW �_loadCAsFromDirH s � � r c C s | du rdS t t| ��S )z� Parse a string referring to a directory full of certificate authorities into a trust root. @param pathName: path name @type pathName: L{unicode} or L{bytes} or L{None} @return: L{None} or L{IOpenSSLTrustRoot} N)r r, )�pathNamerV rV rW �_parseTrustRootPathd s r c C sL | du rdS t | ��� }|du rt�|�S t�t�|�t�t |��� d��S )ax Parse a certificate path and key path, either or both of which might be L{None}, into a certificate object. @param certificatePath: the certificate path @type certificatePath: L{bytes} or L{unicode} or L{None} @param keyPath: the private key path @type keyPath: L{bytes} or L{unicode} or L{None} @return: a L{PrivateCertificate} or L{None} Nr. )r, r� r5 r� �fromCertificateAndKeyPairr2 r4 �load)�certificatePath�keyPath� certBytesrV rV rW �_privateCertFromPathss s �r c C s� | � dd�}t| � dd�| � dd��}t| � dd��}|dur)tt|�||d�}n|dur5|jj}|j}nd}d}t|||d�}|| d< | S ) a� Parse common arguments for SSL endpoints, creating an L{CertificateOptions} instance. @param kwargs: A dict of keyword arguments to be parsed, potentially containing keys C{certKey}, C{privateKey}, C{caCertsDir}, and C{hostname}. See L{_parseClientSSL}. @type kwargs: L{dict} @return: The remaining arguments, including a new key C{sslContextFactory}. �hostnameNr� r� � caCertsDir�� trustRoot�clientCertificate)r r� r� rr )rT r r r6 r0 r� r� r3 )r� r r r � configuration�privateKeyOpenSSL�certificateOpenSSLrV rV rW �_parseClientSSLOptions� s. ���r c O s t | i |��}t|�S )a Perform any argument value coercion necessary for SSL client parameters. Valid keyword arguments to this function are all L{IReactorSSL.connectSSL} arguments except for C{contextFactory}. Instead, C{certKey} (the path name of the certificate file) C{privateKey} (the path name of the private key associated with the certificate) are accepted and used to construct a context factory. Valid positional arguments to this function are host and port. @keyword caCertsDir: The one parameter which is not part of L{IReactorSSL.connectSSL}'s signature, this is a path name used to construct a list of certificate authority certificates. The directory will be scanned for files ending in C{.pem}, all of which will be considered valid certificate authorities for this connection. @type caCertsDir: L{str} @keyword hostname: The hostname to use for validating the server's certificate. @type hostname: L{unicode} @return: The coerced values as a L{dict}. )r� r r� rV rV rW �_parseClientSSL� s r c O sr t | �dkr | d |d< z tt|�d���|d< W n ty" Y nw z t|d �|d< W |S ty8 Y |S w )a� Perform any argument value coercion necessary for UNIX client parameters. Valid keyword arguments to this function are all L{IReactorUNIX.connectUNIX} keyword arguments except for C{checkPID}. Instead, C{lockfile} is accepted and has the same meaning. Also C{path} is used instead of C{address}. Valid positional arguments to this function are C{path}. @return: The coerced values as a C{dict}. r. r r� r� r r� )r� r� r� rT r� r� rV rV rW �_parseClientUNIX� s � ��r c C sr t |�\}}|�d�}|�� }|tvr&ttt�|�}|j| g|�R i |��S t| |i |��}t| | fi |��S )a� Construct a client endpoint from a description string. Client description strings are much like server description strings, although they take all of their arguments as keywords, aside from host and port. You can create a TCP client endpoint with the 'host' and 'port' arguments, like so:: clientFromString(reactor, "tcp:host=www.example.com:port=80") or, without specifying host and port keywords:: clientFromString(reactor, "tcp:www.example.com:80") Or you can specify only one or the other, as in the following 2 examples:: clientFromString(reactor, "tcp:host=www.example.com:80") clientFromString(reactor, "tcp:www.example.com:port=80") or an SSL client endpoint with those arguments, plus the arguments used by the server SSL, for a client certificate:: clientFromString(reactor, "ssl:web.example.com:443:" "privateKey=foo.pem:certKey=foo.pem") to specify your certificate trust roots, you can identify a directory with PEM files in it with the C{caCertsDir} argument:: clientFromString(reactor, "ssl:host=web.example.com:port=443:" "caCertsDir=/etc/ssl/certs") Both TCP and SSL client endpoint description strings can include a 'bindAddress' keyword argument, whose value should be a local IPv4 address. This fixes the client socket to that IP address:: clientFromString(reactor, "tcp:www.example.com:80:" "bindAddress=192.0.2.100") NB: Fixed client ports are not currently supported in TCP or SSL client endpoints. The client socket will always use an ephemeral port assigned by the operating system You can create a UNIX client endpoint with the 'path' argument and optional 'lockfile' and 'timeout' arguments:: clientFromString( reactor, b"unix:path=/var/foo/bar:lockfile=1:timeout=9") or, with the path as a positional argument with or without optional arguments as in the following 2 examples:: clientFromString(reactor, "unix:/var/foo/bar") clientFromString(reactor, "unix:/var/foo/bar:lockfile=1:timeout=9") This function is also extensible; new endpoint types may be registered as L{IStreamClientEndpointStringParserWithReactor} plugins. See that interface for more information. @param reactor: The client endpoint will be constructed with this reactor. @param description: The strports description to parse. @type description: L{str} @return: A new endpoint which can be used to connect with the parameters given by C{description}. @rtype: L{IStreamClientEndpoint<twisted.internet.interfaces.IStreamClientEndpoint>} @since: 10.2 r ) r� rT r� �_clientParsersr� r$ r �parseStreamClient�_endpointClientFactories)r� r� r� r� �anamer r� rV rV rW r: � s H �r: c s G � fdd�dt �}| �|� �S )a� Connect a protocol instance to an endpoint. This allows using a client endpoint without having to create a factory. @param endpoint: A client endpoint to connect to. @param protocol: A protocol instance. @return: The result of calling C{connect} on the endpoint, i.e. a L{Deferred} that will fire with the protocol when connected, or an appropriate error. @since: 13.1 c s e Zd Z� fdd�ZdS )z'connectProtocol.<locals>.OneShotFactoryc s � S r rV )rR r� �r� rV rW r� X s z5connectProtocol.<locals>.OneShotFactory.buildProtocolN)r\ rp rq r� rV r rV rW �OneShotFactoryW s r )r r� )r_ r� r rV r rW rI F s rI c @ r� )�_WrapperEndpointz2 An endpoint that wraps another endpoint. c C � || _ || _dS )z2 Construct a L{_WrapperEndpoint}. N��_wrappedEndpoint�_wrapperFactory�rR �wrappedEndpoint�wrapperFactoryrV rV rW rX d � z_WrapperEndpoint.__init__c C s | j �| �|���dd� �S )�K Connect the given protocol factory and unwrap its result. c S s | j S r )rT r rV rV rW r� q s z*_WrapperEndpoint.connect.<locals>.<lambda>)r r� r! r� r� rV rV rW r� k s � �z_WrapperEndpoint.connectNr� rV rV rV rW r ^ � r c @ r� )�_WrapperServerEndpointz? A server endpoint that wraps another server endpoint. c C r )z8 Construct a L{_WrapperServerEndpoint}. Nr r" rV rV rW rX z r% z _WrapperServerEndpoint.__init__c C s | j �| �|��S )r& )r r� r! r� rV rV rW r� � s z _WrapperServerEndpoint.listenNr� rV rV rV rW r( t r' r( c s" t du rtd��t|� fdd��S )a� Wrap an endpoint which upgrades to TLS as soon as the connection is established. @since: 16.0 @param connectionCreator: The TLS options to use when connecting; see L{twisted.internet.ssl.optionsForClientTLS} for how to construct this. @type connectionCreator: L{twisted.internet.interfaces.IOpenSSLClientConnectionCreator} @param wrappedEndpoint: The endpoint to wrap. @type wrappedEndpoint: An L{IStreamClientEndpoint} provider. @return: an endpoint that provides transport level encryption layered on top of C{wrappedEndpoint} @rtype: L{twisted.internet.interfaces.IStreamClientEndpoint} Nz6OpenSSL not available. Try `pip install twisted[tls]`.c s t � d| �S rb r8 )r� ��connectionCreatorrV rW r� � s �z wrapClientTLS.<locals>.<lambda>)r9 �NotImplementedErrorr )r* r# rV r) rW rJ � s � �rJ � 30c K s� | r t dt| �� ���t|t�r|n|�d�}t|t�s |du r"|n|�d�}t|�}t|�}tt|t |�t ||�d�|durEt | |��S t | t |�|||��S )a� Internal method to construct an endpoint from string parameters. @param reactor: The reactor passed to L{clientFromString}. @param host: The hostname to connect to. @type host: L{bytes} or L{unicode} @param port: The port to connect to. @type port: L{bytes} or L{unicode} @param timeout: For each individual connection attempt, the number of seconds to wait before assuming the connection has failed. @type timeout: L{bytes} or L{unicode} @param bindAddress: The address to which to bind outgoing connections. @type bindAddress: L{bytes} or L{unicode} @param certificate: a string representing a filesystem path to a PEM-encoded certificate. @type certificate: L{bytes} or L{unicode} @param privateKey: a string representing a filesystem path to a PEM-encoded certificate. @type privateKey: L{bytes} or L{unicode} @param endpoint: an optional string endpoint description of an endpoint to wrap; if this is passed then C{host} is used only for certificate verification. @type endpoint: L{bytes} or L{unicode} @return: a client TLS endpoint @rtype: L{IStreamClientEndpoint} z&unrecognized keyword arguments presentzutf-8Nr )� TypeErrorrn �keysr? r" r@ r� rJ r6 r r r: rG r/ ) r� r� r� r� r� r� r� � trustRootsr_ r� rV rV rW �_parseClientTLS� s, .�������r0 c @ s e Zd ZdZdZedd� �ZdS )�_TLSClientEndpointParserz� Stream client endpoint string parser for L{wrapClientTLS} with L{HostnameEndpoint}. @ivar prefix: See L{IStreamClientEndpointStringParserWithReactor.prefix}. �tlsc O s t | g|�R i |��S )a� Redirects to another function L{_parseClientTLS}; tricks zope.interface into believing the interface is correctly implemented, since the signature is (C{reactor}, C{*args}, C{**kwargs}). See L{_parseClientTLS} for the specific signature description for this endpoint parser. @param reactor: The reactor passed to L{clientFromString}. @param args: The positional arguments in the endpoint description. @type args: L{tuple} @param kwargs: The named arguments in the endpoint description. @type kwargs: L{dict} @return: a client TLS endpoint @rtype: L{IStreamClientEndpoint} )r0 )r� r� r� rV rV rW r � s z*_TLSClientEndpointParser.parseStreamClientN)r\ rp rq rr r� r� r rV rV rV rW r1 � s r1 )r� r� )r� r� T)r� NNr� r� NN)r, NNNNN)�rr r� r� r� r5 � unicodedatar �zope.interfacer r r � constantlyr r � incrementalr r� r r r r r �twisted.internet.abstractr r �twisted.internet.addressr r r r �twisted.internet.interfacesr r r r r �twisted.internet.protocolr r r r �twisted.internet.stdior r � ImportError�twisted.internet._resolverr �twisted.internet.deferr �twisted.internet.taskr! �twisted.loggerr" �twisted.pluginr# r$ �twisted.pythonr% r& �twisted.python.compatr' r( r) �twisted.python.componentsr* �twisted.python.failurer+ �twisted.python.filepathr, �twisted.python.systemdr- �_idnar/ r0 � OpenSSL.SSLr1 r� �twisted.internet.sslr2 r3 r4 r5 r6 r7 �twisted.protocols.tlsr9 �_TLSMemoryBIOFactory�__all__rK rs �IStreamServerEndpointrE �IProcessTransport� IConsumer� IPushProducerr� r� r� rH �IStreamClientEndpointrF r� r< r= r> r? r� rG rB rC r@ rA rD r� r� r� r� r� r� r� �ranger� r� r� r� r� r r� r� r; r� r� r r r r r r r r: rI r r( rJ r0 r1 rV rV rV rW �<module> s � �Q_ � ��@C%/IF V*7#( / " �^0&� *#�� I#' ( �T# �DPK Mb�Z��YQ�@ �@ ( internet/__pycache__/udp.cpython-310.pycnu �[��� o �b�H � @ s` d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z e dkrWddl m Z ddl m Z dd l m Z mZmZmZmZmZmZ ee ee gZe eeegZeZe Ze ZeZndd l mZmZmZmZmZmZ eeegZegZdd l m Z m Z m Z m Z m!Z!m"Z" dd l#m$Z$m%Z% ee"j&e"j'e"j(�G d d� de j)��Z*G dd� d�Z+ee"j,�G dd� de+e*��Z-dS )a� Various asynchronous UDP classes. Please do not use this module directly. @var _sockErrReadIgnore: list of symbolic error constants (from the C{errno} module) representing socket errors where the error is temporary and can be ignored. @var _sockErrReadRefuse: list of symbolic error constants (from the C{errno} module) representing socket errors that indicate connection refused. � N)�Optional)� implementer)� platformType�win32)�WSAEINPROGRESS)�WSAEWOULDBLOCK)�WSAECONNREFUSED� WSAECONNRESET�WSAEINTR� WSAEMSGSIZE� WSAENETRESET�WSAENOPROTOOPT� WSAETIMEDOUT)�EAGAIN� ECONNREFUSED�EINTR�EMSGSIZE� ENOPROTOOPT� EWOULDBLOCK)�abstract�address�base�defer�error� interfaces)�failure�logc @ s� e Zd ZU dZejZejZdZ dZ e e e d< dZd2dd�Zed d � �Zd efd d �Zdd� Zdd� Zdd� Zdd� Zdd� Zd3dd�Zdd� Zd d � Zd d � Z d d!� Z d"d#� Z d3d$d%�Z d&d'� Z d(d)� Z!d*d+� Z"d,d-� Z#d.d/� Z$d0d1� Z%dS )4�Porta� UDP port, listening for packets. @ivar maxThroughput: Maximum number of bytes read in one event loop iteration. @ivar addressFamily: L{socket.AF_INET} or L{socket.AF_INET6}, depending on whether this port is listening on an IPv4 address or an IPv6 address. @ivar _realPortNumber: Actual port number being listened on. The value will be L{None} until this L{Port} is listening. @ivar _preexistingSocket: If not L{None}, a L{socket.socket} instance which was created and initialized outside of the reactor and will be used to listen for connections (instead of a new socket being created by this L{Port}). i N�_realPortNumber� � c C s@ t j�| |� || _|| _|| _|| _| �� d| _| � � dS )a @param port: A port number on which to listen. @type port: L{int} @param proto: A C{DatagramProtocol} instance which will be connected to the given C{port}. @type proto: L{twisted.internet.protocol.DatagramProtocol} @param interface: The local IPv4 or IPv6 address to which to bind; defaults to '', ie all IPv4 addresses. @type interface: L{str} @param maxPacketSize: The maximum packet size to accept. @type maxPacketSize: L{int} @param reactor: A reactor which will notify this C{Port} when its socket is ready for reading or writing. Defaults to L{None}, ie the default global reactor. @type reactor: L{interfaces.IReactorFDSet} N) r �BasePort�__init__�port�protocol� maxPacketSize� interface� setLogStr�_connectedAddr�_setAddressFamily)�selfr# �protor& r% �reactor� r- �6/usr/lib/python3/dist-packages/twisted/internet/udp.pyr" [ s z Port.__init__c C s8 t �||| j�}|�� d }| d||||d�}||_|S )a� Create a new L{Port} based on an existing listening I{SOCK_DGRAM} socket. @param reactor: A reactor which will notify this L{Port} when its socket is ready for reading or writing. Defaults to L{None}, ie the default global reactor. @type reactor: L{interfaces.IReactorFDSet} @param fd: An integer file descriptor associated with a listening socket. The socket must be in non-blocking mode. Any additional attributes desired, such as I{FD_CLOEXEC}, must also be set already. @type fd: L{int} @param addressFamily: The address family (sometimes called I{domain}) of the existing socket. For example, L{socket.AF_INET}. @type addressFamily: L{int} @param protocol: A C{DatagramProtocol} instance which will be connected to the C{port}. @type protocol: L{twisted.internet.protocol.DatagramProtocol} @param maxPacketSize: The maximum packet size to accept. @type maxPacketSize: L{int} @return: A new instance of C{cls} wrapping the socket given by C{fd}. @rtype: L{Port} r N)r& r, r% )�socket�fromfd� socketType� getsockname�_preexistingSocket) �clsr, �fd� addressFamilyr$ r% r# r& r* r- r- r. �_fromListeningDescriptory s �z Port._fromListeningDescriptor�returnc C s2 | j d urd| jj� d| j � d�S d| jj� d�S )N�<z on �>z not connected>)r r$ � __class__�r* r- r- r. �__repr__� s z Port.__repr__c C � | j S )z) Return a socket object. )r/ r< r- r- r. � getHandle� � zPort.getHandlec C s | � � | �� dS )z� Create and bind my socket, and begin listening on it. This is called on unserialization, and must be called after creating a server to begin listening on the specified port. N)� _bindSocket�_connectToProtocolr< r- r- r. �startListening� s zPort.startListeningc C s� | j du r*z| �� }|�| j| jf� W n ty) } z t�| j| j|��d}~ww | j }d| _ |�� d | _ t � d| � | j �| j f � d| _|| _| jj| _dS )aJ Prepare and assign a L{socket.socket} instance to C{self.socket}. Either creates a new SOCK_DGRAM L{socket.socket} bound to C{self.interface} and C{self.port} or takes an existing L{socket.socket} provided via the L{interfaces.IReactorSocket.adoptDatagramPort} interface. N� z%s starting on %s)r3 �createInternetSocket�bindr& r# �OSErrorr �CannotListenErrorr2 r r �msg� _getLogPrefixr$ � connectedr/ �fileno�r* �skt�ler- r- r. rA � s& ����zPort._bindSocketc C s | j �| � | �� d S �N)r$ �makeConnection� startReadingr< r- r- r. rB � s zPort._connectToProtocolc C s� d}|| j k rsz | j�| j�\}}W n0 tyB } z$|jd }|tv r*W Y d}~dS |tv r=| jr6| j � � W Y d}~dS � d}~ww |t |�7 }| j tj krU|dd� }z | j �||� W n tyk t�� Y nw || j k sdS dS )z= Called when my socket is ready for reading. r N� )� maxThroughputr/ �recvfromr% rG �args�_sockErrReadIgnore�_sockErrReadRefuser( r$ �connectionRefused�lenr6 �AF_INET6�datagramReceived� BaseExceptionr �err)r* �read�data�addr�se�nor- r- r. �doRead� s0 �� ��z Port.doReadc C s� | j rO|d| j fv s J �z| j�|�W S tyN } z/|jd }|tkr/| �|�W Y d}~S |tkr8t� d��|t krB| j � � n� W Y d}~dS d}~ww |dksUJ �t �|d �sqt �|d �sq|d dkrqt�|d d��t �|d �s~|d dkr�| jtjkr�t�|d d��t �|d �r�| jtjkr�t�|d d��z| j�||�W S ty� } z*|jd }|tkr�| �||�W Y d}~S |tkr�t� d��|t kr�W Y d}~dS � d}~ww )az Write a datagram. @type datagram: L{bytes} @param datagram: The datagram to be sent. @type addr: L{tuple} containing L{str} as first element and L{int} as second element, or L{None} @param addr: A tuple of (I{stringified IPv4 or IPv6 address}, I{integer port number}); can be L{None} in connected mode. Nr zmessage too longz <broadcast>z0write() only accepts IP addresses, not hostnamesz7IPv6 port write() called with IPv4 or broadcast addressz*IPv4 port write() called with IPv6 address)r( r/ �sendrG rV r �writer r �MessageLengthErrorr r$ rY r � isIPAddress� isIPv6Address�InvalidAddressErrorr6 r[ �AF_INET�sendto)r* �datagramra rb rc r- r- r. rf sb ��� � � � � �� ��z Port.writec C s | � d�|�|� dS )a� Write a datagram constructed from an iterable of L{bytes}. @param seq: The data that will make up the complete datagram to be written. @type seq: an iterable of L{bytes} @type addr: L{tuple} containing L{str} as first element and L{int} as second element, or L{None} @param addr: A tuple of (I{stringified IPv4 or IPv6 address}, I{integer port number}); can be L{None} in connected mode. � N)rf �join)r* �seqra r- r- r. � writeSequence@ s zPort.writeSequencec C sL | j rtd��t�|�st�|�st�|d��||f| _ | j�||f� dS )z- 'Connect' to remote server. z:already connected, reconnecting is not currently supported� not an IPv4 or IPv6 address.N) r( � RuntimeErrorr rh ri r rj r/ �connect)r* �hostr# r- r- r. rt O s � z Port.connectc C s& | � � | jr| j�d| j� d S d S )Nr )� stopReadingrK r, � callLater�connectionLostr< r- r- r. �_loseConnection\ s �zPort._loseConnectionc C s& | j r t�� }| _nd }| �� |S rP )rK r �Deferred�dry )r* �resultr- r- r. � stopListeninga s zPort.stopListeningc C s t jdtdd� | �� d S )Nz-Please use stopListening() to disconnect portrS )� stacklevel)�warnings�warn�DeprecationWarningr} r< r- r- r. �loseConnectioni s � zPort.loseConnectionc C sh t �d| j � d| _d| _tj�| |� | j�� | j � � | ` | ` t | d�r2| j �d� | ` dS dS )z& Cleans up my socket. z(UDP Port %s Closed)N���r{ )r rI r rT r r! rx r$ �doStopr/ �closerL �hasattrr{ �callback)r* �reasonr- r- r. rx q s �zPort.connectionLostc C s | � | j�}d| | _dS )zP Initialize the C{logstr} attribute to be used by C{logPrefix}. z%s (UDP)N)rJ r$ �logstr)r* � logPrefixr- r- r. r' � s zPort.setLogStrc C sH t �| j�r tj| _dS t �| j�rtj| _dS | jr"t� | jd��dS )z8 Resolve address family for the socket. rr N) r ri r& r/ r[ r6 rh rk r rj r< r- r- r. r) � s ��zPort._setAddressFamilyc C r> )z0 Return the prefix to log with. )r� r< r- r- r. r� � r@ zPort.logPrefixc C sR | j �� }| jt jkrtjdg|�R � S | jt jkr'tjdg|dd� �R � S dS )z� Return the local address of the UDP connection @returns: the local address of the UDP connection @rtype: L{IPv4Address} or L{IPv6Address} �UDPNrS )r/ r2 r6 rk r � IPv4Addressr[ � IPv6Address�r* ra r- r- r. �getHost� s �z Port.getHostc C s | j �t jt j|� dS )z� Set whether this port may broadcast. This is disabled by default. @param enabled: Whether the port may broadcast. @type enabled: L{bool} N)r/ � setsockopt� SOL_SOCKET� SO_BROADCAST)r* �enabledr- r- r. �setBroadcastAllowed� s zPort.setBroadcastAllowedc C s t | j�tjtj��S )z� Checks if broadcast is currently allowed on this port. @return: Whether this port may broadcast. @rtype: L{bool} )�boolr/ � getsockoptr� r� r< r- r- r. �getBroadcastAllowed� s zPort.getBroadcastAllowed)r r NrP )&�__name__� __module__� __qualname__�__doc__r/ rk r6 � SOCK_DGRAMr1 rT r r �int�__annotations__r3 r" � classmethodr7 �strr= r? rC rA rB rd rf rq rt ry r} r� rx r' r) r� r� r� r� r- r- r- r. r > s: + # > r c @ sl e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z ddd�Z dd� Z dd� Z ddd�ZdS )�MulticastMixinz, Implement multicast functionality. c C s$ | j �t jt j�}t �t�d|��S )Nz@i)r/ r� � IPPROTO_IP�IP_MULTICAST_IF� inet_ntoa�struct�pack)r* �ir- r- r. �getOutgoingInterface� s z#MulticastMixin.getOutgoingInterfacec C s | j �|��| j�S )z Returns Deferred of success.)r, �resolve� addCallback� _setInterfacer� r- r- r. �setOutgoingInterface� s z#MulticastMixin.setOutgoingInterfacec C s" t �|�}| j �t jt j|� dS )NrD )r/ � inet_atonr� r� r� )r* ra r� r- r- r. r� � s z MulticastMixin._setInterfacec C � | j �t jt j�S rP )r/ r� r� �IP_MULTICAST_LOOPr< r- r- r. �getLoopbackMode� � z MulticastMixin.getLoopbackModec C s( t �dt|��}| j�tjtj|� d S )N�b)r� r� r� r/ r� r� r� )r* �moder- r- r. �setLoopbackMode� s z MulticastMixin.setLoopbackModec C r� rP )r/ r� r� �IP_MULTICAST_TTLr< r- r- r. �getTTL� r� zMulticastMixin.getTTLc C s$ t �d|�}| j�tjtj|� d S )N�B)r� r� r/ r� r� r� )r* �ttlr- r- r. �setTTL� s zMulticastMixin.setTTLr c C � | j �|��| j|d�S )z4Join a multicast group. Returns Deferred of success.rD �r, r� r� � _joinAddr1�r* ra r& r- r- r. � joinGroup� � zMulticastMixin.joinGroupc C s | j �|��| j||�S rP )r, r� r� � _joinAddr2)r* ra r& ro r- r- r. r� � s zMulticastMixin._joinAddr1c C s� t �|�}t �|�}|rt j}nt j}z| j �t j||| � W d S tyA } zt�t j ||g|j �R � �W Y d }~S d }~ww rP ) r/ r� �IP_ADD_MEMBERSHIP�IP_DROP_MEMBERSHIPr� r� rG r �Failurer �MulticastJoinErrorrV )r* r& ra ro �cmd�er- r- r. r� � s (��zMulticastMixin._joinAddr2c C r� )z2Leave multicast group, return Deferred of success.r r� r� r- r- r. � leaveGroup� r� zMulticastMixin.leaveGroupN)r )r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r- r- r- r. r� � s r� c @ s* e Zd ZdZ d dd�Zdd � ZdS ) � MulticastPortz. UDP Port that supports multicasting. r r NFc C s t �| |||||� || _dS )zX @see: L{twisted.internet.interfaces.IReactorMulticast.listenMulticast} N)r r" �listenMultiple)r* r# r+ r& r% r, r� r- r- r. r" � s zMulticastPort.__init__c C s~ t �| �}| jr=|�tjtjd� ttd�r=z |�tjtjd� W |S t y< } z|j t kr0n� W Y d }~|S d }~ww |S )NrD � SO_REUSEPORT) r rE r� r� r/ r� � SO_REUSEADDRr� r� rG �errnor rM r- r- r. rE s � ���z"MulticastPort.createInternetSocket)r r NF)r� r� r� r� r" rE r- r- r- r. r� � s � r� ).r� r/ r� r �typingr �zope.interfacer �twisted.python.runtimer r� r r r r r r r r r r rW rX r r r r r �twisted.internetr r r r r r �twisted.pythonr r �IListeningPort� IUDPTransport� ISystemHandler! r r� �IMulticastTransportr� r- r- r- r. �<module> s> $ � |8PK Mb�Z� KL KL ) internet/__pycache__/unix.cpython-310.pycnu �[��� o �b�W � @ s d Z ddlZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl m Z mZ ddlmZmZmZ ddlmZmZmZmZmZmZmZmZ ddl m Z ddl m Z m Z m!Z!m"Z" dd l#m$Z$ dd l%m&Z& dd l'm(Z( zdd l m)Z* W n e+y dZ)Y nw e*Z)e,ed �s�e+d��dd� Z-G dd� d�Z.G dd� d�Z/e)r�e.Z.ne/Z.eej0�G dd� de.ej1��Z1dd� Z2G dd� d�Z3G dd � d e3ej4�Z4eej0�G d d � d e.ej5��Z6G d d � d ej7�Z8eej9�G d!d"� d"e3ej4��Z:eej;geej<��R � G d#d$� d$e:��Z=dS )%z� UNIX socket support for Twisted. End users shouldn't use this module directly - use the reactor APIs instead. Maintainer: Itamar Shtull-Trauring � N)�EAGAIN� ECONNREFUSED�EINTR�EMSGSIZE�ENOBUFS� EWOULDBLOCK)�Optional�Type)� implementedBy� implementer�implementer_only)�address�base�error� interfaces�main�protocol�tcp�udp)�FileDescriptor)�failure�lockfile�log�reflect)� lazyByteSlice)�_coerceToFilesystemEncoding)�untilConcludes)�sendmsg�AF_UNIXz+UNIX sockets not supported on this platformc C s t �d| �}tjtj|fgS )zh Pack an integer into an ancillary data structure suitable for use with L{sendmsg.sendmsg}. �i)�struct�pack�socket� SOL_SOCKETr � SCM_RIGHTS)�fd�packed� r' �7/usr/lib/python3/dist-packages/twisted/internet/unix.py�_ancillaryDescriptor) s r) c @ sZ e Zd ZU dZdZeee ed< dZ dd� Z dd� Z d d � Z d d � Z d d� Zdd� ZdS )� _SendmsgMixina Mixin for stream-oriented UNIX transports which uses sendmsg and recvmsg to offer additional functionality, such as copying file descriptors into other processes. @ivar _writeSomeDataBase: The class which provides the basic implementation of C{writeSomeData}. Ultimately this should be a subclass of L{twisted.internet.abstract.FileDescriptor}. Subclasses which mix in L{_SendmsgMixin} must define this. @ivar _sendmsgQueue: A C{list} of C{int} holding file descriptors which are currently buffered before being sent. @ivar _fileDescriptorBufferSize: An C{int} giving the maximum number of file descriptors to accept and queue for sending before pausing the registered producer, if there is one. N�_writeSomeDataBase�@ c C s g | _ d S �N)� _sendmsgQueue��selfr' r' r( �__init__H � z_SendmsgMixin.__init__c C s t | j�| jkp | j�| �S )a� Determine whether the user-space send buffer for this transport is full or not. This extends the base determination by adding consideration of how many file descriptors need to be sent using L{sendmsg.sendmsg}. When there are more than C{self._fileDescriptorBufferSize}, the buffer is considered full. @return: C{True} if it is full, C{False} otherwise. )�lenr. �_fileDescriptorBufferSizer+ �_isSendBufferFullr/ r' r' r( r5 K s ����z _SendmsgMixin._isSendBufferFullc C s | j �|� | �� | �� dS )zY Queue the given file descriptor to be sent and start trying to send it. N)r. �append�_maybePauseProducer� startWriting)r0 �filenor' r' r( �sendFileDescriptord s z _SendmsgMixin.sendFileDescriptorc C s6 t | j�t |�kr t�� S d}zg|t | j�k ro| j| }zttj| j|||d � t|�� W n4 tyc } z(|j d t t fv rO|W Y d}~W | jd|�= S t j W Y d}~W | jd|�= S d}~ww |d7 }|t | j�k sW | jd|�= n| jd|�= w t||�}| j�| |�}z|| W S ty� | Y S w )zg Send as much of C{data} as possible. Also send any pending file descriptors. r � N)r3 r. r �FileDescriptorOverrunr r r" r) �OSError�argsr r r �CONNECTION_LOSTr r+ � writeSomeData� TypeError)r0 �data�indexr% �se� limitedData�resultr' r' r( r@ l s@ ������ �z_SendmsgMixin.writeSomeDatac C s� zt tj| j| j�\}}}W n# ty1 } z|jd tkr$W Y d}~dS tj W Y d}~S d}~ww |D ](\}}}|tj krI|tj krI| � |� q4t jd| �� | �� | �| j�||d� q4| �|�S )a� Calls {IProtocol.dataReceived} with all available data and L{IFileDescriptorReceiver.fileDescriptorReceived} once for each received file descriptor in ancillary data. This reads up to C{self.bufferSize} bytes of data from its socket, then dispatches the data to protocol callbacks to be handled. If the connection is not lost through an error in the underlying recvmsg(), this function will return the result of the dataReceived call. r Nz�%(protocolName)s (on %(hostAddress)r) received unsupported ancillary data (level=%(cmsgLevel)r, type=%(cmsgType)r) from %(peerAddress)r.)�format� hostAddress� peerAddress� protocolName� cmsgLevel�cmsgType)r r �recvmsgr" � bufferSizer= r> r r r? r# r$ �%_ancillaryLevelSOLSOCKETTypeSCMRIGHTSr �msg�getHost�getPeer� _getLogPrefixr � _dataReceived)r0 rB � ancillary�flagsrD rK rL �cmsgDatar' r' r( �doRead� s, ��� � z_SendmsgMixin.doReadc C s~ t |�d }t�d| |�}tj�| j�r"|D ]}| j�|� qdS tj d| � � | � � | � | j�d� |D ]}t �|� q5dS )a� Processes ancillary data with level SOL_SOCKET and type SCM_RIGHTS, indicating that the ancillary data payload holds file descriptors. Calls L{IFileDescriptorReceiver.fileDescriptorReceived} once for each received file descriptor or logs a message if the protocol does not implement L{IFileDescriptorReceiver}. @param cmsgData: Ancillary data payload. @type cmsgData: L{bytes} � r z�%(protocolName)s (on %(hostAddress)r) does not provide IFileDescriptorReceiver; closing file descriptor received (from %(peerAddress)r).)rG rH rI rJ N)r3 r �unpackr �IFileDescriptorReceiver� providedByr �fileDescriptorReceivedr rP rQ rR rS �os�close)r0 rW �fdCount�fdsr% r' r' r( rO � s � � �z3_SendmsgMixin._ancillaryLevelSOLSOCKETTypeSCMRIGHTS)�__name__� __module__� __qualname__�__doc__r+ r r r �__annotations__r4 r1 r5 r: r@ rX rO r' r' r' r( r* 2 s . )r* c @ s e Zd ZdZdS )�_UnsupportedSendmsgMixinz� Behaviorless placeholder used when C{twisted.python.sendmsg} is not available, preventing L{IUNIXTransport} from being supported. N)rb rc rd re r' r' r' r( rg � s rg c @ s6 e Zd ZejZdd� Zedd� �Zdd� Z dd� Z d S ) �Serverc C s* t �| � tj�| |||d f|||� d S r- )r* r1 r rh )r0 �sockr �client�server� sessionno�reactorr' r' r( r1 � s �zServer.__init__c C s� t �|t jt j�}t�|�� �}|�|�}|du r |�� dS d}| |||� � d||�}d� |j j j |j|�� �|_d� |j j j |j|�� �|_|�|� |S )a Create a new L{Server} based on an existing connected I{SOCK_STREAM} socket. Arguments are the same as to L{Server.__init__}, except where noted. @param fileDescriptor: An integer file descriptor associated with a connected socket. The socket must be in non-blocking mode. Any additional attributes desired, such as I{FD_CLOEXEC}, must also be set already. @return: A new instance of C{cls} wrapping the socket given by C{fileDescriptor}. Nr z<{} #{} on {}>z{},{},{})r" �fromfdr � SOCK_STREAMr � UNIXAddress� getsockname� buildProtocolr_ � getpeernamerG r � __class__rb rl �repstr�logstr�makeConnection) �cls�fileDescriptor�factoryrm �skt� protocolAddr�protorl r0 r' r' r( �_fromConnectedSocket� s( �� zServer._fromConnectedSocketc C � t �| j�� �S r- �r rp r" rq r/ r' r' r( rQ $ � zServer.getHostc C s t �| jpd �S r- )r rp �hostnamer/ r' r' r( rR ' r� zServer.getPeerN) rb rc rd r rh r+ r1 � classmethodr~ rQ rR r' r' r' r( rh � s ' rh c C s | dd� dvS )a� Determine whether the given unix socket path is in a filesystem namespace. While most PF_UNIX sockets are entries in the filesystem, Linux 2.2 and above support PF_UNIX sockets in an "abstract namespace" that does not correspond to any path. This function returns C{True} if the given socket path is stored in the filesystem and C{False} if the path is in this abstract namespace. Nr; )� � r' )�pathr' r' r( �_inFilesystemNamespace+ s r� c @ s e Zd Zdd� ZdS )� _UNIXPortc C r )zV Returns a UNIXAddress. This indicates the server's address. r� r/ r' r' r( rQ 9 s z_UNIXPort.getHostN)rb rc rd rQ r' r' r' r( r� 8 s r� c @ sf e Zd ZejZejZeZ dZ ddd�Z e dd� �Z d efd d �Zd d � Zdd� Zdd� Zdd� ZdS )�PortN�2 � r c C s4 t jj| | �|�j|||d� || _|| _d | _d S )N�rm )r r� r1 � _buildAddr�name�mode�wantPID�_preexistingSocket)r0 �fileNamerz �backlogr� rm r� r' r' r( r1 I s � z Port.__init__c C s. t �|| j| j�}| |�� ||d�}||_|S )a� Create a new L{Port} based on an existing listening I{SOCK_STREAM} socket. Arguments are the same as to L{Port.__init__}, except where noted. @param fd: An integer file descriptor associated with a listening socket. The socket must be in non-blocking mode. Any additional attributes desired, such as I{FD_CLOEXEC}, must also be set already. @return: A new instance of C{cls} wrapping the socket given by C{fd}. r� )r" rn � addressFamily� socketTyperq r� )rx rm r% rz �portr0 r' r' r( �_fromListeningDescriptorS s z Port._fromListeningDescriptor�returnc C s8 t �| jj�}t| d�rd�|td| j��S d|� d�S )Nr" z <{} on {!r}>� �<� (not listening)>)r �qualrz rt �hasattrrG r r� )r0 � factoryNamer' r' r( �__repr__f s � z Port.__repr__c C s t �|�S r- �r rp )r0 r� r' r' r( r� p r2 zPort._buildAddrc C sP t j�� t�d| �| j�td| j�f � | j rOt � | jd �| _ | j � � s/t�d| jd��| j jsOzt�t�| j�j�rDt�| j� W n tyN Y nw | j�� z| jdura| j}d| _n | �� }|�| j� W n ty� } zt�d| j|��d}~ww t | j�r�t� | j| j � |� | j � d| _!|| _"| j"j#| _#d| _$| �%� dS )z� Create and bind my socket, and begin listening on it. This is called on unserialization, and must be called after creating a server to begin listening on the specified port. z%s starting on %rr� � .lockNzCannot acquire lockT�d )&r � _reservedFD�reserver rP rS rz r r� r� r �FilesystemLock�lockFile�lockr �CannotListenError�clean�stat�S_ISSOCKr^ �st_mode�remove� BaseException�doStartr� �createInternetSocket�bindr= r� �chmodr� �listenr� � connectedr" r9 � numberAccepts� startReading�r0 r{ �ler' r' r( �startListenings sP ��� � � ��� zPort.startListeningc C s t �dtd| j� � dS )z0 Log message for closing socket z(UNIX Port %s Closed)r� N)r rP r r� r/ r' r' r( �_logConnectionLostMsg� s ���zPort._logConnectionLostMsgc C s< t | j�r t�| j� | jd ur| j�� tj�| |� d S r- ) r� r� r^ �unlinkr� �unlockr r� �connectionLost�r0 �reasonr' r' r( r� � s zPort.connectionLost)r� r� Nr )rb rc rd r" r r� ro r� rh � transportr� r1 r� r� �strr� r� r� r� r� r' r' r' r( r� B s � 6 r� c @ s< e Zd ZdZejZejZe j Z d dd�Z dd� Z dd � ZdS ) �ClientzA client for Unix sockets.Nr c C sj t �| � t�|�j}|| _| | _| _|r(t� |d �s(| � d d t � |�|� | � | j | �� d |� d S )Nr� )r* r1 r rp r� � connector� realAddress�addrr �isLocked� _finishInitr � BadFileError� doConnectr� )r0 �filenamer� rm �checkPIDr' r' r( r1 � s zClient.__init__c C � t �| j�S r- )r rp r� r/ r' r' r( rR � � zClient.getPeerc C s t �d �S r- r� r/ r' r' r( rQ � r2 zClient.getHost)Nr )rb rc rd re r" r r� ro r� r � BaseClientr+ r1 rR rQ r' r' r' r( r� � s r� c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )� Connectorc C s" t j�| |||� || _|| _d S r- )r � BaseConnectorr1 r r� )r0 r rz �timeoutrm r� r' r' r( r1 � s zConnector.__init__c C s t | j| | j| j�S r- )r� r rm r� r/ r' r' r( �_makeTransport� s zConnector._makeTransportc C s t �| j �S r- r� r/ r' r' r( �getDestination� r� zConnector.getDestinationN)rb rc rd r1 r� r� r' r' r' r( r� � s r� c @ sP e Zd ZdZejZddd�Zdefdd �Z d d � Z d d � Z ddd�Z dd� Z dS )� DatagramPortz4 Datagram UNIX port, listening for packets. � r� Nc C s t jj| ||||d� || _dS )z%Initialize with address to listen on.)� maxPacketSizerm N)r r� r1 r� )r0 r� r} r� r� rm r' r' r( r1 � s � zDatagramPort.__init__r� c C s8 t �| jj�}t| d�rd|� d| j�d�S d|� d�S )Nr" r� z on �>r� )r r� r rt r� r� )r0 rJ r' r' r( r� � s � zDatagramPort.__repr__c C s� t �| jj� dt| j�� �� z| �� }| jr |�| j� W n ty2 } zt � d | j|��d }~ww | jrCt | j�rCt � | j| j� d| _|| _| jj| _d S )Nz starting on r; )r rP r rt �reprr� r� r� r= r r� r� r^ r� r� r� r" r9 r� r' r' r( � _bindSocket� s ���zDatagramPort._bindSocketc C s� z| j �||�W S ty? } z+|jd }|tkr%| �||�W Y d}~S |tkr.t�d��|t kr3n� W Y d}~dS d}~ww )zWrite a datagram.r N�message too long) r" �sendtor= r> r �writer r �MessageLengthErrorr )r0 �datagramr rD �nor' r' r( r� s ���zDatagramPort.writec C sp t �dt| j� � tj�| |� t| d�r| j� � d| _ | j � � | ` | ` t| d�r6| j�d� | `dS dS )zCleans up my socket.z(Port %s Closed)r r �dN)r rP r� r� r �BasePortr� r� r �doStopr� r" r_ r9 r� �callbackr� r' r' r( r� s �zDatagramPort.connectionLostc C s t �| jj�d | _d S )Nz (UDP))r r� r rt rv r/ r' r' r( � setLogStr. s zDatagramPort.setLogStr)r� r� Nr- )rb rc rd re r" r r� r1 r� r� r� r� r� r� r' r' r' r( r� � s r� c @ sJ e Zd ZdZ ddd�Zdd� Zd d � Zd d � Zd d� Zdd� Z dS )�ConnectedDatagramPortz+ A connected datagram UNIX socket. r� r� Nc C s. t |tj�sJ �t�| |||||� || _d S r- )� isinstancer �ConnectedDatagramProtocolr� r1 � remoteaddr)r0 r� r} r� r� � bindAddressrm r' r' r( r1 : s z ConnectedDatagramPort.__init__c C sH z| � � | j�| j� | �� W d S ty# | �t�� � Y d S w r- ) r� r" �connectr� �_connectToProtocolr� �connectionFailedr �Failurer/ r' r' r( r� G s �z$ConnectedDatagramPort.startListeningc C s | � � | j�|� | `dS )z� Called when a connection fails. Stop listening on the socket. @type reason: L{Failure} @param reason: Why the connection failed. N)� stopListeningr r� r� r' r' r( r� O s z&ConnectedDatagramPort.connectionFailedc C s� d}|| j k rbz| j�| j�\}}|t|�7 }| j�|� W n< tyN } z$|jd }|t t t fv r9W Y d}~dS |t krC| j� � n� W Y d}~nd}~w tyZ t�� Y nw || j k sdS dS )z= Called when my socket is ready for reading. r N)� maxThroughputr" �recvfromr� r3 r �datagramReceivedr= r> r r r r �connectionRefusedr� r �deferr)r0 �readrB r� rD r� r' r' r( rX Z s& �� ��z ConnectedDatagramPort.doReadc C s� z| j �|�W S tyN } z;|jd }|tkr#| �|�W Y d}~S |tkr,t�d��|t kr6| j � � n|t kr;n� W Y d}~dS W Y d}~dS d}~ww )z# Write a datagram. r Nr� ) r" �sendr= r> r r� r r r� r r r� r )r0 rB rD r� r' r' r( r� o s" ���zConnectedDatagramPort.writec C r� r- )r rp r� r/ r' r' r( rR � r� z ConnectedDatagramPort.getPeer)r� r� NN) rb rc rd re r1 r� r� rX r� rR r' r' r' r( r� 2 s � r� )>re r^ r" r� r �errnor r r r r r �typingr r �zope.interfacer r r �twisted.internetr r r r r r r r �twisted.internet.abstractr �twisted.pythonr r r r �twisted.python.compatr �twisted.python.filepathr �twisted.python.utilr r �_sendmsg� ImportErrorr� r) r* rg �IUNIXTransportrh r� r� r� r� r� r� r� �IUNIXDatagramTransportr� � IUNIXDatagramConnectedTransportr� r� r' r' r' r( �<module> sZ ( � 39 } L��PK Mb�Z><)/�: �: * internet/__pycache__/error.cpython-310.pycnu �[��� o �b�4 � @ sj d Z ddlZddlmZ ddlmZ G dd� de�ZG dd� de�ZG d d � d e�Z G d d � d e�Z G d d� de �Z G dd� de�Z G dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d d � d e�ZG d d � d e�ZG d!d"� d"e�ZG d#d$� d$e�ZG d%d&� d&e�ZG d'd(� d(e�ZG d)d*� d*e�ZG d+d,� d,e�Zz ddl Z e j ee j ee j eiZ e!e d-�r�ee e j"< ee e j#< W n e$y� i Z Y nw d.d/� Z%G d0d1� d1e�Z&G d2d3� d3e&�Z'G d4d5� d5e'�Z(G d6d7� d7e&�Z)G d8d9� d9e'�Z*G d:d;� d;e'�Z+G d<d=� d=e,�Z-G d>d?� d?e,�Z.G d@dA� dAe/�Z0e�1edBdCdd�dDe2dA� G dEdF� dFe)�Z3G dGdH� dHe'�Z4G dIdJ� dJe�Z5G dKdL� dLe6�Z7G dMdN� dNe6�Z8G dOdP� dPe6�Z9G dQdR� dRe6�Z:G dSdT� dTe6�Z;G dUdV� dVe<�Z=G dWdX� dXe�Z>G dYdZ� dZe�Z?G d[d\� d\e�Z@G d]d^� d^e�ZAG d_d`� d`e�ZBG dadb� dbe,�ZCg dc�ZDdS )dz< Exceptions and errors for use in twisted.internet modules. � N)�Version)� deprecatec @ �" e Zd Zd ZZdefdd�ZdS )� BindErrorz)An error occurred binding to an interface�returnc C �, | j }| jrd�|d�| j��}d| }|S �Nz{}: {}� �%s.��MESSAGE�args�format�join��self�s� r �8/usr/lib/python3/dist-packages/twisted/internet/error.py�__str__ � zBindError.__str__N��__name__� __module__� __qualname__�__doc__r �strr r r r r r � r c @ s& e Zd ZdZdd� Zdefdd�ZdS )�CannotListenErrora2 This gets raised by a call to startListening, when the object cannotstart listening. @ivar interface: the interface I tried to listen on @ivar port: the port I tried to listen on @ivar socketError: the exception I got when I tried to listen @type socketError: L{socket.error} c C s& t �| |||� || _|| _|| _d S �N)r �__init__� interface�port� socketError)r r! r" r# r r r r & s zCannotListenError.__init__r c C s | j pd}d�|| j| j�S )N�anyz Couldn't listen on {}:{}: {}.)r! r r" r# )r �ifacer r r r , s �zCannotListenError.__str__N)r r r r r r r r r r r r s r c @ � e Zd ZdZdS )�MulticastJoinErrorz6 An attempt to join a multicast group failed. N�r r r r r r r r r' 3 � r' c @ r )�MessageLengthErrorzMessage is too long to sendr c C r r r r r r r r < r zMessageLengthError.__str__Nr r r r r r* 9 r r* c @ r )�DNSLookupErrorzDNS lookup failedr c C r r r r r r r r G r zDNSLookupError.__str__Nr r r r r r+ D r r+ c @ r& )�ConnectInProgressErrorz3A connect operation was started and isn't done yet.Nr( r r r r r, O r) r, c @ s, e Zd Zd ZZd dd�Zdefdd�ZdS ) � ConnectErrorz"An error occurred while connectingN� c C s || _ t�| |� d S r )�osError� Exceptionr )r r/ �stringr r r r Y s zConnectError.__init__r c C sF | j }| jr|� d| j� �}| jd r |� d| jd � �}d| }|S )N�: r r )r r/ r r r r r r ] s zConnectError.__str__)Nr. )r r r r r r r r r r r r r- V s r- c @ � e Zd Zd ZZdS )�ConnectBindErrorz Couldn't bindN�r r r r r r r r r r4 g � r4 c @ r3 )�UnknownHostErrorz Hostname couldn't be looked upNr5 r r r r r7 k r6 r7 c @ r3 )� NoRouteErrorzNo route to hostNr5 r r r r r8 o r6 r8 c @ r3 )�ConnectionRefusedErrorz$Connection was refused by other sideNr5 r r r r r9 s r6 r9 c @ r3 )�TCPTimedOutErrorzTCP connection timed outNr5 r r r r r: w r6 r: c @ r3 )� BadFileErrorz$File used for UNIX socket is no goodNr5 r r r r r; { r6 r; c @ r3 )�ServiceNameUnknownErrorz%Service name given as port is unknownNr5 r r r r r< r6 r< c @ r3 )� UserErrorzUser aborted connectionNr5 r r r r r= � r6 r= c @ r3 )� TimeoutErrorz&User timeout caused connection failureNr5 r r r r r> � r6 r> c @ r3 )�SSLErrorzAn SSL error occurredNr5 r r r r r? � r6 r? c @ r3 )� VerifyErrorz:Could not verify something that was supposed to be signed.Nr5 r r r r r@ � r6 r@ c @ r3 )�PeerVerifyErrorz#The peer rejected our verify error.Nr5 r r r r rA � r6 rA c @ r3 )�CertificateErrorz<We did not find a certificate where we expected to find one.Nr5 r r r r rB � r6 rB �WSAECONNREFUSEDc C sr t | t�r | j}n| }z|\}}W n ty t| d� Y S w ttd�r.t | tj�r.t}nt � |t�}|||�S )z2Given a socket exception, return connection error.)r1 �gaierror) � isinstancer0 r � ValueErrorr- �hasattr�socketrD r7 � errnoMapping�get)�er �numberr1 �klassr r r �getConnectError� s � rN c @ r& )�ConnectionClosedz@ Connection was closed, whether cleanly or non-cleanly. Nr( r r r r rO � r) rO c @ r )�ConnectionLostzF Connection to the other side was lost in a non-clean fashion r c C sL | j �� �� d d� }| jr |�d� |�d�| j�� |�d� d�|�S )N� r2 r �.r. )r �strip� splitlinesr �appendr r r r r r � s zConnectionLost.__str__Nr r r r r rP � s rP c @ � e Zd ZdZdZdS )�ConnectionAbortedz� Connection was aborted locally, using L{twisted.internet.interfaces.ITCPTransport.abortConnection}. @since: 11.1 zBConnection was aborted locally using ITCPTransport.abortConnectionNr5 r r r r rW � s rW c @ r )�ConnectionDonez Connection was closed cleanlyr c C r r r r r r r r � r zConnectionDone.__str__Nr r r r r rX � r rX c @ rV )�FileDescriptorOverrunaw A mis-use of L{IUNIXTransport.sendFileDescriptor} caused the connection to be closed. Each file descriptor sent using C{sendFileDescriptor} must be associated with at least one byte sent using L{ITransport.write}. If at any point fewer bytes have been written than file descriptors have been sent, the connection is closed with this exception. zRA mis-use of IUNIXTransport.sendFileDescriptor caused the connection to be closed.Nr5 r r r r rY � s �rY c @ r3 )�ConnectionFdescWentAway�UhNr5 r r r r rZ � r6 rZ c @ r )� AlreadyCalledz'Tried to cancel an already-called eventr c C r r r r r r r r r zAlreadyCalled.__str__Nr r r r r r\ � r r\ c @ r )�AlreadyCancelledz*Tried to cancel an already-cancelled eventr c C r r r r r r r r r zAlreadyCancelled.__str__Nr r r r r r] r r] c @ rV )�PotentialZombieWarningz� Emitted when L{IReactorProcess.spawnProcess} is called in a way which may result in termination of the created child process not being reported. Deprecated in Twisted 10.0. z�spawnProcess called, but the SIGCHLD handler is not installed. This probably means you have not yet called reactor.run, or called reactor.run(installSignalHandler=0). You will probably never see this process finish, and it may become a zombie process.Nr5 r r r r r^ s �r^ �Twisted� z4There is no longer any potential for zombie process.c @ s e Zd Zd ZZdd� ZdS )� ProcessDonez+A process has ended without apparent errorsc C s" t �| d� d| _d | _|| _d S )Nz!process finished with exit code 0r )r0 r �exitCode�signal�status)r rd r r r r 0 s zProcessDone.__init__N�r r r r r r r r r r ra - s ra c @ s e Zd Zd ZZddd�ZdS )�ProcessTerminatedz� A process has ended with a probable error condition @ivar exitCode: See L{__init__} @ivar signal: See L{__init__} @ivar status: See L{__init__} Nc C sN || _ || _|| _d}|dur|d| }|dur |d| }t�| |� dS )a� @param exitCode: The exit status of the process. This is roughly like the value you might pass to L{os._exit}. This is L{None} if the process exited due to a signal. @type exitCode: L{int} or L{None} @param signal: The exit signal of the process. This is L{None} if the process did not exit due to a signal. @type signal: L{int} or L{None} @param status: The exit code of the process. This is a platform specific combination of the exit code and the exit signal. See L{os.WIFEXITED} and related functions. @type status: L{int} z process endedNz with exit code %sz by signal %s)rb rc rd r0 r )r rb rc rd r r r r r @ s zProcessTerminated.__init__)NNNre r r r r rf 7 s rf c @ r& )�ProcessExitedAlreadyzd The process has already exited and the operation requested can no longer be performed. Nr( r r r r rg [ r) rg c @ r )�NotConnectingErrorzEThe Connector was not connecting when it was asked to stop connectingr c C r r r r r r r r g r zNotConnectingError.__str__Nr r r r r rh b s �rh c @ r )�NotListeningErrorz>The Port was not listening when it was asked to stop listeningr c C r r r r r r r r r r zNotListeningError.__str__Nr r r r r ri o r ri c @ r& )�ReactorNotRunningzJ Error raised when trying to stop a reactor which is not running. Nr( r r r r rj z r) rj c @ r& )�ReactorNotRestartablezF Error raised when trying to run a reactor which was stopped. Nr( r r r r rk � r) rk c @ r& )�ReactorAlreadyRunningzG Error raised when trying to start the reactor multiple times. Nr( r r r r rl � r) rl c @ r& )� ReactorAlreadyInstalledErrorzE Could not install reactor because one is already installed. Nr( r r r r rm � r) rm c @ � e Zd ZdZdd� ZdS )�ConnectingCancelledErrorz� An C{Exception} that will be raised when an L{IStreamClientEndpoint} is cancelled before it connects. @ivar address: The L{IAddress} that is the destination of the cancelled L{IStreamClientEndpoint}. c C s t �| |� || _dS )z� @param address: The L{IAddress} that is the destination of the L{IStreamClientEndpoint} that was cancelled. N)r0 r �address)r rp r r r r � s z!ConnectingCancelledError.__init__N�r r r r r r r r r ro � � ro c @ r& )� NoProtocolz� An C{Exception} that will be raised when the factory given to a L{IStreamClientEndpoint} returns L{None} from C{buildProtocol}. Nr( r r r r rs � r) rs c @ r& )�UnsupportedAddressFamilyz� An attempt was made to use a socket with an address family (eg I{AF_INET}, I{AF_INET6}, etc) which is not supported by the reactor. Nr( r r r r rt � r) rt c @ r& )�UnsupportedSocketTypez� An attempt was made to use a socket of a type (eg I{SOCK_STREAM}, I{SOCK_DGRAM}, etc) which is not supported by the reactor. Nr( r r r r ru � r) ru c @ r& )�AlreadyListenedzd An attempt was made to listen on a file descriptor which can only be listened on once. Nr( r r r r rv � r) rv c @ rn )�InvalidAddressErrorz� An invalid address was specified (i.e. neither IPv4 or IPv6, or expected one and got the other). @ivar address: See L{__init__} @ivar message: See L{__init__} c C s || _ || _dS )z� @param address: The address that was provided. @type address: L{bytes} @param message: A native string of additional information provided by the calling context. @type address: L{str} N)rp �message)r rp rx r r r r � s z InvalidAddressError.__init__Nrq r r r r rw � rr rw )(r r r' r* r+ r, r- r4 r7 r8 r9 r: r; r< r= r> r? r@ rA rB rN rO rP rX rZ r\ r] r^ ra rf rg rh ri rj rl rm ro rt ru rw )Er rH � incrementalr �twisted.pythonr r0 r r r' r* �IOErrorr+ r, r- r4 r7 r8 r9 r: r; r< r= r> r? r@ rA rB �errno� ENETUNREACH� ECONNREFUSED� ETIMEDOUTrI rG rC �WSAENETUNREACH� ImportErrorrN rO rP rW rX rY rZ rF r\ r] �Warningr^ �deprecatedModuleAttributer ra rf rg � RuntimeErrorrh ri rj rk rl �AssertionErrorrm ro rs rt ru rv rw �__all__r r r r �<module> s� � � � � $ PK Mb�Z�{�by y . internet/__pycache__/tksupport.cpython-310.pycnu �[��� o �b� � @ s\ d Z ddlmZ ddlmZ ddlmZ da ddd�Z dd� Z d d � Z dd d �Z ddgZdS )a� This module integrates Tkinter with twisted.internet's mainloop. Maintainer: Itamar Shtull-Trauring To use, do:: | tksupport.install(rootWidget) and then run your reactor as usual - do *not* call Tk's mainloop(), use Twisted's regular mechanism for running the event loop. Likewise, to stop your program you will need to stop Twisted's event loop. For example, if you want closing your root widget to stop Twisted:: | root.protocol('WM_DELETE_WINDOW', reactor.stop) When using Aqua Tcl/Tk on macOS the standard Quit menu item in your application might become unresponsive without the additional fix:: | root.createcommand("::tk::mac::Quit", reactor.stop) @see: U{Tcl/TkAqua FAQ for more info<http://wiki.tcl.tk/12987>} � N)�task� c C s& t � t�| j�at�|d d� dS )z/Install a Tkinter.Tk() object into the reactor.g @�@FN)�installTkFunctionsr � LoopingCall�update�_task�start)�widget�ms�reactor� r �</usr/lib/python3/dist-packages/twisted/internet/tksupport.py�install( s r c C s t �� da dS )zdRemove the root Tk widget from the reactor. Call this before destroy()ing the root widget. N)r �stopr r r r � uninstall0 s r c C s dd l } t| jj_d S )Nr )�twisted.python.util� getPassword�python�util)�twistedr r r r : s r � c C sD t jd| dd�}|s |S t jdddd�}||kr|S t�dd� q)N� zPassword Dialog�*)�showzConfirm PasswordzPassword Mismatchz&Passwords did not match, starting over)�tkSimpleDialog� askstring� tkMessageBox� showerror)�prompt�confirm�try1�try2r r r r @ s ��r )r N)r r )�__doc__�tkinter.messagebox� messageboxr �tkinter.simpledialog� simpledialogr �twisted.internetr r r r r r �__all__r r r r �<module> s PK Mb�Zf��� � * internet/__pycache__/_idna.cpython-310.pycnu �[��� o �b� � @ s, d Z dedefdd�Zdedefdd�ZdS ) z� Shared interface to IDNA encoding and decoding, using the C{idna} PyPI package if available, otherwise the stdlib implementation. �text�returnc C �4 zddl }W n ty | �d� Y S w |�| �S )a Convert some text typed by a human into some ASCII bytes. This is provided to allow us to use the U{partially-broken IDNA implementation in the standard library <http://bugs.python.org/issue17305>} if the more-correct U{idna <https://pypi.python.org/pypi/idna>} package is not available; C{service_identity} is somewhat stricter about this. @param text: A domain name, hopefully. @type text: L{unicode} @return: The domain name's IDNA representation, encoded as bytes. @rtype: L{bytes} � N�idna)r � ImportError�encode)r r � r �8/usr/lib/python3/dist-packages/twisted/internet/_idna.py� _idnaBytes s � r �octetsc C r )a Convert some IDNA-encoded octets into some human-readable text. Currently only used by the tests. @param octets: Some bytes representing a hostname. @type octets: L{bytes} @return: A human-readable domain name. @rtype: L{unicode} r Nr )r r �decode)r r r r r � _idnaText" s � r N)�__doc__�str�bytesr r r r r r �<module> s PK Mb�ZĜ&-< < / internet/__pycache__/_sslverify.cpython-310.pycnu �[��� o �b\ � @ s� d dl Z d dlmZ d dlmZ d dlmZ d dlmZm Z d dl m Z m Z d dl mZ d dlZd dlmZmZmZmZ d d lmZ d d lmZmZ d d lm Z d d l m Z m Z d d l m!Z!m"Z"m#Z#m$Z$ d dl%m&Z&m'Z' d dl(m)Z) d dl*m+Z+m,Z, d dl-m.Z. d dl/m0Z0 ddl1m2Z2 G dd� de�Z3e3j4e j5e3j6e j7e3j8e j9e3j:e j;e3j<e=e dd �iZ>dd� Z?G dd� de@�ZAd d � ZBd d � ZCd d!� ZDd"d#� ZEeE� \ZFZGZHG d$d%� d%e�ZIeIjJeIjJA eI_Kd&d'� ZLd(d(d)d)d*d*d+d+d,d,d-d-d.d/� ZMG d0d1� d1eN�ZOeOZPG d2d3� d3�ZQd4d5� ZRG d6d7� d7eQ�ZSG d8d9� d9eQ�ZTG d:d;� d;eS�ZUG d<d=� d=�ZVG d>d?� d?eV�ZWG d@dA� dAe�ZXe eX�G dBdC� dC��ZYdDdE� ZZe eX�G dFdG� dG��Z[dHdI� Z\dJdK� Z]e e#�G dLdM� dM��Z^ dkddN�dOdP�Z_e e$�G dQdR� dR��Z`e,edSdTd d �dU�e`ja�e`_ae,edSdTd d �dU�e`jb�e`_be e"�ejcdVdVdW�G dXdY� dY���ZdedZd[�d\d]� �Zeed^d[�d_d`� �Zfe e!�G dadb� db��Zgeg�hdc�ZiddZjG dedf� df�ZkG dgdh� dh�Zldidj� ZmdS )l� N)�hexlify)� lru_cache��md5)� Interface� implementer)�SSL�crypto)�lib)� FlagConstant�Flags� NamedConstant�Names)�Version)� isIPAddress� isIPv6Address)�Deferred)�CertificateError� VerifyError)�IAcceptableCiphers�ICipher� IOpenSSLClientConnectionCreator�IOpenSSLContextFactory)�log�util)� nativeString)�_mutuallyExclusiveArguments� deprecated)�Failure)� secureRandom� )� _idnaBytesc @ s. e Zd ZdZe� Ze� Ze� Ze� Ze� Z dS )� TLSVersionzD TLS versions that we can negotiate with the client/server. N) �__name__� __module__� __qualname__�__doc__r �SSLv3�TLSv1_0�TLSv1_1�TLSv1_2�TLSv1_3� r, r, �=/usr/lib/python3/dist-packages/twisted/internet/_sslverify.pyr" & s r" � OP_NO_TLSv1_3c C sR t t�� �}dd� |d|�| �� D �}|r'|�dd� ||�|�d� D �� |S )a� Given a pair of L{TLSVersion} constants, figure out what versions we want to disable (as OpenSSL is an exclusion based API). @param oldest: The oldest L{TLSVersion} we want to allow. @type oldest: L{TLSVersion} constant @param newest: The newest L{TLSVersion} we want to allow, or L{None} for no upper limit. @type newest: L{TLSVersion} constant or L{None} @return: The versions we want to disable. @rtype: L{list} of L{TLSVersion} constants. c S � g | ]}|�qS r, r, ��.0�xr, r, r- � <listcomp>N � z,_getExcludedTLSProtocols.<locals>.<listcomp>Nc S r/ r, r, r0 r, r, r- r3 Q r4 )�listr" � iterconstants�index�extend)�oldest�newest�versions�excludedVersionsr, r, r- �_getExcludedTLSProtocols> s "r= c @ s e Zd ZdZdS )�SimpleVerificationErrorz/ Not a very useful verification error. N)r# r$ r% r& r, r, r, r- r> V s r> c C s2 | � � �� j}||krtt|�d t|� ��dS )a� Check only the common name in the certificate presented by the peer and only for an exact match. This is to provide I{something} in the way of hostname verification to users who haven't installed C{service_identity}. This check is overly strict, relies on a deprecated TLS feature (you're supposed to ignore the commonName if the subjectAlternativeName extensions are present, I believe), and lots of valid certificates will fail. @param connection: the OpenSSL connection to verify. @type connection: L{OpenSSL.SSL.Connection} @param hostname: The hostname expected by the user. @type hostname: L{unicode} @raise twisted.internet.ssl.VerificationError: if the common name and hostname don't match. z!=N)�get_peer_certificate� get_subject� commonNamer> �repr)� connection�hostnamerA r, r, r- �simpleVerifyHostname\ s �rE c C � t d��)a5 Always fails validation of IP addresses @param connection: the OpenSSL connection to verify. @type connection: L{OpenSSL.SSL.Connection} @param hostname: The hostname expected by the user. @type hostname: L{unicode} @raise twisted.internet.ssl.VerificationError: Always raised z&Cannot verify certificate IP addresses)r> )rC rD r, r, r- �simpleVerifyIPAddressu s rG c C s, dd� | � d�dd� D �\}}||fdkS )z� Check pyOpenSSL version string whether we can use it for host verification. @param version: A pyOpenSSL version string. @type version: L{str} @rtype: L{bool} c s � � | ]}t |�V qd S �N)�int)r1 �partr, r, r- � <genexpr>� � � z#_usablePyOpenSSL.<locals>.<genexpr>�.N� )r � )�split)�version�major�minorr, r, r- �_usablePyOpenSSL� s rU c C s~ d} zddl m} ddlm}m} |||fW S ty9 } ztjdt|� d | t ddd� W Y d }~nd }~ww t t t fS ) a Determine if C{service_identity} is installed. If so, use it. If not, use simplistic and incorrect checking as implemented in L{simpleVerifyHostname}. @return: 2-tuple of (C{verify_hostname}, C{VerificationError}) @rtype: L{tuple} z�Without the service_identity module, Twisted can perform only rudimentary TLS client hostname verification. Many valid certificate/hostname mappings may be rejected.r )�VerificationError)�verify_hostname�verify_ip_addresszHYou do not have a working installation of the service_identity module: 'z�'. Please install it from <https://pypi.python.org/pypi/service_identity> and make sure all of its dependencies are satisfied. � )�category�filename�linenoN) �service_identityrV �service_identity.pyopensslrW rX � ImportError�warnings� warn_explicit�str� UserWarningrE rG r> )� whatsWrongrV rW rX �er, r, r- �_selectVerifyImplementation� s, � ������ rf c @ s e Zd ZdZed�Zed�ZdS )�ProtocolNegotiationSupporta� L{ProtocolNegotiationSupport} defines flags which are used to indicate the level of NPN/ALPN support provided by the TLS backend. @cvar NOSUPPORT: There is no support for NPN or ALPN. This is exclusive with both L{NPN} and L{ALPN}. @cvar NPN: The implementation supports Next Protocol Negotiation. @cvar ALPN: The implementation supports Application Layer Protocol Negotiation. r rO N)r# r$ r% r& r �NPN�ALPNr, r, r, r- rg � s rg c C s� t j} t�tj�}z |�dd� � W n ttfy Y nw | t jO } z |� dd� � W n ttfy8 Y | S w | t j O } | S )ay Checks whether your versions of PyOpenSSL and OpenSSL are recent enough to support protocol negotiation, and if they are, what kind of protocol negotiation is supported. @return: A combination of flags from L{ProtocolNegotiationSupport} that indicate which mechanisms for protocol negotiation are supported. @rtype: L{constantly.FlagConstant} c S � d S rI r, ��cr, r, r- �<lambda>� � z/protocolNegotiationMechanisms.<locals>.<lambda>c S rj rI r, rk r, r, r- rm � rn ) rg � NOSUPPORTr �Context� SSLv23_METHOD�set_npn_advertise_callback�AttributeError�NotImplementedErrorrh �set_alpn_select_callbackri )�support�ctxr, r, r- � protocolNegotiationMechanisms� s � � rx rA �organizationName�organizationalUnitName� localityName�stateOrProvinceName� countryName� emailAddress) �CNrA �Ory �OUrz �Lr{ �STr| �Cr} r~ c @ sR e Zd ZdZdZdd� Zdd� Zdd� Zd efd d �Z d d � Z dd� Z dd� Z dS )�DistinguishedNameag Identify and describe an entity. Distinguished names are used to provide a minimal amount of identifying information about a certificate issuer or subject. They are commonly created with one or more of the following fields:: commonName (CN) organizationName (O) organizationalUnitName (OU) localityName (L) stateOrProvinceName (ST) countryName (C) emailAddress A L{DistinguishedName} should be constructed using keyword arguments whose keys can be any of the field names above (as a native string), and the values are either Unicode text which is encodable to ASCII, or L{bytes} limited to the ASCII subset. Any fields passed to the constructor will be set as attributes, accessible using both their extended name and their shortened acronym. The attribute values will be the ASCII-encoded bytes. For example:: >>> dn = DistinguishedName(commonName=b'www.example.com', ... C='US') >>> dn.C b'US' >>> dn.countryName b'US' >>> hasattr(dn, "organizationName") False L{DistinguishedName} instances can also be used as dictionaries; the keys are extended name of the fields:: >>> dn.keys() ['countryName', 'commonName'] >>> dn['countryName'] b'US' r, c K s" |� � D ] \}}t| ||� qd S rI )�items�setattr)�self�kw�k�vr, r, r- �__init__1 s �zDistinguishedName.__init__c C s. t D ]}t||d �}|d urt| ||� qd S rI )� _x509names�getattrr� )r� �x509name�name�valuer, r, r- � _copyFrom5 s ��zDistinguishedName._copyFromc C s& | � � D ] \}}t||t|�� qd S rI )r� r� r )r� r� r� r� r, r, r- � _copyInto; s �zDistinguishedName._copyInto�returnc C s dt �| �dd� S )Nz<DN %s>r ���)�dict�__repr__�r� r, r, r- r� ? s zDistinguishedName.__repr__c C s& z| t | W S ty t|��w rI )r� �KeyErrorrs )r� �attrr, r, r- � __getattr__B s �z DistinguishedName.__getattr__c C s> |t vr t|� d���t | }t|t�s|�d�}|| |< d S )Nz' is not a valid OpenSSL X509 name field�ascii)r� rs � isinstance�bytes�encode)r� r� r� �realAttrr, r, r- � __setattr__H s z DistinguishedName.__setattr__c C s� g }d}dd� }t |t��D ]!}t�|�}tt|�|�}t| |d�}|dur/|�|t|�f� q|d7 }t |�D ]\}\}}|� |�d | ||< q8d� |�S )zh Return a multi-line, human-readable representation of this DN. @rtype: L{str} r c S s t | �� �S rI )�set�values)�mappingr, r, r- � uniqueValuesY � z/DistinguishedName.inspect.<locals>.uniqueValuesNrO z: � ) �sortedr� r � nameToLabel�max�lenr� �appendr � enumerate�rjust�join) r� �l�lablenr� r� �labelr� �n�attribr, r, r- �inspectP s � zDistinguishedName.inspectN) r# r$ r% r& � __slots__r� r� r� rb r� r� r� r� r, r, r, r- r� s * r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �CertBasez� Base class for public (certificate only) and private (certificate + key pair) certificates. @ivar original: The underlying OpenSSL certificate object. @type original: L{OpenSSL.crypto.X509} c C � || _ d S rI ��original)r� r� r, r, r- r� t � zCertBase.__init__c C s" t � }|�t| jd| �� � |S )N�get_)r� r� r� r� )r� �suffix�dnr, r, r- � _copyNamew s zCertBase._copyNamec C � | � d�S )z� Retrieve the subject of this certificate. @return: A copy of the subject of this certificate. @rtype: L{DistinguishedName} �subject�r� r� r, r, r- � getSubject| � zCertBase.getSubjectc C s |t u r t| jg�S tS )aM Convert this L{CertBase} into a provider of the given interface. @param interface: The interface to conform to. @type interface: L{zope.interface.interfaces.IInterface} @return: an L{IOpenSSLTrustRoot} provider or L{NotImplemented} @rtype: L{IOpenSSLTrustRoot} or L{NotImplemented} )�IOpenSSLTrustRoot� OpenSSLCertificateAuthoritiesr� �NotImplemented)r� � interfacer, r, r- � __conform__� s zCertBase.__conform__N)r# r$ r% r& r� r� r� r� r, r, r, r- r� k s r� c C sV t |�� d|� d�d�}|du rtd�||���|� }|du r'td�||���| |�S )a (private) Helper for L{Certificate.peerFromTransport} and L{Certificate.hostFromTransport} which checks for incompatible handle types and null certificates and raises the appropriate exception or returns the appropriate certificate object. r� � _certificateNz2non-TLS transport {!r} did not have {} certificatez.TLS transport {!r} did not have {} certificate)r� � getHandler �format)�Class� transport� methodName�method�certr, r, r- �_handleattrhelper� s ����r� c @ s� e Zd ZdZdefdd�Zdedefdd�Ze e j dfd d ��Z e Z d d � Ze d d� �Ze dd� �Ze dd� �Zdd� Ze j fdd�Zdd� Zd%dd�Zd d � Zd d � Zd d!� Zd"d#� Zd$S )&� Certificatez An x509 certificate. r� c C s d� | jj| �� j| �� j�S )Nz<{} Subject={} Issuer={}>)r� � __class__r# r� rA � getIssuerr� r, r, r- r� � s �zCertificate.__repr__�otherc C s t |t�r | �� |�� kS tS rI )r� r� �dumpr� )r� r� r, r, r- �__eq__� s zCertificate.__eq__r, c C s | t �||�g|�R � S )zc Load a certificate from an ASN.1- or PEM-format string. @rtype: C{Class} )r �load_certificate)r� � requestDatar� �argsr, r, r- �load� s zCertificate.loadc C s | � tj�S )z\ Dump this certificate to a PEM-format data string. @rtype: L{str} )r� r � FILETYPE_PEMr� r, r, r- �dumpPEM� s zCertificate.dumpPEMc C s | � |tj�S )z] Load a certificate from a PEM-format data string. @rtype: C{Class} )r� r r� �r� �datar, r, r- �loadPEM� s zCertificate.loadPEMc C � t | |d�S )a Get the certificate for the remote end of the given transport. @param transport: an L{ISystemHandle} provider @rtype: C{Class} @raise CertificateError: if the given transport does not have a peer certificate. �peer�r� �r� r� r, r, r- �peerFromTransport� � z Certificate.peerFromTransportc C r� )a Get the certificate for the local end of the given transport. @param transport: an L{ISystemHandle} provider; the transport we will @rtype: C{Class} @raise CertificateError: if the given transport does not have a host certificate. �hostr� r� r, r, r- �hostFromTransport� r� z Certificate.hostFromTransportc C s t | j�� �S )zX Get the public key for this certificate. @rtype: L{PublicKey} )� PublicKeyr� � get_pubkeyr� r, r, r- � getPublicKey� s zCertificate.getPublicKeyc C � t �|| j�S rI )r �dump_certificater� �r� r� r, r, r- r� � � zCertificate.dumpc C s | j �� S )zY Retrieve the serial number of this certificate. @rtype: L{int} )r� �get_serial_numberr� r, r, r- � serialNumber � zCertificate.serialNumberr c C s | j �|�S )a Return a digest hash of this certificate using the specified hash algorithm. @param method: One of C{'md5'} or C{'sha'}. @return: The digest of the object, formatted as b":"-delimited hex pairs @rtype: L{bytes} )r� �digest)r� r� r, r, r- r� s zCertificate.digestc C s: d� d| �� �� d| �� �� d| �� dt| �� � g�S )Nr� zCertificate For Subject:z Issuer:z Serial Number: %dz Digest: %s)r� r� r� r� r� r r� r� r, r, r- �_inspect s ��zCertificate._inspectc C s d� | �� | �� �� f�S )z� Return a multi-line, human-readable representation of this Certificate, including information about the subject, issuer, and public key. r� )r� r� r� r� r� r, r, r- r� # s zCertificate.inspectc C r� )z� Retrieve the issuer of this certificate. @rtype: L{DistinguishedName} @return: A copy of the issuer of this certificate. �issuerr� r� r, r, r- r� + r� zCertificate.getIssuerc G rF )Nz'Possible, but doubtful we need this yet)rt )r� � authoritiesr, r, r- �options4 s zCertificate.optionsNr )r# r$ r% r& rb r� �object�boolr� � classmethodr � FILETYPE_ASN1r� �_loadr� r� r� r� r� r� r� r� r� r� r� r� r, r, r, r- r� � s, r� c @ s0 e Zd ZdZeejfdd��Zejfdd�ZdS )�CertificateRequestz� An x509 certificate request. Certificate requests are given to certificate authorities to be signed and returned resulting in an actual certificate. c C sF t �||�}t� }|�|�� � |�|�� �s td|�d���| |�S )Nz Can't verify that request for z is self-signed.)r �load_certificate_requestr� r� r@ �verifyr� r )r� r� � requestFormat�reqr� r, r, r- r� @ s zCertificateRequest.loadc C r� rI )r �dump_certificate_requestr� r� r, r, r- r� I r� zCertificateRequest.dumpN) r# r$ r% r& r� r r� r� r� r, r, r, r- r� 8 s r� c @ s� e Zd ZdZdefdd�Zdd� Zejfdd�Z e ejfd d ��Z d d � Z d d� Z e dd� �Ze dd� �Zdd� Zejdfdd�Zejejfdd�Z d dd �Zd S ) �PrivateCertificatez. An x509 certificate and private key. r� c C s t �| �d t| j� S )Nz with )r� r� rB � privateKeyr� r, r, r- r� R s zPrivateCertificate.__repr__c C s |� | �� �s td��|| _| S )Nz1Certificate public and private keys do not match.)�matchesr� r r )r� r r, r, r- �_setPrivateKeyU s z!PrivateCertificate._setPrivateKeyc C s | � || j|�S )z} Create a new L{PrivateCertificate} from the given certificate data and this instance's private key. )r� r �r� � newCertDatar� r, r, r- �newCertificate[ s z!PrivateCertificate.newCertificatec C � | � ||��|�S rI )r� r )r� r� r r� r, r, r- r� b s zPrivateCertificate.loadc C s d� t�| �| j�� g�S )Nr� )r� r� r� r r� r� r, r, r- r� f � zPrivateCertificate.inspectc C s | � tj�| j� tj� S )zi Dump both public and private parts of a private certificate to PEM-format data. )r� r r� r r� r, r, r- r� i s �zPrivateCertificate.dumpPEMc C s | � |t� |tj�tj�S )zv Load both private and public parts of a private certificate from a chunk of PEM-format data. )r� �KeyPairr r� r� r, r, r- r� r s �zPrivateCertificate.loadPEMc C s | |j �}|�|�S rI )r� r )r� �certificateInstancer �privcertr, r, r- �fromCertificateAndKeyPair| s z,PrivateCertificate.fromCertificateAndKeyPairc G sB t | jj| jd�}|r|�t tdd� |D ��d�� tdi |��S )a$ Create a context factory using this L{PrivateCertificate}'s certificate and private key. @param authorities: A list of L{Certificate} object @return: A context factory. @rtype: L{CertificateOptions <twisted.internet.ssl.CertificateOptions>} �r � certificatec S s g | ]}|j �qS r, r� )r1 �authr, r, r- r3 � s z.PrivateCertificate.options.<locals>.<listcomp>)� trustRootNr, )r� r r� �updater� �OpenSSLCertificateOptions)r� r� r� r, r, r- r� � s ���zPrivateCertificate.options�sha256c C s | j �| �� ||�S rI )r �certificateRequestr� )r� r� �digestAlgorithmr, r, r- r � s �z%PrivateCertificate.certificateRequestc C s | � � }| j�||||||�S rI )r� r �signCertificateRequest)r� r� �verifyDNCallbackr� r �certificateFormatr� r, r, r- r � s �z)PrivateCertificate.signCertificateRequest�3�c C s | j �| �� ||||�S rI )r �signRequestObjectr� )r� r r� �secondsToExpiryr r, r, r- r � s �z$PrivateCertificate.signRequestObjectN�r r )r# r$ r% r& rb r� r r r� r r� r� r� r� r� r r� r r r r, r, r, r- r M s* ��r c @ s> e Zd ZdZdd� Zdd� Zdefdd�Zd d � Zd d � Z d S )r� an A L{PublicKey} is a representation of the public part of a key pair. You can't do a whole lot with it aside from comparing it to other L{PublicKey} objects. @note: If constructing a L{PublicKey} manually, be sure to pass only a L{OpenSSL.crypto.PKey} that does not contain a private key! @ivar original: The original private key. c C � || _ dS )zv @param osslpkey: The underlying pyOpenSSL key object. @type osslpkey: L{OpenSSL.crypto.PKey} Nr� )r� �osslpkeyr, r, r- r� � s zPublicKey.__init__c C s | � � |� � kS )a Does this L{PublicKey} contain the same value as another L{PublicKey}? @param otherKey: The key to compare C{self} to. @type otherKey: L{PublicKey} @return: L{True} if these keys match, L{False} if not. @rtype: L{bool} ��keyHash)r� �otherKeyr, r, r- r � s zPublicKey.matchesr� c C s d| j j� d| �� � d�S )N�<� �>)r� r# r$ r� r, r, r- r� � r zPublicKey.__repr__c C s( t �t j| j�}t� }|�|� |�� S )at Compute a hash of the underlying PKey object. The purpose of this method is to allow you to determine if two certificates share the same public key; it is not really useful for anything else. In versions of Twisted prior to 15.0, C{keyHash} used a technique involving certificate requests for computing the hash that was not stable in the face of changes to the underlying OpenSSL library. @return: Return a 32-character hexadecimal string uniquely identifying this public key, I{for this version of Twisted}. @rtype: native L{str} )r �dump_publickeyr� r� r r � hexdigest)r� �raw�hr, r, r- r$ � s zPublicKey.keyHashc C s d| � � � �S )NzPublic Key with Hash: r# r� r, r, r- r� � r� zPublicKey.inspectN) r# r$ r% r& r� r rb r� r$ r� r, r, r, r- r� � s r� c @ s� e Zd Zeejfdd��Zejfdd�Zee dddd�d�d d � �Z ee dddd�d�d d � �Z d d� Z eej dfdd��Zejfdd�Zd!dd�Zejdfdd�Zejejddfdd�Z d"d d �Zd d � Zd S )#r c C s | t �||��S rI )r �load_privatekey)r� r� r� r, r, r- r� � s z KeyPair.loadc C r� rI )r �dump_privatekeyr� r� r, r, r- r� � r� z KeyPair.dump�Twisted� r �a real persistence systemc C s | � � S rI )r� r� r, r, r- � __getstate__ s zKeyPair.__getstate__c C s | � t�tj|�� d S rI )r� r r- r� �r� �stater, r, r- � __setstate__ s zKeyPair.__setstate__c C sJ | j �� }|tjkr d}n |tjkrd}nd}| j �� || �� f}d| S )N�RSA�DSAz(Unknown Type!)z %s-bit %s Key Pair with Hash: %s)r� �typer �TYPE_RSA�TYPE_DSA�bitsr$ )r� �t�tsr� r, r, r- r� s zKeyPair.inspecti c C s t �� }|�||� | |�S rI )r �PKey� generate_key)r� �kind�size�pkeyr, r, r- �generate s zKeyPair.generatec C s t �|| |�S rI )r r� r r, r, r- r r� zKeyPair.newCertificater c C s8 t �� }|�| j� |�|�� � |�| j|� t|�S rI )r �X509Req� set_pubkeyr� r� r@ �signr� )r� �distinguishedNamer r r, r, r- � requestObject s zKeyPair.requestObjectc C r )z� Create a certificate request signed with this key. @return: a string, formatted according to the 'format' argument. )rH r� )r� rG r� r r, r, r- r $ s zKeyPair.certificateRequestr c sT t �||����� ����} � ��������f dd�} t| t�r&| �| �S | | �S )a& Given a blob of certificate request data and a certificate authority's DistinguishedName, return a blob of signed certificate data. If verifyDNCallback returns a Deferred, I will return a Deferred which fires the data when that Deferred has completed. c s, | s t d���������������� �S )Nz)DN callback {!r} rejected request DN {!r})r r� r r� )r� � r r r� �hlreq�issuerDistinguishedNamer r� r� r r, r- �verifiedE s ����z0KeyPair.signCertificateRequest.<locals>.verified)r� r� r� r� r � addCallback) r� rK r� r r� r r r r �vvalrL r, rI r- r . s z KeyPair.signCertificateRequestc C sl |j }t�� }|�|�� � |�|�� � |�|�� � |� d� |� |� |� |� |� | j |� t |�S )zW Sign a CertificateRequest instance, returning a Certificate instance. r )r� r �X509r� � get_issuer� set_subjectr@ rE r� �gmtime_adj_notBefore�gmtime_adj_notAfter�set_serial_numberrF r� )r� rK rH r� r r r r� r, r, r- r Y s zKeyPair.signRequestObjectc K s* t di |��}t�| �|| �|�|�| �S )Nr, )�DNr r r rH )r� r� r� r� r, r, r- �selfSignedCerto s �zKeyPair.selfSignedCertN)r r )r# r$ r% r� r r� r� r� r r r2 r5 r� r9 rC r rH r r r rV r, r, r, r- r � s0 � �0 � r c @ � e Zd ZdZdd� ZdS )r� z� Trust settings for an OpenSSL context. Note that this interface's methods are private, so things outside of Twisted shouldn't implement it. c C � dS )aI Add certificate-authority certificates to an SSL context whose connections should trust those authorities. @param context: An SSL context for a connection which should be verified by some certificate authority. @type context: L{OpenSSL.SSL.Context} @return: L{None} Nr, )�contextr, r, r- �_addCACertsToContext~ rn z&IOpenSSLTrustRoot._addCACertsToContextN�r# r$ r% r& rZ r, r, r, r- r� v s r� c @ s e Zd ZdZdd� Zdd� ZdS )r� zy Trust an explicitly specified set of certificates, represented by a list of L{OpenSSL.crypto.X509} objects. c C r! )z� @param caCerts: The certificate authorities to trust when using this object as a C{trustRoot} for L{OpenSSLCertificateOptions}. @type caCerts: L{list} of L{OpenSSL.crypto.X509} N)�_caCerts)r� �caCertsr, r, r- r� � r� z&OpenSSLCertificateAuthorities.__init__c C s" |� � }| jD ]}|�|� qd S rI )�get_cert_storer\ �add_cert)r� rY �storer� r, r, r- rZ � s �z2OpenSSLCertificateAuthorities._addCACertsToContextN)r# r$ r% r& r� rZ r, r, r, r- r� � s r� c C s: g }| D ]}t |t�r|j}ntd��|�|� qt|�S )a Builds an object that trusts multiple root L{Certificate}s. When passed to L{optionsForClientTLS}, connections using those options will reject any server certificate not signed by at least one of the certificates in the `certificates` list. @since: 16.0 @param certificates: All certificates which will be trusted. @type certificates: C{iterable} of L{CertBase} @rtype: L{IOpenSSLTrustRoot} @return: an object suitable for use as the trustRoot= keyword argument to L{optionsForClientTLS} zBcertificates items must be twisted.internet.ssl.CertBase instances)r� r� r� � TypeErrorr� r� )� certificates�certsr� r, r, r- �trustRootFromCertificates� s � rd c @ rW )�OpenSSLDefaultPathsz� Trust the set of default verify paths that OpenSSL was built with, as specified by U{SSL_CTX_set_default_verify_paths <https://www.openssl.org/docs/man1.1.1/man3/SSL_CTX_load_verify_locations.html>}. c C s |� � d S rI )�set_default_verify_paths)r� rY r, r, r- rZ � r� z(OpenSSLDefaultPaths._addCACertsToContextNr[ r, r, r, r- re � s re c C s t � S )aD Attempt to discover a set of trusted certificate authority certificates (or, in other words: trust roots, or root certificates) whose trust is managed and updated by tools outside of Twisted. If you are writing any client-side TLS code with Twisted, you should use this as the C{trustRoot} argument to L{CertificateOptions <twisted.internet.ssl.CertificateOptions>}. The result of this function should be like the up-to-date list of certificates in a web browser. When developing code that uses C{platformTrust}, you can think of it that way. However, the choice of which certificate authorities to trust is never Twisted's responsibility. Unless you're writing a very unusual application or library, it's not your code's responsibility either. The user may use platform-specific tools for defining which server certificates should be trusted by programs using TLS. The purpose of using this API is to respect that decision as much as possible. This should be a set of trust settings most appropriate for I{client} TLS connections; i.e. those which need to verify a server's authenticity. You should probably use this by default for any client TLS connection that you create. For servers, however, client certificates are typically not verified; or, if they are, their verification will depend on a custom, application-specific certificate authority. @since: 14.0 @note: Currently, L{platformTrust} depends entirely upon your OpenSSL build supporting a set of "L{default verify paths <OpenSSLDefaultPaths>}" which correspond to certificate authority trust roots. Unfortunately, whether this is true of your system is both outside of Twisted's control and difficult (if not impossible) for Twisted to detect automatically. Nevertheless, this ought to work as desired by default on: - Ubuntu Linux machines with the U{ca-certificates <https://launchpad.net/ubuntu/+source/ca-certificates>} package installed, - macOS when using the system-installed version of OpenSSL (i.e. I{not} one installed via MacPorts or Homebrew), - any build of OpenSSL which has had certificate authority certificates installed into its default verify paths (by default, C{/usr/local/ssl/certs} if you've built your own OpenSSL), or - any process where the C{SSL_CERT_FILE} environment variable is set to the path of a file containing your desired CA certificates bundle. Hopefully soon, this API will be updated to use more sophisticated trust-root discovery mechanisms. Until then, you can follow tickets in the Twisted tracker for progress on this implementation on U{Microsoft Windows <https://twistedmatrix.com/trac/ticket/6371>}, U{macOS <https://twistedmatrix.com/trac/ticket/6372>}, and U{a fallback for other platforms which do not have native trust management tools <https://twistedmatrix.com/trac/ticket/6934>}. @return: an appropriate trust settings object for your platform. @rtype: L{IOpenSSLTrustRoot} @raise NotImplementedError: if this platform is not yet supported by Twisted. At present, only OpenSSL is supported. )re r, r, r, r- � platformTrust� s Crg c s � fdd�}|S )a- Wrap up an C{info_callback} for pyOpenSSL so that if something goes wrong the error is immediately logged and the connection is dropped if possible. This wrapper exists because some versions of pyOpenSSL don't handle errors from callbacks at I{all}, and those which do write tracebacks directly to stderr rather than to a supplied logging system. This reports unexpected errors to the Twisted logging system. Also, this terminates the connection immediately if possible because if you've got bugs in your verification logic it's much safer to just give up. @param wrapped: A valid C{info_callback} for pyOpenSSL. @type wrapped: L{callable} @return: A valid C{info_callback} for pyOpenSSL that handles any errors in C{wrapped}. @rtype: L{callable} c sD z� | ||�W S t y! t� }t�|d� | �� �|� Y d S w )NzError during info_callback)� BaseExceptionr r �err� get_app_data�failVerification)rC �where�ret�f��wrappedr, r- � infoCallback& s �z%_tolerateErrors.<locals>.infoCallbackr, )rp rq r, ro r- �_tolerateErrors s rr c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �ClientTLSOptionsa Client creator for TLS. Private implementation type (not exposed to applications) for public L{optionsForClientTLS} API. @ivar _ctx: The context to use for new connections. @type _ctx: L{OpenSSL.SSL.Context} @ivar _hostname: The hostname to verify, as specified by the application, as some human-readable text. @type _hostname: L{unicode} @ivar _hostnameBytes: The hostname to verify, decoded into IDNA-encoded bytes. This is passed to APIs which think that hostnames are bytes, such as OpenSSL's SNI implementation. @type _hostnameBytes: L{bytes} @ivar _hostnameASCII: The hostname, as transcoded into IDNA ASCII-range unicode code points. This is pre-transcoded because the C{service_identity} package is rather strict about requiring the C{idna} package from PyPI for internationalized domain names, rather than working with Python's built-in (but sometimes broken) IDNA encoding. ASCII values, however, will always work. @type _hostnameASCII: L{unicode} @ivar _hostnameIsDnsName: Whether or not the C{_hostname} is a DNSName. Will be L{False} if C{_hostname} is an IP address or L{True} if C{_hostname} is a DNSName @type _hostnameIsDnsName: L{bool} c C sb || _ || _t|�st|�r|�d�| _d| _nt|�| _d| _| j�d�| _ |� t | j �� dS )a Initialize L{ClientTLSOptions}. @param hostname: The hostname to verify as input by a human. @type hostname: L{unicode} @param ctx: an L{OpenSSL.SSL.Context} to use for new connections. @type ctx: L{OpenSSL.SSL.Context}. r� FTN) �_ctx� _hostnamer r r� �_hostnameBytes�_hostnameIsDnsNamer! �decode�_hostnameASCII�set_info_callbackrr � _identityVerifyingInfoCallback)r� rD rw r, r, r- r� S s zClientTLSOptions.__init__c C s | j }t�|d�}|�|� |S )ap Create a TLS connection for a client. @note: This will call C{set_app_data} on its connection. If you're delegating to this implementation of this method, don't ever call C{set_app_data} or C{set_info_callback} on the returned connection, or you'll break the implementation of various features of this class. @param tlsProtocol: the TLS protocol initiating the connection. @type tlsProtocol: L{twisted.protocols.tls.TLSMemoryBIOProtocol} @return: the configured client connection. @rtype: L{OpenSSL.SSL.Connection} N)rt r � Connection� set_app_data)r� � tlsProtocolrY rC r, r, r- �clientConnectionForTLSj s z'ClientTLSOptions.clientConnectionForTLSc C s� |t j@ r| jr|�| j� dS |t j@ rAz| jr"t|| j� W dS t|| j� W dS t y@ t � }|� � }|� |� Y dS w dS )a U{info_callback <http://pythonhosted.org/pyOpenSSL/api/ssl.html#OpenSSL.SSL.Context.set_info_callback> } for pyOpenSSL that verifies the hostname in the presented certificate matches the one passed to this L{ClientTLSOptions}. @param connection: the connection which is handshaking. @type connection: L{OpenSSL.SSL.Connection} @param where: flags indicating progress through a TLS handshake. @type where: L{int} @param ret: ignored @type ret: ignored N) r �SSL_CB_HANDSHAKE_STARTrw �set_tlsext_host_namerv �SSL_CB_HANDSHAKE_DONE�verifyHostnamery �verifyIPAddressrV r rj rk )r� rC rl rm rn r� r, r, r- r{ s ��z/ClientTLSOptions._identityVerifyingInfoCallbackN)r# r$ r% r& r� r r{ r, r, r, r- rs 1 s rs )�extraCertificateOptionsc C sn |du ri }|du r t � }t| t�std| jj ��|r&|j|jj|jd� t d||d�|��}t | |� � �S )a� Create a L{client connection creator <IOpenSSLClientConnectionCreator>} for use with APIs such as L{SSL4ClientEndpoint <twisted.internet.endpoints.SSL4ClientEndpoint>}, L{connectSSL <twisted.internet.interfaces.IReactorSSL.connectSSL>}, and L{startTLS <twisted.internet.interfaces.ITLSTransport.startTLS>}. @since: 14.0 @param hostname: The expected name of the remote host. This serves two purposes: first, and most importantly, it verifies that the certificate received from the server correctly identifies the specified hostname. The second purpose is to use the U{Server Name Indication extension <https://en.wikipedia.org/wiki/Server_Name_Indication>} to indicate to the server which certificate should be used. @type hostname: L{unicode} @param trustRoot: Specification of trust requirements of peers. This may be a L{Certificate} or the result of L{platformTrust}. By default it is L{platformTrust} and you probably shouldn't adjust it unless you really know what you're doing. Be aware that clients using this interface I{must} verify the server; you cannot explicitly pass L{None} since that just means to use L{platformTrust}. @type trustRoot: L{IOpenSSLTrustRoot} @param clientCertificate: The certificate and private key that the client will use to authenticate to the server. If unspecified, the client will not authenticate. @type clientCertificate: L{PrivateCertificate} @param acceptableProtocols: The protocols this peer is willing to speak after the TLS negotiation has completed, advertised over both ALPN and NPN. If this argument is specified, and no overlap can be found with the other peer, the connection will fail to be established. If the remote peer does not offer NPN or ALPN, the connection will be established, but no protocol wil be negotiated. Protocols earlier in the list are preferred over those later in the list. @type acceptableProtocols: L{list} of L{bytes} @param extraCertificateOptions: A dictionary of additional keyword arguments to be presented to L{CertificateOptions}. Please avoid using this unless you absolutely need to; any time you need to pass an option here that is a bug in this interface. @type extraCertificateOptions: L{dict} @return: A client connection creator. @rtype: L{IOpenSSLClientConnectionCreator} Nz6optionsForClientTLS requires text for host names, not r )r �acceptableProtocolsr, ) rg r� rb ra r� r# r r r� r rs � getContext)rD r �clientCertificater� r� �certificateOptionsr, r, r- �optionsForClientTLS� s, 8 �����r� c @ s� e Zd ZdZejZdZee j Z e j Z eddgddgddgddgdd gd dgdd gg� ddd��Zdd� Zdd� Zdd� Zdd� ZdS )r a� A L{CertificateOptions <twisted.internet.ssl.CertificateOptions>} specifies the security properties for a client or server TLS connection used with OpenSSL. @ivar _options: Any option flags to set on the L{OpenSSL.SSL.Context} object that will be created. @type _options: L{int} @ivar _cipherString: An OpenSSL-specific cipher string. @type _cipherString: L{unicode} @ivar _defaultMinimumTLSVersion: The default TLS version that will be negotiated. This should be a "safe default", with wide client and server support, vs an optimally secure one that excludes a large number of users. As of late 2016, TLSv1.0 is that safe default. @type _defaultMinimumTLSVersion: L{TLSVersion} constant Nr �requireCertificater r] r� �insecurelyLowerMinimumTo�raiseMinimumTo�lowerMaximumSecurityToF� Tc C sX |du |du kr t d��|| _|| _tjtjB tjB | _tj| _ |du rhtj | _ |r;|r4||kr4t d��|| j kr;|}|du rJ| j }|rJ||krJ|}|rT||krTt d��t ||�}|D ] }| jt| O _q[n tjdtdd� || _ |r{|s{t d��|| _| dur�d||fv r�t d ��| dur�| | _ng | _|| _|| _|| _|| _| | _| r�| jtjtjB O _| | _| | _ | r�| jtj O _| | _ | s�| jtj O _|| _ t!tj"t#t$d �| _%|du r�t&}d �'d d � |�(t)d| j | j��D ��| _*| j*dkr�t d��|du �r | j�r t+|�}n d| _d| _t,|�}|| _-|du�r't.� �s't/d��|| _0dS )a� Create an OpenSSL context SSL connection context factory. @param privateKey: A PKey object holding the private key. @param certificate: An X509 object holding the certificate. @param method: Deprecated, use a combination of C{insecurelyLowerMinimumTo}, C{raiseMinimumTo}, or C{lowerMaximumSecurityTo} instead. The SSL protocol to use, one of C{SSLv23_METHOD}, C{SSLv2_METHOD}, C{SSLv3_METHOD}, C{TLSv1_METHOD} (or any other method constants provided by pyOpenSSL). By default, a setting will be used which allows TLSv1.0, TLSv1.1, and TLSv1.2. Can not be used with C{insecurelyLowerMinimumTo}, C{raiseMinimumTo}, or C{lowerMaximumSecurityTo} @param verify: Please use a C{trustRoot} keyword argument instead, since it provides the same functionality in a less error-prone way. By default this is L{False}. If L{True}, verify certificates received from the peer and fail the handshake if verification fails. Otherwise, allow anonymous sessions and sessions with certificates which fail validation. @param caCerts: Please use a C{trustRoot} keyword argument instead, since it provides the same functionality in a less error-prone way. List of certificate authority certificate objects to use to verify the peer's certificate. Only used if verify is L{True} and will be ignored otherwise. Since verify is L{False} by default, this is L{None} by default. @type caCerts: L{list} of L{OpenSSL.crypto.X509} @param verifyDepth: Depth in certificate chain down to which to verify. If unspecified, use the underlying default (9). @param requireCertificate: Please use a C{trustRoot} keyword argument instead, since it provides the same functionality in a less error-prone way. If L{True}, do not allow anonymous sessions; defaults to L{True}. @param verifyOnce: If True, do not re-verify the certificate on session resumption. @param enableSingleUseKeys: If L{True}, generate a new key whenever ephemeral DH and ECDH parameters are used to prevent small subgroup attacks and to ensure perfect forward secrecy. @param enableSessions: This allows a shortened handshake to be used when a known client reconnects to the same process. If True, enable OpenSSL's session caching. Note that session caching only works on a single Twisted node at once. Also, it is currently somewhat risky due to U{a crashing bug when using OpenSSL 1.1.1 <https://twistedmatrix.com/trac/ticket/9764>}. @param fixBrokenPeers: If True, enable various non-spec protocol fixes for broken SSL implementations. This should be entirely safe, according to the OpenSSL documentation, but YMMV. This option is now off by default, because it causes problems with connections between peers using OpenSSL 0.9.8a. @param enableSessionTickets: If L{True}, enable session ticket extension for session resumption per RFC 5077. Note there is no support for controlling session tickets. This option is off by default, as some server implementations don't correctly process incoming empty session ticket extensions in the hello. @param extraCertChain: List of certificates that I{complete} your verification chain if the certificate authority that signed your C{certificate} isn't widely supported. Do I{not} add C{certificate} to it. @type extraCertChain: C{list} of L{OpenSSL.crypto.X509} @param acceptableCiphers: Ciphers that are acceptable for connections. Uses a secure default if left L{None}. @type acceptableCiphers: L{IAcceptableCiphers} @param dhParameters: Key generation parameters that are required for Diffie-Hellman key exchange. If this argument is left L{None}, C{EDH} ciphers are I{disabled} regardless of C{acceptableCiphers}. @type dhParameters: L{DiffieHellmanParameters <twisted.internet.ssl.DiffieHellmanParameters>} @param trustRoot: Specification of trust requirements of peers. If this argument is specified, the peer is verified. It requires a certificate, and that certificate must be signed by one of the certificate authorities specified by this object. Note that since this option specifies the same information as C{caCerts}, C{verify}, and C{requireCertificate}, specifying any of those options in combination with this one will raise a L{TypeError}. @type trustRoot: L{IOpenSSLTrustRoot} @param acceptableProtocols: The protocols this peer is willing to speak after the TLS negotiation has completed, advertised over both ALPN and NPN. If this argument is specified, and no overlap can be found with the other peer, the connection will fail to be established. If the remote peer does not offer NPN or ALPN, the connection will be established, but no protocol wil be negotiated. Protocols earlier in the list are preferred over those later in the list. @type acceptableProtocols: L{list} of L{bytes} @param raiseMinimumTo: The minimum TLS version that you want to use, or Twisted's default if it is higher. Use this if you want to make your client/server more secure than Twisted's default, but will accept Twisted's default instead if it moves higher than this value. You probably want to use this over C{insecurelyLowerMinimumTo}. @type raiseMinimumTo: L{TLSVersion} constant @param insecurelyLowerMinimumTo: The minimum TLS version to use, possibly lower than Twisted's default. If not specified, it is a generally considered safe default (TLSv1.0). If you want to raise your minimum TLS version to above that of this default, use C{raiseMinimumTo}. DO NOT use this argument unless you are absolutely sure this is what you want. @type insecurelyLowerMinimumTo: L{TLSVersion} constant @param lowerMaximumSecurityTo: The maximum TLS version to use. If not specified, it is the most recent your OpenSSL supports. You only want to set this if the peer that you are communicating with has problems with more recent TLS versions, it lowers your security when communicating with newer peers. DO NOT use this argument unless you are absolutely sure this is what you want. @type lowerMaximumSecurityTo: L{TLSVersion} constant @raise ValueError: when C{privateKey} or C{certificate} are set without setting the respective other. @raise ValueError: when C{verify} is L{True} but C{caCerts} doesn't specify any CA certificates. @raise ValueError: when C{extraCertChain} is passed without specifying C{privateKey} or C{certificate}. @raise ValueError: when C{acceptableCiphers} doesn't yield any usable ciphers for the current platform. @raise TypeError: if C{trustRoot} is passed in combination with C{caCert}, C{verify}, or C{requireCertificate}. Please prefer C{trustRoot} in new code, as its semantics are less tricky. @raise TypeError: if C{method} is passed in combination with C{tlsProtocols}. Please prefer the more explicit C{tlsProtocols} in new code. @raises NotImplementedError: If acceptableProtocols were provided but no negotiation mechanism is available. Nz5Specify neither or both of privateKey and certificatez<raiseMinimumTo needs to be lower than lowerMaximumSecurityTozFinsecurelyLowerMinimumTo needs to be lower than lowerMaximumSecurityToz�Passing method to twisted.internet.ssl.CertificateOptions was deprecated in Twisted 17.1.0. Please use a combination of insecurelyLowerMinimumTo, raiseMinimumTo, and lowerMaximumSecurityTo instead, as Twisted will correctly configure the method.� )� stacklevelzZSpecify client CA certificate information if and only if enabling certificate verificationzZA private key and a certificate are required when adding a supplemental certificate chain.)� openSSLlib� openSSLcrypto�:c s s � | ]}|j V qd S rI )�fullName)r1 rl r, r, r- rL 4 s � � �z5OpenSSLCertificateOptions.__init__.<locals>.<genexpr>�ALLrY zGSupplied IAcceptableCiphers yielded no usable ciphers on this platform.Tz5No support for protocol negotiation on this platform.)1� ValueErrorr r r � OP_NO_SSLv2�OP_NO_COMPRESSION�OP_CIPHER_SERVER_PREFERENCE�_options�MODE_RELEASE_BUFFERS�_moderq r� �_defaultMinimumTLSVersionr= �_tlsDisableFlagsr` �warn�DeprecationWarningr �extraCertChainr] � verifyDepthr� � verifyOnce�enableSingleUseKeys�OP_SINGLE_DH_USE�OP_SINGLE_ECDH_USE�enableSessions�fixBrokenPeers�OP_ALL�enableSessionTickets� OP_NO_TICKET� dhParameters�!_ChooseDiffieHellmanEllipticCurve�OPENSSL_VERSION_NUMBER� pyOpenSSLlibr � _ecChooser�defaultCiphersr� � selectCiphers�_expandCipherString� _cipherStringr� r� r rx rt �_acceptableProtocols)r� r r r� r r] r� r� r� r� r� r� r� r� �acceptableCiphersr� r r� r� r� r� r< rR r, r, r- r� s� :� � ������ ��� � � � �� z"OpenSSLCertificateOptions.__init__c C s, | j �� }z|d= W |S ty Y |S w )N�_context)�__dict__�copyr� )r� �dr, r, r- r2 P s ��z&OpenSSLCertificateOptions.__getstate__c C r� rI )r� r3 r, r, r- r5 X r� z&OpenSSLCertificateOptions.__setstate__c C s | j du r | �� | _ | j S )z: Return an L{OpenSSL.SSL.Context} object. N)r� � _makeContextr� r, r, r- r� [ s z$OpenSSLCertificateOptions.getContextc C sV | � | j�}|�| j� |�| j� | jd ur7| jd ur7|�| j� |� | j� | j D ]}|� |� q+|� � t j}| jrVt j}| jrH|t jO }| jrP|t jO }| j�|� dd� }|�||� | jd urk|�| j� ttd��}|� |� | j r�|� t j � n|� t j � | j!r�|�"| j!j#j$� |�%| j&�'d�� | j(�)|� | j*r�t+|| j*� |S )Nc S s |S rI r, )�connr� �errno�depth� preverify_okr, r, r- �_verifyCallback| � z?OpenSSLCertificateOptions._makeContext.<locals>._verifyCallback� r� ),�_contextFactoryr� � set_optionsr� �set_moder� r r �use_certificate�use_privatekeyr� �add_extra_chain_cert�check_privatekeyr � VERIFY_NONEr � VERIFY_PEERr� �VERIFY_FAIL_IF_NO_PEER_CERTr� �VERIFY_CLIENT_ONCEr rZ � set_verifyr� �set_verify_depthr r �set_session_idr� �set_session_cache_mode�SESS_CACHE_SERVER�SESS_CACHE_OFFr� � load_tmp_dh�_dhFile�path�set_cipher_listr� r� r� �configureECDHCurver� �_setAcceptableProtocols)r� rw � extraCert� verifyFlagsr� �sessionIDContextr, r, r- r� c sB z&OpenSSLCertificateOptions._makeContext)NNNFNr� TTTFFFNNNNNNNN)r# r$ r% r& r rp r� r� r� r" r+ �_OP_NO_TLSv1_3r( r� r r� r2 r5 r� r� r, r, r, r- r � sV �� � = r r/ r0 r1 T)�frozen� auto_attribsc @ s e Zd ZU dZeed< dS )� OpenSSLCipherz� A representation of an OpenSSL cipher. @ivar fullName: The full name of the cipher. For example C{u"ECDHE-RSA-AES256-GCM-SHA384"}. @type fullName: L{unicode} r� N)r# r$ r% r& rb �__annotations__r, r, r, r- r� � s r� � )�maxsizec C s� t �|�}|�|� z |�| �d�� W n0 t jyD } z#|jd s+t� W Y d}~S |jd d d dkr?t� W Y d}~S � d}~ww t �|d�}|� � }t |d t �r_tdd� |D ��S tdd� |D ��S ) ah Expand C{cipherString} according to C{method} and C{options} to a tuple of explicit ciphers that are supported by the current platform. @param cipherString: An OpenSSL cipher string to expand. @type cipherString: L{unicode} @param method: An OpenSSL method like C{SSL.TLSv1_METHOD} used for determining the effective ciphers. @param options: OpenSSL options like C{SSL.OP_NO_SSLv3} ORed together. @type options: L{int} @return: The effective list of explicit ciphers that results from the arguments on the current platform. @rtype: L{tuple} of L{ICipher} r� r NrO zno cipher matchc s rH rI )r� �r1 �cipherr, r, r- rL � rM z&_expandCipherString.<locals>.<genexpr>c s s � | ] }t |�d ��V qdS )r� N)r� rx r� r, r, r- rL � s � ) r rp r� r� r� �Errorr� �tupler| �get_cipher_listr� rb )� cipherStringr� r� rw re r� �ciphersr, r, r- r� � s" �� r� � c s t � fdd�| D ��S )a� Caclulate the acceptable list of ciphers from the ciphers we want and the ciphers we have support for. @param wantedCiphers: The ciphers we want to use. @type wantedCiphers: L{tuple} of L{OpenSSLCipher} @param availableCiphers: The ciphers we have available to use. @type availableCiphers: L{tuple} of L{OpenSSLCipher} @rtype: L{tuple} of L{OpenSSLCipher} c 3 s � | ] }|� v r|V qd S rI r, r� ��availableCiphersr, r- rL � s � z!_selectCiphers.<locals>.<genexpr>)r� )� wantedCiphersr� r, r� r- �_selectCiphers� s r� c @ s, e Zd ZdZdd� Zdd� Zedd� �ZdS ) �OpenSSLAcceptableCipherszN A representation of ciphers that are acceptable for TLS connections. c C s t |�| _d S rI )r� �_ciphers)r� r� r, r, r- r� � r� z!OpenSSLAcceptableCiphers.__init__c C s t | jt|��S rI )r� r� r� )r� r� r, r, r- r� � s z&OpenSSLAcceptableCiphers.selectCiphersc C s | t t|�tjtjtjB ��S )aR Create a new instance using an OpenSSL cipher string. @param cipherString: An OpenSSL cipher string that describes what cipher suites are acceptable. See the documentation of U{OpenSSL <http://www.openssl.org/docs/apps/ciphers.html#CIPHER_STRINGS>} or U{Apache <http://httpd.apache.org/docs/2.4/mod/mod_ssl.html#sslciphersuite>} for details. @type cipherString: L{unicode} @return: Instance representing C{cipherString}. @rtype: L{twisted.internet.ssl.AcceptableCiphers} )r� r r rq r� � OP_NO_SSLv3)�clsr� r, r, r- �fromOpenSSLCipherString s ��z0OpenSSLAcceptableCiphers.fromOpenSSLCipherStringN)r# r$ r% r& r� r� r� r� r, r, r, r- r� � s r� z�TLS13-AES-256-GCM-SHA384:TLS13-CHACHA20-POLY1305-SHA256:TLS13-AES-128-GCM-SHA256:ECDH+AESGCM:ECDH+CHACHA20:DH+AESGCM:DH+CHACHA20:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:RSA+AESGCM:RSA+AES:!aNULL:!MD5:!DSS� prime256v1c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) r� a Chooses the best elliptic curve for Elliptic Curve Diffie-Hellman key exchange, and provides a C{configureECDHCurve} method to set the curve, when appropriate, on a new L{OpenSSL.SSL.Context}. The C{configureECDHCurve} method will be set to one of the following based on the provided OpenSSL version and configuration: - L{_configureOpenSSL110} - L{_configureOpenSSL102} - L{_configureOpenSSL101} - L{_configureOpenSSL101NoCurves}. @param openSSLVersion: The OpenSSL version number. @type openSSLVersion: L{int} @see: L{OpenSSL.SSL.OPENSSL_VERSION_NUMBER} @param openSSLlib: The OpenSSL C{cffi} library module. @param openSSLcrypto: The OpenSSL L{crypto} module. @see: L{crypto} c C sn || _ || _|dkr| j| _d S |dkr| j| _d S z|�t�| _W n ty0 | j | _Y d S w | j | _d S )Ni i ) � _openSSLlib�_openSSLcrypto�_configureOpenSSL110r� �_configureOpenSSL102�get_elliptic_curve�_defaultCurveName�_ecCurver� � _configureOpenSSL101NoCurves�_configureOpenSSL101)r� �openSSLVersionr� r� r, r, r- r� P s � z*_ChooseDiffieHellmanEllipticCurve.__init__c C rX )z� OpenSSL 1.1.0 Contexts are preconfigured with an optimal set of ECDH curves. This method does nothing. @param ctx: L{OpenSSL.SSL.Context} Nr, �r� rw r, r, r- r� a rn z6_ChooseDiffieHellmanEllipticCurve._configureOpenSSL110c C s0 |j }z | j�|d� W dS ty Y dS w )a Have the context automatically choose elliptic curves for ECDH. Run on OpenSSL 1.0.2 and OpenSSL 1.1.0+, but only has an effect on OpenSSL 1.0.2. @param ctx: The context which . @type ctx: L{OpenSSL.SSL.Context} TN)r� r� �SSL_CTX_set_ecdh_autorh )r� rw �ctxPtrr, r, r- r� i s �z6_ChooseDiffieHellmanEllipticCurve._configureOpenSSL102c C s( z |� | j� W dS ty Y dS w )z� Set the default elliptic curve for ECDH on the context. Only run on OpenSSL 1.0.1. @param ctx: The context on which to set the ECDH curve. @type ctx: L{OpenSSL.SSL.Context} N)� set_tmp_ecdhr� rh r r, r, r- r� x s �z6_ChooseDiffieHellmanEllipticCurve._configureOpenSSL101c C rX )z� No elliptic curves are available on OpenSSL 1.0.1. We can't set anything, so do nothing. @param ctx: The context on which to set the ECDH curve. @type ctx: L{OpenSSL.SSL.Context} Nr, r r, r, r- r� � rn z>_ChooseDiffieHellmanEllipticCurve._configureOpenSSL101NoCurvesN) r# r$ r% r& r� r� r� r� r� r, r, r, r- r� 4 s r� c @ s$ e Zd ZdZdd� Zedd� �ZdS )� OpenSSLDiffieHellmanParameterszn A representation of key generation parameters that are required for Diffie-Hellman key exchange. c C r� rI )r� )r� � parametersr, r, r- r� � r� z'OpenSSLDiffieHellmanParameters.__init__c C s | |�S )a� Load parameters from a file. Such a file can be generated using the C{openssl} command line tool as following: C{openssl dhparam -out dh_param_2048.pem -2 2048} Please refer to U{OpenSSL's C{dhparam} documentation <http://www.openssl.org/docs/apps/dhparam.html>} for further details. @param filePath: A file containing parameters for Diffie-Hellman key exchange. @type filePath: L{FilePath <twisted.python.filepath.FilePath>} @return: An instance that loads its parameters from C{filePath}. @rtype: L{DiffieHellmanParameters <twisted.internet.ssl.DiffieHellmanParameters>} r, )r� �filePathr, r, r- �fromFile� s z'OpenSSLDiffieHellmanParameters.fromFileN)r# r$ r% r& r� r� r r, r, r, r- r � s r c sj � fdd�}� s dS t � }|tj@ r"� fdd�}| �|� | �|� |tj@ r3| �|� | �� � dS dS )a� Called to set up the L{OpenSSL.SSL.Context} for doing NPN and/or ALPN negotiation. @param context: The context which is set up. @type context: L{OpenSSL.SSL.Context} @param acceptableProtocols: The protocols this peer is willing to speak after the TLS negotiation has completed, advertised over both ALPN and NPN. If this argument is specified, and no overlap can be found with the other peer, the connection will fail to be established. If the remote peer does not offer NPN or ALPN, the connection will be established, but no protocol wil be negotiated. Protocols earlier in the list are preferred over those later in the list. @type acceptableProtocols: L{list} of L{bytes} c s. t |�t � �@ }� D ] }||v r| S q dS )at NPN client-side and ALPN server-side callback used to select the next protocol. Prefers protocols found earlier in C{_acceptableProtocols}. @param conn: The context which is set up. @type conn: L{OpenSSL.SSL.Connection} @param conn: Protocols advertised by the other side. @type conn: L{list} of L{bytes} � )r� )r� � protocols�overlap�p�r� r, r- �protoSelectCallback� s �z4_setAcceptableProtocols.<locals>.protoSelectCallbackNc s � S rI r, )r� r r, r- �npnAdvertiseCallback� r� z5_setAcceptableProtocols.<locals>.npnAdvertiseCallback)rx rg rh rr �set_npn_select_callbackri ru �set_alpn_protos)rY r� r � supportedr r, r r- r� � s �r� )NNN)nr` �binasciir � functoolsr �hashlibr �zope.interfacer r �OpenSSLr r � OpenSSL._utilr r� r� � constantlyr r r r � incrementalr �twisted.internet.abstractr r �twisted.internet.deferr �twisted.internet.errorr r �twisted.internet.interfacesr r r r �twisted.pythonr r �twisted.python.compatr �twisted.python.deprecater r �twisted.python.failurer �twisted.python.randbytesr �_idnar! r" r' r� r( � OP_NO_TLSv1r) � OP_NO_TLSv1_1r* � OP_NO_TLSv1_2r+ r� r� r= � Exceptionr> rE rG rU rf r� r� rV rg rh ro rx r� r� r� rU r� r� r� r� r r� r r� r� rd re rg rr rs r� r r2 r5 �sr� r� r� r� r� r� r� r� r r� r, r, r, r- �<module> s� � ( � �d) p<} F o� �N 9���� ) 4�[ !PK Mb�Z��� ! ! 1 internet/__pycache__/_pollingfile.cpython-310.pycnu �[��� o �bW" � @ s� d Z ddlmZ ddlmZmZ dZdZG dd� d�ZG dd � d �Z dd l Z dd l Z dd l Z dd l Z ee�G d d � d e��Zd Zee�G dd� de��Zd S )z� Implements a simple polling interface for file descriptors that don't work with select() - this is pretty much only useful on Windows. � )� implementer)� IConsumer� IPushProducerg��&� .>g�������?c @ s e Zd ZdZdd� Zdd� ZdS )�_PollableResourceTc C � d| _ d S �NT��active��self� r �?/usr/lib/python3/dist-packages/twisted/internet/_pollingfile.py�activate � z_PollableResource.activatec C r �NFr r r r r � deactivate r z _PollableResource.deactivateN)�__name__� __module__� __qualname__r r r r r r r r s r c @ sT e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dS )� _PollingTimerc C s" || _ g | _d | _t| _d| _d S r )�reactor� _resources� _pollTimer� MAX_TIMEOUT�_currentTimeout�_paused)r r r r r �__init__ s z_PollingTimer.__init__c C s | j �|� | �� d S �N)r �append�_checkPollingState)r �resr r r �_addPollableResource' s z"_PollingTimer._addPollableResourcec C s, | j D ] }|jr| �� d S q| �� d S r )r r � _startPolling� _stopPolling)r �resourcer r r r + s � z _PollingTimer._checkPollingStatec C s | j d u r | �� | _ d S d S r )r � _rescheduler r r r r" 3 s �z_PollingTimer._startPollingc C s" | j d ur| j �� d | _ d S d S r )r �cancelr r r r r# 7 s �z_PollingTimer._stopPollingc C r r )r r r r r �_pause< r z_PollingTimer._pausec C s d| _ | �� d S r )r r r r r r �_unpause? s z_PollingTimer._unpausec C s | j s | j�| j| j�S d S r )r r � callLaterr � _pollEventr r r r r% C s �z_PollingTimer._reschedulec C s� d}g }| j D ]}|jr||�� 7 }|jr|�|� q| j}|r.| j|d }|tk r-t}n | jd }|tkr9t}|| _|rE| �� | _d S d S )Ng g �?g @) r r � checkWorkr r � MIN_TIMEOUTr r% r )r � workUnits� anyActiver$ � newTimeoutr r r r* G s* �� �z_PollingTimer._pollEventN) r r r r r! r r" r# r' r( r% r* r r r r r s r Nc @ sD e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dS )�_PollableReadPipec C s || _ || _|| _d S r )�pipe�receivedCallback� lostCallback)r r1 r2 r3 r r r r j s z_PollableReadPipe.__init__c C s� d}g } z t �| jd�\}}}|sW n t�| j|d �\}}|�|� W n tjy0 d}Y nw qd�|�}|r>| � |� |rD| � � t |�S )Nr � � ) � win32pipe� PeekNamedPiper1 � win32file�ReadFiler �win32api�error�joinr2 �cleanup�len) r �finished� fullDataRead�buffer� bytesToRead�result�hr�data�dataBufr r r r+ p s( �� z_PollableReadPipe.checkWorkc C s | � � | �� d S r )r r3 r r r r r= � s z_PollableReadPipe.cleanupc C s* z t �| j� W d S tjy Y d S w r )r: � CloseHandler1 � pywintypesr; r r r r �close� s �z_PollableReadPipe.closec C � | � � d S r )rI r r r r � stopProducing� � z _PollableReadPipe.stopProducingc C rJ r )r r r r r �pauseProducing� rL z _PollableReadPipe.pauseProducingc C rJ r )r r r r r �resumeProducing� rL z!_PollableReadPipe.resumeProducingN) r r r r r+ r= rI rK rM rN r r r r r0 h s r0 i c @ s\ e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dS )�_PollableWritePipec C sZ d| _ d | _d| _d| _g | _|| _|| _z t�|tj d d � W d S t j y, Y d S w )NFr ) � disconnecting�producer�producerPaused�streamingProducer�outQueue� writePiper3 r6 �SetNamedPipeHandleState� PIPE_NOWAITrH r; )r rU r3 r r r r � s ��z_PollableWritePipe.__init__c C r r )rP r r r r rI � r z_PollableWritePipe.closec C s" | j d urd| _| j �� d S d S r )rQ rR rM r r r r � bufferFull� s �z _PollableWritePipe.bufferFullc C s0 | j d ur| jr | jrd| j _| j �� dS dS )NFT)rQ rS rR rN r r r r � bufferEmpty� s �� z _PollableWritePipe.bufferEmptyc C sN | j durtd|| j f ��| js|�� dS || _ || _|s%|�� dS dS )aw Register to receive data from a producer. This sets this selectable to be a consumer for a producer. When this selectable runs out of data on a write() call, it will ask the producer to resumeProducing(). A producer should implement the IProducer interface. FileDescriptor provides some infrastructure for producer methods. NzHCannot register producer %s, because producer %s was never unregistered.)rQ � RuntimeErrorr rK rS rN )r rQ � streamingr r r �registerProducer� s �� �z#_PollableWritePipe.registerProducerc C s d| _ dS )z;Stop consuming data from a producer, without disconnecting.N)rQ r r r r �unregisterProducer� s z%_PollableWritePipe.unregisterProducerc C s: | � � zt�| j� W n tjy Y nw | �� d S r )r r: rG rU rH r; r3 r r r r �writeConnectionLost� s � z&_PollableWritePipe.writeConnectionLostc C s& t tt|�v r td��| j�|� dS )z� Append a C{list} or C{tuple} of bytes to the output buffer. @param seq: C{list} or C{tuple} of C{str} instances to be appended to the output buffer. @raise TypeError: If C{seq} contains C{unicode}. �%Unicode not allowed in output buffer.N)�str�map�type� TypeErrorrT �extend)r �seqr r r � writeSequence� s z _PollableWritePipe.writeSequencec C sL t |t�r td��| jrdS | j�|� ttt| j��t kr$| � � dS dS )z� Append some bytes to the output buffer. @param data: C{str} to be appended to the output buffer. @type data: C{str}. @raise TypeError: If C{data} is C{unicode} instead of C{str}. r_ N) � isinstancer` rc rP rT r �sumra r> �FULL_BUFFER_SIZErX )r rE r r r �write� s �z_PollableWritePipe.writec C s� d}| j s)| jr| �� dS z t�| jdd � W n tjy( | �� | Y S w | j rk| j �d�}d}z t�| j|d �\}}W n t jyO | �� Y |S w ||7 }t |�|krh| j � d||d � � |S | j s,| � � }|sx| jrx| �� |S )Nr r5 ) rT rP r^ r8 � WriteFilerU rH r; �popr: r> �insertrY )r �numBytesWrittenrE �errCode� nBytesWritten�resumedr r r r+ s> � � � z _PollableWritePipe.checkWorkN) r r r r rI rX rY r\ r] r^ rf rj r+ r r r r rO � s rO )�__doc__�zope.interfacer �twisted.internet.interfacesr r r, r r r rH r: r8 r6 r0 ri rO r r r r �<module> s E3PK Mb�Z��y� � , internet/__pycache__/default.cpython-310.pycnu �[��� o �be � @ s* d Z dgZddlmZ dd� Zee�ZdS )z� The most suitable default reactor for the current platform. Depending on a specific application's needs, some other reactor may in fact be better. �install� )�platformc C s� z<| � � r!z ddlm} W W |S ty ddlm} Y W |S w | �� dkr4| �� s4ddlm} W |S ddlm} W |S tyL ddlm} Y |S w )a' Return a function to install the reactor most suited for the given platform. @param platform: The platform for which to select a reactor. @type platform: L{twisted.python.runtime.Platform} @return: A zero-argument callable which will install the selected reactor. r )r �posix)�isLinux� twisted.internet.epollreactorr � ImportError� twisted.internet.pollreactor�getType�isMacOSX� twisted.internet.selectreactor)r r � r �:/usr/lib/python3/dist-packages/twisted/internet/default.py�_getInstallFunction s$ ��� ��r N)�__doc__�__all__�twisted.python.runtimer r r r r r r �<module> s %PK Mb�Z]t��� � 1 internet/__pycache__/_baseprocess.cpython-310.pycnu �[��� o �b� � @ sV d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z dZ G dd � d �Z d S ) zd Cross-platform process-related functionality used by different L{IReactorProcess} implementations. � )�Optional)�getWarningMethod)�Failure)�err)�qualzUSince Twisted 8.2, IProcessProtocol.processExited is required. %s must implement it.c @ sV e Zd ZU dZee ed< dZee ed< dZdZ dd� Z dd� Z d d � Z d d � Z dS ) � BaseProcessN�pid�statusr c C s || _ d S )N)�proto)�self�protocol� r �?/usr/lib/python3/dist-packages/twisted/internet/_baseprocess.py�__init__ s zBaseProcess.__init__c C sp t � }t| jd|�}||u r t� tt| jj�f tdd� d S z |t|�� W d S t y7 t d d� Y d S w )N� processExitedr )� stacklevelz!unexpected error in processExited) �object�getattrr r �_missingProcessExitedr � __class__�DeprecationWarningr � BaseExceptionr )r �reason�defaultr r r r �_callProcessExited s � �z BaseProcess._callProcessExitedc C s6 || _ | jd7 _d| _| �| �|�� | �� dS )z; This is called when the child terminates. � N)r � lostProcessr r � _getReason�maybeCallProcessEnded)r r r r r � processEnded/ s zBaseProcess.processEndedc C sZ | j dur+| �| j�}| j }d| _ z |�t|�� W dS ty* tdd� Y dS w dS )zD Call processEnded on protocol after final cleanup. Nz unexpected error in processEnded)r r r r r r r )r r r r r r r 9 s ��z!BaseProcess.maybeCallProcessEnded)�__name__� __module__� __qualname__r r �int�__annotations__r r r r r r r r r r r r s r N) �__doc__�typingr �twisted.python.deprecater �twisted.python.failurer �twisted.python.logr �twisted.python.reflectr r r r r r r �<module> s �PK Mb�Z�!9� 0 internet/__pycache__/gtk2reactor.cpython-310.pycnu �[��� o �b8 � @ s� d Z ddlZddlmZ ddlmZ zeed�s!ddlZe�d� W n e e fy- Y nw ddl Z ee d�r;e � � G dd � d ej �ZG d d � d ej�Zdd d�Zddd�Zej�� dkraeZneZdgZdS )a> This module provides support for Twisted to interact with the glib/gtk2 mainloop. In order to use this support, simply do the following:: from twisted.internet import gtk2reactor gtk2reactor.install() Then use twisted.internet APIs as usual. The other methods here are not intended to be called directly. � N)� _glibbase)�runtime�frozenz2.0� threads_initc @ sH e Zd ZdZejejB ejB Zej Z ej Z e eB Z e eB Zddd�ZdS )� Gtk2Reactorz& PyGTK+ 2 event loop reactor. Tc C �, d }|du r dd l }tjj| t||d� d S �NTr )�useGtk)�gtkr �GlibReactorBase�__init__�gobject��selfr �_gtk� r �>/usr/lib/python3/dist-packages/twisted/internet/gtk2reactor.pyr F � zGtk2Reactor.__init__N�T)�__name__� __module__� __qualname__�__doc__r �IO_HUP�IO_ERR�IO_NVAL�_POLL_DISCONNECTED�IO_IN�_POLL_IN�IO_OUT� _POLL_OUT�INFLAGS�OUTFLAGSr r r r r r 7 s r c @ s e Zd ZdZddd�ZdS )�PortableGtkReactorzd Reactor that works on Windows. Sockets aren't supported by GTK+'s input_add on Win32. Tc C r r )r r �PortableGlibReactorBaser r r r r r r U r zPortableGtkReactor.__init__Nr )r r r r r r r r r r# N s r# Tc C s t | �}ddlm} ||� |S )z� Configure the twisted mainloop to be run inside the gtk mainloop. @param useGtk: should glib rather than GTK+ event loop be used (this will be slightly faster but does not support GUI). r ��installReactor)r �twisted.internet.mainr& �r �reactorr& r r r �install] s r* c C s t � }ddlm} ||� |S )zK Configure the twisted mainloop to be run inside the gtk mainloop. r r% )r# r' r& r( r r r �portableInstallk s r+ �posixr )r �sys�twisted.internetr �twisted.pythonr �hasattr�pygtk�require� ImportError�AttributeErrorr r r r r$ r# r* r+ �platform�getType�__all__r r r r �<module> s. �� PK Mb�Z��q́� �� / internet/__pycache__/interfaces.cpython-310.pycnu �[��� o �b � @ sb d Z ddlmZmZmZmZmZmZmZm Z m Z m Z m Z ddl mZmZ ddlmZ er�ddlmZ z ddlmZmZ W n eyI e ZZY nw ddlm Z ddl m Z m Z m Z dd l!m"Z" dd l#m$Z$m%Z%m&Z&m'Z'm(Z( dd l)m*Z* dd l+m,Z,m-Z- dd l.m/Z/ ddl0m1Z1 e1�2� r�ddl3m4Z4 neZ4G dd� de�Z5G dd� de�Z6G dd� de�Z7G dd� de�Z8G dd� de�Z9G dd� de�Z:G d d � d e7�Z;G d d � d e�Z<G d d!� d!e�Z=G d"d#� d#e�Z>G d$d%� d%e�Z?G d&d'� d'e�Z@G d(d)� d)e�ZAG d*d+� d+e�ZBG d,d-� d-e�ZCG d.d/� d/e�ZDG d0d1� d1e�ZEG d2d3� d3e�ZFG d4d5� d5e�ZGG d6d7� d7e�ZHG d8d9� d9eGeH�ZIG d:d;� d;e�ZJG d<d=� d=e�ZKG d>d?� d?e�ZLG d@dA� dAe�ZMG dBdC� dCe�ZNG dDdE� dEe�ZOG dFdG� dGe�ZPG dHdI� dIeP�ZQG dJdK� dKeQ�ZRG dLdM� dMeQ�ZSG dNdO� dOeReS�ZTG dPdQ� dQe�ZUG dRdS� dSe�ZVG dTdU� dUe�ZWG dVdW� dWe�ZXG dXdY� dYeX�ZYG dZd[� d[eX�ZZG d\d]� d]e�Z[G d^d_� d_e�Z\G d`da� dae�Z]G dbdc� dce�Z^G ddde� dee�Z_G dfdg� dge�Z`G dhdi� die�ZaG djdk� dkea�ZbG dldm� dmea�ZcG dndo� doe�ZdG dpdq� dqe�ZeG drds� dse�ZfG dtdu� due�ZgG dvdw� dweb�ZhG dxdy� dyeb�ZiG dzd{� d{ei�ZjG d|d}� d}e�ZkG d~d� de�ZlG d�d�� d�ea�ZmG d�d�� d�e�ZnG d�d�� d�e�ZoG d�d�� d�e�ZpG d�d�� d�e�ZqG d�d�� d�e�ZrG d�d�� d�e�ZsG d�d�� d�e�ZtG d�d�� d�e�ZuG d�d�� d�e�ZvG d�d�� d�e�Zwd�S )�z> Interface documentation. Maintainer: Itamar Shtull-Trauring � ) � TYPE_CHECKING�Any�AnyStr�Callable�Iterable�List�Mapping�Optional�Sequence�Tuple�Union)� Attribute� Interface)�Failure)� AddressFamily)� Connection�Context)�FileDescriptor)� IPv4Address� IPv6Address� UNIXAddress)�Deferred)� ClientFactory�ConnectedDatagramProtocol�DatagramProtocol�Factory� ServerFactory)�ClientContextFactory)�Query�RRHeader)�TLSMemoryBIOProtocol)�platform)� ThreadPoolc @ � e Zd ZdZdS )�IAddresszr An address, e.g. a TCP C{(host, port)}. Default implementations are in L{twisted.internet.address}. N��__name__� __module__� __qualname__�__doc__� r* r* �=/usr/lib/python3/dist-packages/twisted/internet/interfaces.pyr$ < � r$ c @ s< e Zd ZdZd dd�Zd dd�Zd dd �Zdefd d �ZdS ) � IConnectorzu Object used to interface between connections and protocols. Each L{IConnector} manages one connection. �returnNc C � dS )z- Stop attempting to connect. Nr* r* r* r* r+ �stopConnectingN � zIConnector.stopConnectingc C r/ )z� Disconnect regardless of the connection state. If we are connected, disconnect, if we are trying to connect, stop trying. Nr* r* r* r* r+ � disconnectS r1 zIConnector.disconnectc C r/ )z3 Try to connect to remote address. Nr* r* r* r* r+ �connect[ r1 zIConnector.connectc C r/ )zy Return destination this will try to connect to. @return: An object which provides L{IAddress}. Nr* r* r* r* r+ �getDestination` r1 zIConnector.getDestination�r. N) r& r' r( r) r0 r2 r3 r$ r4 r* r* r* r+ r- G s r- c @ s& e Zd Zdedee ddfdd�ZdS )�IResolverSimple�name�timeoutr. � Deferred[str]c C r/ )a� Resolve the domain name C{name} into an IP address. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: The callback of the Deferred that is returned will be passed a string that represents the IP address of the specified name, or the errback will be called if the lookup times out. If multiple types of address records are associated with the name, A6 records will be returned in preference to AAAA records, which will be returned in preference to A records. If there are multiple records of the type to be returned, one will be selected at random. @raise twisted.internet.defer.TimeoutError: Raised (asynchronously) if the name cannot be resolved within the specified timeout period. Nr* �r7 r8 r* r* r+ � getHostByNamei r1 z IResolverSimple.getHostByNameN)r& r' r( �strr �intr; r* r* r* r+ r6 h s r6 c @ s" e Zd ZdZed�Zddd�ZdS )�IHostResolutionz� An L{IHostResolution} represents represents an in-progress recursive query for a DNS name. @since: Twisted 17.1.0 zB L{unicode}; the name of the host being resolved. r. Nc C r/ )z; Stop the hostname resolution in progress. Nr* r* r* r* r+ �cancel� r1 zIHostResolution.cancelr5 )r& r' r( r) r r7 r? r* r* r* r+ r> � s �r> c @ s> e Zd ZdZdeddfdd�Zdeddfdd �Zd d d �ZdS ) �IResolutionReceiverz� An L{IResolutionReceiver} receives the results of a hostname resolution in progress, initiated by an L{IHostnameResolver}. @since: Twisted 17.1.0 �resolutionInProgressr. Nc C r/ )zk A hostname resolution began. @param resolutionInProgress: an L{IHostResolution}. Nr* )rA r* r* r+ �resolutionBegan� r1 z#IResolutionReceiver.resolutionBegan�addressc C r/ )a� An internet address. This is called when an address for the given name is discovered. In the current implementation this practically means L{IPv4Address} or L{IPv6Address}, but implementations of this interface should be lenient to other types being passed to this interface as well, for future-proofing. @param address: An address object. Nr* )rC r* r* r+ �addressResolved� r1 z#IResolutionReceiver.addressResolvedc C r/ )z� Resolution has completed; no further addresses will be relayed to L{IResolutionReceiver.addressResolved}. Nr* r* r* r* r+ �resolutionComplete� r1 z&IResolutionReceiver.resolutionCompleter5 ) r& r' r( r) r> rB r$ rD rE r* r* r* r+ r@ � s r@ c @ s6 e Zd ZdZdedededee dedef dd �Z d S ) �IHostnameResolverz� An L{IHostnameResolver} can resolve a host name and port number into a series of L{IAddress} objects. @since: Twisted 17.1.0 �resolutionReceiver�hostName� portNumber� addressTypes�transportSemanticsr. c C r/ )a� Initiate a hostname resolution. @param resolutionReceiver: an object that will receive each resolved address as it arrives. @param hostName: The name of the host to resolve. If this contains non-ASCII code points, they will be converted to IDNA first. @param portNumber: The port number that the returned addresses should include. @param addressTypes: An iterable of implementors of L{IAddress} that are acceptable values for C{resolutionReceiver} to receive to its L{addressResolved <IResolutionReceiver.addressResolved>}. In practice, this means an iterable containing L{twisted.internet.address.IPv4Address}, L{twisted.internet.address.IPv6Address}, both, or neither. @param transportSemantics: A string describing the semantics of the transport; either C{'TCP'} for stream-oriented transports or C{'UDP'} for datagram-oriented; see L{twisted.internet.address.IPv6Address.type} and L{twisted.internet.address.IPv4Address.type}. @return: The resolution in progress. Nr* )rG rH rI rJ rK r* r* r+ �resolveHostName� r1 z!IHostnameResolver.resolveHostNameN) r& r' r( r) r@ r< r= r r$ rL r* r* r* r+ rF � s ������rF c @ s| e Zd Zdddee ddfdd�Zdedee ddfd d �Zdedee ddfd d �Zdedee ddfd d�Z dedee ddfdd�Z dedee ddfdd�Z dedee ddfdd�Z dedee ddfdd�Z dedee ddfdd�Zdedee ddfdd�Zdedee ddfdd �Zdedee ddfd d �Zdedee ddfd d �Zdedee ddfd!d"�Zdedee ddfd#d$�Zdedee ddfd%d&�Zdedee ddfd'd(�Zdedee ddfd)d*�Zdedee ddfd+d,�Zdedee ddfd-d.�Zdedee ddfd/d0�Zdedee ddfd1d2�Zdedee ddfd3d4�Z dedee ddfd5d6�Z d7S )8� IResolver�queryr r8 r. z-Deferred[Tuple[RRHeader, RRHeader, RRHeader]]c C r/ )a& Dispatch C{query} to the method which can handle its type. @param query: The DNS query being issued, to which a response is to be generated. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* )rN r8 r* r* r+ rN � r1 zIResolver.queryr7 c C r/ )a� Perform an A record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ � lookupAddress� r1 zIResolver.lookupAddressc C r/ )a� Perform an A6 record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupAddress6 r1 zIResolver.lookupAddress6c C r/ )a� Perform an AAAA record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupIPV6Address r1 zIResolver.lookupIPV6Addressc C r/ )a� Perform an MX record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupMailExchange+ r1 z IResolver.lookupMailExchangec C r/ )a� Perform an NS record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupNameservers> r1 zIResolver.lookupNameserversc C r/ )a� Perform a CNAME record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupCanonicalNameQ r1 z IResolver.lookupCanonicalNamec C r/ )a� Perform an MB record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ � lookupMailBoxd r1 zIResolver.lookupMailBoxc C r/ )a� Perform an MG record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupMailGroupw r1 zIResolver.lookupMailGroupc C r/ )a� Perform an MR record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupMailRename� r1 zIResolver.lookupMailRenamec C r/ )a� Perform a PTR record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ � lookupPointer� r1 zIResolver.lookupPointerc C r/ )a� Perform an SOA record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupAuthority� r1 zIResolver.lookupAuthorityc C r/ )a� Perform a NULL record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ � lookupNull� r1 zIResolver.lookupNullc C r/ )a� Perform a WKS record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupWellKnownServices� r1 z!IResolver.lookupWellKnownServicesc C r/ )a� Perform a HINFO record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupHostInfo� r1 zIResolver.lookupHostInfoc C r/ )a� Perform an MINFO record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupMailboxInfo� r1 zIResolver.lookupMailboxInfoc C r/ )a� Perform a TXT record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ � lookupText r1 zIResolver.lookupTextc C r/ )a� Perform an RP record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupResponsibility" r1 z IResolver.lookupResponsibilityc C r/ )a� Perform an AFSDB record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupAFSDatabase5 r1 zIResolver.lookupAFSDatabasec C r/ )a� Perform an SRV record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ � lookupServiceH r1 zIResolver.lookupServicec C r/ )a� Perform an ALL_RECORD lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupAllRecords[ r1 zIResolver.lookupAllRecordsc C r/ )a� Perform a SPF record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ �lookupSenderPolicyn r1 z IResolver.lookupSenderPolicyc C r/ )a� Perform a NAPTR record lookup. @param name: DNS name to resolve. @param timeout: Number of seconds after which to reissue the query. When the last timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second element of the tuple gives authorities. The third element of the tuple gives additional information. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ � lookupNamingAuthorityPointer� r1 z&IResolver.lookupNamingAuthorityPointerc C r/ )aT Perform an AXFR record lookup. NB This is quite different from other DNS requests. See U{http://cr.yp.to/djbdns/axfr-notes.html} for more information. NB Unlike other C{lookup*} methods, the timeout here is not a list of ints, it is a single int. @param name: DNS name to resolve. @param timeout: When this timeout expires, the query is considered failed. @return: A L{Deferred} which fires with a three-tuple of lists of L{twisted.names.dns.RRHeader} instances. The first element of the tuple gives answers. The second and third elements are always empty. The L{Deferred} may instead fail with one of the exceptions defined in L{twisted.names.error} or with C{NotImplementedError}. Nr* r: r* r* r+ � lookupZone� r1 zIResolver.lookupZoneN) r& r' r( r r= rN r< rO rP rQ rR rS rT rU rV rW rX rY rZ r[ r\ r] r^ r_ r` ra rb rc rd re r* r* r* r+ rM � sR �� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ��� ����rM c @ sX e Zd Zdedddededdf dd �Zd ededd d ed eeeef de f dd�Z dS )� IReactorTCP�port�factoryr �backlog� interfacer. �IListeningPortc C r/ )a6 Connects a given protocol factory to the given numeric TCP/IP port. @param port: a port number on which to listen @param factory: a L{twisted.internet.protocol.ServerFactory} instance @param backlog: size of the listen queue @param interface: The local IPv4 or IPv6 address to which to bind; defaults to '', ie all IPv4 addresses. To bind to all IPv4 and IPv6 addresses, you must call this method twice. @return: an object that provides L{IListeningPort}. @raise CannotListenError: as defined here L{twisted.internet.error.CannotListenError}, if it cannot listen on this port (e.g., it cannot bind to the required port number) Nr* )rg rh ri rj r* r* r+ � listenTCP� r1 zIReactorTCP.listenTCP�hostr r8 � bindAddressc C r/ )a� Connect a TCP client. @param host: A hostname or an IPv4 or IPv6 address literal. @param port: a port number @param factory: a L{twisted.internet.protocol.ClientFactory} instance @param timeout: number of seconds to wait before assuming the connection has failed. @param bindAddress: a (host, port) tuple of local address to bind to, or None. @return: An object which provides L{IConnector}. This connector will call various callbacks on the factory when a connection is made, failed, or lost - see L{ClientFactory<twisted.internet.protocol.ClientFactory>} docs for details. Nr* )rm rg rh r8 rn r* r* r+ � connectTCP� r1 zIReactorTCP.connectTCPN) r& r' r( r= r< rl �floatr r r- ro r* r* r* r+ rf � s2 ���� �������rf c @ s` e Zd Zdededddddedeeeef d efd d �Z dedd dd deded ef dd�Z dS )� IReactorSSLrm rg rh r �contextFactoryr r8 rn r. c C r/ )aQ Connect a client Protocol to a remote SSL socket. @param host: a host name @param port: a port number @param factory: a L{twisted.internet.protocol.ClientFactory} instance @param contextFactory: a L{twisted.internet.ssl.ClientContextFactory} object. @param timeout: number of seconds to wait before assuming the connection has failed. @param bindAddress: a (host, port) tuple of local address to bind to, or L{None}. @return: An object which provides L{IConnector}. Nr* )rm rg rh rr r8 rn r* r* r+ � connectSSL� r1 zIReactorSSL.connectSSLr �IOpenSSLContextFactoryri rj c C r/ )a� Connects a given protocol factory to the given numeric TCP/IP port. The connection is a SSL one, using contexts created by the context factory. @param port: a port number on which to listen @param factory: a L{twisted.internet.protocol.ServerFactory} instance @param contextFactory: an implementor of L{IOpenSSLContextFactory} @param backlog: size of the listen queue @param interface: the hostname to bind to, defaults to '' (all) Nr* )rg rh rr ri rj r* r* r+ � listenSSL� r1 zIReactorSSL.listenSSLN) r& r' r( r< r= rp r r r- rs ru r* r* r* r+ rq � s: ������ �������rq c @ sP e Zd ZdZdedddededef dd �Zdedd d e d e d eddf dd�Z dS )� IReactorUNIXz UNIX socket methods. rC rh r r8 �checkPIDr. c C r/ )a1 Connect a client protocol to a UNIX socket. @param address: a path to a unix socket on the filesystem. @param factory: a L{twisted.internet.protocol.ClientFactory} instance @param timeout: number of seconds to wait before assuming the connection has failed. @param checkPID: if True, check for a pid file to verify that a server is listening. If C{address} is a Linux abstract namespace path, this must be C{False}. @return: An object which provides L{IConnector}. Nr* )rC rh r8 rw r* r* r+ � connectUNIX r1 zIReactorUNIX.connectUNIXr ri �mode�wantPIDrk c C r/ )a� Listen on a UNIX socket. @param address: a path to a unix socket on the filesystem. @param factory: a L{twisted.internet.protocol.Factory} instance. @param backlog: number of connections to allow in backlog. @param mode: The mode (B{not} umask) to set on the unix socket. See platform specific documentation for information about how this might affect connection attempts. @param wantPID: if True, create a pidfile for the socket. If C{address} is a Linux abstract namespace path, this must be C{False}. @return: An object which provides L{IListeningPort}. Nr* )rC rh ri ry rz r* r* r+ � listenUNIX! r1 zIReactorUNIX.listenUNIXN) r& r' r( r) r< rp �boolr- rx r= r{ r* r* r* r+ rv s4 ���� �������rv c @ s\ e Zd ZdZdedddededeeeef def d d �Z dedd dededd f d d�Z dS )�IReactorUNIXDatagramz' Datagram UNIX socket methods. rC �protocolr � maxPacketSizery rn r. c C r/ )aQ Connect a client protocol to a datagram UNIX socket. @param address: a path to a unix socket on the filesystem. @param protocol: a L{twisted.internet.protocol.ConnectedDatagramProtocol} instance @param maxPacketSize: maximum packet size to accept @param mode: The mode (B{not} umask) to set on the unix socket. See platform specific documentation for information about how this might affect connection attempts. @param bindAddress: address to bind to @return: An object which provides L{IConnector}. Nr* )rC r~ r ry rn r* r* r+ �connectUNIXDatagram9 r1 z(IReactorUNIXDatagram.connectUNIXDatagramr rk c C r/ )a Listen on a datagram UNIX socket. @param address: a path to a unix socket on the filesystem. @param protocol: a L{twisted.internet.protocol.DatagramProtocol} instance. @param maxPacketSize: maximum packet size to accept @param mode: The mode (B{not} umask) to set on the unix socket. See platform specific documentation for information about how this might affect connection attempts. @return: An object which provides L{IListeningPort}. Nr* )rC r~ r ry r* r* r+ �listenUNIXDatagramO r1 z'IReactorUNIXDatagram.listenUNIXDatagramN) r& r' r( r) r< r= r r r- r� r� r* r* r* r+ r} 4 s4 ����� ������r} c @ s< e Zd ZdZdedddeddfdd �Zdeddfd d �ZdS ) �IReactorWin32Eventsz3 Win32 Event API methods @since: 10.2 �event�fdr �actionr. Nc C r/ )al Add a new win32 event to the event loop. @param event: a Win32 event object created using win32event.CreateEvent() @param fd: an instance of L{twisted.internet.abstract.FileDescriptor} @param action: a string that is a method name of the fd instance. This method is called in response to the event. Nr* )r� r� r� r* r* r+ �addEventg r1 z IReactorWin32Events.addEventc C r/ )z� Remove an event. @param event: a Win32 event object added using L{IReactorWin32Events.addEvent} @return: None Nr* )r� r* r* r+ � removeEventq r1 z IReactorWin32Events.removeEvent)r& r' r( r) �objectr< r� r� r* r* r* r+ r� ` s r� c @ s. e Zd ZdZdedddededdf d d �Zd S ) � IReactorUDPz UDP socket methods. rg r~ r rj r r. rk c C r/ )a� Connects a given L{DatagramProtocol} to the given numeric UDP port. @param port: A port number on which to listen. @param protocol: A L{DatagramProtocol} instance which will be connected to the given C{port}. @param interface: The local IPv4 or IPv6 address to which to bind; defaults to '', ie all IPv4 addresses. @param maxPacketSize: The maximum packet size to accept. @return: object which provides L{IListeningPort}. Nr* )rg r~ rj r r* r* r+ � listenUDP� r1 zIReactorUDP.listenUDPN)r& r' r( r) r= r< r� r* r* r* r+ r� { s �����r� c @ s2 e Zd ZdZdedddedededd f d d �Zd S ) �IReactorMulticastz� UDP socket methods that support multicast. IMPORTANT: This is an experimental new interface. It may change without backwards compatibility. Suggestions are welcome. rg r~ r rj r �listenMultipler. rk c C r/ )a� Connects a given L{DatagramProtocol<twisted.internet.protocol.DatagramProtocol>} to the given numeric UDP port. @param listenMultiple: If set to True, allows multiple sockets to bind to the same address and port number at the same time. @returns: An object which provides L{IListeningPort}. @see: L{twisted.internet.interfaces.IMulticastTransport} @see: U{http://twistedmatrix.com/documents/current/core/howto/udp.html} Nr* )rg r~ rj r r� r* r* r+ �listenMulticast� r1 z!IReactorMulticast.listenMulticastN)r& r' r( r) r= r< r| r� r* r* r* r+ r� � s ������r� c @ sb e Zd ZdZdeddddddfd d �Zdedddddd fd d �Zdedddddeddf dd�Zd S )�IReactorSocketa Methods which allow a reactor to use externally created sockets. For example, to use C{adoptStreamPort} to implement behavior equivalent to that of L{IReactorTCP.listenTCP}, you might write code like this:: from socket import SOMAXCONN, AF_INET, SOCK_STREAM, socket portSocket = socket(AF_INET, SOCK_STREAM) # Set FD_CLOEXEC on port, left as an exercise. Then make it into a # non-blocking listening port: portSocket.setblocking(False) portSocket.bind(('192.168.1.2', 12345)) portSocket.listen(SOMAXCONN) # Now have the reactor use it as a TCP port port = reactor.adoptStreamPort( portSocket.fileno(), AF_INET, YourFactory()) # portSocket itself is no longer necessary, and needs to be cleaned # up by us. portSocket.close() # Whenever the server is no longer needed, stop it as usual. stoppedDeferred = port.stopListening() Another potential use is to inherit a listening descriptor from a parent process (for example, systemd or launchd), or to receive one over a UNIX domain socket. Some plans for extending this interface exist. See: - U{http://twistedmatrix.com/trac/ticket/6594}: AF_UNIX SOCK_DGRAM ports �fileDescriptor� addressFamilyr rh r r. rk c C r/ )a Add an existing listening I{SOCK_STREAM} socket to the reactor to monitor for new connections to accept and handle. @param fileDescriptor: A file descriptor associated with a socket which is already bound to an address and marked as listening. The socket must be set non-blocking. Any additional flags (for example, close-on-exec) must also be set by application code. Application code is responsible for closing the file descriptor, which may be done as soon as C{adoptStreamPort} returns. @param addressFamily: The address family (or I{domain}) of the socket. For example, L{socket.AF_INET6}. @param factory: A L{ServerFactory} instance to use to create new protocols to handle connections accepted via this socket. @return: An object providing L{IListeningPort}. @raise twisted.internet.error.UnsupportedAddressFamily: If the given address family is not supported by this reactor, or not supported with the given socket type. @raise twisted.internet.error.UnsupportedSocketType: If the given socket type is not supported by this reactor, or not supported with the given socket type. Nr* �r� r� rh r* r* r+ �adoptStreamPort� r1 z IReactorSocket.adoptStreamPortNc C r/ )a Add an existing connected I{SOCK_STREAM} socket to the reactor to monitor for data. Note that the given factory won't have its C{startFactory} and C{stopFactory} methods called, as there is no sensible time to call them in this situation. @param fileDescriptor: A file descriptor associated with a socket which is already connected. The socket must be set non-blocking. Any additional flags (for example, close-on-exec) must also be set by application code. Application code is responsible for closing the file descriptor, which may be done as soon as C{adoptStreamConnection} returns. @param addressFamily: The address family (or I{domain}) of the socket. For example, L{socket.AF_INET6}. @param factory: A L{ServerFactory} instance to use to create a new protocol to handle the connection via this socket. @raise UnsupportedAddressFamily: If the given address family is not supported by this reactor, or not supported with the given socket type. @raise UnsupportedSocketType: If the given socket type is not supported by this reactor, or not supported with the given socket type. Nr* r� r* r* r+ �adoptStreamConnection� r1 z$IReactorSocket.adoptStreamConnectionr~ r r c C r/ )a� Add an existing listening I{SOCK_DGRAM} socket to the reactor to monitor for read and write readiness. @param fileDescriptor: A file descriptor associated with a socket which is already bound to an address and marked as listening. The socket must be set non-blocking. Any additional flags (for example, close-on-exec) must also be set by application code. Application code is responsible for closing the file descriptor, which may be done as soon as C{adoptDatagramPort} returns. @param addressFamily: The address family or I{domain} of the socket. For example, L{socket.AF_INET6}. @param protocol: A L{DatagramProtocol} instance to connect to a UDP transport. @param maxPacketSize: The maximum packet size to accept. @return: An object providing L{IListeningPort}. @raise UnsupportedAddressFamily: If the given address family is not supported by this reactor, or not supported with the given socket type. @raise UnsupportedSocketType: If the given socket type is not supported by this reactor, or not supported with the given socket type. Nr* )r� r� r~ r r* r* r+ �adoptDatagramPort r1 z IReactorSocket.adoptDatagramPort)r& r' r( r) r= r� r� r� r* r* r* r+ r� � s> "��� � ��� � �����r� c @ sv e Zd Zdddeeef deeeef deee e f deeef de de d e d ee ee ef f d d fd d�Z dS )�IReactorProcess�processProtocol�IProcessProtocol� executable�args�env�path�uid�gid�usePTY�childFDsr. �IProcessTransportc C r/ )aJ Spawn a process, with a process protocol. Arguments given to this function that are listed as L{bytes} or L{unicode} may be encoded or decoded depending on the platform and the argument type given. On UNIX systems (Linux, FreeBSD, macOS) and Python 2 on Windows, L{unicode} arguments will be encoded down to L{bytes} using the encoding given by L{sys.getfilesystemencoding}, to be used with the "narrow" OS APIs. On Python 3 on Windows, L{bytes} arguments will be decoded up to L{unicode} using the encoding given by L{sys.getfilesystemencoding} (C{mbcs} before Python 3.6, C{utf8} thereafter) and given to Windows's native "wide" APIs. @param processProtocol: An object which will be notified of all events related to the created process. @param executable: the file name to spawn - the full path should be used. @param args: the command line arguments to pass to the process; a sequence of strings. The first string should be the executable's name. @param env: the environment variables to pass to the child process. The resulting behavior varies between platforms. If: - C{env} is not set: - On POSIX: pass an empty environment. - On Windows: pass L{os.environ}. - C{env} is L{None}: - On POSIX: pass L{os.environ}. - On Windows: pass L{os.environ}. - C{env} is a L{dict}: - On POSIX: pass the key/value pairs in C{env} as the complete environment. - On Windows: update L{os.environ} with the key/value pairs in the L{dict} before passing it. As a consequence of U{bug #1640 <http://twistedmatrix.com/trac/ticket/1640>}, passing keys with empty values in an effort to unset environment variables I{won't} unset them. @param path: the path to run the subprocess in - defaults to the current directory. @param uid: user ID to run the subprocess as. (Only available on POSIX systems.) @param gid: group ID to run the subprocess as. (Only available on POSIX systems.) @param usePTY: if true, run this process in a pseudo-terminal. optionally a tuple of C{(masterfd, slavefd, ttyname)}, in which case use those file descriptors. (Not available on all systems.) @param childFDs: A dictionary mapping file descriptors in the new child process to an integer or to the string 'r' or 'w'. If the value is an integer, it specifies a file descriptor in the parent process which will be mapped to a file descriptor (specified by the key) in the child process. This is useful for things like inetd and shell-like file redirection. If it is the string 'r', a pipe will be created and attached to the child at that file descriptor: the child will be able to write to that file descriptor and the parent will receive read notification via the L{IProcessProtocol.childDataReceived} callback. This is useful for the child's stdout and stderr. If it is the string 'w', similar setup to the previous case will occur, with the pipe being readable by the child instead of writeable. The parent process can write to that file descriptor using L{IProcessTransport.writeToChild}. This is useful for the child's stdin. If childFDs is not passed, the default behaviour is to use a mapping that opens the usual stdin/stdout/stderr pipes. @see: L{twisted.internet.protocol.ProcessProtocol} @return: An object which provides L{IProcessTransport}. @raise OSError: Raised with errno C{EAGAIN} or C{ENOMEM} if there are insufficient system resources to create a new process. Nr* ) r� r� r� r� r� r� r� r� r� r* r* r+ � spawnProcess, r1 z IReactorProcess.spawnProcessN) r& r' r( r �bytesr< r r r r r= r| r� r* r* r* r+ r� + s, � ��� ���� � �r� c @ sV e Zd ZdZdefdd�Zdededef ded edd f d d �Z de d fd d�Z dS )� IReactorTimez7 Time methods that a Reactor should implement. r. c C r/ )zg Get the current time in seconds. @return: A number-like object of some sort. Nr* r* r* r* r+ �seconds� r1 zIReactorTime.seconds�delay�callable.r� �kwargs� IDelayedCallc O r/ )a Call a function later. @param delay: the number of seconds to wait. @param callable: the callable object to call later. @param args: the arguments to call it with. @param kwargs: the keyword arguments to call it with. @return: An object which provides L{IDelayedCall} and can be used to cancel the scheduled call, by calling its C{cancel()} method. It also may be rescheduled by calling its C{delay()} or C{reset()} methods. Nr* )r� r� r� r� r* r* r+ � callLater� r1 zIReactorTime.callLaterc C r/ )zQ See L{twisted.internet.interfaces.IReactorTime.getDelayedCalls} Nr* r* r* r* r+ �getDelayedCalls� r1 z IReactorTime.getDelayedCallsN) r& r' r( r) rp r� r r r� r� r r� r* r* r* r+ r� � s � ��� �r� c @ sZ e Zd ZdZdefdd�Zddd�Zdeddfd d �Zd eddfd d �Zde fdd�Z dS )r� z� A scheduled call. There are probably other useful methods we can add to this interface; suggestions are welcome. r. c C r/ )zr Get time when delayed call will happen. @return: time in seconds since epoch (a float). Nr* r* r* r* r+ �getTime� r1 zIDelayedCall.getTimeNc C r/ )z� Cancel the scheduled call. @raises twisted.internet.error.AlreadyCalled: if the call has already happened. @raises twisted.internet.error.AlreadyCancelled: if the call has already been cancelled. Nr* r* r* r* r+ r? � r1 zIDelayedCall.cancel� secondsLaterc C r/ )aR Delay the scheduled call. @param secondsLater: how many seconds from its current firing time to delay @raises twisted.internet.error.AlreadyCalled: if the call has already happened. @raises twisted.internet.error.AlreadyCancelled: if the call has already been cancelled. Nr* )r� r* r* r+ r� � r1 zIDelayedCall.delay�secondsFromNowc C r/ )a� Reset the scheduled call's timer. @param secondsFromNow: how many seconds from now it should fire, equivalent to C{.cancel()} and then doing another C{reactor.callLater(secondsLater, ...)} @raises twisted.internet.error.AlreadyCalled: if the call has already happened. @raises twisted.internet.error.AlreadyCancelled: if the call has already been cancelled. Nr* )r� r* r* r+ �reset� r1 zIDelayedCall.resetc C r/ )zx @return: True if this call is still active, False if it has been called or cancelled. Nr* r* r* r* r+ �active� r1 zIDelayedCall.activer5 ) r& r' r( r) rp r� r? r� r� r| r� r* r* r* r+ r� � s r� c @ �2 e Zd ZdZdedef dededdfdd �ZdS ) �IReactorFromThreadsz� This interface is the set of thread-safe methods which may be invoked on the reactor from other threads. @since: 15.4 r� .r� r� r. Nc O r/ )a� Cause a function to be executed by the reactor thread. Use this method when you want to run a function in the reactor's thread from another thread. Calling L{callFromThread} should wake up the main thread (where L{reactor.run() <IReactorCore.run>} is executing) and run the given callable in that thread. If you're writing a multi-threaded application the C{callable} may need to be thread safe, but this method doesn't require it as such. If you want to call a function in the next mainloop iteration, but you're in the same thread, use L{callLater} with a delay of 0. Nr* �r� r� r� r* r* r+ �callFromThread� r1 z"IReactorFromThreads.callFromThread)r& r' r( r) r r r� r� r* r* r* r+ r� � � ����r� c @ r� ) �IReactorInThreadsz� This interface contains the methods exposed by a reactor which will let you run functions in another thread. @since: 15.4 r� .r� r� r. Nc O r/ )z} Run the given callable object in a separate thread, with the given arguments and keyword arguments. Nr* r� r* r* r+ � callInThread r1 z IReactorInThreads.callInThread)r& r' r( r) r r r� r� r* r* r* r+ r� r� r� c @ s, e Zd ZdZd dd�Zdeddfdd �ZdS ) �IReactorThreadsz} Dispatch methods to be run in threads. Internally, this should use a thread pool and dispatch methods to them. r. r" c C r/ )zx Return the threadpool used by L{IReactorInThreads.callInThread}. Create it first if necessary. Nr* r* r* r* r+ � getThreadPool r1 z IReactorThreads.getThreadPool�sizeNc C r/ )z� Suggest the size of the internal threadpool used to dispatch functions passed to L{IReactorInThreads.callInThread}. Nr* )r� r* r* r+ �suggestThreadPoolSize# r1 z%IReactorThreads.suggestThreadPoolSize)r. r" )r& r' r( r) r� r= r� r* r* r* r+ r� s r� c @ s� e Zd ZdZed�Zdedee ddfdd�Z d"d d �Z d"d d �Z d"dd�Z de dd fdd�Zdedd fdd�Zdedededef dededef dd �Zd edd fd d �Zdedef dededee fd d!�Zd S )#� IReactorCorez5 Core methods that a Reactor must implement. zjA C{bool} which is C{True} from I{during startup} to I{during shutdown} and C{False} the rest of the time.r7 r8 r. r9 c C r/ )zc Return a L{twisted.internet.defer.Deferred} that will resolve a hostname. Nr* r: r* r* r+ �resolve4 r1 zIReactorCore.resolveNc C r/ )z� Fire 'startup' System Events, move the reactor to the 'running' state, then run the main loop until it is stopped with C{stop()} or C{crash()}. Nr* r* r* r* r+ �run: r1 zIReactorCore.runc C r/ )z� Fire 'shutdown' System Events, which will move the reactor to the 'stopped' state and cause C{reactor.run()} to exit. Nr* r* r* r* r+ �stopA r1 zIReactorCore.stopc C r/ )as Stop the main loop *immediately*, without firing any system events. This is named as it is because this is an extremely "rude" thing to do; it is possible to lose data and put your system in an inconsistent state by calling this. However, it is necessary, as sometimes a system can become wedged in a pre-shutdown call. Nr* r* r* r* r+ �crashG r1 zIReactorCore.crashr� c C r/ )ap Run the main loop's I/O polling function for a period of time. This is most useful in applications where the UI is being drawn "as fast as possible", such as games. All pending L{IDelayedCall}s will be called. The reactor must have been started (via the C{run()} method) prior to any invocations of this method. It must also be stopped manually after the last call to this method (via the C{stop()} method). This method is not re-entrant: you must not call it recursively; in particular, you must not call it while the reactor is running. Nr* )r� r* r* r+ �iterateQ r1 zIReactorCore.iterate� eventTypec C r/ )z� Fire a system-wide event. System-wide events are things like 'startup', 'shutdown', and 'persist'. Nr* )r� r* r* r+ �fireSystemEvent` r1 z IReactorCore.fireSystemEvent�phaser� .r� r� c O r/ )a% Add a function to be called when a system event occurs. Each "system event" in Twisted, such as 'startup', 'shutdown', and 'persist', has 3 phases: 'before', 'during', and 'after' (in that order, of course). These events will be fired internally by the Reactor. An implementor of this interface must only implement those events described here. Callbacks registered for the "before" phase may return either None or a Deferred. The "during" phase will not execute until all of the Deferreds from the "before" phase have fired. Once the "during" phase is running, all of the remaining triggers must execute; their return values must be ignored. @param phase: a time to call the event -- either the string 'before', 'after', or 'during', describing when to call it relative to the event's execution. @param eventType: this is a string describing the type of event. @param callable: the object to call before shutdown. @param args: the arguments to call it with. @param kwargs: the keyword arguments to call it with. @return: an ID that can be used to remove this call with removeSystemEventTrigger. Nr* )r� r� r� r� r� r* r* r+ �addSystemEventTriggerh r1 z"IReactorCore.addSystemEventTrigger� triggerIDc C r/ )a� Removes a trigger added with addSystemEventTrigger. @param triggerID: a value returned from addSystemEventTrigger. @raise KeyError: If there is no system event trigger for the given C{triggerID}. @raise ValueError: If there is no system event trigger for the given C{triggerID}. @raise TypeError: If there is no system event trigger for the given C{triggerID}. Nr* )r� r* r* r+ �removeSystemEventTrigger� r1 z%IReactorCore.removeSystemEventTriggerc O r/ )a Call a function when the reactor is running. If the reactor has not started, the callable will be scheduled to run when it does start. Otherwise, the callable will be invoked immediately. @param callable: the callable object to call later. @param args: the arguments to call it with. @param kwargs: the keyword arguments to call it with. @return: None if the callable was invoked, otherwise a system event id for the scheduled call. Nr* r� r* r* r+ �callWhenRunning� r1 z IReactorCore.callWhenRunningr5 )r& r' r( r) r �runningr< r r= r� r� r� r� rp r� r� r r r� r� r� r r� r* r* r* r+ r� * sD � �� ��� �% ����r� c @ s" e Zd ZdZdedefdd�ZdS )�IReactorPluggableResolvera An L{IReactorPluggableResolver} is a reactor which can be customized with an L{IResolverSimple}. This is a fairly limited interface, that supports only IPv4; you should use L{IReactorPluggableNameResolver} instead. @see: L{IReactorPluggableNameResolver} �resolverr. c C r/ )z� Set the internal resolver to use to for name lookups. @param resolver: The new resolver to use. @return: The previously installed resolver. Nr* �r� r* r* r+ �installResolver� r1 z)IReactorPluggableResolver.installResolverN)r& r' r( r) r6 r� r* r* r* r+ r� � s r� c @ s* e Zd ZdZed�Zdedefdd�ZdS )� IReactorPluggableNameResolverzx An L{IReactorPluggableNameResolver} is a reactor whose name resolver can be set to a user-supplied object. zw Read-only attribute; the resolver installed with L{installResolver}. An L{IHostnameResolver}. r� r. c C r/ )z� Set the internal resolver to use for name lookups. @param resolver: The new resolver to use. @return: The previously installed resolver. Nr* r� r* r* r+ �installNameResolver� r1 z1IReactorPluggableNameResolver.installNameResolverN)r& r' r( r) r � nameResolverrF r� r* r* r* r+ r� � s �r� c @ �$ e Zd ZdZddd�Zddd�ZdS ) �IReactorDaemonizea� A reactor which provides hooks that need to be called before and after daemonization. Notes: - This interface SHOULD NOT be called by applications. - This interface should only be implemented by reactors as a workaround (in particular, it's implemented currently only by kqueue()). For details please see the comments on ticket #1918. r. Nc C r/ )z� Hook to be called immediately before daemonization. No reactor methods may be called until L{afterDaemonize} is called. Nr* r* r* r* r+ �beforeDaemonize� r1 z!IReactorDaemonize.beforeDaemonizec C r/ )z� Hook to be called immediately after daemonization. This may only be called after L{beforeDaemonize} had been called previously. Nr* r* r* r* r+ �afterDaemonize� r1 z IReactorDaemonize.afterDaemonizer5 )r& r' r( r) r� r� r* r* r* r+ r� � s r� c @ sr e Zd ZdZddd�Zdd d �Zdd d �Zddd�Zdee d fdd�Z ded fdd�Z ded fdd�Z dS )� IReactorFDSetz� Implement me to be able to use L{IFileDescriptor} type resources. This assumes that your main-loop uses UNIX-style numeric file descriptors (or at least similarly opaque IDs returned from a .fileno() method) �reader�IReadDescriptorr. Nc C r/ )a I add reader to the set of file descriptors to get read events for. @param reader: An L{IReadDescriptor} provider that will be checked for read events until it is removed from the reactor with L{removeReader}. Nr* �r� r* r* r+ � addReader� r1 zIReactorFDSet.addReader�writer�IWriteDescriptorc C r/ )a I add writer to the set of file descriptors to get write events for. @param writer: An L{IWriteDescriptor} provider that will be checked for write events until it is removed from the reactor with L{removeWriter}. Nr* �r� r* r* r+ � addWriter r1 zIReactorFDSet.addWriterc C r/ )zG Removes an object previously added with L{addReader}. Nr* r� r* r* r+ � removeReader r1 zIReactorFDSet.removeReaderc C r/ )zG Removes an object previously added with L{addWriter}. Nr* r� r* r* r+ � removeWriter r1 zIReactorFDSet.removeWriter)r� r� c C r/ )z� Remove all readers and writers. Should not remove reactor internal reactor connections (like a waker). @return: A list of L{IReadDescriptor} and L{IWriteDescriptor} providers which were removed. Nr* r* r* r* r+ � removeAll r1 zIReactorFDSet.removeAllc C r/ )z� Return the list of file descriptors currently monitored for input events by the reactor. @return: the list of file descriptors monitored for input events. Nr* r* r* r* r+ � getReaders r1 zIReactorFDSet.getReadersc C r/ )z� Return the list file descriptors currently monitored for output events by the reactor. @return: the list of file descriptors monitored for output events. Nr* r* r* r* r+ � getWriters' r1 zIReactorFDSet.getWriters)r� r� r. N)r� r� r. N) r& r' r( r) r� r� r� r� r r r� r� r� r* r* r* r+ r� � s r� c @ s: e Zd ZdZd dd�Zded fdd�Zdefd d �ZdS ) rk z A listening port. r. Nc C r/ )a Start listening on this port. @raise CannotListenError: If it cannot listen on this port (e.g., it is a TCP port and it cannot bind to the required port number). Nr* r* r* r* r+ �startListening5 r1 z IListeningPort.startListeningr c C r/ )z� Stop listening on this port. If it does not complete immediately, will return Deferred that fires upon completion. Nr* r* r* r* r+ � stopListening> r1 z IListeningPort.stopListeningc C r/ )zj Get the host that this port is listening for. @return: An L{IAddress} provider. Nr* r* r* r* r+ �getHostF r1 zIListeningPort.getHostr5 ) r& r' r( r) r� r r� r$ r� r* r* r* r+ rk 0 s rk c @ � e Zd ZdZdefdd�ZdS )�ILoggingContextz^ Give context information that will be used to log events generated by this item. r. c C r/ )zQ @return: Prefix used during log formatting to indicate context. Nr* r* r* r* r+ � logPrefixT r1 zILoggingContext.logPrefixN)r& r' r( r) r< r� r* r* r* r+ r� N s r� c @ s0 e Zd ZdZdefdd�Zdeddfdd�ZdS ) �IFileDescriptorzI An interface representing a UNIX-style numeric file descriptor. r. c C r/ )aY @return: The platform-specified representation of a file descriptor number. Or C{-1} if the descriptor no longer has a valid file descriptor number associated with it. As long as the descriptor is valid, calls to this method on a particular instance must return the same value. Nr* r* r* r* r+ �fileno_ r1 zIFileDescriptor.fileno�reasonNc C r/ )a� Called when the connection was lost. This is called when the connection on a selectable object has been lost. It will be called whether the connection was closed explicitly, an exception occurred in an event handler, or the other end of the connection closed it first. See also L{IHalfCloseableDescriptor} if your descriptor wants to be notified separately of the two halves of the connection being closed. @param reason: A failure instance indicating the reason why the connection was lost. L{error.ConnectionLost} and L{error.ConnectionDone} are of special note, but the failure may be of other classes as well. Nr* �r� r* r* r+ �connectionLosth r1 z IFileDescriptor.connectionLost)r& r' r( r) r� r� r r� r* r* r* r+ r� Z s r� c @ �" e Zd ZdZdee fdd�ZdS )r� zz An L{IFileDescriptor} that can read. This interface is generally used in conjunction with L{IReactorFDSet}. r. c C r/ )z� Some data is available for reading on your descriptor. @return: If an error is encountered which causes the descriptor to no longer be valid, a L{Failure} should be returned. Otherwise, L{None}. Nr* r* r* r* r+ �doRead� r1 zIReadDescriptor.doReadN)r& r' r( r) r r r� r* r* r* r+ r� { � r� c @ r� )r� z{ An L{IFileDescriptor} that can write. This interface is generally used in conjunction with L{IReactorFDSet}. r. c C r/ )z� Some data can be written to your descriptor. @return: If an error is encountered which causes the descriptor to no longer be valid, a L{Failure} should be returned. Otherwise, L{None}. Nr* r* r* r* r+ �doWrite� r1 zIWriteDescriptor.doWriteN)r& r' r( r) r r r� r* r* r* r+ r� � r� r� c @ r# )�IReadWriteDescriptorz= An L{IFileDescriptor} that can both read and write. Nr% r* r* r* r+ r� � r, r� c @ s4 e Zd ZdZdeddfdd�Zdeddfdd�ZdS ) �IHalfCloseableDescriptorz/ A descriptor that can be half-closed. r� r. Nc C r/ )z6 Indicates write connection was lost. Nr* r� r* r* r+ �writeConnectionLost� r1 z,IHalfCloseableDescriptor.writeConnectionLostc C r/ )z5 Indicates read connection was lost. Nr* r� r* r* r+ �readConnectionLost� r1 z+IHalfCloseableDescriptor.readConnectionLost)r& r' r( r) r r� r� r* r* r* r+ r� � s r� c @ r� )� ISystemHandlez? An object that wraps a networking OS-specific handle. r. c C r/ )ab Return a system- and reactor-specific handle. This might be a socket.socket() object, or some other type of object, depending on which reactor is being used. Use and manipulate at your own risk. This might be used in cases where you want to set specific options not exposed by the Twisted APIs. Nr* r* r* r* r+ � getHandle� r1 zISystemHandle.getHandleN)r& r' r( r) r� r� r* r* r* r+ r� � � r� c @ sB e Zd ZdZdddeddfdd�Zdd d �Zd eddfd d �ZdS )� IConsumerz3 A consumer consumes data from a producer. �producer� IProducer� streamingr. Nc C r/ )a� Register to receive data from a producer. This sets self to be a consumer for a producer. When this object runs out of data (as when a send(2) call on a socket succeeds in moving the last data from a userspace buffer into a kernelspace buffer), it will ask the producer to resumeProducing(). For L{IPullProducer} providers, C{resumeProducing} will be called once each time data is required. For L{IPushProducer} providers, C{pauseProducing} will be called whenever the write buffer fills up and C{resumeProducing} will only be called when it empties. The consumer will only call C{resumeProducing} to balance a previous C{pauseProducing} call; the producer is assumed to start in an un-paused state. @param streaming: C{True} if C{producer} provides L{IPushProducer}, C{False} if C{producer} provides L{IPullProducer}. @raise RuntimeError: If a producer is already registered. Nr* )r� r� r* r* r+ �registerProducer� r1 zIConsumer.registerProducerc C r/ )zM Stop consuming data from a producer, without disconnecting. Nr* r* r* r* r+ �unregisterProducer� r1 z IConsumer.unregisterProducer�datac C r/ )a@ The producer will write data by calling this method. The implementation must be non-blocking and perform whatever buffering is necessary. If the producer has provided enough data for now and it is a L{IPushProducer}, the consumer may call its C{pauseProducing} method. Nr* �r� r* r* r+ �write� r1 zIConsumer.writer5 ) r& r' r( r) r| r� r� r� r r* r* r* r+ r� � s r� c @ � e Zd ZdZddd�ZdS )r� z� A producer produces data for a consumer. Typically producing is done by calling the C{write} method of a class implementing L{IConsumer}. r. Nc C r/ )z� Stop producing data. This tells a producer that its consumer has died, so it must stop producing data for good. Nr* r* r* r* r+ � stopProducing� r1 zIProducer.stopProducingr5 )r& r' r( r) r r* r* r* r+ r� � s r� c @ r� ) � IPushProducera^ A push producer, also known as a streaming producer is expected to produce (write to this consumer) data on a continuous basis, unless it has been paused. A paused push producer will resume producing after its C{resumeProducing()} method is called. For a push producer which is not pauseable, these functions may be noops. r. Nc C r/ )z� Pause producing data. Tells a producer that it has produced too much data to process for the time being, and to stop until C{resumeProducing()} is called. Nr* r* r* r* r+ �pauseProducing r1 z IPushProducer.pauseProducingc C r/ )z� Resume producing data. This tells a producer to re-add itself to the main loop and produce more data for its consumer. Nr* r* r* r* r+ �resumeProducing r1 z IPushProducer.resumeProducingr5 )r& r' r( r) r r r* r* r* r+ r s r c @ r )� IPullProducerz� A pull producer, also known as a non-streaming producer, is expected to produce data each time L{resumeProducing()} is called. r. Nc C r/ )a� Produce data for the consumer a single time. This tells a producer to produce data for the consumer once (not repeatedly, once only). Typically this will be done by calling the consumer's C{write} method a single time with produced data. The producer should produce data before returning from C{resumeProducing()}, that is, it should not schedule a deferred write. Nr* r* r* r* r+ r # r1 z IPullProducer.resumeProducingr5 )r& r' r( r) r r* r* r* r+ r s r c @ sD e Zd Zdeddfdd�Zdeddfdd�Zdd d �Zdd d�ZdS )� IProtocolr� r. Nc C r/ )a2 Called whenever data is received. Use this method to translate to a higher-level message. Usually, some callback will be made upon the receipt of each complete protocol message. Please keep in mind that you will probably need to buffer some data as partial (or multiple) protocol messages may be received! We recommend that unit tests for protocols call through to this method with differing chunk sizes, down to one byte at a time. @param data: bytes of indeterminate length Nr* r� r* r* r+ � dataReceived1 r1 zIProtocol.dataReceivedr� c C r/ )as Called when the connection is shut down. Clear any circular references here, and any external references to this Protocol. The connection has been closed. The C{reason} Failure wraps a L{twisted.internet.error.ConnectionDone} or L{twisted.internet.error.ConnectionLost} instance (or a subclass of one of those). Nr* r� r* r* r+ r� A r1 zIProtocol.connectionLost� transport� ITransportc C r/ )z@ Make a connection to a transport and a server. Nr* )r r* r* r+ �makeConnectionL r1 zIProtocol.makeConnectionc C r/ )a� Called when a connection is made. This may be considered the initializer of the protocol, because it is called when the connection is completed. For clients, this is called once the connection to the server has been established; for servers, this is called after an accept() call stops blocking and a socket has been received. If you need to send any greeting or initial message, do it here. Nr* r* r* r* r+ �connectionMadeQ r1 zIProtocol.connectionMade)r r r. Nr5 ) r& r' r( r� r r r� r r r* r* r* r+ r 0 s r c @ sf e Zd ZdZddd�Zded eddfd d �Zdeddfd d �Zde ddfdd�Z de ddfdd�Z dS )r� z7 Interface for process-related event handlers. �processr� r. Nc C r/ )z� Called when the process has been created. @param process: An object representing the process which has been created and associated with this protocol. Nr* )r r* r* r+ r c r1 z IProcessProtocol.makeConnection�childFDr� c C r/ )z� Called when data arrives from the child process. @param childFD: The file descriptor from which the data was received. @param data: The data read from the child's file descriptor. Nr* �r r� r* r* r+ �childDataReceivedk r1 z"IProcessProtocol.childDataReceivedc C r/ )z� Called when a file descriptor associated with the child process is closed. @param childFD: The file descriptor which was closed. Nr* )r r* r* r+ �childConnectionLostt r1 z$IProcessProtocol.childConnectionLostr� c C r/ )aI Called when the child process exits. @param reason: A failure giving the reason the child process terminated. The type of exception for this failure is either L{twisted.internet.error.ProcessDone} or L{twisted.internet.error.ProcessTerminated}. @since: 8.2 Nr* r� r* r* r+ � processExited| r1 z IProcessProtocol.processExitedc C r/ )ay Called when the child process exits and all file descriptors associated with it have been closed. @param reason: A failure giving the reason the child process terminated. The type of exception for this failure is either L{twisted.internet.error.ProcessDone} or L{twisted.internet.error.ProcessTerminated}. Nr* r� r* r* r+ � processEnded� r1 z IProcessProtocol.processEnded)r r� r. N) r& r' r( r) r r= r� r r r r r r* r* r* r+ r� ^ s r� c @ r� ) �IHalfCloseableProtocolaA Implemented to indicate they want notification of half-closes. TCP supports the notion of half-closing the connection, e.g. closing the write side but still not stopping reading. A protocol that implements this interface will be notified of such events, instead of having connectionLost called. r. Nc C r/ )a= Notification of the read connection being closed. This indicates peer did half-close of write side. It is now the responsibility of the this protocol to call loseConnection(). In addition, the protocol MUST make sure a reference to it still exists (i.e. by doing a callLater with one of its methods, etc.) as the reactor will only have a reference to it if it is writing. If the protocol does not do so, it might get garbage collected without the connectionLost method ever being called. Nr* r* r* r* r+ r� � r1 z)IHalfCloseableProtocol.readConnectionLostc C r/ )z� Notification of the write connection being closed. This will never be called for TCP connections as TCP does not support notification of this type of half-close. Nr* r* r* r* r+ r� � r1 z*IHalfCloseableProtocol.writeConnectionLostr5 )r& r' r( r) r� r� r* r* r* r+ r � s r c @ r )�IHandshakeListeneraC An interface implemented by a L{IProtocol} to indicate that it would like to be notified when TLS handshakes complete when run over a TLS-based transport. This interface is only guaranteed to be called when run over a TLS-based transport: non TLS-based transports will not respect this interface. r. Nc C r/ )ax Notification of the TLS handshake being completed. This notification fires when OpenSSL has completed the TLS handshake. At this point the TLS connection is established, and the protocol can interrogate its transport (usually an L{ISSLTransport}) for details of the TLS connection. This notification *also* fires whenever the TLS session is renegotiated. As a result, protocols that have certain minimum security requirements should implement this interface to ensure that they are able to re-evaluate the security of the TLS session if it changes. Nr* r* r* r* r+ �handshakeCompleted� r1 z%IHandshakeListener.handshakeCompletedr5 )r& r' r( r) r r* r* r* r+ r � � r c @ �" e Zd ZdZdeddfdd�ZdS )�IFileDescriptorReceiverz� Protocols may implement L{IFileDescriptorReceiver} to receive file descriptors sent to them. This is useful in conjunction with L{IUNIXTransport}, which allows file descriptors to be sent between processes on a single host. � descriptorr. Nc C r/ )z� Called when a file descriptor is received over the connection. @param descriptor: The descriptor which was received. @return: L{None} Nr* �r r* r* r+ �fileDescriptorReceived� r1 z.IFileDescriptorReceiver.fileDescriptorReceived)r& r' r( r) r= r r* r* r* r+ r � � r c @ s: e Zd ZdZdedee fdd�Zd dd�Zd d d �Z dS ) �IProtocolFactoryz+ Interface for protocol factories. �addrr. c C r/ )a Called when a connection has been established to addr. If None is returned, the connection is assumed to have been refused, and the Port will close the connection. @param addr: The address of the newly-established connection @return: None if the connection was refused, otherwise an object providing L{IProtocol}. Nr* �r r* r* r+ � buildProtocol� r1 z IProtocolFactory.buildProtocolNc C r/ )zM Called every time this is connected to a Port or Connector. Nr* r* r* r* r+ �doStart� r1 zIProtocolFactory.doStartc C r/ )zQ Called every time this is unconnected from a Port or Connector. Nr* r* r* r* r+ �doStop� r1 zIProtocolFactory.doStopr5 ) r& r' r( r) r$ r r r! r" r# r* r* r* r+ r � s r c @ s^ e Zd ZdZdeddfdd�Zdee ddfdd�Zdd d �Zde fd d �Z de fd d�Z dS )r a� I am a transport for bytes. I represent (and wrap) the physical connection and synchronicity of the framework which is talking to the network. I make no representations about whether calls to me will happen immediately or require returning to a control loop, or whether they will happen in the same or another thread. Consider methods of this class (aside from getPeer) to be 'thrown over the wall', to happen at some indeterminate time. r� r. Nc C r/ )aH Write some data to the physical connection, in sequence, in a non-blocking fashion. If possible, make sure that it is all written. No data will ever be lost, although (obviously) the connection may be closed before it all gets through. @param data: The data to write. Nr* r� r* r* r+ r r1 zITransport.writec C r/ )a Write an iterable of byte strings to the physical connection. If possible, make sure that all of the data is written to the socket at once, without first copying it all into a single byte string. @param data: The data to write. Nr* r� r* r* r+ � writeSequence r1 zITransport.writeSequencec C r/ )z� Close my connection, after writing all pending data. Note that if there is a registered producer on a transport it will not be closed until the producer has been unregistered. Nr* r* r* r* r+ �loseConnection# r1 zITransport.loseConnectionc C r/ )ah Get the remote address of this connection. Treat this method with caution. It is the unfortunate result of the CGI and Jabber standards, but should not be considered reliable for the usual host of reasons; port forwarding, proxying, firewalls, IP masquerading, etc. @return: An L{IAddress} provider. Nr* r* r* r* r+ �getPeer+ r1 zITransport.getPeerc C r/ )z� Similar to getPeer, but returns an address describing this side of the connection. @return: An L{IAddress} provider. Nr* r* r* r* r+ r� 7 r1 zITransport.getHostr5 ) r& r' r( r) r� r r r$ r% r$ r& r� r* r* r* r+ r � s r c @ s� e Zd ZdZddd�Zddd�Zdefdd �Zd eddfd d �Zdefd d�Z d eddfdd�Z de d fdd�Z de d fdd�Z dS )� ITCPTransportz A TCP based transport. r. Nc C r/ )aq Half-close the write side of a TCP connection. If the protocol instance this is attached to provides IHalfCloseableProtocol, it will get notified when the operation is done. When closing write connection, as with loseConnection this will only happen when buffer has emptied and there is no registered producer. Nr* r* r* r* r+ �loseWriteConnectionE r1 z!ITCPTransport.loseWriteConnectionc C r/ )z� Close the connection abruptly. Discards any buffered data, stops any registered producer, and, if possible, notifies the other end of the unclean closure. @since: 11.1 Nr* r* r* r* r+ �abortConnectionP r1 z ITCPTransport.abortConnectionc C r/ )z6 Return if C{TCP_NODELAY} is enabled. Nr* r* r* r* r+ � getTcpNoDelay[ r1 zITCPTransport.getTcpNoDelay�enabledc C r/ )z� Enable/disable C{TCP_NODELAY}. Enabling C{TCP_NODELAY} turns off Nagle's algorithm. Small packets are sent sooner, possibly at the expense of overall throughput. Nr* �r+ r* r* r+ � setTcpNoDelay` r1 zITCPTransport.setTcpNoDelayc C r/ )z7 Return if C{SO_KEEPALIVE} is enabled. Nr* r* r* r* r+ �getTcpKeepAliveh r1 z ITCPTransport.getTcpKeepAlivec C r/ )a Enable/disable C{SO_KEEPALIVE}. Enabling C{SO_KEEPALIVE} sends packets periodically when the connection is otherwise idle, usually once every two hours. They are intended to allow detection of lost peers in a non-infinite amount of time. Nr* r, r* r* r+ �setTcpKeepAlivem r1 z ITCPTransport.setTcpKeepAlive�r r c C r/ �z; Returns L{IPv4Address} or L{IPv6Address}. Nr* r* r* r* r+ r� v r1 zITCPTransport.getHostc C r/ r1 r* r* r* r* r+ r& { r1 zITCPTransport.getPeerr5 )r& r' r( r) r( r) r| r* r- r. r/ r r� r& r* r* r* r+ r' @ s r' c @ r )�IUNIXTransportz@ Transport for stream-oriented unix domain connections. r r. Nc C r/ )ax Send a duplicate of this (file, socket, pipe, etc) descriptor to the other end of this connection. The send is non-blocking and will be queued if it cannot be performed immediately. The send will be processed in order with respect to other C{sendFileDescriptor} calls on this transport, but not necessarily with respect to C{write} calls on this transport. The send can only be processed if there are also bytes in the normal connection-oriented send buffer (ie, you must call C{write} at least as many times as you call C{sendFileDescriptor}). @param descriptor: An C{int} giving a valid file descriptor in this process. Note that a I{file descriptor} may actually refer to a socket, a pipe, or anything else POSIX tries to treat in the same way as a file. Nr* r r* r* r+ �sendFileDescriptor� r1 z!IUNIXTransport.sendFileDescriptor)r& r' r( r) r= r3 r* r* r* r+ r2 � s r2 c @ �" e Zd ZdZ d dd�ZdS ) � IOpenSSLServerConnectionCreatoraX A provider of L{IOpenSSLServerConnectionCreator} can create L{OpenSSL.SSL.Connection} objects for TLS servers. @see: L{twisted.internet.ssl} @note: Creating OpenSSL connection objects is subtle, error-prone, and security-critical. Before implementing this interface yourself, consider using L{twisted.internet.ssl.CertificateOptions} as your C{contextFactory}. (For historical reasons, that class does not actually I{implement} this interface; nevertheless it is usable in all Twisted APIs which require a provider of this interface.) � tlsProtocolr r. �OpenSSLConnectionc C r/ )z� Create a connection for the given server protocol. @return: an OpenSSL connection object configured appropriately for the given Twisted protocol. Nr* �r6 r* r* r+ �serverConnectionForTLS� r1 z6IOpenSSLServerConnectionCreator.serverConnectionForTLSN�r6 r r. r7 )r& r' r( r) r9 r* r* r* r+ r5 � s ��r5 c @ r4 ) � IOpenSSLClientConnectionCreatora� A provider of L{IOpenSSLClientConnectionCreator} can create L{OpenSSL.SSL.Connection} objects for TLS clients. @see: L{twisted.internet.ssl} @note: Creating OpenSSL connection objects is subtle, error-prone, and security-critical. Before implementing this interface yourself, consider using L{twisted.internet.ssl.optionsForClientTLS} as your C{contextFactory}. r6 r r. r7 c C r/ )z� Create a connection for the given client protocol. @param tlsProtocol: the client protocol making the request. @return: an OpenSSL connection object configured appropriately for the given Twisted protocol. Nr* r8 r* r* r+ �clientConnectionForTLS� r1 z6IOpenSSLClientConnectionCreator.clientConnectionForTLSNr: )r& r' r( r) r< r* r* r* r+ r; � s ��r; c @ r� )�IProtocolNegotiationFactoryaL A provider of L{IProtocolNegotiationFactory} can provide information about the various protocols that the factory can create implementations of. This can be used, for example, to provide protocol names for Next Protocol Negotiation and Application Layer Protocol Negotiation. @see: L{twisted.internet.ssl} r. c C r/ )z� Returns a list of protocols that can be spoken by the connection factory in the form of ALPN tokens, as laid out in the IANA registry for ALPN tokens. @return: a list of ALPN tokens in order of preference. Nr* r* r* r* r+ �acceptableProtocols� r1 z/IProtocolNegotiationFactory.acceptableProtocolsN)r& r' r( r) r r� r> r* r* r* r+ r= � s r= c @ s e Zd ZdZddd�ZdS )rt a5 A provider of L{IOpenSSLContextFactory} is capable of generating L{OpenSSL.SSL.Context} classes suitable for configuring TLS on a connection. A provider will store enough state to be able to generate these contexts as needed for individual connections. @see: L{twisted.internet.ssl} r. �OpenSSLContextc C r/ )z� Returns a TLS context object, suitable for securing a TLS connection. This context object will be appropriately customized for the connection based on the state in this object. @return: A TLS context object. Nr* r* r* r* r+ � getContext� r1 z!IOpenSSLContextFactory.getContextN)r. r? )r& r' r( r) r@ r* r* r* r+ rt � r rt c @ s* e Zd ZdZdeeef ddfdd�ZdS )� ITLSTransportz� A TCP transport that supports switching to TLS midstream. Once TLS mode is started the transport will implement L{ISSLTransport}. rr r. Nc C r/ )a� Initiate TLS negotiation. @param contextFactory: An object which creates appropriately configured TLS connections. For clients, use L{twisted.internet.ssl.optionsForClientTLS}; for servers, use L{twisted.internet.ssl.CertificateOptions}. @type contextFactory: L{IOpenSSLClientConnectionCreator} or L{IOpenSSLServerConnectionCreator}, depending on whether this L{ITLSTransport} is a server or not. If the appropriate interface is not provided by the value given for C{contextFactory}, it must be an implementor of L{IOpenSSLContextFactory}. Nr* )rr r* r* r+ �startTLS� r1 zITLSTransport.startTLS)r& r' r( r) r r; r5 rB r* r* r* r+ rA � s ���rA c @ r� )� ISSLTransportz$ A SSL/TLS based transport. r. c C r/ )zD Return an object with the peer's certificate info. Nr* r* r* r* r+ �getPeerCertificate r1 z ISSLTransport.getPeerCertificateN)r& r' r( r) r� rD r* r* r* r+ rC r� rC c @ � e Zd ZdZed�ZdS )� INegotiatedz� A TLS based transport that supports using ALPN/NPN to negotiate the protocol to be used inside the encrypted tunnel. aC The protocol selected to be spoken using ALPN/NPN. The result from ALPN is preferred to the result from NPN if both were used. If the remote peer does not support ALPN or NPN, or neither NPN or ALPN are available on this machine, will be L{None}. Otherwise, will be the name of the selected protocol as C{bytes}. Note that until the handshake has completed this property may incorrectly return L{None}: wait until data has been received before trusting it (see https://twistedmatrix.com/trac/ticket/6024). N)r& r' r( r) r �negotiatedProtocolr* r* r* r+ rF s �rF c @ rE )�ICipherz A TLS cipher. z5The fully qualified name of the cipher in L{unicode}.N)r& r' r( r) r �fullNamer* r* r* r+ rH 2 s rH c @ s* e Zd ZdZdee dee fdd�ZdS )�IAcceptableCiphersz9 A list of acceptable ciphers for a TLS context. �availableCiphersr. c C r/ )a� Choose which ciphers to allow to be negotiated on a TLS connection. @param availableCiphers: A L{tuple} of L{ICipher} which gives the names of all ciphers supported by the TLS implementation in use. @return: A L{tuple} of L{ICipher} which represents the ciphers which may be negotiated on the TLS connection. The result is ordered by preference with more preferred ciphers appearing earlier. Nr* )rK r* r* r+ � selectCiphers? r1 z IAcceptableCiphers.selectCiphersN)r& r' r( r) r rH rL r* r* r* r+ rJ : s rJ c @ s� e Zd ZdZed�Zddd�Zddd�Zdd d �Zd e ddfd d �Z de de ddfdd�Z ddd�Z deee f ddfdd�ZdS )r� z A process transport. z�From before L{IProcessProtocol.makeConnection} is called to before L{IProcessProtocol.processEnded} is called, C{pid} is an L{int} giving the platform process ID of this process. C{pid} is L{None} at all other times.r. Nc C r/ )zB Close stdin after all data has been written out. Nr* r* r* r* r+ � closeStdinY r1 z IProcessTransport.closeStdinc C r/ )z Close stdout. Nr* r* r* r* r+ � closeStdout^ r1 z IProcessTransport.closeStdoutc C r/ )z Close stderr. Nr* r* r* r* r+ � closeStderrc r1 z IProcessTransport.closeStderrr c C r/ )z� Close a file descriptor which is connected to the child process, identified by its FD in the child process. Nr* r r* r* r+ � closeChildFDh r1 z IProcessTransport.closeChildFDr r� c C r/ )a� Similar to L{ITransport.write} but also allows the file descriptor in the child process which will receive the bytes to be specified. @param childFD: The file descriptor to which to write. @param data: The bytes to write. @raise KeyError: If C{childFD} is not a file descriptor that was mapped in the child when L{IReactorProcess.spawnProcess} was used to create it. Nr* r r* r* r+ � writeToChildn r1 z IProcessTransport.writeToChildc C r/ )z1 Close stdin, stderr and stdout. Nr* r* r* r* r+ r% { r1 z IProcessTransport.loseConnection�signalIDc C r/ )a* Send a signal to the process. @param signalID: can be - one of C{"KILL"}, C{"TERM"}, or C{"INT"}. These will be implemented in a cross-platform manner, and so should be used if possible. - an integer, where it represents a POSIX signal ID. @raise twisted.internet.error.ProcessExitedAlready: If the process has already exited. @raise OSError: If the C{os.kill} call fails with an errno different from C{ESRCH}. Nr* )rR r* r* r+ � signalProcess� r1 z IProcessTransport.signalProcessr5 )r& r' r( r) r �pidrM rN rO r= rP r� rQ r% r r< rS r* r* r* r+ r� M s � r� c @ sF e Zd ZdZdedefdd�Zdeddfdd �Zdeddfd d �ZdS ) �IServiceCollectionzF An object which provides access to a collection of services. � serviceNamer. c C r/ )z� Retrieve the named service from this application. Raise a C{KeyError} if there is no such service name. Nr* )rV r* r* r+ �getServiceNamed� r1 z"IServiceCollection.getServiceNamed�serviceNc C r/ )z3 Add a service to this collection. Nr* �rX r* r* r+ � addService� r1 z IServiceCollection.addServicec C r/ )z8 Remove a service from this collection. Nr* rY r* r* r+ � removeService� r1 z IServiceCollection.removeService) r& r' r( r) r< r� rW rZ r[ r* r* r* r+ rU � s rU c @ s� e Zd ZdZdedeeeef ddfdd�Z ded eddfd d �Z de d fd d�Z ded fdd�Z deddfdd�Zdefdd�ZdS )� IUDPTransportz. Transport for UDP DatagramProtocols. �packetr r. Nc C r/ )a` Write packet to given address. @param addr: a tuple of (ip, port). For connected transports must be the address the transport is connected to, or None. In non-connected mode this is mandatory. @raise twisted.internet.error.MessageLengthError: C{packet} was too long. Nr* �r] r r* r* r+ r � r1 zIUDPTransport.writerm rg c C r/ )a� Connect the transport to an address. This changes it to connected mode. Datagrams can only be sent to this address, and will only be received from this address. In addition the protocol's connectionRefused method might get called if destination is not receiving datagrams. @param host: an IP address, not a domain name ('127.0.0.1', not 'localhost') @param port: port to connect to. Nr* )rm rg r* r* r+ r3 � r1 zIUDPTransport.connectr0 c C r/ )zk Get this port's host address. @return: an address describing the listening port. Nr* r* r* r* r+ r� � r1 zIUDPTransport.getHostr c C r/ )z� Stop listening on this port. If it does not complete immediately, will return L{Deferred} that fires upon completion. Nr* r* r* r* r+ r� � r1 zIUDPTransport.stopListeningr+ c C r/ )zo Set whether this port may broadcast. @param enabled: Whether the port may broadcast. Nr* r, r* r* r+ �setBroadcastAllowed� r1 z!IUDPTransport.setBroadcastAllowedc C r/ )z{ Checks if broadcast is currently allowed on this port. @return: Whether this port may broadcast. Nr* r* r* r* r+ �getBroadcastAllowed� r1 z!IUDPTransport.getBroadcastAllowed)r& r' r( r) r� r r r< r= r r3 r r� r� r| r_ r` r* r* r* r+ r\ � s " r\ c @ s0 e Zd ZdZdededdfdd�Zd d d �ZdS ) �IUNIXDatagramTransportz, Transport for UDP PacketProtocols. r] r r. Nc C r/ )z0 Write packet to given address. Nr* r^ r* r* r+ r � r1 z IUNIXDatagramTransport.writer c C r/ �z) Returns L{UNIXAddress}. Nr* r* r* r* r+ r� � r1 z IUNIXDatagramTransport.getHost�r. r )r& r' r( r) r� r< r r� r* r* r* r+ ra � s ra c @ s6 e Zd ZdZdeddfdd�Zd dd �Zd d d �ZdS ) � IUNIXDatagramConnectedTransportz5 Transport for UDP ConnectedPacketProtocols. r] r. Nc C r/ )z> Write packet to address we are connected to. Nr* )r] r* r* r+ r � r1 z%IUNIXDatagramConnectedTransport.writer c C r/ rb r* r* r* r* r+ r� r1 z'IUNIXDatagramConnectedTransport.getHostc C r/ rb r* r* r* r* r+ r& r1 z'IUNIXDatagramConnectedTransport.getPeerrc )r& r' r( r) r� r r� r& r* r* r* r+ rd � s rd c @ s� e Zd ZdZdefdd�Zdeddfdd�Zdefd d �Zd eddfd d �Z de fdd�Z de ddfdd�Z dededdfdd�Z dededdfdd�ZdS )�IMulticastTransportz5 Additional functionality for multicast UDP. r. c C r/ )zA Return interface of outgoing multicast packets. Nr* r* r* r* r+ �getOutgoingInterface r1 z(IMulticastTransport.getOutgoingInterfacer Nc C r/ )ze Set interface for outgoing multicast packets. Returns Deferred of success. Nr* r r* r* r+ �setOutgoingInterface r1 z(IMulticastTransport.setOutgoingInterfacec C r/ )z5 Return if loopback mode is enabled. Nr* r* r* r* r+ �getLoopbackMode r1 z#IMulticastTransport.getLoopbackModery c C r/ )z2 Set if loopback mode is enabled. Nr* )ry r* r* r+ �setLoopbackMode! r1 z#IMulticastTransport.setLoopbackModec C r/ )z9 Get time to live for multicast packets. Nr* r* r* r* r+ �getTTL& r1 zIMulticastTransport.getTTL�ttlc C r/ )z8 Set time to live on multicast packets. Nr* )rk r* r* r+ �setTTL+ r1 zIMulticastTransport.setTTLrj zDeferred[None]c C r/ )z� Join a multicast group. Returns L{Deferred} of success or failure. If an error occurs, the returned L{Deferred} will fail with L{error.MulticastJoinError}. Nr* �r rj r* r* r+ � joinGroup0 r1 z IMulticastTransport.joinGroupc C r/ )zG Leave multicast group, return L{Deferred} of success. Nr* rm r* r* r+ � leaveGroup8 r1 z IMulticastTransport.leaveGroup)r& r' r( r) r< rf rg r| rh ri r= rj rl rn ro r* r* r* r+ re s re c @ �" e Zd ZdZdeddfdd�ZdS )�IStreamClientEndpointz� A stream client endpoint is a place that L{ClientFactory} can connect to. For example, a remote TCP host/port pair would be a TCP client endpoint. @since: 10.1 �protocolFactoryr. zDeferred[IProtocol]c C r/ )a� Connect the C{protocolFactory} to the location specified by this L{IStreamClientEndpoint} provider. @param protocolFactory: A provider of L{IProtocolFactory} @return: A L{Deferred} that results in an L{IProtocol} upon successful connection otherwise a L{Failure} wrapping L{ConnectError} or L{NoProtocol <twisted.internet.error.NoProtocol>}. Nr* �rr r* r* r+ r3 F r1 z IStreamClientEndpoint.connectN)r& r' r( r) r r3 r* r* r* r+ rq > r rq c @ rp )�IStreamServerEndpointzz A stream server endpoint is a place that a L{Factory} can listen for incoming connections. @since: 10.1 rr r. zDeferred[IListeningPort]c C r/ )a, Listen with C{protocolFactory} at the location specified by this L{IStreamServerEndpoint} provider. @param protocolFactory: A provider of L{IProtocolFactory} @return: A L{Deferred} that results in an L{IListeningPort} or an L{CannotListenError} Nr* rs r* r* r+ �listen[ r1 z IStreamServerEndpoint.listenN)r& r' r( r) r ru r* r* r* r+ rt S r rt c @ �2 e Zd ZdZed�Zdedededefdd�Z d S ) �!IStreamServerEndpointStringParserz� An L{IStreamServerEndpointStringParser} is like an L{IStreamClientEndpointStringParserWithReactor}, except for L{IStreamServerEndpoint}s instead of clients. It integrates with L{endpoints.serverFromString} in much the same way. a A C{str}, the description prefix to respond to. For example, an L{IStreamServerEndpointStringParser} plugin which had C{"foo"} for its C{prefix} attribute would be called for endpoint descriptions like C{"foo:bar:baz"} or C{"foo:"}. �reactorr� r� r. c O r/ )z� Parse a stream server endpoint from a reactor and string-only arguments and keyword arguments. @see: L{IStreamClientEndpointStringParserWithReactor.parseStreamClient} @return: a stream server endpoint Nr* �rx r� r� r* r* r+ �parseStreamServerx r1 z3IStreamServerEndpointStringParser.parseStreamServerN) r& r' r( r) r �prefixr� r� rt rz r* r* r* r+ rw g s � ����rw c @ rv ) �,IStreamClientEndpointStringParserWithReactora� An L{IStreamClientEndpointStringParserWithReactor} is a parser which can convert a set of string C{*args} and C{**kwargs} into an L{IStreamClientEndpoint} provider. This interface is really only useful in the context of the plugin system for L{endpoints.clientFromString}. See the document entitled "I{The Twisted Plugin System}" for more details on how to write a plugin. If you place an L{IStreamClientEndpointStringParserWithReactor} plugin in the C{twisted.plugins} package, that plugin's C{parseStreamClient} method will be used to produce endpoints for any description string that begins with the result of that L{IStreamClientEndpointStringParserWithReactor}'s prefix attribute. a! L{bytes}, the description prefix to respond to. For example, an L{IStreamClientEndpointStringParserWithReactor} plugin which had C{b"foo"} for its C{prefix} attribute would be called for endpoint descriptions like C{b"foo:bar:baz"} or C{b"foo:"}. rx r� r� r. c O r/ )a� This method is invoked by L{endpoints.clientFromString}, if the type of endpoint matches the return value from this L{IStreamClientEndpointStringParserWithReactor}'s C{prefix} method. @param reactor: The reactor passed to L{endpoints.clientFromString}. @param args: The byte string arguments, minus the endpoint type, in the endpoint description string, parsed according to the rules described in L{endpoints.quoteStringArgument}. For example, if the description were C{b"my-type:foo:bar:baz=qux"}, C{args} would be C{(b'foo', b'bar')} @param kwargs: The byte string arguments from the endpoint description passed as keyword arguments. For example, if the description were C{b"my-type:foo:bar:baz=qux"}, C{kwargs} would be C{dict(baz=b'qux')}. @return: a client endpoint Nr* ry r* r* r+ �parseStreamClient� r1 z>IStreamClientEndpointStringParserWithReactor.parseStreamClientN) r& r' r( r) r r{ r� r� rq r} r* r* r* r+ r| � s � ����r| c @ rE )� _ISupportsExitSignalCapturinga An implementor of L{_ISupportsExitSignalCapturing} will capture the value of any delivered exit signal (SIGINT, SIGTERM, SIGBREAK) for which it has installed a handler. The caught signal number is made available in the _exitSignal attribute. z� C{int} or C{None}, the integer exit signal delivered to the application, or None if no signal was delivered. N)r& r' r( r) r � _exitSignalr* r* r* r+ r~ � s �r~ N)xr) �typingr r r r r r r r r r r �zope.interfacer r �twisted.python.failurer �socketr � OpenSSL.SSLr r7 r r? � ImportErrorr� �twisted.internet.abstractr �twisted.internet.addressr r r �twisted.internet.deferr �twisted.internet.protocolr r r r r �twisted.internet.sslr �twisted.names.dnsr r �twisted.protocols.tlsr �twisted.python.runtimer! �supportsThreads�twisted.python.threadpoolr" r$ r- r6 r> r@ rF rM rf rq rv r} r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rk r� r� r� r� r� r� r� r� r� r r r r� r r r r r r' r2 r5 r; r= rt rA rC rF rH rJ r� rU r\ ra rd re rq rt rw r| r~ r* r* r* r+ �<module> s� 4 � !!( U0,), |c#: ? !-.6" AA F<3 1PK Mb�Z��!W� � * internet/__pycache__/defer.cpython-310.pycnu �[��� o 5�@g�N � @ sd U d Z ddlZddlZddlmZmZ ddlmZmZm Z ddl m Z ddl m Z ddlmZmZ ddlmZmZ dd lmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z' ddl(Z(dd l)m*Z* dd l+m,Z,m-Z- dd l.m/Z/ dd l0m1Z1 ddl2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8 ddl9m:Z:m;Z; z ddl<m=Z> dZ?W n e@y� dZ?G dd� d�ZAde#eA fdd�ZBY nw e>ZBe/� ZCe$d�ZDG dd� deE�ZFG d d � d eE�ZGG d d � d eE�ZHG d d!� d!eI�ZJd"e:de:fd#d$�ZKd%eDdd&fd'd(�ZLd�d%e!e%e:eMf dd)fd*d+�ZNd,ed-eDf d.eOd/eOdd&fd0d1�ZPd2ed-eDf d.eOd/eOdd&fd3d4�ZQe7e*d5d6d7d�d8d9�d�d<d=��ZRd>eDdeDfd?d@�ZSd>e:de:fdAdB�ZTdCeUddfdDdE�ZVdeUfdFdG�ZWdHeDd=eXdeDfdIdJ�ZYG dKdL� dLe �ZZeZj[Z[eZj\Z\ed-eOf Z]ed-eOf Z^e"eOd-f Z_e e`eOf Zae"e"e%e]e eZj\ f e_eaf e"e%e^e]e eZj\ f e_eaf f Zbei �ZceaeddM< e$dNddO�Zee$dPddQ�ZfG dRdS� dS�ZgG dTdU� dUeee �ZhdVe%eeheD eeDf eeheD eeDf eheD f deheD fdWdX�Zie5G dYdZ� dZeE��Zje"eeekf Zle"eUeef Zme em Zne�rle' d�d[e ehee d\e d d]eUd^eUdehel f d_d`��Zoe' d�d[e ehee d\e d d]eUd^eUdehen f dad`��Zo d�d[e ehee d\eUd]eUd^eUde%ehel ehen f f dbd`�ZoeoZpG dcdd� ddehen �Zp d�dee em d]eUde eD fdfdg�Zq d�d[e eheD d^eUdehe eD fdhdi�ZrdZsdZtG djdk� dk�ZueeOddf Zvdlevd:eheO dehe fdmdn�Zwe7e*d5dodd�dp�d2ed-evf ded-eheO f fdqdr��ZxG dsdt� dteM�ZydueOde fdvdw�Zze(j{ddx�G dydz� dz��Z|e;d%eOd{e%eeheD eOdf eeheD eOdf f d|e|ddfd}d~��Z}d{e%ed&eOeDf ed&eOeDf f deheD fdd��Z~G d�d�� d�eE�Zd2ed-eeheO eOeDf f ded-eheD f fd�d��Z�e$d�d�d��Z�G d�d�� d�eeee �Z�e$d�d�d��Z�G d�d�� d�e��Z�e$d�d�d��Z�G d�d�� d�e��Z�G d�d�� d�eE�Z�G d�d�� d�eE�Z�G d�d�� d�eeD �Z�G d�d�� d�eE�Z�G d�d�� d�e1j��Z�g d��Z�dS )�zU Support for results that aren't immediately available. Maintainer: Glyph Lefkowitz � N)�ABC�abstractmethod)�AbstractEventLoop�Future� iscoroutine)�Enum)�wraps)�exc_info� version_info)� GeneratorType�MappingProxyType)� TYPE_CHECKING�Any� Awaitable�Callable� Coroutine� Generator�Generic�Iterable�List�Literal�Mapping�NoReturn�Optional�Tuple�Type�TypeVar�Union�cast�overload)�Version)� IDelayedCall� IReactorTime)�Logger)�lockfile)�_PYPY�cmp� comparable)� deprecated�warnAboutFunction)�Failure� _extraneous)� copy_contextTFc @ s2 e Zd Zededef dededefdd��ZdS ) � _NoContext�f.�args�kwargs�returnc O s | |i |��S �N� )r. r/ r0 r3 r3 �8/usr/lib/python3/dist-packages/twisted/internet/defer.py�run< s z_NoContext.runN)�__name__� __module__� __qualname__� staticmethodr �objectr5 r3 r3 r3 r4 r- ; s (r- r1 c C s t S r2 )r- r3 r3 r3 r4 � _copy_context@ � r; �_Tc @ � e Zd ZdZdS )�AlreadyCalledErrorz� This error is raised when one of L{Deferred.callback} or L{Deferred.errback} is called after one of the two had already been called. N�r6 r7 r8 �__doc__r3 r3 r3 r4 r? M � r? c @ r> )�CancelledErrorzJ This error is raised by default when a L{Deferred} is cancelled. Nr@ r3 r3 r3 r4 rC T rB rC c @ r> )� TimeoutErrorzG This error is raised by default when a L{Deferred} times out. Nr@ r3 r3 r3 r4 rD Z rB rD c @ r> )�NotACoroutineErrorzb This error is raised when a coroutine is expected and something else is encountered. Nr@ r3 r3 r3 r4 rE ` rB rE �errc C s t �d| � | S )a- Log and return failure. This method can be used as an errback that passes the failure on to the next errback unmodified. Note that if this is the last errback, and the deferred gets garbage collected after being this errback has been called, the clean up code logs it again. � )�log�failure)rF r3 r3 r4 �logErrorg s rJ �result� Deferred[_T]c C � t � }|�| � |S )a Return a L{Deferred} that has already had C{.callback(result)} called. This is useful when you're writing synchronous code to an asynchronous interface: i.e., some code is calling you expecting a L{Deferred} result, but you don't actually need to do anything asynchronous. Just return C{defer.succeed(theResult)}. See L{fail} for a version of this function that uses a failing L{Deferred} rather than a successful one. @param result: The result to give to the Deferred's 'callback' method. )�Deferred�callback�rK �dr3 r3 r4 �succeedt s rR � Deferred[Any]c C rM )a2 Return a L{Deferred} that has already had C{.errback(result)} called. See L{succeed}'s docstring for rationale. @param result: The same argument that L{Deferred.errback} takes. @raise NoCurrentExceptionError: If C{result} is L{None} but there is no current exception state. )rN �errbackrP r3 r3 r4 �fail� s rU �callable.r/ r0 c O s2 z | |i |��}W t|�S t y t� Y S w )a Create a L{Deferred} from a callable and arguments. Call the given function with the given arguments. Return a L{Deferred} which has been fired with its callback as the result of that invocation or its C{errback} with a L{Failure} for the exception thrown. )� BaseExceptionrU rR )rV r/ r0 rK r3 r3 r4 �execute� s � �rX r. c O s^ z | |i |��}W n t y tttjd�� Y S w t|t�r"|S t|t�r+t|�S t|�S )a� Invoke a function that may or may not return a L{Deferred}. Call the given function with the given arguments. If the returned object is a L{Deferred}, return it. If the returned object is a L{Failure}, wrap it with L{fail} and return it. Otherwise, wrap it in L{succeed} and return it. If an exception is raised, convert it to a L{Failure}, wrap it in L{fail}, and then return it. @param f: The callable to invoke @param args: The arguments to pass to C{f} @param kwargs: The keyword arguments to pass to C{f} @return: The result of the function call, wrapped in a L{Deferred} if necessary. �� captureVars)rW rU r* rN �debug� isinstancerR )r. r/ r0 rK r3 r3 r4 � maybeDeferred� s � r] �Twisted� � z*twisted.internet.defer.Deferred.addTimeout)� replacement�deferred�Deferred[object]c C s | � ttd��� d S )NzCallback timed out)rT r* rD �rb r3 r3 r4 �timeout� s re �argc C � | S r2 r3 �rf r3 r3 r4 �passthru� r< ri c C rg r2 r3 rh r3 r3 r4 � _failthru� r< rj �onc C s t | �t_dS )z� Enable or disable L{Deferred} debugging. When debugging is on, the call stacks from creation and invocation are recorded, and added to any L{AlreadyCalledError}s we raise. N)�boolrN r[ )rk r3 r3 r4 � setDebugging� s rm c C s t jS )z= Determine whether L{Deferred} debugging is enabled. )rN r[ r3 r3 r3 r4 � getDebugging� s rn �valuec C s" t | t�r| �t� t|d��| S )a� A default translation function that translates L{Failure}s that are L{CancelledError}s to L{TimeoutError}s. @param value: Anything @param timeout: The timeout @raise TimeoutError: If C{value} is a L{Failure} that is a L{CancelledError}. @raise Exception: If C{value} is a L{Failure} that is not a L{CancelledError}, it is re-raised. @since: 16.5 rN )r\ r* �traprC rD )ro re r3 r3 r4 �_cancelledToTimedOutError� s rq c @ s e Zd ZdZe� Ze� ZdS )� _Sentinela� @cvar _NO_RESULT: The result used to represent the fact that there is no result. B{Never ever ever use this as an actual result for a Deferred}. You have been warned. @cvar _CONTINUE: A marker left in L{Deferred.callback}s to indicate a Deferred chain. Always accompanied by a Deferred instance in the args tuple pointing at the Deferred which is chained to the Deferred which has this marker. N)r6 r7 r8 rA r: � _NO_RESULT� _CONTINUEr3 r3 r3 r4 rr � s rr � _NONE_KWARGS�_DeferredResultT)� contravariant�_NextDeferredResultT)� covariantc @ sb e Zd ZU dZdZee ed< dZee e ed< dZ ee e ed< de fdd�Z d d d �Z dS ) � DebugInfoz Deferred debug helper. N� failResult�creator�invokerr1 c C st d}| j d ur |d7 }|d�| j ��� �dd�7 }|d7 }| jd ur8|d7 }|d�| j��� �dd�7 }|d7 }|S )NrG z C: Deferred was created: C:� z C:z I: First Invoker was: I:z I:)r| �join�rstrip�replacer} )�self�infor3 r3 r4 �_getDebugTracebacks: s z DebugInfo._getDebugTracebacksc C sH | j dur"tjddd� | �� }|rd}nd}tj|| j |d� dS dS )z� Print tracebacks and die. If the *last* (and I do mean *last*) callback leaves me in an error state, print a traceback (if said errback is a L{Failure}). Nz Unhandled error in Deferred:T)�isErrorz(debug: {debugInfo})rG )� debugInfo)r{ rH �criticalr� rI )r� r� �formatr3 r3 r4 �__del__F s �zDebugInfo.__del__�r1 N)r6 r7 r8 rA r{ r r* �__annotations__r| r �strr} r� r� r3 r3 r3 r4 rz 1 s rz c @ s^ e Zd ZU dZdZdZdZee e d< dZ dZ dZ dZ de d< dRdeed gdf d dfd d �Zed ed efded ded dedededed dfdd�Zded deded dfdd �Zded deded d fd d �Zded deded dfd d!�Z dRd"ed#ed$eeeegef d d%fd&d'�ZdSd*d+�Z d,e e e f d dfd-d.�Z dRd/ee e e!f d dfd0d1�Z"dTd2d3�Z#dTd4d5�Z$dTd6d7�Z%d,ed dfd8d9�Z&d e'fd:d;�Z(dTd<d=�Z)d e*fd>d?�Z+e+Z,dUd@dA�Z-e.dRdBed d%fdCdD��Z/d e0e1de f fdEdF�Z2e/Z3dGe4d dHfdIdJ�Z5e6dKe7d d fdLdM��Z8e6dNe e9dOe1e:f e0dOe1e:f f d dOfdPdQ��Z;dS )VrN a This is a callback which will be put off until later. Why do we want this? Well, in cases where a function in a threaded program would block until it gets a result, for Twisted it should not block. Instead, it should return a L{Deferred}. This can be implemented for protocols that run over the network by writing an asynchronous protocol for L{twisted.internet}. For methods that come from outside packages that are not under our control, we use threads (see for example L{twisted.enterprise.adbapi}). For more information about Deferreds, see doc/core/howto/defer.html or U{http://twistedmatrix.com/documents/current/core/howto/defer.html} When creating a Deferred, you may provide a canceller function, which will be called by d.cancel() to let you do any clean-up necessary if the user decides not to wait for the deferred to complete. @ivar called: A flag which is C{False} until either C{callback} or C{errback} is called and afterwards always C{True}. @ivar paused: A counter of how many unmatched C{pause} calls have been made on this instance. @ivar _suppressAlreadyCalled: A flag used by the cancellation mechanism which is C{True} if the Deferred has no canceller and has been cancelled, C{False} otherwise. If C{True}, it can be expected that C{callback} or C{errback} will eventually be called and the result should be silently discarded. @ivar _runningCallbacks: A flag which is C{True} while this instance is executing its callback chain, used to stop recursive execution of L{_runCallbacks} @ivar _chainedTo: If this L{Deferred} is waiting for the result of another L{Deferred}, this is a reference to the other Deferred. Otherwise, L{None}. Fr N� _debugInfozOptional[Deferred[Any]]� _chainedTo� cancellerrS r1 c C s6 g | _ || _| jrt� | _t�� dd� | j_dS dS )aH Initialize a L{Deferred}. @param canceller: a callable used to stop the pending operation scheduled by this L{Deferred} when L{Deferred.cancel} is invoked. The canceller will be passed the deferred whose cancellation is requested (i.e., C{self}). If a canceller is not given, or does not invoke its argument's C{callback} or C{errback} method, L{Deferred.cancel} will invoke L{Deferred.errback} with a L{CancelledError}. Note that if a canceller is not given, C{callback} or C{errback} may still be invoked exactly once, even though defer.py will have already invoked C{errback}, as described above. This allows clients of code which returns a L{Deferred} to cancel it without requiring the L{Deferred} instantiator to provide any specific implementation support for cancellation. New in 10.1. @type canceller: a 1-argument callable which takes a L{Deferred}. The return result is ignored. N���)� callbacks� _cancellerr[ rz r� � traceback� format_stackr| �r� r� r3 r3 r4 �__init__� s �zDeferred.__init__r3 rO ).z;Union[_NextDeferredResultT, Deferred[_NextDeferredResultT]]rT ).zDUnion[Failure, _NextDeferredResultT, Deferred[_NextDeferredResultT]]� callbackArgs�callbackKeywords� errbackArgs�errbackKeywordsz Deferred[_NextDeferredResultT]c C s� |du rt }|du r d}|du ri }|du rd}|du r i }t|�s$J �t|�s*J �| j�|||f|||ff� | jr?| �� ttt | �S )z� Add a pair of callbacks (success and error) to this L{Deferred}. These will be executed when the 'master' callback is run. @return: C{self}. Nr3 ) rj rV r� �append�called� _runCallbacksr rN rx )r� rO rT r� r� r� r� r3 r3 r4 � addCallbacks� s( ��zDeferred.addCallbacksr/ r0 c O s | j |||d�S )z^ Convenience method for adding just a callback. See L{addCallbacks}. )r� r� �r� �r� rO r/ r0 r3 r3 r4 � addCallback� � zDeferred.addCallbackz7Deferred[Union[_DeferredResultT, _NextDeferredResultT]]c O s | j t|||d�S )z^ Convenience method for adding just an errback. See L{addCallbacks}. )r� r� )r� ri )r� rT r/ r0 r3 r3 r4 � addErrback� s �zDeferred.addErrbackc O s | j ||||||d�S )z� Convenience method for adding a single callable as both a callback and an errback. See L{addCallbacks}. )r� r� r� r� r� r� r3 r3 r4 �addBoth s �zDeferred.addBothre �clock�onTimeoutCancel�Deferred[_DeferredResultT]c sz dg�d ��fdd� }|� �|�� dtdtf���fdd� }��|� d tttf dtttf f� fd d � }��|� �S ) a� Time out this L{Deferred} by scheduling it to be cancelled after C{timeout} seconds. The timeout encompasses all the callbacks and errbacks added to this L{defer.Deferred} before the call to L{addTimeout}, and none added after the call. If this L{Deferred} gets timed out, it errbacks with a L{TimeoutError}, unless a cancelable function was passed to its initialization or unless a different C{onTimeoutCancel} callable is provided. @param timeout: number of seconds to wait before timing out this L{Deferred} @param clock: The object which will be used to schedule the timeout. @param onTimeoutCancel: A callable which is called immediately after this L{Deferred} times out, and not if this L{Deferred} is otherwise cancelled before the timeout. It takes an arbitrary value, which is the value of this L{Deferred} at that exact point in time (probably a L{CancelledError} L{Failure}), and the C{timeout}. The default callable (if C{None} is provided) will translate a L{CancelledError} L{Failure} into a L{TimeoutError}. @return: C{self}. @since: 16.5 Fr1 Nc s d�d< � � � d S )NTr )�cancelr3 )r� �timedOutr3 r4 � timeItOutG s z&Deferred.addTimeout.<locals>.timeItOutro c s �d r � pt }|| ��S | S )Nr )rq )ro �toCall)r� r� re r3 r4 �convertCancelledM s z-Deferred.addTimeout.<locals>.convertCancelledrK c s � � � r� �� | S r2 )�activer� �rK )� delayedCallr3 r4 � cancelTimeoutW s z*Deferred.addTimeout.<locals>.cancelTimeoutr� )� callLaterr: r� r rv r* )r� re r� r� r� r� r� r3 )r� r� r� r� re r4 � addTimeout# s " � � zDeferred.addTimeoutrQ �Deferred[None]c C s | |_ | �|j|j�S )a� Chain another L{Deferred} to this L{Deferred}. This method adds callbacks to this L{Deferred} to call C{d}'s callback or errback, as appropriate. It is merely a shorthand way of performing the following:: d1.addCallbacks(d2.callback, d2.errback) When you chain a deferred C{d2} to another deferred C{d1} with C{d1.chainDeferred(d2)}, you are making C{d2} participate in the callback chain of C{d1}. Thus any event that fires C{d1} will also fire C{d2}. However, the converse is B{not} true; if C{d2} is fired, C{d1} will not be affected. Note that unlike the case where chaining is caused by a L{Deferred} being returned from a callback, it is possible to cause the call stack size limit to be exceeded by chaining many L{Deferred}s together with C{chainDeferred}. @return: C{self}. )r� r� rO rT �r� rQ r3 r3 r4 � chainDeferredb s zDeferred.chainDeferredrK c C s t |t�rJ �| �|� dS )a7 Run all success callbacks that have been added to this L{Deferred}. Each callback will have its result passed as the first argument to the next; this way, the callbacks act as a 'processing chain'. If the success-callback returns a L{Failure} or raises an L{Exception}, processing will continue on the *error* callback chain. If a callback (or errback) returns another L{Deferred}, this L{Deferred} will be chained to it (and further callbacks will not run until that L{Deferred} has a result). An instance of L{Deferred} may only have either L{callback} or L{errback} called on it, and only once. @param result: The object which will be passed to the first callback added to this L{Deferred} (via L{addCallback}), unless C{result} is a L{Failure}, in which case the behavior is the same as calling C{errback(result)}. @raise AlreadyCalledError: If L{callback} or L{errback} has already been called on this L{Deferred}. N)r\ rN �_startRunCallbacks)r� rK r3 r3 r4 rO } s zDeferred.callbackrU c C s6 |du r t | jd�}n t|t �st |�}| �|� dS )a� Run all error callbacks that have been added to this L{Deferred}. Each callback will have its result passed as the first argument to the next; this way, the callbacks act as a 'processing chain'. Also, if the error-callback returns a non-Failure or doesn't raise an L{Exception}, processing will continue on the *success*-callback chain. If the argument that's passed to me is not a L{Failure} instance, it will be embedded in one. If no argument is passed, a L{Failure} instance will be created based on the current traceback stack. Passing a string as `fail' is deprecated, and will be punished with a warning message. An instance of L{Deferred} may only have either L{callback} or L{errback} called on it, and only once. @param fail: The L{Failure} object which will be passed to the first errback added to this L{Deferred} (via L{addErrback}). Alternatively, a L{Exception} instance from which a L{Failure} will be constructed (with no traceback) or L{None} to create a L{Failure} instance from the current exception state (with a traceback). @raise AlreadyCalledError: If L{callback} or L{errback} has already been called on this L{Deferred}. @raise NoCurrentExceptionError: If C{fail} is L{None} but there is no current exception state. NrY )r* r[ r\ r� )r� rU r3 r3 r4 rT � s zDeferred.errbackc C s | j d | _ dS )zP Stop processing on a L{Deferred} until L{unpause}() is called. r` N)�paused�r� r3 r3 r4 �pause� s zDeferred.pausec C s, | j d | _ | j r dS | jr| �� dS dS )zI Process all callbacks made since L{pause}() was called. r` N)r� r� r� r� r3 r3 r4 �unpause� s �zDeferred.unpausec C s\ | j s | j}|r || � nd| _| j s | �tt� �� dS dS t| jt�r,| j� � dS dS )a� Cancel this L{Deferred}. If the L{Deferred} has not yet had its C{errback} or C{callback} method invoked, call the canceller function provided to the constructor. If that function does not invoke C{callback} or C{errback}, or if no canceller function was provided, errback with L{CancelledError}. If this L{Deferred} is waiting on another L{Deferred}, forward the cancellation to the other L{Deferred}. TN) r� r� �_suppressAlreadyCalledrT r* rC r\ rK rN r� r� r3 r3 r4 r� � s � �zDeferred.cancelc C s� | j r$| jr d| _d S | jr"| jd u rt� | _d| j�� }t|��t�| jr:| jd u r0t� | _t�� d d� | j_ d| _ || _ | � � d S )NFr~ ���T) r� r� r[ r� rz r� r? r� r� r} rK r� )r� rK �extrar3 r3 r4 r� � s" zDeferred._startRunCallbacksc C s t j| ftft j| ftffS )zT Build a tuple of callback and errback with L{_Sentinel._CONTINUE}. )rr rt ru r� r3 r3 r4 � _continuation� s �zDeferred._continuationc C s | j rdS | g}|�r |d }|jrdS d}d|_|jr�|j�d�}t|jt�s0|d \}}}n|d \}}}|tu rct t t |d �}|j|_d|_|j durTd|j _ | jd8 _|�|� d}nxz&d|_ z ||jg|�R i |��|_|j|u rt|d� W d|_ nd|_ w W n ty� t| jd�|_Y n?w t|jt �r�t|jd t�} | tu s�t| t �s�|jjr�|�� |j|_|jj�|�� � nd|j_|jj dur�d|jj _ | |_|js |�rt|jt�r�|j�� |j du r�t� |_ |j|j _ n |j du�rd|j _ |�� |s dS dS ) a� Run the chain of callbacks once a result is available. This consists of a simple loop over all of the callbacks, calling each with the current result and making the current result equal to the return value (or raised exception) of that call. If L{_runningCallbacks} is true, this loop won't run at all, since it is already running above us on the call stack. If C{self.paused} is true, the loop also won't run, because that's what it means to be paused. The loop will terminate before processing all of the callbacks if a L{Deferred} without a result is encountered. If a L{Deferred} I{with} a result is encountered, that result is taken and the loop proceeds. @note: The implementation is complicated slightly by the fact that chaining (associating two L{Deferred}s with each other such that one will wait for the result of the other, as happens when a Deferred is returned from a callback on another L{Deferred}) is supported iteratively rather than recursively, to avoid running out of stack frames when processing long chains. Nr� Tr r` Fz|Callback returned the Deferred it was attached to; this breaks the callback chain and will raise an exception in the future.rY rK )�_runningCallbacksr� r� r� �popr\ rK r* rt r rN r: r� r{ r� r) rW r[ �getattrrs r� r� � cleanFailurerz ) r� �chain�current�finished�itemrO r/ r0 �chainee� resultResultr3 r3 r4 r� s� ��� �� � �� �P �zDeferred._runCallbacksc C sj | j j}t| dt�}t| �}| jdur dt| j�d��}n |tu r$d}nd|��}d|� d|d�|� d �S ) zE Return a string representation of this L{Deferred}. rK Nz waiting on Deferred at 0x�xrG z current result: �<z at 0x�>)� __class__r6 r� rs �idr� )r� �cnamerK �myIDr3 r3 r4 �__str__� s zDeferred.__str__c C rg r2 r3 r� r3 r3 r4 �__iter__� r< zDeferred.__iter__ro c C sX | j r| S t| dt�}|tu r| S t|t�r(| jd us J �d | j_||j_|j�t |��)NrK ) r� r� rs r\ r* r� r{ ro � __failure__� StopIteration)r� ro rK r3 r3 r4 �send� s z Deferred.sendc C � | � � S r2 )r� r� r3 r3 r4 � __await__� s zDeferred.__await__�loop�Future[_DeferredResultT]c s\ |� � � d �fdd� }dtddf� fdd � }d tddf� fd d � }��||� � �|� � S )a Adapt this L{Deferred} into a L{Future} which is bound to C{loop}. @note: converting a L{Deferred} to an L{Future} consumes both its result and its errors, so this method implicitly converts C{self} into a L{Deferred} firing with L{None}, regardless of what its result previously would have been. @since: Twisted 17.5.0 @param loop: The L{asyncio} event loop to bind the L{Future} to. @return: A L{Future} which will fire when the L{Deferred} fires. � futureAgainr� r1 Nc s | � � r � �� d S d S r2 )� cancelledr� )r� r� r3 r4 � checkCancel� s �z&Deferred.asFuture.<locals>.checkCancelrI c s � � � s � �| j� d S d S r2 )r� � set_exceptionro )rI ��futurer3 r4 � maybeFail� s �z$Deferred.asFuture.<locals>.maybeFailrK c s � � � s � �| � d S d S r2 )r� � set_resultr� r� r3 r4 � maybeSucceed� s �z'Deferred.asFuture.<locals>.maybeSucceed)r� r� r1 N)� create_futurer* r: r� �add_done_callback)r� r� r� r� r� r3 )r� r� r4 �asFuture� s zDeferred.asFuturer� c s� dt ddf� fdd� }t� �dtt ddf��fdd� }| |�}|� dtdtttt f f� �fd d � }|�|� ��|� |S ) a� Adapt a L{Future} to a L{Deferred}. @note: This creates a L{Deferred} from a L{Future}, I{not} from a C{coroutine}; in other words, you will need to call L{asyncio.ensure_future}, L{asyncio.loop.create_task} or create an L{asyncio.Task} yourself to get from a C{coroutine} to a L{Future} if what you have is an awaitable coroutine and not a L{Future}. (The length of this list of techniques is exactly why we have left it to the caller!) @since: Twisted 17.5.0 @param future: The L{Future} to adapt. @return: A L{Deferred} which will fire when the L{Future} fires. rK r1 Nc s4 z| � � }W n ty t� }Y nw � �|� d S r2 )rK rW r* rO )rK � extracted)�actualr3 r4 �adapt s �z"Deferred.fromFuture.<locals>.adapt�reselfc s � � � | ��� d S r2 )r� rO )r� )r� � futureCancelr3 r4 r� s z#Deferred.fromFuture.<locals>.cancelc s | �u r t � � � S | S r2 )rN r� )r� r� r3 r4 �uncancel s z%Deferred.fromFuture.<locals>.uncancel)r r: rN rv r r� r� )�clsr� r� r� r� r� r3 )r� r� r� r4 � fromFuture� s �� zDeferred.fromFuture�cororL c C s( t |�st|t�st|�d���t|�S )a� Schedule the execution of a coroutine that awaits on L{Deferred}s, wrapping it in a L{Deferred} that will fire on success/failure of the coroutine. Coroutine functions return a coroutine object, similar to how generators work. This function turns that coroutine into a Deferred, meaning that it can be used in regular Twisted code. For example:: import treq from twisted.internet.defer import Deferred from twisted.internet.task import react async def crawl(pages): results = {} for page in pages: results[page] = await treq.content(await treq.get(page)) return results def main(reactor): pages = [ "http://localhost:8080" ] d = Deferred.fromCoroutine(crawl(pages)) d.addCallback(print) return d react(main) @since: Twisted 21.2.0 @param coro: The coroutine object to schedule. @raise ValueError: If C{coro} is not a coroutine or generator. z is not a coroutine)r r\ r rE �_cancellableInlineCallbacks)r� r� r3 r3 r4 � fromCoroutine" s ,zDeferred.fromCoroutiner2 )rQ r� r1 r� r� )r1 r� )<r6 r7 r8 rA r� r� r� r rz r� r� r� r[ r� r r� rj ru �_CallbackOrderedArguments�_CallbackKeywordArgumentsr� r: r� r� r� �floatr" r� r� r rv r* rO rW rT r� r� r� r� �_CallbackChainr� r� r� r� �__repr__r� r+ r� r r r� �__next__r r� � classmethodr r� r r= r� r3 r3 r3 r4 rN [ s� $ �� �)����� � � � � �3���� ����� ����� � ���� � ? ' "1 ����rN r� c C s8 t | t�r| S zt�| �W S ty t| �d���w )a� Schedule the execution of a coroutine that awaits/yields from L{Deferred}s, wrapping it in a L{Deferred} that will fire on success/failure of the coroutine. If a Deferred is passed to this function, it will be returned directly (mimicing the L{asyncio.ensure_future} function). See L{Deferred.fromCoroutine} for examples of coroutines. @param coro: The coroutine object to schedule, or a L{Deferred}. z! is not a coroutine or a Deferred)r\ rN r� rE )r� r3 r3 r4 �ensureDeferredT s �r� c @ sT e Zd ZdZdededdfdd�Zdefdd �Zdefd d �Z d e defd d�Z dS )� FirstErrorz� First error to occur in a L{DeferredList} if C{fireOnOneErrback} is set. @ivar subFailure: The L{Failure} that occurred. @ivar index: The index of the L{Deferred} in the L{DeferredList} where it happened. rI �indexr1 Nc C s t �| ||� || _|| _d S r2 )� Exceptionr� � subFailurer� )r� rI r� r3 r3 r4 r� z s zFirstError.__init__c C s d| j | jjf S )z� The I{repr} of L{FirstError} instances includes the repr of the wrapped failure's exception and the index of the L{FirstError}. zFirstError[#%d, %r])r� r� ro r� r3 r3 r4 r� s zFirstError.__repr__c C s d| j | jf S )z� The I{str} of L{FirstError} instances includes the I{str} of the entire wrapped failure (including its traceback and exception) and the index of the L{FirstError}. zFirstError[#%d, %s])r� r� r� r3 r3 r4 r� � s zFirstError.__str__�otherc C s( t |t�rt| j| jf|j|jf�S dS )a+ Comparison between L{FirstError} and other L{FirstError} instances is defined as the comparison of the index and sub-failure of each instance. L{FirstError} instances don't compare equal to anything that isn't a L{FirstError} instance. @since: 8.2 r� )r\ r� r& r� r� )r� r� r3 r3 r4 �__cmp__� s zFirstError.__cmp__) r6 r7 r8 rA r* �intr� r� r� r� r: r� r3 r3 r3 r4 r� p s r� � deferredList�fireOnOneCallback�fireOnOneErrback� consumeErrorsc C � d S r2 r3 �r� r r r r3 r3 r4 � _DeferredList� � r c C r r2 r3 r r3 r3 r4 r � r c C r r2 r3 r r3 r3 r4 r � s c @ sj e Zd ZdZdZdZ ddeee de de de fdd�Z d ed e d e d e e fd d�Z ddd�ZdS )� DeferredLista) L{DeferredList} is a tool for collecting the results of several Deferreds. This tracks a list of L{Deferred}s for their results, and makes a single callback when they have all completed. By default, the ultimate result is a list of (success, result) tuples, 'success' being a boolean. L{DeferredList} exposes the same API that L{Deferred} does, so callbacks and errbacks can be added to it in the same way. L{DeferredList} is implemented by adding callbacks and errbacks to each L{Deferred} in the list passed to it. This means callbacks and errbacks added to the Deferreds before they are passed to L{DeferredList} will change the result that L{DeferredList} sees (i.e., L{DeferredList} is not special). Callbacks and errbacks can also be added to the Deferreds after they are passed to L{DeferredList} and L{DeferredList} may change the result that they see. See the documentation for the C{__init__} arguments for more information. @ivar _deferredList: The L{list} of L{Deferred}s to track. Fr� r r r c C s� t |�| _dgt| j� | _ t�| � t| j�dkr"|s"| �g � || _|| _|| _ d| _ d}| jD ]}|j | j | j |t f|tfd� |d }q3dS )aj Initialize a DeferredList. @param deferredList: The deferreds to track. @param fireOnOneCallback: (keyword param) a flag indicating that this L{DeferredList} will fire when the first L{Deferred} in C{deferredList} fires with a non-failure result without waiting for any of the other Deferreds. When this flag is set, the DeferredList will fire with a two-tuple: the first element is the result of the Deferred which fired; the second element is the index in C{deferredList} of that Deferred. @param fireOnOneErrback: (keyword param) a flag indicating that this L{DeferredList} will fire when the first L{Deferred} in C{deferredList} fires with a failure result without waiting for any of the other Deferreds. When this flag is set, if a Deferred in the list errbacks, the DeferredList will errback with a L{FirstError} failure wrapping the failure of that Deferred. @param consumeErrors: (keyword param) a flag indicating that failures in any of the included L{Deferred}s should not be propagated to errbacks added to the individual L{Deferred}s after this L{DeferredList} is constructed. After constructing the L{DeferredList}, any errors in the individual L{Deferred}s will be converted to a callback result of L{None}. This is useful to prevent spurious 'Unhandled error in Deferred' messages from being logged. This does not prevent C{fireOnOneErrback} from working. Nr )r� r� r` )�list� _deferredList�len� resultListrN r� rO r r r � finishedCountr� � _cbDeferred�SUCCESS�FAILURE)r� r� r r r r� rb r3 r3 r4 r� � s, !� � �zDeferredList.__init__rK r� � succeededr1 c C s� ||f| j |< | jd7 _| jsJ|tkr | jr | �||f� n*|tkr9| jr9t|t �s.J �| � t t ||��� n| jt | j �krJ| �t t| j �� |tkrS| jrSdS |S )zI (internal) Callback for when one of my deferreds fires. r` N)r r r� r r rO r r r\ r* rT r� r r �_DeferredListResultListTr )r� rK r� r r3 r3 r4 r & s zDeferredList._cbDeferredNc C sB | j s | jD ]}z|�� W q ty t�d� Y qw dS dS )a� Cancel this L{DeferredList}. If the L{DeferredList} hasn't fired yet, cancel every L{Deferred} in the list. If the L{DeferredList} has fired, including the case where the C{fireOnOneCallback}/C{fireOnOneErrback} flag is set and the L{DeferredList} fires because one L{Deferred} in the list fires with a non-failure/failure result, do nothing in the C{cancel} method. z-Exception raised from user supplied cancellerN)r� r r� rW rH rI )r� rb r3 r3 r4 r� @ s ��zDeferredList.cancel�FFFr� )r6 r7 r8 rA r r r rN rv rl r� r� r r r� r3 r3 r3 r4 r � s4 � ��� �F��� �r r c C s6 | D ]}|d us J �|\}}|sJ �qdd� | D �S )NTc S s g | ]}|d �qS )r` r3 )�.0r� r3 r3 r4 � <listcomp>\ s z,_parseDeferredListResult.<locals>.<listcomp>r3 )r r rK �successro r3 r3 r4 �_parseDeferredListResultT s r c C s* t | d|d�}|�t� tttt |�S )a Returns, via a L{Deferred}, a list with the results of the given L{Deferred}s - in effect, a "join" of multiple deferred operations. The returned L{Deferred} will fire when I{all} of the provided L{Deferred}s have fired, or when any one of them has failed. This method can be cancelled by calling the C{cancel} method of the L{Deferred}, all the L{Deferred}s in the list will be cancelled. This differs from L{DeferredList} in that you don't need to parse the result for success/failure. @param consumeErrors: (keyword param) a flag, defaulting to False, indicating that failures in any of the given L{Deferred}s should not be propagated to errbacks added to the individual L{Deferred}s after this L{gatherResults} invocation. Any such errors in the individual L{Deferred}s will be converted to a callback result of L{None}. This is useful to prevent spurious 'Unhandled error in Deferred' messages from being logged. This parameter is available since 11.1.0. T)r r )r r� r r rN r r= )r� r rQ r3 r3 r4 � gatherResults_ s r c @ sB e Zd ZU dZeZeed< dee ddfdd�Z defdd �Z dS ) �waitForDeferred�# See L{deferredGenerator}. rK rQ r1 Nc C s4 t jdtdd� t|t�std|�d���|| _d S )Nz�twisted.internet.defer.waitForDeferred was deprecated in Twisted 15.0.0; please use twisted.internet.defer.inlineCallbacks instead� )� stacklevelz6You must give waitForDeferred a Deferred. You gave it �.)�warnings�warn�DeprecationWarningr\ rN � TypeErrorrQ r� r3 r3 r4 r� � s � � zwaitForDeferred.__init__c C s& t | jt�r | j�� | jtu | jS r2 )r\ rK r* �raiseExceptionrs r� r3 r3 r4 � getResult� s zwaitForDeferred.getResult) r6 r7 r8 rA rs rK r r� rN r: r� r" r3 r3 r3 r4 r � s r �gc s� d}ddg� zt ��}W n ty � �|� � Y S ty+ � �� � Y S w t|t�r7ttd��S t|t �rjt t |�fdt dt ddf� ��fdd � }|j � |� �d r`d �d < � S d�d < d�d< d}q) r NTr` z Yield waitForDeferred(d), not d!�rrK r1 c s0 | |_ �d rd�d< | �d< d S t�� � d S �Nr Fr` )rK �_deferGenerator)r$ rK �rb r# �waitingr3 r4 � gotResult� s z"_deferGenerator.<locals>.gotResultr F)�nextr� rO rW rT r\ rN rU r r r r: rQ r� )r# rb rK r) r3 r' r4 r& � s> � ���� �r& � z&twisted.internet.defer.inlineCallbacksc �* t � �dtdtdtt f� fdd� �}|S )aI L{deferredGenerator} and L{waitForDeferred} help you write L{Deferred}-using code that looks like a regular sequential function. Consider the use of L{inlineCallbacks} instead, which can accomplish the same thing in a more concise manner. There are two important functions involved: L{waitForDeferred}, and L{deferredGenerator}. They are used together, like this:: @deferredGenerator def thingummy(): thing = waitForDeferred(makeSomeRequestResultingInDeferred()) yield thing thing = thing.getResult() print(thing) #the result! hoorj! L{waitForDeferred} returns something that you should immediately yield; when your generator is resumed, calling C{thing.getResult()} will either give you the result of the L{Deferred} if it was a success, or raise an exception if it was a failure. Calling C{getResult} is B{absolutely mandatory}. If you do not call it, I{your program will not work}. L{deferredGenerator} takes one of these waitForDeferred-using generator functions and converts it into a function that returns a L{Deferred}. The result of the L{Deferred} will be the last value that your generator yielded unless the last value is a L{waitForDeferred} instance, in which case the result will be L{None}. If the function raises an unhandled exception, the L{Deferred} will errback instead. Remember that C{return result} won't work; use C{yield result; return} in place of that. Note that not yielding anything from your generator will make the L{Deferred} result in L{None}. Yielding a L{Deferred} from your generator is also an error condition; always yield C{waitForDeferred(d)} instead. The L{Deferred} returned from your deferred generator may also errback if your generator raised an exception. For example:: @deferredGenerator def thingummy(): thing = waitForDeferred(makeSomeRequestResultingInDeferred()) yield thing thing = thing.getResult() if thing == 'I love Twisted': # will become the result of the Deferred yield 'TWISTED IS GREAT!' return else: # will trigger an errback raise Exception('DESTROY ALL LIFE') Put succinctly, these functions connect deferred-using code with this 'fake blocking' style in both directions: L{waitForDeferred} converts from a L{Deferred} to the 'blocking' style, and L{deferredGenerator} converts from the 'blocking' style to a L{Deferred}. r/ r0 r1 c s t � | i |��t� �S r2 )r& rN )r/ r0 �r. r3 r4 �unwindGenerator s z*deferredGenerator.<locals>.unwindGenerator�r r: rN �r. r. r3 r- r4 �deferredGenerator� s < r1 c @ s e Zd Zdeddfdd�ZdS )�_DefGen_Returnro r1 Nc C s || _ d S r2 )ro )r� ro r3 r3 r4 r� ) � z_DefGen_Return.__init__)r6 r7 r8 r: r� r3 r3 r3 r4 r2 ( s r2 �valc C s t | ��)a� Return val from a L{inlineCallbacks} generator. Note: this is currently implemented by raising an exception derived from L{BaseException}. You might want to change any 'except:' clauses to an 'except Exception:' clause so as not to catch this exception. Also: while this function currently will work when called from within arbitrary functions called from within the generator, do not rely upon this behavior. )r2 )r4 r3 r3 r4 � returnValue- s r5 )� auto_attribsc @ s2 e Zd ZU dZee ed< dZeee ed< dS )�_CancellationStatusa, Cancellation status of an L{inlineCallbacks} invocation. @ivar deferred: the L{Deferred} to callback or errback when the generator invocation has finished. @ivar waitingOn: the L{Deferred} being waited upon (which L{_inlineCallbacks} must fill out before returning) rb N� waitingOn) r6 r7 r8 rA rN r: r� r8 r r3 r3 r3 r4 r7 = s r7 �gen�statusc s^ ddg�t � � zt| t�}|r� �tt| �j��} n� ��j| �} W n� ty@ } z�j� t |dd�� W Y d}~dS d}~w t y� } z�t � }|dusPJ �|d }|dusZJ �|j }|duscJ �tdk rq|j }|duspJ �n tr||j }|dus|J �|r�|j }|dus�J �|j dus�J �|j j r�|}|dus�J �|j dus�J �|j j r�|j }|dus�J �|j j s�|jjj} |j} |jdus�J �|jdus�J �t�d|jjj|jjjf t| | � �j� |j� W Y d}~dS d}~w ty� �j�� Y dS w t| t��r.dt d df� ���fd d � } | � | � �d �r"d �d < | �_ dS �d } d�d < d�d< q)a5 Carry out the work of L{inlineCallbacks}. Iterate the generator produced by an C{@}L{inlineCallbacks}-decorated function, C{gen}, C{send()}ing it the results of each value C{yield}ed by that generator, until a L{Deferred} is yielded, at which point a callback is added to that L{Deferred} to call this function again. @param result: The last result seen by this generator. Note that this is never a L{Deferred} - by the time this function is invoked, the L{Deferred} has been called back and this will be a particular result at a point in its callback chain. @param gen: a generator object returned by calling a function or method decorated with C{@}L{inlineCallbacks} @param status: a L{_CancellationStatus} tracking the current status of C{gen} TNr` ro r )� � zvreturnValue() in %r causing %r to exit: returnValue should only be invoked by functions decorated with inlineCallbacksr$ r1 c s0 �d rd�d< | �d< d S � � t| ��� d S r% )r5 �_inlineCallbacks)r$ ��current_contextr9 r: r( r3 r4 r) � s z#_inlineCallbacks.<locals>.gotResultr F) r; r\ r* r5 r �throwExceptionIntoGeneratorr� r� rb rO r� r2 r �tb_nextr r% �tb_frame�f_code� co_filename� tb_linenor � warn_explicit�co_namer ro rW rT rN r: r� r8 ) rK r9 r: � isFailure�e�excInfor� � appCodeTrace� ultimateTrace�filename�linenor) r3 r> r4 r= L s� ! ��� � ��� � � �r= c sV dt t ddf�fdd� � t � �}t|��dtdt t f� �fdd� �td| �� |S ) z� Make an C{@}L{inlineCallbacks} cancellable. @param gen: a generator object returned by calling a function or method decorated with C{@}L{inlineCallbacks} @return: L{Deferred} for the C{@}L{inlineCallbacks} that is cancellable. �itr1 Nc s4 g | j | _ }| �� � | j �|� | �t� � d S r2 )r� r� �extendrT �&_InternalInlineCallbacksCancelledError)rO �tmp)� handleCancelr3 r4 r� � s z+_cancellableInlineCallbacks.<locals>.cancelrK c s4 | � t� t� ��_�j}|dusJ �|�� �jS )aS Propagate the cancellation of an C{@}L{inlineCallbacks} to the L{Deferred} it is waiting on. @param result: An L{_InternalInlineCallbacksCancelledError} from C{cancel()}. @return: A new L{Deferred} that the C{@}L{inlineCallbacks} generator can callback or errback through. N)rp rQ rN rb r8 r� )rK �awaited)r� r: r3 r4 rS s z1_cancellableInlineCallbacks.<locals>.handleCancel)rN r: r7 r* r= )r9 rb r3 )r� rS r: r4 r� � s r� c @ r> )rQ z� A unique exception used only in L{_cancellableInlineCallbacks} to verify that an L{inlineCallbacks} is being cancelled as expected. Nr@ r3 r3 r3 r4 rQ rB rQ c r, )a L{inlineCallbacks} helps you write L{Deferred}-using code that looks like a regular sequential function. For example:: @inlineCallbacks def thingummy(): thing = yield makeSomeRequestResultingInDeferred() print(thing) # the result! hoorj! When you call anything that results in a L{Deferred}, you can simply yield it; your generator will automatically be resumed when the Deferred's result is available. The generator will be sent the result of the L{Deferred} with the 'send' method on generators, or if the result was a failure, 'throw'. Things that are not L{Deferred}s may also be yielded, and your generator will be resumed with the same object sent back. This means C{yield} performs an operation roughly equivalent to L{maybeDeferred}. Your inlineCallbacks-enabled generator will return a L{Deferred} object, which will result in the return value of the generator (or will fail with a failure object if your generator raises an unhandled exception). Note that you can't use C{return result} to return a value; use C{returnValue(result)} instead. Falling off the end of the generator, or simply using C{return} will cause the L{Deferred} to have a result of L{None}. Be aware that L{returnValue} will not accept a L{Deferred} as a parameter. If you believe the thing you'd like to return could be a L{Deferred}, do this:: result = yield result returnValue(result) The L{Deferred} returned from your deferred generator may errback if your generator raised an exception:: @inlineCallbacks def thingummy(): thing = yield makeSomeRequestResultingInDeferred() if thing == 'I love Twisted': # will become the result of the Deferred returnValue('TWISTED IS GREAT!') else: # will trigger an errback raise Exception('DESTROY ALL LIFE') It is possible to use the C{return} statement instead of L{returnValue}:: @inlineCallbacks def loadData(url): response = yield makeRequest(url) return json.loads(response) You can cancel the L{Deferred} returned from your L{inlineCallbacks} generator before it is fired by your generator completing (either by reaching its end, a C{return} statement, or by calling L{returnValue}). A C{CancelledError} will be raised from the C{yield}ed L{Deferred} that has been cancelled if that C{Deferred} does not otherwise suppress it. r/ r0 r1 c sR z � | i |��}W n t y td� f ��w t|t�s%td� |f ��t|�S )NzkinlineCallbacks requires %r to produce a generator; insteadcaught returnValue being used in a non-generatorzBinlineCallbacks requires %r to produce a generator; instead got %r)r2 r r\ r r� )r/ r0 r9 r- r3 r4 r. c s ��� ��z(inlineCallbacks.<locals>.unwindGeneratorr/ r0 r3 r- r4 �inlineCallbacks% s > rU �_ConcurrencyPrimitiveT�_ConcurrencyPrimitive)�boundc @ s� e Zd Zdeddfdd�Zdedefdd�Zd ed ed ef d e d e de e f dd�Z dede e fdd�Z de de de de e fdd�Zedede e fdd��Zeddd��ZdS ) rW r� r1 Nc C s g | _ d S r2 )r( r� r3 r3 r4 r� r3 z _ConcurrencyPrimitive.__init__r$ c C s | � � |S r2 )�release)r� r$ r3 r3 r4 �_releaseAndReturn� s z'_ConcurrencyPrimitive._releaseAndReturn�%self_319AA2A8B18F4B8EA296D75F279EB07Fr. .r/ r0 c s. dt dtt f� ���fdd� }��� �|�S )a� Acquire, run, release. This method takes a callable as its first argument and any number of other positional and keyword arguments. When the lock or semaphore is acquired, the callable will be invoked with those arguments. The callable may return a L{Deferred}; if it does, the lock or semaphore won't be released until that L{Deferred} fires. @return: L{Deferred} of function result. � ignoredResultr1 c s t �g� �R i �����j�S r2 )r] r� rZ )r\ �r/ r. r0 r[ r3 r4 rX � s �z*_ConcurrencyPrimitive.run.<locals>.execute)r: rN rv �acquirer� )r[ r. r/ r0 rX r3 r] r4 r5 � s z_ConcurrencyPrimitive.runc C r� )zD We can be used as an asynchronous context manager. )r^ r� r3 r3 r4 � __aenter__� s z _ConcurrencyPrimitive.__aenter__�exc_type�exc_val�exc_tbc C s | � � td�S )NF)rY rR )r� r` ra rb r3 r3 r4 � __aexit__� s z _ConcurrencyPrimitive.__aexit__c C r r2 r3 r� r3 r3 r4 r^ � � z _ConcurrencyPrimitive.acquirec C r r2 r3 r� r3 r3 r4 rY � rd z _ConcurrencyPrimitive.releaser� )r6 r7 r8 rV r� r= rZ r rv r: rN r5 r_ rl rc r r^ rY r3 r3 r3 r4 rW ~ s( � ��� � �_DeferredLockT� DeferredLockc @ sV e Zd ZdZdZdedee ddfdd�Zdedee fd d �Zdeddfd d �Z dS ) rf z� A lock for event driven systems. @ivar locked: C{True} when this Lock has been acquired, false at all other times. Do not change this value, but it is useful to examine for the equivalent of a "non-blocking" acquisition. Fr� rQ r1 Nc C � | j �|� dS �a� Remove a deferred d from our waiting list, as the deferred has been canceled. Note: We do not need to wrap this in a try/except to catch d not being in self.waiting because this canceller will not be called if d has fired. release() pops a deferred out of self.waiting and calls it, so the canceller will no longer be called. @param d: The deferred that has been canceled. N�r( �remover� r3 r3 r4 �_cancelAcquire� � zDeferredLock._cancelAcquirec C s6 t | jd�}| jr| j�|� |S d| _|�| � |S )aL Attempt to acquire the lock. Returns a L{Deferred} that fires on lock acquisition with the L{DeferredLock} as the value. If the lock is locked, then the Deferred is placed at the end of a waiting list. @return: a L{Deferred} which fires on lock acquisition. @rtype: a L{Deferred} �r� T)rN rk �lockedr( r� rO r� r3 r3 r4 r^ � s � zDeferredLock.acquirec C s> | j sJ d��d| _ | jr d| _ | j�d�}|�| � dS dS )z� Release the lock. If there is a waiting list, then the first L{Deferred} in that waiting list will be called back. Should be called by whomever did the L{acquire}() when the shared resource is free. z!Tried to release an unlocked lockFTr N)rn r( r� rO r� r3 r3 r4 rY � s �zDeferredLock.release) r6 r7 r8 rA rn re rN rk r^ rY r3 r3 r3 r4 rf � s �_DeferredSemaphoreT�DeferredSemaphorec @ sd e Zd ZdZdeddfdd�Zdedee ddfd d �Zdedee fd d �Z deddfd d�Z dS )rp a� A semaphore for event driven systems. If you are looking into this as a means of limiting parallelism, you might find L{twisted.internet.task.Cooperator} more useful. @ivar limit: At most this many users may acquire this semaphore at once. @ivar tokens: The difference between C{limit} and the number of users which have currently acquired this semaphore. �tokensr1 Nc C s* t �| � |dk r td��|| _|| _dS )ze @param tokens: initial value of L{tokens} and L{limit} @type tokens: L{int} r` z&DeferredSemaphore requires tokens >= 1N)rW r� � ValueErrorrq �limit)r� rq r3 r3 r4 r� s zDeferredSemaphore.__init__r� rQ c C rg rh ri r� r3 r3 r4 rk r� z DeferredSemaphore._cancelAcquirec C sN | j dks J d��t| jd�}| j s| j�|� |S | j d | _ |�| � |S )zq Attempt to acquire the token. @return: a L{Deferred} which fires on token acquisition. r z9Internal inconsistency?? tokens should never be negativerm r` )rq rN rk r( r� rO r� r3 r3 r4 r^ $ s � � zDeferredSemaphore.acquirec C sP | j | jk s J d��| j d | _ | jr&| j d | _ | j�d�}|�| � dS dS )z� Release the token. Should be called by whoever did the L{acquire}() when the shared resource is free. z4Someone released me too many times: too many tokens!r` r N)rq rs r( r� rO r� r3 r3 r4 rY 5 s � �zDeferredSemaphore.release) r6 r7 r8 rA r� r� ro rN rk r^ rY r3 r3 r3 r4 rp � s �� �c @ � e Zd ZdS )� QueueOverflowN�r6 r7 r8 r3 r3 r3 r4 ru G � ru c @ rt )�QueueUnderflowNrv r3 r3 r3 r4 rx K rw rx c @ sl e Zd ZdZ ddee dee ddfdd�Zdee ddfd d �Z d e ddfd d �Z dee fdd�Z dS )� DeferredQueuea� An event driven queue. Objects may be added as usual to this queue. When an attempt is made to retrieve an object when the queue is empty, a L{Deferred} is returned which will fire when an object becomes available. @ivar size: The maximum number of objects to allow into the queue at a time. When an attempt to add a new object would exceed this limit, L{QueueOverflow} is raised synchronously. L{None} for no limit. @ivar backlog: The maximum number of L{Deferred} gets to allow at one time. When an attempt is made to get an object which would exceed this limit, L{QueueUnderflow} is raised synchronously. L{None} for no limit. N�size�backlogr1 c C s g | _ g | _|| _|| _d S r2 )r( �pendingrz r{ )r� rz r{ r3 r3 r4 r� ` s zDeferredQueue.__init__rQ c C rg )a� Remove a deferred d from our waiting list, as the deferred has been canceled. Note: We do not need to wrap this in a try/except to catch d not being in self.waiting because this canceller will not be called if d has fired. put() pops a deferred out of self.waiting and calls it, so the canceller will no longer be called. @param d: The deferred that has been canceled. Nri r� r3 r3 r4 � _cancelGeth rl zDeferredQueue._cancelGet�objc C sL | j r| j �d��|� dS | jdu st| j�| jk r#| j�|� dS t� �)zq Add an object to this queue. @raise QueueOverflow: Too many objects are in this queue. r N)r( r� rO rz r r| r� ru )r� r~ r3 r3 r4 �putv s zDeferredQueue.putc C sR | j r t| j �d��S | jdu st| j�| jk r&t| jd�}| j�|� |S t � �)a3 Attempt to retrieve and remove an object from the queue. @return: a L{Deferred} which fires with the next object available in the queue. @raise QueueUnderflow: Too many (more than C{backlog}) L{Deferred}s are already waiting for an object from this queue. r Nrm ) r| rR r� r{ r r( rN r} r� rx r� r3 r3 r4 �get� s zDeferredQueue.get)NN) r6 r7 r8 rA r r� r� rN r: r} r= r r� r3 r3 r3 r4 ry O s ��� � ry c @ r> )�AlreadyTryingToLockErrorz{ Raised when L{DeferredFilesystemLock.deferUntilLocked} is called twice on a single L{DeferredFilesystemLock}. Nr@ r3 r3 r3 r4 r� � rB r� c @ sn e Zd ZU dZdZdZee ed< dZ ee ed< dde dee ddfd d �Z dd ee ded fd d �ZdS )�DeferredFilesystemLockaj A L{FilesystemLock} that allows for a L{Deferred} to be fired when the lock is acquired. @ivar _scheduler: The object in charge of scheduling retries. In this implementation this is parameterized for testing. @ivar _interval: The retry interval for an L{IReactorTime} based scheduler. @ivar _tryLockCall: An L{IDelayedCall} based on C{_interval} that will manage the next retry for acquiring the lock. @ivar _timeoutCall: An L{IDelayedCall} based on C{deferUntilLocked}'s timeout argument. This is in charge of timing out our attempt to acquire the lock. r` N� _tryLockCall� _timeoutCall�name� schedulerr1 c C s6 t j�| |� |du rddlm} tt|�}|| _dS )z� @param name: The name of the lock to acquire @param scheduler: An object which provides L{IReactorTime} Nr )�reactor)r$ �FilesystemLockr� �twisted.internetr� r r" � _scheduler)r� r� r� r� r3 r3 r4 r� � s z DeferredFilesystemLock.__init__re c sf �j dur ttd��S dtttf ddf��fdd� � t� fdd���d � ����fd d � ��� �S ) a� Wait until we acquire this lock. This method is not safe for concurrent use. @param timeout: the number of seconds after which to time out if the lock has not been acquired. @return: a L{Deferred} which will callback when the lock is acquired, or errback with a L{TimeoutError} after timing out or an L{AlreadyTryingToLockError} if the L{deferUntilLocked} has already been called and not successfully locked the file. Nz/deferUntilLocked isn't safe for concurrent use.�reasonr1 c sf �j dusJ ��j �� d�_ �jdur!�j�� r!�j�� d�_��� r,� �d� dS � �| � dS )z� Cancel a L{DeferredFilesystemLock.deferUntilLocked} call. @type reason: L{Failure} @param reason: The reason why the call is cancelled. N)r� r� r� r� �lockrO rT �r� )rQ r� r3 r4 � _cancelLock� s z<DeferredFilesystemLock.deferUntilLocked.<locals>._cancelLockc s � t � �S r2 )rC rd )r� r3 r4 �<lambda>� s z9DeferredFilesystemLock.deferUntilLocked.<locals>.<lambda>c s� �� � r�jd ur�j�� d �_d �_��d � d S �d ur8�jd u r8ttd�j�f ��} �j� �� | ��_�j� �j ���_d S )Nz&Timed out acquiring lock: %s after %fs) r� r� r� r� rO r* rD r� r� r� � _intervalr� �r� �_tryLockrQ r� re r3 r4 r� � s$ ����z9DeferredFilesystemLock.deferUntilLocked.<locals>._tryLockr� )r� rU r� r r* r� rN )r� re r3 r� r4 �deferUntilLocked� s �� z'DeferredFilesystemLock.deferUntilLockedr2 )r6 r7 r8 rA r� r� r r! r� r� r� r" r� r� rN r� r3 r3 r3 r4 r� � s r� )rN r rR rU r r r? rD r r] r� r r1 rU r5 rf rp ry r� r� rC r2 )rb rc r1 N)FFr )F)�rA r� r �abcr r �asyncior r r �enumr � functoolsr �sysr r �typesr r �typingr r r r r r r r r r r r r r r r r r r �attr� incrementalr �twisted.internet.interfacesr! r" �twisted.loggerr# �twisted.pythonr$ �twisted.python.compatr% r& r' �twisted.python.deprecater( r) �twisted.python.failurer* r+ � contextvarsr, �__copy_context�_contextvarsSupport� ImportErrorr- r; rH r= r� r? rC rD r rE rJ rR rW rU r: rX r] re ri rj rl rm rn r� rq rr rs rt �DeferredCallback�DeferredErrbackr� r� r� r� ru r� rv rx rz rN r� r� r� �_DeferredListSingleResultT�_DeferredListResultItemTr r r r r r r r �_DeferableGeneratorr& r1 r2 r5 �sr7 r= r� rQ rU rV rW re rf ro rp ru rx ry r� r� r� �__all__r3 r3 r3 r4 �<module> s� T � ��� � ��� � � ������ * ~��� � + � ���� �� ���� � � ����� � ��� � � �� � �� �@ � �E ����� � ��� �2 � �T� = ;KH fPK Mb�Z���)�- �- 4 internet/__pycache__/_threadedselect.cpython-310.pycnu �[��� o �b>- � @ s� d Z ddlZddlZddlmZmZ ddlmZ ddlm Z m Z ddl m Z ddl mZ ddlmZ dd lmZ dd lmZmZ dd lmZ dd lmZmZmZ d d� Z dd� Z ee�G dd� dej ��Z dd� Z dgZ!dS )a Threaded select reactor The threadedselectreactor is a specialized reactor for integrating with arbitrary foreign event loop, such as those you find in GUI toolkits. There are three things you'll need to do to use this reactor. Install the reactor at the beginning of your program, before importing the rest of Twisted:: | from twisted.internet import _threadedselect | _threadedselect.install() Interleave this reactor with your foreign event loop, at some point after your event loop is initialized:: | from twisted.internet import reactor | reactor.interleave(foreignEventLoopWakerFunction) | self.addSystemEventTrigger('after', 'shutdown', foreignEventLoopStop) Instead of shutting down the foreign event loop directly, shut down the reactor:: | from twisted.internet import reactor | reactor.stop() In order for Twisted to do its work in the main thread (the thread that interleave is called from), a waker function is necessary. The waker function will be called from a "background" thread with one argument: func. The waker function's purpose is to call func() from the main thread. Many GUI toolkits ship with appropriate waker functions. Some examples of this are wxPython's wx.callAfter (may be wxCallAfter in older versions of wxPython) or PyObjC's PyObjCTools.AppHelper.callAfter. These would be used in place of "foreignEventLoopWakerFunction" in the above example. The other integration point at which the foreign event loop and this reactor must integrate is shutdown. In order to ensure clean shutdown of Twisted, you must allow for Twisted to come to a complete stop before quitting the application. Typically, you will do this by setting up an after shutdown trigger to stop your foreign event loop, and call reactor.stop() where you would normally have initiated the shutdown procedure for the foreign event loop. Shutdown functions that could be used in place of "foreignEventloopStop" would be the ExitMainLoop method of the wxApp instance with wxPython, or the PyObjCTools.AppHelper.stopEventLoop function. � N)�EBADF�EINTR)�partial)�Empty�Queue)�Thread)� implementer)� posixbase)� IReactorFDSet)� _NO_FILEDESC� _NO_FILENO)�_select)�failure�log� threadablec C s" z| |= W d S t y Y d S w �N)�KeyError)�dct�value� r �B/usr/lib/python3/dist-packages/twisted/internet/_threadedselect.py� dictRemoveE s �r c C s | �r r )�er r r �raiseExceptionL s r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z e Zdd� Zdd� ZeZdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Z d0d1� Z d8d3d4�Z d5d6� Z d7S )9�ThreadedSelectReactorzVA threaded select() based reactor - runs on all POSIX platforms and on Win32. c C sR t �d� i | _i | _t� | _t� | _d | _d | _t j � | � | � dd| j � d S )N� �after�shutdown)r �init�reads�writesr � toThreadQueue� toMainThread� workerThread� mainWakerr �PosixReactorBase�__init__�addSystemEventTrigger�_mainLoopShutdown��selfr r r r& V s z ThreadedSelectReactor.__init__c C s | j �� d S r )�waker�wakeUpr) r r r r, a s z ThreadedSelectReactor.wakeUpc O s& t jj| g|�R i |��}| �� |S r )r r% � callLaterr, )r* �args�kw�tpler r r r- e s z ThreadedSelectReactor.callLaterc G s* | j �||f� | jd ur| �� d S d S r )r" �putr$ )r* �msgr. r r r � _sendToMainj s �z!ThreadedSelectReactor._sendToMainc G s | j �||f� d S r )r! r1 )r* �fnr. r r r � _sendToThreado s z#ThreadedSelectReactor._sendToThreadc C s� t �d� | j�� }| j�� }| j�� | j�� | j|f| j|ffD ]+\}}|D ]$}z t�|g|g|gd� W n tyH t �d| � Y q)w d||< q)q#d S )Nz1Malformed file descriptor found. Preening lists.r zbad descriptor %sr )r r2 r �keysr �clear�select� BaseException)r* �readers�writers�selDict�selList� selectabler r r �_preenDescriptorsInThreadr s � ��z/ThreadedSelectReactor._preenDescriptorsInThreadc C sV z | j �� \}}||� q ty Y d S ty* t�� }| �d|� Y d S w )Nr �Failure)r! �get� SystemExitr9 r r@ r3 )r* r4 r. �fr r r �_workerInThread� s � �z%ThreadedSelectReactor._workerInThreadc C s | j }| j} zt|�� |�� g |�\}}}W na ty( t�� | �� Y nP ty8 t�� | �� Y n@ t yw } z4|j d dv rR|sQ|sQW Y d}~dS � |j d t kr`W Y d}~dS |j d t krl| �� n� W Y d}~nd}~ww q| � d||� dS )z�Run one iteration of the I/O monitor loop. This will run all selectables who had input or output readiness waiting for them. r r )r � N�Notify)r r r r6 � ValueErrorr �errr? � TypeError�OSErrorr. r r r3 )r* �timeoutr r �r�w�ignored�ser r r �_doSelectInThread� s6 ���� z'ThreadedSelectReactor._doSelectInThreadc C s` | j }| j}| j}tj}|d|f|d|ffD ]\}}} |D ]} | | vr$q || || || � q qd S )N�doRead�doWrite)r r �_doReadOrWriter �callWithLogger) r* rL rM r r �_drdw�_logrun� selectables�methodr r> r r r �_process_Notify� s ��z%ThreadedSelectReactor._process_Notifyc C s |� � d S r )r )r* rC r r r �_process_Failure� s z&ThreadedSelectReactor._process_Failurec C s4 | j d u s | j �� st| jd�| _ | j �� d S d S )N)�target)r# �isAliver rD �startr) r r r �ensureWorkerThread� s �z(ThreadedSelectReactor.ensureWorkerThreadc C s: | � | j|� | �� | j�� \}}t| d| �|� d S �N� _process_)r5 �_doIterationInThreadr^ r" rA �getattr)r* rK r2 r. r r r �doThreadIteration� s z'ThreadedSelectReactor.doThreadIterationc c sd � | j r0| �� | �� }| j o|}| �| j|� d V | j�� \}}t| d| �|� | j sd S d S r_ )�running�runUntilCurrentrK r5 ra r" � get_nowaitrb )r* �t2�tr2 r. r r r � _interleave� s � �z!ThreadedSelectReactor._interleavec O s@ | j |i |�� | �� }||fdd�}|| _t|� | �� dS )a� interleave(waker) interleaves this reactor with the current application by moving the blocking parts of the reactor (select() in this case) to a separate thread. This is typically useful for integration with GUI applications which have their own event loop already running. See the module docstring for more information. c S s | t t|�� d S r )r �next)r+ �loopr r r r$ � s z3ThreadedSelectReactor.interleave.<locals>.mainWakerN)� startRunningri r$ rj r^ )r* r+ r. r/ rk r$ r r r � interleave� s z ThreadedSelectReactor.interleavec C s� d | _ | jd ur-| �tt� | �� z | j�� \}}q ty$ Y nw | j� � d | _z# | j �� \}}|| j u rAt � d� n|tu rL|d tu rLn||� q/ tyZ Y d S w )Nr z'Iteration is still in the thread queue!r )r$ r# r5 r rB r, r" rf r �joinr! ra r r2 )r* r2 r. r4 r r r r( � s2 � � � �z'ThreadedSelectReactor._mainLoopShutdownc C sz zt ||�� }t |dd �}|st}n|� dkrt}W n ty- t�� d }t�� Y nw |r;| �|||dk� d S d S )N�fileno���r rQ ) rb r r r9 �sys�exc_infor rH �_disconnectSelectable)r* r> rX �dict�why�handfnr r r rS s � ��z$ThreadedSelectReactor._doReadOrWritec C � | � | jj|d� | �� dS )z@Add a FileDescriptor for notification of data available to read.r N)r5 r � __setitem__r, �r* �readerr r r � addReader � z ThreadedSelectReactor.addReaderc C rw )zAAdd a FileDescriptor for notification of data available to write.r N)r5 r rx r, �r* �writerr r r � addWriter r| z ThreadedSelectReactor.addWriterc C � | � t| j|� dS )z?Remove a Selectable for notification of data available to read.N)r5 r r ry r r r � removeReader! � z"ThreadedSelectReactor.removeReaderc C r� )z@Remove a Selectable for notification of data available to write.N)r5 r r r} r r r � removeWriter% r� z"ThreadedSelectReactor.removeWriterc C s | � | j| j�S r )� _removeAllr r r) r r r � removeAll) s z ThreadedSelectReactor.removeAllc C � t | j�� �S r )�listr r6 r) r r r � getReaders, � z ThreadedSelectReactor.getReadersc C r� r )r� r r6 r) r r r � getWriters/ r� z ThreadedSelectReactor.getWritersc C s t j�| � | �� dS )z� Extend the base stop implementation to also wake up the select thread so that C{runUntilCurrent} notices the reactor should stop. N)r r% �stopr, r) r r r r� 2 s zThreadedSelectReactor.stopTc C s | j |d� | �� d S )N)�installSignalHandlers)rl �mainLoop)r* r� r r r �run: s zThreadedSelectReactor.runc C sJ t � }| �|j� | jr#z|�� � W n ty Y d S w | js d S d S r )r rm r1 rd rA � StopIteration)r* �qr r r r� > s ��z ThreadedSelectReactor.mainLoopN)T) �__name__� __module__� __qualname__�__doc__r& r, r- r3 r5 r? rD rP rY rZ ra r^ rc � doIterationri rm r( rS r{ r r� r� r� r� r� r� r� r� r r r r r P s< & r c C s t � } ddlm} || � | S )zDConfigure the twisted mainloop to be run using the select() reactor.r )�installReactor)r �twisted.internet.mainr� )�reactorr� r r r �installH s r� )"r� r8 rq �errnor r � functoolsr �queuer r � threadingr �zope.interfacer �twisted.internetr �twisted.internet.interfacesr �twisted.internet.posixbaser r � twisted.internet.selectreactorr �twisted.pythonr r r r r r% r r� �__all__r r r r �<module> s( 0 x PK Mb�ZQɷ��! �! internet/ssl.pynu �[��� # -*- test-case-name: twisted.test.test_ssl -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module implements Transport Layer Security (TLS) support for Twisted. It requires U{PyOpenSSL <https://pypi.python.org/pypi/pyOpenSSL>}. If you wish to establish a TLS connection, please use one of the following APIs: - SSL endpoints for L{servers <twisted.internet.endpoints.SSL4ServerEndpoint>} and L{clients <twisted.internet.endpoints.SSL4ClientEndpoint>} - L{startTLS <twisted.internet.interfaces.ITLSTransport.startTLS>} - L{connectSSL <twisted.internet.interfaces.IReactorSSL.connectSSL>} - L{listenSSL <twisted.internet.interfaces.IReactorSSL.listenSSL>} These APIs all require a C{contextFactory} argument that specifies their security properties, such as certificate, private key, certificate authorities to verify the peer, allowed TLS protocol versions, cipher suites, and so on. The recommended value for this argument is a L{CertificateOptions} instance; see its documentation for an explanation of the available options. The C{contextFactory} name is a bit of an anachronism now, as context factories have been replaced with "connection creators", but these objects serve the same role. Be warned that implementing your own connection creator (i.e.: value for the C{contextFactory}) is both difficult and dangerous; the Twisted team has worked hard to make L{CertificateOptions}' API comprehensible and unsurprising, and the Twisted team is actively maintaining it to ensure that it becomes more secure over time. If you are really absolutely sure that you want to take on the risk of implementing your own connection creator based on the pyOpenSSL API, see the L{server connection creator <twisted.internet.interfaces.IOpenSSLServerConnectionCreator>} and L{client connection creator <twisted.internet.interfaces.IOpenSSLServerConnectionCreator>} interfaces. Developers using Twisted, please ignore the L{Port}, L{Connector}, and L{Client} classes defined here, as these are details of certain reactors' TLS implementations, exposed by accident (and remaining here only for compatibility reasons). If you wish to establish a TLS connection, please use one of the APIs listed above. @note: "SSL" (Secure Sockets Layer) is an antiquated synonym for "TLS" (Transport Layer Security). You may see these terms used interchangeably throughout the documentation. """ from zope.interface import implementedBy, implementer, implementer_only # System imports from OpenSSL import SSL # Twisted imports from twisted.internet import interfaces, tcp supported = True @implementer(interfaces.IOpenSSLContextFactory) class ContextFactory: """A factory for SSL context objects, for server SSL connections.""" isClient = 0 def getContext(self): """Return a SSL.Context object. override in subclasses.""" raise NotImplementedError class DefaultOpenSSLContextFactory(ContextFactory): """ L{DefaultOpenSSLContextFactory} is a factory for server-side SSL context objects. These objects define certain parameters related to SSL handshakes and the subsequent connection. @ivar _contextFactory: A callable which will be used to create new context objects. This is typically L{OpenSSL.SSL.Context}. """ _context = None def __init__( self, privateKeyFileName, certificateFileName, sslmethod=SSL.SSLv23_METHOD, _contextFactory=SSL.Context, ): """ @param privateKeyFileName: Name of a file containing a private key @param certificateFileName: Name of a file containing a certificate @param sslmethod: The SSL method to use """ self.privateKeyFileName = privateKeyFileName self.certificateFileName = certificateFileName self.sslmethod = sslmethod self._contextFactory = _contextFactory # Create a context object right now. This is to force validation of # the given parameters so that errors are detected earlier rather # than later. self.cacheContext() def cacheContext(self): if self._context is None: ctx = self._contextFactory(self.sslmethod) # Disallow SSLv2! It's insecure! SSLv3 has been around since # 1996. It's time to move on. ctx.set_options(SSL.OP_NO_SSLv2) ctx.use_certificate_file(self.certificateFileName) ctx.use_privatekey_file(self.privateKeyFileName) self._context = ctx def __getstate__(self): d = self.__dict__.copy() del d["_context"] return d def __setstate__(self, state): self.__dict__ = state def getContext(self): """ Return an SSL context. """ return self._context @implementer(interfaces.IOpenSSLContextFactory) class ClientContextFactory: """A context factory for SSL clients.""" isClient = 1 # SSLv23_METHOD allows SSLv2, SSLv3, and TLSv1. We disable SSLv2 below, # though. method = SSL.SSLv23_METHOD _contextFactory = SSL.Context def getContext(self): ctx = self._contextFactory(self.method) # See comment in DefaultOpenSSLContextFactory about SSLv2. ctx.set_options(SSL.OP_NO_SSLv2) return ctx @implementer_only( interfaces.ISSLTransport, *(i for i in implementedBy(tcp.Client) if i != interfaces.ITLSTransport), ) class Client(tcp.Client): """ I am an SSL client. """ def __init__(self, host, port, bindAddress, ctxFactory, connector, reactor=None): # tcp.Client.__init__ depends on self.ctxFactory being set self.ctxFactory = ctxFactory tcp.Client.__init__(self, host, port, bindAddress, connector, reactor) def _connectDone(self): self.startTLS(self.ctxFactory) self.startWriting() tcp.Client._connectDone(self) @implementer(interfaces.ISSLTransport) class Server(tcp.Server): """ I am an SSL server. """ def __init__(self, *args, **kwargs): tcp.Server.__init__(self, *args, **kwargs) self.startTLS(self.server.ctxFactory) def getPeerCertificate(self): # ISSLTransport.getPeerCertificate raise NotImplementedError("Server.getPeerCertificate") class Port(tcp.Port): """ I am an SSL port. """ transport = Server _type = "TLS" def __init__( self, port, factory, ctxFactory, backlog=50, interface="", reactor=None ): tcp.Port.__init__(self, port, factory, backlog, interface, reactor) self.ctxFactory = ctxFactory def _getLogPrefix(self, factory): """ Override the normal prefix to include an annotation indicating this is a port for TLS connections. """ return tcp.Port._getLogPrefix(self, factory) + " (TLS)" class Connector(tcp.Connector): def __init__( self, host, port, factory, contextFactory, timeout, bindAddress, reactor=None ): self.contextFactory = contextFactory tcp.Connector.__init__(self, host, port, factory, timeout, bindAddress, reactor) # Force some parameter checking in pyOpenSSL. It's better to fail now # than after we've set up the transport. contextFactory.getContext() def _makeTransport(self): return Client( self.host, self.port, self.bindAddress, self.contextFactory, self, self.reactor, ) from twisted.internet._sslverify import ( DN, Certificate, CertificateRequest, DistinguishedName, KeyPair, OpenSSLAcceptableCiphers as AcceptableCiphers, OpenSSLCertificateOptions as CertificateOptions, OpenSSLDefaultPaths, OpenSSLDiffieHellmanParameters as DiffieHellmanParameters, PrivateCertificate, ProtocolNegotiationSupport, TLSVersion, VerificationError, optionsForClientTLS, platformTrust, protocolNegotiationMechanisms, trustRootFromCertificates, ) __all__ = [ "ContextFactory", "DefaultOpenSSLContextFactory", "ClientContextFactory", "DistinguishedName", "DN", "Certificate", "CertificateRequest", "PrivateCertificate", "KeyPair", "AcceptableCiphers", "CertificateOptions", "DiffieHellmanParameters", "platformTrust", "OpenSSLDefaultPaths", "TLSVersion", "VerificationError", "optionsForClientTLS", "ProtocolNegotiationSupport", "protocolNegotiationMechanisms", "trustRootFromCertificates", ] PK Mb�Z�;� � internet/gtk3reactor.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module provides support for Twisted to interact with the gtk3 mainloop via Gobject introspection. This is like gi, but slightly slower and requires a working $DISPLAY. In order to use this support, simply do the following:: from twisted.internet import gtk3reactor gtk3reactor.install() If you wish to use a GApplication, register it with the reactor:: from twisted.internet import reactor reactor.registerGApplication(app) Then use twisted.internet APIs as usual. """ from twisted.internet import gireactor from twisted.python import runtime class Gtk3Reactor(gireactor.GIReactor): """ A reactor using the gtk3+ event loop. """ def __init__(self): """ Override init to set the C{useGtk} flag. """ gireactor.GIReactor.__init__(self, useGtk=True) class PortableGtk3Reactor(gireactor.PortableGIReactor): """ Portable GTK+ 3.x reactor. """ def __init__(self): """ Override init to set the C{useGtk} flag. """ gireactor.PortableGIReactor.__init__(self, useGtk=True) def install(): """ Configure the Twisted mainloop to be run inside the gtk3+ mainloop. """ if runtime.platform.getType() == "posix": reactor = Gtk3Reactor() else: reactor = PortableGtk3Reactor() from twisted.internet.main import installReactor installReactor(reactor) return reactor __all__ = ["install"] PK Mb�ZoS�*� � internet/_baseprocess.pynu �[��� # -*- test-case-name: twisted.test.test_process -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Cross-platform process-related functionality used by different L{IReactorProcess} implementations. """ from typing import Optional from twisted.python.deprecate import getWarningMethod from twisted.python.failure import Failure from twisted.python.log import err from twisted.python.reflect import qual _missingProcessExited = ( "Since Twisted 8.2, IProcessProtocol.processExited " "is required. %s must implement it." ) class BaseProcess: pid: Optional[int] = None status: Optional[int] = None lostProcess = 0 proto = None def __init__(self, protocol): self.proto = protocol def _callProcessExited(self, reason): default = object() processExited = getattr(self.proto, "processExited", default) if processExited is default: getWarningMethod()( _missingProcessExited % (qual(self.proto.__class__),), DeprecationWarning, stacklevel=0, ) else: try: processExited(Failure(reason)) except BaseException: err(None, "unexpected error in processExited") def processEnded(self, status): """ This is called when the child terminates. """ self.status = status self.lostProcess += 1 self.pid = None self._callProcessExited(self._getReason(status)) self.maybeCallProcessEnded() def maybeCallProcessEnded(self): """ Call processEnded on protocol after final cleanup. """ if self.proto is not None: reason = self._getReason(self.status) proto = self.proto self.proto = None try: proto.processEnded(Failure(reason)) except BaseException: err(None, "unexpected error in processEnded") PK Mb�Z�2�58 8 internet/gtk2reactor.pynu �[��� # -*- test-case-name: twisted.internet.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module provides support for Twisted to interact with the glib/gtk2 mainloop. In order to use this support, simply do the following:: from twisted.internet import gtk2reactor gtk2reactor.install() Then use twisted.internet APIs as usual. The other methods here are not intended to be called directly. """ # System Imports import sys # Twisted Imports from twisted.internet import _glibbase from twisted.python import runtime # Certain old versions of pygtk and gi crash if imported at the same # time. This is a problem when running Twisted's unit tests, since they will # attempt to run both gtk2 and gtk3/gi tests. However, gireactor makes sure # that if we are in such an old version, and gireactor was imported, # gtk2reactor will not be importable. So we don't *need* to enforce that here # as well; whichever is imported first will still win. Moreover, additional # enforcement in this module is unnecessary in modern versions, and downright # problematic in certain versions where for some reason importing gtk also # imports some subset of gi. So we do nothing here, relying on gireactor to # prevent the crash. try: if not hasattr(sys, "frozen"): # Don't want to check this for py2exe import pygtk # type: ignore[import] pygtk.require("2.0") except (ImportError, AttributeError): pass # maybe we're using pygtk before this hack existed. import gobject # type: ignore[import] if hasattr(gobject, "threads_init"): # recent versions of python-gtk expose this. python-gtk=2.4.1 # (wrapping glib-2.4.7) does. python-gtk=2.0.0 (wrapping # glib-2.2.3) does not. gobject.threads_init() class Gtk2Reactor(_glibbase.GlibReactorBase): """ PyGTK+ 2 event loop reactor. """ _POLL_DISCONNECTED = gobject.IO_HUP | gobject.IO_ERR | gobject.IO_NVAL _POLL_IN = gobject.IO_IN _POLL_OUT = gobject.IO_OUT # glib's iochannel sources won't tell us about any events that we haven't # asked for, even if those events aren't sensible inputs to the poll() # call. INFLAGS = _POLL_IN | _POLL_DISCONNECTED OUTFLAGS = _POLL_OUT | _POLL_DISCONNECTED def __init__(self, useGtk=True): _gtk = None if useGtk is True: import gtk as _gtk # type: ignore[import] _glibbase.GlibReactorBase.__init__(self, gobject, _gtk, useGtk=useGtk) class PortableGtkReactor(_glibbase.PortableGlibReactorBase): """ Reactor that works on Windows. Sockets aren't supported by GTK+'s input_add on Win32. """ def __init__(self, useGtk=True): _gtk = None if useGtk is True: import gtk as _gtk _glibbase.PortableGlibReactorBase.__init__(self, gobject, _gtk, useGtk=useGtk) def install(useGtk=True): """ Configure the twisted mainloop to be run inside the gtk mainloop. @param useGtk: should glib rather than GTK+ event loop be used (this will be slightly faster but does not support GUI). """ reactor = Gtk2Reactor(useGtk) from twisted.internet.main import installReactor installReactor(reactor) return reactor def portableInstall(useGtk=True): """ Configure the twisted mainloop to be run inside the gtk mainloop. """ reactor = PortableGtkReactor() from twisted.internet.main import installReactor installReactor(reactor) return reactor if runtime.platform.getType() == "posix": install = install else: install = portableInstall __all__ = ["install"] PK Mb�Z/!�kH� H� internet/task.pynu �[��� # -*- test-case-name: twisted.test.test_task,twisted.test.test_cooperator -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Scheduling utility methods and classes. """ import sys import time import warnings from typing import ( Callable, Coroutine, Iterable, Iterator, List, NoReturn, Optional, Sequence, TypeVar, Union, cast, ) from zope.interface import implementer from incremental import Version from twisted.internet.base import DelayedCall from twisted.internet.defer import Deferred, ensureDeferred, maybeDeferred from twisted.internet.error import ReactorNotRunning from twisted.internet.interfaces import IDelayedCall, IReactorCore, IReactorTime from twisted.python import log, reflect from twisted.python.deprecate import _getDeprecationWarningString from twisted.python.failure import Failure _T = TypeVar("_T") class LoopingCall: """Call a function repeatedly. If C{f} returns a deferred, rescheduling will not take place until the deferred has fired. The result value is ignored. @ivar f: The function to call. @ivar a: A tuple of arguments to pass the function. @ivar kw: A dictionary of keyword arguments to pass to the function. @ivar clock: A provider of L{twisted.internet.interfaces.IReactorTime}. The default is L{twisted.internet.reactor}. Feel free to set this to something else, but it probably ought to be set *before* calling L{start}. @ivar running: A flag which is C{True} while C{f} is scheduled to be called (or is currently being called). It is set to C{True} when L{start} is called and set to C{False} when L{stop} is called or if C{f} raises an exception. In either case, it will be C{False} by the time the C{Deferred} returned by L{start} fires its callback or errback. @ivar _realLastTime: When counting skips, the time at which the skip counter was last invoked. @ivar _runAtStart: A flag indicating whether the 'now' argument was passed to L{LoopingCall.start}. """ call: Optional[IDelayedCall] = None running = False _deferred: Optional[Deferred["LoopingCall"]] = None interval: Optional[float] = None _runAtStart = False starttime: Optional[float] = None _realLastTime: Optional[float] = None def __init__(self, f: Callable[..., object], *a: object, **kw: object) -> None: self.f = f self.a = a self.kw = kw from twisted.internet import reactor self.clock = cast(IReactorTime, reactor) @property def deferred(self) -> Optional[Deferred["LoopingCall"]]: """ DEPRECATED. L{Deferred} fired when loop stops or fails. Use the L{Deferred} returned by L{LoopingCall.start}. """ warningString = _getDeprecationWarningString( "twisted.internet.task.LoopingCall.deferred", Version("Twisted", 16, 0, 0), replacement="the deferred returned by start()", ) warnings.warn(warningString, DeprecationWarning, stacklevel=2) return self._deferred @classmethod def withCount(cls, countCallable: Callable[[int], object]) -> "LoopingCall": """ An alternate constructor for L{LoopingCall} that makes available the number of calls which should have occurred since it was last invoked. Note that this number is an C{int} value; It represents the discrete number of calls that should have been made. For example, if you are using a looping call to display an animation with discrete frames, this number would be the number of frames to advance. The count is normally 1, but can be higher. For example, if the reactor is blocked and takes too long to invoke the L{LoopingCall}, a Deferred returned from a previous call is not fired before an interval has elapsed, or if the callable itself blocks for longer than an interval, preventing I{itself} from being called. When running with an interval of 0, count will be always 1. @param countCallable: A callable that will be invoked each time the resulting LoopingCall is run, with an integer specifying the number of calls that should have been invoked. @return: An instance of L{LoopingCall} with call counting enabled, which provides the count as the first positional argument. @since: 9.0 """ def counter() -> object: now = self.clock.seconds() if self.interval == 0: self._realLastTime = now return countCallable(1) lastTime = self._realLastTime if lastTime is None: assert ( self.starttime is not None ), "LoopingCall called before it was started" lastTime = self.starttime if self._runAtStart: assert ( self.interval is not None ), "Looping call called with None interval" lastTime -= self.interval lastInterval = self._intervalOf(lastTime) thisInterval = self._intervalOf(now) count = thisInterval - lastInterval if count > 0: self._realLastTime = now return countCallable(count) return None self = cls(counter) return self def _intervalOf(self, t: float) -> int: """ Determine the number of intervals passed as of the given point in time. @param t: The specified time (from the start of the L{LoopingCall}) to be measured in intervals @return: The C{int} number of intervals which have passed as of the given point in time. """ assert self.starttime is not None assert self.interval is not None elapsedTime = t - self.starttime intervalNum = int(elapsedTime / self.interval) return intervalNum def start(self, interval: float, now: bool = True) -> Deferred["LoopingCall"]: """ Start running function every interval seconds. @param interval: The number of seconds between calls. May be less than one. Precision will depend on the underlying platform, the available hardware, and the load on the system. @param now: If True, run this call right now. Otherwise, wait until the interval has elapsed before beginning. @return: A Deferred whose callback will be invoked with C{self} when C{self.stop} is called, or whose errback will be invoked when the function raises an exception or returned a deferred that has its errback invoked. """ assert not self.running, "Tried to start an already running " "LoopingCall." if interval < 0: raise ValueError("interval must be >= 0") self.running = True # Loop might fail to start and then self._deferred will be cleared. # This why the local C{deferred} variable is used. deferred = self._deferred = Deferred() self.starttime = self.clock.seconds() self.interval = interval self._runAtStart = now if now: self() else: self._scheduleFrom(self.starttime) return deferred def stop(self) -> None: """Stop running function.""" assert self.running, "Tried to stop a LoopingCall that was " "not running." self.running = False if self.call is not None: self.call.cancel() self.call = None d, self._deferred = self._deferred, None assert d is not None d.callback(self) def reset(self) -> None: """ Skip the next iteration and reset the timer. @since: 11.1 """ assert self.running, "Tried to reset a LoopingCall that was " "not running." if self.call is not None: self.call.cancel() self.call = None self.starttime = self.clock.seconds() self._scheduleFrom(self.starttime) def __call__(self) -> None: def cb(result: object) -> None: if self.running: self._scheduleFrom(self.clock.seconds()) else: d, self._deferred = self._deferred, None assert d is not None d.callback(self) def eb(failure: Failure) -> None: self.running = False d, self._deferred = self._deferred, None assert d is not None d.errback(failure) self.call = None d = maybeDeferred(self.f, *self.a, **self.kw) d.addCallback(cb) d.addErrback(eb) def _scheduleFrom(self, when: float) -> None: """ Schedule the next iteration of this looping call. @param when: The present time from whence the call is scheduled. """ def howLong() -> float: # How long should it take until the next invocation of our # callable? Split out into a function because there are multiple # places we want to 'return' out of this. if self.interval == 0: # If the interval is 0, just go as fast as possible, always # return zero, call ourselves ASAP. return 0 # Compute the time until the next interval; how long has this call # been running for? assert self.starttime is not None runningFor = when - self.starttime # And based on that start time, when does the current interval end? assert self.interval is not None untilNextInterval = self.interval - (runningFor % self.interval) # Now that we know how long it would be, we have to tell if the # number is effectively zero. However, we can't just test against # zero. If a number with a small exponent is added to a number # with a large exponent, it may be so small that the digits just # fall off the end, which means that adding the increment makes no # difference; it's time to tick over into the next interval. if when == when + untilNextInterval: # If it's effectively zero, then we need to add another # interval. return self.interval # Finally, if everything else is normal, we just return the # computed delay. return untilNextInterval self.call = self.clock.callLater(howLong(), self) def __repr__(self) -> str: # This code should be replaced by a utility function in reflect; # see ticket #6066: func = getattr(self.f, "__qualname__", None) if func is None: func = getattr(self.f, "__name__", None) if func is not None: imClass = getattr(self.f, "im_class", None) if imClass is not None: func = f"{imClass}.{func}" if func is None: func = reflect.safe_repr(self.f) return "LoopingCall<{!r}>({}, *{}, **{})".format( self.interval, func, reflect.safe_repr(self.a), reflect.safe_repr(self.kw), ) class SchedulerError(Exception): """ The operation could not be completed because the scheduler or one of its tasks was in an invalid state. This exception should not be raised directly, but is a superclass of various scheduler-state-related exceptions. """ class SchedulerStopped(SchedulerError): """ The operation could not complete because the scheduler was stopped in progress or was already stopped. """ class TaskFinished(SchedulerError): """ The operation could not complete because the task was already completed, stopped, encountered an error or otherwise permanently stopped running. """ class TaskDone(TaskFinished): """ The operation could not complete because the task was already completed. """ class TaskStopped(TaskFinished): """ The operation could not complete because the task was stopped. """ class TaskFailed(TaskFinished): """ The operation could not complete because the task died with an unhandled error. """ class NotPaused(SchedulerError): """ This exception is raised when a task is resumed which was not previously paused. """ class _Timer: MAX_SLICE = 0.01 def __init__(self) -> None: self.end = time.time() + self.MAX_SLICE def __call__(self) -> bool: return time.time() >= self.end _EPSILON = 0.00000001 def _defaultScheduler(callable: Callable[[], None]) -> IDelayedCall: from twisted.internet import reactor return cast(IReactorTime, reactor).callLater(_EPSILON, callable) _TaskResultT = TypeVar("_TaskResultT") class CooperativeTask: """ A L{CooperativeTask} is a task object inside a L{Cooperator}, which can be paused, resumed, and stopped. It can also have its completion (or termination) monitored. @see: L{Cooperator.cooperate} @ivar _iterator: the iterator to iterate when this L{CooperativeTask} is asked to do work. @ivar _cooperator: the L{Cooperator} that this L{CooperativeTask} participates in, which is used to re-insert it upon resume. @ivar _deferreds: the list of L{Deferred}s to fire when this task completes, fails, or finishes. @ivar _pauseCount: the number of times that this L{CooperativeTask} has been paused; if 0, it is running. @ivar _completionState: The completion-state of this L{CooperativeTask}. L{None} if the task is not yet completed, an instance of L{TaskStopped} if C{stop} was called to stop this task early, of L{TaskFailed} if the application code in the iterator raised an exception which caused it to terminate, and of L{TaskDone} if it terminated normally via raising C{StopIteration}. """ def __init__( self, iterator: Iterator[_TaskResultT], cooperator: "Cooperator" ) -> None: """ A private constructor: to create a new L{CooperativeTask}, see L{Cooperator.cooperate}. """ self._iterator = iterator self._cooperator = cooperator self._deferreds: List[Deferred[Iterator[_TaskResultT]]] = [] self._pauseCount = 0 self._completionState: Optional[SchedulerError] = None self._completionResult: Optional[Union[Iterator[_TaskResultT], Failure]] = None cooperator._addTask(self) def whenDone(self) -> Deferred[Iterator[_TaskResultT]]: """ Get a L{Deferred} notification of when this task is complete. @return: a L{Deferred} that fires with the C{iterator} that this L{CooperativeTask} was created with when the iterator has been exhausted (i.e. its C{next} method has raised C{StopIteration}), or fails with the exception raised by C{next} if it raises some other exception. @rtype: L{Deferred} """ d: Deferred[Iterator[_TaskResultT]] = Deferred() if self._completionState is None: self._deferreds.append(d) else: assert self._completionResult is not None d.callback(self._completionResult) return d def pause(self) -> None: """ Pause this L{CooperativeTask}. Stop doing work until L{CooperativeTask.resume} is called. If C{pause} is called more than once, C{resume} must be called an equal number of times to resume this task. @raise TaskFinished: if this task has already finished or completed. """ self._checkFinish() self._pauseCount += 1 if self._pauseCount == 1: self._cooperator._removeTask(self) def resume(self) -> None: """ Resume processing of a paused L{CooperativeTask}. @raise NotPaused: if this L{CooperativeTask} is not paused. """ if self._pauseCount == 0: raise NotPaused() self._pauseCount -= 1 if self._pauseCount == 0 and self._completionState is None: self._cooperator._addTask(self) def _completeWith( self, completionState: SchedulerError, deferredResult: Union[Iterator[_TaskResultT], Failure], ) -> None: """ @param completionState: a L{SchedulerError} exception or a subclass thereof, indicating what exception should be raised when subsequent operations are performed. @param deferredResult: the result to fire all the deferreds with. """ self._completionState = completionState self._completionResult = deferredResult if not self._pauseCount: self._cooperator._removeTask(self) # The Deferreds need to be invoked after all this is completed, because # a Deferred may want to manipulate other tasks in a Cooperator. For # example, if you call "stop()" on a cooperator in a callback on a # Deferred returned from whenDone(), this CooperativeTask must be gone # from the Cooperator by that point so that _completeWith is not # invoked reentrantly; that would cause these Deferreds to blow up with # an AlreadyCalledError, or the _removeTask to fail with a ValueError. for d in self._deferreds: d.callback(deferredResult) def stop(self) -> None: """ Stop further processing of this task. @raise TaskFinished: if this L{CooperativeTask} has previously completed, via C{stop}, completion, or failure. """ self._checkFinish() self._completeWith(TaskStopped(), Failure(TaskStopped())) def _checkFinish(self) -> None: """ If this task has been stopped, raise the appropriate subclass of L{TaskFinished}. """ if self._completionState is not None: raise self._completionState def _oneWorkUnit(self) -> None: """ Perform one unit of work for this task, retrieving one item from its iterator, stopping if there are no further items in the iterator, and pausing if the result was a L{Deferred}. """ try: result = next(self._iterator) except StopIteration: self._completeWith(TaskDone(), self._iterator) except BaseException: self._completeWith(TaskFailed(), Failure()) else: if isinstance(result, Deferred): self.pause() def failLater(failure: Failure) -> None: self._completeWith(TaskFailed(), failure) result.addCallbacks(lambda result: self.resume(), failLater) class Cooperator: """ Cooperative task scheduler. A cooperative task is an iterator where each iteration represents an atomic unit of work. When the iterator yields, it allows the L{Cooperator} to decide which of its tasks to execute next. If the iterator yields a L{Deferred} then work will pause until the L{Deferred} fires and completes its callback chain. When a L{Cooperator} has more than one task, it distributes work between all tasks. There are two ways to add tasks to a L{Cooperator}, L{cooperate} and L{coiterate}. L{cooperate} is the more useful of the two, as it returns a L{CooperativeTask}, which can be L{paused<CooperativeTask.pause>}, L{resumed<CooperativeTask.resume>} and L{waited on<CooperativeTask.whenDone>}. L{coiterate} has the same effect, but returns only a L{Deferred} that fires when the task is done. L{Cooperator} can be used for many things, including but not limited to: - running one or more computationally intensive tasks without blocking - limiting parallelism by running a subset of the total tasks simultaneously - doing one thing, waiting for a L{Deferred} to fire, doing the next thing, repeat (i.e. serializing a sequence of asynchronous tasks) Multiple L{Cooperator}s do not cooperate with each other, so for most cases you should use the L{global cooperator<task.cooperate>}. """ def __init__( self, terminationPredicateFactory: Callable[[], Callable[[], bool]] = _Timer, scheduler: Callable[[Callable[[], None]], IDelayedCall] = _defaultScheduler, started: bool = True, ): """ Create a scheduler-like object to which iterators may be added. @param terminationPredicateFactory: A no-argument callable which will be invoked at the beginning of each step and should return a no-argument callable which will return True when the step should be terminated. The default factory is time-based and allows iterators to run for 1/100th of a second at a time. @param scheduler: A one-argument callable which takes a no-argument callable and should invoke it at some future point. This will be used to schedule each step of this Cooperator. @param started: A boolean which indicates whether iterators should be stepped as soon as they are added, or if they will be queued up until L{Cooperator.start} is called. """ self._tasks: List[CooperativeTask] = [] self._metarator: Iterator[CooperativeTask] = iter(()) self._terminationPredicateFactory = terminationPredicateFactory self._scheduler = scheduler self._delayedCall: Optional[IDelayedCall] = None self._stopped = False self._started = started def coiterate( self, iterator: Iterator[_TaskResultT], doneDeferred: Optional[Deferred[Iterator[_TaskResultT]]] = None, ) -> Deferred[Iterator[_TaskResultT]]: """ Add an iterator to the list of iterators this L{Cooperator} is currently running. Equivalent to L{cooperate}, but returns a L{Deferred} that will be fired when the task is done. @param doneDeferred: If specified, this will be the Deferred used as the completion deferred. It is suggested that you use the default, which creates a new Deferred for you. @return: a Deferred that will fire when the iterator finishes. """ if doneDeferred is None: doneDeferred = Deferred() CooperativeTask(iterator, self).whenDone().chainDeferred(doneDeferred) return doneDeferred def cooperate(self, iterator: Iterator[_TaskResultT]) -> CooperativeTask: """ Start running the given iterator as a long-running cooperative task, by calling next() on it as a periodic timed event. @param iterator: the iterator to invoke. @return: a L{CooperativeTask} object representing this task. """ return CooperativeTask(iterator, self) def _addTask(self, task: CooperativeTask) -> None: """ Add a L{CooperativeTask} object to this L{Cooperator}. """ if self._stopped: self._tasks.append(task) # XXX silly, I know, but _completeWith # does the inverse task._completeWith(SchedulerStopped(), Failure(SchedulerStopped())) else: self._tasks.append(task) self._reschedule() def _removeTask(self, task: CooperativeTask) -> None: """ Remove a L{CooperativeTask} from this L{Cooperator}. """ self._tasks.remove(task) # If no work left to do, cancel the delayed call: if not self._tasks and self._delayedCall: self._delayedCall.cancel() self._delayedCall = None def _tasksWhileNotStopped(self) -> Iterable[CooperativeTask]: """ Yield all L{CooperativeTask} objects in a loop as long as this L{Cooperator}'s termination condition has not been met. """ terminator = self._terminationPredicateFactory() while self._tasks: for t in self._metarator: yield t if terminator(): return self._metarator = iter(self._tasks) def _tick(self) -> None: """ Run one scheduler tick. """ self._delayedCall = None for taskObj in self._tasksWhileNotStopped(): taskObj._oneWorkUnit() self._reschedule() _mustScheduleOnStart = False def _reschedule(self) -> None: if not self._started: self._mustScheduleOnStart = True return if self._delayedCall is None and self._tasks: self._delayedCall = self._scheduler(self._tick) def start(self) -> None: """ Begin scheduling steps. """ self._stopped = False self._started = True if self._mustScheduleOnStart: del self._mustScheduleOnStart self._reschedule() def stop(self) -> None: """ Stop scheduling steps. Errback the completion Deferreds of all iterators which have been added and forget about them. """ self._stopped = True for taskObj in self._tasks: taskObj._completeWith(SchedulerStopped(), Failure(SchedulerStopped())) self._tasks = [] if self._delayedCall is not None: self._delayedCall.cancel() self._delayedCall = None @property def running(self) -> bool: """ Is this L{Cooperator} is currently running? @return: C{True} if the L{Cooperator} is running, C{False} otherwise. @rtype: C{bool} """ return self._started and not self._stopped _theCooperator = Cooperator() def coiterate(iterator: Iterator[_T]) -> Deferred[Iterator[_T]]: """ Cooperatively iterate over the given iterator, dividing runtime between it and all other iterators which have been passed to this function and not yet exhausted. @param iterator: the iterator to invoke. @return: a Deferred that will fire when the iterator finishes. """ return _theCooperator.coiterate(iterator) def cooperate(iterator: Iterator[_T]) -> CooperativeTask: """ Start running the given iterator as a long-running cooperative task, by calling next() on it as a periodic timed event. This is very useful if you have computationally expensive tasks that you want to run without blocking the reactor. Just break each task up so that it yields frequently, pass it in here and the global L{Cooperator} will make sure work is distributed between them without blocking longer than a single iteration of a single task. @param iterator: the iterator to invoke. @return: a L{CooperativeTask} object representing this task. """ return _theCooperator.cooperate(iterator) @implementer(IReactorTime) class Clock: """ Provide a deterministic, easily-controlled implementation of L{IReactorTime.callLater}. This is commonly useful for writing deterministic unit tests for code which schedules events using this API. """ rightNow = 0.0 def __init__(self) -> None: self.calls: List[DelayedCall] = [] def seconds(self) -> float: """ Pretend to be time.time(). This is used internally when an operation such as L{IDelayedCall.reset} needs to determine a time value relative to the current time. @return: The time which should be considered the current time. """ return self.rightNow def _sortCalls(self) -> None: """ Sort the pending calls according to the time they are scheduled. """ self.calls.sort(key=lambda a: a.getTime()) def callLater( self, delay: float, callable: Callable[..., object], *args: object, **kw: object ) -> IDelayedCall: """ See L{twisted.internet.interfaces.IReactorTime.callLater}. """ dc = DelayedCall( self.seconds() + delay, callable, args, kw, self.calls.remove, lambda c: None, self.seconds, ) self.calls.append(dc) self._sortCalls() return dc def getDelayedCalls(self) -> Sequence[IDelayedCall]: """ See L{twisted.internet.interfaces.IReactorTime.getDelayedCalls} """ return self.calls def advance(self, amount: float) -> None: """ Move time on this clock forward by the given amount and run whatever pending calls should be run. @param amount: The number of seconds which to advance this clock's time. """ self.rightNow += amount self._sortCalls() while self.calls and self.calls[0].getTime() <= self.seconds(): call = self.calls.pop(0) call.called = 1 call.func(*call.args, **call.kw) self._sortCalls() def pump(self, timings: Iterable[float]) -> None: """ Advance incrementally by the given set of times. """ for amount in timings: self.advance(amount) def deferLater( clock: IReactorTime, delay: float, callable: Optional[Callable[..., _T]] = None, *args: object, **kw: object, ) -> Deferred[_T]: """ Call the given function after a certain period of time has passed. @param clock: The object which will be used to schedule the delayed call. @param delay: The number of seconds to wait before calling the function. @param callable: The callable to call after the delay, or C{None}. @param args: The positional arguments to pass to C{callable}. @param kw: The keyword arguments to pass to C{callable}. @return: A deferred that fires with the result of the callable when the specified time has elapsed. """ def deferLaterCancel(deferred: Deferred[object]) -> None: delayedCall.cancel() def cb(result: object) -> _T: if callable is None: return None # type: ignore[return-value] return callable(*args, **kw) d: Deferred[_T] = Deferred(deferLaterCancel) d.addCallback(cb) delayedCall = clock.callLater(delay, d.callback, None) return d def react( main: Callable[ ..., Union[Deferred[_T], Coroutine["Deferred[_T]", object, _T]], ], argv: Iterable[_T] = (), _reactor: Optional[IReactorCore] = None, ) -> NoReturn: """ Call C{main} and run the reactor until the L{Deferred} it returns fires or the coroutine it returns completes. This is intended as the way to start up an application with a well-defined completion condition. Use it to write clients or one-off asynchronous operations. Prefer this to calling C{reactor.run} directly, as this function will also: - Take care to call C{reactor.stop} once and only once, and at the right time. - Log any failures from the C{Deferred} returned by C{main}. - Exit the application when done, with exit code 0 in case of success and 1 in case of failure. If C{main} fails with a C{SystemExit} error, the code returned is used. The following demonstrates the signature of a C{main} function which can be used with L{react}:: async def main(reactor, username, password): return "ok" task.react(main, ("alice", "secret")) @param main: A callable which returns a L{Deferred} or coroutine. It should take the reactor as its first parameter, followed by the elements of C{argv}. @param argv: A list of arguments to pass to C{main}. If omitted the callable will be invoked with no additional arguments. @param _reactor: An implementation detail to allow easier unit testing. Do not supply this parameter. @since: 12.3 """ if _reactor is None: from twisted.internet import reactor _reactor = cast(IReactorCore, reactor) finished = ensureDeferred(main(_reactor, *argv)) code = 0 stopping = False def onShutdown() -> None: nonlocal stopping stopping = True _reactor.addSystemEventTrigger("before", "shutdown", onShutdown) def stop(result: object, stopReactor: bool) -> None: if stopReactor: assert _reactor is not None try: _reactor.stop() except ReactorNotRunning: pass if isinstance(result, Failure): nonlocal code if result.check(SystemExit) is not None: code = result.value.code else: log.err(result, "main function encountered error") code = 1 def cbFinish(result: object) -> None: if stopping: stop(result, False) else: assert _reactor is not None _reactor.callWhenRunning(stop, result, True) finished.addBoth(cbFinish) _reactor.run() sys.exit(code) __all__ = [ "LoopingCall", "Clock", "SchedulerStopped", "Cooperator", "coiterate", "deferLater", "react", ] PK Mb�Z$O�sE E internet/_producer_helpers.pynu �[��� # -*- test-case-name: twisted.test.test_producer_helpers -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Helpers for working with producers. """ from typing import List from zope.interface import implementer from twisted.internet.interfaces import IPushProducer from twisted.internet.task import cooperate from twisted.python import log from twisted.python.reflect import safe_str # This module exports nothing public, it's for internal Twisted use only. __all__: List[str] = [] @implementer(IPushProducer) class _PullToPush: """ An adapter that converts a non-streaming to a streaming producer. Because of limitations of the producer API, this adapter requires the cooperation of the consumer. When the consumer's C{registerProducer} is called with a non-streaming producer, it must wrap it with L{_PullToPush} and then call C{startStreaming} on the resulting object. When the consumer's C{unregisterProducer} is called, it must call C{stopStreaming} on the L{_PullToPush} instance. If the underlying producer throws an exception from C{resumeProducing}, the producer will be unregistered from the consumer. @ivar _producer: the underling non-streaming producer. @ivar _consumer: the consumer with which the underlying producer was registered. @ivar _finished: C{bool} indicating whether the producer has finished. @ivar _coopTask: the result of calling L{cooperate}, the task driving the streaming producer. """ _finished = False def __init__(self, pullProducer, consumer): self._producer = pullProducer self._consumer = consumer def _pull(self): """ A generator that calls C{resumeProducing} on the underlying producer forever. If C{resumeProducing} throws an exception, the producer is unregistered, which should result in streaming stopping. """ while True: try: self._producer.resumeProducing() except BaseException: log.err( None, "%s failed, producing will be stopped:" % (safe_str(self._producer),), ) try: self._consumer.unregisterProducer() # The consumer should now call stopStreaming() on us, # thus stopping the streaming. except BaseException: # Since the consumer blew up, we may not have had # stopStreaming() called, so we just stop on our own: log.err( None, "%s failed to unregister producer:" % (safe_str(self._consumer),), ) self._finished = True return yield None def startStreaming(self): """ This should be called by the consumer when the producer is registered. Start streaming data to the consumer. """ self._coopTask = cooperate(self._pull()) def stopStreaming(self): """ This should be called by the consumer when the producer is unregistered. Stop streaming data to the consumer. """ if self._finished: return self._finished = True self._coopTask.stop() def pauseProducing(self): """ @see: C{IPushProducer.pauseProducing} """ self._coopTask.pause() def resumeProducing(self): """ @see: C{IPushProducer.resumeProducing} """ self._coopTask.resume() def stopProducing(self): """ @see: C{IPushProducer.stopProducing} """ self.stopStreaming() self._producer.stopProducing() PK Mb�Z��m��. �. internet/endpoints.pynu �[��� # -*- test-case-name: twisted.internet.test.test_endpoints -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Implementations of L{IStreamServerEndpoint} and L{IStreamClientEndpoint} that wrap the L{IReactorTCP}, L{IReactorSSL}, and L{IReactorUNIX} interfaces. This also implements an extensible mini-language for describing endpoints, parsed by the L{clientFromString} and L{serverFromString} functions. @since: 10.1 """ import os import re import socket import warnings from unicodedata import normalize from zope.interface import directlyProvides, implementer, provider from constantly import NamedConstant, Names # type: ignore[import] from incremental import Version from twisted.internet import defer, error, fdesc, interfaces, threads from twisted.internet.abstract import isIPAddress, isIPv6Address from twisted.internet.address import ( HostnameAddress, IPv4Address, IPv6Address, _ProcessAddress, ) from twisted.internet.interfaces import ( IHostnameResolver, IReactorPluggableNameResolver, IResolutionReceiver, IStreamClientEndpointStringParserWithReactor, IStreamServerEndpointStringParser, ) from twisted.internet.protocol import ClientFactory, Factory, ProcessProtocol, Protocol try: from twisted.internet.stdio import PipeAddress, StandardIO except ImportError: # fallback if pywin32 is not installed StandardIO = None # type: ignore[assignment,misc] PipeAddress = None # type: ignore[assignment,misc] from twisted.internet._resolver import HostResolution from twisted.internet.defer import Deferred from twisted.internet.task import LoopingCall from twisted.logger import Logger from twisted.plugin import IPlugin, getPlugins from twisted.python import deprecate, log from twisted.python.compat import _matchingString, iterbytes, nativeString from twisted.python.components import proxyForInterface from twisted.python.failure import Failure from twisted.python.filepath import FilePath from twisted.python.systemd import ListenFDs from ._idna import _idnaBytes, _idnaText try: from OpenSSL.SSL import Error as SSLError from twisted.internet.ssl import ( Certificate, CertificateOptions, KeyPair, PrivateCertificate, optionsForClientTLS, trustRootFromCertificates, ) from twisted.protocols.tls import TLSMemoryBIOFactory as _TLSMemoryBIOFactory except ImportError: TLSMemoryBIOFactory = None else: TLSMemoryBIOFactory = _TLSMemoryBIOFactory __all__ = [ "clientFromString", "serverFromString", "TCP4ServerEndpoint", "TCP6ServerEndpoint", "TCP4ClientEndpoint", "TCP6ClientEndpoint", "UNIXServerEndpoint", "UNIXClientEndpoint", "SSL4ServerEndpoint", "SSL4ClientEndpoint", "AdoptedStreamServerEndpoint", "StandardIOEndpoint", "ProcessEndpoint", "HostnameEndpoint", "StandardErrorBehavior", "connectProtocol", "wrapClientTLS", ] class _WrappingProtocol(Protocol): """ Wrap another protocol in order to notify my user when a connection has been made. """ def __init__(self, connectedDeferred, wrappedProtocol): """ @param connectedDeferred: The L{Deferred} that will callback with the C{wrappedProtocol} when it is connected. @param wrappedProtocol: An L{IProtocol} provider that will be connected. """ self._connectedDeferred = connectedDeferred self._wrappedProtocol = wrappedProtocol for iface in [ interfaces.IHalfCloseableProtocol, interfaces.IFileDescriptorReceiver, interfaces.IHandshakeListener, ]: if iface.providedBy(self._wrappedProtocol): directlyProvides(self, iface) def logPrefix(self): """ Transparently pass through the wrapped protocol's log prefix. """ if interfaces.ILoggingContext.providedBy(self._wrappedProtocol): return self._wrappedProtocol.logPrefix() return self._wrappedProtocol.__class__.__name__ def connectionMade(self): """ Connect the C{self._wrappedProtocol} to our C{self.transport} and callback C{self._connectedDeferred} with the C{self._wrappedProtocol} """ self._wrappedProtocol.makeConnection(self.transport) self._connectedDeferred.callback(self._wrappedProtocol) def dataReceived(self, data): """ Proxy C{dataReceived} calls to our C{self._wrappedProtocol} """ return self._wrappedProtocol.dataReceived(data) def fileDescriptorReceived(self, descriptor): """ Proxy C{fileDescriptorReceived} calls to our C{self._wrappedProtocol} """ return self._wrappedProtocol.fileDescriptorReceived(descriptor) def connectionLost(self, reason): """ Proxy C{connectionLost} calls to our C{self._wrappedProtocol} """ return self._wrappedProtocol.connectionLost(reason) def readConnectionLost(self): """ Proxy L{IHalfCloseableProtocol.readConnectionLost} to our C{self._wrappedProtocol} """ self._wrappedProtocol.readConnectionLost() def writeConnectionLost(self): """ Proxy L{IHalfCloseableProtocol.writeConnectionLost} to our C{self._wrappedProtocol} """ self._wrappedProtocol.writeConnectionLost() def handshakeCompleted(self): """ Proxy L{interfaces.IHandshakeListener} to our C{self._wrappedProtocol}. """ self._wrappedProtocol.handshakeCompleted() class _WrappingFactory(ClientFactory): """ Wrap a factory in order to wrap the protocols it builds. @ivar _wrappedFactory: A provider of I{IProtocolFactory} whose buildProtocol method will be called and whose resulting protocol will be wrapped. @ivar _onConnection: A L{Deferred} that fires when the protocol is connected @ivar _connector: A L{connector <twisted.internet.interfaces.IConnector>} that is managing the current or previous connection attempt. """ # Type is wrong. See https://twistedmatrix.com/trac/ticket/10005#ticket protocol = _WrappingProtocol # type: ignore[assignment] def __init__(self, wrappedFactory): """ @param wrappedFactory: A provider of I{IProtocolFactory} whose buildProtocol method will be called and whose resulting protocol will be wrapped. """ self._wrappedFactory = wrappedFactory self._onConnection = defer.Deferred(canceller=self._canceller) def startedConnecting(self, connector): """ A connection attempt was started. Remember the connector which started said attempt, for use later. """ self._connector = connector def _canceller(self, deferred): """ The outgoing connection attempt was cancelled. Fail that L{Deferred} with an L{error.ConnectingCancelledError}. @param deferred: The L{Deferred <defer.Deferred>} that was cancelled; should be the same as C{self._onConnection}. @type deferred: L{Deferred <defer.Deferred>} @note: This relies on startedConnecting having been called, so it may seem as though there's a race condition where C{_connector} may not have been set. However, using public APIs, this condition is impossible to catch, because a connection API (C{connectTCP}/C{SSL}/C{UNIX}) is always invoked before a L{_WrappingFactory}'s L{Deferred <defer.Deferred>} is returned to C{connect()}'s caller. @return: L{None} """ deferred.errback( error.ConnectingCancelledError(self._connector.getDestination()) ) self._connector.stopConnecting() def doStart(self): """ Start notifications are passed straight through to the wrapped factory. """ self._wrappedFactory.doStart() def doStop(self): """ Stop notifications are passed straight through to the wrapped factory. """ self._wrappedFactory.doStop() def buildProtocol(self, addr): """ Proxy C{buildProtocol} to our C{self._wrappedFactory} or errback the C{self._onConnection} L{Deferred} if the wrapped factory raises an exception or returns L{None}. @return: An instance of L{_WrappingProtocol} or L{None} """ try: proto = self._wrappedFactory.buildProtocol(addr) if proto is None: raise error.NoProtocol() except BaseException: self._onConnection.errback() else: return self.protocol(self._onConnection, proto) def clientConnectionFailed(self, connector, reason): """ Errback the C{self._onConnection} L{Deferred} when the client connection fails. """ if not self._onConnection.called: self._onConnection.errback(reason) @implementer(interfaces.IStreamServerEndpoint) class StandardIOEndpoint: """ A Standard Input/Output endpoint @ivar _stdio: a callable, like L{stdio.StandardIO}, which takes an L{IProtocol} provider and a C{reactor} keyword argument (interface dependent upon your platform). """ _stdio = StandardIO def __init__(self, reactor): """ @param reactor: The reactor for the endpoint. """ self._reactor = reactor def listen(self, stdioProtocolFactory): """ Implement L{IStreamServerEndpoint.listen} to listen on stdin/stdout """ return defer.execute( self._stdio, stdioProtocolFactory.buildProtocol(PipeAddress()), reactor=self._reactor, ) class _IProcessTransportWithConsumerAndProducer( interfaces.IProcessTransport, interfaces.IConsumer, interfaces.IPushProducer ): """ An L{_IProcessTransportWithConsumerAndProducer} combines various interfaces to work around the issue that L{interfaces.IProcessTransport} is incompletely defined and doesn't specify flow-control interfaces, and that L{proxyForInterface} doesn't allow for multiple interfaces. """ class _ProcessEndpointTransport( proxyForInterface( # type: ignore[misc] _IProcessTransportWithConsumerAndProducer, "_process", ) ): """ An L{ITransport}, L{IProcessTransport}, L{IConsumer}, and L{IPushProducer} provider for the L{IProtocol} instance passed to the process endpoint. @ivar _process: An active process transport which will be used by write methods on this object to write data to a child process. @type _process: L{interfaces.IProcessTransport} provider """ class _WrapIProtocol(ProcessProtocol): """ An L{IProcessProtocol} provider that wraps an L{IProtocol}. @ivar transport: A L{_ProcessEndpointTransport} provider that is hooked to the wrapped L{IProtocol} provider. @see: L{protocol.ProcessProtocol} """ def __init__(self, proto, executable, errFlag): """ @param proto: An L{IProtocol} provider. @param errFlag: A constant belonging to L{StandardErrorBehavior} that determines if stderr is logged or dropped. @param executable: The file name (full path) to spawn. """ self.protocol = proto self.errFlag = errFlag self.executable = executable def makeConnection(self, process): """ Call L{IProtocol} provider's makeConnection method with an L{ITransport} provider. @param process: An L{IProcessTransport} provider. """ self.transport = _ProcessEndpointTransport(process) return self.protocol.makeConnection(self.transport) def childDataReceived(self, childFD, data): """ This is called with data from the process's stdout or stderr pipes. It checks the status of the errFlag to setermine if stderr should be logged (default) or dropped. """ if childFD == 1: return self.protocol.dataReceived(data) elif childFD == 2 and self.errFlag == StandardErrorBehavior.LOG: log.msg( format="Process %(executable)r wrote stderr unhandled by " "%(protocol)s: %(data)s", executable=self.executable, protocol=self.protocol, data=data, ) def processEnded(self, reason): """ If the process ends with L{error.ProcessDone}, this method calls the L{IProtocol} provider's L{connectionLost} with a L{error.ConnectionDone} @see: L{ProcessProtocol.processEnded} """ if (reason.check(error.ProcessDone) == error.ProcessDone) and ( reason.value.status == 0 ): return self.protocol.connectionLost(Failure(error.ConnectionDone())) else: return self.protocol.connectionLost(reason) class StandardErrorBehavior(Names): """ Constants used in ProcessEndpoint to decide what to do with stderr. @cvar LOG: Indicates that stderr is to be logged. @cvar DROP: Indicates that stderr is to be dropped (and not logged). @since: 13.1 """ LOG = NamedConstant() DROP = NamedConstant() @implementer(interfaces.IStreamClientEndpoint) class ProcessEndpoint: """ An endpoint for child processes @ivar _spawnProcess: A hook used for testing the spawning of child process. @since: 13.1 """ def __init__( self, reactor, executable, args=(), env={}, path=None, uid=None, gid=None, usePTY=0, childFDs=None, errFlag=StandardErrorBehavior.LOG, ): """ See L{IReactorProcess.spawnProcess}. @param errFlag: Determines if stderr should be logged. @type errFlag: L{endpoints.StandardErrorBehavior} """ self._reactor = reactor self._executable = executable self._args = args self._env = env self._path = path self._uid = uid self._gid = gid self._usePTY = usePTY self._childFDs = childFDs self._errFlag = errFlag self._spawnProcess = self._reactor.spawnProcess def connect(self, protocolFactory): """ Implement L{IStreamClientEndpoint.connect} to launch a child process and connect it to a protocol created by C{protocolFactory}. @param protocolFactory: A factory for an L{IProtocol} provider which will be notified of all events related to the created process. """ proto = protocolFactory.buildProtocol(_ProcessAddress()) try: self._spawnProcess( _WrapIProtocol(proto, self._executable, self._errFlag), self._executable, self._args, self._env, self._path, self._uid, self._gid, self._usePTY, self._childFDs, ) except BaseException: return defer.fail() else: return defer.succeed(proto) @implementer(interfaces.IStreamServerEndpoint) class _TCPServerEndpoint: """ A TCP server endpoint interface """ def __init__(self, reactor, port, backlog, interface): """ @param reactor: An L{IReactorTCP} provider. @param port: The port number used for listening @type port: int @param backlog: Size of the listen queue @type backlog: int @param interface: The hostname to bind to @type interface: str """ self._reactor = reactor self._port = port self._backlog = backlog self._interface = interface def listen(self, protocolFactory): """ Implement L{IStreamServerEndpoint.listen} to listen on a TCP socket """ return defer.execute( self._reactor.listenTCP, self._port, protocolFactory, backlog=self._backlog, interface=self._interface, ) class TCP4ServerEndpoint(_TCPServerEndpoint): """ Implements TCP server endpoint with an IPv4 configuration """ def __init__(self, reactor, port, backlog=50, interface=""): """ @param reactor: An L{IReactorTCP} provider. @param port: The port number used for listening @type port: int @param backlog: Size of the listen queue @type backlog: int @param interface: The hostname to bind to, defaults to '' (all) @type interface: str """ _TCPServerEndpoint.__init__(self, reactor, port, backlog, interface) class TCP6ServerEndpoint(_TCPServerEndpoint): """ Implements TCP server endpoint with an IPv6 configuration """ def __init__(self, reactor, port, backlog=50, interface="::"): """ @param reactor: An L{IReactorTCP} provider. @param port: The port number used for listening @type port: int @param backlog: Size of the listen queue @type backlog: int @param interface: The hostname to bind to, defaults to C{::} (all) @type interface: str """ _TCPServerEndpoint.__init__(self, reactor, port, backlog, interface) @implementer(interfaces.IStreamClientEndpoint) class TCP4ClientEndpoint: """ TCP client endpoint with an IPv4 configuration. """ def __init__(self, reactor, host, port, timeout=30, bindAddress=None): """ @param reactor: An L{IReactorTCP} provider @param host: A hostname, used when connecting @type host: str @param port: The port number, used when connecting @type port: int @param timeout: The number of seconds to wait before assuming the connection has failed. @type timeout: L{float} or L{int} @param bindAddress: A (host, port) tuple of local address to bind to, or None. @type bindAddress: tuple """ self._reactor = reactor self._host = host self._port = port self._timeout = timeout self._bindAddress = bindAddress def connect(self, protocolFactory): """ Implement L{IStreamClientEndpoint.connect} to connect via TCP. """ try: wf = _WrappingFactory(protocolFactory) self._reactor.connectTCP( self._host, self._port, wf, timeout=self._timeout, bindAddress=self._bindAddress, ) return wf._onConnection except BaseException: return defer.fail() @implementer(interfaces.IStreamClientEndpoint) class TCP6ClientEndpoint: """ TCP client endpoint with an IPv6 configuration. @ivar _getaddrinfo: A hook used for testing name resolution. @ivar _deferToThread: A hook used for testing deferToThread. @ivar _GAI_ADDRESS: Index of the address portion in result of getaddrinfo to be used. @ivar _GAI_ADDRESS_HOST: Index of the actual host-address in the 5-tuple L{_GAI_ADDRESS}. """ _getaddrinfo = staticmethod(socket.getaddrinfo) _deferToThread = staticmethod(threads.deferToThread) _GAI_ADDRESS = 4 _GAI_ADDRESS_HOST = 0 def __init__(self, reactor, host, port, timeout=30, bindAddress=None): """ @param host: An IPv6 address literal or a hostname with an IPv6 address @see: L{twisted.internet.interfaces.IReactorTCP.connectTCP} """ self._reactor = reactor self._host = host self._port = port self._timeout = timeout self._bindAddress = bindAddress def connect(self, protocolFactory): """ Implement L{IStreamClientEndpoint.connect} to connect via TCP, once the hostname resolution is done. """ if isIPv6Address(self._host): d = self._resolvedHostConnect(self._host, protocolFactory) else: d = self._nameResolution(self._host) d.addCallback( lambda result: result[0][self._GAI_ADDRESS][self._GAI_ADDRESS_HOST] ) d.addCallback(self._resolvedHostConnect, protocolFactory) return d def _nameResolution(self, host): """ Resolve the hostname string into a tuple containing the host IPv6 address. """ return self._deferToThread(self._getaddrinfo, host, 0, socket.AF_INET6) def _resolvedHostConnect(self, resolvedHost, protocolFactory): """ Connect to the server using the resolved hostname. """ try: wf = _WrappingFactory(protocolFactory) self._reactor.connectTCP( resolvedHost, self._port, wf, timeout=self._timeout, bindAddress=self._bindAddress, ) return wf._onConnection except BaseException: return defer.fail() @implementer(IHostnameResolver) class _SimpleHostnameResolver: """ An L{IHostnameResolver} provider that invokes a provided callable to resolve hostnames. @ivar _nameResolution: the callable L{resolveHostName} invokes to resolve hostnames. @type _nameResolution: A L{callable} that accepts two arguments: the host to resolve and the port number to include in the result. """ _log = Logger() def __init__(self, nameResolution): """ Create a L{_SimpleHostnameResolver} instance. """ self._nameResolution = nameResolution def resolveHostName( self, resolutionReceiver, hostName, portNumber=0, addressTypes=None, transportSemantics="TCP", ): """ Initiate a hostname resolution. @param resolutionReceiver: an object that will receive each resolved address as it arrives. @type resolutionReceiver: L{IResolutionReceiver} @param hostName: see interface @param portNumber: see interface @param addressTypes: Ignored in this implementation. @param transportSemantics: Ignored in this implementation. @return: The resolution in progress. @rtype: L{IResolutionReceiver} """ resolutionReceiver.resolutionBegan(HostResolution(hostName)) d = self._nameResolution(hostName, portNumber) def cbDeliver(gairesult): for family, socktype, proto, canonname, sockaddr in gairesult: if family == socket.AF_INET6: resolutionReceiver.addressResolved(IPv6Address("TCP", *sockaddr)) elif family == socket.AF_INET: resolutionReceiver.addressResolved(IPv4Address("TCP", *sockaddr)) def ebLog(error): self._log.failure( "while looking up {name} with {callable}", error, name=hostName, callable=self._nameResolution, ) d.addCallback(cbDeliver) d.addErrback(ebLog) d.addBoth(lambda ignored: resolutionReceiver.resolutionComplete()) return resolutionReceiver @implementer(interfaces.IStreamClientEndpoint) class HostnameEndpoint: """ A name-based endpoint that connects to the fastest amongst the resolved host addresses. @cvar _DEFAULT_ATTEMPT_DELAY: The default time to use between attempts, in seconds, when no C{attemptDelay} is given to L{HostnameEndpoint.__init__}. @ivar _hostText: the textual representation of the hostname passed to the constructor. Used to pass to the reactor's hostname resolver. @type _hostText: L{unicode} @ivar _hostBytes: the encoded bytes-representation of the hostname passed to the constructor. Used to construct the L{HostnameAddress} associated with this endpoint. @type _hostBytes: L{bytes} @ivar _hostStr: the native-string representation of the hostname passed to the constructor, used for exception construction @type _hostStr: native L{str} @ivar _badHostname: a flag - hopefully false! - indicating that an invalid hostname was passed to the constructor. This might be a textual hostname that isn't valid IDNA, or non-ASCII bytes. @type _badHostname: L{bool} """ _getaddrinfo = staticmethod(socket.getaddrinfo) _deferToThread = staticmethod(threads.deferToThread) _DEFAULT_ATTEMPT_DELAY = 0.3 def __init__( self, reactor, host, port, timeout=30, bindAddress=None, attemptDelay=None ): """ Create a L{HostnameEndpoint}. @param reactor: The reactor to use for connections and delayed calls. @type reactor: provider of L{IReactorTCP}, L{IReactorTime} and either L{IReactorPluggableNameResolver} or L{IReactorPluggableResolver}. @param host: A hostname to connect to. @type host: L{bytes} or L{unicode} @param port: The port number to connect to. @type port: L{int} @param timeout: For each individual connection attempt, the number of seconds to wait before assuming the connection has failed. @type timeout: L{float} or L{int} @param bindAddress: the local address of the network interface to make the connections from. @type bindAddress: L{bytes} @param attemptDelay: The number of seconds to delay between connection attempts. @type attemptDelay: L{float} @see: L{twisted.internet.interfaces.IReactorTCP.connectTCP} """ self._reactor = reactor self._nameResolver = self._getNameResolverAndMaybeWarn(reactor) [self._badHostname, self._hostBytes, self._hostText] = self._hostAsBytesAndText( host ) self._hostStr = self._hostBytes if bytes is str else self._hostText self._port = port self._timeout = timeout self._bindAddress = bindAddress if attemptDelay is None: attemptDelay = self._DEFAULT_ATTEMPT_DELAY self._attemptDelay = attemptDelay def __repr__(self) -> str: """ Produce a string representation of the L{HostnameEndpoint}. @return: A L{str} """ if self._badHostname: # Use the backslash-encoded version of the string passed to the # constructor, which is already a native string. host = self._hostStr elif isIPv6Address(self._hostStr): host = f"[{self._hostStr}]" else: # Convert the bytes representation to a native string to ensure # that we display the punycoded version of the hostname, which is # more useful than any IDN version as it can be easily copy-pasted # into debugging tools. host = nativeString(self._hostBytes) return "".join(["<HostnameEndpoint ", host, ":", str(self._port), ">"]) def _getNameResolverAndMaybeWarn(self, reactor): """ Retrieve a C{nameResolver} callable and warn the caller's caller that using a reactor which doesn't provide L{IReactorPluggableNameResolver} is deprecated. @param reactor: The reactor to check. @return: A L{IHostnameResolver} provider. """ if not IReactorPluggableNameResolver.providedBy(reactor): warningString = deprecate.getDeprecationWarningString( reactor.__class__, Version("Twisted", 17, 5, 0), format=( "Passing HostnameEndpoint a reactor that does not" " provide IReactorPluggableNameResolver (%(fqpn)s)" " was deprecated in %(version)s" ), replacement=( "a reactor that provides" " IReactorPluggableNameResolver" ), ) warnings.warn(warningString, DeprecationWarning, stacklevel=3) return _SimpleHostnameResolver(self._fallbackNameResolution) return reactor.nameResolver @staticmethod def _hostAsBytesAndText(host): """ For various reasons (documented in the C{@ivar}'s in the class docstring) we need both a textual and a binary representation of the hostname given to the constructor. For compatibility and convenience, we accept both textual and binary representations of the hostname, save the form that was passed, and convert into the other form. This is mostly just because L{HostnameAddress} chose somewhat poorly to define its attribute as bytes; hopefully we can find a compatible way to clean this up in the future and just operate in terms of text internally. @param host: A hostname to convert. @type host: L{bytes} or C{str} @return: a 3-tuple of C{(invalid, bytes, text)} where C{invalid} is a boolean indicating the validity of the hostname, C{bytes} is a binary representation of C{host}, and C{text} is a textual representation of C{host}. """ if isinstance(host, bytes): if isIPAddress(host) or isIPv6Address(host): return False, host, host.decode("ascii") else: try: return False, host, _idnaText(host) except UnicodeError: # Convert the host to _some_ kind of text, to handle below. host = host.decode("charmap") else: host = normalize("NFC", host) if isIPAddress(host) or isIPv6Address(host): return False, host.encode("ascii"), host else: try: return False, _idnaBytes(host), host except UnicodeError: pass # `host` has been converted to text by this point either way; it's # invalid as a hostname, and so may contain unprintable characters and # such. escape it with backslashes so the user can get _some_ guess as # to what went wrong. asciibytes = host.encode("ascii", "backslashreplace") return True, asciibytes, asciibytes.decode("ascii") def connect(self, protocolFactory): """ Attempts a connection to each resolved address, and returns a connection which is established first. @param protocolFactory: The protocol factory whose protocol will be connected. @type protocolFactory: L{IProtocolFactory<twisted.internet.interfaces.IProtocolFactory>} @return: A L{Deferred} that fires with the connected protocol or fails a connection-related error. """ if self._badHostname: return defer.fail(ValueError(f"invalid hostname: {self._hostStr}")) d = Deferred() addresses = [] @provider(IResolutionReceiver) class EndpointReceiver: @staticmethod def resolutionBegan(resolutionInProgress): pass @staticmethod def addressResolved(address): addresses.append(address) @staticmethod def resolutionComplete(): d.callback(addresses) self._nameResolver.resolveHostName( EndpointReceiver, self._hostText, portNumber=self._port ) d.addErrback( lambda ignored: defer.fail( error.DNSLookupError(f"Couldn't find the hostname '{self._hostStr}'") ) ) @d.addCallback def resolvedAddressesToEndpoints(addresses): # Yield an endpoint for every address resolved from the name. for eachAddress in addresses: if isinstance(eachAddress, IPv6Address): yield TCP6ClientEndpoint( self._reactor, eachAddress.host, eachAddress.port, self._timeout, self._bindAddress, ) if isinstance(eachAddress, IPv4Address): yield TCP4ClientEndpoint( self._reactor, eachAddress.host, eachAddress.port, self._timeout, self._bindAddress, ) d.addCallback(list) def _canceller(d): # This canceller must remain defined outside of # `startConnectionAttempts`, because Deferred should not # participate in cycles with their cancellers; that would create a # potentially problematic circular reference and possibly # gc.garbage. d.errback( error.ConnectingCancelledError( HostnameAddress(self._hostBytes, self._port) ) ) @d.addCallback def startConnectionAttempts(endpoints): """ Given a sequence of endpoints obtained via name resolution, start connecting to a new one every C{self._attemptDelay} seconds until one of the connections succeeds, all of them fail, or the attempt is cancelled. @param endpoints: a list of all the endpoints we might try to connect to, as determined by name resolution. @type endpoints: L{list} of L{IStreamServerEndpoint} @return: a Deferred that fires with the result of the C{endpoint.connect} method that completes the fastest, or fails with the first connection error it encountered if none of them succeed. @rtype: L{Deferred} failing with L{error.ConnectingCancelledError} or firing with L{IProtocol} """ if not endpoints: raise error.DNSLookupError( f"no results for hostname lookup: {self._hostStr}" ) iterEndpoints = iter(endpoints) pending = [] failures = [] winner = defer.Deferred(canceller=_canceller) def checkDone(): if pending or checkDone.completed or checkDone.endpointsLeft: return winner.errback(failures.pop()) checkDone.completed = False checkDone.endpointsLeft = True @LoopingCall def iterateEndpoint(): endpoint = next(iterEndpoints, None) if endpoint is None: # The list of endpoints ends. checkDone.endpointsLeft = False checkDone() return eachAttempt = endpoint.connect(protocolFactory) pending.append(eachAttempt) @eachAttempt.addBoth def noLongerPending(result): pending.remove(eachAttempt) return result @eachAttempt.addCallback def succeeded(result): winner.callback(result) @eachAttempt.addErrback def failed(reason): failures.append(reason) checkDone() iterateEndpoint.clock = self._reactor iterateEndpoint.start(self._attemptDelay) @winner.addBoth def cancelRemainingPending(result): checkDone.completed = True for remaining in pending[:]: remaining.cancel() if iterateEndpoint.running: iterateEndpoint.stop() return result return winner return d def _fallbackNameResolution(self, host, port): """ Resolve the hostname string into a tuple containing the host address. This is method is only used when the reactor does not provide L{IReactorPluggableNameResolver}. @param host: A unicode hostname to resolve. @param port: The port to include in the resolution. @return: A L{Deferred} that fires with L{_getaddrinfo}'s return value. """ return self._deferToThread(self._getaddrinfo, host, port, 0, socket.SOCK_STREAM) @implementer(interfaces.IStreamServerEndpoint) class SSL4ServerEndpoint: """ SSL secured TCP server endpoint with an IPv4 configuration. """ def __init__(self, reactor, port, sslContextFactory, backlog=50, interface=""): """ @param reactor: An L{IReactorSSL} provider. @param port: The port number used for listening @type port: int @param sslContextFactory: An instance of L{interfaces.IOpenSSLContextFactory}. @param backlog: Size of the listen queue @type backlog: int @param interface: The hostname to bind to, defaults to '' (all) @type interface: str """ self._reactor = reactor self._port = port self._sslContextFactory = sslContextFactory self._backlog = backlog self._interface = interface def listen(self, protocolFactory): """ Implement L{IStreamServerEndpoint.listen} to listen for SSL on a TCP socket. """ return defer.execute( self._reactor.listenSSL, self._port, protocolFactory, contextFactory=self._sslContextFactory, backlog=self._backlog, interface=self._interface, ) @implementer(interfaces.IStreamClientEndpoint) class SSL4ClientEndpoint: """ SSL secured TCP client endpoint with an IPv4 configuration """ def __init__( self, reactor, host, port, sslContextFactory, timeout=30, bindAddress=None ): """ @param reactor: An L{IReactorSSL} provider. @param host: A hostname, used when connecting @type host: str @param port: The port number, used when connecting @type port: int @param sslContextFactory: SSL Configuration information as an instance of L{interfaces.IOpenSSLContextFactory}. @param timeout: Number of seconds to wait before assuming the connection has failed. @type timeout: int @param bindAddress: A (host, port) tuple of local address to bind to, or None. @type bindAddress: tuple """ self._reactor = reactor self._host = host self._port = port self._sslContextFactory = sslContextFactory self._timeout = timeout self._bindAddress = bindAddress def connect(self, protocolFactory): """ Implement L{IStreamClientEndpoint.connect} to connect with SSL over TCP. """ try: wf = _WrappingFactory(protocolFactory) self._reactor.connectSSL( self._host, self._port, wf, self._sslContextFactory, timeout=self._timeout, bindAddress=self._bindAddress, ) return wf._onConnection except BaseException: return defer.fail() @implementer(interfaces.IStreamServerEndpoint) class UNIXServerEndpoint: """ UnixSocket server endpoint. """ def __init__(self, reactor, address, backlog=50, mode=0o666, wantPID=0): """ @param reactor: An L{IReactorUNIX} provider. @param address: The path to the Unix socket file, used when listening @param backlog: number of connections to allow in backlog. @param mode: mode to set on the unix socket. This parameter is deprecated. Permissions should be set on the directory which contains the UNIX socket. @param wantPID: If True, create a pidfile for the socket. """ self._reactor = reactor self._address = address self._backlog = backlog self._mode = mode self._wantPID = wantPID def listen(self, protocolFactory): """ Implement L{IStreamServerEndpoint.listen} to listen on a UNIX socket. """ return defer.execute( self._reactor.listenUNIX, self._address, protocolFactory, backlog=self._backlog, mode=self._mode, wantPID=self._wantPID, ) @implementer(interfaces.IStreamClientEndpoint) class UNIXClientEndpoint: """ UnixSocket client endpoint. """ def __init__(self, reactor, path, timeout=30, checkPID=0): """ @param reactor: An L{IReactorUNIX} provider. @param path: The path to the Unix socket file, used when connecting @type path: str @param timeout: Number of seconds to wait before assuming the connection has failed. @type timeout: int @param checkPID: If True, check for a pid file to verify that a server is listening. @type checkPID: bool """ self._reactor = reactor self._path = path self._timeout = timeout self._checkPID = checkPID def connect(self, protocolFactory): """ Implement L{IStreamClientEndpoint.connect} to connect via a UNIX Socket """ try: wf = _WrappingFactory(protocolFactory) self._reactor.connectUNIX( self._path, wf, timeout=self._timeout, checkPID=self._checkPID ) return wf._onConnection except BaseException: return defer.fail() @implementer(interfaces.IStreamServerEndpoint) class AdoptedStreamServerEndpoint: """ An endpoint for listening on a file descriptor initialized outside of Twisted. @ivar _used: A C{bool} indicating whether this endpoint has been used to listen with a factory yet. C{True} if so. """ _close = os.close _setNonBlocking = staticmethod(fdesc.setNonBlocking) def __init__(self, reactor, fileno, addressFamily): """ @param reactor: An L{IReactorSocket} provider. @param fileno: An integer file descriptor corresponding to a listening I{SOCK_STREAM} socket. @param addressFamily: The address family of the socket given by C{fileno}. """ self.reactor = reactor self.fileno = fileno self.addressFamily = addressFamily self._used = False def listen(self, factory): """ Implement L{IStreamServerEndpoint.listen} to start listening on, and then close, C{self._fileno}. """ if self._used: return defer.fail(error.AlreadyListened()) self._used = True try: self._setNonBlocking(self.fileno) port = self.reactor.adoptStreamPort( self.fileno, self.addressFamily, factory ) self._close(self.fileno) except BaseException: return defer.fail() return defer.succeed(port) def _parseTCP(factory, port, interface="", backlog=50): """ Internal parser function for L{_parseServer} to convert the string arguments for a TCP(IPv4) stream endpoint into the structured arguments. @param factory: the protocol factory being parsed, or L{None}. (This was a leftover argument from when this code was in C{strports}, and is now mostly None and unused.) @type factory: L{IProtocolFactory} or L{None} @param port: the integer port number to bind @type port: C{str} @param interface: the interface IP to listen on @param backlog: the length of the listen queue @type backlog: C{str} @return: a 2-tuple of (args, kwargs), describing the parameters to L{IReactorTCP.listenTCP} (or, modulo argument 2, the factory, arguments to L{TCP4ServerEndpoint}. """ return (int(port), factory), {"interface": interface, "backlog": int(backlog)} def _parseUNIX(factory, address, mode="666", backlog=50, lockfile=True): """ Internal parser function for L{_parseServer} to convert the string arguments for a UNIX (AF_UNIX/SOCK_STREAM) stream endpoint into the structured arguments. @param factory: the protocol factory being parsed, or L{None}. (This was a leftover argument from when this code was in C{strports}, and is now mostly None and unused.) @type factory: L{IProtocolFactory} or L{None} @param address: the pathname of the unix socket @type address: C{str} @param backlog: the length of the listen queue @type backlog: C{str} @param lockfile: A string '0' or '1', mapping to True and False respectively. See the C{wantPID} argument to C{listenUNIX} @return: a 2-tuple of (args, kwargs), describing the parameters to L{twisted.internet.interfaces.IReactorUNIX.listenUNIX} (or, modulo argument 2, the factory, arguments to L{UNIXServerEndpoint}. """ return ( (address, factory), {"mode": int(mode, 8), "backlog": int(backlog), "wantPID": bool(int(lockfile))}, ) def _parseSSL( factory, port, privateKey="server.pem", certKey=None, sslmethod=None, interface="", backlog=50, extraCertChain=None, dhParameters=None, ): """ Internal parser function for L{_parseServer} to convert the string arguments for an SSL (over TCP/IPv4) stream endpoint into the structured arguments. @param factory: the protocol factory being parsed, or L{None}. (This was a leftover argument from when this code was in C{strports}, and is now mostly None and unused.) @type factory: L{IProtocolFactory} or L{None} @param port: the integer port number to bind @type port: C{str} @param interface: the interface IP to listen on @param backlog: the length of the listen queue @type backlog: C{str} @param privateKey: The file name of a PEM format private key file. @type privateKey: C{str} @param certKey: The file name of a PEM format certificate file. @type certKey: C{str} @param sslmethod: The string name of an SSL method, based on the name of a constant in C{OpenSSL.SSL}. Must be one of: "SSLv23_METHOD", "SSLv2_METHOD", "SSLv3_METHOD", "TLSv1_METHOD". @type sslmethod: C{str} @param extraCertChain: The path of a file containing one or more certificates in PEM format that establish the chain from a root CA to the CA that signed your C{certKey}. @type extraCertChain: L{str} @param dhParameters: The file name of a file containing parameters that are required for Diffie-Hellman key exchange. If this is not specified, the forward secret C{DHE} ciphers aren't available for servers. @type dhParameters: L{str} @return: a 2-tuple of (args, kwargs), describing the parameters to L{IReactorSSL.listenSSL} (or, modulo argument 2, the factory, arguments to L{SSL4ServerEndpoint}. """ from twisted.internet import ssl if certKey is None: certKey = privateKey kw = {} if sslmethod is not None: kw["method"] = getattr(ssl.SSL, sslmethod) certPEM = FilePath(certKey).getContent() keyPEM = FilePath(privateKey).getContent() privateCertificate = ssl.PrivateCertificate.loadPEM(certPEM + b"\n" + keyPEM) if extraCertChain is not None: matches = re.findall( r"(-----BEGIN CERTIFICATE-----\n.+?\n-----END CERTIFICATE-----)", nativeString(FilePath(extraCertChain).getContent()), flags=re.DOTALL, ) chainCertificates = [ ssl.Certificate.loadPEM(chainCertPEM).original for chainCertPEM in matches ] if not chainCertificates: raise ValueError( "Specified chain file '%s' doesn't contain any valid " "certificates in PEM format." % (extraCertChain,) ) else: chainCertificates = None if dhParameters is not None: dhParameters = ssl.DiffieHellmanParameters.fromFile( FilePath(dhParameters), ) cf = ssl.CertificateOptions( privateKey=privateCertificate.privateKey.original, certificate=privateCertificate.original, extraCertChain=chainCertificates, dhParameters=dhParameters, **kw, ) return ((int(port), factory, cf), {"interface": interface, "backlog": int(backlog)}) @implementer(IPlugin, IStreamServerEndpointStringParser) class _StandardIOParser: """ Stream server endpoint string parser for the Standard I/O type. @ivar prefix: See L{IStreamServerEndpointStringParser.prefix}. """ prefix = "stdio" def _parseServer(self, reactor): """ Internal parser function for L{_parseServer} to convert the string arguments into structured arguments for the L{StandardIOEndpoint} @param reactor: Reactor for the endpoint """ return StandardIOEndpoint(reactor) def parseStreamServer(self, reactor, *args, **kwargs): # Redirects to another function (self._parseServer), tricks zope.interface # into believing the interface is correctly implemented. return self._parseServer(reactor) @implementer(IPlugin, IStreamServerEndpointStringParser) class _SystemdParser: """ Stream server endpoint string parser for the I{systemd} endpoint type. @ivar prefix: See L{IStreamServerEndpointStringParser.prefix}. @ivar _sddaemon: A L{ListenFDs} instance used to translate an index into an actual file descriptor. """ _sddaemon = ListenFDs.fromEnvironment() prefix = "systemd" def _parseServer(self, reactor, domain, index): """ Internal parser function for L{_parseServer} to convert the string arguments for a systemd server endpoint into structured arguments for L{AdoptedStreamServerEndpoint}. @param reactor: An L{IReactorSocket} provider. @param domain: The domain (or address family) of the socket inherited from systemd. This is a string like C{"INET"} or C{"UNIX"}, ie the name of an address family from the L{socket} module, without the C{"AF_"} prefix. @type domain: C{str} @param index: An offset into the list of file descriptors inherited from systemd. @type index: C{str} @return: A two-tuple of parsed positional arguments and parsed keyword arguments (a tuple and a dictionary). These can be used to construct an L{AdoptedStreamServerEndpoint}. """ index = int(index) fileno = self._sddaemon.inheritedDescriptors()[index] addressFamily = getattr(socket, "AF_" + domain) return AdoptedStreamServerEndpoint(reactor, fileno, addressFamily) def parseStreamServer(self, reactor, *args, **kwargs): # Delegate to another function with a sane signature. This function has # an insane signature to trick zope.interface into believing the # interface is correctly implemented. return self._parseServer(reactor, *args, **kwargs) @implementer(IPlugin, IStreamServerEndpointStringParser) class _TCP6ServerParser: """ Stream server endpoint string parser for the TCP6ServerEndpoint type. @ivar prefix: See L{IStreamServerEndpointStringParser.prefix}. """ prefix = ( "tcp6" # Used in _parseServer to identify the plugin with the endpoint type ) def _parseServer(self, reactor, port, backlog=50, interface="::"): """ Internal parser function for L{_parseServer} to convert the string arguments into structured arguments for the L{TCP6ServerEndpoint} @param reactor: An L{IReactorTCP} provider. @param port: The port number used for listening @type port: int @param backlog: Size of the listen queue @type backlog: int @param interface: The hostname to bind to @type interface: str """ port = int(port) backlog = int(backlog) return TCP6ServerEndpoint(reactor, port, backlog, interface) def parseStreamServer(self, reactor, *args, **kwargs): # Redirects to another function (self._parseServer), tricks zope.interface # into believing the interface is correctly implemented. return self._parseServer(reactor, *args, **kwargs) _serverParsers = { "tcp": _parseTCP, "unix": _parseUNIX, "ssl": _parseSSL, } _OP, _STRING = range(2) def _tokenize(description): """ Tokenize a strports string and yield each token. @param description: a string as described by L{serverFromString} or L{clientFromString}. @type description: L{str} or L{bytes} @return: an iterable of 2-tuples of (C{_OP} or C{_STRING}, string). Tuples starting with C{_OP} will contain a second element of either ':' (i.e. 'next parameter') or '=' (i.e. 'assign parameter value'). For example, the string 'hello:greeting=world' would result in a generator yielding these values:: _STRING, 'hello' _OP, ':' _STRING, 'greet=ing' _OP, '=' _STRING, 'world' """ empty = _matchingString("", description) colon = _matchingString(":", description) equals = _matchingString("=", description) backslash = _matchingString("\x5c", description) current = empty ops = colon + equals nextOps = {colon: colon + equals, equals: colon} iterdesc = iter(iterbytes(description)) for n in iterdesc: if n in iterbytes(ops): yield _STRING, current yield _OP, n current = empty ops = nextOps[n] elif n == backslash: current += next(iterdesc) else: current += n yield _STRING, current def _parse(description): """ Convert a description string into a list of positional and keyword parameters, using logic vaguely like what Python does. @param description: a string as described by L{serverFromString} or L{clientFromString}. @return: a 2-tuple of C{(args, kwargs)}, where 'args' is a list of all ':'-separated C{str}s not containing an '=' and 'kwargs' is a map of all C{str}s which do contain an '='. For example, the result of C{_parse('a:b:d=1:c')} would be C{(['a', 'b', 'c'], {'d': '1'})}. """ args, kw = [], {} colon = _matchingString(":", description) def add(sofar): if len(sofar) == 1: args.append(sofar[0]) else: kw[nativeString(sofar[0])] = sofar[1] sofar = () for (type, value) in _tokenize(description): if type is _STRING: sofar += (value,) elif value == colon: add(sofar) sofar = () add(sofar) return args, kw # Mappings from description "names" to endpoint constructors. _endpointServerFactories = { "TCP": TCP4ServerEndpoint, "SSL": SSL4ServerEndpoint, "UNIX": UNIXServerEndpoint, } _endpointClientFactories = { "TCP": TCP4ClientEndpoint, "SSL": SSL4ClientEndpoint, "UNIX": UNIXClientEndpoint, } def _parseServer(description, factory): """ Parse a strports description into a 2-tuple of arguments and keyword values. @param description: A description in the format explained by L{serverFromString}. @type description: C{str} @param factory: A 'factory' argument; this is left-over from twisted.application.strports, it's not really used. @type factory: L{IProtocolFactory} or L{None} @return: a 3-tuple of (plugin or name, arguments, keyword arguments) """ args, kw = _parse(description) endpointType = args[0] parser = _serverParsers.get(endpointType) if parser is None: # If the required parser is not found in _server, check if # a plugin exists for the endpointType plugin = _matchPluginToPrefix( getPlugins(IStreamServerEndpointStringParser), endpointType ) return (plugin, args[1:], kw) return (endpointType.upper(),) + parser(factory, *args[1:], **kw) def _matchPluginToPrefix(plugins, endpointType): """ Match plugin to prefix. """ endpointType = endpointType.lower() for plugin in plugins: if _matchingString(plugin.prefix.lower(), endpointType) == endpointType: return plugin raise ValueError(f"Unknown endpoint type: '{endpointType}'") def serverFromString(reactor, description): """ Construct a stream server endpoint from an endpoint description string. The format for server endpoint descriptions is a simple byte string. It is a prefix naming the type of endpoint, then a colon, then the arguments for that endpoint. For example, you can call it like this to create an endpoint that will listen on TCP port 80:: serverFromString(reactor, "tcp:80") Additional arguments may be specified as keywords, separated with colons. For example, you can specify the interface for a TCP server endpoint to bind to like this:: serverFromString(reactor, "tcp:80:interface=127.0.0.1") SSL server endpoints may be specified with the 'ssl' prefix, and the private key and certificate files may be specified by the C{privateKey} and C{certKey} arguments:: serverFromString( reactor, "ssl:443:privateKey=key.pem:certKey=crt.pem") If a private key file name (C{privateKey}) isn't provided, a "server.pem" file is assumed to exist which contains the private key. If the certificate file name (C{certKey}) isn't provided, the private key file is assumed to contain the certificate as well. You may escape colons in arguments with a backslash, which you will need to use if you want to specify a full pathname argument on Windows:: serverFromString(reactor, "ssl:443:privateKey=C\\:/key.pem:certKey=C\\:/cert.pem") finally, the 'unix' prefix may be used to specify a filesystem UNIX socket, optionally with a 'mode' argument to specify the mode of the socket file created by C{listen}:: serverFromString(reactor, "unix:/var/run/finger") serverFromString(reactor, "unix:/var/run/finger:mode=660") This function is also extensible; new endpoint types may be registered as L{IStreamServerEndpointStringParser} plugins. See that interface for more information. @param reactor: The server endpoint will be constructed with this reactor. @param description: The strports description to parse. @type description: L{str} @return: A new endpoint which can be used to listen with the parameters given by C{description}. @rtype: L{IStreamServerEndpoint<twisted.internet.interfaces.IStreamServerEndpoint>} @raise ValueError: when the 'description' string cannot be parsed. @since: 10.2 """ nameOrPlugin, args, kw = _parseServer(description, None) if type(nameOrPlugin) is not str: plugin = nameOrPlugin return plugin.parseStreamServer(reactor, *args, **kw) else: name = nameOrPlugin # Chop out the factory. args = args[:1] + args[2:] return _endpointServerFactories[name](reactor, *args, **kw) def quoteStringArgument(argument): """ Quote an argument to L{serverFromString} and L{clientFromString}. Since arguments are separated with colons and colons are escaped with backslashes, some care is necessary if, for example, you have a pathname, you may be tempted to interpolate into a string like this:: serverFromString(reactor, "ssl:443:privateKey=%s" % (myPathName,)) This may appear to work, but will have portability issues (Windows pathnames, for example). Usually you should just construct the appropriate endpoint type rather than interpolating strings, which in this case would be L{SSL4ServerEndpoint}. There are some use-cases where you may need to generate such a string, though; for example, a tool to manipulate a configuration file which has strports descriptions in it. To be correct in those cases, do this instead:: serverFromString(reactor, "ssl:443:privateKey=%s" % (quoteStringArgument(myPathName),)) @param argument: The part of the endpoint description string you want to pass through. @type argument: C{str} @return: The quoted argument. @rtype: C{str} """ backslash, colon = "\\:" for c in backslash, colon: argument = argument.replace(c, backslash + c) return argument def _parseClientTCP(*args, **kwargs): """ Perform any argument value coercion necessary for TCP client parameters. Valid positional arguments to this function are host and port. Valid keyword arguments to this function are all L{IReactorTCP.connectTCP} arguments. @return: The coerced values as a C{dict}. """ if len(args) == 2: kwargs["port"] = int(args[1]) kwargs["host"] = args[0] elif len(args) == 1: if "host" in kwargs: kwargs["port"] = int(args[0]) else: kwargs["host"] = args[0] try: kwargs["port"] = int(kwargs["port"]) except KeyError: pass try: kwargs["timeout"] = int(kwargs["timeout"]) except KeyError: pass try: kwargs["bindAddress"] = (kwargs["bindAddress"], 0) except KeyError: pass return kwargs def _loadCAsFromDir(directoryPath): """ Load certificate-authority certificate objects in a given directory. @param directoryPath: a L{unicode} or L{bytes} pointing at a directory to load .pem files from, or L{None}. @return: an L{IOpenSSLTrustRoot} provider. """ caCerts = {} for child in directoryPath.children(): if not child.asTextMode().basename().split(".")[-1].lower() == "pem": continue try: data = child.getContent() except OSError: # Permission denied, corrupt disk, we don't care. continue try: theCert = Certificate.loadPEM(data) except SSLError: # Duplicate certificate, invalid certificate, etc. We don't care. pass else: caCerts[theCert.digest()] = theCert return trustRootFromCertificates(caCerts.values()) def _parseTrustRootPath(pathName): """ Parse a string referring to a directory full of certificate authorities into a trust root. @param pathName: path name @type pathName: L{unicode} or L{bytes} or L{None} @return: L{None} or L{IOpenSSLTrustRoot} """ if pathName is None: return None return _loadCAsFromDir(FilePath(pathName)) def _privateCertFromPaths(certificatePath, keyPath): """ Parse a certificate path and key path, either or both of which might be L{None}, into a certificate object. @param certificatePath: the certificate path @type certificatePath: L{bytes} or L{unicode} or L{None} @param keyPath: the private key path @type keyPath: L{bytes} or L{unicode} or L{None} @return: a L{PrivateCertificate} or L{None} """ if certificatePath is None: return None certBytes = FilePath(certificatePath).getContent() if keyPath is None: return PrivateCertificate.loadPEM(certBytes) else: return PrivateCertificate.fromCertificateAndKeyPair( Certificate.loadPEM(certBytes), KeyPair.load(FilePath(keyPath).getContent(), 1), ) def _parseClientSSLOptions(kwargs): """ Parse common arguments for SSL endpoints, creating an L{CertificateOptions} instance. @param kwargs: A dict of keyword arguments to be parsed, potentially containing keys C{certKey}, C{privateKey}, C{caCertsDir}, and C{hostname}. See L{_parseClientSSL}. @type kwargs: L{dict} @return: The remaining arguments, including a new key C{sslContextFactory}. """ hostname = kwargs.pop("hostname", None) clientCertificate = _privateCertFromPaths( kwargs.pop("certKey", None), kwargs.pop("privateKey", None) ) trustRoot = _parseTrustRootPath(kwargs.pop("caCertsDir", None)) if hostname is not None: configuration = optionsForClientTLS( _idnaText(hostname), trustRoot=trustRoot, clientCertificate=clientCertificate, ) else: # _really_ though, you should specify a hostname. if clientCertificate is not None: privateKeyOpenSSL = clientCertificate.privateKey.original certificateOpenSSL = clientCertificate.original else: privateKeyOpenSSL = None certificateOpenSSL = None configuration = CertificateOptions( trustRoot=trustRoot, privateKey=privateKeyOpenSSL, certificate=certificateOpenSSL, ) kwargs["sslContextFactory"] = configuration return kwargs def _parseClientSSL(*args, **kwargs): """ Perform any argument value coercion necessary for SSL client parameters. Valid keyword arguments to this function are all L{IReactorSSL.connectSSL} arguments except for C{contextFactory}. Instead, C{certKey} (the path name of the certificate file) C{privateKey} (the path name of the private key associated with the certificate) are accepted and used to construct a context factory. Valid positional arguments to this function are host and port. @keyword caCertsDir: The one parameter which is not part of L{IReactorSSL.connectSSL}'s signature, this is a path name used to construct a list of certificate authority certificates. The directory will be scanned for files ending in C{.pem}, all of which will be considered valid certificate authorities for this connection. @type caCertsDir: L{str} @keyword hostname: The hostname to use for validating the server's certificate. @type hostname: L{unicode} @return: The coerced values as a L{dict}. """ kwargs = _parseClientTCP(*args, **kwargs) return _parseClientSSLOptions(kwargs) def _parseClientUNIX(*args, **kwargs): """ Perform any argument value coercion necessary for UNIX client parameters. Valid keyword arguments to this function are all L{IReactorUNIX.connectUNIX} keyword arguments except for C{checkPID}. Instead, C{lockfile} is accepted and has the same meaning. Also C{path} is used instead of C{address}. Valid positional arguments to this function are C{path}. @return: The coerced values as a C{dict}. """ if len(args) == 1: kwargs["path"] = args[0] try: kwargs["checkPID"] = bool(int(kwargs.pop("lockfile"))) except KeyError: pass try: kwargs["timeout"] = int(kwargs["timeout"]) except KeyError: pass return kwargs _clientParsers = { "TCP": _parseClientTCP, "SSL": _parseClientSSL, "UNIX": _parseClientUNIX, } def clientFromString(reactor, description): """ Construct a client endpoint from a description string. Client description strings are much like server description strings, although they take all of their arguments as keywords, aside from host and port. You can create a TCP client endpoint with the 'host' and 'port' arguments, like so:: clientFromString(reactor, "tcp:host=www.example.com:port=80") or, without specifying host and port keywords:: clientFromString(reactor, "tcp:www.example.com:80") Or you can specify only one or the other, as in the following 2 examples:: clientFromString(reactor, "tcp:host=www.example.com:80") clientFromString(reactor, "tcp:www.example.com:port=80") or an SSL client endpoint with those arguments, plus the arguments used by the server SSL, for a client certificate:: clientFromString(reactor, "ssl:web.example.com:443:" "privateKey=foo.pem:certKey=foo.pem") to specify your certificate trust roots, you can identify a directory with PEM files in it with the C{caCertsDir} argument:: clientFromString(reactor, "ssl:host=web.example.com:port=443:" "caCertsDir=/etc/ssl/certs") Both TCP and SSL client endpoint description strings can include a 'bindAddress' keyword argument, whose value should be a local IPv4 address. This fixes the client socket to that IP address:: clientFromString(reactor, "tcp:www.example.com:80:" "bindAddress=192.0.2.100") NB: Fixed client ports are not currently supported in TCP or SSL client endpoints. The client socket will always use an ephemeral port assigned by the operating system You can create a UNIX client endpoint with the 'path' argument and optional 'lockfile' and 'timeout' arguments:: clientFromString( reactor, b"unix:path=/var/foo/bar:lockfile=1:timeout=9") or, with the path as a positional argument with or without optional arguments as in the following 2 examples:: clientFromString(reactor, "unix:/var/foo/bar") clientFromString(reactor, "unix:/var/foo/bar:lockfile=1:timeout=9") This function is also extensible; new endpoint types may be registered as L{IStreamClientEndpointStringParserWithReactor} plugins. See that interface for more information. @param reactor: The client endpoint will be constructed with this reactor. @param description: The strports description to parse. @type description: L{str} @return: A new endpoint which can be used to connect with the parameters given by C{description}. @rtype: L{IStreamClientEndpoint<twisted.internet.interfaces.IStreamClientEndpoint>} @since: 10.2 """ args, kwargs = _parse(description) aname = args.pop(0) name = aname.upper() if name not in _clientParsers: plugin = _matchPluginToPrefix( getPlugins(IStreamClientEndpointStringParserWithReactor), name ) return plugin.parseStreamClient(reactor, *args, **kwargs) kwargs = _clientParsers[name](*args, **kwargs) return _endpointClientFactories[name](reactor, **kwargs) def connectProtocol(endpoint, protocol): """ Connect a protocol instance to an endpoint. This allows using a client endpoint without having to create a factory. @param endpoint: A client endpoint to connect to. @param protocol: A protocol instance. @return: The result of calling C{connect} on the endpoint, i.e. a L{Deferred} that will fire with the protocol when connected, or an appropriate error. @since: 13.1 """ class OneShotFactory(Factory): def buildProtocol(self, addr): return protocol return endpoint.connect(OneShotFactory()) @implementer(interfaces.IStreamClientEndpoint) class _WrapperEndpoint: """ An endpoint that wraps another endpoint. """ def __init__(self, wrappedEndpoint, wrapperFactory): """ Construct a L{_WrapperEndpoint}. """ self._wrappedEndpoint = wrappedEndpoint self._wrapperFactory = wrapperFactory def connect(self, protocolFactory): """ Connect the given protocol factory and unwrap its result. """ return self._wrappedEndpoint.connect( self._wrapperFactory(protocolFactory) ).addCallback(lambda protocol: protocol.wrappedProtocol) @implementer(interfaces.IStreamServerEndpoint) class _WrapperServerEndpoint: """ A server endpoint that wraps another server endpoint. """ def __init__(self, wrappedEndpoint, wrapperFactory): """ Construct a L{_WrapperServerEndpoint}. """ self._wrappedEndpoint = wrappedEndpoint self._wrapperFactory = wrapperFactory def listen(self, protocolFactory): """ Connect the given protocol factory and unwrap its result. """ return self._wrappedEndpoint.listen(self._wrapperFactory(protocolFactory)) def wrapClientTLS(connectionCreator, wrappedEndpoint): """ Wrap an endpoint which upgrades to TLS as soon as the connection is established. @since: 16.0 @param connectionCreator: The TLS options to use when connecting; see L{twisted.internet.ssl.optionsForClientTLS} for how to construct this. @type connectionCreator: L{twisted.internet.interfaces.IOpenSSLClientConnectionCreator} @param wrappedEndpoint: The endpoint to wrap. @type wrappedEndpoint: An L{IStreamClientEndpoint} provider. @return: an endpoint that provides transport level encryption layered on top of C{wrappedEndpoint} @rtype: L{twisted.internet.interfaces.IStreamClientEndpoint} """ if TLSMemoryBIOFactory is None: raise NotImplementedError( "OpenSSL not available. Try `pip install twisted[tls]`." ) return _WrapperEndpoint( wrappedEndpoint, lambda protocolFactory: TLSMemoryBIOFactory( connectionCreator, True, protocolFactory ), ) def _parseClientTLS( reactor, host, port, timeout=b"30", bindAddress=None, certificate=None, privateKey=None, trustRoots=None, endpoint=None, **kwargs, ): """ Internal method to construct an endpoint from string parameters. @param reactor: The reactor passed to L{clientFromString}. @param host: The hostname to connect to. @type host: L{bytes} or L{unicode} @param port: The port to connect to. @type port: L{bytes} or L{unicode} @param timeout: For each individual connection attempt, the number of seconds to wait before assuming the connection has failed. @type timeout: L{bytes} or L{unicode} @param bindAddress: The address to which to bind outgoing connections. @type bindAddress: L{bytes} or L{unicode} @param certificate: a string representing a filesystem path to a PEM-encoded certificate. @type certificate: L{bytes} or L{unicode} @param privateKey: a string representing a filesystem path to a PEM-encoded certificate. @type privateKey: L{bytes} or L{unicode} @param endpoint: an optional string endpoint description of an endpoint to wrap; if this is passed then C{host} is used only for certificate verification. @type endpoint: L{bytes} or L{unicode} @return: a client TLS endpoint @rtype: L{IStreamClientEndpoint} """ if kwargs: raise TypeError("unrecognized keyword arguments present", list(kwargs.keys())) host = host if isinstance(host, str) else host.decode("utf-8") bindAddress = ( bindAddress if isinstance(bindAddress, str) or bindAddress is None else bindAddress.decode("utf-8") ) port = int(port) timeout = int(timeout) return wrapClientTLS( optionsForClientTLS( host, trustRoot=_parseTrustRootPath(trustRoots), clientCertificate=_privateCertFromPaths(certificate, privateKey), ), clientFromString(reactor, endpoint) if endpoint is not None else HostnameEndpoint(reactor, _idnaBytes(host), port, timeout, bindAddress), ) @implementer(IPlugin, IStreamClientEndpointStringParserWithReactor) class _TLSClientEndpointParser: """ Stream client endpoint string parser for L{wrapClientTLS} with L{HostnameEndpoint}. @ivar prefix: See L{IStreamClientEndpointStringParserWithReactor.prefix}. """ prefix = "tls" @staticmethod def parseStreamClient(reactor, *args, **kwargs): """ Redirects to another function L{_parseClientTLS}; tricks zope.interface into believing the interface is correctly implemented, since the signature is (C{reactor}, C{*args}, C{**kwargs}). See L{_parseClientTLS} for the specific signature description for this endpoint parser. @param reactor: The reactor passed to L{clientFromString}. @param args: The positional arguments in the endpoint description. @type args: L{tuple} @param kwargs: The named arguments in the endpoint description. @type kwargs: L{dict} @return: a client TLS endpoint @rtype: L{IStreamClientEndpoint} """ return _parseClientTLS(reactor, *args, **kwargs) PK Mb�Zi���o$ o$ $ internet/test/test_asyncioreactor.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.internet.asyncioreactor}. """ import gc import sys from asyncio import ( DefaultEventLoopPolicy, Future, SelectorEventLoop, set_event_loop, set_event_loop_policy, ) from unittest import skipIf from twisted.internet.asyncioreactor import AsyncioSelectorReactor from twisted.python.runtime import platform from twisted.trial.unittest import SynchronousTestCase from .reactormixins import ReactorBuilder hasWindowsProactorEventLoopPolicy = False hasWindowsSelectorEventLoopPolicy = False try: if sys.platform.startswith("win32"): from asyncio import ( WindowsProactorEventLoopPolicy, WindowsSelectorEventLoopPolicy, ) hasWindowsProactorEventLoopPolicy = True hasWindowsSelectorEventLoopPolicy = True except ImportError: pass class AsyncioSelectorReactorTests(ReactorBuilder, SynchronousTestCase): """ L{AsyncioSelectorReactor} tests. """ _defaultEventLoop = DefaultEventLoopPolicy().new_event_loop() _defaultEventLoopIsSelector = isinstance(_defaultEventLoop, SelectorEventLoop) def assertReactorWorksWithAsyncioFuture(self, reactor): """ Ensure that C{reactor} has an event loop that works properly with L{asyncio.Future}. """ future = Future() result = [] def completed(future): result.append(future.result()) reactor.stop() future.add_done_callback(completed) future.set_result(True) self.assertEqual(result, []) self.runReactor(reactor, timeout=1) self.assertEqual(result, [True]) @skipIf( not _defaultEventLoopIsSelector, "default event loop: {}\nis not of type SelectorEventLoop " "on Python {}.{} ({})".format( type(_defaultEventLoop), sys.version_info.major, sys.version_info.minor, platform.getType(), ), ) def test_defaultSelectorEventLoopFromGlobalPolicy(self): """ L{AsyncioSelectorReactor} wraps the global policy's event loop by default. This ensures that L{asyncio.Future}s and coroutines created by library code that uses L{asyncio.get_event_loop} are bound to the same loop. """ reactor = AsyncioSelectorReactor() self.assertReactorWorksWithAsyncioFuture(reactor) @skipIf( not _defaultEventLoopIsSelector, "default event loop: {}\nis not of type SelectorEventLoop " "on Python {}.{} ({})".format( type(_defaultEventLoop), sys.version_info.major, sys.version_info.minor, platform.getType(), ), ) def test_newSelectorEventLoopFromDefaultEventLoopPolicy(self): """ If we use the L{asyncio.DefaultLoopPolicy} to create a new event loop, and then pass that event loop to a new L{AsyncioSelectorReactor}, this reactor should work properly with L{asyncio.Future}. """ event_loop = DefaultEventLoopPolicy().new_event_loop() reactor = AsyncioSelectorReactor(event_loop) set_event_loop(event_loop) self.assertReactorWorksWithAsyncioFuture(reactor) set_event_loop_policy(None) @skipIf( _defaultEventLoopIsSelector, "default event loop: {}\nis of type SelectorEventLoop " "on Python {}.{} ({})".format( type(_defaultEventLoop), sys.version_info.major, sys.version_info.minor, platform.getType(), ), ) def test_defaultNotASelectorEventLoopFromGlobalPolicy(self): """ On Windows Python 3.5 to 3.7, L{get_event_loop()} returns a L{WindowsSelectorEventLoop} by default. On Windows Python 3.8+, L{get_event_loop()} returns a L{WindowsProactorEventLoop} by default. L{AsyncioSelectorReactor} should raise a L{TypeError} if the default event loop is not a L{WindowsSelectorEventLoop}. """ self.assertRaises(TypeError, AsyncioSelectorReactor) @skipIf( not hasWindowsProactorEventLoopPolicy, "WindowsProactorEventLoop not available" ) def test_WindowsProactorEventLoop(self): """ L{AsyncioSelectorReactor} will raise a L{TypeError} if instantiated with a L{asyncio.WindowsProactorEventLoop} """ event_loop = WindowsProactorEventLoopPolicy().new_event_loop() self.assertRaises(TypeError, AsyncioSelectorReactor, event_loop) @skipIf( not hasWindowsSelectorEventLoopPolicy, "WindowsSelectorEventLoop only on Windows", ) def test_WindowsSelectorEventLoop(self): """ L{WindowsSelectorEventLoop} works with L{AsyncioSelectorReactor} """ event_loop = WindowsSelectorEventLoopPolicy().new_event_loop() reactor = AsyncioSelectorReactor(event_loop) set_event_loop(event_loop) self.assertReactorWorksWithAsyncioFuture(reactor) set_event_loop_policy(None) @skipIf( not hasWindowsProactorEventLoopPolicy, "WindowsProactorEventLoopPolicy only on Windows", ) def test_WindowsProactorEventLoopPolicy(self): """ L{AsyncioSelectorReactor} will raise a L{TypeError} if L{asyncio.WindowsProactorEventLoopPolicy} is default. """ set_event_loop_policy(WindowsProactorEventLoopPolicy()) with self.assertRaises(TypeError): AsyncioSelectorReactor() set_event_loop_policy(None) @skipIf( not hasWindowsSelectorEventLoopPolicy, "WindowsSelectorEventLoopPolicy only on Windows", ) def test_WindowsSelectorEventLoopPolicy(self): """ L{AsyncioSelectorReactor} will work if if L{asyncio.WindowsSelectorEventLoopPolicy} is default. """ set_event_loop_policy(WindowsSelectorEventLoopPolicy()) reactor = AsyncioSelectorReactor() self.assertReactorWorksWithAsyncioFuture(reactor) set_event_loop_policy(None) def test_seconds(self): """L{seconds} should return a plausible epoch time.""" if hasWindowsSelectorEventLoopPolicy: set_event_loop_policy(WindowsSelectorEventLoopPolicy()) reactor = AsyncioSelectorReactor() result = reactor.seconds() # greater than 2020-01-01 self.assertGreater(result, 1577836800) # less than 2120-01-01 self.assertLess(result, 4733510400) if hasWindowsSelectorEventLoopPolicy: set_event_loop_policy(None) def test_delayedCallResetToLater(self): """ L{DelayedCall.reset()} properly reschedules timer to later time """ if hasWindowsSelectorEventLoopPolicy: set_event_loop_policy(WindowsSelectorEventLoopPolicy()) reactor = AsyncioSelectorReactor() timer_called_at = [None] def on_timer(): timer_called_at[0] = reactor.seconds() start_time = reactor.seconds() dc = reactor.callLater(0, on_timer) dc.reset(0.5) reactor.callLater(1, reactor.stop) reactor.run() self.assertIsNotNone(timer_called_at[0]) self.assertGreater(timer_called_at[0] - start_time, 0.4) if hasWindowsSelectorEventLoopPolicy: set_event_loop_policy(None) def test_delayedCallResetToEarlier(self): """ L{DelayedCall.reset()} properly reschedules timer to earlier time """ if hasWindowsSelectorEventLoopPolicy: set_event_loop_policy(WindowsSelectorEventLoopPolicy()) reactor = AsyncioSelectorReactor() timer_called_at = [None] def on_timer(): timer_called_at[0] = reactor.seconds() start_time = reactor.seconds() dc = reactor.callLater(0.5, on_timer) dc.reset(0) reactor.callLater(1, reactor.stop) import io from contextlib import redirect_stderr stderr = io.StringIO() with redirect_stderr(stderr): reactor.run() self.assertEqual(stderr.getvalue(), "") self.assertIsNotNone(timer_called_at[0]) self.assertLess(timer_called_at[0] - start_time, 0.4) if hasWindowsSelectorEventLoopPolicy: set_event_loop_policy(None) def test_noCycleReferencesInCallLater(self): """ L{AsyncioSelectorReactor.callLater()} doesn't leave cyclic references """ if hasWindowsSelectorEventLoopPolicy: set_event_loop_policy(WindowsSelectorEventLoopPolicy()) gc_was_enabled = gc.isenabled() gc.disable() try: objects_before = len(gc.get_objects()) timer_count = 1000 reactor = AsyncioSelectorReactor() for _ in range(timer_count): reactor.callLater(0, lambda: None) reactor.runUntilCurrent() objects_after = len(gc.get_objects()) self.assertLess((objects_after - objects_before) / timer_count, 1) finally: if gc_was_enabled: gc.enable() if hasWindowsSelectorEventLoopPolicy: set_event_loop_policy(None) PK Mb�Z|��' ' internet/test/_posixifaces.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ POSIX implementation of local network interface enumeration. """ import socket import sys from ctypes import ( CDLL, POINTER, Structure, c_char_p, c_int, c_ubyte, c_uint8, c_uint32, c_ushort, c_void_p, cast, pointer, ) from ctypes.util import find_library from socket import AF_INET, AF_INET6, inet_ntop from typing import Any, List, Tuple from twisted.python.compat import nativeString libc = CDLL(find_library("c") or "") if sys.platform.startswith("freebsd") or sys.platform == "darwin": _sockaddrCommon: List[Tuple[str, Any]] = [ ("sin_len", c_uint8), ("sin_family", c_uint8), ] else: _sockaddrCommon: List[Tuple[str, Any]] = [ ("sin_family", c_ushort), ] class in_addr(Structure): _fields_ = [ ("in_addr", c_ubyte * 4), ] class in6_addr(Structure): _fields_ = [ ("in_addr", c_ubyte * 16), ] class sockaddr(Structure): _fields_ = _sockaddrCommon + [ ("sin_port", c_ushort), ] class sockaddr_in(Structure): _fields_ = _sockaddrCommon + [ ("sin_port", c_ushort), ("sin_addr", in_addr), ] class sockaddr_in6(Structure): _fields_ = _sockaddrCommon + [ ("sin_port", c_ushort), ("sin_flowinfo", c_uint32), ("sin_addr", in6_addr), ] class ifaddrs(Structure): pass ifaddrs_p = POINTER(ifaddrs) ifaddrs._fields_ = [ ("ifa_next", ifaddrs_p), ("ifa_name", c_char_p), ("ifa_flags", c_uint32), ("ifa_addr", POINTER(sockaddr)), ("ifa_netmask", POINTER(sockaddr)), ("ifa_dstaddr", POINTER(sockaddr)), ("ifa_data", c_void_p), ] getifaddrs = libc.getifaddrs getifaddrs.argtypes = [POINTER(ifaddrs_p)] getifaddrs.restype = c_int freeifaddrs = libc.freeifaddrs freeifaddrs.argtypes = [ifaddrs_p] def _maybeCleanupScopeIndex(family, packed): """ On FreeBSD, kill the embedded interface indices in link-local scoped addresses. @param family: The address family of the packed address - one of the I{socket.AF_*} constants. @param packed: The packed representation of the address (ie, the bytes of a I{in_addr} field). @type packed: L{bytes} @return: The packed address with any FreeBSD-specific extra bits cleared. @rtype: L{bytes} @see: U{https://twistedmatrix.com/trac/ticket/6843} @see: U{http://www.freebsd.org/doc/en/books/developers-handbook/ipv6.html#ipv6-scope-index} @note: Indications are that the need for this will be gone in FreeBSD >=10. """ if sys.platform.startswith("freebsd") and packed[:2] == b"\xfe\x80": return packed[:2] + b"\x00\x00" + packed[4:] return packed def _interfaces(): """ Call C{getifaddrs(3)} and return a list of tuples of interface name, address family, and human-readable address representing its results. """ ifaddrs = ifaddrs_p() if getifaddrs(pointer(ifaddrs)) < 0: raise OSError() results = [] try: while ifaddrs: if ifaddrs[0].ifa_addr: family = ifaddrs[0].ifa_addr[0].sin_family if family == AF_INET: addr = cast(ifaddrs[0].ifa_addr, POINTER(sockaddr_in)) elif family == AF_INET6: addr = cast(ifaddrs[0].ifa_addr, POINTER(sockaddr_in6)) else: addr = None if addr: packed = bytes(addr[0].sin_addr.in_addr[:]) packed = _maybeCleanupScopeIndex(family, packed) results.append( (ifaddrs[0].ifa_name, family, inet_ntop(family, packed)) ) ifaddrs = ifaddrs[0].ifa_next finally: freeifaddrs(ifaddrs) return results def posixGetLinkLocalIPv6Addresses(): """ Return a list of strings in colon-hex format representing all the link local IPv6 addresses available on the system, as reported by I{getifaddrs(3)}. """ retList = [] for (interface, family, address) in _interfaces(): interface = nativeString(interface) address = nativeString(address) if family == socket.AF_INET6 and address.startswith("fe80:"): retList.append(f"{address}%{interface}") return retList PK Mb�Z� 6�% �% internet/test/test_posixbase.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.internet.posixbase} and supporting code. """ from twisted.internet.defer import Deferred from twisted.internet.posixbase import PosixReactorBase, _Waker from twisted.internet.protocol import ServerFactory from twisted.trial.unittest import TestCase skipSockets = None try: from twisted.internet import unix from twisted.test.test_unix import ClientProto except ImportError: skipSockets = "Platform does not support AF_UNIX sockets" from twisted.internet import reactor from twisted.internet.tcp import Port class TrivialReactor(PosixReactorBase): def __init__(self): self._readers = {} self._writers = {} PosixReactorBase.__init__(self) def addReader(self, reader): self._readers[reader] = True def removeReader(self, reader): del self._readers[reader] def addWriter(self, writer): self._writers[writer] = True def removeWriter(self, writer): del self._writers[writer] class PosixReactorBaseTests(TestCase): """ Tests for L{PosixReactorBase}. """ def _checkWaker(self, reactor): self.assertIsInstance(reactor.waker, _Waker) self.assertIn(reactor.waker, reactor._internalReaders) self.assertIn(reactor.waker, reactor._readers) def test_wakerIsInternalReader(self): """ When L{PosixReactorBase} is instantiated, it creates a waker and adds it to its internal readers set. """ reactor = TrivialReactor() self._checkWaker(reactor) def test_removeAllSkipsInternalReaders(self): """ Any L{IReadDescriptors} in L{PosixReactorBase._internalReaders} are left alone by L{PosixReactorBase._removeAll}. """ reactor = TrivialReactor() extra = object() reactor._internalReaders.add(extra) reactor.addReader(extra) reactor._removeAll(reactor._readers, reactor._writers) self._checkWaker(reactor) self.assertIn(extra, reactor._internalReaders) self.assertIn(extra, reactor._readers) def test_removeAllReturnsRemovedDescriptors(self): """ L{PosixReactorBase._removeAll} returns a list of removed L{IReadDescriptor} and L{IWriteDescriptor} objects. """ reactor = TrivialReactor() reader = object() writer = object() reactor.addReader(reader) reactor.addWriter(writer) removed = reactor._removeAll(reactor._readers, reactor._writers) self.assertEqual(set(removed), {reader, writer}) self.assertNotIn(reader, reactor._readers) self.assertNotIn(writer, reactor._writers) class TCPPortTests(TestCase): """ Tests for L{twisted.internet.tcp.Port}. """ if not isinstance(reactor, PosixReactorBase): skip = "Non-posixbase reactor" def test_connectionLostFailed(self): """ L{Port.stopListening} returns a L{Deferred} which errbacks if L{Port.connectionLost} raises an exception. """ port = Port(12345, ServerFactory()) port.connected = True port.connectionLost = lambda reason: 1 // 0 return self.assertFailure(port.stopListening(), ZeroDivisionError) class TimeoutReportReactor(PosixReactorBase): """ A reactor which is just barely runnable and which cannot monitor any readers or writers, and which fires a L{Deferred} with the timeout passed to its C{doIteration} method as soon as that method is invoked. """ def __init__(self): PosixReactorBase.__init__(self) self.iterationTimeout = Deferred() self.now = 100 def addReader(self, reader): """ Ignore the reader. This is necessary because the waker will be added. However, we won't actually monitor it for any events. """ def removeAll(self): """ There are no readers or writers, so there is nothing to remove. This will be called when the reactor stops, though, so it must be implemented. """ return [] def seconds(self): """ Override the real clock with a deterministic one that can be easily controlled in a unit test. """ return self.now def doIteration(self, timeout): d = self.iterationTimeout if d is not None: self.iterationTimeout = None d.callback(timeout) class IterationTimeoutTests(TestCase): """ Tests for the timeout argument L{PosixReactorBase.run} calls L{PosixReactorBase.doIteration} with in the presence of various delayed calls. """ def _checkIterationTimeout(self, reactor): timeout = [] reactor.iterationTimeout.addCallback(timeout.append) reactor.iterationTimeout.addCallback(lambda ignored: reactor.stop()) reactor.run() return timeout[0] def test_noCalls(self): """ If there are no delayed calls, C{doIteration} is called with a timeout of L{None}. """ reactor = TimeoutReportReactor() timeout = self._checkIterationTimeout(reactor) self.assertIsNone(timeout) def test_delayedCall(self): """ If there is a delayed call, C{doIteration} is called with a timeout which is the difference between the current time and the time at which that call is to run. """ reactor = TimeoutReportReactor() reactor.callLater(100, lambda: None) timeout = self._checkIterationTimeout(reactor) self.assertEqual(timeout, 100) def test_timePasses(self): """ If a delayed call is scheduled and then some time passes, the timeout passed to C{doIteration} is reduced by the amount of time which passed. """ reactor = TimeoutReportReactor() reactor.callLater(100, lambda: None) reactor.now += 25 timeout = self._checkIterationTimeout(reactor) self.assertEqual(timeout, 75) def test_multipleDelayedCalls(self): """ If there are several delayed calls, C{doIteration} is called with a timeout which is the difference between the current time and the time at which the earlier of the two calls is to run. """ reactor = TimeoutReportReactor() reactor.callLater(50, lambda: None) reactor.callLater(10, lambda: None) reactor.callLater(100, lambda: None) timeout = self._checkIterationTimeout(reactor) self.assertEqual(timeout, 10) def test_resetDelayedCall(self): """ If a delayed call is reset, the timeout passed to C{doIteration} is based on the interval between the time when reset is called and the new delay of the call. """ reactor = TimeoutReportReactor() call = reactor.callLater(50, lambda: None) reactor.now += 25 call.reset(15) timeout = self._checkIterationTimeout(reactor) self.assertEqual(timeout, 15) def test_delayDelayedCall(self): """ If a delayed call is re-delayed, the timeout passed to C{doIteration} is based on the remaining time before the call would have been made and the additional amount of time passed to the delay method. """ reactor = TimeoutReportReactor() call = reactor.callLater(50, lambda: None) reactor.now += 10 call.delay(20) timeout = self._checkIterationTimeout(reactor) self.assertEqual(timeout, 60) def test_cancelDelayedCall(self): """ If the only delayed call is canceled, L{None} is the timeout passed to C{doIteration}. """ reactor = TimeoutReportReactor() call = reactor.callLater(50, lambda: None) call.cancel() timeout = self._checkIterationTimeout(reactor) self.assertIsNone(timeout) class ConnectedDatagramPortTests(TestCase): """ Test connected datagram UNIX sockets. """ if skipSockets is not None: skip = skipSockets def test_connectionFailedDoesntCallLoseConnection(self): """ L{ConnectedDatagramPort} does not call the deprecated C{loseConnection} in L{ConnectedDatagramPort.connectionFailed}. """ def loseConnection(): """ Dummy C{loseConnection} method. C{loseConnection} is deprecated and should not get called. """ self.fail("loseConnection is deprecated and should not get called.") port = unix.ConnectedDatagramPort(None, ClientProto()) port.loseConnection = loseConnection port.connectionFailed("goodbye") def test_connectionFailedCallsStopListening(self): """ L{ConnectedDatagramPort} calls L{ConnectedDatagramPort.stopListening} instead of the deprecated C{loseConnection} in L{ConnectedDatagramPort.connectionFailed}. """ self.called = False def stopListening(): """ Dummy C{stopListening} method. """ self.called = True port = unix.ConnectedDatagramPort(None, ClientProto()) port.stopListening = stopListening port.connectionFailed("goodbye") self.assertTrue(self.called) class WakerTests(TestCase): def test_noWakerConstructionWarnings(self): waker = _Waker(reactor=None) warnings = self.flushWarnings() # explicitly close the sockets waker.connectionLost(None) self.assertEqual(len(warnings), 0) PK Mb�Z��� � $ internet/test/test_filedescriptor.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Whitebox tests for L{twisted.internet.abstract.FileDescriptor}. """ from zope.interface.verify import verifyClass from twisted.internet.abstract import FileDescriptor from twisted.internet.interfaces import IPushProducer from twisted.trial.unittest import SynchronousTestCase class MemoryFile(FileDescriptor): """ A L{FileDescriptor} customization which writes to a Python list in memory with certain limitations. @ivar _written: A C{list} of C{bytes} which have been accepted as written. @ivar _freeSpace: A C{int} giving the number of bytes which will be accepted by future writes. """ connected = True def __init__(self): FileDescriptor.__init__(self, reactor=object()) self._written = [] self._freeSpace = 0 def startWriting(self): pass def stopWriting(self): pass def writeSomeData(self, data): """ Copy at most C{self._freeSpace} bytes from C{data} into C{self._written}. @return: A C{int} indicating how many bytes were copied from C{data}. """ acceptLength = min(self._freeSpace, len(data)) if acceptLength: self._freeSpace -= acceptLength self._written.append(data[:acceptLength]) return acceptLength class FileDescriptorTests(SynchronousTestCase): """ Tests for L{FileDescriptor}. """ def test_writeWithUnicodeRaisesException(self): """ L{FileDescriptor.write} doesn't accept unicode data. """ fileDescriptor = FileDescriptor(reactor=object()) self.assertRaises(TypeError, fileDescriptor.write, "foo") def test_writeSequenceWithUnicodeRaisesException(self): """ L{FileDescriptor.writeSequence} doesn't accept unicode data. """ fileDescriptor = FileDescriptor(reactor=object()) self.assertRaises( TypeError, fileDescriptor.writeSequence, [b"foo", "bar", b"baz"] ) def test_implementInterfaceIPushProducer(self): """ L{FileDescriptor} should implement L{IPushProducer}. """ self.assertTrue(verifyClass(IPushProducer, FileDescriptor)) class WriteDescriptorTests(SynchronousTestCase): """ Tests for L{FileDescriptor}'s implementation of L{IWriteDescriptor}. """ def test_kernelBufferFull(self): """ When L{FileDescriptor.writeSomeData} returns C{0} to indicate no more data can be written immediately, L{FileDescriptor.doWrite} returns L{None}. """ descriptor = MemoryFile() descriptor.write(b"hello, world") self.assertIsNone(descriptor.doWrite()) PK Mb�Zcu{XH XH internet/test/test_protocol.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.internet.protocol}. """ from io import BytesIO from zope.interface import implementer from zope.interface.verify import verifyObject from twisted.internet.defer import CancelledError from twisted.internet.interfaces import ( IConsumer, ILoggingContext, IProtocol, IProtocolFactory, ) from twisted.internet.protocol import ( ClientCreator, ConsumerToProtocolAdapter, Factory, FileWrapper, Protocol, ProtocolToConsumerAdapter, ) from twisted.logger import LogLevel, globalLogPublisher from twisted.python.failure import Failure from twisted.test.proto_helpers import MemoryReactorClock, StringTransport from twisted.trial.unittest import TestCase class ClientCreatorTests(TestCase): """ Tests for L{twisted.internet.protocol.ClientCreator}. """ def _basicConnectTest(self, check): """ Helper for implementing a test to verify that one of the I{connect} methods of L{ClientCreator} passes the right arguments to the right reactor method. @param check: A function which will be invoked with a reactor and a L{ClientCreator} instance and which should call one of the L{ClientCreator}'s I{connect} methods and assert that all of its arguments except for the factory are passed on as expected to the reactor. The factory should be returned. """ class SomeProtocol(Protocol): pass reactor = MemoryReactorClock() cc = ClientCreator(reactor, SomeProtocol) factory = check(reactor, cc) protocol = factory.buildProtocol(None) self.assertIsInstance(protocol, SomeProtocol) def test_connectTCP(self): """ L{ClientCreator.connectTCP} calls C{reactor.connectTCP} with the host and port information passed to it, and with a factory which will construct the protocol passed to L{ClientCreator.__init__}. """ def check(reactor, cc): cc.connectTCP("example.com", 1234, 4321, ("1.2.3.4", 9876)) host, port, factory, timeout, bindAddress = reactor.tcpClients.pop() self.assertEqual(host, "example.com") self.assertEqual(port, 1234) self.assertEqual(timeout, 4321) self.assertEqual(bindAddress, ("1.2.3.4", 9876)) return factory self._basicConnectTest(check) def test_connectUNIX(self): """ L{ClientCreator.connectUNIX} calls C{reactor.connectUNIX} with the filename passed to it, and with a factory which will construct the protocol passed to L{ClientCreator.__init__}. """ def check(reactor, cc): cc.connectUNIX("/foo/bar", 123, True) address, factory, timeout, checkPID = reactor.unixClients.pop() self.assertEqual(address, "/foo/bar") self.assertEqual(timeout, 123) self.assertTrue(checkPID) return factory self._basicConnectTest(check) def test_connectSSL(self): """ L{ClientCreator.connectSSL} calls C{reactor.connectSSL} with the host, port, and context factory passed to it, and with a factory which will construct the protocol passed to L{ClientCreator.__init__}. """ def check(reactor, cc): expectedContextFactory = object() cc.connectSSL( "example.com", 1234, expectedContextFactory, 4321, ("4.3.2.1", 5678) ) ( host, port, factory, contextFactory, timeout, bindAddress, ) = reactor.sslClients.pop() self.assertEqual(host, "example.com") self.assertEqual(port, 1234) self.assertIs(contextFactory, expectedContextFactory) self.assertEqual(timeout, 4321) self.assertEqual(bindAddress, ("4.3.2.1", 5678)) return factory self._basicConnectTest(check) def _cancelConnectTest(self, connect): """ Helper for implementing a test to verify that cancellation of the L{Deferred} returned by one of L{ClientCreator}'s I{connect} methods is implemented to cancel the underlying connector. @param connect: A function which will be invoked with a L{ClientCreator} instance as an argument and which should call one its I{connect} methods and return the result. @return: A L{Deferred} which fires when the test is complete or fails if there is a problem. """ reactor = MemoryReactorClock() cc = ClientCreator(reactor, Protocol) d = connect(cc) connector = reactor.connectors.pop() self.assertFalse(connector._disconnected) d.cancel() self.assertTrue(connector._disconnected) return self.assertFailure(d, CancelledError) def test_cancelConnectTCP(self): """ The L{Deferred} returned by L{ClientCreator.connectTCP} can be cancelled to abort the connection attempt before it completes. """ def connect(cc): return cc.connectTCP("example.com", 1234) return self._cancelConnectTest(connect) def test_cancelConnectUNIX(self): """ The L{Deferred} returned by L{ClientCreator.connectTCP} can be cancelled to abort the connection attempt before it completes. """ def connect(cc): return cc.connectUNIX("/foo/bar") return self._cancelConnectTest(connect) def test_cancelConnectSSL(self): """ The L{Deferred} returned by L{ClientCreator.connectTCP} can be cancelled to abort the connection attempt before it completes. """ def connect(cc): return cc.connectSSL("example.com", 1234, object()) return self._cancelConnectTest(connect) def _cancelConnectTimeoutTest(self, connect): """ Like L{_cancelConnectTest}, but for the case where the L{Deferred} is cancelled after the connection is set up but before it is fired with the resulting protocol instance. """ reactor = MemoryReactorClock() cc = ClientCreator(reactor, Protocol) d = connect(reactor, cc) connector = reactor.connectors.pop() # Sanity check - there is an outstanding delayed call to fire the # Deferred. self.assertEqual(len(reactor.getDelayedCalls()), 1) # Cancel the Deferred, disconnecting the transport just set up and # cancelling the delayed call. d.cancel() self.assertEqual(reactor.getDelayedCalls(), []) # A real connector implementation is responsible for disconnecting the # transport as well. For our purposes, just check that someone told the # connector to disconnect. self.assertTrue(connector._disconnected) return self.assertFailure(d, CancelledError) def test_cancelConnectTCPTimeout(self): """ L{ClientCreator.connectTCP} inserts a very short delayed call between the time the connection is established and the time the L{Deferred} returned from one of its connect methods actually fires. If the L{Deferred} is cancelled in this interval, the established connection is closed, the timeout is cancelled, and the L{Deferred} fails with L{CancelledError}. """ def connect(reactor, cc): d = cc.connectTCP("example.com", 1234) host, port, factory, timeout, bindAddress = reactor.tcpClients.pop() protocol = factory.buildProtocol(None) transport = StringTransport() protocol.makeConnection(transport) return d return self._cancelConnectTimeoutTest(connect) def test_cancelConnectUNIXTimeout(self): """ L{ClientCreator.connectUNIX} inserts a very short delayed call between the time the connection is established and the time the L{Deferred} returned from one of its connect methods actually fires. If the L{Deferred} is cancelled in this interval, the established connection is closed, the timeout is cancelled, and the L{Deferred} fails with L{CancelledError}. """ def connect(reactor, cc): d = cc.connectUNIX("/foo/bar") address, factory, timeout, bindAddress = reactor.unixClients.pop() protocol = factory.buildProtocol(None) transport = StringTransport() protocol.makeConnection(transport) return d return self._cancelConnectTimeoutTest(connect) def test_cancelConnectSSLTimeout(self): """ L{ClientCreator.connectSSL} inserts a very short delayed call between the time the connection is established and the time the L{Deferred} returned from one of its connect methods actually fires. If the L{Deferred} is cancelled in this interval, the established connection is closed, the timeout is cancelled, and the L{Deferred} fails with L{CancelledError}. """ def connect(reactor, cc): d = cc.connectSSL("example.com", 1234, object()) ( host, port, factory, contextFactory, timeout, bindADdress, ) = reactor.sslClients.pop() protocol = factory.buildProtocol(None) transport = StringTransport() protocol.makeConnection(transport) return d return self._cancelConnectTimeoutTest(connect) def _cancelConnectFailedTimeoutTest(self, connect): """ Like L{_cancelConnectTest}, but for the case where the L{Deferred} is cancelled after the connection attempt has failed but before it is fired with the resulting failure. """ reactor = MemoryReactorClock() cc = ClientCreator(reactor, Protocol) d, factory = connect(reactor, cc) connector = reactor.connectors.pop() factory.clientConnectionFailed( connector, Failure(Exception("Simulated failure")) ) # Sanity check - there is an outstanding delayed call to fire the # Deferred. self.assertEqual(len(reactor.getDelayedCalls()), 1) # Cancel the Deferred, cancelling the delayed call. d.cancel() self.assertEqual(reactor.getDelayedCalls(), []) return self.assertFailure(d, CancelledError) def test_cancelConnectTCPFailedTimeout(self): """ Similar to L{test_cancelConnectTCPTimeout}, but for the case where the connection attempt fails. """ def connect(reactor, cc): d = cc.connectTCP("example.com", 1234) host, port, factory, timeout, bindAddress = reactor.tcpClients.pop() return d, factory return self._cancelConnectFailedTimeoutTest(connect) def test_cancelConnectUNIXFailedTimeout(self): """ Similar to L{test_cancelConnectUNIXTimeout}, but for the case where the connection attempt fails. """ def connect(reactor, cc): d = cc.connectUNIX("/foo/bar") address, factory, timeout, bindAddress = reactor.unixClients.pop() return d, factory return self._cancelConnectFailedTimeoutTest(connect) def test_cancelConnectSSLFailedTimeout(self): """ Similar to L{test_cancelConnectSSLTimeout}, but for the case where the connection attempt fails. """ def connect(reactor, cc): d = cc.connectSSL("example.com", 1234, object()) ( host, port, factory, contextFactory, timeout, bindADdress, ) = reactor.sslClients.pop() return d, factory return self._cancelConnectFailedTimeoutTest(connect) class ProtocolTests(TestCase): """ Tests for L{twisted.internet.protocol.Protocol}. """ def test_interfaces(self): """ L{Protocol} instances provide L{IProtocol} and L{ILoggingContext}. """ proto = Protocol() self.assertTrue(verifyObject(IProtocol, proto)) self.assertTrue(verifyObject(ILoggingContext, proto)) def test_logPrefix(self): """ L{Protocol.logPrefix} returns the protocol class's name. """ class SomeThing(Protocol): pass self.assertEqual("SomeThing", SomeThing().logPrefix()) def test_makeConnection(self): """ L{Protocol.makeConnection} sets the given transport on itself, and then calls C{connectionMade}. """ result = [] class SomeProtocol(Protocol): def connectionMade(self): result.append(self.transport) transport = object() protocol = SomeProtocol() protocol.makeConnection(transport) self.assertEqual(result, [transport]) class FactoryTests(TestCase): """ Tests for L{protocol.Factory}. """ def test_interfaces(self): """ L{Factory} instances provide both L{IProtocolFactory} and L{ILoggingContext}. """ factory = Factory() self.assertTrue(verifyObject(IProtocolFactory, factory)) self.assertTrue(verifyObject(ILoggingContext, factory)) def test_logPrefix(self): """ L{Factory.logPrefix} returns the name of the factory class. """ class SomeKindOfFactory(Factory): pass self.assertEqual("SomeKindOfFactory", SomeKindOfFactory().logPrefix()) def test_defaultBuildProtocol(self): """ L{Factory.buildProtocol} by default constructs a protocol by calling its C{protocol} attribute, and attaches the factory to the result. """ class SomeProtocol(Protocol): pass f = Factory() f.protocol = SomeProtocol protocol = f.buildProtocol(None) self.assertIsInstance(protocol, SomeProtocol) self.assertIs(protocol.factory, f) def test_forProtocol(self): """ L{Factory.forProtocol} constructs a Factory, passing along any additional arguments, and sets its C{protocol} attribute to the given Protocol subclass. """ class ArgTakingFactory(Factory): def __init__(self, *args, **kwargs): self.args, self.kwargs = args, kwargs factory = ArgTakingFactory.forProtocol(Protocol, 1, 2, foo=12) self.assertEqual(factory.protocol, Protocol) self.assertEqual(factory.args, (1, 2)) self.assertEqual(factory.kwargs, {"foo": 12}) def test_doStartLoggingStatement(self): """ L{Factory.doStart} logs that it is starting a factory, followed by the L{repr} of the L{Factory} instance that is being started. """ events = [] globalLogPublisher.addObserver(events.append) self.addCleanup(lambda: globalLogPublisher.removeObserver(events.append)) f = Factory() f.doStart() self.assertIs(events[0]["factory"], f) self.assertEqual(events[0]["log_level"], LogLevel.info) self.assertEqual(events[0]["log_format"], "Starting factory {factory!r}") def test_doStopLoggingStatement(self): """ L{Factory.doStop} logs that it is stopping a factory, followed by the L{repr} of the L{Factory} instance that is being stopped. """ events = [] globalLogPublisher.addObserver(events.append) self.addCleanup(lambda: globalLogPublisher.removeObserver(events.append)) class MyFactory(Factory): numPorts = 1 f = MyFactory() f.doStop() self.assertIs(events[0]["factory"], f) self.assertEqual(events[0]["log_level"], LogLevel.info) self.assertEqual(events[0]["log_format"], "Stopping factory {factory!r}") class AdapterTests(TestCase): """ Tests for L{ProtocolToConsumerAdapter} and L{ConsumerToProtocolAdapter}. """ def test_protocolToConsumer(self): """ L{IProtocol} providers can be adapted to L{IConsumer} providers using L{ProtocolToConsumerAdapter}. """ result = [] p = Protocol() p.dataReceived = result.append consumer = IConsumer(p) consumer.write(b"hello") self.assertEqual(result, [b"hello"]) self.assertIsInstance(consumer, ProtocolToConsumerAdapter) def test_consumerToProtocol(self): """ L{IConsumer} providers can be adapted to L{IProtocol} providers using L{ProtocolToConsumerAdapter}. """ result = [] @implementer(IConsumer) class Consumer: def write(self, d): result.append(d) c = Consumer() protocol = IProtocol(c) protocol.dataReceived(b"hello") self.assertEqual(result, [b"hello"]) self.assertIsInstance(protocol, ConsumerToProtocolAdapter) class FileWrapperTests(TestCase): """ L{twisted.internet.protocol.FileWrapper} """ def test_write(self): """ L{twisted.internet.protocol.FileWrapper.write} """ wrapper = FileWrapper(BytesIO()) wrapper.write(b"test1") self.assertEqual(wrapper.file.getvalue(), b"test1") wrapper = FileWrapper(BytesIO()) # BytesIO() cannot accept unicode, so this will # cause an exception to be thrown which will be # handled by FileWrapper.handle_exception(). wrapper.write("stuff") self.assertNotEqual(wrapper.file.getvalue(), "stuff") def test_writeSequence(self): """ L{twisted.internet.protocol.FileWrapper.writeSequence} """ wrapper = FileWrapper(BytesIO()) wrapper.writeSequence([b"test1", b"test2"]) self.assertEqual(wrapper.file.getvalue(), b"test1test2") wrapper = FileWrapper(BytesIO()) # In Python 3, b"".join([u"a", u"b"]) will raise a TypeError self.assertRaises(TypeError, wrapper.writeSequence, ["test3", "test4"]) PK Mb�Z�\*}� }� internet/test/test_tcp.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for implementations of L{IReactorTCP} and the TCP parts of L{IReactorSocket}. """ import errno import gc import io import os import socket from functools import wraps from typing import Callable, ClassVar, List, Optional, Sequence, Type from unittest import skipIf from zope.interface import Interface, implementer from zope.interface.verify import verifyClass, verifyObject import attr from twisted.internet.address import IPv4Address, IPv6Address from twisted.internet.defer import ( Deferred, DeferredList, fail, gatherResults, maybeDeferred, succeed, ) from twisted.internet.endpoints import TCP4ClientEndpoint, TCP4ServerEndpoint from twisted.internet.error import ( ConnectBindError, ConnectionAborted, ConnectionClosed, ConnectionDone, ConnectionLost, ConnectionRefusedError, DNSLookupError, NoProtocol, UserError, ) from twisted.internet.interfaces import ( IConnector, IHalfCloseableProtocol, ILoggingContext, IPullProducer, IPushProducer, IReactorFDSet, IReactorSocket, IReactorTCP, IResolverSimple, ITLSTransport, ) from twisted.internet.protocol import ClientFactory, Protocol, ServerFactory from twisted.internet.tcp import ( Connection, Server, _BuffersLogs, _FileDescriptorReservation, _IFileDescriptorReservation, _NullFileDescriptorReservation, _resolveIPv6, ) from twisted.internet.test.connectionmixins import ( BrokenContextFactory, ConnectableProtocol, ConnectionTestsMixin, EndpointCreator, LogObserverMixin, Stop, StreamClientTestsMixin, findFreePort, runProtocolsWithReactor, ) from twisted.internet.test.reactormixins import ( ReactorBuilder, needsRunningReactor, stopOnError, ) from twisted.logger import Logger from twisted.python import log from twisted.python.failure import Failure from twisted.python.runtime import platform from twisted.test.proto_helpers import MemoryReactor, StringTransport from twisted.test.test_tcp import ( ClientStartStopFactory, ClosingFactory, MyClientFactory, MyServerFactory, ) from twisted.trial.unittest import SkipTest, SynchronousTestCase, TestCase try: from OpenSSL import SSL except ImportError: useSSL = False else: from twisted.internet.ssl import ClientContextFactory useSSL = True s = None try: s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) s.bind(("::1", 0)) except OSError as e: ipv6Skip = True ipv6SkipReason = f"IPv6 not available. {e}" else: ipv6Skip = False ipv6SkipReason = "" if s is not None: s.close() if platform.isWindows(): from twisted.internet.test import _win32ifaces getLinkLocalIPv6Addresses = _win32ifaces.win32GetLinkLocalIPv6Addresses SKIP_EMFILE = True else: try: from twisted.internet.test import _posixifaces except ImportError: getLinkLocalIPv6Addresses = lambda: [] else: getLinkLocalIPv6Addresses = _posixifaces.posixGetLinkLocalIPv6Addresses SKIP_EMFILE = False def getLinkLocalIPv6Address(): """ Find and return a configured link local IPv6 address including a scope identifier using the % separation syntax. If the system has no link local IPv6 addresses, raise L{SkipTest} instead. @raise SkipTest: if no link local address can be found or if the C{netifaces} module is not available. @return: a C{str} giving the address """ addresses = getLinkLocalIPv6Addresses() if addresses: return addresses[0] raise SkipTest("Link local IPv6 address unavailable") def connect(client, destination): """ Connect a socket to the given destination. @param client: A C{socket.socket}. @param destination: A tuple of (host, port). The host is a C{str}, the port a C{int}. If the C{host} is an IPv6 IP, the address is resolved using C{getaddrinfo} and the first version found is used. """ (host, port) = destination if "%" in host or ":" in host: address = socket.getaddrinfo(host, port)[0][4] else: address = (host, port) client.connect(address) class FakeSocket: """ A fake for L{socket.socket} objects. @ivar data: A C{str} giving the data which will be returned from L{FakeSocket.recv}. @ivar sendBuffer: A C{list} of the objects passed to L{FakeSocket.send}. """ def __init__(self, data): self.data = data self.sendBuffer = [] def setblocking(self, blocking): self.blocking = blocking def recv(self, size): return self.data def send(self, bytes): """ I{Send} all of C{bytes} by accumulating it into C{self.sendBuffer}. @return: The length of C{bytes}, indicating all the data has been accepted. """ self.sendBuffer.append(bytes) return len(bytes) def shutdown(self, how): """ Shutdown is not implemented. The method is provided since real sockets have it and some code expects it. No behavior of L{FakeSocket} is affected by a call to it. """ def close(self): """ Close is not implemented. The method is provided since real sockets have it and some code expects it. No behavior of L{FakeSocket} is affected by a call to it. """ def setsockopt(self, *args): """ Setsockopt is not implemented. The method is provided since real sockets have it and some code expects it. No behavior of L{FakeSocket} is affected by a call to it. """ def fileno(self): """ Return a fake file descriptor. If actually used, this will have no connection to this L{FakeSocket} and will probably cause surprising results. """ return 1 class FakeSocketTests(TestCase): """ Test that the FakeSocket can be used by the doRead method of L{Connection} """ def test_blocking(self): skt = FakeSocket(b"someData") skt.setblocking(0) self.assertEqual(skt.blocking, 0) def test_recv(self): skt = FakeSocket(b"someData") self.assertEqual(skt.recv(10), b"someData") def test_send(self): """ L{FakeSocket.send} accepts the entire string passed to it, adds it to its send buffer, and returns its length. """ skt = FakeSocket(b"") count = skt.send(b"foo") self.assertEqual(count, 3) self.assertEqual(skt.sendBuffer, [b"foo"]) class FakeProtocol(Protocol): """ An L{IProtocol} that returns a value from its dataReceived method. """ def dataReceived(self, data): """ Return something other than L{None} to trigger a deprecation warning for that behavior. """ return () @implementer(IReactorFDSet) class _FakeFDSetReactor: """ An in-memory implementation of L{IReactorFDSet}, which records the current sets of active L{IReadDescriptor} and L{IWriteDescriptor}s. @ivar _readers: The set of L{IReadDescriptor}s active on this L{_FakeFDSetReactor} @type _readers: L{set} @ivar _writers: The set of L{IWriteDescriptor}s active on this L{_FakeFDSetReactor} @ivar _writers: L{set} """ def __init__(self): self._readers = set() self._writers = set() def addReader(self, reader): self._readers.add(reader) def removeReader(self, reader): if reader in self._readers: self._readers.remove(reader) def addWriter(self, writer): self._writers.add(writer) def removeWriter(self, writer): if writer in self._writers: self._writers.remove(writer) def removeAll(self): result = self.getReaders() + self.getWriters() self.__init__() return result def getReaders(self): return list(self._readers) def getWriters(self): return list(self._writers) verifyClass(IReactorFDSet, _FakeFDSetReactor) class TCPServerTests(TestCase): """ Whitebox tests for L{twisted.internet.tcp.Server}. """ def setUp(self): self.reactor = _FakeFDSetReactor() class FakePort: _realPortNumber = 3 self.skt = FakeSocket(b"") self.protocol = Protocol() self.server = Server( self.skt, self.protocol, ("", 0), FakePort(), None, self.reactor ) def test_writeAfterDisconnect(self): """ L{Server.write} discards bytes passed to it if called after it has lost its connection. """ self.server.connectionLost(Failure(Exception("Simulated lost connection"))) self.server.write(b"hello world") self.assertEqual(self.skt.sendBuffer, []) def test_writeAfterDisconnectAfterTLS(self): """ L{Server.write} discards bytes passed to it if called after it has lost its connection when the connection had started TLS. """ self.server.TLS = True self.test_writeAfterDisconnect() def test_writeSequenceAfterDisconnect(self): """ L{Server.writeSequence} discards bytes passed to it if called after it has lost its connection. """ self.server.connectionLost(Failure(Exception("Simulated lost connection"))) self.server.writeSequence([b"hello world"]) self.assertEqual(self.skt.sendBuffer, []) def test_writeSequenceAfterDisconnectAfterTLS(self): """ L{Server.writeSequence} discards bytes passed to it if called after it has lost its connection when the connection had started TLS. """ self.server.TLS = True self.test_writeSequenceAfterDisconnect() class TCPConnectionTests(TestCase): """ Whitebox tests for L{twisted.internet.tcp.Connection}. """ def test_doReadWarningIsRaised(self): """ When an L{IProtocol} implementation that returns a value from its C{dataReceived} method, a deprecated warning is emitted. """ skt = FakeSocket(b"someData") protocol = FakeProtocol() conn = Connection(skt, protocol) conn.doRead() warnings = self.flushWarnings([FakeProtocol.dataReceived]) self.assertEqual(warnings[0]["category"], DeprecationWarning) self.assertEqual( warnings[0]["message"], "Returning a value other than None from " "twisted.internet.test.test_tcp.FakeProtocol.dataReceived " "is deprecated since Twisted 11.0.0.", ) self.assertEqual(len(warnings), 1) def test_noTLSBeforeStartTLS(self): """ The C{TLS} attribute of a L{Connection} instance is C{False} before L{Connection.startTLS} is called. """ skt = FakeSocket(b"") protocol = FakeProtocol() conn = Connection(skt, protocol) self.assertFalse(conn.TLS) @skipIf(not useSSL, "No SSL support available") def test_tlsAfterStartTLS(self): """ The C{TLS} attribute of a L{Connection} instance is C{True} after L{Connection.startTLS} is called. """ skt = FakeSocket(b"") protocol = FakeProtocol() conn = Connection(skt, protocol, reactor=_FakeFDSetReactor()) conn._tlsClientDefault = True conn.startTLS(ClientContextFactory(), True) self.assertTrue(conn.TLS) class TCPCreator(EndpointCreator): """ Create IPv4 TCP endpoints for L{runProtocolsWithReactor}-based tests. """ interface = "127.0.0.1" def server(self, reactor): """ Create a server-side TCP endpoint. """ return TCP4ServerEndpoint(reactor, 0, interface=self.interface) def client(self, reactor, serverAddress): """ Create a client end point that will connect to the given address. @type serverAddress: L{IPv4Address} """ return TCP4ClientEndpoint(reactor, self.interface, serverAddress.port) class TCP6Creator(TCPCreator): """ Create IPv6 TCP endpoints for C{ReactorBuilder.runProtocolsWithReactor}-based tests. The endpoint types in question here are still the TCP4 variety, since these simply pass through IPv6 address literals to the reactor, and we are only testing address literals, not name resolution (as name resolution has not yet been implemented). See http://twistedmatrix.com/trac/ticket/4470 for more specific information about new endpoint classes. The naming is slightly misleading, but presumably if you're passing an IPv6 literal, you know what you're asking for. """ def __init__(self): self.interface = getLinkLocalIPv6Address() @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): """ Return the address mapped to C{name} if it exists, or raise a C{DNSLookupError}. @param name: The name to resolve. @param timeout: The lookup timeout, ignore here. """ try: return succeed(self.names[name]) except KeyError: return fail(DNSLookupError("FakeResolver couldn't find " + name)) class TCPClientTestsBase(ReactorBuilder, ConnectionTestsMixin, StreamClientTestsMixin): """ Base class for builders defining tests related to L{IReactorTCP.connectTCP}. Classes which uses this in must provide all of the documented instance variables in order to specify how the test works. These are documented as instance variables rather than declared as methods due to some peculiar inheritance ordering concerns, but they are effectively abstract methods. @ivar endpoints: A client/server endpoint creator appropriate to the address family being tested. @type endpoints: L{twisted.internet.test.connectionmixins.EndpointCreator} @ivar interface: An IP address literal to locally bind a socket to as well as to connect to. This can be any valid interface for the local host. @type interface: C{str} @ivar port: An unused local listening port to listen on and connect to. This will be used in conjunction with the C{interface}. (Depending on what they're testing, some tests will locate their own port with L{findFreePort} instead.) @type port: C{int} @ivar family: an address family constant, such as L{socket.AF_INET}, L{socket.AF_INET6}, or L{socket.AF_UNIX}, which indicates the address family of the transport type under test. @type family: C{int} @ivar addressClass: the L{twisted.internet.interfaces.IAddress} implementor associated with the transport type under test. Must also be a 3-argument callable which produces an instance of same. @type addressClass: C{type} @ivar fakeDomainName: A fake domain name to use, to simulate hostname resolution and to distinguish between hostnames and IP addresses where necessary. @type fakeDomainName: C{str} """ requiredInterfaces = (IReactorTCP,) _port = None @property def port(self): """ Return the port number to connect to, using C{self._port} set up by C{listen} if available. @return: The port number to connect to. @rtype: C{int} """ if self._port is not None: return self._port.getHost().port return findFreePort(self.interface, self.family)[1] @property def interface(self): """ Return the interface attribute from the endpoints object. """ return self.endpoints.interface def listen(self, reactor, factory): """ Start a TCP server with the given C{factory}. @param reactor: The reactor to create the TCP port in. @param factory: The server factory. @return: A TCP port instance. """ self._port = reactor.listenTCP(0, factory, interface=self.interface) return self._port def connect(self, reactor, factory): """ Start a TCP client with the given C{factory}. @param reactor: The reactor to create the connection in. @param factory: The client factory. @return: A TCP connector instance. """ return reactor.connectTCP(self.interface, self.port, factory) def test_buildProtocolReturnsNone(self): """ When the factory's C{buildProtocol} returns L{None} the connection is gracefully closed. """ connectionLost = Deferred() reactor = self.buildReactor() serverFactory = MyServerFactory() serverFactory.protocolConnectionLost = connectionLost # Make sure the test ends quickly. stopOnError(self, reactor) class NoneFactory(ServerFactory): def buildProtocol(self, address): return None listening = self.endpoints.server(reactor).listen(serverFactory) def listened(port): clientFactory = NoneFactory() endpoint = self.endpoints.client(reactor, port.getHost()) return endpoint.connect(clientFactory) connecting = listening.addCallback(listened) def connectSucceeded(protocol): self.fail( "Stream client endpoint connect succeeded with %r, " "should have failed with NoProtocol." % (protocol,) ) def connectFailed(reason): reason.trap(NoProtocol) connecting.addCallbacks(connectSucceeded, connectFailed) def connected(ignored): # Now that the connection attempt has failed continue waiting for # the server-side connection to be lost. This is the behavior this # test is primarily concerned with. return connectionLost disconnecting = connecting.addCallback(connected) # Make sure any errors that happen in that process get logged quickly. disconnecting.addErrback(log.err) def disconnected(ignored): # The Deferred has to succeed at this point (because log.err always # returns None). If an error got logged it will fail the test. # Stop the reactor now so the test can complete one way or the # other now. reactor.stop() disconnecting.addCallback(disconnected) self.runReactor(reactor) def test_addresses(self): """ A client's transport's C{getHost} and C{getPeer} return L{IPv4Address} instances which have the dotted-quad string form of the resolved address of the local and remote endpoints of the connection respectively as their C{host} attribute, not the hostname originally passed in to L{connectTCP<twisted.internet.interfaces.IReactorTCP.connectTCP>}, if a hostname was used. """ host, ignored = findFreePort(self.interface, self.family)[:2] reactor = self.buildReactor() fakeDomain = self.fakeDomainName reactor.installResolver(FakeResolver({fakeDomain: self.interface})) server = reactor.listenTCP( 0, ServerFactory.forProtocol(Protocol), interface=host ) serverAddress = server.getHost() transportData = {"host": None, "peer": None, "instance": None} class CheckAddress(Protocol): def makeConnection(self, transport): transportData["host"] = transport.getHost() transportData["peer"] = transport.getPeer() transportData["instance"] = transport reactor.stop() clientFactory = Stop(reactor) clientFactory.protocol = CheckAddress def connectMe(): while True: port = findFreePort(self.interface, self.family) bindAddress = (self.interface, port[1]) log.msg(f"Connect attempt with bindAddress {bindAddress}") try: reactor.connectTCP( fakeDomain, server.getHost().port, clientFactory, bindAddress=bindAddress, ) except ConnectBindError: continue else: clientFactory.boundPort = port[1] break needsRunningReactor(reactor, connectMe) self.runReactor(reactor) if clientFactory.failReason: self.fail(clientFactory.failReason.getTraceback()) transportRepr = "<{} to {} at {:x}>".format( transportData["instance"].__class__, transportData["instance"].addr, id(transportData["instance"]), ) boundPort = [host] + list( socket.getaddrinfo(self.interface, clientFactory.boundPort)[0][-1][1:] ) serverPort = [host] + list( socket.getaddrinfo(self.interface, serverAddress.port)[0][-1][1:] ) self.assertEqual(transportData["host"], self.addressClass("TCP", *boundPort)) self.assertEqual(transportData["peer"], self.addressClass("TCP", *serverPort)) self.assertEqual(repr(transportData["instance"]), transportRepr) def test_badContext(self): """ If the context factory passed to L{ITCPTransport.startTLS} raises an exception from its C{getContext} method, that exception is raised by L{ITCPTransport.startTLS}. """ reactor = self.buildReactor() brokenFactory = BrokenContextFactory() results = [] serverFactory = ServerFactory.forProtocol(Protocol) port = reactor.listenTCP(0, serverFactory, interface=self.interface) endpoint = self.endpoints.client(reactor, port.getHost()) clientFactory = ClientFactory() clientFactory.protocol = Protocol connectDeferred = endpoint.connect(clientFactory) def connected(protocol): if not ITLSTransport.providedBy(protocol.transport): results.append("skip") else: results.append( self.assertRaises( ValueError, protocol.transport.startTLS, brokenFactory ) ) def connectFailed(failure): results.append(failure) def whenRun(): connectDeferred.addCallback(connected) connectDeferred.addErrback(connectFailed) connectDeferred.addBoth(lambda ign: reactor.stop()) needsRunningReactor(reactor, whenRun) self.runReactor(reactor) self.assertEqual(len(results), 1, f"more than one callback result: {results}") if isinstance(results[0], Failure): # self.fail(Failure) results[0].raiseException() if results[0] == "skip": raise SkipTest("Reactor does not support ITLSTransport") self.assertEqual(BrokenContextFactory.message, str(results[0])) class TCP4ClientTestsBuilder(TCPClientTestsBase): """ Builder configured with IPv4 parameters for tests related to L{IReactorTCP.connectTCP}. """ fakeDomainName = "some-fake.domain.example.com" family = socket.AF_INET addressClass = IPv4Address endpoints = TCPCreator() @skipIf(ipv6Skip, ipv6SkipReason) class TCP6ClientTestsBuilder(TCPClientTestsBase): """ Builder configured with IPv6 parameters for tests related to L{IReactorTCP.connectTCP}. """ family = socket.AF_INET6 addressClass = IPv6Address def setUp(self): # Only create this object here, so that it won't be created if tests # are being skipped: self.endpoints = TCP6Creator() # This is used by test_addresses to test the distinction between the # resolved name and the name on the socket itself. All the same # invariants should hold, but giving back an IPv6 address from a # resolver is not something the reactor can handle, so instead, we make # it so that the connect call for the IPv6 address test simply uses an # address literal. self.fakeDomainName = self.endpoints.interface class TCPConnectorTestsBuilder(ReactorBuilder): """ Tests for the L{IConnector} provider returned by L{IReactorTCP.connectTCP}. """ requiredInterfaces = (IReactorTCP,) def test_connectorIdentity(self): """ L{IReactorTCP.connectTCP} returns an object which provides L{IConnector}. The destination of the connector is the address which was passed to C{connectTCP}. The same connector object is passed to the factory's C{startedConnecting} method as to the factory's C{clientConnectionLost} method. """ serverFactory = ClosingFactory() reactor = self.buildReactor() tcpPort = reactor.listenTCP(0, serverFactory, interface=self.interface) serverFactory.port = tcpPort portNumber = tcpPort.getHost().port seenConnectors = [] seenFailures = [] clientFactory = ClientStartStopFactory() clientFactory.clientConnectionLost = lambda connector, reason: ( seenConnectors.append(connector), seenFailures.append(reason), ) clientFactory.startedConnecting = seenConnectors.append connector = reactor.connectTCP(self.interface, portNumber, clientFactory) self.assertTrue(IConnector.providedBy(connector)) dest = connector.getDestination() self.assertEqual(dest.type, "TCP") self.assertEqual(dest.host, self.interface) self.assertEqual(dest.port, portNumber) clientFactory.whenStopped.addBoth(lambda _: reactor.stop()) self.runReactor(reactor) seenFailures[0].trap(ConnectionDone) self.assertEqual(seenConnectors, [connector, connector]) def test_userFail(self): """ Calling L{IConnector.stopConnecting} in C{Factory.startedConnecting} results in C{Factory.clientConnectionFailed} being called with L{error.UserError} as the reason. """ serverFactory = MyServerFactory() reactor = self.buildReactor() tcpPort = reactor.listenTCP(0, serverFactory, interface=self.interface) portNumber = tcpPort.getHost().port fatalErrors = [] def startedConnecting(connector): try: connector.stopConnecting() except Exception: fatalErrors.append(Failure()) reactor.stop() clientFactory = ClientStartStopFactory() clientFactory.startedConnecting = startedConnecting clientFactory.whenStopped.addBoth(lambda _: reactor.stop()) reactor.callWhenRunning( lambda: reactor.connectTCP(self.interface, portNumber, clientFactory) ) self.runReactor(reactor) if fatalErrors: self.fail(fatalErrors[0].getTraceback()) clientFactory.reason.trap(UserError) self.assertEqual(clientFactory.failed, 1) def test_reconnect(self): """ Calling L{IConnector.connect} in C{Factory.clientConnectionLost} causes a new connection attempt to be made. """ serverFactory = ClosingFactory() reactor = self.buildReactor() tcpPort = reactor.listenTCP(0, serverFactory, interface=self.interface) serverFactory.port = tcpPort portNumber = tcpPort.getHost().port clientFactory = MyClientFactory() def clientConnectionLost(connector, reason): connector.connect() clientFactory.clientConnectionLost = clientConnectionLost reactor.connectTCP(self.interface, portNumber, clientFactory) protocolMadeAndClosed = [] def reconnectFailed(ignored): p = clientFactory.protocol protocolMadeAndClosed.append((p.made, p.closed)) reactor.stop() clientFactory.failDeferred.addCallback(reconnectFailed) self.runReactor(reactor) clientFactory.reason.trap(ConnectionRefusedError) self.assertEqual(protocolMadeAndClosed, [(1, 1)]) class TCP4ConnectorTestsBuilder(TCPConnectorTestsBuilder): interface = "127.0.0.1" family = socket.AF_INET addressClass = IPv4Address @skipIf(ipv6Skip, ipv6SkipReason) class TCP6ConnectorTestsBuilder(TCPConnectorTestsBuilder): family = socket.AF_INET6 addressClass = IPv6Address def setUp(self): self.interface = getLinkLocalIPv6Address() def createTestSocket(test, addressFamily, socketType): """ Create a socket for the duration of the given test. @param test: the test to add cleanup to. @param addressFamily: an C{AF_*} constant @param socketType: a C{SOCK_*} constant. @return: a socket object. """ skt = socket.socket(addressFamily, socketType) test.addCleanup(skt.close) return skt class _IExhaustsFileDescriptors(Interface): """ A way to trigger C{EMFILE}. """ def exhaust(): """ Open file descriptors until C{EMFILE} is reached. This can raise any exception except an L{OSError} whose C{errno} is C{EMFILE}. Any exception raised to the caller implies L{release}. """ def release(): """ Release all file descriptors opened by L{exhaust}. """ def count(): """ Return the number of opened file descriptors. @return: The number of opened file descriptors; this will be zero if this instance has not opened any. @rtype: L{int} """ @implementer(_IExhaustsFileDescriptors) @attr.s(auto_attribs=True) class _ExhaustsFileDescriptors: """ A class that triggers C{EMFILE} by creating as many file descriptors as necessary. @ivar fileDescriptorFactory: A factory that creates a new file descriptor. @type fileDescriptorFactory: A L{callable} that accepts no arguments and returns an integral file descriptor, suitable for passing to L{os.close}. """ _log: ClassVar[Logger] = Logger() _fileDescriptorFactory: Callable[[], int] = attr.ib( default=lambda: os.dup(0), repr=False ) _close: Callable[[int], None] = attr.ib(default=os.close, repr=False) _fileDescriptors: List[int] = attr.ib( default=attr.Factory(list), init=False, repr=False ) def exhaust(self): """ Open file descriptors until C{EMFILE} is reached. """ # Force a collection to close dangling files. gc.collect() try: while True: try: fd = self._fileDescriptorFactory() except OSError as e: if e.errno == errno.EMFILE: break raise else: self._fileDescriptors.append(fd) except Exception: self.release() raise else: self._log.info( "EMFILE reached by opening" " {openedFileDescriptors} file descriptors.", openedFileDescriptors=self.count(), ) def release(self): """ Release all file descriptors opened by L{exhaust}. """ while self._fileDescriptors: fd = self._fileDescriptors.pop() try: self._close(fd) except OSError as e: if e.errno == errno.EBADF: continue raise def count(self): """ Return the number of opened file descriptors. @return: The number of opened file descriptors; this will be zero if this instance has not opened any. @rtype: L{int} """ return len(self._fileDescriptors) @skipIf(SKIP_EMFILE, "Reserved EMFILE file descriptor not supported on Windows.") class ExhaustsFileDescriptorsTests(SynchronousTestCase): """ Tests for L{_ExhaustsFileDescriptors}. """ def setUp(self): self.exhauster = _ExhaustsFileDescriptors() # This assumes release succeeds when there are no file # descriptors to close. self.addCleanup(self.exhauster.release) def openAFile(self): """ Attempt to open a file; if successful, the file is immediately closed. """ open(os.devnull).close() def test_providesInterface(self): """ L{_ExhaustsFileDescriptors} instances provide L{_IExhaustsFileDescriptors}. """ verifyObject(_IExhaustsFileDescriptors, self.exhauster) def test_count(self): """ L{_ExhaustsFileDescriptors.count} returns the number of open file descriptors. """ self.assertEqual(self.exhauster.count(), 0) self.exhauster.exhaust() self.assertGreater(self.exhauster.count(), 0) self.exhauster.release() self.assertEqual(self.exhauster.count(), 0) def test_exhaustTriggersEMFILE(self): """ L{_ExhaustsFileDescriptors.exhaust} causes the process to exhaust its available file descriptors. """ self.addCleanup(self.exhauster.release) self.exhauster.exhaust() exception = self.assertRaises(IOError, self.openAFile) self.assertEqual(exception.errno, errno.EMFILE) def test_exhaustRaisesOSError(self): """ An L{OSError} raised within L{_ExhaustsFileDescriptors.exhaust} with an C{errno} other than C{EMFILE} is reraised to the caller. """ def raiseOSError(): raise OSError(errno.EMFILE + 1, "Not EMFILE") exhauster = _ExhaustsFileDescriptors(raiseOSError) self.assertRaises(OSError, exhauster.exhaust) def test_release(self): """ L{_ExhaustsFileDescriptors.release} releases all opened file descriptors. """ self.exhauster.exhaust() self.exhauster.release() # Does not fail with EMFILE self.openAFile() def test_fileDescriptorsReleasedOnFailure(self): """ L{_ExhaustsFileDescriptors.exhaust} closes any opened file descriptors if an exception occurs during its exhaustion loop. """ fileDescriptors = [] def failsAfterThree(): if len(fileDescriptors) == 3: raise ValueError( "test_fileDescriptorsReleasedOnFailure" " fake open exception" ) else: fd = os.dup(0) fileDescriptors.append(fd) return fd exhauster = _ExhaustsFileDescriptors(failsAfterThree) self.addCleanup(exhauster.release) self.assertRaises(ValueError, exhauster.exhaust) self.assertEqual(len(fileDescriptors), 3) self.assertEqual(exhauster.count(), 0) for fd in fileDescriptors: exception = self.assertRaises(OSError, os.fstat, fd) self.assertEqual(exception.errno, errno.EBADF) def test_releaseIgnoresEBADF(self): """ L{_ExhaustsFileDescriptors.release} continues to close opened file descriptors even when closing one fails with C{EBADF}. """ fileDescriptors = [] def recordFileDescriptors(): fd = os.dup(0) fileDescriptors.append(fd) return fd exhauster = _ExhaustsFileDescriptors(recordFileDescriptors) self.addCleanup(exhauster.release) exhauster.exhaust() self.assertGreater(exhauster.count(), 0) os.close(fileDescriptors[0]) exhauster.release() self.assertEqual(exhauster.count(), 0) def test_releaseRaisesOSError(self): """ An L{OSError} raised within L{_ExhaustsFileDescriptors.release} with an C{errno} other than C{EBADF} is reraised to the caller. """ fakeFileDescriptors = [] def opensThree(): if len(fakeFileDescriptors) == 3: raise OSError(errno.EMFILE, "Too many files") fakeFileDescriptors.append(-1) return fakeFileDescriptors[-1] def failingClose(fd): raise OSError(11, "test_releaseRaisesOSError fake OSError") exhauster = _ExhaustsFileDescriptors(opensThree, close=failingClose) self.assertEqual(exhauster.count(), 0) exhauster.exhaust() self.assertGreater(exhauster.count(), 0) self.assertRaises(OSError, exhauster.release) def assertPeerClosedOnEMFILE( testCase, exhauster, reactor, runReactor, listen, connect, ): """ Assert that an L{IListeningPort} immediately closes an accepted peer socket when the number of open file descriptors exceeds the soft resource limit. @param testCase: The test case under which to run this assertion. @type testCase: L{trial.unittest.SynchronousTestCase} @param exhauster: The file descriptor exhauster. @type exhauster: L{_ExhaustsFileDescriptors} @param reactor: The reactor under test. @param runReactor: A callable that will synchronously run the provided reactor. @param listen: A callback to bind to a port. @type listen: A L{callable} that accepts two arguments: the provided C{reactor}; and a L{ServerFactory}. It must return an L{IListeningPort} provider. @param connect: A callback to connect a client to the listening port. @type connect: A L{callable} that accepts three arguments: the provided C{reactor}; the address returned by L{IListeningPort.getHost}; and a L{ClientFactory}. Its return value is ignored. """ testCase.addCleanup(exhauster.release) serverFactory = MyServerFactory() serverConnectionMade = Deferred() serverFactory.protocolConnectionMade = serverConnectionMade serverConnectionCompleted = [False] def stopReactorIfServerAccepted(_): reactor.stop() serverConnectionCompleted[0] = True serverConnectionMade.addCallback(stopReactorIfServerAccepted) port = listen(reactor, serverFactory) listeningHost = port.getHost() clientFactory = MyClientFactory() connect(reactor, listeningHost, clientFactory) reactor.callWhenRunning(exhauster.exhaust) def stopReactorAndCloseFileDescriptors(result): exhauster.release() reactor.stop() return result clientFactory.deferred.addBoth(stopReactorAndCloseFileDescriptors) clientFactory.failDeferred.addBoth(stopReactorAndCloseFileDescriptors) runReactor(reactor) noResult = [] serverConnectionMade.addBoth(noResult.append) testCase.assertFalse(noResult, "Server accepted connection; EMFILE not triggered.") testCase.assertNoResult(clientFactory.failDeferred) testCase.successResultOf(clientFactory.deferred) testCase.assertRaises( ConnectionClosed, clientFactory.lostReason.raiseException, ) @skipIf(SKIP_EMFILE, "Reserved EMFILE file descriptor not supported on Windows.") class AssertPeerClosedOnEMFILETests(SynchronousTestCase): """ Tests for L{assertPeerClosedOnEMFILE}. """ @implementer(_IExhaustsFileDescriptors) class NullExhauster: """ An exhauster that does nothing. """ def exhaust(self): """ See L{_IExhaustsFileDescriptors.exhaust} """ def release(self): """ See L{_IExhaustsFileDescriptors.release} """ def count(self): """ See L{_IExhaustsFileDescriptors.count} """ def setUp(self): self.reactor = MemoryReactor() self.testCase = SynchronousTestCase() def test_nullExhausterProvidesInterface(self): """ L{NullExhauster} instances provide L{_IExhaustsFileDescriptors}. """ verifyObject(_IExhaustsFileDescriptors, self.NullExhauster()) def test_reactorStoppedOnSuccessfulConnection(self): """ If the exhauster fails to trigger C{EMFILE} and a connection reaches the server, the reactor is stopped and the test fails. """ exhauster = self.NullExhauster() serverFactory = [None] def runReactor(reactor): reactor.run() proto = serverFactory[0].buildProtocol( IPv4Address("TCP", "127.0.0.1", 4321) ) proto.makeConnection(StringTransport()) def listen(reactor, factory): port = reactor.listenTCP("127.0.0.1", 1234, factory) factory.doStart() serverFactory[0] = factory return port def connect(reactor, address, factory): reactor.connectTCP("127.0.0.1", 0, factory) exception = self.assertRaises( self.testCase.failureException, assertPeerClosedOnEMFILE, testCase=self.testCase, exhauster=exhauster, reactor=self.reactor, runReactor=runReactor, listen=listen, connect=connect, ) self.assertIn("EMFILE", str(exception)) self.assertFalse(self.reactor.running) class StreamTransportTestsMixin(LogObserverMixin): """ Mixin defining tests which apply to any port/connection based transport. """ def test_startedListeningLogMessage(self): """ When a port starts, a message including a description of the associated factory is logged. """ loggedMessages = self.observe() reactor = self.buildReactor() @implementer(ILoggingContext) class SomeFactory(ServerFactory): def logPrefix(self): return "Crazy Factory" factory = SomeFactory() p = self.getListeningPort(reactor, factory) expectedMessage = self.getExpectedStartListeningLogMessage(p, "Crazy Factory") self.assertEqual((expectedMessage,), loggedMessages[0]["message"]) def test_connectionLostLogMsg(self): """ When a connection is lost, an informative message should be logged (see L{getExpectedConnectionLostLogMsg}): an address identifying the port and the fact that it was closed. """ loggedMessages = [] def logConnectionLostMsg(eventDict): loggedMessages.append(log.textFromEventDict(eventDict)) reactor = self.buildReactor() p = self.getListeningPort(reactor, ServerFactory()) expectedMessage = self.getExpectedConnectionLostLogMsg(p) log.addObserver(logConnectionLostMsg) def stopReactor(ignored): log.removeObserver(logConnectionLostMsg) reactor.stop() def doStopListening(): log.addObserver(logConnectionLostMsg) maybeDeferred(p.stopListening).addCallback(stopReactor) reactor.callWhenRunning(doStopListening) reactor.run() self.assertIn(expectedMessage, loggedMessages) @skipIf(SKIP_EMFILE, "Reserved EMFILE file descriptor not supported on Windows.") def test_closePeerOnEMFILE(self): """ See L{assertPeerClosedOnEMFILE}. """ assertPeerClosedOnEMFILE( testCase=self, exhauster=_ExhaustsFileDescriptors(), reactor=self.buildReactor(), runReactor=self.runReactor, listen=self.getListeningPort, connect=self.connectToListener, ) class ConnectToTCPListenerMixin: """ Provides L{connectToListener} for TCP transports. @ivar LISTENER_HOST: The host on which the port is expected to be listening. This is specific to avoid compatibility issues with Windows, which cannot connect to the wildcard host. @type LISTENER_HOST: L{str} @see: U{http://twistedmatrix.com/trac/ticket/1472} """ LISTENER_HOST = "127.0.0.1" def connectToListener(self, reactor, address, factory): """ Connect to the given listening TCP port. @param reactor: The reactor under test. @type reactor: L{IReactorTCP} @param address: The listening port's address. Only the C{port} component is used; see L{LISTENER_HOST}. @type address: L{IPv4Address} or L{IPv6Address} @param factory: The client factory. @type factory: L{ClientFactory} @return: The connector """ return reactor.connectTCP(self.LISTENER_HOST, address.port, factory) class ListenTCPMixin(ConnectToTCPListenerMixin): """ Mixin which uses L{IReactorTCP.listenTCP} to hand out listening TCP ports. """ def getListeningPort(self, reactor, factory, port=0, interface=""): """ Get a TCP port from a reactor. """ return reactor.listenTCP(port, factory, interface=interface) class SocketTCPMixin(ConnectToTCPListenerMixin): """ Mixin which uses L{IReactorSocket.adoptStreamPort} to hand out listening TCP ports. """ def getListeningPort(self, reactor, factory, port=0, interface=""): """ Get a TCP port from a reactor, wrapping an already-initialized file descriptor. """ if IReactorSocket.providedBy(reactor): if ":" in interface: domain = socket.AF_INET6 address = socket.getaddrinfo(interface, port)[0][4] else: domain = socket.AF_INET address = (interface, port) portSock = socket.socket(domain) portSock.bind(address) portSock.listen(3) portSock.setblocking(False) try: return reactor.adoptStreamPort( portSock.fileno(), portSock.family, factory ) finally: # The socket should still be open; fileno will raise if it is # not. portSock.fileno() # Now clean it up, because the rest of the test does not need # it. portSock.close() else: raise SkipTest("Reactor does not provide IReactorSocket") class TCPPortTestsMixin: """ Tests for L{IReactorTCP.listenTCP} """ requiredInterfaces: Optional[Sequence[Type[Interface]]] = (IReactorTCP,) def getExpectedStartListeningLogMessage(self, port, factory): """ Get the message expected to be logged when a TCP port starts listening. """ return "%s starting on %d" % (factory, port.getHost().port) def getExpectedConnectionLostLogMsg(self, port): """ Get the expected connection lost message for a TCP port. """ return f"(TCP Port {port.getHost().port} Closed)" def test_portGetHostOnIPv4(self): """ When no interface is passed to L{IReactorTCP.listenTCP}, the returned listening port listens on an IPv4 address. """ reactor = self.buildReactor() port = self.getListeningPort(reactor, ServerFactory()) address = port.getHost() self.assertIsInstance(address, IPv4Address) @skipIf(ipv6Skip, ipv6SkipReason) def test_portGetHostOnIPv6(self): """ When listening on an IPv6 address, L{IListeningPort.getHost} returns an L{IPv6Address} with C{host} and C{port} attributes reflecting the address the port is bound to. """ reactor = self.buildReactor() host, portNumber = findFreePort(family=socket.AF_INET6, interface="::1")[:2] port = self.getListeningPort(reactor, ServerFactory(), portNumber, host) address = port.getHost() self.assertIsInstance(address, IPv6Address) self.assertEqual("::1", address.host) self.assertEqual(portNumber, address.port) @skipIf(ipv6Skip, ipv6SkipReason) def test_portGetHostOnIPv6ScopeID(self): """ When a link-local IPv6 address including a scope identifier is passed as the C{interface} argument to L{IReactorTCP.listenTCP}, the resulting L{IListeningPort} reports its address as an L{IPv6Address} with a host value that includes the scope identifier. """ linkLocal = getLinkLocalIPv6Address() reactor = self.buildReactor() port = self.getListeningPort(reactor, ServerFactory(), 0, linkLocal) address = port.getHost() self.assertIsInstance(address, IPv6Address) self.assertEqual(linkLocal, address.host) def _buildProtocolAddressTest(self, client, interface): """ Connect C{client} to a server listening on C{interface} started with L{IReactorTCP.listenTCP} and return the address passed to the factory's C{buildProtocol} method. @param client: A C{SOCK_STREAM} L{socket.socket} created with an address family such that it will be able to connect to a server listening on C{interface}. @param interface: A C{str} giving an address for a server to listen on. This should almost certainly be the loopback address for some address family supported by L{IReactorTCP.listenTCP}. @return: Whatever object, probably an L{IAddress} provider, is passed to a server factory's C{buildProtocol} method when C{client} establishes a connection. """ class ObserveAddress(ServerFactory): def buildProtocol(self, address): reactor.stop() self.observedAddress = address return Protocol() factory = ObserveAddress() reactor = self.buildReactor() port = self.getListeningPort(reactor, factory, 0, interface) client.setblocking(False) try: connect(client, (port.getHost().host, port.getHost().port)) except OSError as e: self.assertIn(e.errno, (errno.EINPROGRESS, errno.EWOULDBLOCK)) self.runReactor(reactor) return factory.observedAddress def test_buildProtocolIPv4Address(self): """ When a connection is accepted over IPv4, an L{IPv4Address} is passed to the factory's C{buildProtocol} method giving the peer's address. """ interface = "127.0.0.1" client = createTestSocket(self, socket.AF_INET, socket.SOCK_STREAM) observedAddress = self._buildProtocolAddressTest(client, interface) self.assertEqual(IPv4Address("TCP", *client.getsockname()), observedAddress) @skipIf(ipv6Skip, ipv6SkipReason) def test_buildProtocolIPv6Address(self): """ When a connection is accepted to an IPv6 address, an L{IPv6Address} is passed to the factory's C{buildProtocol} method giving the peer's address. """ interface = "::1" client = createTestSocket(self, socket.AF_INET6, socket.SOCK_STREAM) observedAddress = self._buildProtocolAddressTest(client, interface) peer = client.getsockname() hostname = socket.getnameinfo(peer, socket.NI_NUMERICHOST)[0] self.assertEqual(IPv6Address("TCP", hostname, peer[1]), observedAddress) @skipIf(ipv6Skip, ipv6SkipReason) def test_buildProtocolIPv6AddressScopeID(self): """ When a connection is accepted to a link-local IPv6 address, an L{IPv6Address} is passed to the factory's C{buildProtocol} method giving the peer's address, including a scope identifier. """ interface = getLinkLocalIPv6Address() client = createTestSocket(self, socket.AF_INET6, socket.SOCK_STREAM) observedAddress = self._buildProtocolAddressTest(client, interface) peer = client.getsockname() hostname = socket.getnameinfo(peer, socket.NI_NUMERICHOST)[0] self.assertEqual(IPv6Address("TCP", hostname, *peer[1:]), observedAddress) def _serverGetConnectionAddressTest(self, client, interface, which): """ Connect C{client} to a server listening on C{interface} started with L{IReactorTCP.listenTCP} and return the address returned by one of the server transport's address lookup methods, C{getHost} or C{getPeer}. @param client: A C{SOCK_STREAM} L{socket.socket} created with an address family such that it will be able to connect to a server listening on C{interface}. @param interface: A C{str} giving an address for a server to listen on. This should almost certainly be the loopback address for some address family supported by L{IReactorTCP.listenTCP}. @param which: A C{str} equal to either C{"getHost"} or C{"getPeer"} determining which address will be returned. @return: Whatever object, probably an L{IAddress} provider, is returned from the method indicated by C{which}. """ class ObserveAddress(Protocol): def makeConnection(self, transport): reactor.stop() self.factory.address = getattr(transport, which)() reactor = self.buildReactor() factory = ServerFactory() factory.protocol = ObserveAddress port = self.getListeningPort(reactor, factory, 0, interface) client.setblocking(False) try: connect(client, (port.getHost().host, port.getHost().port)) except OSError as e: self.assertIn(e.errno, (errno.EINPROGRESS, errno.EWOULDBLOCK)) self.runReactor(reactor) return factory.address def test_serverGetHostOnIPv4(self): """ When a connection is accepted over IPv4, the server L{ITransport.getHost} method returns an L{IPv4Address} giving the address on which the server accepted the connection. """ interface = "127.0.0.1" client = createTestSocket(self, socket.AF_INET, socket.SOCK_STREAM) hostAddress = self._serverGetConnectionAddressTest(client, interface, "getHost") self.assertEqual(IPv4Address("TCP", *client.getpeername()), hostAddress) @skipIf(ipv6Skip, ipv6SkipReason) def test_serverGetHostOnIPv6(self): """ When a connection is accepted over IPv6, the server L{ITransport.getHost} method returns an L{IPv6Address} giving the address on which the server accepted the connection. """ interface = "::1" client = createTestSocket(self, socket.AF_INET6, socket.SOCK_STREAM) hostAddress = self._serverGetConnectionAddressTest(client, interface, "getHost") peer = client.getpeername() hostname = socket.getnameinfo(peer, socket.NI_NUMERICHOST)[0] self.assertEqual(IPv6Address("TCP", hostname, *peer[1:]), hostAddress) @skipIf(ipv6Skip, ipv6SkipReason) def test_serverGetHostOnIPv6ScopeID(self): """ When a connection is accepted over IPv6, the server L{ITransport.getHost} method returns an L{IPv6Address} giving the address on which the server accepted the connection, including the scope identifier. """ interface = getLinkLocalIPv6Address() client = createTestSocket(self, socket.AF_INET6, socket.SOCK_STREAM) hostAddress = self._serverGetConnectionAddressTest(client, interface, "getHost") peer = client.getpeername() hostname = socket.getnameinfo(peer, socket.NI_NUMERICHOST)[0] self.assertEqual(IPv6Address("TCP", hostname, *peer[1:]), hostAddress) def test_serverGetPeerOnIPv4(self): """ When a connection is accepted over IPv4, the server L{ITransport.getPeer} method returns an L{IPv4Address} giving the address of the remote end of the connection. """ interface = "127.0.0.1" client = createTestSocket(self, socket.AF_INET, socket.SOCK_STREAM) peerAddress = self._serverGetConnectionAddressTest(client, interface, "getPeer") self.assertEqual(IPv4Address("TCP", *client.getsockname()), peerAddress) @skipIf(ipv6Skip, ipv6SkipReason) def test_serverGetPeerOnIPv6(self): """ When a connection is accepted over IPv6, the server L{ITransport.getPeer} method returns an L{IPv6Address} giving the address on the remote end of the connection. """ interface = "::1" client = createTestSocket(self, socket.AF_INET6, socket.SOCK_STREAM) peerAddress = self._serverGetConnectionAddressTest(client, interface, "getPeer") peer = client.getsockname() hostname = socket.getnameinfo(peer, socket.NI_NUMERICHOST)[0] self.assertEqual(IPv6Address("TCP", hostname, *peer[1:]), peerAddress) @skipIf(ipv6Skip, ipv6SkipReason) def test_serverGetPeerOnIPv6ScopeID(self): """ When a connection is accepted over IPv6, the server L{ITransport.getPeer} method returns an L{IPv6Address} giving the address on the remote end of the connection, including the scope identifier. """ interface = getLinkLocalIPv6Address() client = createTestSocket(self, socket.AF_INET6, socket.SOCK_STREAM) peerAddress = self._serverGetConnectionAddressTest(client, interface, "getPeer") peer = client.getsockname() hostname = socket.getnameinfo(peer, socket.NI_NUMERICHOST)[0] self.assertEqual(IPv6Address("TCP", hostname, *peer[1:]), peerAddress) class TCPPortTestsBuilder( ReactorBuilder, ListenTCPMixin, TCPPortTestsMixin, StreamTransportTestsMixin, ): pass class TCPFDPortTestsBuilder( ReactorBuilder, SocketTCPMixin, TCPPortTestsMixin, StreamTransportTestsMixin, ): pass class StopStartReadingProtocol(Protocol): """ Protocol that pauses and resumes the transport a few times """ def connectionMade(self): self.data = b"" self.pauseResumeProducing(3) def pauseResumeProducing(self, counter): """ Toggle transport read state, then count down. """ self.transport.pauseProducing() self.transport.resumeProducing() if counter: self.factory.reactor.callLater(0, self.pauseResumeProducing, counter - 1) else: self.factory.reactor.callLater(0, self.factory.ready.callback, self) def dataReceived(self, data): log.msg("got data", len(data)) self.data += data if len(self.data) == 4 * 4096: self.factory.stop.callback(self.data) def oneTransportTest(testMethod): """ Decorate a L{ReactorBuilder} test function which tests one reactor and one connected transport. Run that test method in the context of C{connectionMade}, and immediately drop the connection (and end the test) when that completes. @param testMethod: A unit test method on a L{ReactorBuilder} test suite; taking two additional parameters; a C{reactor} as built by the L{ReactorBuilder}, and an L{ITCPTransport} provider. @type testMethod: 3-argument C{function} @return: a no-argument test method. @rtype: 1-argument C{function} """ @wraps(testMethod) def actualTestMethod(builder): other = ConnectableProtocol() class ServerProtocol(ConnectableProtocol): def connectionMade(self): try: testMethod(builder, self.reactor, self.transport) finally: if self.transport is not None: self.transport.loseConnection() if other.transport is not None: other.transport.loseConnection() serverProtocol = ServerProtocol() runProtocolsWithReactor(builder, serverProtocol, other, TCPCreator()) return actualTestMethod def assertReading(testCase, reactor, transport): """ Use the given test to assert that the given transport is actively reading in the given reactor. @note: Maintainers; for more information on why this is a function rather than a method on a test case, see U{this document on how we structure test tools <http://twistedmatrix.com/trac/wiki/Design/KeepTestToolsOutOfFixtures>} @param testCase: a test case to perform the assertion upon. @type testCase: L{TestCase} @param reactor: A reactor, possibly one providing L{IReactorFDSet}, or an IOCP reactor. @param transport: An L{ITCPTransport} """ if IReactorFDSet.providedBy(reactor): testCase.assertIn(transport, reactor.getReaders()) else: # IOCP. testCase.assertIn(transport, reactor.handles) testCase.assertTrue(transport.reading) def assertNotReading(testCase, reactor, transport): """ Use the given test to assert that the given transport is I{not} actively reading in the given reactor. @note: Maintainers; for more information on why this is a function rather than a method on a test case, see U{this document on how we structure test tools <http://twistedmatrix.com/trac/wiki/Design/KeepTestToolsOutOfFixtures>} @param testCase: a test case to perform the assertion upon. @type testCase: L{TestCase} @param reactor: A reactor, possibly one providing L{IReactorFDSet}, or an IOCP reactor. @param transport: An L{ITCPTransport} """ if IReactorFDSet.providedBy(reactor): testCase.assertNotIn(transport, reactor.getReaders()) else: # IOCP. testCase.assertFalse(transport.reading) class TCPConnectionTestsBuilder(ReactorBuilder): """ Builder defining tests relating to L{twisted.internet.tcp.Connection}. """ requiredInterfaces = (IReactorTCP,) def test_stopStartReading(self): """ This test verifies transport socket read state after multiple pause/resumeProducing calls. """ sf = ServerFactory() reactor = sf.reactor = self.buildReactor() skippedReactors = ["Glib2Reactor", "Gtk2Reactor"] reactorClassName = reactor.__class__.__name__ if reactorClassName in skippedReactors and platform.isWindows(): raise SkipTest("This test is broken on gtk/glib under Windows.") sf.protocol = StopStartReadingProtocol sf.ready = Deferred() sf.stop = Deferred() p = reactor.listenTCP(0, sf) port = p.getHost().port def proceed(protos, port): """ Send several IOCPReactor's buffers' worth of data. """ self.assertTrue(protos[0]) self.assertTrue(protos[1]) protos = protos[0][1], protos[1][1] protos[0].transport.write(b"x" * (2 * 4096) + b"y" * (2 * 4096)) return sf.stop.addCallback(cleanup, protos, port).addCallback( lambda ign: reactor.stop() ) def cleanup(data, protos, port): """ Make sure IOCPReactor didn't start several WSARecv operations that clobbered each other's results. """ self.assertEqual( data, b"x" * (2 * 4096) + b"y" * (2 * 4096), "did not get the right data", ) return DeferredList( [ maybeDeferred(protos[0].transport.loseConnection), maybeDeferred(protos[1].transport.loseConnection), maybeDeferred(port.stopListening), ] ) cc = TCP4ClientEndpoint(reactor, "127.0.0.1", port) cf = ClientFactory() cf.protocol = Protocol d = DeferredList([cc.connect(cf), sf.ready]).addCallback(proceed, p) d.addErrback(log.err) self.runReactor(reactor) @oneTransportTest def test_resumeProducing(self, reactor, server): """ When a L{Server} is connected, its C{resumeProducing} method adds it as a reader to the reactor. """ server.pauseProducing() assertNotReading(self, reactor, server) server.resumeProducing() assertReading(self, reactor, server) @oneTransportTest def test_resumeProducingWhileDisconnecting(self, reactor, server): """ When a L{Server} has already started disconnecting via C{loseConnection}, its C{resumeProducing} method does not add it as a reader to its reactor. """ server.loseConnection() server.resumeProducing() assertNotReading(self, reactor, server) @oneTransportTest def test_resumeProducingWhileDisconnected(self, reactor, server): """ When a L{Server} has already lost its connection, its C{resumeProducing} method does not add it as a reader to its reactor. """ server.connectionLost(Failure(Exception("dummy"))) assertNotReading(self, reactor, server) server.resumeProducing() assertNotReading(self, reactor, server) def test_connectionLostAfterPausedTransport(self): """ Alice connects to Bob. Alice writes some bytes and then shuts down the connection. Bob receives the bytes from the connection and then pauses the transport object. Shortly afterwards Bob resumes the transport object. At that point, Bob is notified that the connection has been closed. This is no problem for most reactors. The underlying event notification API will probably just remind them that the connection has been closed. It is a little tricky for win32eventreactor (MsgWaitForMultipleObjects). MsgWaitForMultipleObjects will only deliver the close notification once. The reactor needs to remember that notification until Bob resumes the transport. """ class Pauser(ConnectableProtocol): def __init__(self): self.events = [] def dataReceived(self, bytes): self.events.append("paused") self.transport.pauseProducing() self.reactor.callLater(0, self.resume) def resume(self): self.events.append("resumed") self.transport.resumeProducing() def connectionLost(self, reason): # This is the event you have been waiting for. self.events.append("lost") ConnectableProtocol.connectionLost(self, reason) class Client(ConnectableProtocol): def connectionMade(self): self.transport.write(b"some bytes for you") self.transport.loseConnection() pauser = Pauser() runProtocolsWithReactor(self, pauser, Client(), TCPCreator()) self.assertEqual(pauser.events, ["paused", "resumed", "lost"]) def test_doubleHalfClose(self): """ If one side half-closes its connection, and then the other side of the connection calls C{loseWriteConnection}, and then C{loseConnection} in {writeConnectionLost}, the connection is closed correctly. This rather obscure case used to fail (see ticket #3037). """ @implementer(IHalfCloseableProtocol) class ListenerProtocol(ConnectableProtocol): def readConnectionLost(self): self.transport.loseWriteConnection() def writeConnectionLost(self): self.transport.loseConnection() class Client(ConnectableProtocol): def connectionMade(self): self.transport.loseConnection() # If test fails, reactor won't stop and we'll hit timeout: runProtocolsWithReactor(self, ListenerProtocol(), Client(), TCPCreator()) class WriteSequenceTestsMixin: """ Test for L{twisted.internet.abstract.FileDescriptor.writeSequence}. """ requiredInterfaces: Optional[Sequence[Type[Interface]]] = (IReactorTCP,) def setWriteBufferSize(self, transport, value): """ Set the write buffer size for the given transport, mananing possible differences (ie, IOCP). Bug #4322 should remove the need of that hack. """ if getattr(transport, "writeBufferSize", None) is not None: transport.writeBufferSize = value else: transport.bufferSize = value def test_writeSequeceWithoutWrite(self): """ C{writeSequence} sends the data even if C{write} hasn't been called. """ def connected(protocols): client, server, port = protocols def dataReceived(data): log.msg("data received: %r" % data) self.assertEqual(data, b"Some sequence splitted") client.transport.loseConnection() server.dataReceived = dataReceived client.transport.writeSequence([b"Some ", b"sequence ", b"splitted"]) reactor = self.buildReactor() d = self.getConnectedClientAndServer(reactor, "127.0.0.1", socket.AF_INET) d.addCallback(connected) d.addErrback(log.err) self.runReactor(reactor) def test_writeSequenceWithUnicodeRaisesException(self): """ C{writeSequence} with an element in the sequence of type unicode raises C{TypeError}. """ def connected(protocols): client, server, port = protocols exc = self.assertRaises( TypeError, server.transport.writeSequence, ["Unicode is not kosher"] ) self.assertEqual(str(exc), "Data must be bytes") server.transport.loseConnection() reactor = self.buildReactor() d = self.getConnectedClientAndServer(reactor, "127.0.0.1", socket.AF_INET) d.addCallback(connected) d.addErrback(log.err) self.runReactor(reactor) def test_streamingProducer(self): """ C{writeSequence} pauses its streaming producer if too much data is buffered, and then resumes it. """ @implementer(IPushProducer) class SaveActionProducer: client = None server = None def __init__(self): self.actions = [] def pauseProducing(self): self.actions.append("pause") def resumeProducing(self): self.actions.append("resume") # Unregister the producer so the connection can close self.client.transport.unregisterProducer() # This is why the code below waits for the server connection # first - so we have it to close here. We close the server # side because win32evenreactor cannot reliably observe us # closing the client side (#5285). self.server.transport.loseConnection() def stopProducing(self): self.actions.append("stop") producer = SaveActionProducer() def connected(protocols): client, server = protocols[:2] producer.client = client producer.server = server # Register a streaming producer and verify that it gets paused # after it writes more than the local send buffer can hold. client.transport.registerProducer(producer, True) self.assertEqual(producer.actions, []) self.setWriteBufferSize(client.transport, 500) client.transport.writeSequence([b"x" * 50] * 20) self.assertEqual(producer.actions, ["pause"]) reactor = self.buildReactor() d = self.getConnectedClientAndServer(reactor, "127.0.0.1", socket.AF_INET) d.addCallback(connected) d.addErrback(log.err) self.runReactor(reactor) # After the send buffer gets a chance to empty out a bit, the producer # should be resumed. self.assertEqual(producer.actions, ["pause", "resume"]) def test_nonStreamingProducer(self): """ C{writeSequence} pauses its producer if too much data is buffered only if this is a streaming producer. """ test = self @implementer(IPullProducer) class SaveActionProducer: client = None def __init__(self): self.actions = [] def resumeProducing(self): self.actions.append("resume") if self.actions.count("resume") == 2: self.client.transport.stopConsuming() else: test.setWriteBufferSize(self.client.transport, 500) self.client.transport.writeSequence([b"x" * 50] * 20) def stopProducing(self): self.actions.append("stop") producer = SaveActionProducer() def connected(protocols): client = protocols[0] producer.client = client # Register a non-streaming producer and verify that it is resumed # immediately. client.transport.registerProducer(producer, False) self.assertEqual(producer.actions, ["resume"]) reactor = self.buildReactor() d = self.getConnectedClientAndServer(reactor, "127.0.0.1", socket.AF_INET) d.addCallback(connected) d.addErrback(log.err) self.runReactor(reactor) # After the local send buffer empties out, the producer should be # resumed again. self.assertEqual(producer.actions, ["resume", "resume"]) class TCPTransportServerAddressTestMixin: """ Test mixing for TCP server address building and log prefix. """ def getConnectedClientAndServer(self, reactor, interface, addressFamily): """ Helper method returnine a L{Deferred} firing with a tuple of a client protocol, a server protocol, and a running TCP port. """ raise NotImplementedError() def _testServerAddress(self, interface, addressFamily, adressClass): """ Helper method to test TCP server addresses on either IPv4 or IPv6. """ def connected(protocols): client, server, port = protocols try: self.assertEqual( "<AccumulatingProtocol #%s on %s>" % (server.transport.sessionno, port.getHost().port), str(server.transport), ) self.assertEqual( "AccumulatingProtocol,%s,%s" % (server.transport.sessionno, interface), server.transport.logstr, ) [peerAddress] = server.factory.peerAddresses self.assertIsInstance(peerAddress, adressClass) self.assertEqual("TCP", peerAddress.type) self.assertEqual(interface, peerAddress.host) finally: # Be certain to drop the connection so the test completes. server.transport.loseConnection() reactor = self.buildReactor() d = self.getConnectedClientAndServer(reactor, interface, addressFamily) d.addCallback(connected) d.addErrback(log.err) self.runReactor(reactor) def test_serverAddressTCP4(self): """ L{Server} instances have a string representation indicating on which port they're running, and the connected address is stored on the C{peerAddresses} attribute of the factory. """ return self._testServerAddress("127.0.0.1", socket.AF_INET, IPv4Address) @skipIf(ipv6Skip, ipv6SkipReason) def test_serverAddressTCP6(self): """ IPv6 L{Server} instances have a string representation indicating on which port they're running, and the connected address is stored on the C{peerAddresses} attribute of the factory. """ return self._testServerAddress( getLinkLocalIPv6Address(), socket.AF_INET6, IPv6Address ) class TCPTransportTestsBuilder( TCPTransportServerAddressTestMixin, WriteSequenceTestsMixin, ReactorBuilder ): """ Test standard L{ITCPTransport}s built with C{listenTCP} and C{connectTCP}. """ def getConnectedClientAndServer(self, reactor, interface, addressFamily): """ Return a L{Deferred} firing with a L{MyClientFactory} and L{MyServerFactory} connected pair, and the listening C{Port}. """ server = MyServerFactory() server.protocolConnectionMade = Deferred() server.protocolConnectionLost = Deferred() client = MyClientFactory() client.protocolConnectionMade = Deferred() client.protocolConnectionLost = Deferred() port = reactor.listenTCP(0, server, interface=interface) lostDeferred = gatherResults( [client.protocolConnectionLost, server.protocolConnectionLost] ) def stop(result): reactor.stop() return result lostDeferred.addBoth(stop) startDeferred = gatherResults( [client.protocolConnectionMade, server.protocolConnectionMade] ) deferred = Deferred() def start(protocols): client, server = protocols log.msg("client connected %s" % client) log.msg("server connected %s" % server) deferred.callback((client, server, port)) startDeferred.addCallback(start) reactor.connectTCP(interface, port.getHost().port, client) return deferred class AdoptStreamConnectionTestsBuilder( TCPTransportServerAddressTestMixin, WriteSequenceTestsMixin, ReactorBuilder ): """ Test server transports built using C{adoptStreamConnection}. """ requiredInterfaces = (IReactorFDSet, IReactorSocket) def getConnectedClientAndServer(self, reactor, interface, addressFamily): """ Return a L{Deferred} firing with a L{MyClientFactory} and L{MyServerFactory} connected pair, and the listening C{Port}. The particularity is that the server protocol has been obtained after doing a C{adoptStreamConnection} against the original server connection. """ firstServer = MyServerFactory() firstServer.protocolConnectionMade = Deferred() server = MyServerFactory() server.protocolConnectionMade = Deferred() server.protocolConnectionLost = Deferred() client = MyClientFactory() client.protocolConnectionMade = Deferred() client.protocolConnectionLost = Deferred() port = reactor.listenTCP(0, firstServer, interface=interface) def firtServerConnected(proto): reactor.removeReader(proto.transport) reactor.removeWriter(proto.transport) reactor.adoptStreamConnection( proto.transport.fileno(), addressFamily, server ) firstServer.protocolConnectionMade.addCallback(firtServerConnected) lostDeferred = gatherResults( [client.protocolConnectionLost, server.protocolConnectionLost] ) def stop(result): if reactor.running: reactor.stop() return result lostDeferred.addBoth(stop) deferred = Deferred() deferred.addErrback(stop) startDeferred = gatherResults( [client.protocolConnectionMade, server.protocolConnectionMade] ) def start(protocols): client, server = protocols log.msg("client connected %s" % client) log.msg("server connected %s" % server) deferred.callback((client, server, port)) startDeferred.addCallback(start) reactor.connectTCP(interface, port.getHost().port, client) return deferred globals().update(TCP4ClientTestsBuilder.makeTestCaseClasses()) globals().update(TCP6ClientTestsBuilder.makeTestCaseClasses()) globals().update(TCPPortTestsBuilder.makeTestCaseClasses()) globals().update(TCPFDPortTestsBuilder.makeTestCaseClasses()) globals().update(TCPConnectionTestsBuilder.makeTestCaseClasses()) globals().update(TCP4ConnectorTestsBuilder.makeTestCaseClasses()) globals().update(TCP6ConnectorTestsBuilder.makeTestCaseClasses()) globals().update(TCPTransportTestsBuilder.makeTestCaseClasses()) globals().update(AdoptStreamConnectionTestsBuilder.makeTestCaseClasses()) class ServerAbortsTwice(ConnectableProtocol): """ Call abortConnection() twice. """ def dataReceived(self, data): self.transport.abortConnection() self.transport.abortConnection() class ServerAbortsThenLoses(ConnectableProtocol): """ Call abortConnection() followed by loseConnection(). """ def dataReceived(self, data): self.transport.abortConnection() self.transport.loseConnection() class AbortServerWritingProtocol(ConnectableProtocol): """ Protocol that writes data upon connection. """ def connectionMade(self): """ Tell the client that the connection is set up and it's time to abort. """ self.transport.write(b"ready") class ReadAbortServerProtocol(AbortServerWritingProtocol): """ Server that should never receive any data, except 'X's which are written by the other side of the connection before abortConnection, and so might possibly arrive. """ def dataReceived(self, data): if data.replace(b"X", b""): raise Exception("Unexpectedly received data.") class NoReadServer(ConnectableProtocol): """ Stop reading immediately on connection. This simulates a lost connection that will cause the other side to time out, and therefore call abortConnection(). """ def connectionMade(self): self.transport.stopReading() class EventualNoReadServer(ConnectableProtocol): """ Like NoReadServer, except we Wait until some bytes have been delivered before stopping reading. This means TLS handshake has finished, where applicable. """ gotData = False stoppedReading = False def dataReceived(self, data): if not self.gotData: self.gotData = True self.transport.registerProducer(self, False) self.transport.write(b"hello") def resumeProducing(self): if self.stoppedReading: return self.stoppedReading = True # We've written out the data: self.transport.stopReading() def pauseProducing(self): pass def stopProducing(self): pass class BaseAbortingClient(ConnectableProtocol): """ Base class for abort-testing clients. """ inReactorMethod = False def connectionLost(self, reason): if self.inReactorMethod: raise RuntimeError("BUG: connectionLost was called re-entrantly!") ConnectableProtocol.connectionLost(self, reason) class WritingButNotAbortingClient(BaseAbortingClient): """ Write data, but don't abort. """ def connectionMade(self): self.transport.write(b"hello") class AbortingClient(BaseAbortingClient): """ Call abortConnection() after writing some data. """ def dataReceived(self, data): """ Some data was received, so the connection is set up. """ self.inReactorMethod = True self.writeAndAbort() self.inReactorMethod = False def writeAndAbort(self): # X is written before abortConnection, and so there is a chance it # might arrive. Y is written after, and so no Ys should ever be # delivered: self.transport.write(b"X" * 10000) self.transport.abortConnection() self.transport.write(b"Y" * 10000) class AbortingTwiceClient(AbortingClient): """ Call abortConnection() twice, after writing some data. """ def writeAndAbort(self): AbortingClient.writeAndAbort(self) self.transport.abortConnection() class AbortingThenLosingClient(AbortingClient): """ Call abortConnection() and then loseConnection(). """ def writeAndAbort(self): AbortingClient.writeAndAbort(self) self.transport.loseConnection() class ProducerAbortingClient(ConnectableProtocol): """ Call abortConnection from doWrite, via resumeProducing. """ inReactorMethod = True producerStopped = False def write(self): self.transport.write(b"lalala" * 127000) self.inRegisterProducer = True self.transport.registerProducer(self, False) self.inRegisterProducer = False def connectionMade(self): self.write() def resumeProducing(self): self.inReactorMethod = True if not self.inRegisterProducer: self.transport.abortConnection() self.inReactorMethod = False def stopProducing(self): self.producerStopped = True def connectionLost(self, reason): if not self.producerStopped: raise RuntimeError("BUG: stopProducing() was never called.") if self.inReactorMethod: raise RuntimeError("BUG: connectionLost called re-entrantly!") ConnectableProtocol.connectionLost(self, reason) class StreamingProducerClient(ConnectableProtocol): """ Call abortConnection() when the other side has stopped reading. In particular, we want to call abortConnection() only once our local socket hits a state where it is no longer writeable. This helps emulate the most common use case for abortConnection(), closing a connection after a timeout, with write buffers being full. Since it's very difficult to know when this actually happens, we just write a lot of data, and assume at that point no more writes will happen. """ paused = False extraWrites = 0 inReactorMethod = False def connectionMade(self): self.write() def write(self): """ Write large amount to transport, then wait for a while for buffers to fill up. """ self.transport.registerProducer(self, True) for i in range(100): self.transport.write(b"1234567890" * 32000) def resumeProducing(self): self.paused = False def stopProducing(self): pass def pauseProducing(self): """ Called when local buffer fills up. The goal is to hit the point where the local file descriptor is not writeable (or the moral equivalent). The fact that pauseProducing has been called is not sufficient, since that can happen when Twisted's buffers fill up but OS hasn't gotten any writes yet. We want to be as close as possible to every buffer (including OS buffers) being full. So, we wait a bit more after this for Twisted to write out a few chunks, then abortConnection. """ if self.paused: return self.paused = True # The amount we wait is arbitrary, we just want to make sure some # writes have happened and outgoing OS buffers filled up -- see # http://twistedmatrix.com/trac/ticket/5303 for details: self.reactor.callLater(0.01, self.doAbort) def doAbort(self): if not self.paused: log.err(RuntimeError("BUG: We should be paused a this point.")) self.inReactorMethod = True self.transport.abortConnection() self.inReactorMethod = False def connectionLost(self, reason): # Tell server to start reading again so it knows to go away: self.otherProtocol.transport.startReading() ConnectableProtocol.connectionLost(self, reason) class StreamingProducerClientLater(StreamingProducerClient): """ Call abortConnection() from dataReceived, after bytes have been exchanged. """ def connectionMade(self): self.transport.write(b"hello") self.gotData = False def dataReceived(self, data): if not self.gotData: self.gotData = True self.write() class ProducerAbortingClientLater(ProducerAbortingClient): """ Call abortConnection from doWrite, via resumeProducing. Try to do so after some bytes have already been exchanged, so we don't interrupt SSL handshake. """ def connectionMade(self): # Override base class connectionMade(). pass def dataReceived(self, data): self.write() class DataReceivedRaisingClient(AbortingClient): """ Call abortConnection(), and then throw exception, from dataReceived. """ def dataReceived(self, data): self.transport.abortConnection() raise ZeroDivisionError("ONO") class ResumeThrowsClient(ProducerAbortingClient): """ Call abortConnection() and throw exception from resumeProducing(). """ def resumeProducing(self): if not self.inRegisterProducer: self.transport.abortConnection() raise ZeroDivisionError("ono!") def connectionLost(self, reason): # Base class assertion about stopProducing being called isn't valid; # if the we blew up in resumeProducing, consumers are justified in # giving up on the producer and not calling stopProducing. ConnectableProtocol.connectionLost(self, reason) class AbortConnectionMixin: """ Unit tests for L{ITransport.abortConnection}. """ # Override in subclasses, should be an EndpointCreator instance: endpoints: Optional[EndpointCreator] = None def runAbortTest(self, clientClass, serverClass, clientConnectionLostReason=None): """ A test runner utility function, which hooks up a matched pair of client and server protocols. We then run the reactor until both sides have disconnected, and then verify that the right exception resulted. """ clientExpectedExceptions = (ConnectionAborted, ConnectionLost) serverExpectedExceptions = (ConnectionLost, ConnectionDone) # In TLS tests we may get SSL.Error instead of ConnectionLost, # since we're trashing the TLS protocol layer. if useSSL: clientExpectedExceptions = clientExpectedExceptions + (SSL.Error,) serverExpectedExceptions = serverExpectedExceptions + (SSL.Error,) client = clientClass() server = serverClass() client.otherProtocol = server server.otherProtocol = client reactor = runProtocolsWithReactor(self, server, client, self.endpoints) # Make sure everything was shutdown correctly: self.assertEqual(reactor.removeAll(), []) self.assertEqual(reactor.getDelayedCalls(), []) if clientConnectionLostReason is not None: self.assertIsInstance( client.disconnectReason.value, (clientConnectionLostReason,) + clientExpectedExceptions, ) else: self.assertIsInstance( client.disconnectReason.value, clientExpectedExceptions ) self.assertIsInstance(server.disconnectReason.value, serverExpectedExceptions) def test_dataReceivedAbort(self): """ abortConnection() is called in dataReceived. The protocol should be disconnected, but connectionLost should not be called re-entrantly. """ return self.runAbortTest(AbortingClient, ReadAbortServerProtocol) def test_clientAbortsConnectionTwice(self): """ abortConnection() is called twice by client. No exception should be thrown, and the connection will be closed. """ return self.runAbortTest(AbortingTwiceClient, ReadAbortServerProtocol) def test_clientAbortsConnectionThenLosesConnection(self): """ Client calls abortConnection(), followed by loseConnection(). No exception should be thrown, and the connection will be closed. """ return self.runAbortTest(AbortingThenLosingClient, ReadAbortServerProtocol) def test_serverAbortsConnectionTwice(self): """ abortConnection() is called twice by server. No exception should be thrown, and the connection will be closed. """ return self.runAbortTest( WritingButNotAbortingClient, ServerAbortsTwice, clientConnectionLostReason=ConnectionLost, ) def test_serverAbortsConnectionThenLosesConnection(self): """ Server calls abortConnection(), followed by loseConnection(). No exception should be thrown, and the connection will be closed. """ return self.runAbortTest( WritingButNotAbortingClient, ServerAbortsThenLoses, clientConnectionLostReason=ConnectionLost, ) def test_resumeProducingAbort(self): """ abortConnection() is called in resumeProducing, before any bytes have been exchanged. The protocol should be disconnected, but connectionLost should not be called re-entrantly. """ self.runAbortTest(ProducerAbortingClient, ConnectableProtocol) def test_resumeProducingAbortLater(self): """ abortConnection() is called in resumeProducing, after some bytes have been exchanged. The protocol should be disconnected. """ return self.runAbortTest( ProducerAbortingClientLater, AbortServerWritingProtocol ) def test_fullWriteBuffer(self): """ abortConnection() triggered by the write buffer being full. In particular, the server side stops reading. This is supposed to simulate a realistic timeout scenario where the client notices the server is no longer accepting data. The protocol should be disconnected, but connectionLost should not be called re-entrantly. """ self.runAbortTest(StreamingProducerClient, NoReadServer) def test_fullWriteBufferAfterByteExchange(self): """ abortConnection() is triggered by a write buffer being full. However, this buffer is filled after some bytes have been exchanged, allowing a TLS handshake if we're testing TLS. The connection will then be lost. """ return self.runAbortTest(StreamingProducerClientLater, EventualNoReadServer) def test_dataReceivedThrows(self): """ dataReceived calls abortConnection(), and then raises an exception. The connection will be lost, with the thrown exception (C{ZeroDivisionError}) as the reason on the client. The idea here is that bugs should not be masked by abortConnection, in particular unexpected exceptions. """ self.runAbortTest( DataReceivedRaisingClient, AbortServerWritingProtocol, clientConnectionLostReason=ZeroDivisionError, ) errors = self.flushLoggedErrors(ZeroDivisionError) self.assertEqual(len(errors), 1) def test_resumeProducingThrows(self): """ resumeProducing calls abortConnection(), and then raises an exception. The connection will be lost, with the thrown exception (C{ZeroDivisionError}) as the reason on the client. The idea here is that bugs should not be masked by abortConnection, in particular unexpected exceptions. """ self.runAbortTest( ResumeThrowsClient, ConnectableProtocol, clientConnectionLostReason=ZeroDivisionError, ) errors = self.flushLoggedErrors(ZeroDivisionError) self.assertEqual(len(errors), 1) class AbortConnectionTests(ReactorBuilder, AbortConnectionMixin): """ TCP-specific L{AbortConnectionMixin} tests. """ requiredInterfaces = (IReactorTCP,) endpoints = TCPCreator() globals().update(AbortConnectionTests.makeTestCaseClasses()) @skipIf(ipv6Skip, ipv6SkipReason) class SimpleUtilityTests(TestCase): """ Simple, direct tests for helpers within L{twisted.internet.tcp}. """ def test_resolveNumericHost(self): """ L{_resolveIPv6} raises a L{socket.gaierror} (L{socket.EAI_NONAME}) when invoked with a non-numeric host. (In other words, it is passing L{socket.AI_NUMERICHOST} to L{socket.getaddrinfo} and will not accidentally block if it receives bad input.) """ err = self.assertRaises(socket.gaierror, _resolveIPv6, "localhost", 1) self.assertEqual(err.args[0], socket.EAI_NONAME) @skipIf( platform.isWindows(), "The AI_NUMERICSERV flag is not supported by Microsoft providers.", ) # http://msdn.microsoft.com/en-us/library/windows/desktop/ms738520.aspx def test_resolveNumericService(self): """ L{_resolveIPv6} raises a L{socket.gaierror} (L{socket.EAI_NONAME}) when invoked with a non-numeric port. (In other words, it is passing L{socket.AI_NUMERICSERV} to L{socket.getaddrinfo} and will not accidentally block if it receives bad input.) """ err = self.assertRaises(socket.gaierror, _resolveIPv6, "::1", "http") self.assertEqual(err.args[0], socket.EAI_NONAME) def test_resolveIPv6(self): """ L{_resolveIPv6} discovers the flow info and scope ID of an IPv6 address. """ result = _resolveIPv6("::1", 2) self.assertEqual(len(result), 4) # We can't say anything more useful about these than that they're # integers, because the whole point of getaddrinfo is that you can # never know a-priori know _anything_ about the network interfaces # of the computer that you're on and you have to ask it. self.assertIsInstance(result[2], int) # flow info self.assertIsInstance(result[3], int) # scope id # but, luckily, IP presentation format and what it means to be a port # number are a little better specified. self.assertEqual(result[:2], ("::1", 2)) class BuffersLogsTests(SynchronousTestCase): """ Tests for L{_BuffersLogs}. """ def setUp(self): self.namespace = "name.space" self.events = [] self.logBuffer = _BuffersLogs(self.namespace, self.events.append) def test_buffersInBlock(self): """ The context manager's logger does not log to provided observer inside the block. """ with self.logBuffer as logger: logger.info("An event") self.assertFalse(self.events) def test_flushesOnExit(self): """ The context manager flushes its buffered logs when the block terminates without an exception. """ with self.logBuffer as logger: logger.info("An event") self.assertFalse(self.events) self.assertEqual(1, len(self.events)) [event] = self.events self.assertEqual(event["log_format"], "An event") self.assertEqual(event["log_namespace"], self.namespace) def test_flushesOnExitWithException(self): """ The context manager flushes its buffered logs when the block terminates because of an exception. """ class TestException(Exception): """ An exception only raised by this test. """ with self.assertRaises(TestException): with self.logBuffer as logger: logger.info("An event") self.assertFalse(self.events) raise TestException() self.assertEqual(1, len(self.events)) [event] = self.events self.assertEqual(event["log_format"], "An event") self.assertEqual(event["log_namespace"], self.namespace) @skipIf(SKIP_EMFILE, "Reserved EMFILE file descriptor not supported on Windows.") class FileDescriptorReservationTests(SynchronousTestCase): """ Tests for L{_FileDescriptorReservation}. """ def setUp(self): self.reservedFileObjects = [] self.tempfile = self.mktemp() def fakeFileFactory(): self.reservedFileObjects.append(open(self.tempfile, "w")) return self.reservedFileObjects[-1] self.reservedFD = _FileDescriptorReservation(fakeFileFactory) def test_providesInterface(self): """ L{_FileDescriptorReservation} instances provide L{_IFileDescriptorReservation}. """ verifyObject(_IFileDescriptorReservation, self.reservedFD) def test_reserveOpensFileOnce(self): """ Multiple acquisitions without releases open the reservation file exactly once. """ self.assertEqual(len(self.reservedFileObjects), 0) for _ in range(10): self.reservedFD.reserve() self.assertEqual(len(self.reservedFileObjects), 1) self.assertFalse(self.reservedFileObjects[0].closed) def test_reserveEMFILELogged(self): """ If reserving the file descriptor fails because of C{EMFILE}, the exception is suppressed but logged and the reservation remains unavailable. """ exhauster = _ExhaustsFileDescriptors() self.addCleanup(exhauster.release) exhauster.exhaust() self.assertFalse(self.reservedFD.available()) self.reservedFD.reserve() self.assertFalse(self.reservedFD.available()) errors = self.flushLoggedErrors(OSError, IOError) self.assertEqual(len(errors), 1) self.assertEqual(errors[0].value.errno, errno.EMFILE) def test_reserveRaisesNonEMFILEExceptions(self): """ Any exception raised while opening the reserve file that is not an L{OSError} or L{IOError} whose errno is C{EMFILE} is allowed through to the caller. """ for errorClass in (OSError, IOError, ValueError): # Note that the ValueError will present the errno as its # value. def failsWith(errorClass=errorClass): raise errorClass(errno.EMFILE + 1, "message") reserveFD = _FileDescriptorReservation(failsWith) self.assertRaises(errorClass, reserveFD.reserve) def test_available(self): """ The reservation is available after the file descriptor is reserved. """ self.assertFalse(self.reservedFD.available()) self.reservedFD.reserve() self.assertTrue(self.reservedFD.available()) def test_enterFailsWithoutFile(self): """ A reservation without an open file used as a context manager raises a L{RuntimeError}. """ with self.assertRaises(RuntimeError): with self.reservedFD: """This string cannot raise an exception.""" def test_enterClosesFileExitOpensFile(self): """ Entering a reservation closes its file for the duration of the context manager's block. """ self.reservedFD.reserve() self.assertTrue(self.reservedFD.available()) with self.reservedFD: self.assertFalse(self.reservedFD.available()) self.assertTrue(self.reservedFD.available()) def test_exitOpensFileOnException(self): """ An exception raised within a reservation context manager's block does not prevent the file from being reopened. """ class TestException(Exception): """ An exception only used by this test. """ self.reservedFD.reserve() with self.assertRaises(TestException): with self.reservedFD: raise TestException() def test_exitSuppressesReservationException(self): """ An exception raised while re-opening the reserve file exiting a reservation's context manager block is suppressed but logged, allowing an exception raised within the block through. """ class AllowedException(Exception): """ The exception allowed out of the block. """ class SuppressedException(Exception): """ An exception raised by the file descriptor factory. """ called = [False] def failsWithSuppressedExceptionAfterSecondOpen(): if called[0]: raise SuppressedException() else: called[0] = True return io.BytesIO() reservedFD = _FileDescriptorReservation( failsWithSuppressedExceptionAfterSecondOpen ) reservedFD.reserve() self.assertTrue(reservedFD.available()) with self.assertRaises(AllowedException): with reservedFD: raise AllowedException() errors = self.flushLoggedErrors(SuppressedException) self.assertEqual(len(errors), 1) class NullFileDescriptorReservationTests(SynchronousTestCase): """ Tests for L{_NullFileDescriptorReservation}. """ def setUp(self): self.nullReservedFD = _NullFileDescriptorReservation() def test_providesInterface(self): """ L{_NullFileDescriptorReservation} provides L{_IFileDescriptorReservation}. """ verifyObject(_IFileDescriptorReservation, self.nullReservedFD) def test_available(self): """ The null reserved file descriptor is never available. """ self.assertFalse(self.nullReservedFD.available()) def test_contextManager(self): """ The null reserved file descriptor is a null context manager. """ self.assertFalse(self.nullReservedFD.available()) with self.nullReservedFD: self.assertFalse(self.nullReservedFD.available()) self.assertFalse(self.nullReservedFD.available()) PK Mb�Z����u+ u+ internet/test/test_core.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for implementations of L{IReactorCore}. """ import signal import time from types import FrameType from typing import Callable, List, Optional, Tuple, Union, cast from twisted.internet.abstract import FileDescriptor from twisted.internet.defer import Deferred from twisted.internet.error import ReactorAlreadyRunning, ReactorNotRestartable from twisted.internet.test.reactormixins import ReactorBuilder from twisted.python.failure import Failure from twisted.trial.unittest import SynchronousTestCase class SystemEventTestsBuilder(ReactorBuilder): """ Builder defining tests relating to L{IReactorCore.addSystemEventTrigger} and L{IReactorCore.fireSystemEvent}. """ def test_stopWhenNotStarted(self) -> None: """ C{reactor.stop()} raises L{RuntimeError} when called when the reactor has not been started. """ reactor = self.buildReactor() cast(SynchronousTestCase, self).assertRaises(RuntimeError, reactor.stop) def test_stopWhenAlreadyStopped(self) -> None: """ C{reactor.stop()} raises L{RuntimeError} when called after the reactor has been stopped. """ reactor = self.buildReactor() reactor.callWhenRunning(reactor.stop) self.runReactor(reactor) cast(SynchronousTestCase, self).assertRaises(RuntimeError, reactor.stop) def test_callWhenRunningOrder(self) -> None: """ Functions are run in the order that they were passed to L{reactor.callWhenRunning}. """ reactor = self.buildReactor() events: List[str] = [] reactor.callWhenRunning(events.append, "first") reactor.callWhenRunning(events.append, "second") reactor.callWhenRunning(reactor.stop) self.runReactor(reactor) cast(SynchronousTestCase, self).assertEqual(events, ["first", "second"]) def test_runningForStartupEvents(self) -> None: """ The reactor is not running when C{"before"} C{"startup"} triggers are called and is running when C{"during"} and C{"after"} C{"startup"} triggers are called. """ reactor = self.buildReactor() state = {} def beforeStartup() -> None: state["before"] = reactor.running def duringStartup() -> None: state["during"] = reactor.running def afterStartup() -> None: state["after"] = reactor.running testCase = cast(SynchronousTestCase, self) reactor.addSystemEventTrigger("before", "startup", beforeStartup) reactor.addSystemEventTrigger("during", "startup", duringStartup) reactor.addSystemEventTrigger("after", "startup", afterStartup) reactor.callWhenRunning(reactor.stop) testCase.assertEqual(state, {}) self.runReactor(reactor) testCase.assertEqual(state, {"before": False, "during": True, "after": True}) def test_signalHandlersInstalledDuringStartup(self) -> None: """ Signal handlers are installed in responsed to the C{"during"} C{"startup"}. """ reactor = self.buildReactor() phase: Optional[str] = None def beforeStartup() -> None: nonlocal phase phase = "before" def afterStartup() -> None: nonlocal phase phase = "after" reactor.addSystemEventTrigger("before", "startup", beforeStartup) reactor.addSystemEventTrigger("after", "startup", afterStartup) sawPhase = [] def fakeSignal(signum: int, action: Callable[[int, FrameType], None]) -> None: sawPhase.append(phase) testCase = cast(SynchronousTestCase, self) testCase.patch(signal, "signal", fakeSignal) reactor.callWhenRunning(reactor.stop) testCase.assertIsNone(phase) testCase.assertEqual(sawPhase, []) self.runReactor(reactor) testCase.assertIn("before", sawPhase) testCase.assertEqual(phase, "after") def test_stopShutDownEvents(self) -> None: """ C{reactor.stop()} fires all three phases of shutdown event triggers before it makes C{reactor.run()} return. """ reactor = self.buildReactor() events = [] reactor.addSystemEventTrigger( "before", "shutdown", lambda: events.append(("before", "shutdown")) ) reactor.addSystemEventTrigger( "during", "shutdown", lambda: events.append(("during", "shutdown")) ) reactor.addSystemEventTrigger( "after", "shutdown", lambda: events.append(("after", "shutdown")) ) reactor.callWhenRunning(reactor.stop) self.runReactor(reactor) cast(SynchronousTestCase, self).assertEqual( events, [("before", "shutdown"), ("during", "shutdown"), ("after", "shutdown")], ) def test_shutdownFiresTriggersAsynchronously(self) -> None: """ C{"before"} C{"shutdown"} triggers are not run synchronously from L{reactor.stop}. """ reactor = self.buildReactor() events: List[str] = [] reactor.addSystemEventTrigger( "before", "shutdown", events.append, "before shutdown" ) def stopIt() -> None: reactor.stop() events.append("stopped") testCase = cast(SynchronousTestCase, self) reactor.callWhenRunning(stopIt) testCase.assertEqual(events, []) self.runReactor(reactor) testCase.assertEqual(events, ["stopped", "before shutdown"]) def test_shutdownDisconnectsCleanly(self) -> None: """ A L{IFileDescriptor.connectionLost} implementation which raises an exception does not prevent the remaining L{IFileDescriptor}s from having their C{connectionLost} method called. """ lostOK = [False] # Subclass FileDescriptor to get logPrefix class ProblematicFileDescriptor(FileDescriptor): def connectionLost(self, reason: Failure) -> None: raise RuntimeError("simulated connectionLost error") class OKFileDescriptor(FileDescriptor): def connectionLost(self, reason: Failure) -> None: lostOK[0] = True testCase = cast(SynchronousTestCase, self) reactor = self.buildReactor() # Unfortunately, it is necessary to patch removeAll to directly control # the order of the returned values. The test is only valid if # ProblematicFileDescriptor comes first. Also, return these # descriptors only the first time removeAll is called so that if it is # called again the file descriptors aren't re-disconnected. fds = iter([ProblematicFileDescriptor(), OKFileDescriptor()]) reactor.removeAll = lambda: fds reactor.callWhenRunning(reactor.stop) self.runReactor(reactor) testCase.assertEqual(len(testCase.flushLoggedErrors(RuntimeError)), 1) testCase.assertTrue(lostOK[0]) def test_multipleRun(self) -> None: """ C{reactor.run()} raises L{ReactorAlreadyRunning} when called when the reactor is already running. """ events: List[str] = [] testCase = cast(SynchronousTestCase, self) def reentrantRun() -> None: testCase.assertRaises(ReactorAlreadyRunning, reactor.run) events.append("tested") reactor = self.buildReactor() reactor.callWhenRunning(reentrantRun) reactor.callWhenRunning(reactor.stop) self.runReactor(reactor) testCase.assertEqual(events, ["tested"]) def test_runWithAsynchronousBeforeStartupTrigger(self) -> None: """ When there is a C{'before'} C{'startup'} trigger which returns an unfired L{Deferred}, C{reactor.run()} starts the reactor and does not return until after C{reactor.stop()} is called """ events = [] def trigger() -> Deferred[object]: events.append("trigger") d: Deferred[object] = Deferred() d.addCallback(callback) reactor.callLater(0, d.callback, None) return d def callback(ignored: object) -> None: events.append("callback") reactor.stop() reactor = self.buildReactor() reactor.addSystemEventTrigger("before", "startup", trigger) self.runReactor(reactor) cast(SynchronousTestCase, self).assertEqual(events, ["trigger", "callback"]) def test_iterate(self) -> None: """ C{reactor.iterate()} does not block. """ reactor = self.buildReactor() t = reactor.callLater(5, reactor.crash) start = time.time() reactor.iterate(0) # Shouldn't block elapsed = time.time() - start cast(SynchronousTestCase, self).assertTrue(elapsed < 2) t.cancel() def test_crash(self) -> None: """ C{reactor.crash()} stops the reactor and does not fire shutdown triggers. """ reactor = self.buildReactor() events = [] reactor.addSystemEventTrigger( "before", "shutdown", lambda: events.append(("before", "shutdown")) ) reactor.callWhenRunning(reactor.callLater, 0, reactor.crash) self.runReactor(reactor) testCase = cast(SynchronousTestCase, self) testCase.assertFalse(reactor.running) testCase.assertFalse( events, "Shutdown triggers invoked but they should not have been." ) def test_runAfterCrash(self) -> None: """ C{reactor.run()} restarts the reactor after it has been stopped by C{reactor.crash()}. """ events: List[Union[str, Tuple[str, bool]]] = [] def crash() -> None: events.append("crash") reactor.crash() reactor = self.buildReactor() reactor.callWhenRunning(crash) self.runReactor(reactor) def stop() -> None: events.append(("stop", reactor.running)) reactor.stop() reactor.callWhenRunning(stop) self.runReactor(reactor) cast(SynchronousTestCase, self).assertEqual(events, ["crash", ("stop", True)]) def test_runAfterStop(self) -> None: """ C{reactor.run()} raises L{ReactorNotRestartable} when called when the reactor is being run after getting stopped priorly. """ events: List[str] = [] testCase = cast(SynchronousTestCase, self) def restart() -> None: testCase.assertRaises(ReactorNotRestartable, reactor.run) events.append("tested") reactor = self.buildReactor() reactor.callWhenRunning(reactor.stop) reactor.addSystemEventTrigger("after", "shutdown", restart) self.runReactor(reactor) testCase.assertEqual(events, ["tested"]) globals().update(SystemEventTestsBuilder.makeTestCaseClasses()) PK Mb�ZdV�� � % internet/test/test_win32serialport.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.internet.serialport}. """ import os import shutil import tempfile from twisted.internet.protocol import Protocol from twisted.internet.test.test_serialport import DoNothing from twisted.python.failure import Failure from twisted.python.runtime import platform from twisted.trial import unittest testingForced = "TWISTED_FORCE_SERIAL_TESTS" in os.environ try: import serial # type: ignore[import] from twisted.internet import serialport except ImportError: if testingForced: raise serialport = None # type: ignore[assignment] serial = None if serialport is not None: class RegularFileSerial(serial.Serial): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.captured_args = args self.captured_kwargs = kwargs def _reconfigurePort(self): pass def _reconfigure_port(self): pass class RegularFileSerialPort(serialport.SerialPort): _serialFactory = RegularFileSerial def __init__(self, *args, **kwargs): cbInQue = kwargs.get("cbInQue") if "cbInQue" in kwargs: del kwargs["cbInQue"] self.comstat = serial.win32.COMSTAT self.comstat.cbInQue = cbInQue super().__init__(*args, **kwargs) def _clearCommError(self): return True, self.comstat class CollectReceivedProtocol(Protocol): def __init__(self): self.received_data = [] def dataReceived(self, data): self.received_data.append(data) class Win32SerialPortTests(unittest.TestCase): """ Minimal testing for Twisted's Win32 serial port support. """ if not testingForced: if not platform.isWindows(): skip = "This test must run on Windows." elif not serialport: skip = "Windows serial port support is not available." def setUp(self): # Re-usable protocol and reactor self.protocol = Protocol() self.reactor = DoNothing() self.directory = tempfile.mkdtemp() self.path = os.path.join(self.directory, "fake_serial") data = b"1234" with open(self.path, "wb") as f: f.write(data) def tearDown(self): shutil.rmtree(self.directory) def test_serialPortDefaultArgs(self): """ Test correct positional and keyword arguments have been passed to the C{serial.Serial} object. """ port = RegularFileSerialPort(self.protocol, self.path, self.reactor) # Validate args self.assertEqual((self.path,), port._serial.captured_args) # Validate kwargs kwargs = port._serial.captured_kwargs self.assertEqual(9600, kwargs["baudrate"]) self.assertEqual(serial.EIGHTBITS, kwargs["bytesize"]) self.assertEqual(serial.PARITY_NONE, kwargs["parity"]) self.assertEqual(serial.STOPBITS_ONE, kwargs["stopbits"]) self.assertEqual(0, kwargs["xonxoff"]) self.assertEqual(0, kwargs["rtscts"]) self.assertEqual(None, kwargs["timeout"]) port.connectionLost(Failure(Exception("Cleanup"))) def test_serialPortInitiallyConnected(self): """ Test the port is connected at initialization time, and C{Protocol.makeConnection} has been called on the desired protocol. """ self.assertEqual(0, self.protocol.connected) port = RegularFileSerialPort(self.protocol, self.path, self.reactor) self.assertEqual(1, port.connected) self.assertEqual(1, self.protocol.connected) self.assertEqual(port, self.protocol.transport) port.connectionLost(Failure(Exception("Cleanup"))) def common_exerciseHandleAccess(self, cbInQue): port = RegularFileSerialPort( protocol=self.protocol, deviceNameOrPortNumber=self.path, reactor=self.reactor, cbInQue=cbInQue, ) port.serialReadEvent() port.write(b"") port.write(b"abcd") port.write(b"ABCD") port.serialWriteEvent() port.serialWriteEvent() port.connectionLost(Failure(Exception("Cleanup"))) # No assertion since the point is simply to make sure that in all cases # the port handle resolves instead of raising an exception. def test_exerciseHandleAccess_1(self): self.common_exerciseHandleAccess(cbInQue=False) def test_exerciseHandleAccess_2(self): self.common_exerciseHandleAccess(cbInQue=True) def common_serialPortReturnsBytes(self, cbInQue): protocol = CollectReceivedProtocol() port = RegularFileSerialPort( protocol=protocol, deviceNameOrPortNumber=self.path, reactor=self.reactor, cbInQue=cbInQue, ) port.serialReadEvent() self.assertTrue(all(isinstance(d, bytes) for d in protocol.received_data)) port.connectionLost(Failure(Exception("Cleanup"))) def test_serialPortReturnsBytes_1(self): self.common_serialPortReturnsBytes(cbInQue=False) def test_serialPortReturnsBytes_2(self): self.common_serialPortReturnsBytes(cbInQue=True) PK Mb�Z(���� � internet/test/_win32ifaces.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Windows implementation of local network interface enumeration. """ from ctypes import ( # type: ignore[attr-defined] POINTER, Structure, WinDLL, byref, c_int, c_void_p, cast, create_string_buffer, create_unicode_buffer, wstring_at, ) from socket import AF_INET6, SOCK_STREAM, socket WS2_32 = WinDLL("ws2_32") SOCKET = c_int DWORD = c_int LPVOID = c_void_p LPSOCKADDR = c_void_p LPWSAPROTOCOL_INFO = c_void_p LPTSTR = c_void_p LPDWORD = c_void_p LPWSAOVERLAPPED = c_void_p LPWSAOVERLAPPED_COMPLETION_ROUTINE = c_void_p # http://msdn.microsoft.com/en-us/library/ms741621(v=VS.85).aspx # int WSAIoctl( # __in SOCKET s, # __in DWORD dwIoControlCode, # __in LPVOID lpvInBuffer, # __in DWORD cbInBuffer, # __out LPVOID lpvOutBuffer, # __in DWORD cbOutBuffer, # __out LPDWORD lpcbBytesReturned, # __in LPWSAOVERLAPPED lpOverlapped, # __in LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine # ); WSAIoctl = WS2_32.WSAIoctl WSAIoctl.argtypes = [ SOCKET, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE, ] WSAIoctl.restype = c_int # http://msdn.microsoft.com/en-us/library/ms741516(VS.85).aspx # INT WSAAPI WSAAddressToString( # __in LPSOCKADDR lpsaAddress, # __in DWORD dwAddressLength, # __in_opt LPWSAPROTOCOL_INFO lpProtocolInfo, # __inout LPTSTR lpszAddressString, # __inout LPDWORD lpdwAddressStringLength # ); WSAAddressToString = WS2_32.WSAAddressToStringW WSAAddressToString.argtypes = [LPSOCKADDR, DWORD, LPWSAPROTOCOL_INFO, LPTSTR, LPDWORD] WSAAddressToString.restype = c_int SIO_ADDRESS_LIST_QUERY = 0x48000016 WSAEFAULT = 10014 class SOCKET_ADDRESS(Structure): _fields_ = [("lpSockaddr", c_void_p), ("iSockaddrLength", c_int)] def make_SAL(ln): class SOCKET_ADDRESS_LIST(Structure): _fields_ = [("iAddressCount", c_int), ("Address", SOCKET_ADDRESS * ln)] return SOCKET_ADDRESS_LIST def win32GetLinkLocalIPv6Addresses(): """ Return a list of strings in colon-hex format representing all the link local IPv6 addresses available on the system, as reported by I{WSAIoctl}/C{SIO_ADDRESS_LIST_QUERY}. """ s = socket(AF_INET6, SOCK_STREAM) size = 4096 retBytes = c_int() for i in range(2): buf = create_string_buffer(size) ret = WSAIoctl( s.fileno(), SIO_ADDRESS_LIST_QUERY, 0, 0, buf, size, byref(retBytes), 0, 0 ) # WSAIoctl might fail with WSAEFAULT, which means there was not enough # space in the buffer we gave it. There's no way to check the errno # until Python 2.6, so we don't even try. :/ Maybe if retBytes is still # 0 another error happened, though. if ret and retBytes.value: size = retBytes.value else: break # If it failed, then we'll just have to give up. Still no way to see why. if ret: raise RuntimeError("WSAIoctl failure") addrList = cast(buf, POINTER(make_SAL(0))) addrCount = addrList[0].iAddressCount addrList = cast(buf, POINTER(make_SAL(addrCount))) addressStringBufLength = 1024 addressStringBuf = create_unicode_buffer(addressStringBufLength) retList = [] for i in range(addrList[0].iAddressCount): retBytes.value = addressStringBufLength address = addrList[0].Address[i] ret = WSAAddressToString( address.lpSockaddr, address.iSockaddrLength, 0, addressStringBuf, byref(retBytes), ) if ret: raise RuntimeError("WSAAddressToString failure") retList.append(wstring_at(addressStringBuf)) return [addr for addr in retList if "%" in addr] PK Mb�Z�L)Q# # internet/test/process_cli.pynu �[��� import os import sys try: # On Windows, stdout is not opened in binary mode by default, # so newline characters are munged on writing, interfering with # the tests. import msvcrt msvcrt.setmode( # type:ignore[attr-defined] sys.stdout.fileno(), os.O_BINARY ) except ImportError: pass # Loop over each of the arguments given and print it to stdout for arg in sys.argv[1:]: res = arg + chr(0) sys.stdout.buffer.write(res.encode(sys.getfilesystemencoding(), "surrogateescape")) sys.stdout.flush() PK Mb�Z���! ! ; internet/test/__pycache__/test_epollreactor.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z zddl m Z W n e y3 dZ Y nw G d d � d �Zee d �G d d � d e ��ZdS )z- Tests for L{twisted.internet.epollreactor}. � )�skipIf��ConnectionDone)�_ContinuousPolling)�Clock)�TestCase)� epollreactorNc @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � DescriptorzF Records reads and writes, as if it were a C{FileDescriptor}. c C s g | _ d S �N)�events��self� r �I/usr/lib/python3/dist-packages/twisted/internet/test/test_epollreactor.py�__init__ s zDescriptor.__init__c C s dS )N� r r r r r �fileno s zDescriptor.filenoc C � | j �d� d S )N�read�r �appendr r r r �doRead � zDescriptor.doReadc C r )N�writer r r r r �doWrite# r zDescriptor.doWritec C s |� t� | j�d� d S )N�lost)�trapr r r )r �reasonr r r �connectionLost& s zDescriptor.connectionLostN) �__name__� __module__� __qualname__�__doc__r r r r r r r r r r s r z(epoll not supported in this environment.c @ sx e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd S ) �ContinuousPollingTestsza L{_ContinuousPolling} can be used to read and write from C{FileDescriptor} objects. c C �v t t� �}| �|j� t� }| �|�|�� |�|� | �|j� | � |jj � | � |jj |j � | � |�|�� dS )zi Adding a reader when there was previously no reader starts up a C{LoopingCall}. N)r r � assertIsNone�_loop�object� assertFalse� isReading� addReader�assertIsNotNone� assertTrue�running�assertIs�clock�_reactor�r �poller�readerr r r �test_addReader2 � z%ContinuousPollingTests.test_addReaderc C r$ )zi Adding a writer when there was previously no writer starts up a C{LoopingCall}. N)r r r% r& r' r( � isWriting� addWriterr+ r, r- r. r/ r0 �r r2 �writerr r r �test_addWriterA r5 z%ContinuousPollingTests.test_addWriterc C �V t t� �}t� }|�|� |�|� | �|j� | �|j� � g � | � |� |�� dS )z= Removing a reader stops the C{LoopingCall}. N) r r r' r* � removeReaderr% r& � assertEqualr0 �getDelayedCallsr( r) r1 r r r �test_removeReaderP � z(ContinuousPollingTests.test_removeReaderc C r; )z= Removing a writer stops the C{LoopingCall}. N) r r r' r7 � removeWriterr% r& r= r0 r> r( r6 r8 r r r �test_removeWriter\ r@ z(ContinuousPollingTests.test_removeWriterc C s& t t� �}|�t� � |�t� � dS )zM Removing unknown readers and writers silently does nothing. N)r r rA r' r< )r r2 r r r �test_removeUnknownh s z)ContinuousPollingTests.test_removeUnknownc C s� t t� �}t� }|�|� | �|j� |�t� � | �|j� |�t� � | �|j� |�t� � |�|� | �|j� | �|jj � | � t |j � � �d� dS )za Adding multiple readers and writers results in a single C{LoopingCall}. r N)r r r' r7 r+ r& r* rA r, r- r= �lenr0 r> r8 r r r � test_multipleReadersAndWritersp s z5ContinuousPollingTests.test_multipleReadersAndWritersc C � t � }t|�}t� }|�|� | �|jg � |�d� | �|jdg� |�d� | �|jddg� |�d� | �|jg d�� dS )za Adding a reader causes its C{doRead} to be called every 1 milliseconds. g�h㈵��>r )r r r N)r r r r* r= r �advance�r �reactorr2 �descr r r �test_readerPolling� � z)ContinuousPollingTests.test_readerPollingc C rF )zb Adding a writer causes its C{doWrite} to be called every 1 milliseconds. ���MbP?r )r r r N)r r r r7 r= r rG rH r r r �test_writerPolling� rL z)ContinuousPollingTests.test_writerPollingc C �T t � }t|�}t� }dd� |_|�|� | �|jg � |�d� | �|jdg� dS )zu If a C{doRead} returns a value indicating disconnection, C{connectionLost} is called on it. c S � t � S r r r r r r �<lambda>� � zBContinuousPollingTests.test_connectionLostOnRead.<locals>.<lambda>rM r N)r r r r r* r= r rG rH r r r �test_connectionLostOnRead� � z0ContinuousPollingTests.test_connectionLostOnReadc C rO )zv If a C{doWrite} returns a value indicating disconnection, C{connectionLost} is called on it. c S rP r r r r r r rQ � rR zCContinuousPollingTests.test_connectionLostOnWrite.<locals>.<lambda>rM r N)r r r r r7 r= r rG rH r r r �test_connectionLostOnWrite� rT z1ContinuousPollingTests.test_connectionLostOnWritec C s� t t� �}t� }t� }t� }|�|� |�|� |�|� |�|� |�� }| �|�� g � | �|�� g � | �t |�d� | �t |�|||h� dS )zv L{_ContinuousPolling.removeAll} removes all descriptors and returns the readers and writers. � N) r r r' r* r7 � removeAllr= � getReaders� getWritersrD �set)r r2 r3 r9 �both�removedr r r �test_removeAll� s z%ContinuousPollingTests.test_removeAllc C �. t t� �}t� }|�|� | �||�� � dS )zb L{_ContinuousPolling.getReaders} returns a list of the read descriptors. N)r r r' r* �assertInrX r1 r r r �test_getReaders� � z&ContinuousPollingTests.test_getReadersc C r^ )zc L{_ContinuousPolling.getWriters} returns a list of the write descriptors. N)r r r' r7 r_ rY r8 r r r �test_getWriters� ra z&ContinuousPollingTests.test_getWritersN)r r r! r" r4 r: r? rB rC rE rK rN rS rU r] r` rb r r r r r# + s r# )r" �unittestr �twisted.internet.errorr �twisted.internet.posixbaser �twisted.internet.taskr �twisted.trial.unittestr �twisted.internetr � ImportErrorr r# r r r r �<module> s � PK Mb�Z�`G�R R 6 internet/test/__pycache__/test_threads.cpython-310.pycnu �[��� o �b " � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZ G d d � d e�Ze� �e�� � dS ) z2 Tests for implementations of L{IReactorThreads}. � N)�ref)�IReactorThreads)�ReactorBuilder)� isInIOThread)� ThreadPool)�Versionc @ sf e Zd ZdZefZdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dd� Zdd� ZdS )�ThreadTestsBuilderzD Builder for defining tests relating to L{IReactorThreads}. c s� g �| � � ���� � | �� t� | �� jd� � ��fdd�}��|� | ��d� | ��d d� | ��d d� | �� j d � d S ) z� C{reactor.getThreadPool()} returns an instance of L{ThreadPool} which starts when C{reactor.run()} is called and stops before it returns. z(Pool should not start before reactor.runc s$ �� � j� �� � j� ��� d S �N)�append�started�joined�stop� ��pool�reactor�stater �D/usr/lib/python3/dist-packages/twisted/internet/test/test_threads.py�f' s z0ThreadTestsBuilder.test_getThreadPool.<locals>.f� r z#Pool should start after reactor.run� z-Pool should not be joined before reactor.stopz0Pool should be stopped after reactor.run returnsN) � buildReactor� getThreadPool�assertIsInstancer � assertFalser �callWhenRunning� runReactor� assertTruer )�selfr r r r �test_getThreadPool s z%ThreadTestsBuilder.test_getThreadPoolc C s, | � � }|�d� |�� }| �|jd� dS )zm C{reactor.suggestThreadPoolSize()} sets the maximum size of the reactor threadpool. � N)r �suggestThreadPoolSizer � assertEqual�max)r r r r r r �test_suggestThreadPoolSize4 s z-ThreadTestsBuilder.test_suggestThreadPoolSizec sV | � � � � fdd�}� �d� j|� � �� }| �� d� � �� }| �|| dk � dS )aR A function scheduled with L{IReactorThreads.callFromThread} invoked from a delayed call is run immediately in the next reactor iteration. When invoked from the reactor thread, previous implementations of L{IReactorThreads.callFromThread} would skip the pipe/socket based wake up step, assuming the reactor would wake up on its own. However, this resulted in the reactor not noticing an insert into the thread queue at the right time (in this case, after the thread queue has been processed for that reactor iteration). c s � � � d S r )r r �r r r � threadCallL s zAThreadTestsBuilder.test_delayedCallFromThread.<locals>.threadCallr �< � N)r � callLater�callFromThread�secondsr r )r r& �before�afterr r% r �test_delayedCallFromThread> s z-ThreadTestsBuilder.test_delayedCallFromThreadc sP | � � � g �� �fdd�}� �d� j� j|� | �� d� | ��t�� g� dS )z� A function scheduled with L{IReactorThreads.callFromThread} invoked from another thread is run in the reactor thread. c s �� t�� � � �� d S r )r � threading�current_threadr r �r �resultr r r& p s z:ThreadTestsBuilder.test_callFromThread.<locals>.threadCallr � N)r r) � callInThreadr* r r" r/ r0 )r r& r r1 r �test_callFromThreadh s z&ThreadTestsBuilder.test_callFromThreadc C sB | � � }t|�� �}|�|j� | �|� t�� | �|� � dS )a0 When the reactor stops, L{ReactorBase._stopThreadPool} drops the reactor's direct reference to its internal threadpool and removes the associated startup and shutdown triggers. This is the case of the thread pool being created before the reactor is run. N) r r r r r r �gc�collect� assertIsNone)r r � threadpoolr r r �test_stopThreadPooly s z&ThreadTestsBuilder.test_stopThreadPoolc sJ | � � � g �� �fdd�}� �|� | �� � t�� | ��d � � dS )a� We must handle the case of shutting down the thread pool when it was started after the reactor was run in a special way. Some implementation background: The thread pool is started with callWhenRunning, which only returns a system trigger ID when it is invoked before the reactor is started. This is the case of the thread pool being created after the reactor is started. c s �� t� �� �� � �� d S r )r r r r r �r �threadPoolRefsr r �acquireThreadPool� s z[ThreadTestsBuilder.test_stopThreadPoolWhenStartedAfterReactorRan.<locals>.acquireThreadPoolr N)r r r r6 r7 r8 )r r= r r; r �-test_stopThreadPoolWhenStartedAfterReactorRan� s z@ThreadTestsBuilder.test_stopThreadPoolWhenStartedAfterReactorRanc C s\ | � � }t|�� �}|�d� |jjdkr"| �|j� | �|� dS t � � | �|� � dS )a[ When the reactor has its shutdown event fired before it is run, the thread pool is completely destroyed. For what it's worth, the reason we support this behavior at all is because Trial does this. This is the case of the thread pool being created without the reactor being started at al. �shutdown�AsyncioSelectorReactorN) r r r �fireSystemEvent� __class__�__name__r8 r9 r r6 r7 )r r � threadPoolRefr r r �,test_cleanUpThreadPoolEvenBeforeReactorIsRun� s z?ThreadTestsBuilder.test_cleanUpThreadPoolEvenBeforeReactorIsRunc �@ g �| � � � � �fdd�}� �|� | �� � | �dg�� dS )z� The reactor registers itself as the I/O thread when it runs so that L{twisted.python.threadable.isInIOThread} returns C{True} if it is called in the thread the reactor is running in. c s �� t� � � �� d S r )r r r r �r �resultsr r �check� s z3ThreadTestsBuilder.test_isInIOThread.<locals>.checkTN)r r r r" �r rI r rG r �test_isInIOThread� � z$ThreadTestsBuilder.test_isInIOThreadc rF )z� The reactor registers itself as the I/O thread when it runs so that L{twisted.python.threadable.isInIOThread} returns C{False} if it is called in a different thread than the reactor is running in. c s �� t� � � �� j� d S r )r r r* r r rG r r rI � s z6ThreadTestsBuilder.test_isNotInIOThread.<locals>.checkFN)r r4 r r" rJ r rG r �test_isNotInIOThread� rL z'ThreadTestsBuilder.test_isNotInIOThreadc C s" | j tdddd�dftjd� d S )N�Twisted� r r zthreading.current_thread)�versionr )�callDeprecatedr r � currentThread)r r r r �&test_threadPoolCurrentThreadDeprecated� s � �z9ThreadTestsBuilder.test_threadPoolCurrentThreadDeprecatedN)rC � __module__� __qualname__�__doc__r �requiredInterfacesr r$ r. r5 r: r> rE rK rM rS r r r r r s * r )rV r6 r/ �weakrefr �twisted.internet.interfacesr �#twisted.internet.test.reactormixinsr �twisted.python.threadabler �twisted.python.threadpoolr �twisted.python.versionsr r �globals�update�makeTestCaseClassesr r r r �<module> s WPK Mb�Zy�Ϭ� � 3 internet/test/__pycache__/test_iocp.cpython-310.pycnu �[��� o �b � @ sp d Z ddlZddlZddlZddlmZ ddlmZmZmZm Z mZ ddl m Z ddl m Z ddlmZ ddlmZ dd lmZ dd lmZ z(dd lmZmZmZ dd lm Z dd l m Z ddl m Z ddl!m"Z"m#Z#m$Z$ W n e%y ej&dkr{� dZ'Y nw z eee��(� W n e)y� Z* z dZ+e,e*�Z-W Y dZ*[*n dZ*[*ww dZ+dZ-G dd� de�Z.G dd� de�Z/dS )z, Tests for L{twisted.internet.iocpreactor}. � N)�array)�AF_INET�AF_INET6� SOCK_STREAM� SOL_SOCKET�socket)�pack)�skipIf)� verifyClass)� IPushProducer)�msg)�TestCase)� iocpsupport�tcp�udp)� FileHandle)�SO_UPDATE_ACCEPT_CONTEXT)�IReadWriteHandle)�EVENTS_PER_LOOP� KEY_NORMAL� IOCPReactor�win32z%This test only applies to IOCPReactorTF� c @ s2 e Zd ZdZdd� Zdd� Zeee�dd� �Z dS ) � SupportTestszn Tests for L{twisted.internet.iocpreactor.iocpsupport}, low-level reactor implementation helpers. c C s� t d|��� t|t�}| �|j� |�d� |�d� t|t�}| �|j� |�d� z |�||� � d f� W n t yV } z| � |j t j t jf� W Y d}~nd}~ww t|t�}| �|j� tdd�}| �dt�|�� |�� |d�� ttd ��D ]7}z|�tttd |�� �� W n& t y� } z| j tt d �kr�� |dkr�� W Y d} ~ nd} ~ ww t� d � q}| �||� � dd � |� � dd � ft� |�� |�� dS )a� Create a C{SOCK_STREAM} connection to localhost using a socket with an address family of C{family} and assert that the result of L{iocpsupport.get_accept_addrs} is consistent with the result of C{socket.getsockname} and C{socket.getpeername}. A port starts listening (is bound) at the low-level socket without calling accept() yet. A client is then connected. After the client is connected IOCP accept() is called, which is the target of these tests. Most of the time, the socket is ready instantly, but sometimes the socket is not ready right away after calling IOCP accept(). It should not take more than 5 seconds for a socket to be ready, as the client connection is already made over the loopback interface. These are flaky tests. Tweak the failure rate by changing the number of retries and the wait/sleep between retries. If you will need to update the retries to wait more than 5 seconds for the port to be available, then there might a bug in the code and not the test (or a very, very busy VM running the tests). z family = )r r � FN�Bs r � �P� WSAENOTCONNg�������?� ) r r r � addCleanup�close�bind�listen� setblocking�connect� getsockname�OSError�assertIn�errno� EINPROGRESS� EWOULDBLOCKr � assertEqual�_iocp�accept�fileno�reversed�range� setsockoptr r r �getattr�time�sleep� getpeername�get_accept_addrs) �self�family� localhost�port�client�e�server�buff�attemptsRemaining� socketError� rB �A/usr/lib/python3/dist-packages/twisted/internet/test/test_iocp.py�_acceptAddressTest7 sJ "�� � ��� �z SupportTests._acceptAddressTestc C � | � td� dS )a L{iocpsupport.get_accept_addrs} returns a three-tuple of address information about the socket associated with the file descriptor passed to it. For a connection using IPv4: - the first element is C{AF_INET} - the second element is a two-tuple of a dotted decimal notation IPv4 address and a port number giving the peer address of the connection - the third element is the same type giving the host address of the connection z 127.0.0.1N)rD r �r8 rB rB rC �test_ipv4AcceptAddress� � z#SupportTests.test_ipv4AcceptAddressc C rE )a� Like L{test_ipv4AcceptAddress}, but for IPv6 connections. In this case: - the first element is C{AF_INET6} - the second element is a two-tuple of a hexadecimal IPv6 address literal and a port number giving the peer address of the connection - the third element is the same type giving the host address of the connection z::1N)rD r rF rB rB rC �test_ipv6AcceptAddress� rH z#SupportTests.test_ipv6AcceptAddressN) �__name__� __module__� __qualname__�__doc__rD rG r �ipv6Skip�ipv6SkipReasonrI rB rB rB rC r 1 s Rr c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �IOCPReactorTestsc C s" t � }|�� | �|�d�� dS )zd Test reactor behavior (doIteration) when there are no pending time events. N)r �wakeUp� assertFalse� doIteration)r8 �irrB rB rC �test_noPendingTimerEvents� s z*IOCPReactorTests.test_noPendingTimerEventsc C s( | � tttj�� | � tttj�� dS )zY Verify that IOCP socket-representing classes implement IReadWriteHandle N)� assertTruer r r � Connectionr �PortrF rB rB rC �test_reactorInterfaces� s z'IOCPReactorTests.test_reactorInterfacesc C s | � ttt�� dS )zH Verify that L{Filehandle} implements L{IPushProducer}. N)rV r r r rF rB rB rC �test_fileHandleInterfaces� s z*IOCPReactorTests.test_fileHandleInterfacesc C s� G dd� d�}t � }|� }t�|j|�}ttd �D ] }|j�dt|� q|� d� | � |j t� |� d� | � |j td � dS )z� Verify that we don't lose an event when more than EVENTS_PER_LOOP events occur in the same reactor iteration c @ s e Zd ZdZdd� Zdd� ZdS )z;IOCPReactorTests.test_maxEventsPerIteration.<locals>.FakeFDr c S s dS )N�FakeFDrB rF rB rB rC � logPrefix� s zEIOCPReactorTests.test_maxEventsPerIteration.<locals>.FakeFD.logPrefixc S s | j d7 _ d S )Nr )�counter)r8 �rc�bytes�evtrB rB rC �cb� s z>IOCPReactorTests.test_maxEventsPerIteration.<locals>.FakeFD.cbN)rJ rK rL r] r\ ra rB rB rB rC r[ � s r[ r r N) r r- �Eventra r1 r r; � postEventr rS r, r] )r8 r[ rT �fd�event�_rB rB rC �test_maxEventsPerIteration� s z+IOCPReactorTests.test_maxEventsPerIterationN)rJ rK rL rU rY rZ rg rB rB rB rC rP � s rP )0rM r) �sysr4 r r r r r r �structr �unittestr �zope.interface.verifyr �twisted.internet.interfacesr �twisted.python.logr �twisted.trial.unittestr � twisted.internet.iocpreactorr r- r r �%twisted.internet.iocpreactor.abstractr �"twisted.internet.iocpreactor.constr �'twisted.internet.iocpreactor.interfacesr �$twisted.internet.iocpreactor.reactorr r r � ImportError�platform�skipr! r' r= rN �strrO r rP rB rB rB rC �<module> sD ���uPK Mb�Z�� #T T 8 internet/test/__pycache__/process_helper.cpython-310.pycnu �[��� o �b � @ s6 d dl Z d dlZdd� Zdd� Zedkre� dS dS )� Nc C s$ t j�d� t j�� t j�� d S )Nzgrandchild started)�sys�stdout�write�flush�stdin�read� r r �F/usr/lib/python3/dist-packages/twisted/internet/test/process_helper.py� grandchild s r c C s� t jd dkrat jd dkrTdd l} dd l}|�� }| �| j�|_| �| j�|_ | �| j �|_ t j }t j�t�}t j�t�}|�d d�||df�d d ddt j||� d S t �� dkr_t� d S d S t� d S )N� �child� �windowsr � r )r �argv�win32api� win32process� STARTUPINFO� GetStdHandle�STD_INPUT_HANDLE� hStdInput�STD_OUTPUT_HANDLE� hStdOutput�STD_ERROR_HANDLE� hStdError� executable�os�path�dirname�__file__�basename� CreateProcess�join�environ�forkr )�api�proc�info�python� scriptDir� scriptNamer r r �main s4 � � r+ �__main__)r r r r+ �__name__r r r r �<module> s �PK Mb�Z���ӊ ӊ 3 internet/test/__pycache__/test_unix.cpython-310.pycnu �[��� o �b&� � @ s` d Z ddlmZ ddlmZmZmZmZmZ ddl m Z ddl m Z m Z mZm Z ddlmZ ddlmZ ddlmZmZ dd lmZmZmZ dd lmZ zdd l mZ W n e y_ d ZY nw e Zdd l m Z m Z ddl!m"Z"m#Z# ddl$m%Z% ddl&m'Z'm(Z(m)Z) ddl*m+Z+m,Z, ddl-m.Z.m/Z/m0Z0 ddl1m2Z2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9 ddl:m;Z; ddl<m=Z=m>Z>m?Z?m@Z@mAZA ddlBmCZC ddlDmEZEmFZFmGZGmHZH ddlImJZJ ddlKmLZL ddlMmNZN dd lOmPZPmQZQmRZR dd lSmTZT dd lUmVZV eTd �ZWd ZXeTd �d u�rd!ZXG d"d#� d#�ZYd$d%� ZZG d&d'� d'e?�Z[G d(d)� d)e=�Z\e e2�G d*d+� d+e=��Z]G d,d-� d-eYeCe>�Z^G d.d/� d/eYeC�Z_G d0d1� d1�Z`G d2d3� d3�ZaG d4d5� d5�ZbG d6d7� d7eaebeCeG�ZcG d8d9� d9e`ebeCeG�ZdG d:d;� d;eHeC�Zeef� �ge^�h� � ef� �ge_�h� � ef� �gec�h� � ef� �ged�h� � ef� �gee�h� � G d<d=� d=eCe@�Zief� �gei�h� � d S )>z/ Tests for implementations of L{IReactorUNIX}. � )�md5)�close�fstat�stat�unlink�urandom)�pformat)�AF_INET� SOCK_STREAM� SOL_SOCKET�socket)�S_IMODE)�pack)�mkstemp�mktemp)�Optional�Sequence�Type)�skipIf)�AF_UNIXN)� Interface� implementer)�base� interfaces)� UNIXAddress)�Deferred�fail� gatherResults)�UNIXClientEndpoint�UNIXServerEndpoint)�CannotListenError�ConnectionClosed�FileDescriptorOverrun)�IFileDescriptorReceiver� IReactorFDSet�IReactorSocket� IReactorUNIX)� ClientFactory�DatagramProtocol� ServerFactory)� LoopingCall)�ConnectableProtocol�ConnectionTestsMixin�EndpointCreator�StreamClientTestsMixin�runProtocolsWithReactor)�ReactorBuilder)�MyClientFactory�MyServerFactory�StreamTransportTestsMixin�WriteSequenceTestsMixin)� nativeString)�Failure)�_coerceToFilesystemEncoding)� addObserver�err�removeObserver)� requireModule)�platformztwisted.python.sendmsg� z>sendmsg extension unavailable, extended UNIX features disabledc @ s e Zd ZdZdd� ZdS )�UNIXFamilyMixinzK Test-helper defining mixin for things related to AF_UNIX sockets. c C sB d}| � � }t||�|||d�}|�� | �tt|�j�|� dS )z} Assert that the mode of the created unix socket is set to the mode specified to the reactor method. i� )�modeN)� buildReactor�getattr� stopListening� assertEqualr r �st_mode)�self� methodName�path�factoryr? �reactor�unixPort� rK �A/usr/lib/python3/dist-packages/twisted/internet/test/test_unix.py� _modeTestO s zUNIXFamilyMixin._modeTestN)�__name__� __module__� __qualname__�__doc__rM rK rK rK rL r> J s r> c C s t td���� S )zI Return a new, unique abstract namespace path to be listened on. �d )r r � hexdigest)�caserK rK rL � _abstractPath[ s rU c @ s> e Zd ZU dZejfZeee e e d< dd� Z dd� Z dS )� UNIXCreatorz( Create UNIX socket end points. �requiredInterfacesc C s t ddd�}t||�S )z3 Construct a UNIX server endpoint. �.sock�.��suffix�dir)r r )rE rI rG rK rK rL �serveri � zUNIXCreator.serverc C s t ||j�S )z3 Construct a UNIX client endpoint. )r �name)rE rI � serverAddressrK rK rL �clientq s zUNIXCreator.clientN)rN rO rP rQ r r& rW r r r r �__annotations__r] ra rK rK rK rL rV b s rV c @ s, e Zd ZdZdZdd� Zdd� Zdd� ZdS ) �SendFileDescriptorz� L{SendFileDescriptorAndBytes} sends a file descriptor and optionally some normal bytes and then closes its connection. @ivar reason: The reason the connection was lost, after C{connectionLost} is called. Nc C s || _ || _dS )z� @param fd: A C{int} giving a file descriptor to send over the connection. @param data: A C{str} giving data to send over the connection, or L{None} if no data is to be sent. N)�fd�data)rE rd re rK rK rL �__init__� s zSendFileDescriptor.__init__c C s0 | j �| j� | jr| j �| j� | j �� dS )zn Send C{self.fd} and, if it is not L{None}, C{self.data}. Then close the connection. N)� transport�sendFileDescriptorrd re �write�loseConnection�rE rK rK rL �connectionMade� s z!SendFileDescriptor.connectionMadec C s t �| |� || _d S �N)r+ �connectionLost�reason�rE ro rK rK rL rn � s z!SendFileDescriptor.connectionLost)rN rO rP rQ ro rf rl rn rK rK rK rL rc x s rc c @ s8 e Zd ZdZdZdZdd� Zdd� Zdd� Zd d � Z dS ) �ReceiveFileDescriptora} L{ReceiveFileDescriptor} provides an API for waiting for file descriptors to be received. @ivar reason: The reason the connection was lost, after C{connectionLost} is called. @ivar waiting: A L{Deferred} which fires with a file descriptor once one is received, or with a failure if the connection is lost with no descriptor arriving. Nc C s" | j du r t� | _| jS t| j �S )z� Return a L{Deferred} which will fire with the next file descriptor received, or with a failure if the connection is or has already been lost. N)ro r �waitingr rk rK rK rL �waitForDescriptor� s z'ReceiveFileDescriptor.waitForDescriptorc C s | j �|� d| _ dS )z� Fire the waiting Deferred, initialized by C{waitForDescriptor}, with the file descriptor just received. N)rr �callback)rE � descriptorrK rK rL �fileDescriptorReceived� r^ z,ReceiveFileDescriptor.fileDescriptorReceivedc C s4 | j dur| j �ttd|�d���� d| _ dS dS )a_ Fail the waiting Deferred, if it has not already been fired by C{fileDescriptorReceived}. The bytes sent along with a file descriptor are guaranteed to be delivered to the protocol's C{dataReceived} method only after the file descriptor has been delivered to the protocol's C{fileDescriptorReceived}. NzReceived bytes (z) before descriptor.)rr �errbackr6 � Exception�rE re rK rK rL � dataReceived� s � �z"ReceiveFileDescriptor.dataReceivedc C s2 t �| |� | jdur| j�|� d| _|| _dS )zj Fail the waiting Deferred, initialized by C{waitForDescriptor}, if there is one. N)r+ rn rr rw ro rp rK rK rL rn � s z$ReceiveFileDescriptor.connectionLost) rN rO rP rQ ro rr rs rv rz rn rK rK rK rL rq � s rq c @ s e Zd ZdZefZe� Zdd� Ze e � � d�dd� �Z dd� Z e e � � d�d d � �Zd d � Ze e e�d d� �Ze e e�dd� �Ze e e�dd� �Zdd� Ze e e�dd� �Ze e �� d�e e e�dd� ��Ze e e�dd� �Ze e e�d d � �Ze e e�d d � �Zd S )!�UNIXTestsBuilderz= Builder defining tests relating to L{IReactorUNIX}. c C � | � d| �� t� � dS )zs The UNIX socket created by L{IReactorUNIX.listenUNIX} is created with the mode specified. � listenUNIXN)rM r r) rk rK rK rL � test_mode� � zUNIXTestsBuilder.test_mode�8Abstract namespace UNIX sockets only supported on Linux.c C �> t | �}| �� }|�d| t� �}| �|�� td| �� dS )z� On Linux, a UNIX socket path may begin with C{' '} to indicate a socket in the abstract namespace. L{IReactorUNIX.listenUNIX} accepts such a path. � N)rU r@ r} r) rC �getHostr �rE rG rI �portrK rK rL �#test_listenOnLinuxAbstractNamespace� s z4UNIXTestsBuilder.test_listenOnLinuxAbstractNamespacec C s^ dd� }| � tjd|� | �� }| �t�� |�dt� � W d � dS 1 s(w Y dS )z� L{IReactorUNIX.listenUNIX} raises L{CannotListenError} if the underlying port's createInternetSocket raises a socket error. c S s t d��)Nz FakeBasePort forced socket.error)�OSErrorrk rK rK rL �raiseSocketError s z=UNIXTestsBuilder.test_listenFailure.<locals>.raiseSocketError�createInternetSocketznot-usedN)�patchr �BasePortr@ � assertRaisesr r} r) )rE r� rI rK rK rL �test_listenFailure� s "�z#UNIXTestsBuilder.test_listenFailurec C r� )zc L{IReactorUNIX.connectUNIX} also accepts a Linux abstract namespace path. r� N)rU r@ � connectUNIXr' rC �getDestinationr )rE rG rI � connectorrK rK rL �$test_connectToLinuxAbstractNamespace s z5UNIXTestsBuilder.test_connectToLinuxAbstractNamespacec C s` G dd� dt �}|� }|� }t| ||| j� | �|jd |jd � | �|jd |jd � dS )z� A client's transport's C{getHost} and C{getPeer} return L{UNIXAddress} instances which have the filesystem path of the host and peer ends of the connection. c @ � e Zd Zdd� ZdS )z4UNIXTestsBuilder.test_addresses.<locals>.SaveAddressc S s" t |�� |�� d�| _|�� d S )N)�host�peer)�dictr� �getPeer� addressesrj )rE rg rK rK rL �makeConnection s � zCUNIXTestsBuilder.test_addresses.<locals>.SaveAddress.makeConnectionN)rN rO rP r� rK rK rK rL � SaveAddress � r� r� r� N)r+ r/ � endpointsrC r� )rE r� r] ra rK rK rL �test_addresses s z UNIXTestsBuilder.test_addressesc s� ddl m� t � ���d� t��� d��t� }|�� }� ��fdd�}|�|� |�t d� |� �fdd �� t ��|�j � d S ) z� L{IUNIXTransport.sendFileDescriptor} accepts an integer file descriptor and sends a copy of it to the process reading from the connection. r )�fromfd)r= r � junkc s@ � | t t�}t| � ����� |�� � ����� |�� � d S rm )r r r rC � getsockname�assertNotEqual�fileno)ru �received)r� �srE rK rL �checkDescriptor= s zAUNIXTestsBuilder.test_sendFileDescriptor.<locals>.checkDescriptorz-Sending file descriptor encountered a problemc � � j �� S rm �rg rj ��ignored�r] rK rL �<lambda>M � z:UNIXTestsBuilder.test_sendFileDescriptor.<locals>.<lambda>N) r r� �bindrc r� rq rs � addCallback� addErrbackr9 �addBothr/ r� )rE ra �dr� rK )r� r� rE r] rL �test_sendFileDescriptor. s z(UNIXTestsBuilder.test_sendFileDescriptorc C sT G dd� dt �}G dd� dt �}|� }|� }||_t| ||| j� | �|jd� dS )z� If a L{IUNIXTransport.sendFileDescriptor} call fills up the send buffer, any registered producer is paused. c @ r� )zSUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.DoesNotReadc S s | j �� d S rm )rg �pauseProducingrk rK rK rL rl Y s zbUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.DoesNotRead.connectionMadeN�rN rO rP rl rK rK rK rL � DoesNotReadX r� r� c @ �8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) z`UNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptorsFc sP t � � _ � j�� d� � fdd�}t|�� _� jj� j_� j�d��t d� d S )NTc s" � j �� j�� � � j �d� d S )N� x)rg rh r r� ri rK rk rK rL �senderc s zUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors.connectionMade.<locals>.senderr zSend loop failure) r rg �registerProducerr* �taskrI �clock�startr� r9 )rE r� rK rk rL rl _ s zoUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors.connectionMadec S � | � � d S rm �� _disconnectrk rK rK rL � stopProducingk � znUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors.stopProducingc S r� rm r� rk rK rK rL �resumeProducingn r� zpUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors.resumeProducingc S s d| _ | j�� | �� d S )NT)�pausedrg �unregisterProducerr� rk rK rK rL r� q s zoUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors.pauseProducingc S s$ | j �� | j�� | jj�� d S rm )r� �stoprg �abortConnection�otherrk rK rK rL r� v s zlUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors._disconnectN) rN rO rP r� rl r� r� r� r� rK rK rK rL �SendsManyFileDescriptors\ s r� z*sendFileDescriptor producer was not pausedN)r+ r� r/ r� � assertTruer� )rE r� r� r] ra rK rK rL �-test_sendFileDescriptorTriggersPauseProducingQ s z>UNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducingc s� t � }t|�� d�� t� }g }|�� }|�|j� |�� fdd�� t| � || j� | � |d t � |d � t � | � � j jt� dS )ag If L{IUNIXTransport.sendFileDescriptor} is used to queue a greater number of file descriptors than the number of bytes sent using L{ITransport.write}, the connection is closed and the protocol connected to the transport has its C{connectionLost} method called with a failure wrapping L{FileDescriptorOverrun}. Nc r� rm r� r� r� rK rL r� � r� z=UNIXTestsBuilder.test_fileDescriptorOverrun.<locals>.<lambda>r )r rc r� rq rs r� �appendr/ r� �assertIsInstancer6 �trapr! ro �valuer" )rE �cargora �resultr� rK r� rL �test_fileDescriptorOverrun� s z+UNIXTestsBuilder.test_fileDescriptorOverrunc s@ ddl m} ddlm} ddlm} dd� � tt�G � fdd�dt��}G d d � d |�}|t t �\}}| � |j � | � |j � |� } ||| �} t � \} } t � \} }| � t| � | � t|� d }| | g}||�\}}||||� | �� | �t| j�|� | �t|��t| j��� | jr�� fd d �|D �}| �|| j� dS dS )a� Drive _SendmsgMixin via sendmsg socket calls to check that L{IFileDescriptorReceiver.fileDescriptorReceived} is called once for each file descriptor received in the ancillary messages. @param ancillaryPacker: A callable that will be given a list of two file descriptors and should return a two-tuple where: The first item is an iterable of zero or more (cmsg_level, cmsg_type, cmsg_data) tuples in the same order as the given list for actual sending via sendmsg; the second item is an integer indicating the expected number of FDs to be received. r �� socketpair)� _SendmsgMixin��sendmsgc S s t | �}|j|jfS rm )r �st_dev�st_ino)rd �fsrK rK rL �deviceInodeTuple� s zTUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.deviceInodeTuplec s e Zd Zdd� Z� fdd�ZdS )zPUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeProtocolc S s g | _ g | _d S rm )�fds�deviceInodesReceivedrk rK rK rL rf � � zYUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeProtocol.__init__c s( | j �|� | j�� |�� t|� d S rm )r� r� r� r )rE rd �r� rK rL rv � s zgUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeProtocol.fileDescriptorReceivedN)rN rO rP rf rv rK r� rK rL � FakeProtocol� s r� c @ r� ) zPUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver� c S s || _ || _d S rm )r �protocol)rE �skt�protorK rK rL rf � r� zYUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver.__init__c S � d S rm rK ry rK rK rL � _dataReceived� � z^UNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver._dataReceivedc S r� rm rK rk rK rK rL r� � r� zXUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver.getHostc S r� rm rK rk rK rK rL r� � r� zXUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver.getPeerc S r� rm rK )rE �orK rK rL � _getLogPrefix� r� z^UNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver._getLogPrefixN) rN rO rP � bufferSizerf r� r� r� r� rK rK rK rL � FakeReceiver� s r� s some data needs to be sentc s g | ]}� |��qS rK rK ��.0rd r� rK rL � <listcomp>� s zNUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.<listcomp>N)r r� �twisted.internet.unixr� �twisted.python.sendmsgr� r r# r+ r r � addCleanupr r r �doReadrC �lenr� � assertFalse�set� intersectionr� )rE �ancillaryPackerr� r� r� r� r� � sendSocket� recvSocketr� �receiver� fileOneFD� fileOneName� fileTwoFD� fileTwoName� dataToSend� fdsToSend� ancillary� expectedCount�deviceInodesSentrK r� rL �)_sendmsgMixinFileDescriptorReceivedDriver� s6 �z:UNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriverc �& ddl m� � fdd�}| �|� dS )z� _SendmsgMixin handles multiple file descriptors per recvmsg, calling L{IFileDescriptorReceiver.fileDescriptorReceived} once per received file descriptor. Scenario: single CMSG with two FDs. r �� SCM_RIGHTSc s$ t � tdg| �R � fg}d}||fS )N�ii� �r r �r� r� r r rK rL r� s z[UNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgOneCMSG.<locals>.ancillaryPackerN�r� r r �rE r� rK r rL �1test_multiFileDescriptorReceivedPerRecvmsgOneCMSG� s zBUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgOneCMSGz=Multi control message ancillary sendmsg not supported on Mac.c r )z� _SendmsgMixin handles multiple file descriptors per recvmsg, calling L{IFileDescriptorReceiver.fileDescriptorReceived} once per received file descriptor. Scenario: two CMSGs with one FD each. r r c s � fdd�| D �}d}||fS )Nc s g | ] }t � td |�f�qS )�ir r� r rK rL r� s zpUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgTwoCMSGs.<locals>.ancillaryPacker.<locals>.<listcomp>r rK r r rK rL r� s z\UNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgTwoCMSGs.<locals>.ancillaryPackerNr r rK r rL �2test_multiFileDescriptorReceivedPerRecvmsgTwoCMSGs s zCUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgTwoCMSGsc s~ ddl m� dd� }�fdd�}g }t|j� | �t|j� | ��d|� | �|� d� t� fd d �|D ��}| � |d � d S ) z� _SendmsgMixin handles multiple file descriptors per recvmsg, calling L{IFileDescriptorReceiver.fileDescriptorReceived} once per received file descriptor. Scenario: unsupported CMSGs. r r� c S s g }d}||fS )Nr rK r rK rK rL r� 0 s z[UNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgBadCMSG.<locals>.ancillaryPackerc s d}dg}d}� � |||�S )Ns some data)NN� r )�ReceivedMessage)r� �args�kwargsre r� �flagsr� rK rL � fakeRecvmsgUnsupportedAncillary5 s zkUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgBadCMSG.<locals>.fakeRecvmsgUnsupportedAncillary�recvmsgz#received unsupported ancillary datac 3 s � | ] }� |d v V qdS )�formatNrK )r� �e)�expectedMessagerK rL � <genexpr>D s � zUUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgBadCMSG.<locals>.<genexpr>z+Expected message not found in logged eventsN) �twisted.pythonr� r8 r� r� r: r� r �anyr� )rE r� r �events�foundrK )r r� rL �1test_multiFileDescriptorReceivedPerRecvmsgBadCMSG! s zBUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgBadCMSGc C s� ddl m} |� \}}g }t|j� | �t|j� G dd� dt�}||�� d�}t� }t | ||| j � |� � |� d� | � d|�d�� d }d } t|j|j| |d �} |D ]} | �� D ] \} } | | �| �krh nq[ d S qU| �d | t|�f � d S )z� If associated with a protocol which does not provide L{IFileDescriptorReceiver}, file descriptors received by the L{IUNIXTransport} implementation are closed and a warning is emitted. r r� c @ r� )zRUNIXTestsBuilder.test_avoidLeakingFileDescriptors.<locals>.RecordEndpointAddressesc S s& | j �� | _| j �� | _t�| � d S rm )rg r� � hostAddressr� � peerAddressrc rl rk rK rK rL rl \ s zaUNIXTestsBuilder.test_avoidLeakingFileDescriptors.<locals>.RecordEndpointAddresses.connectionMadeNr� rK rK rK rL �RecordEndpointAddresses[ r� r! r� Fr r� z�%(protocolName)s (on %(hostAddress)r) does not provide IFileDescriptorReceiver; closing file descriptor received (from %(peerAddress)r).r+ )r r � protocolNamer z3Expected event (%s) not found in logged events (%s)N)r r� r8 r� r� r: rc r� r+ r/ r� r � setblockingrC �recvr� r r �items�getr r )rE r� � probeClient� probeServerr r! r] ra r �clsName� expectedEvent�logEvent�k�vrK rK rL � test_avoidLeakingFileDescriptorsG sJ ��������z1UNIXTestsBuilder.test_avoidLeakingFileDescriptorsc sv t t�G � fdd�dt��}t� }t|�� d�}|� }t� ||� j� � �t |j d � � �dt |j dd� �� dS )z� L{IUNIXTransport.sendFileDescriptor} sends file descriptors before L{ITransport.write} sends normal bytes. c s( e Zd Zdd� Z� fdd�Zdd� ZdS )zJUNIXTestsBuilder.test_descriptorDeliveredBeforeBytes.<locals>.RecordEventsc S s t �| � g | _d S rm )r+ rl r rk rK rK rL rl � s zYUNIXTestsBuilder.test_descriptorDeliveredBeforeBytes.<locals>.RecordEvents.connectionMadec s � � t|� | j�t|�� d S rm )r� r r r� �type)� innerSelfru rk rK rL rv � s zaUNIXTestsBuilder.test_descriptorDeliveredBeforeBytes.<locals>.RecordEvents.fileDescriptorReceivedc S s | j �|� d S rm )r �extendry rK rK rL rz � s zWUNIXTestsBuilder.test_descriptorDeliveredBeforeBytes.<locals>.RecordEvents.dataReceivedN)rN rO rP rl rv rz rK rk rK rL � RecordEvents� s r2 r� r � N) r r# r+ r rc r� r/ r� rC �intr �bytes)rE r2 r� r] ra rK rk rL �#test_descriptorDeliveredBeforeBytes� s z4UNIXTestsBuilder.test_descriptorDeliveredBeforeBytesN) rN rO rP rQ r& rW rV r� r~ r r< �isLinuxr� r� r� r� r� �sendmsgSkipReasonr� r� r� r r �isMacOSXr r r. r6 rK rK rK rL r{ � sL � � " 0 c � % Lr{ c @ s8 e Zd ZdZejfZdd� Zee � � d�dd� �Z dS )�UNIXDatagramTestsBuilderzE Builder defining tests relating to L{IReactorUNIXDatagram}. c C r| )z� The UNIX socket created by L{IReactorUNIXDatagram.listenUNIXDatagram} is created with the mode specified. �listenUNIXDatagramN)rM r r( rk rK rK rL �test_listenMode� r z(UNIXDatagramTestsBuilder.test_listenModer� c C r� )z� On Linux, a UNIX socket path may begin with C{' '} to indicate a socket in the abstract namespace. L{IReactorUNIX.listenUNIXDatagram} accepts such a path. r� N)rU r@ r; r( rC r� r r� rK rK rL r� � s z<UNIXDatagramTestsBuilder.test_listenOnLinuxAbstractNamespaceN) rN rO rP rQ r �IReactorUNIXDatagramrW r< r r< r7 r� rK rK rK rL r: � s �r: c @ s> e Zd ZU dZeefZeee e e d< dd� Z dd� Z dS )�SocketUNIXMixinzb Mixin which uses L{IReactorSocket.adoptStreamPort} to hand out listening UNIX ports. rW c C s\ t t�}tddd�}|�|� |�d� |�d� z|�|�� |j|�W |� � S |� � w )zj Get a UNIX port from a reactor, wrapping an already-initialized file descriptor. rX rY rZ � F) r r r r� �listenr# �adoptStreamPortr� �familyr )rE rI rH �portSockrG rK rK rL �getListeningPort� s z SocketUNIXMixin.getListeningPortc C � |� |j|�S �aZ Connect to a listening UNIX socket. @param reactor: The reactor under test. @type reactor: L{IReactorUNIX} @param address: The listening's address. @type address: L{UNIXAddress} @param factory: The client factory. @type factory: L{ClientFactory} @return: The connector �r� r_ �rE rI �addressrH rK rK rL �connectToListener� � z!SocketUNIXMixin.connectToListenerN)rN rO rP rQ r& r% rW r r r r rb rD rJ rK rK rK rL r> � s � r> c @ s e Zd ZdZdd� Zdd� ZdS )�ListenUNIXMixinzZ Mixin which uses L{IReactorTCP.listenUNIX} to hand out listening UNIX ports. c C s t ddd�}|�||�S )z0 Get a UNIX port from a reactor rX rY rZ )r r} )rE rI rH rG rK rK rL rD s z ListenUNIXMixin.getListeningPortc C rE rF rG rH rK rK rL rJ rK z!ListenUNIXMixin.connectToListenerN)rN rO rP rQ rD rJ rK rK rK rL rL s rL c @ s8 e Zd ZU efZeeee e d< dd� Z dd� Z dS )�UNIXPortTestsMixinrW c C s |� dt |�� j���S )zZ Get the message expected to be logged when a UNIX port starts listening. z starting on �r5 r� r_ )rE r� rH rK rK rL �#getExpectedStartListeningLogMessage# s z6UNIXPortTestsMixin.getExpectedStartListeningLogMessagec C s dt |�� j�� d�S )zJ Get the expected connection lost message for a UNIX port z (UNIX Port z Closed)rN )rE r� rK rK rL � getExpectedConnectionLostLogMsg) s z2UNIXPortTestsMixin.getExpectedConnectionLostLogMsgN) rN rO rP r& rW r r r r rb rO rP rK rK rK rL rM s rM c @ � e Zd ZdZdS )�UNIXPortTestsBuilderz. Tests for L{IReactorUNIX.listenUnix} N�rN rO rP rQ rK rK rK rL rR 0 � rR c @ rQ )�UNIXFDPortTestsBuilderz3 Tests for L{IReactorUNIX.adoptStreamPort} NrS rK rK rK rL rU ; rT rU c @ s. e Zd ZeeefZdd� Zdd� Zdd� Z dS )�%UNIXAdoptStreamConnectionTestsBuilderc C s~ | � � }ddlm} G dd� dt�}|tt�\}}|�d� | �|j� | �|j� |� � }|� }|� |t|�}| � |� dS )z� {IReactorSocket.adoptStreamConnection} returns None if the given factory's buildProtocol returns None. r r� c @ r� )zXUNIXAdoptStreamConnectionTestsBuilder.test_buildProtocolReturnsNone.<locals>.NoneFactoryc S r� rm rK )rE rI rK rK rL � buildProtocol\ r� zfUNIXAdoptStreamConnectionTestsBuilder.test_buildProtocolReturnsNone.<locals>.NoneFactory.buildProtocolN)rN rO rP rW rK rK rK rL � NoneFactory[ r� rX FN) r@ r r� r) r r r# r� r r� �adoptStreamConnection� assertIsNone) rE rI r� rX �s1�s2�s1FDrH r� rK rK rL � test_buildProtocolReturnsNoneM s zCUNIXAdoptStreamConnectionTestsBuilder.test_buildProtocolReturnsNonec s< � fdd�}� � � }� j|ddd�}|�|� � �|� dS )z> Helper method to test UNIX server addresses. c s� | \}}}z9t d|�� j�}� �d|jj|f t|j�� � �d|jj|f |jj� |jj d }� � |t � W |j� � d S |j� � w )Nr= z <AccumulatingProtocol #%s on %s>zAccumulatingProtocol,%s,%sr ) r7 r� r_ rC rg � sessionno�str�logstrrH � peerAddressesr� r rj )� protocolsra r] r� �portPathr rk rK rL � connectedn s$ �� �� zOUNIXAdoptStreamConnectionTestsBuilder.test_ServerAddressUNIX.<locals>.connectedN)� interface� addressFamily)r@ �getConnectedClientAndServerr� � runReactor)rE re rI r� rK rk rL �test_ServerAddressUNIXi s � z<UNIXAdoptStreamConnectionTestsBuilder.test_ServerAddressUNIXc s� t � }t� |_t � �t� �_t� �_t� }t� |_t� |_tddd�}��||����fdd�}|j�|� t|j�jg�}�fdd�} |� | � t� � � � | � t|j�jg�} � �fdd �} | �| � �� �� � j |� � S ) a0 Return a L{Deferred} firing with a L{MyClientFactory} and L{MyServerFactory} connected pair, and the listening C{Port}. The particularity is that the server protocol has been obtained after doing a C{adoptStreamConnection} against the original server connection. rX rY rZ c s0 � � | j� � �| j� � �| j�� t�� d S rm )� removeReaderrg � removeWriterrY r� r )r� )rI r] rK rL �firstServerConnected� s z_UNIXAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.firstServerConnectedc s � j r� �� | S rm )�runningr� )r� )rI rK rL r� � s zOUNIXAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.stopc s | \}}� � ||�f� d S rm )rt )rc ra r] )�deferredr� rK rL r� � s zPUNIXAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.start)r2 r �protocolConnectionMade�protocolConnectionLostr1 r r} r� r r� r� r� r� r_ ) rE rI rf rg � firstServerra rG rm � lostDeferredr� � startDeferredr� rK )ro r� rI r] rL rh � s4 � � zAUNIXAdoptStreamConnectionTestsBuilder.getConnectedClientAndServerN) rN rO rP r$ r% r& rW r^ rj rh rK rK rK rL rV F s � "rV c @ s6 e Zd ZdZefZdZedd� �Zdd� Z dd� Z dS ) �UnixClientTestsBuilderz7 Define tests for L{IReactorUNIX.connectUNIX}. Nc C s | j du r t| �| _ | j S )z� Return a path usable by C{connectUNIX} and C{listenUNIX}. @return: A path instance, built with C{_abstractPath}. N)�_pathrU rk rK rK rL rG � s zUnixClientTestsBuilder.pathc C � |� | j|�S )z� Start an UNIX server with the given C{factory}. @param reactor: The reactor to create the UNIX port in. @param factory: The server factory. @return: A UNIX port instance. )r} rG �rE rI rH rK rK rL r@ � � z UnixClientTestsBuilder.listenc C rw )z� Start an UNIX client with the given C{factory}. @param reactor: The reactor to create the connection in. @param factory: The client factory. @return: A UNIX connector instance. )r� rG rx rK rK rL �connect� ry z UnixClientTestsBuilder.connect) rN rO rP rQ r& rW rv �propertyrG r@ rz rK rK rK rL ru � s ru )jrQ �hashlibr �osr r r r r �pprintr r r r r r �structr �tempfiler r �typingr r r �unittestr r �_AF_UNIX� ImportError�zope.interfacer r �twisted.internetr r �twisted.internet.addressr �twisted.internet.deferr r r �twisted.internet.endpointsr r �twisted.internet.errorr r! r" �twisted.internet.interfacesr# r$ r% r& �twisted.internet.protocolr' r( r) �twisted.internet.taskr* �&twisted.internet.test.connectionmixinsr+ r, r- r. r/ �#twisted.internet.test.reactormixinsr0 � twisted.internet.test.test_tcpr1 r2 r3 r4 �twisted.python.compatr5 �twisted.python.failurer6 �twisted.python.filepathr7 �twisted.python.logr8 r9 r: �twisted.python.reflectr; �twisted.python.runtimer< r� r8 r> rU rV rc rq r{ r: r> rL rM rR rU rV �globals�update�makeTestCaseClassesru rK rK rK rL �<module> s� � �%> Y!- � � ~-PK Mb�ZZ�B{ܸ ܸ 2 internet/test/__pycache__/test_tcp.cpython-310.pycnu �[��� o �b}� � @ s� d Z ddlZddlZddlZddlZddlZddlmZ ddlm Z m Z m Z m Z m Z mZ ddlmZ ddlmZmZ ddlmZmZ ddlZddlmZmZ dd lm Z m Z m Z m Z m Z m!Z! dd l"m#Z#m$Z$ dd l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. dd l/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9 dd l:m;Z;m<Z<m=Z= ddl>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZE ddlFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZO ddlPmQZQmRZRmSZS ddlTmUZU ddlVmWZW ddlXmYZY ddlZm[Z[ ddl\m]Z]m^Z^ ddl_m`Z`maZambZbmcZc ddldmeZemfZfmgZg zddlhmiZi W n ej�y dZkY n w ddllmmZm dZkdZnze�ejoejp�Znen�qd � W n er�yN Zs z dZtd es� �ZuW Y dZs[sn dZs[sww dZtd Zuendu�r\en�v� e[�w� �rmdd lxmyZy eyjzZ{dZ|n zdd lxm}Z} W n ej�y� d!d"� Z{Y nw e}j~Z{dZ|d#d$� Zd%d&� Z�G d'd(� d(�Z�G d)d*� d*eg�Z�G d+d,� d,e<�Z�ee5�G d-d.� d.��Z�ee5e�� G d/d0� d0eg�Z�G d1d2� d2eg�Z�G d3d4� d4eJ�Z�G d5d6� d6e��Z�ee8�G d7d8� d8��Z�G d9d:� d:eQeIeM�Z�G d;d<� d<e��Z�eeteu�G d=d>� d>e���Z�G d?d@� d@eQ�Z�G dAdB� dBe��Z�eeteu�G dCdD� dDe���Z�dEdF� Z�G dGdH� dHe�Z�ee��ejnddI�G dJdK� dK���Z�ee|dL�G dMdN� dNef��Z�dOdP� Z�ee|dL�G dQdR� dRef��Z�G dSdT� dTeK�Z�G dUdV� dV�Z�G dWdX� dXe��Z�G dYdZ� dZe��Z�G d[d\� d\�Z�G d]d^� d^eQe�e�e��Z�G d_d`� d`eQe�e�e��Z�G dadb� dbe<�Z�dcdd� Z�dedf� Z�dgdh� Z�G didj� djeQ�Z�G dkdl� dl�Z�G dmdn� dn�Z�G dodp� dpe�e�eQ�Z�G dqdr� dre�e�eQ�Z�e�� ��e���� � e�� ��e���� � e�� ��e���� � e�� ��e���� � e�� ��e���� � e�� ��e���� � e�� ��e���� � e�� ��e���� � e�� ��e���� � G dsdt� dteH�Z�G dudv� dveH�Z�G dwdx� dxeH�Z�G dydz� dze��Z�G d{d|� d|eH�Z�G d}d~� d~eH�Z�G dd�� d�eH�Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�eH�Z�G d�d�� d�eH�Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d�e��Z�G d�d�� d��Z�G d�d�� d�eQe��Z�e�� ��e���� � eeteu�G d�d�� d�eg��Z�G d�d�� d�ef�Z�ee|dL�G d�d�� d�ef��Z�G d�d�� d�ef�Z�dS )�zU Tests for implementations of L{IReactorTCP} and the TCP parts of L{IReactorSocket}. � N��wraps)�Callable�ClassVar�List�Optional�Sequence�Type)�skipIf)� Interface� implementer)� verifyClass� verifyObject)� IPv4Address� IPv6Address)�Deferred� DeferredList�fail� gatherResults� maybeDeferred�succeed)�TCP4ClientEndpoint�TCP4ServerEndpoint) �ConnectBindError�ConnectionAborted�ConnectionClosed�ConnectionDone�ConnectionLost�ConnectionRefusedError�DNSLookupError� NoProtocol� UserError) � IConnector�IHalfCloseableProtocol�ILoggingContext� IPullProducer� IPushProducer� IReactorFDSet�IReactorSocket� IReactorTCP�IResolverSimple� ITLSTransport)� ClientFactory�Protocol� ServerFactory)� Connection�Server� _BuffersLogs�_FileDescriptorReservation�_IFileDescriptorReservation� _NullFileDescriptorReservation� _resolveIPv6) �BrokenContextFactory�ConnectableProtocol�ConnectionTestsMixin�EndpointCreator�LogObserverMixin�Stop�StreamClientTestsMixin� findFreePort�runProtocolsWithReactor)�ReactorBuilder�needsRunningReactor� stopOnError)�Logger)�log)�Failure)�platform)� MemoryReactor�StringTransport)�ClientStartStopFactory�ClosingFactory�MyClientFactory�MyServerFactory)�SkipTest�SynchronousTestCase�TestCase)�SSLF)�ClientContextFactoryT)�::1r zIPv6 not available. � )� _win32ifaces)� _posixifacesc C s g S �N� rV rV rV �@/usr/lib/python3/dist-packages/twisted/internet/test/test_tcp.py�<lambda>� � rX c C s t � } | r | d S td��)al Find and return a configured link local IPv6 address including a scope identifier using the % separation syntax. If the system has no link local IPv6 addresses, raise L{SkipTest} instead. @raise SkipTest: if no link local address can be found or if the C{netifaces} module is not available. @return: a C{str} giving the address r z#Link local IPv6 address unavailable)�getLinkLocalIPv6AddressesrL )� addressesrV rV rW �getLinkLocalIPv6Address� s r\ c C sD |\}}d|v s d|v rt �||�d d }n||f}| �|� dS )a7 Connect a socket to the given destination. @param client: A C{socket.socket}. @param destination: A tuple of (host, port). The host is a C{str}, the port a C{int}. If the C{host} is an IPv6 IP, the address is resolved using C{getaddrinfo} and the first version found is used. �%�:r � N)�socket� getaddrinfo�connect)�client� destination�host�port�addressrV rV rW rb � s rb c @ �P e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )� FakeSocketz� A fake for L{socket.socket} objects. @ivar data: A C{str} giving the data which will be returned from L{FakeSocket.recv}. @ivar sendBuffer: A C{list} of the objects passed to L{FakeSocket.send}. c C s || _ g | _d S rU )�data� sendBuffer��selfrj rV rV rW �__init__� s zFakeSocket.__init__c C � || _ d S rU )�blocking)rm rp rV rV rW � setblocking� � zFakeSocket.setblockingc C s | j S rU �rj )rm �sizerV rV rW �recv� s zFakeSocket.recvc C s | j �|� t|�S )z� I{Send} all of C{bytes} by accumulating it into C{self.sendBuffer}. @return: The length of C{bytes}, indicating all the data has been accepted. )rk �append�len�rm �bytesrV rV rW �send� s zFakeSocket.sendc C � dS )z� Shutdown is not implemented. The method is provided since real sockets have it and some code expects it. No behavior of L{FakeSocket} is affected by a call to it. NrV )rm �howrV rV rW �shutdown� rY zFakeSocket.shutdownc C r{ )z� Close is not implemented. The method is provided since real sockets have it and some code expects it. No behavior of L{FakeSocket} is affected by a call to it. NrV �rm rV rV rW �close� rY zFakeSocket.closec G r{ )z� Setsockopt is not implemented. The method is provided since real sockets have it and some code expects it. No behavior of L{FakeSocket} is affected by a call to it. NrV )rm �argsrV rV rW � setsockopt� rY zFakeSocket.setsockoptc C r{ )z� Return a fake file descriptor. If actually used, this will have no connection to this L{FakeSocket} and will probably cause surprising results. � rV r~ rV rV rW �fileno� s zFakeSocket.filenoN) �__name__� __module__� __qualname__�__doc__rn rq ru rz r} r r� r� rV rV rV rW ri � s ri c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �FakeSocketTestszT Test that the FakeSocket can be used by the doRead method of L{Connection} c C s$ t d�}|�d� | �|jd� d S )N� someDatar )ri rq � assertEqualrp �rm �sktrV rV rW � test_blocking� s z FakeSocketTests.test_blockingc C s t d�}| �|�d�d� d S )Nr� � )ri r� ru r� rV rV rW � test_recv� s zFakeSocketTests.test_recvc C s2 t d�}|�d�}| �|d� | �|jdg� dS )z� L{FakeSocket.send} accepts the entire string passed to it, adds it to its send buffer, and returns its length. � s foo� N)ri rz r� rk )rm r� �countrV rV rW � test_send� s zFakeSocketTests.test_sendN)r� r� r� r� r� r� r� rV rV rV rW r� � s r� c @ � e Zd ZdZdd� ZdS )� FakeProtocolzL An L{IProtocol} that returns a value from its dataReceived method. c C r{ )zq Return something other than L{None} to trigger a deprecation warning for that behavior. rV rV rl rV rV rW � dataReceived s zFakeProtocol.dataReceivedN�r� r� r� r� r� rV rV rV rW r� � r� c @ rh )�_FakeFDSetReactora� An in-memory implementation of L{IReactorFDSet}, which records the current sets of active L{IReadDescriptor} and L{IWriteDescriptor}s. @ivar _readers: The set of L{IReadDescriptor}s active on this L{_FakeFDSetReactor} @type _readers: L{set} @ivar _writers: The set of L{IWriteDescriptor}s active on this L{_FakeFDSetReactor} @ivar _writers: L{set} c C s t � | _t � | _d S rU )�set�_readers�_writersr~ rV rV rW rn � z_FakeFDSetReactor.__init__c C � | j �|� d S rU )r� �add�rm �readerrV rV rW � addReader � z_FakeFDSetReactor.addReaderc C � || j v r | j �|� d S d S rU )r� �remover� rV rV rW � removeReader# � �z _FakeFDSetReactor.removeReaderc C r� rU )r� r� �rm �writerrV rV rW � addWriter' r� z_FakeFDSetReactor.addWriterc C r� rU )r� r� r� rV rV rW � removeWriter* r� z _FakeFDSetReactor.removeWriterc C s | � � | �� }| �� |S rU )� getReaders� getWritersrn �rm �resultrV rV rW � removeAll. s z_FakeFDSetReactor.removeAllc C � t | j�S rU )�listr� r~ rV rV rW r� 3 rr z _FakeFDSetReactor.getReadersc C r� rU )r� r� r~ rV rV rW r� 6 rr z _FakeFDSetReactor.getWritersN) r� r� r� r� rn r� r� r� r� r� r� r� rV rV rV rW r� s r� c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �TCPServerTestsz< Whitebox tests for L{twisted.internet.tcp.Server}. c C sH t � | _G dd� d�}td�| _t� | _t| j| jd|� d | j�| _d S )Nc @ � e Zd ZdZdS )z&TCPServerTests.setUp.<locals>.FakePortr� N)r� r� r� �_realPortNumberrV rV rV rW �FakePortE � r� r� )rR r )r� �reactorri r� r- �protocolr0 �server)rm r� rV rV rW �setUpB s �zTCPServerTests.setUpc C s4 | j �ttd��� | j �d� | �| jjg � dS )zq L{Server.write} discards bytes passed to it if called after it has lost its connection. �Simulated lost connection� hello worldN)r� �connectionLostrD � Exception�writer� r� rk r~ rV rV rW �test_writeAfterDisconnectN s z(TCPServerTests.test_writeAfterDisconnectc C � d| j _| �� dS )z� L{Server.write} discards bytes passed to it if called after it has lost its connection when the connection had started TLS. TN)r� �TLSr� r~ rV rV rW �!test_writeAfterDisconnectAfterTLSW � z0TCPServerTests.test_writeAfterDisconnectAfterTLSc C s6 | j �ttd��� | j �dg� | �| jjg � dS )zy L{Server.writeSequence} discards bytes passed to it if called after it has lost its connection. r� r� N)r� r� rD r� � writeSequencer� r� rk r~ rV rV rW �!test_writeSequenceAfterDisconnect_ s z0TCPServerTests.test_writeSequenceAfterDisconnectc C r� )z� L{Server.writeSequence} discards bytes passed to it if called after it has lost its connection when the connection had started TLS. TN)r� r� r� r~ rV rV rW �)test_writeSequenceAfterDisconnectAfterTLSh r� z8TCPServerTests.test_writeSequenceAfterDisconnectAfterTLSN) r� r� r� r� r� r� r� r� r� rV rV rV rW r� = s r� c @ s4 e Zd ZdZdd� Zdd� Zee d�dd� �Zd S ) �TCPConnectionTestsz@ Whitebox tests for L{twisted.internet.tcp.Connection}. c C sj t d�}t� }t||�}|�� | �tjg�}| �|d d t� | �|d d d� | �t|�d� dS )z� When an L{IProtocol} implementation that returns a value from its C{dataReceived} method, a deprecated warning is emitted. r� r �category�messagez�Returning a value other than None from twisted.internet.test.test_tcp.FakeProtocol.dataReceived is deprecated since Twisted 11.0.0.r� N) ri r� r/ �doRead� flushWarningsr� r� �DeprecationWarningrw )rm r� r� �conn�warningsrV rV rW �test_doReadWarningIsRaisedv s �z-TCPConnectionTests.test_doReadWarningIsRaisedc C s( t d�}t� }t||�}| �|j� dS )z The C{TLS} attribute of a L{Connection} instance is C{False} before L{Connection.startTLS} is called. r� N)ri r� r/ � assertFalser� �rm r� r� r� rV rV rW �test_noTLSBeforeStartTLS� s z+TCPConnectionTests.test_noTLSBeforeStartTLSzNo SSL support availablec C sB t d�}t� }t||t� d�}d|_|�t� d� | �|j� dS )z} The C{TLS} attribute of a L{Connection} instance is C{True} after L{Connection.startTLS} is called. r� �r� TN) ri r� r/ r� �_tlsClientDefault�startTLSrP � assertTruer� r� rV rV rW �test_tlsAfterStartTLS� s z(TCPConnectionTests.test_tlsAfterStartTLSN) r� r� r� r� r� r� r �useSSLr� rV rV rV rW r� q s r� c @ s$ e Zd ZdZdZdd� Zdd� ZdS )� TCPCreatorzO Create IPv4 TCP endpoints for L{runProtocolsWithReactor}-based tests. � 127.0.0.1c C s t |d| jd�S )z4 Create a server-side TCP endpoint. r �� interface)r r� )rm r� rV rV rW r� � � zTCPCreator.serverc C s t || j|j�S )z� Create a client end point that will connect to the given address. @type serverAddress: L{IPv4Address} )r r� rf )rm r� � serverAddressrV rV rW rc � � zTCPCreator.clientN)r� r� r� r� r� r� rc rV rV rV rW r� � s r� c @ r� )� TCP6CreatoraV Create IPv6 TCP endpoints for C{ReactorBuilder.runProtocolsWithReactor}-based tests. The endpoint types in question here are still the TCP4 variety, since these simply pass through IPv6 address literals to the reactor, and we are only testing address literals, not name resolution (as name resolution has not yet been implemented). See http://twistedmatrix.com/trac/ticket/4470 for more specific information about new endpoint classes. The naming is slightly misleading, but presumably if you're passing an IPv6 literal, you know what you're asking for. c C � t � | _d S rU �r\ r� r~ rV rV rW rn � � zTCP6Creator.__init__N)r� r� r� r� rn rV rV rV rW r� � s r� c @ � e Zd ZdZdd� Zdd� ZdS )� FakeResolverzR A resolver implementation based on a C{dict} mapping names to addresses. c C ro rU )�names)rm r� rV rV rW rn � rr zFakeResolver.__init__c C s4 zt | j| �W S ty ttd| �� Y S w )z� Return the address mapped to C{name} if it exists, or raise a C{DNSLookupError}. @param name: The name to resolve. @param timeout: The lookup timeout, ignore here. zFakeResolver couldn't find )r r� �KeyErrorr r )rm �name�timeoutrV rV rW � getHostByName� s �zFakeResolver.getHostByNameN)r� r� r� r� rn r� rV rV rV rW r� � s r� c @ sZ e Zd ZdZefZdZedd� �Zedd� �Z dd� Z d d � Z d d � Z d d� Z dd� ZdS )�TCPClientTestsBasea� Base class for builders defining tests related to L{IReactorTCP.connectTCP}. Classes which uses this in must provide all of the documented instance variables in order to specify how the test works. These are documented as instance variables rather than declared as methods due to some peculiar inheritance ordering concerns, but they are effectively abstract methods. @ivar endpoints: A client/server endpoint creator appropriate to the address family being tested. @type endpoints: L{twisted.internet.test.connectionmixins.EndpointCreator} @ivar interface: An IP address literal to locally bind a socket to as well as to connect to. This can be any valid interface for the local host. @type interface: C{str} @ivar port: An unused local listening port to listen on and connect to. This will be used in conjunction with the C{interface}. (Depending on what they're testing, some tests will locate their own port with L{findFreePort} instead.) @type port: C{int} @ivar family: an address family constant, such as L{socket.AF_INET}, L{socket.AF_INET6}, or L{socket.AF_UNIX}, which indicates the address family of the transport type under test. @type family: C{int} @ivar addressClass: the L{twisted.internet.interfaces.IAddress} implementor associated with the transport type under test. Must also be a 3-argument callable which produces an instance of same. @type addressClass: C{type} @ivar fakeDomainName: A fake domain name to use, to simulate hostname resolution and to distinguish between hostnames and IP addresses where necessary. @type fakeDomainName: C{str} Nc C s( | j dur | j �� jS t| j| j�d S )z� Return the port number to connect to, using C{self._port} set up by C{listen} if available. @return: The port number to connect to. @rtype: C{int} Nr� )�_port�getHostrf r= r� �familyr~ rV rV rW rf s zTCPClientTestsBase.portc C s | j jS )zK Return the interface attribute from the endpoints object. )� endpointsr� r~ rV rV rW r� s z TCPClientTestsBase.interfacec C s |j d|| jd�| _| jS )z� Start a TCP server with the given C{factory}. @param reactor: The reactor to create the TCP port in. @param factory: The server factory. @return: A TCP port instance. r r� )� listenTCPr� r� �rm r� �factoryrV rV rW �listen s zTCPClientTestsBase.listenc C s |� | j| j|�S )z� Start a TCP client with the given C{factory}. @param reactor: The reactor to create the connection in. @param factory: The client factory. @return: A TCP connector instance. )� connectTCPr� rf r� rV rV rW rb - s zTCPClientTestsBase.connectc s� t � ���� �t� }�|_t��� G dd� dt�� �j����|�}� ��fdd�}|� |�}�fdd�}dd� }|� ||� �fd d �}|� |�}|� t j � �fd d �} |� | � ���� d S )zr When the factory's C{buildProtocol} returns L{None} the connection is gracefully closed. c @ � e Zd Zdd� ZdS )zETCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.NoneFactoryc S � d S rU rV �rm rg rV rV rW � buildProtocolG � zSTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.NoneFactory.buildProtocolN�r� r� r� r� rV rV rV rW � NoneFactoryF � r� c s" � � }�j ��| �� �}|�|�S rU )r� rc r� rb )rf � clientFactory�endpoint)r� r� rm rV rW �listenedL s zBTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.listenedc s � � d| f � d S )NzUStream client endpoint connect succeeded with %r, should have failed with NoProtocol.)r �r� r~ rV rW �connectSucceededS s ��zJTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.connectSucceededc S s | � t� d S rU )�trapr )�reasonrV rV rW � connectFailedY � zGTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.connectFailedc s � S rU rV ��ignored)r� rV rW � connected^ s zCTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.connectedc s � � � d S rU ��stopr r� rV rW � disconnectedi � zFTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.disconnectedN)r � buildReactorrK �protocolConnectionLostrA r. r� r� r� � addCallback� addCallbacks� addErrbackrC �err� runReactor) rm � serverFactory� listeningr � connectingr r r � disconnectingr rV )r� r� r� rm rW � test_buildProtocolReturnsNone9 s$ z0TCPClientTestsBase.test_buildProtocolReturnsNonec s� t �j�j�dd� \}}��� ��j���t��ji�� �jdt� t �|d���� � }dddd��G ��fdd�dt �}t ��� |� _ � ����fdd �}t�|� ���� � jrd��� j�� � d ��d j�d jt�d ��}|gtt��j� j�d d d d� � }|gtt��j|j�d d d d� � }�� �d �j dg|�R � � �� �d �j dg|�R � � �� t �d �|� dS )a� A client's transport's C{getHost} and C{getPeer} return L{IPv4Address} instances which have the dotted-quad string form of the resolved address of the local and remote endpoints of the connection respectively as their C{host} attribute, not the hostname originally passed in to L{connectTCP<twisted.internet.interfaces.IReactorTCP.connectTCP>}, if a hostname was used. N� r r� )re �peer�instancec � e Zd Z� �fdd�ZdS )z7TCPClientTestsBase.test_addresses.<locals>.CheckAddressc s, |� � �d< |�� �d< |�d< � �� d S )Nre r r )r� �getPeerr �rm � transport�r� � transportDatarV rW �makeConnection� s zFTCPClientTestsBase.test_addresses.<locals>.CheckAddress.makeConnectionN�r� r� r� r% rV r# rV rW � CheckAddress� � r' c sl t �j�j�} �j| d f}t�d|� �� z�j���� j� |d� W n ty. Y q w | d � _ d S )NTr� z!Connect attempt with bindAddress )� bindAddress) r= r� r� rC �msgr� r� rf r � boundPort)rf r) )r � fakeDomainr� rm r� rV rW � connectMe� s � � z4TCPClientTestsBase.test_addresses.<locals>.connectMez<{} to {} at {:x}>r ���r� re �TCPr ) r= r� r� r �fakeDomainName�installResolverr� r� r. � forProtocolr- r� r; r� r@ r � failReasonr � getTraceback�format� __class__�addr�idr� r` ra r+ rf r� � addressClass�repr) rm re r r� r' r- � transportReprr+ � serverPortrV )r r, r� rm r� r$ rW �test_addressest s> � � � � z!TCPClientTestsBase.test_addressesc s� �� � �t� � g �t�t�}�jd|�jd�}�j��|� � �}t � }t|_ |� |��� ��fdd���fdd������fdd�}t �|� ���� ��t��d d �� �� t�d t�re�d �� �d d krotd ����tjt�d �� d S )z� If the context factory passed to L{ITCPTransport.startTLS} raises an exception from its C{getContext} method, that exception is raised by L{ITCPTransport.startTLS}. r r� c s6 t �| j�s ��d� d S ����t| jj� �� d S )N�skip)r+ � providedByr" rv � assertRaises� ValueErrorr� r )� brokenFactory�resultsrm rV rW r � s ��z5TCPClientTestsBase.test_badContext.<locals>.connectedc s � � | � d S rU �rv )�failure)rC rV rW r � r z9TCPClientTestsBase.test_badContext.<locals>.connectFailedc s* � � �� � ��� � ��fdd�� d S )Nc � � � � S rU r ��ignr� rV rW rX � � zETCPClientTestsBase.test_badContext.<locals>.whenRun.<locals>.<lambda>)r r �addBothrV )�connectDeferredr r r� rV rW �whenRun� s z3TCPClientTestsBase.test_badContext.<locals>.whenRunr� z more than one callback result: r> z&Reactor does not support ITLSTransportN)r r6 r. r2 r- r� r� r� rc r� r, r� rb r@ r r� rw � isinstancerD �raiseExceptionrL r� �str)rm r rf r r rL rV )rB rK r r r� rC rm rW �test_badContext� s( z"TCPClientTestsBase.test_badContext)r� r� r� r� r) �requiredInterfacesr� �propertyrf r� r� rb r r= rP rV rV rV rW r� � s & ; Jr� c @ s$ e Zd ZdZdZejZeZ e � Z dS )�TCP4ClientTestsBuilderze Builder configured with IPv4 parameters for tests related to L{IReactorTCP.connectTCP}. z some-fake.domain.example.comN) r� r� r� r� r0 r` �AF_INETr� r r9 r� r� rV rV rV rW rS � s rS c @ s" e Zd ZdZejZeZdd� Z dS )�TCP6ClientTestsBuilderze Builder configured with IPv6 parameters for tests related to L{IReactorTCP.connectTCP}. c C s t � | _| jj| _d S rU )r� r� r� r0 r~ rV rV rW r� s z TCP6ClientTestsBuilder.setUpN) r� r� r� r� r` �AF_INET6r� r r9 r� rV rV rV rW rU � s rU c @ s. e Zd ZdZefZdd� Zdd� Zdd� ZdS ) �TCPConnectorTestsBuilderzU Tests for the L{IConnector} provider returned by L{IReactorTCP.connectTCP}. c s� t � }| �� � � jd|| jd�}||_|�� j}g �g �t� }��fdd�|_�j|_ � � | j||�}| � t � |�� |�� }| �|jd� | �|j| j� | �|j|� |j�� fdd�� | �� � �d �t� | ��||g� dS )aU L{IReactorTCP.connectTCP} returns an object which provides L{IConnector}. The destination of the connector is the address which was passed to C{connectTCP}. The same connector object is passed to the factory's C{startedConnecting} method as to the factory's C{clientConnectionLost} method. r r� c s � � | ��� |�fS rU rD �� connectorr )�seenConnectors� seenFailuresrV rW rX . s �zATCPConnectorTestsBuilder.test_connectorIdentity.<locals>.<lambda>r/ c rF rU r ��_r� rV rW rX ; rI N)rI r r� r� rf r� rH �clientConnectionLostrv �startedConnectingr� r� r" r? �getDestinationr� �typere � whenStoppedrJ r r r )rm r �tcpPort� portNumberr rY �destrV )r� rZ r[ rW �test_connectorIdentity s( z/TCPConnectorTestsBuilder.test_connectorIdentityc s� t � }��� ��jd|�jd�}|�� j�g ���fdd�}t� � |� _� j� �fdd�� �� � ���fdd�� �� �� �rJ�� �d � � � � j�t� ��� jd� d S ) z� Calling L{IConnector.stopConnecting} in C{Factory.startedConnecting} results in C{Factory.clientConnectionFailed} being called with L{error.UserError} as the reason. r r� c s8 z| � � W d S ty � �t� � ��� Y d S w rU )�stopConnectingr� rv rD r )rY )� fatalErrorsr� rV rW r_ O s �zATCPConnectorTestsBuilder.test_userFail.<locals>.startedConnectingc rF rU r r\ r� rV rW rX Y rI z8TCPConnectorTestsBuilder.test_userFail.<locals>.<lambda>c s �� �j�� �S rU )r� r� rV )r rd r� rm rV rW rX \ s r� N)rK r r� r� r� rf rH r_ rb rJ �callWhenRunningr r r4 r r r! r� �failed)rm r rc r_ rV )r rh rd r� rm rW � test_userFailB s" � z&TCPConnectorTestsBuilder.test_userFailc s� t � }| �� ��jd|| jd�}||_|�� j}t� � dd� }|� _��| j|� � g �� ��fdd�}� j � |� | � �� � j � t� | ��dg� dS ) z� Calling L{IConnector.connect} in C{Factory.clientConnectionLost} causes a new connection attempt to be made. r r� c S � | � � d S rU )rb rX rV rV rW r^ s r� zETCPConnectorTestsBuilder.test_reconnect.<locals>.clientConnectionLostc s$ � j }��|j|jf� ��� d S rU )r� rv �made�closedr )r �p�r �protocolMadeAndClosedr� rV rW �reconnectFailed{ s z@TCPConnectorTestsBuilder.test_reconnect.<locals>.reconnectFailed)r� r� N)rI r r� r� rf r� rJ r^ r� � failDeferredr r r r r r� )rm r rc rd r^ rr rV rp rW �test_reconnectf s z'TCPConnectorTestsBuilder.test_reconnectN) r� r� r� r� r) rQ rf rk rt rV rV rV rW rW s & $rW c @ s e Zd ZdZejZeZdS )�TCP4ConnectorTestsBuilderr� N) r� r� r� r� r` rT r� r r9 rV rV rV rW ru � s ru c @ s e Zd ZejZeZdd� ZdS )�TCP6ConnectorTestsBuilderc C r� rU r� r~ rV rV rW r� � r� z TCP6ConnectorTestsBuilder.setUpN) r� r� r� r` rV r� r r9 r� rV rV rV rW rv � s rv c C s t � ||�}| �|j� |S )z� Create a socket for the duration of the given test. @param test: the test to add cleanup to. @param addressFamily: an C{AF_*} constant @param socketType: a C{SOCK_*} constant. @return: a socket object. )r` � addCleanupr )�test� addressFamily� socketTyper� rV rV rW �createTestSocket� s r{ c @ r� ) �_IExhaustsFileDescriptorsz% A way to trigger C{EMFILE}. c C r{ )z� Open file descriptors until C{EMFILE} is reached. This can raise any exception except an L{OSError} whose C{errno} is C{EMFILE}. Any exception raised to the caller implies L{release}. NrV rV rV rV rW �exhaust� rY z!_IExhaustsFileDescriptors.exhaustc C r{ �zD Release all file descriptors opened by L{exhaust}. NrV rV rV rV rW �release� rY z!_IExhaustsFileDescriptors.releasec C r{ )�� Return the number of opened file descriptors. @return: The number of opened file descriptors; this will be zero if this instance has not opened any. @rtype: L{int} NrV rV rV rV rW r� � rY z _IExhaustsFileDescriptors.countN�r� r� r� r� r} r r� rV rV rV rW r| � s r| )� auto_attribsc @ s� e Zd ZU dZe� Zee ed< ej dd� dd�Z e g e f ed< ej e jdd�Ze e gdf ed < ej e�e�ddd �Zee ed < d d � Zdd� Zdd� ZdS )�_ExhaustsFileDescriptorsa_ A class that triggers C{EMFILE} by creating as many file descriptors as necessary. @ivar fileDescriptorFactory: A factory that creates a new file descriptor. @type fileDescriptorFactory: A L{callable} that accepts no arguments and returns an integral file descriptor, suitable for passing to L{os.close}. �_logc C s t �d�S �Nr )�os�duprV rV rV rW rX � s z!_ExhaustsFileDescriptors.<lambda>F)�defaultr: �_fileDescriptorFactoryN�_close)r� �initr: �_fileDescriptorsc C s� t �� z* z| �� }W n ty% } z |jtjkr W Y d}~n � d}~ww | j�|� qW n ty: | � � � w | j j d| � � d� dS )zC Open file descriptors until C{EMFILE} is reached. TNzCEMFILE reached by opening {openedFileDescriptors} file descriptors.)�openedFileDescriptors) �gc�collectr� �OSError�errno�EMFILEr� rv r� r r� �infor� �rm �fd�erV rV rW r} � s, �� � � �z _ExhaustsFileDescriptors.exhaustc C s` | j r.| j �� }z| �|� W n ty( } z |jtjkr#W Y d}~q � d}~ww | j sdS dS r~ )r� �popr� r� r� �EBADFr� rV rV rW r � s ���z _ExhaustsFileDescriptors.releasec C r� )r� )rw r� r~ rV rV rW r� s z _ExhaustsFileDescriptors.count)r� r� r� r� rB r� r �__annotations__�attr�ibr� r �intr� r r� �Factoryr� r� r r} r r� rV rV rV rW r� � s �" � r� �9Reserved EMFILE file descriptor not supported on Windows.c @ �` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )� ExhaustsFileDescriptorsTestsz0 Tests for L{_ExhaustsFileDescriptors}. c C s t � | _| �| jj� d S rU )r� � exhausterrw r r~ rV rV rW r� s z"ExhaustsFileDescriptorsTests.setUpc C s t tj��� dS )z` Attempt to open a file; if successful, the file is immediately closed. N)�openr� �devnullr r~ rV rV rW � openAFile � z&ExhaustsFileDescriptorsTests.openAFilec C � t t| j� dS )ze L{_ExhaustsFileDescriptors} instances provide L{_IExhaustsFileDescriptors}. N)r r| r� r~ rV rV rW �test_providesInterface! � z3ExhaustsFileDescriptorsTests.test_providesInterfacec C sN | � | j�� d� | j�� | �| j�� d� | j�� | � | j�� d� dS )zh L{_ExhaustsFileDescriptors.count} returns the number of open file descriptors. r N)r� r� r� r} � assertGreaterr r~ rV rV rW � test_count( s z'ExhaustsFileDescriptorsTests.test_countc C s: | � | jj� | j�� | �t| j�}| �|jtj � dS )z{ L{_ExhaustsFileDescriptors.exhaust} causes the process to exhaust its available file descriptors. N) rw r� r r} r@ �IOErrorr� r� r� r� )rm � exceptionrV rV rW �test_exhaustTriggersEMFILE3 s z7ExhaustsFileDescriptorsTests.test_exhaustTriggersEMFILEc C s" dd� }t |�}| �t|j� dS )z� An L{OSError} raised within L{_ExhaustsFileDescriptors.exhaust} with an C{errno} other than C{EMFILE} is reraised to the caller. c S s t tjd d��)Nr� z Not EMFILE)r� r� r� rV rV rV rW � raiseOSErrorD r� zLExhaustsFileDescriptorsTests.test_exhaustRaisesOSError.<locals>.raiseOSErrorN)r� r@ r� r} )rm r� r� rV rV rW �test_exhaustRaisesOSError= s z6ExhaustsFileDescriptorsTests.test_exhaustRaisesOSErrorc C s | j �� | j �� | �� dS )zc L{_ExhaustsFileDescriptors.release} releases all opened file descriptors. N)r� r} r r� r~ rV rV rW � test_releaseJ s z)ExhaustsFileDescriptorsTests.test_releasec s� g � � fdd�}t |�}| �|j� | �t|j� | �t� �d� | �|�� d� � D ]}| �t t j |�}| �|j t j � q+dS )z� L{_ExhaustsFileDescriptors.exhaust} closes any opened file descriptors if an exception occurs during its exhaustion loop. c s, t � �dkr td��t�d�} � �| � | S )Nr� z9test_fileDescriptorsReleasedOnFailure fake open exceptionr )rw rA r� r� rv �r� ��fileDescriptorsrV rW �failsAfterThree[ s � z[ExhaustsFileDescriptorsTests.test_fileDescriptorsReleasedOnFailure.<locals>.failsAfterThreer� r N)r� rw r r@ rA r} r� rw r� r� r� �fstatr� r� )rm r� r� r� r� rV r� rW �%test_fileDescriptorsReleasedOnFailureT s �zBExhaustsFileDescriptorsTests.test_fileDescriptorsReleasedOnFailurec sf g � � fdd�}t |�}| �|j� |�� | �|�� d� t�� d � |�� | �|�� d� dS )z� L{_ExhaustsFileDescriptors.release} continues to close opened file descriptors even when closing one fails with C{EBADF}. c s t �d�} � �| � | S r� )r� r� rv r� r� rV rW �recordFileDescriptorsw s zTExhaustsFileDescriptorsTests.test_releaseIgnoresEBADF.<locals>.recordFileDescriptorsr N) r� rw r r} r� r� r� r r� )rm r� r� rV r� rW �test_releaseIgnoresEBADFp s z5ExhaustsFileDescriptorsTests.test_releaseIgnoresEBADFc s^ g � � fdd�}dd� }t ||d�}| �|�� d� |�� | �|�� d� | �t|j� dS )z� An L{OSError} raised within L{_ExhaustsFileDescriptors.release} with an C{errno} other than C{EBADF} is reraised to the caller. c s* t � �dkr ttjd��� �d� � d S )Nr� zToo many filesr. )rw r� r� r� rv rV ��fakeFileDescriptorsrV rW � opensThree� s zJExhaustsFileDescriptorsTests.test_releaseRaisesOSError.<locals>.opensThreec S s t dd��)N� z&test_releaseRaisesOSError fake OSError)r� r� rV rV rW � failingClose� rr zLExhaustsFileDescriptorsTests.test_releaseRaisesOSError.<locals>.failingClose)r r N)r� r� r� r} r� r@ r� r )rm r� r� r� rV r� rW �test_releaseRaisesOSError� s z6ExhaustsFileDescriptorsTests.test_releaseRaisesOSErrorN)r� r� r� r� r� r� r� r� r� r� r� r� r� r� rV rV rV rW r� s r� c s� | � � j� t� }t� }||_dg���fdd�}|�|� |�|�} | �� } t� } |�| | � ��� j � � �fdd�} | j � | � | j � | � |�� g } |� | j � | �| d� | �| j � | �| j � | �t| jj� dS )a# Assert that an L{IListeningPort} immediately closes an accepted peer socket when the number of open file descriptors exceeds the soft resource limit. @param testCase: The test case under which to run this assertion. @type testCase: L{trial.unittest.SynchronousTestCase} @param exhauster: The file descriptor exhauster. @type exhauster: L{_ExhaustsFileDescriptors} @param reactor: The reactor under test. @param runReactor: A callable that will synchronously run the provided reactor. @param listen: A callback to bind to a port. @type listen: A L{callable} that accepts two arguments: the provided C{reactor}; and a L{ServerFactory}. It must return an L{IListeningPort} provider. @param connect: A callback to connect a client to the listening port. @type connect: A L{callable} that accepts three arguments: the provided C{reactor}; the address returned by L{IListeningPort.getHost}; and a L{ClientFactory}. Its return value is ignored. Fc s � � � d�d< d S )NTr r r\ )r� �serverConnectionCompletedrV rW �stopReactorIfServerAccepted� r� z=assertPeerClosedOnEMFILE.<locals>.stopReactorIfServerAcceptedc s � � � ��� | S rU )r r �r� )r� r� rV rW �"stopReactorAndCloseFileDescriptors� s zDassertPeerClosedOnEMFILE.<locals>.stopReactorAndCloseFileDescriptorsz1Server accepted connection; EMFILE not triggered.N)rw r rK r �protocolConnectionMader r� rJ ri r} �deferredrJ rs rv r� �assertNoResult�successResultOfr@ r � lostReasonrN )�testCaser� r� r r� rb r �serverConnectionMader� rf � listeningHostr r� �noResultrV )r� r� r� rW �assertPeerClosedOnEMFILE� s2 $ �r� c @ s> e Zd ZdZee�G dd� d��Zdd� Zdd� Zdd � Z d S ) � AssertPeerClosedOnEMFILETestsz0 Tests for L{assertPeerClosedOnEMFILE}. c @ r� ) z+AssertPeerClosedOnEMFILETests.NullExhausterz1 An exhauster that does nothing. c C r{ )zB See L{_IExhaustsFileDescriptors.exhaust} NrV r~ rV rV rW r} � rY z3AssertPeerClosedOnEMFILETests.NullExhauster.exhaustc C r{ )zB See L{_IExhaustsFileDescriptors.release} NrV r~ rV rV rW r � rY z3AssertPeerClosedOnEMFILETests.NullExhauster.releasec C r{ )z@ See L{_IExhaustsFileDescriptors.count} NrV r~ rV rV rW r� rY z1AssertPeerClosedOnEMFILETests.NullExhauster.countNr� rV rV rV rW � NullExhauster� s r� c C s t � | _t� | _d S rU )rF r� rM r� r~ rV rV rW r� r� z#AssertPeerClosedOnEMFILETests.setUpc C s t t| �� � dS )zZ L{NullExhauster} instances provide L{_IExhaustsFileDescriptors}. N)r r| r� r~ rV rV rW �#test_nullExhausterProvidesInterface r� zAAssertPeerClosedOnEMFILETests.test_nullExhausterProvidesInterfacec sr | � � }dg� � fdd�}� fdd�}dd� }| j| jjt| j|| j|||d�}| �d t|�� | �| jj � dS ) z� If the exhauster fails to trigger C{EMFILE} and a connection reaches the server, the reactor is stopped and the test fails. Nc s. | � � � d �tddd��}|�t� � d S )Nr r/ r� i� )�runr� r r% rG )r� �proto�r rV rW r s �z[AssertPeerClosedOnEMFILETests.test_reactorStoppedOnSuccessfulConnection.<locals>.runReactorc s" | � dd|�}|�� |� d< |S )Nr� i� r )r� �doStart)r� r� rf r� rV rW r� " s zWAssertPeerClosedOnEMFILETests.test_reactorStoppedOnSuccessfulConnection.<locals>.listenc S s | � dd|� d S )Nr� r )r� )r� rg r� rV rV rW rb ( s zXAssertPeerClosedOnEMFILETests.test_reactorStoppedOnSuccessfulConnection.<locals>.connect�r� r� r� r r� rb r� ) r� r@ r� �failureExceptionr� r� �assertInrO r� �running)rm r� r r� rb r� rV r� rW �)test_reactorStoppedOnSuccessfulConnection s" � zGAssertPeerClosedOnEMFILETests.test_reactorStoppedOnSuccessfulConnectionN) r� r� r� r� r r| r� r� r� r� rV rV rV rW r� � s r� c @ s2 e Zd ZdZdd� Zdd� Zeed�dd� �Zd S ) �StreamTransportTestsMixinzR Mixin defining tests which apply to any port/connection based transport. c C s` | � � }| �� }tt�G dd� dt��}|� }| �||�}| �|d�}| �|f|d d � dS )zt When a port starts, a message including a description of the associated factory is logged. c @ r� )zNStreamTransportTestsMixin.test_startedListeningLogMessage.<locals>.SomeFactoryc S r{ )N� Crazy FactoryrV r~ rV rV rW � logPrefixI r� zXStreamTransportTestsMixin.test_startedListeningLogMessage.<locals>.SomeFactory.logPrefixN)r� r� r� r� rV rV rV rW � SomeFactoryG s r� r� r r� N)�observer r r$ r. �getListeningPort�#getExpectedStartListeningLogMessager� )rm �loggedMessagesr� r� r� ro �expectedMessagerV rV rW � test_startedListeningLogMessage? s z9StreamTransportTestsMixin.test_startedListeningLogMessagec sz g ��fdd�� | � � �| ��t� ��| ���}t�� � � �fdd��� ��fdd�}��|� ��� | �|�� dS )z� When a connection is lost, an informative message should be logged (see L{getExpectedConnectionLostLogMsg}): an address identifying the port and the fact that it was closed. c s � � t�| �� d S rU )rv rC �textFromEventDict)� eventDict)r� rV rW �logConnectionLostMsgZ s zQStreamTransportTestsMixin.test_connectionLostLogMsg.<locals>.logConnectionLostMsgc s t �� � ��� d S rU )rC �removeObserverr r )r� r� rV rW � stopReactorb s zHStreamTransportTestsMixin.test_connectionLostLogMsg.<locals>.stopReactorc s t �� � t�j���� d S rU )rC � addObserverr � stopListeningr rV )r� ro r� rV rW �doStopListeningf s zLStreamTransportTestsMixin.test_connectionLostLogMsg.<locals>.doStopListeningN) r r� r. � getExpectedConnectionLostLogMsgrC r� ri r� r� )rm r� r� rV )r� r� ro r� r� rW �test_connectionLostLogMsgQ s z3StreamTransportTestsMixin.test_connectionLostLogMsgr� c C s$ t | t� | �� | j| j| jd� dS )z2 See L{assertPeerClosedOnEMFILE}. r� N)r� r� r r r� �connectToListenerr~ rV rV rW �test_closePeerOnEMFILEo s �z0StreamTransportTestsMixin.test_closePeerOnEMFILEN) r� r� r� r� r� r� r � SKIP_EMFILEr� rV rV rV rW r� : s r� c @ � e Zd ZdZdZdd� ZdS )�ConnectToTCPListenerMixina^ Provides L{connectToListener} for TCP transports. @ivar LISTENER_HOST: The host on which the port is expected to be listening. This is specific to avoid compatibility issues with Windows, which cannot connect to the wildcard host. @type LISTENER_HOST: L{str} @see: U{http://twistedmatrix.com/trac/ticket/1472} r� c C s |� | j|j|�S )a� Connect to the given listening TCP port. @param reactor: The reactor under test. @type reactor: L{IReactorTCP} @param address: The listening port's address. Only the C{port} component is used; see L{LISTENER_HOST}. @type address: L{IPv4Address} or L{IPv6Address} @param factory: The client factory. @type factory: L{ClientFactory} @return: The connector )r� � LISTENER_HOSTrf )rm r� rg r� rV rV rW r� � s z+ConnectToTCPListenerMixin.connectToListenerN)r� r� r� r� r� r� rV rV rV rW r� ~ s r� c @ � e Zd ZdZddd�ZdS )�ListenTCPMixinzT Mixin which uses L{IReactorTCP.listenTCP} to hand out listening TCP ports. r rR c C s |j |||d�S )z0 Get a TCP port from a reactor. r� )r� )rm r� r� rf r� rV rV rW r� � r� z ListenTCPMixin.getListeningPortN�r rR �r� r� r� r� r� rV rV rV rW r� � s r� c @ r� )�SocketTCPMixinza Mixin which uses L{IReactorSocket.adoptStreamPort} to hand out listening TCP ports. r rR c C s� t �|�rOd|v rtj}t�||�d d }ntj}||f}t�|�}|�|� |�d� |�d� z|� |� � |j |�W |� � |� � S |� � |� � w t d��)zi Get a TCP port from a reactor, wrapping an already-initialized file descriptor. r^ r r_ r� Fz'Reactor does not provide IReactorSocket)r( r? r` rV ra rT �bindr� rq �adoptStreamPortr� r� r rL )rm r� r� rf r� �domainrg �portSockrV rV rW r� � s& � � z SocketTCPMixin.getListeningPortNr� r� rV rV rV rW r� � s r� c @ s� e Zd ZU dZefZeeee e d< dd� Z dd� Z dd� Z eee�d d � �Zeee�d d � �Zd d� Zdd� Zeee�dd� �Zeee�dd� �Zdd� Zdd� Zeee�dd� �Zeee�dd � �Zd d � Zeee�d d � �Z eee�d!d"� �Z d#S )$�TCPPortTestsMixinz, Tests for L{IReactorTCP.listenTCP} rQ c C s d||� � jf S )zY Get the message expected to be logged when a TCP port starts listening. z%s starting on %d�r� rf )rm rf r� rV rV rW r� � � z5TCPPortTestsMixin.getExpectedStartListeningLogMessagec C s d|� � j� d�S )zJ Get the expected connection lost message for a TCP port. z (TCP Port z Closed)r� )rm rf rV rV rW r� � r� z1TCPPortTestsMixin.getExpectedConnectionLostLogMsgc C s. | � � }| �|t� �}|�� }| �|t� dS )z� When no interface is passed to L{IReactorTCP.listenTCP}, the returned listening port listens on an IPv4 address. N)r r� r. r� �assertIsInstancer )rm r� rf rg rV rV rW �test_portGetHostOnIPv4� s z(TCPPortTestsMixin.test_portGetHostOnIPv4c C sh | � � }ttjdd�dd� \}}| �|t� ||�}|�� }| �|t� | � d|j � | � ||j � dS )z� When listening on an IPv6 address, L{IListeningPort.getHost} returns an L{IPv6Address} with C{host} and C{port} attributes reflecting the address the port is bound to. rQ )r� r� Nr ) r r= r` rV r� r. r� r� r r� re rf )rm r� re rd rf rg rV rV rW �test_portGetHostOnIPv6� s z(TCPPortTestsMixin.test_portGetHostOnIPv6c C sF t � }| �� }| �|t� d|�}|�� }| �|t� | �||j� dS )a( When a link-local IPv6 address including a scope identifier is passed as the C{interface} argument to L{IReactorTCP.listenTCP}, the resulting L{IListeningPort} reports its address as an L{IPv6Address} with a host value that includes the scope identifier. r N) r\ r r� r. r� r� r r� re )rm � linkLocalr� rf rg rV rV rW � test_portGetHostOnIPv6ScopeID� s z/TCPPortTestsMixin.test_portGetHostOnIPv6ScopeIDc s� G � fdd�dt �}|� }| �� � | �� |d|�}|�d� zt||�� j|�� jf� W n tyJ } z| � |j t j t j f� W Y d}~nd}~ww | � � � |jS )a Connect C{client} to a server listening on C{interface} started with L{IReactorTCP.listenTCP} and return the address passed to the factory's C{buildProtocol} method. @param client: A C{SOCK_STREAM} L{socket.socket} created with an address family such that it will be able to connect to a server listening on C{interface}. @param interface: A C{str} giving an address for a server to listen on. This should almost certainly be the loopback address for some address family supported by L{IReactorTCP.listenTCP}. @return: Whatever object, probably an L{IAddress} provider, is passed to a server factory's C{buildProtocol} method when C{client} establishes a connection. c s e Zd Z� fdd�ZdS )zCTCPPortTestsMixin._buildProtocolAddressTest.<locals>.ObserveAddressc s � � � || _t� S rU )r �observedAddressr- r� r� rV rW r� s zQTCPPortTestsMixin._buildProtocolAddressTest.<locals>.ObserveAddress.buildProtocolNr� rV r� rV rW �ObserveAddress s r r FN)r. r r� rq rb r� re rf r� r� r� � EINPROGRESS� EWOULDBLOCKr r )rm rc r� r r� rf r� rV r� rW �_buildProtocolAddressTest s "�� z+TCPPortTestsMixin._buildProtocolAddressTestc C s@ d}t | tjtj�}| �||�}| �tdg|�� �R � |� dS )z� When a connection is accepted over IPv4, an L{IPv4Address} is passed to the factory's C{buildProtocol} method giving the peer's address. r� r/ N)r{ r` rT � SOCK_STREAMr r� r � getsockname)rm r� rc r rV rV rW � test_buildProtocolIPv4Address1 s z/TCPPortTestsMixin.test_buildProtocolIPv4Addressc C sV d}t | tjtj�}| �||�}|�� }t�|tj�d }| �t d||d �|� dS )z� When a connection is accepted to an IPv6 address, an L{IPv6Address} is passed to the factory's C{buildProtocol} method giving the peer's address. rQ r r/ r� N) r{ r` rV r r r � getnameinfo�NI_NUMERICHOSTr� r �rm r� rc r r �hostnamerV rV rW � test_buildProtocolIPv6Address; s z/TCPPortTestsMixin.test_buildProtocolIPv6Addressc C sb t � }t| tjtj�}| �||�}|�� }t�|tj�d }| � t d|g|dd� �R � |� dS )z� When a connection is accepted to a link-local IPv6 address, an L{IPv6Address} is passed to the factory's C{buildProtocol} method giving the peer's address, including a scope identifier. r r/ r� N) r\ r{ r` rV r r r r r r� r r rV rV rW �$test_buildProtocolIPv6AddressScopeIDK s &z6TCPPortTestsMixin.test_buildProtocolIPv6AddressScopeIDc s� G � �fdd�dt �}| �� � t� }||_| �� |d|�}|�d� zt||�� j|�� j f� W n t yN } z| � |j t j t jf� W Y d}~nd}~ww | �� � |jS )a� Connect C{client} to a server listening on C{interface} started with L{IReactorTCP.listenTCP} and return the address returned by one of the server transport's address lookup methods, C{getHost} or C{getPeer}. @param client: A C{SOCK_STREAM} L{socket.socket} created with an address family such that it will be able to connect to a server listening on C{interface}. @param interface: A C{str} giving an address for a server to listen on. This should almost certainly be the loopback address for some address family supported by L{IReactorTCP.listenTCP}. @param which: A C{str} equal to either C{"getHost"} or C{"getPeer"} determining which address will be returned. @return: Whatever object, probably an L{IAddress} provider, is returned from the method indicated by C{which}. c r )zITCPPortTestsMixin._serverGetConnectionAddressTest.<locals>.ObserveAddressc s � � � t|��� | j_d S rU )r �getattrr� rg r! �r� �whichrV rW r% q s zXTCPPortTestsMixin._serverGetConnectionAddressTest.<locals>.ObserveAddress.makeConnectionNr& rV r rV rW r p r( r r FN)r- r r. r� r� rq rb r� re rf r� r� r� r r r rg )rm rc r� r r r� rf r� rV r rW � _serverGetConnectionAddressTest[ s "�� z1TCPPortTestsMixin._serverGetConnectionAddressTestc C �B d}t | tjtj�}| �||d�}| �tdg|�� �R � |� dS )z� When a connection is accepted over IPv4, the server L{ITransport.getHost} method returns an L{IPv4Address} giving the address on which the server accepted the connection. r� r� r/ N)r{ r` rT r r r� r � getpeername)rm r� rc � hostAddressrV rV rW �test_serverGetHostOnIPv4� � z*TCPPortTestsMixin.test_serverGetHostOnIPv4c C �b d}t | tjtj�}| �||d�}|�� }t�|tj�d }| �t d|g|dd� �R � |� dS )z� When a connection is accepted over IPv6, the server L{ITransport.getHost} method returns an L{IPv6Address} giving the address on which the server accepted the connection. rQ r� r r/ r� N) r{ r` rV r r r r r r� r �rm r� rc r r r rV rV rW �test_serverGetHostOnIPv6� � &z*TCPPortTestsMixin.test_serverGetHostOnIPv6c C �d t � }t| tjtj�}| �||d�}|�� }t�|tj�d }| � t d|g|dd� �R � |� dS )z� When a connection is accepted over IPv6, the server L{ITransport.getHost} method returns an L{IPv6Address} giving the address on which the server accepted the connection, including the scope identifier. r� r r/ r� N) r\ r{ r` rV r r r r r r� r r rV rV rW � test_serverGetHostOnIPv6ScopeID� � &z1TCPPortTestsMixin.test_serverGetHostOnIPv6ScopeIDc C r )z� When a connection is accepted over IPv4, the server L{ITransport.getPeer} method returns an L{IPv4Address} giving the address of the remote end of the connection. r� r r/ N)r{ r` rT r r r� r r )rm r� rc � peerAddressrV rV rW �test_serverGetPeerOnIPv4� r z*TCPPortTestsMixin.test_serverGetPeerOnIPv4c C r )z� When a connection is accepted over IPv6, the server L{ITransport.getPeer} method returns an L{IPv6Address} giving the address on the remote end of the connection. rQ r r r/ r� N) r{ r` rV r r r r r r� r �rm r� rc r" r r rV rV rW �test_serverGetPeerOnIPv6� r z*TCPPortTestsMixin.test_serverGetPeerOnIPv6c C r )z� When a connection is accepted over IPv6, the server L{ITransport.getPeer} method returns an L{IPv6Address} giving the address on the remote end of the connection, including the scope identifier. r r r/ r� N) r\ r{ r` rV r r r r r r� r r$ rV rV rW � test_serverGetPeerOnIPv6ScopeID� r! z1TCPPortTestsMixin.test_serverGetPeerOnIPv6ScopeIDN) r� r� r� r� r) rQ r r r r r� r� r� r r �ipv6Skip�ipv6SkipReasonr r r r r r r r r r r# r% r& rV rV rV rW r� � s6 & & r� c @ � e Zd ZdS )�TCPPortTestsBuilderN�r� r� r� rV rV rV rW r* � � r* c @ r) )�TCPFDPortTestsBuilderNr+ rV rV rV rW r- � r, r- c @ r� ) �StopStartReadingProtocolzD Protocol that pauses and resumes the transport a few times c C s d| _ | �d� d S )Nr� r� )rj �pauseResumeProducingr~ rV rV rW �connectionMade� s z'StopStartReadingProtocol.connectionMadec C sP | j �� | j �� |r| jj�d| j|d � dS | jj�d| jjj| � dS )z? Toggle transport read state, then count down. r r� N) r" �pauseProducing�resumeProducingr� r� � callLaterr/ �ready�callback)rm �counterrV rV rW r/ � s z-StopStartReadingProtocol.pauseResumeProducingc C sD t �dt|�� | j|7 _t| j�dkr | jj�| j� d S d S )Nzgot datai @ )rC r* rw rj r� r r5 rl rV rV rW r� s �z%StopStartReadingProtocol.dataReceivedN)r� r� r� r� r0 r/ r� rV rV rV rW r. � s r. c s t � �� fdd��}|S )aG Decorate a L{ReactorBuilder} test function which tests one reactor and one connected transport. Run that test method in the context of C{connectionMade}, and immediately drop the connection (and end the test) when that completes. @param testMethod: A unit test method on a L{ReactorBuilder} test suite; taking two additional parameters; a C{reactor} as built by the L{ReactorBuilder}, and an L{ITCPTransport} provider. @type testMethod: 3-argument C{function} @return: a no-argument test method. @rtype: 1-argument C{function} c s8 t � �G � ��fdd�dt �}|� }t� |�t� � d S )Nc s e Zd Z� ��fdd�ZdS )zBoneTransportTest.<locals>.actualTestMethod.<locals>.ServerProtocolc sp z!�� | j | j� W | jd ur| j�� �jd ur �j�� d S d S | jd ur,| j�� �jd ur7�j�� w w rU )r� r" �loseConnectionr~ ��builder�other� testMethodrV rW r0 s � � �zQoneTransportTest.<locals>.actualTestMethod.<locals>.ServerProtocol.connectionMadeN�r� r� r� r0 rV r8 rV rW �ServerProtocol s r= )r7 r> r� )r9 r= �serverProtocol�r; )r9 r: rW �actualTestMethod s z*oneTransportTest.<locals>.actualTestMethodr )r; r@ rV r? rW �oneTransportTest s rA c C s< t �|�r| �||�� � dS | �||j� | �|j� dS )a^ Use the given test to assert that the given transport is actively reading in the given reactor. @note: Maintainers; for more information on why this is a function rather than a method on a test case, see U{this document on how we structure test tools <http://twistedmatrix.com/trac/wiki/Design/KeepTestToolsOutOfFixtures>} @param testCase: a test case to perform the assertion upon. @type testCase: L{TestCase} @param reactor: A reactor, possibly one providing L{IReactorFDSet}, or an IOCP reactor. @param transport: An L{ITCPTransport} N)r' r? r� r� �handlesr� �reading�r� r� r" rV rV rW � assertReading+ s rE c C s. t �|�r| �||�� � dS | �|j� dS )ae Use the given test to assert that the given transport is I{not} actively reading in the given reactor. @note: Maintainers; for more information on why this is a function rather than a method on a test case, see U{this document on how we structure test tools <http://twistedmatrix.com/trac/wiki/Design/KeepTestToolsOutOfFixtures>} @param testCase: a test case to perform the assertion upon. @type testCase: L{TestCase} @param reactor: A reactor, possibly one providing L{IReactorFDSet}, or an IOCP reactor. @param transport: An L{ITCPTransport} N)r' r? � assertNotInr� r� rC rD rV rV rW �assertNotReadingE s rG c @ sR e Zd ZdZefZdd� Zedd� �Zedd� �Z edd � �Z d d � Z d d � Z dS )�TCPConnectionTestsBuilderzP Builder defining tests relating to L{twisted.internet.tcp.Connection}. c s� t � ���� ��_ddg}�jj}||v r t�� r td��t�_ t � �_ t � �_ �� d��}|�� j}� ���fdd�}�fdd�� t�d |�}t� }t|_ t|�|��j g��||�}|�tj� ���� d S ) zt This test verifies transport socket read state after multiple pause/resumeProducing calls. � Glib2Reactor� Gtk2Reactorz.This test is broken on gtk/glib under Windows.r c sn �� | d � �� | d � | d d | d d f} | d j�dd dd � �j�� | |���fdd��S )zL Send several IOCPReactor's buffers' worth of data. r r� � x� � yc rF rU r rG r� rV rW rX � rI zRTCPConnectionTestsBuilder.test_stopStartReading.<locals>.proceed.<locals>.<lambda>)r� r" r� r r )�protosrf ��cleanupr� rm �sfrV rW �proceedx s �z@TCPConnectionTestsBuilder.test_stopStartReading.<locals>.proceedc sF � � | dd dd d� tt|d jj�t|d jj�t|j�g�S )z� Make sure IOCPReactor didn't start several WSARecv operations that clobbered each other's results. rK rL rM zdid not get the right datar r� )r� r r r" r7 r� )rj rN rf r~ rV rW rP � s ���z@TCPConnectionTestsBuilder.test_stopStartReading.<locals>.cleanupr� N)r. r r� r6 r� rE � isWindowsrL r. r� r r4 r r� r� rf r r, r- r rb r r rC r r ) rm �skippedReactors�reactorClassNamero rf rR �cc�cf�drV rO rW �test_stopStartReadinge s& z/TCPConnectionTestsBuilder.test_stopStartReadingc C s, |� � t| ||� |�� t| ||� dS )zz When a L{Server} is connected, its C{resumeProducing} method adds it as a reader to the reactor. N)r1 rG r2 rE �rm r� r� rV rV rW �test_resumeProducing� s z.TCPConnectionTestsBuilder.test_resumeProducingc C s |� � |�� t| ||� dS )z� When a L{Server} has already started disconnecting via C{loseConnection}, its C{resumeProducing} method does not add it as a reader to its reactor. N)r7 r2 rG rZ rV rV rW �&test_resumeProducingWhileDisconnecting� s z@TCPConnectionTestsBuilder.test_resumeProducingWhileDisconnectingc C s6 |� ttd��� t| ||� |�� t| ||� dS )z� When a L{Server} has already lost its connection, its C{resumeProducing} method does not add it as a reader to its reactor. �dummyN)r� rD r� rG r2 rZ rV rV rW �%test_resumeProducingWhileDisconnected� s z?TCPConnectionTestsBuilder.test_resumeProducingWhileDisconnectedc C sN G dd� dt �}G dd� dt �}|� }t| ||� t� � | �|jg d�� dS )a� Alice connects to Bob. Alice writes some bytes and then shuts down the connection. Bob receives the bytes from the connection and then pauses the transport object. Shortly afterwards Bob resumes the transport object. At that point, Bob is notified that the connection has been closed. This is no problem for most reactors. The underlying event notification API will probably just remind them that the connection has been closed. It is a little tricky for win32eventreactor (MsgWaitForMultipleObjects). MsgWaitForMultipleObjects will only deliver the close notification once. The reactor needs to remember that notification until Bob resumes the transport. c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) zQTCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Pauserc S � g | _ d S rU )�eventsr~ rV rV rW rn � rr zZTCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Pauser.__init__c S s* | j �d� | j�� | j�d| j� d S )N�pausedr )r` rv r" r1 r� r3 �resumerx rV rV rW r� � s z^TCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Pauser.dataReceivedc S s | j �d� | j�� d S )N�resumed)r` rv r" r2 r~ rV rV rW rb � � zXTCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Pauser.resumec S s | j �d� t�| |� d S )N�lost)r` rv r7 r� �rm r rV rV rW r� � � z`TCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Pauser.connectionLostN)r� r� r� rn r� rb r� rV rV rV rW �Pauser� s rh c @ r� )zQTCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Clientc S s | j �d� | j �� d S )Ns some bytes for you)r" r� r7 r~ rV rV rW r0 � rd z`TCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Client.connectionMadeNr< rV rV rV rW �Client� r� ri )ra rc re N)r7 r> r� r� r` )rm rh ri �pauserrV rV rW �'test_connectionLostAfterPausedTransport� s zATCPConnectionTestsBuilder.test_connectionLostAfterPausedTransportc C s@ t t�G dd� dt��}G dd� dt�}t| |� |� t� � dS )a- If one side half-closes its connection, and then the other side of the connection calls C{loseWriteConnection}, and then C{loseConnection} in {writeConnectionLost}, the connection is closed correctly. This rather obscure case used to fail (see ticket #3037). c @ s e Zd Zdd� Zdd� ZdS )zHTCPConnectionTestsBuilder.test_doubleHalfClose.<locals>.ListenerProtocolc S � | j �� d S rU )r" �loseWriteConnectionr~ rV rV rW �readConnectionLost� r z[TCPConnectionTestsBuilder.test_doubleHalfClose.<locals>.ListenerProtocol.readConnectionLostc S rl rU �r" r7 r~ rV rV rW �writeConnectionLost� r z\TCPConnectionTestsBuilder.test_doubleHalfClose.<locals>.ListenerProtocol.writeConnectionLostN)r� r� r� rn rp rV rV rV rW �ListenerProtocol� s rq c @ r� )z>TCPConnectionTestsBuilder.test_doubleHalfClose.<locals>.Clientc S rl rU ro r~ rV rV rW r0 � r zMTCPConnectionTestsBuilder.test_doubleHalfClose.<locals>.Client.connectionMadeNr< rV rV rV rW ri � r� ri N)r r# r7 r> r� )rm rq ri rV rV rW �test_doubleHalfClose� s z.TCPConnectionTestsBuilder.test_doubleHalfCloseN) r� r� r� r� r) rQ rY rA r[ r\ r^ rk rr rV rV rV rW rH ^ s 8 +rH c @ sT e Zd ZU dZefZeeee e d< dd� Z dd� Z dd� Z d d � Zd d � Zd S )�WriteSequenceTestsMixinzM Test for L{twisted.internet.abstract.FileDescriptor.writeSequence}. rQ c C s$ t |dd�dur ||_dS ||_dS )z� Set the write buffer size for the given transport, mananing possible differences (ie, IOCP). Bug #4322 should remove the need of that hack. �writeBufferSizeN)r rt � bufferSize)rm r" �valuerV rV rW �setWriteBufferSize s z*WriteSequenceTestsMixin.setWriteBufferSizec �H � fdd�}� � � }� �|dtj�}|�|� |�tj� � �|� dS )zV C{writeSequence} sends the data even if C{write} hasn't been called. c s2 | \� }}� �fdd�}||_ � j�g d�� d S )Nc s( t �d| � ��| d� � j�� d S )Nzdata received: %rs Some sequence splitted)rC r* r� r" r7 rs )rc rm rV rW r� s z^WriteSequenceTestsMixin.test_writeSequeceWithoutWrite.<locals>.connected.<locals>.dataReceived)s Some s sequence s splitted)r� r" r� )� protocolsr� rf r� r~ )rc rW r s zHWriteSequenceTestsMixin.test_writeSequeceWithoutWrite.<locals>.connectedr� N� r �getConnectedClientAndServerr` rT r r rC r r �rm r r� rX rV r~ rW � test_writeSequeceWithoutWrite s z5WriteSequenceTestsMixin.test_writeSequeceWithoutWritec rx )zo C{writeSequence} with an element in the sequence of type unicode raises C{TypeError}. c s< | \}}}� � t|jjdg�}� �t|�d� |j�� d S )NzUnicode is not kosherzData must be bytes)r@ � TypeErrorr" r� r� rO r7 )ry rc r� rf �excr~ rV rW r 0 s �zWWriteSequenceTestsMixin.test_writeSequenceWithUnicodeRaisesException.<locals>.connectedr� Nrz r| rV r~ rW �,test_writeSequenceWithUnicodeRaisesException* s zDWriteSequenceTestsMixin.test_writeSequenceWithUnicodeRaisesExceptionc sx t t�G dd� d��}|� � � �fdd�}��� }��|dtj�}|�|� |�tj � �� |� �� � j ddg� dS ) z{ C{writeSequence} pauses its streaming producer if too much data is buffered, and then resumes it. c @ s4 e Zd ZdZdZdd� Zdd� Zdd� Zdd � ZdS ) zJWriteSequenceTestsMixin.test_streamingProducer.<locals>.SaveActionProducerNc S r_ rU ��actionsr~ rV rV rW rn L rr zSWriteSequenceTestsMixin.test_streamingProducer.<locals>.SaveActionProducer.__init__c S � | j �d� d S )N�pause�r� rv r~ rV rV rW r1 O r� zYWriteSequenceTestsMixin.test_streamingProducer.<locals>.SaveActionProducer.pauseProducingc S s( | j �d� | jj�� | jj�� d S )Nrb )r� rv rc r" �unregisterProducerr� r7 r~ rV rV rW r2 R s zZWriteSequenceTestsMixin.test_streamingProducer.<locals>.SaveActionProducer.resumeProducingc S r� �Nr r� r~ rV rV rW � stopProducing\ r� zXWriteSequenceTestsMixin.test_streamingProducer.<locals>.SaveActionProducer.stopProducing) r� r� r� rc r� rn r1 r2 r� rV rV rV rW �SaveActionProducerG s r� c sl | d d� \}}|� _ |� _|j�� d� ��� jg � ��|jd� |j�dgd � ��� jdg� d S )Nr T�� �2 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx� r� )rc r� r" �registerProducerr� r� rw r� �ry rc r� ��producerrm rV rW r a s zAWriteSequenceTestsMixin.test_streamingProducer.<locals>.connectedr� r� rb N) r r& r r{ r` rT r r rC r r r� r� �rm r� r r� rX rV r� rW �test_streamingProducerA s z.WriteSequenceTestsMixin.test_streamingProducerc s� ��t t�G �fdd�d��}|� � � �fdd�}��� }��|dtj�}|�|� |�tj � �� |� �� � j ddg� dS )z� C{writeSequence} pauses its producer if too much data is buffered only if this is a streaming producer. c s, e Zd ZdZdd� Z� fdd�Zdd� ZdS )zMWriteSequenceTestsMixin.test_nonStreamingProducer.<locals>.SaveActionProducerNc S r_ rU r� r~ rV rV rW rn � rr zVWriteSequenceTestsMixin.test_nonStreamingProducer.<locals>.SaveActionProducer.__init__c sT | j �d� | j �d�dkr| jj�� d S � �| jjd� | jj�dgd � d S )Nrb r r� r� r� )r� rv r� rc r" � stopConsumingrw r� r~ �rx rV rW r2 � s z]WriteSequenceTestsMixin.test_nonStreamingProducer.<locals>.SaveActionProducer.resumeProducingc S r� r� r� r~ rV rV rW r� � r� z[WriteSequenceTestsMixin.test_nonStreamingProducer.<locals>.SaveActionProducer.stopProducing)r� r� r� rc rn r2 r� rV r� rV rW r� } s r� c s0 | d }|� _ |j�� d� ��� jdg� d S )Nr Frb )rc r" r� r� r� )ry rc r� rV rW r � s zDWriteSequenceTestsMixin.test_nonStreamingProducer.<locals>.connectedr� rb N) r r% r r{ r` rT r r rC r r r� r� r� rV )r� rm rx rW �test_nonStreamingProducerv s z1WriteSequenceTestsMixin.test_nonStreamingProducerN)r� r� r� r� r) rQ r r r r r� rw r} r� r� r� rV rV rV rW rs s 5rs c @ s: e Zd ZdZdd� Zdd� Zdd� Zeee �dd � �Z d S ) �"TCPTransportServerAddressTestMixinzE Test mixing for TCP server address building and log prefix. c C s t � �)z� Helper method returnine a L{Deferred} firing with a tuple of a client protocol, a server protocol, and a running TCP port. )�NotImplementedError)rm r� r� ry rV rV rW r{ � s z>TCPTransportServerAddressTestMixin.getConnectedClientAndServerc sJ � ��fdd�}�� � }��|�|�}|�|� |�tj� ��|� dS )zT Helper method to test TCP server addresses on either IPv4 or IPv6. c s� | \}}}zA�� d|jj|�� jf t|j�� �� d|jj�f |jj� |jj\}�� |� � �� d|j � �� �|j � W |j� � d S |j� � w )Nz <AccumulatingProtocol #%s on %s>zAccumulatingProtocol,%s,%sr/ ) r� r" � sessionnor� rf rO �logstrr� � peerAddressesr� ra re r7 )ry rc r� rf r" �� adressClassr� rm rV rW r � s& �� �� zHTCPTransportServerAddressTestMixin._testServerAddress.<locals>.connectedN)r r{ r r rC r r )rm r� ry r� r r� rX rV r� rW �_testServerAddress� s z5TCPTransportServerAddressTestMixin._testServerAddressc C s | � dtjt�S )z� L{Server} instances have a string representation indicating on which port they're running, and the connected address is stored on the C{peerAddresses} attribute of the factory. r� )r� r` rT r r~ rV rV rW �test_serverAddressTCP4� r� z9TCPTransportServerAddressTestMixin.test_serverAddressTCP4c C s | � t� tjt�S )z� IPv6 L{Server} instances have a string representation indicating on which port they're running, and the connected address is stored on the C{peerAddresses} attribute of the factory. )r� r\ r` rV r r~ rV rV rW �test_serverAddressTCP6� s �z9TCPTransportServerAddressTestMixin.test_serverAddressTCP6N) r� r� r� r� r{ r� r� r r' r( r� rV rV rV rW r� � s "r� c @ r� )�TCPTransportTestsBuilderzT Test standard L{ITCPTransport}s built with C{listenTCP} and C{connectTCP}. c s� t � }t� |_t� |_t� }t� |_t� |_�jd||d��t|j|jg�}�fdd�}|�|� t|j|jg�}t� � � �fdd�} |�| � �� |�� � j |� � S )z� Return a L{Deferred} firing with a L{MyClientFactory} and L{MyServerFactory} connected pair, and the listening C{Port}. r r� c s � � � | S rU r r� r� rV rW r � s zBTCPTransportTestsBuilder.getConnectedClientAndServer.<locals>.stopc �8 | \}}t �d| � t �d| � � �||�f� d S �Nzclient connected %szserver connected %s�rC r* r5 r� �r� rf rV rW �start � zCTCPTransportTestsBuilder.getConnectedClientAndServer.<locals>.start) rK r r� r rJ r� r rJ r r� r� rf ) rm r� r� ry r� rc � lostDeferredr � startDeferredr� rV )r� rf r� rW r{ � s( � � z4TCPTransportTestsBuilder.getConnectedClientAndServerN)r� r� r� r� r{ rV rV rV rW r� � s r� c @ s e Zd ZdZeefZdd� ZdS )�!AdoptStreamConnectionTestsBuilderzF Test server transports built using C{adoptStreamConnection}. c s� t � }t� |_t � �t� �_t� �_t� }t� |_t� |_�jd||d��� ��fdd�}|j�|� t|j�jg�}�fdd�}|�|� t� ��� |� t|j�jg�} ��fdd�} | �| � �� |�� � j |� �S ) a0 Return a L{Deferred} firing with a L{MyClientFactory} and L{MyServerFactory} connected pair, and the listening C{Port}. The particularity is that the server protocol has been obtained after doing a C{adoptStreamConnection} against the original server connection. r r� c s0 �� | j� ��| j� ��| j�� � �� d S rU )r� r" r� �adoptStreamConnectionr� )r� )ry r� r� rV rW �firtServerConnected5 s �zZAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.firtServerConnectedc s � j r� �� | S rU )r� r r� r� rV rW r B s zKAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.stopc r� r� r� r� r� rV rW r� P r� zLAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.start) rK r r� r rJ r� r r rJ r r� r� rf ) rm r� r� ry � firstServerrc r� r� r r� r� rV )ry r� rf r� r� rW r{ ! s2 � � z=AdoptStreamConnectionTestsBuilder.getConnectedClientAndServerN)r� r� r� r� r' r( rQ r{ rV rV rV rW r� s r� c @ r� )�ServerAbortsTwicez' Call abortConnection() twice. c C s | j �� | j �� d S rU )r" �abortConnectionrl rV rV rW r� l � z ServerAbortsTwice.dataReceivedNr� rV rV rV rW r� g r� r� c @ r� )�ServerAbortsThenLosesz> Call abortConnection() followed by loseConnection(). c C s | j �� | j �� d S rU )r" r� r7 rl rV rV rW r� v r� z"ServerAbortsThenLoses.dataReceivedNr� rV rV rV rW r� q r� r� c @ r� )�AbortServerWritingProtocolz4 Protocol that writes data upon connection. c C s | j �d� dS )zW Tell the client that the connection is set up and it's time to abort. s readyN�r" r� r~ rV rV rW r0 � r� z)AbortServerWritingProtocol.connectionMadeN�r� r� r� r� r0 rV rV rV rW r� { r� r� c @ r� )�ReadAbortServerProtocolz� Server that should never receive any data, except 'X's which are written by the other side of the connection before abortConnection, and so might possibly arrive. c C s |� dd�r td��d S )N� Xr� zUnexpectedly received data.)�replacer� rl rV rV rW r� � s �z$ReadAbortServerProtocol.dataReceivedNr� rV rV rV rW r� � s r� c @ r� )� NoReadServerz� Stop reading immediately on connection. This simulates a lost connection that will cause the other side to time out, and therefore call abortConnection(). c C rl rU )r" � stopReadingr~ rV rV rW r0 � r zNoReadServer.connectionMadeNr� rV rV rV rW r� � s r� c @ s8 e Zd ZdZdZdZdd� Zdd� Zdd� Zd d � Z d S ) �EventualNoReadServerz� Like NoReadServer, except we Wait until some bytes have been delivered before stopping reading. This means TLS handshake has finished, where applicable. Fc C s. | j sd| _ | j�| d� | j�d� d S d S )NTF� hello)�gotDatar" r� r� rl rV rV rW r� � s �z!EventualNoReadServer.dataReceivedc C s | j rd S d| _ | j�� d S �NT)�stoppedReadingr" r� r~ rV rV rW r2 � s z$EventualNoReadServer.resumeProducingc C r� rU rV r~ rV rV rW r1 � r� z#EventualNoReadServer.pauseProducingc C r� rU rV r~ rV rV rW r� � r� z"EventualNoReadServer.stopProducingN) r� r� r� r� r� r� r� r2 r1 r� rV rV rV rW r� � s r� c @ r� )�BaseAbortingClientz/ Base class for abort-testing clients. Fc C s | j rtd��t�| |� d S )Nz,BUG: connectionLost was called re-entrantly!)�inReactorMethod� RuntimeErrorr7 r� rf rV rV rW r� � s z!BaseAbortingClient.connectionLostN)r� r� r� r� r� r� rV rV rV rW r� � s r� c @ r� )�WritingButNotAbortingClientz& Write data, but don't abort. c C r� )Nr� r� r~ rV rV rW r0 � r� z*WritingButNotAbortingClient.connectionMadeNr� rV rV rV rW r� � r� r� c @ r� )�AbortingClientz9 Call abortConnection() after writing some data. c C s d| _ | �� d| _ dS )zF Some data was received, so the connection is set up. TFN)r� � writeAndAbortrl rV rV rW r� � s zAbortingClient.dataReceivedc C s. | j �dd � | j �� | j �dd � d S )Nr� i' � Y)r" r� r� r~ rV rV rW r� � s z AbortingClient.writeAndAbortN)r� r� r� r� r� r� rV rV rV rW r� � s r� c @ r� )�AbortingTwiceClientz@ Call abortConnection() twice, after writing some data. c C � t �| � | j�� d S rU )r� r� r" r� r~ rV rV rW r� � r� z!AbortingTwiceClient.writeAndAbortN�r� r� r� r� r� rV rV rV rW r� � r� r� c @ r� )�AbortingThenLosingClientz; Call abortConnection() and then loseConnection(). c C r� rU )r� r� r" r7 r~ rV rV rW r� � r� z&AbortingThenLosingClient.writeAndAbortNr� rV rV rV rW r� � r� r� c @ s@ e Zd ZdZdZdZdd� Zdd� Zdd � Zd d � Z d d � Z dS )�ProducerAbortingClientzA Call abortConnection from doWrite, via resumeProducing. TFc C s. | j �dd � d| _| j �| d� d| _d S )Ns lalalai� TF)r" r� �inRegisterProducerr� r~ rV rV rW r� s z ProducerAbortingClient.writec C rl rU �r� r~ rV rV rW r0 r� z%ProducerAbortingClient.connectionMadec C s d| _ | js | j�� d| _ d S )NTF)r� r� r" r� r~ rV rV rW r2 s z&ProducerAbortingClient.resumeProducingc C � d| _ d S r� )�producerStoppedr~ rV rV rW r� rr z$ProducerAbortingClient.stopProducingc C s, | j std��| jrtd��t�| |� d S )Nz&BUG: stopProducing() was never called.z(BUG: connectionLost called re-entrantly!)r� r� r� r7 r� rf rV rV rW r� s z%ProducerAbortingClient.connectionLostN) r� r� r� r� r� r� r� r0 r2 r� r� rV rV rV rW r� � s r� c @ sT e Zd ZdZdZdZdZdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dS )�StreamingProducerClienta� Call abortConnection() when the other side has stopped reading. In particular, we want to call abortConnection() only once our local socket hits a state where it is no longer writeable. This helps emulate the most common use case for abortConnection(), closing a connection after a timeout, with write buffers being full. Since it's very difficult to know when this actually happens, we just write a lot of data, and assume at that point no more writes will happen. Fr c C rl rU r� r~ rV rV rW r0 0 r� z&StreamingProducerClient.connectionMadec C s0 | j �| d� td�D ] }| j �dd � q dS )zh Write large amount to transport, then wait for a while for buffers to fill up. T�d s 1234567890i } N)r" r� �ranger� )rm �irV rV rW r� 3 s �z StreamingProducerClient.writec C r� )NF)ra r~ rV rV rW r2 < rr z'StreamingProducerClient.resumeProducingc C r� rU rV r~ rV rV rW r� ? r� z%StreamingProducerClient.stopProducingc C s$ | j rdS d| _ | j�d| j� dS )a& Called when local buffer fills up. The goal is to hit the point where the local file descriptor is not writeable (or the moral equivalent). The fact that pauseProducing has been called is not sufficient, since that can happen when Twisted's buffers fill up but OS hasn't gotten any writes yet. We want to be as close as possible to every buffer (including OS buffers) being full. So, we wait a bit more after this for Twisted to write out a few chunks, then abortConnection. NTg{�G�z�?)ra r� r3 �doAbortr~ rV rV rW r1 B s z&StreamingProducerClient.pauseProducingc C s. | j s t�td�� d| _| j�� d| _d S )Nz&BUG: We should be paused a this point.TF)ra rC r r� r� r" r� r~ rV rV rW r� W s z StreamingProducerClient.doAbortc C s | j j�� t�| |� d S rU )� otherProtocolr" � startReadingr7 r� rf rV rV rW r� ^ rg z&StreamingProducerClient.connectionLostN)r� r� r� r� ra � extraWritesr� r0 r� r2 r� r1 r� r� rV rV rV rW r� s r� c @ r� )� StreamingProducerClientLaterzX Call abortConnection() from dataReceived, after bytes have been exchanged. c C s | j �d� d| _d S )Nr� F)r" r� r� r~ rV rV rW r0 j s z+StreamingProducerClientLater.connectionMadec C s | j s d| _ | �� d S d S r� )r� r� rl rV rV rW r� n s �z)StreamingProducerClientLater.dataReceivedN�r� r� r� r� r0 r� rV rV rV rW r� d s r� c @ r� )�ProducerAbortingClientLaterz� Call abortConnection from doWrite, via resumeProducing. Try to do so after some bytes have already been exchanged, so we don't interrupt SSL handshake. c C r� rU rV r~ rV rV rW r0 | s z*ProducerAbortingClientLater.connectionMadec C rl rU r� rl rV rV rW r� � r� z(ProducerAbortingClientLater.dataReceivedNr� rV rV rV rW r� t s r� c @ r� )�DataReceivedRaisingClientzN Call abortConnection(), and then throw exception, from dataReceived. c C s | j �� td��)N�ONO)r" r� �ZeroDivisionErrorrl rV rV rW r� � s z&DataReceivedRaisingClient.dataReceivedNr� rV rV rV rW r� � r� r� c @ r� )�ResumeThrowsClientzL Call abortConnection() and throw exception from resumeProducing(). c C s | j s | j�� td��d S )Nzono!)r� r" r� r� r~ rV rV rW r2 � s �z"ResumeThrowsClient.resumeProducingc C s t �| |� d S rU )r7 r� rf rV rV rW r� � r� z!ResumeThrowsClient.connectionLostN)r� r� r� r� r2 r� rV rV rV rW r� � s r� c @ s� e Zd ZU dZdZee ed< d dd�Zdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� ZdS ) �AbortConnectionMixinz7 Unit tests for L{ITransport.abortConnection}. Nr� c C s� t tf}ttf}tr|tjf }|tjf }|� }|� }||_||_t| ||| j�}| � |� � g � | � |� � g � |durJ| � |j j|f| � n| � |j j|� | � |j j|� dS )z� A test runner utility function, which hooks up a matched pair of client and server protocols. We then run the reactor until both sides have disconnected, and then verify that the right exception resulted. N)r r r r� rO �Errorr� r> r� r� r� �getDelayedCallsr� �disconnectReasonrv ) rm � clientClass� serverClass�clientConnectionLostReason�clientExpectedExceptions�serverExpectedExceptionsrc r� r� rV rV rW � runAbortTest� s* ��z!AbortConnectionMixin.runAbortTestc C � | � tt�S )z� abortConnection() is called in dataReceived. The protocol should be disconnected, but connectionLost should not be called re-entrantly. )r� r� r� r~ rV rV rW �test_dataReceivedAbort� r z+AbortConnectionMixin.test_dataReceivedAbortc C r� )z� abortConnection() is called twice by client. No exception should be thrown, and the connection will be closed. )r� r� r� r~ rV rV rW � test_clientAbortsConnectionTwice� � z5AbortConnectionMixin.test_clientAbortsConnectionTwicec C r� )z� Client calls abortConnection(), followed by loseConnection(). No exception should be thrown, and the connection will be closed. )r� r� r� r~ rV rV rW �.test_clientAbortsConnectionThenLosesConnection� r� zCAbortConnectionMixin.test_clientAbortsConnectionThenLosesConnectionc C � | j tttd�S )z� abortConnection() is called twice by server. No exception should be thrown, and the connection will be closed. �r� )r� r� r� r r~ rV rV rW � test_serverAbortsConnectionTwice� � �z5AbortConnectionMixin.test_serverAbortsConnectionTwicec C r� )z� Server calls abortConnection(), followed by loseConnection(). No exception should be thrown, and the connection will be closed. r� )r� r� r� r r~ rV rV rW �.test_serverAbortsConnectionThenLosesConnection� r� zCAbortConnectionMixin.test_serverAbortsConnectionThenLosesConnectionc C � | � tt� dS )z� abortConnection() is called in resumeProducing, before any bytes have been exchanged. The protocol should be disconnected, but connectionLost should not be called re-entrantly. N)r� r� r7 r~ rV rV rW �test_resumeProducingAbort� r� z.AbortConnectionMixin.test_resumeProducingAbortc C r� )z� abortConnection() is called in resumeProducing, after some bytes have been exchanged. The protocol should be disconnected. )r� r� r� r~ rV rV rW � test_resumeProducingAbortLater s �z3AbortConnectionMixin.test_resumeProducingAbortLaterc C r� )a{ abortConnection() triggered by the write buffer being full. In particular, the server side stops reading. This is supposed to simulate a realistic timeout scenario where the client notices the server is no longer accepting data. The protocol should be disconnected, but connectionLost should not be called re-entrantly. N)r� r� r� r~ rV rV rW �test_fullWriteBuffer s z)AbortConnectionMixin.test_fullWriteBufferc C r� )z� abortConnection() is triggered by a write buffer being full. However, this buffer is filled after some bytes have been exchanged, allowing a TLS handshake if we're testing TLS. The connection will then be lost. )r� r� r� r~ rV rV rW �%test_fullWriteBufferAfterByteExchange s z:AbortConnectionMixin.test_fullWriteBufferAfterByteExchangec C �. | j tttd� | �t�}| �t|�d� dS )aJ dataReceived calls abortConnection(), and then raises an exception. The connection will be lost, with the thrown exception (C{ZeroDivisionError}) as the reason on the client. The idea here is that bugs should not be masked by abortConnection, in particular unexpected exceptions. r� r� N)r� r� r� r� �flushLoggedErrorsr� rw �rm �errorsrV rV rW �test_dataReceivedThrows# � � z,AbortConnectionMixin.test_dataReceivedThrowsc C r� )aM resumeProducing calls abortConnection(), and then raises an exception. The connection will be lost, with the thrown exception (C{ZeroDivisionError}) as the reason on the client. The idea here is that bugs should not be masked by abortConnection, in particular unexpected exceptions. r� r� N)r� r� r7 r� r� r� rw r� rV rV rW �test_resumeProducingThrows4 r� z/AbortConnectionMixin.test_resumeProducingThrowsrU )r� r� r� r� r� r r9 r� r� r� r� r� r� r� r� r� r� r� r� r� rV rV rV rW r� � s % r� c @ s e Zd ZdZefZe� ZdS )�AbortConnectionTestsz5 TCP-specific L{AbortConnectionMixin} tests. N)r� r� r� r� r) rQ r� r� rV rV rV rW r� F s r� c @ s6 e Zd ZdZdd� Zee�� d�dd� �Zdd� Z d S ) �SimpleUtilityTestszJ Simple, direct tests for helpers within L{twisted.internet.tcp}. c C �* | � tjtdd�}| �|jd tj� dS )a L{_resolveIPv6} raises a L{socket.gaierror} (L{socket.EAI_NONAME}) when invoked with a non-numeric host. (In other words, it is passing L{socket.AI_NUMERICHOST} to L{socket.getaddrinfo} and will not accidentally block if it receives bad input.) � localhostr� r N�r@ r` �gaierrorr5 r� r� � EAI_NONAME�rm r rV rV rW �test_resolveNumericHostY s z*SimpleUtilityTests.test_resolveNumericHostz@The AI_NUMERICSERV flag is not supported by Microsoft providers.c C r� )a L{_resolveIPv6} raises a L{socket.gaierror} (L{socket.EAI_NONAME}) when invoked with a non-numeric port. (In other words, it is passing L{socket.AI_NUMERICSERV} to L{socket.getaddrinfo} and will not accidentally block if it receives bad input.) rQ �httpr Nr r rV rV rW �test_resolveNumericServicec s z-SimpleUtilityTests.test_resolveNumericServicec C sR t dd�}| �t|�d� | �|d t� | �|d t� | �|dd� d� dS )zb L{_resolveIPv6} discovers the flow info and scope ID of an IPv6 address. rQ r r_ r� N)rQ r )r5 r� rw r� r� r� rV rV rW �test_resolveIPv6r s z#SimpleUtilityTests.test_resolveIPv6N) r� r� r� r� r r rE rS r r rV rV rV rW r� S s � r� c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �BuffersLogsTestsz$ Tests for L{_BuffersLogs}. c C s" d| _ g | _t| j | jj�| _d S )Nz name.space)� namespacer` r1 rv � logBufferr~ rV rV rW r� � s zBuffersLogsTests.setUpc C sB | j �}|�d� | �| j� W d � dS 1 sw Y dS )zj The context manager's logger does not log to provided observer inside the block. �An eventN)r r� r� r` )rm �loggerrV rV rW �test_buffersInBlock� s "�z$BuffersLogsTests.test_buffersInBlockc C s| | j �}|�d� | �| j� W d � n1 sw Y | �dt| j�� | j\}| �|d d� | �|d | j� dS )zw The context manager flushes its buffered logs when the block terminates without an exception. r Nr� � log_format� log_namespace)r r� r� r` r� rw r )rm r �eventrV rV rW �test_flushesOnExit� s �z#BuffersLogsTests.test_flushesOnExitc C s� G dd� dt �}| �|��" | j�}|�d� | �| j� |� �1 s#w Y W d � n1 s2w Y | �dt| j�� | j\}| �|d d� | �|d | j� dS )zz The context manager flushes its buffered logs when the block terminates because of an exception. c @ r� )zGBuffersLogsTests.test_flushesOnExitWithException.<locals>.TestExceptionz@ An exception only raised by this test. N�r� r� r� r� rV rV rV rW � TestException� r� r r Nr� r r ) r� r@ r r� r� r` r� rw r )rm r r r rV rV rW � test_flushesOnExitWithException� s � �z0BuffersLogsTests.test_flushesOnExitWithExceptionN)r� r� r� r� r� r r r rV rV rV rW r � s r c @ r� )� FileDescriptorReservationTestsz2 Tests for L{_FileDescriptorReservation}. c s* g � _ � �� � _� fdd�}t|�� _d S )Nc s � j �t� jd�� � j d S )N�wr. )�reservedFileObjectsrv r� �tempfilerV r~ rV rW �fakeFileFactory� s z=FileDescriptorReservationTests.setUp.<locals>.fakeFileFactory)r �mktempr r2 � reservedFD)rm r rV r~ rW r� � s z$FileDescriptorReservationTests.setUpc C r� )zi L{_FileDescriptorReservation} instances provide L{_IFileDescriptorReservation}. N)r r3 r r~ rV rV rW r� � r� z5FileDescriptorReservationTests.test_providesInterfacec C sR | � t| j�d� td�D ]}| j�� | � t| j�d� | �| jd j� q dS )zh Multiple acquisitions without releases open the reservation file exactly once. r r� r� N)r� rw r r� r �reserver� rn )rm r] rV rV rW �test_reserveOpensFileOnce� s �z8FileDescriptorReservationTests.test_reserveOpensFileOncec C sz t � }| �|j� |�� | �| j�� � | j�� | �| j�� � | �t t �}| � t |�d� | � |d j jtj� dS )z� If reserving the file descriptor fails because of C{EMFILE}, the exception is suppressed but logged and the reservation remains unavailable. r� r N)r� rw r r} r� r � availabler r� r� r� r� rw rv r� r� )rm r� r� rV rV rW �test_reserveEMFILELogged� s z7FileDescriptorReservationTests.test_reserveEMFILELoggedc C s6 t ttfD ]}|fdd�}t|�}| �||j� qdS )z� Any exception raised while opening the reserve file that is not an L{OSError} or L{IOError} whose errno is C{EMFILE} is allowed through to the caller. c S s | t jd d��)Nr� r� )r� r� )� errorClassrV rV rW � failsWith� r� zWFileDescriptorReservationTests.test_reserveRaisesNonEMFILEExceptions.<locals>.failsWithN)r� r� rA r2 r@ r )rm r" r# � reserveFDrV rV rW �%test_reserveRaisesNonEMFILEExceptions� s �zDFileDescriptorReservationTests.test_reserveRaisesNonEMFILEExceptionsc C s. | � | j�� � | j�� | �| j�� � dS )z] The reservation is available after the file descriptor is reserved. N)r� r r r r� r~ rV rV rW �test_available� s z-FileDescriptorReservationTests.test_availablec C sf | � t��$ | j� W d � n1 sw Y W d � dS W d � dS 1 s,w Y dS )zp A reservation without an open file used as a context manager raises a L{RuntimeError}. N)r@ r� r r~ rV rV rW �test_enterFailsWithoutFile s ��"�z9FileDescriptorReservationTests.test_enterFailsWithoutFilec C sd | j �� | �| j �� � | j � | �| j �� � W d � n1 s#w Y | �| j �� � dS )zq Entering a reservation closes its file for the duration of the context manager's block. N)r r r� r r� r~ rV rV rW �!test_enterClosesFileExitOpensFile s �z@FileDescriptorReservationTests.test_enterClosesFileExitOpensFilec C sh G dd� dt �}| j�� | �|�� | j� |� �1 s w Y W d � dS 1 s-w Y dS )z� An exception raised within a reservation context manager's block does not prevent the file from being reopened. c @ r� )zSFileDescriptorReservationTests.test_exitOpensFileOnException.<locals>.TestExceptionz> An exception only used by this test. Nr rV rV rV rW r " r� r N)r� r r r@ )rm r rV rV rW � test_exitOpensFileOnException s �"�z<FileDescriptorReservationTests.test_exitOpensFileOnExceptionc s� G dd� dt �}G dd� dt �� dg�� �fdd�}t|�}|�� | �|�� � | �|�� |� |� �1 s8w Y W d � n1 sGw Y | �� �}| �t|�d � dS ) z� An exception raised while re-opening the reserve file exiting a reservation's context manager block is suppressed but logged, allowing an exception raised within the block through. c @ r� )z`FileDescriptorReservationTests.test_exitSuppressesReservationException.<locals>.AllowedExceptionzA The exception allowed out of the block. Nr rV rV rV rW �AllowedException3 r� r* c @ r� )zcFileDescriptorReservationTests.test_exitSuppressesReservationException.<locals>.SuppressedExceptionzM An exception raised by the file descriptor factory. Nr rV rV rV rW �SuppressedException8 r� r+ Fc s �d r� � �d�d< t �� S )Nr T)�io�BytesIOrV �r+ �calledrV rW �+failsWithSuppressedExceptionAfterSecondOpen? s z{FileDescriptorReservationTests.test_exitSuppressesReservationException.<locals>.failsWithSuppressedExceptionAfterSecondOpenNr� ) r� r2 r r� r r@ r� r� rw )rm r* r0 r r� rV r. rW �'test_exitSuppressesReservationException, s � � � zFFileDescriptorReservationTests.test_exitSuppressesReservationExceptionN)r� r� r� r� r� r� r r! r% r& r' r( r) r1 rV rV rV rW r � s r c @ r ) �"NullFileDescriptorReservationTestsz6 Tests for L{_NullFileDescriptorReservation}. c C r� rU )r4 �nullReservedFDr~ rV rV rW r� Z r� z(NullFileDescriptorReservationTests.setUpc C r� )zd L{_NullFileDescriptorReservation} provides L{_IFileDescriptorReservation}. N)r r3 r3 r~ rV rV rW r� ] r� z9NullFileDescriptorReservationTests.test_providesInterfacec C s | � | j�� � dS )zG The null reserved file descriptor is never available. N�r� r3 r r~ rV rV rW r& d s z1NullFileDescriptorReservationTests.test_availablec C sZ | � | j�� � | j� | � | j�� � W d � n1 s w Y | � | j�� � dS )zN The null reserved file descriptor is a null context manager. Nr4 r~ rV rV rW �test_contextManagerj s �z6NullFileDescriptorReservationTests.test_contextManagerN)r� r� r� r� r� r� r& r5 rV rV rV rW r2 U s r2 )�r� r� r� r, r� r` � functoolsr �typingr r r r r r �unittestr �zope.interfacer r �zope.interface.verifyr r r� �twisted.internet.addressr r �twisted.internet.deferr r r r r r �twisted.internet.endpointsr r �twisted.internet.errorr r r r r r r r r! �twisted.internet.interfacesr" r# r$ r% r& r' r( r) r* r+ �twisted.internet.protocolr, r- r. �twisted.internet.tcpr/ r0 r1 r2 r3 r4 r5 �&twisted.internet.test.connectionmixinsr6 r7 r8 r9 r: r; r< r= r> �#twisted.internet.test.reactormixinsr? r@ rA �twisted.loggerrB �twisted.pythonrC �twisted.python.failurerD �twisted.python.runtimerE �twisted.test.proto_helpersrF rG �twisted.test.test_tcprH rI rJ rK �twisted.trial.unittestrL rM rN �OpenSSLrO � ImportErrorr� �twisted.internet.sslrP �srV r r� r� r� r' r( r rS �twisted.internet.testrS � win32GetLinkLocalIPv6AddressesrZ r� rT � posixGetLinkLocalIPv6Addressesr\ rb ri r� r� r� r� r� r� r� r� r� rS rU rW ru rv r{ r| r� r� r� r� r� r� r� r� r� r* r- r. rA rE rG rH rs r� r� r� �globals�update�makeTestCaseClassesr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r2 rV rV rV rW �<module> sJ ,0 $, � �� �< ,40 s G MLD! % � � $ % " B� 3�D "E ( 07 PK Mb�ZB��7� � = internet/test/__pycache__/test_filedescriptor.cpython-310.pycnu �[��� o �b� � @ sh d Z ddlmZ ddlmZ ddlmZ ddlmZ G dd� de�Z G dd � d e�Z G d d � d e�Z d S ) zA Whitebox tests for L{twisted.internet.abstract.FileDescriptor}. � )� verifyClass)�FileDescriptor)� IPushProducer)�SynchronousTestCasec @ s4 e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd S ) � MemoryFilea- A L{FileDescriptor} customization which writes to a Python list in memory with certain limitations. @ivar _written: A C{list} of C{bytes} which have been accepted as written. @ivar _freeSpace: A C{int} giving the number of bytes which will be accepted by future writes. Tc C s t j| t� d� g | _d| _d S )N��reactorr )r �__init__�object�_written� _freeSpace��self� r �K/usr/lib/python3/dist-packages/twisted/internet/test/test_filedescriptor.pyr s zMemoryFile.__init__c C � d S �Nr r r r r � startWriting" � zMemoryFile.startWritingc C r r r r r r r � stopWriting% r zMemoryFile.stopWritingc C s: t | jt|��}|r| j|8 _| j�|d|� � |S )z� Copy at most C{self._freeSpace} bytes from C{data} into C{self._written}. @return: A C{int} indicating how many bytes were copied from C{data}. N)�minr �lenr �append)r �data� acceptLengthr r r � writeSomeData( s zMemoryFile.writeSomeDataN) �__name__� __module__� __qualname__�__doc__� connectedr r r r r r r r r s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �FileDescriptorTestsz& Tests for L{FileDescriptor}. c C s t t� d�}| �t|jd� dS )zF L{FileDescriptor.write} doesn't accept unicode data. r �fooN)r r � assertRaises� TypeError�write�r �fileDescriptorr r r �$test_writeWithUnicodeRaisesException: s z8FileDescriptorTests.test_writeWithUnicodeRaisesExceptionc C s$ t t� d�}| �t|jg d�� dS )zN L{FileDescriptor.writeSequence} doesn't accept unicode data. r )s foo�bars bazN)r r r# r$ � writeSequencer& r r r �,test_writeSequenceWithUnicodeRaisesExceptionA s �z@FileDescriptorTests.test_writeSequenceWithUnicodeRaisesExceptionc C s | � ttt�� dS )zF L{FileDescriptor} should implement L{IPushProducer}. N)� assertTruer r r r r r r �$test_implementInterfaceIPushProducerJ s z8FileDescriptorTests.test_implementInterfaceIPushProducerN)r r r r r( r+ r- r r r r r! 5 s r! c @ s e Zd ZdZdd� ZdS )�WriteDescriptorTestszN Tests for L{FileDescriptor}'s implementation of L{IWriteDescriptor}. c C s" t � }|�d� | �|�� � dS )z� When L{FileDescriptor.writeSomeData} returns C{0} to indicate no more data can be written immediately, L{FileDescriptor.doWrite} returns L{None}. s hello, worldN)r r% � assertIsNone�doWrite)r � descriptorr r r �test_kernelBufferFullV s z*WriteDescriptorTests.test_kernelBufferFullN)r r r r r2 r r r r r. Q s r. N) r �zope.interface.verifyr �twisted.internet.abstractr �twisted.internet.interfacesr �twisted.trial.unittestr r r! r. r r r r �<module> s % PK Mb�Zh8���! �! = internet/test/__pycache__/test_asyncioreactor.cpython-310.pycnu �[��� o �bo$ � @ s� d Z ddlZddlZddlmZmZmZmZmZ ddl m Z ddl m Z ddl mZ ddlmZ dd lmZ d Zd Zzej�d �rMdd lmZmZ d Zd ZW n eyW Y nw G dd� dee�ZdS )z/ Tests for L{twisted.internet.asyncioreactor}. � N)�DefaultEventLoopPolicy�Future�SelectorEventLoop�set_event_loop�set_event_loop_policy)�skipIf)�AsyncioSelectorReactor)�platform)�SynchronousTestCase� )�ReactorBuilderF�win32)� WindowsProactorEventLoopPolicy� WindowsSelectorEventLoopPolicyTc @ s* e Zd ZdZe� �� Zeee�Z dd� Z e e d� e e�ejjejje�� ��dd� �Ze e d� e e�ejjejje�� ��dd� �Ze e d � e e�ejjejje�� ��d d � �Ze e d �d d� �Ze e d�dd� �Ze e d�dd� �Ze e d�dd� �Z dd� Z dd� Z d d � Z d d � Z d S )!�AsyncioSelectorReactorTestsz* L{AsyncioSelectorReactor} tests. c sX t � }g �� �fdd�}|�|� |�d� | ��g � | j� dd� | ��dg� dS )zn Ensure that C{reactor} has an event loop that works properly with L{asyncio.Future}. c s �� | �� � � �� d S �N)�append�result�stop)�future��reactorr � �K/usr/lib/python3/dist-packages/twisted/internet/test/test_asyncioreactor.py� completed7 s zRAsyncioSelectorReactorTests.assertReactorWorksWithAsyncioFuture.<locals>.completedTr )�timeoutN)r �add_done_callback� set_result� assertEqual� runReactor)�selfr r r r r r �#assertReactorWorksWithAsyncioFuture/ s z?AsyncioSelectorReactorTests.assertReactorWorksWithAsyncioFuturezLdefault event loop: {} is not of type SelectorEventLoop on Python {}.{} ({})c C s t � }| �|� dS )a L{AsyncioSelectorReactor} wraps the global policy's event loop by default. This ensures that L{asyncio.Future}s and coroutines created by library code that uses L{asyncio.get_event_loop} are bound to the same loop. N)r r! �r r r r r �-test_defaultSelectorEventLoopFromGlobalPolicyB s zIAsyncioSelectorReactorTests.test_defaultSelectorEventLoopFromGlobalPolicyc C �0 t � �� }t|�}t|� | �|� td� dS )z� If we use the L{asyncio.DefaultLoopPolicy} to create a new event loop, and then pass that event loop to a new L{AsyncioSelectorReactor}, this reactor should work properly with L{asyncio.Future}. N)r �new_event_loopr r r! r �r � event_loopr r r r �3test_newSelectorEventLoopFromDefaultEventLoopPolicyV s zOAsyncioSelectorReactorTests.test_newSelectorEventLoopFromDefaultEventLoopPolicyzHdefault event loop: {} is of type SelectorEventLoop on Python {}.{} ({})c C s | � tt� dS )ay On Windows Python 3.5 to 3.7, L{get_event_loop()} returns a L{WindowsSelectorEventLoop} by default. On Windows Python 3.8+, L{get_event_loop()} returns a L{WindowsProactorEventLoop} by default. L{AsyncioSelectorReactor} should raise a L{TypeError} if the default event loop is not a L{WindowsSelectorEventLoop}. N)� assertRaises� TypeErrorr �r r r r �1test_defaultNotASelectorEventLoopFromGlobalPolicyl s zMAsyncioSelectorReactorTests.test_defaultNotASelectorEventLoopFromGlobalPolicyz&WindowsProactorEventLoop not availablec C s t � �� }| �tt|� dS )z� L{AsyncioSelectorReactor} will raise a L{TypeError} if instantiated with a L{asyncio.WindowsProactorEventLoop} N)r r% r) r* r )r r' r r r � test_WindowsProactorEventLoop� s z9AsyncioSelectorReactorTests.test_WindowsProactorEventLoopz(WindowsSelectorEventLoop only on Windowsc C r$ )zR L{WindowsSelectorEventLoop} works with L{AsyncioSelectorReactor} N)r r% r r r! r r& r r r � test_WindowsSelectorEventLoop� s z9AsyncioSelectorReactorTests.test_WindowsSelectorEventLoopz.WindowsProactorEventLoopPolicy only on Windowsc C sF t t� � | �t�� t� W d � n1 sw Y t d� dS )z� L{AsyncioSelectorReactor} will raise a L{TypeError} if L{asyncio.WindowsProactorEventLoopPolicy} is default. N)r r r) r* r r+ r r r �#test_WindowsProactorEventLoopPolicy� s � z?AsyncioSelectorReactorTests.test_WindowsProactorEventLoopPolicyz.WindowsSelectorEventLoopPolicy only on Windowsc C s& t t� � t� }| �|� t d� dS )zy L{AsyncioSelectorReactor} will work if if L{asyncio.WindowsSelectorEventLoopPolicy} is default. N)r r r r! r" r r r �#test_WindowsSelectorEventLoopPolicy� s z?AsyncioSelectorReactorTests.test_WindowsSelectorEventLoopPolicyc C sH t rtt� � t� }|�� }| �|d� | �|d� t r"td� dS dS )z0L{seconds} should return a plausible epoch time.i � ^l #G4 N)�!hasWindowsSelectorEventLoopPolicyr r r �seconds� assertGreater� assertLess)r r r r r r � test_seconds� s �z(AsyncioSelectorReactorTests.test_secondsc s� t rtt� � t� � dg�� �fdd�}� �� }� �d|�}|�d� � �d� j� � �� | � �d � | � �d | d� t rGtd� dS dS )zQ L{DelayedCall.reset()} properly reschedules timer to later time Nc � � � � �d< d S �Nr �r2 r �r �timer_called_atr r �on_timer� � zJAsyncioSelectorReactorTests.test_delayedCallResetToLater.<locals>.on_timerr � �?r 皙�����?) r1 r r r r2 � callLater�resetr �run�assertIsNotNoner3 )r r; � start_time�dcr r9 r � test_delayedCallResetToLater� s �z8AsyncioSelectorReactorTests.test_delayedCallResetToLaterc s� t rtt� � t� � dg�� �fdd�}� �� }� �d|�}|�d� � �d� j� ddl}ddl m } |� � }||�� � � � W d � n1 sKw Y | � |�� d� | ��d � | ��d | d � t rqtd� dS dS ) zS L{DelayedCall.reset()} properly reschedules timer to earlier time Nc r6 r7 r8 r r9 r r r; � r< zLAsyncioSelectorReactorTests.test_delayedCallResetToEarlier.<locals>.on_timerr= r r )�redirect_stderr� r> )r1 r r r r2 r? r@ r �io� contextlibrF �StringIOrA r �getvaluerB r4 )r r; rC rD rH rF �stderrr r9 r � test_delayedCallResetToEarlier� s* � �z:AsyncioSelectorReactorTests.test_delayedCallResetToEarlierc C s� t rtt� � t�� }t�� z6tt�� �}d}t� }t |�D ] }|� ddd� � q |� � tt�� �}| � || | d� W |rEt� � n|rMt� � w w t rVtd� dS dS )zW L{AsyncioSelectorReactor.callLater()} doesn't leave cyclic references i� r c S s d S r r r r r r �<lambda> s zOAsyncioSelectorReactorTests.test_noCycleReferencesInCallLater.<locals>.<lambda>r N)r1 r r �gc� isenabled�disable�len� get_objectsr �ranger? �runUntilCurrentr4 �enable)r �gc_was_enabled�objects_before� timer_countr �_� objects_afterr r r �!test_noCycleReferencesInCallLater� s, �� � �z=AsyncioSelectorReactorTests.test_noCycleReferencesInCallLaterN)!�__name__� __module__� __qualname__�__doc__r r% �_defaultEventLoop� isinstancer �_defaultEventLoopIsSelectorr! r �format�type�sys� version_info�major�minorr �getTyper# r( r, �!hasWindowsProactorEventLoopPolicyr- r1 r. r/ r0 r5 rE rM r\ r r r r r ' sz �� �� �� � � � � r )r` rO rf �asyncior r r r r �unittestr � twisted.internet.asyncioreactorr �twisted.python.runtimer �twisted.trial.unittestr � reactormixinsr rk r1 � startswithr r � ImportErrorr r r r r �<module> s* � �PK Mb�Z1��� . . 7 internet/test/__pycache__/reactormixins.cpython-310.pycnu �[��� o �b9 � @ s d Z g d�ZddlZddlZddlZddlmZmZmZm Z m Z ddl m Z ddl mZ ddlmZ ddlmZ dd lmZ dd lmZ dd lmZmZ dd lm Z m Z zdd l m Z W n e!yg dZ Y nw e Z G dd� de"�Z#dd� Z$ddd�Z%G dd� d�Z&dS )a� Utilities for unit testing reactor implementations. The main feature of this module is L{ReactorBuilder}, a base class for use when writing interface/blackbox tests for reactor implementations. Test case classes for reactor features should subclass L{ReactorBuilder} instead of L{SynchronousTestCase}. All of the features of L{SynchronousTestCase} will be available. Additionally, the tests will automatically be applied to all available reactor implementations. )�TestTimeoutError�ReactorBuilder�needsRunningReactor� N)�Dict�Optional�Sequence�Type�Union)� Interface��log)�_fullyQualifiedName)�Failure)�namedAny)�platform)�SkipTest�SynchronousTestCase)�DEFAULT_TIMEOUT_DURATION�acquireAttribute)�processc @ s e Zd ZdZdS )r zm The reactor was still running after the timeout period elapsed in L{ReactorBuilder.runReactor}. N)�__name__� __module__� __qualname__�__doc__� r r �E/usr/lib/python3/dist-packages/twisted/internet/test/reactormixins.pyr * s r c C s | � |� dS )a* Various functions within these tests need an already-running reactor at some point. They need to stop the reactor when the test has completed, and that means calling reactor.stop(). However, reactor.stop() raises an exception if the reactor isn't already running, so if the L{Deferred} that a particular API under test returns fires synchronously (as especially an endpoint's C{connect()} method may do, if the connect is to a local interface address) then the test won't be able to stop the reactor being tested and finish. So this calls C{thunk} only once C{reactor} is running. (This is just an alias for L{twisted.internet.interfaces.IReactorCore.callWhenRunning} on the given reactor parameter, in order to centrally reference the above paragraph and repeating it everywhere as a comment.) @param reactor: the L{twisted.internet.interfaces.IReactorCore} under test @param thunk: a 0-argument callable, which eventually finishes the test in question, probably in a L{Deferred} callback. N)�callWhenRunning)�reactor�thunkr r r r 1 s r c sD |du r ddl m} dg�� �fdd�}|�|� | �|j|� dS )a� Stop the reactor as soon as any error is logged on the given publisher. This is beneficial for tests which will wait for a L{Deferred} to fire before completing (by passing or failing). Certain implementation bugs may prevent the L{Deferred} from firing with any result at all (consider a protocol's {dataReceived} method that raises an exception: this exception is logged but it won't ever cause a L{Deferred} to fire). In that case the test would have to complete by timing out which is a much less desirable outcome than completing as soon as the unexpected error is encountered. @param case: A L{SynchronousTestCase} to use to clean up the necessary log observer when the test is over. @param reactor: The reactor to stop. @param publisher: A L{LogPublisher} to watch for errors. If L{None}, the global log publisher will be watched. Nr r c s* �r| � d�r��� � �� d S d S d S )N�isError)�get�pop�stop)�event�r �runningr r � stopIfError_ s �z stopOnError.<locals>.stopIfError)�twisted.pythonr � addObserver� addCleanup�removeObserver)�caser � publisherr& r r$ r � stopOnErrorI s r- c @ s e Zd ZU dZdgZe�� re�g d�� n'e�g d�� e�d� e� � r,e�d� ne�ddg� e� � s=e�d g� d Z d Z d Z eeee ed < i Zeeef ed < d d� Zdd� Zdd� Zdd� Zdd� Zd dd�Ze ded deee ed ee f f fdd ��Z d S ) r a� L{SynchronousTestCase} mixin which provides a reactor-creation API. This mixin defines C{setUp} and C{tearDown}, so mix it in before L{SynchronousTestCase} or call its methods from the overridden ones in the subclass. @cvar skippedReactors: A dict mapping FQPN strings of reactors for which the tests defined by this class will be skipped to strings giving the skip message. @cvar requiredInterfaces: A C{list} of interfaces which the reactor must provide or these tests will be skipped. The default, L{None}, means that no interfaces are required. @ivar reactorFactory: A no-argument callable which returns the reactor to use for testing. @ivar originalHandler: The SIGCHLD handler which was installed when setUp ran and which will be re-installed when tearDown runs. @ivar _reactors: A list of FQPN strings giving the reactors for which L{SynchronousTestCase}s will be created. z,twisted.internet.selectreactor.SelectReactor)z/twisted.internet.gtk2reactor.PortableGtkReactorz,twisted.internet.gireactor.PortableGIReactorz0twisted.internet.gtk3reactor.PortableGtk3Reactorz/twisted.internet.win32eventreactor.Win32Reactorz0twisted.internet.iocpreactor.reactor.IOCPReactor)z*twisted.internet.glib2reactor.Glib2Reactorz(twisted.internet.gtk2reactor.Gtk2Reactorz$twisted.internet.gireactor.GIReactorz(twisted.internet.gtk3reactor.Gtk3Reactorz6twisted.internet.asyncioreactor.AsyncioSelectorReactorz$twisted.internet.cfreactor.CFReactorz(twisted.internet.pollreactor.PollReactorz*twisted.internet.epollreactor.EPollReactorz(twisted.internet.kqreactor.KQueueReactorN�requiredInterfaces�skippedReactorsc C s" t �� st�tjtj�| _dS dS )z� Clear the SIGCHLD handler, if there is one, to ensure an environment like the one which exists prior to a call to L{reactor.run}. N)r � isWindows�signal�SIGCHLD�SIG_DFL�originalHandler��selfr r r �setUp� s �zReactorBuilder.setUpc C s� | j dur t�tj| j � tdurLt�� }tjrNt�dtjf � t�� t� d� t�� | dkrGtjD ] }t � |tj � q5t dtjf ��tjsdS dS dS )z| Restore the original SIGCHLD handler and reap processes as long as there seem to be any remaining. Nz1ReactorBuilder.tearDown reaping some processes %rg����MbP?�< z/Timeout waiting for child processes to exit: %r)r4 r1 r2 r �time�reapProcessHandlersr �msg�reapAllProcesses�sleep�os�kill�SIGKILL� Exception)r6 �begin�pidr r r �tearDown� s. �� �� ��zReactorBuilder.tearDownc C sh |� � t|dd�dur!|jD ] }|�|� |�d� q|j�� |�� |�� }|D ]}|�� q+dS )z� Clean up any resources which may have been allocated for the given reactor by its creation or by a test which used it. �_internalReadersN) �_uninstallHandler�getattrrE � removeReader�connectionLost�clear� disconnectAll�getDelayedCalls�cancel)r6 r �reader�calls�cr r r �unbuildReactor� s �z ReactorBuilder.unbuildReactorc s� zddl m} ddlm} W n ty Y nw t||�r&| j|u r&td��z| �� � W n tyD t � dd� | � � tt � � � ��w | jdurn� fdd�| jD �}|rn| �� � td t� j�d �d d� |D ��f ��| �| j� � � S ) zK Create and return a reactor using C{self.reactorFactory}. r �r )� CFReactorzuCFReactor uses APIs which manipulate global state, so it's not safe to run its own reactor-builder tests under itselfNzFailed to install reactorc s g | ] }|� � �s|�qS r )� providedBy)�.0�requiredrR r r � <listcomp> s ��z/ReactorBuilder.buildReactor.<locals>.<listcomp>z%s does not provide %s�,c S s g | ]}t |��qS r )�fullyQualifiedName)rU �xr r r rW & s )�twisted.internetr �twisted.internet.cfreactorrS � ImportError� isinstance�reactorFactoryr � BaseExceptionr �err�flushLoggedErrorsr �getErrorMessager. rQ rY � __class__�joinr) )r6 � globalReactorrS �missingr rR r � buildReactor� sD �� � � � ���zReactorBuilder.buildReactorc C s t | jdt�S )z� Determine how long to run the test before considering it failed. @return: A C{int} or C{float} giving a number of seconds. �timeout)r �_parentsr r5 r r r � getTimeout, s zReactorBuilder.getTimeoutc sV |du r| � � }g �� �fdd�}� �||�}� �� �r%td|� d���|�� dS )a� Run the reactor for at most the given amount of time. @param reactor: The reactor to run. @type timeout: C{int} or C{float} @param timeout: The maximum amount of time, specified in seconds, to allow the reactor to run. If the reactor is still running after this much time has elapsed, it will be stopped and an exception raised. If L{None}, the default test method timeout imposed by Trial will be used. This depends on the L{IReactorTime} implementation of C{reactor} for correct operation. @raise TestTimeoutError: If the reactor is still running after C{timeout} seconds. Nc s �� d � � �� d S �N)�appendr" r �r �timedOutr r r" J s z'ReactorBuilder.runReactor.<locals>.stopz reactor still running after z seconds)rk � callLater�runr rM )r6 r ri r" � timedOutCallr rn r � runReactor4 s zReactorBuilder.runReactor�cls�returnc s� i }� j D ]:���d�d }� jd | d �dd�}G � �fdd�d� t�}||_d�� j�� dd� |g �|_|||j< q|S )z� Create a L{SynchronousTestCase} subclass which mixes in C{cls} for each known reactor and return a dict mapping their names to them. �.����Tests�_c sP e Zd Z� jZ�� jv r� j� Zze��ZW dS ey' e� � � ZY dS w )z4ReactorBuilder.makeTestCaseClasses.<locals>.testcaseN) r r r r/ �skipr r_ r` r rc r �rt r r r �testcased s �r| r )� _reactors�splitr �replacer re r )rt �classes�shortReactorName�namer| r r{ r �makeTestCaseClassesU s � z"ReactorBuilder.makeTestCaseClassesrl ) r r r r r} r r0 �extendrm �isMacOSX�isLinuxr_ r4 r. r r r r �__annotations__r/ r �strr7 rD rQ rh rk rs � classmethodr r r� r r r r r h sP �� � ���� 2 !��r rl )'r �__all__r> r1 r9 �typingr r r r r �zope.interfacer r' r �twisted.python.deprecater rY �twisted.python.failurer �twisted.python.reflectr �twisted.python.runtimer �twisted.trial.unittestr r �twisted.trial.utilr r r[ r �_processr] rA r r r- r r r r r �<module> s0 � PK Mb�Z<� �g g : internet/test/__pycache__/test_defer_await.cpython-310.pycnu �[��� o �br � @ sp d Z ddlZddlmZmZmZmZmZ ddlm Z ddl m Z ddl m Z G dd� de�ZG d d � d e �ZdS ) z* Tests for C{await} support in Deferreds. � N)�Deferred�ensureDeferred�fail� maybeDeferred�succeed)�Clock)�Failure)�TestCasec @ s e Zd ZdZdS )�SampleExceptionz2 A specific sample exception for testing. N)�__name__� __module__� __qualname__�__doc__� r r �H/usr/lib/python3/dist-packages/twisted/internet/test/test_defer_await.pyr s r c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )� AwaitTestsz@ Tests for using Deferreds in conjunction with PEP-492. c C s" t � }|�� }| �|t|�� dS )z< C{Deferred.__await__} returns an iterable. N)r � __await__� assertEqual�iter)�self�d�awaitedDeferredr r r �test_awaitReturnsIterable" s z$AwaitTests.test_awaitReturnsIterablec sX � fdd�}dd� � |� }| � |tj� t�|�}| � |t� | �|�}| �|d� dS )zU L{Deferred.fromCoroutine} will turn a coroutine into a L{Deferred}. c � s$ �t d�} | I d H � � I d H }|S )N�bar�r �r �res��run2r r �run/ s � z2AwaitTests.test_deferredFromCoroutine.<locals>.runc � � �t d�} | I d H }|S �N�foor r r r r r 5 � � z3AwaitTests.test_deferredFromCoroutine.<locals>.run2r" N)�assertIsInstance�types� CoroutineTyper � fromCoroutine�successResultOfr )r r �rr r r r r �test_deferredFromCoroutine* s z%AwaitTests.test_deferredFromCoroutinec C s. dd� }t �|� �}| �|�}| �|d� dS )zc L{Deferred.fromCoroutine} allows a function to C{await} on a L{Deferred}. c � r r! r r r r r r L r# z"AwaitTests.test_basic.<locals>.runr" N)r r' r( r �r r r r r r r � test_basicF s zAwaitTests.test_basicc C s, dd� }t |� �}| �|�}| �|d� dS )zS L{ensureDeferred} allows a function to C{await} on a L{Deferred}. c � r r! r r r r r r Z r# z0AwaitTests.test_basicEnsureDeferred.<locals>.runr" N)r r( r r+ r r r �test_basicEnsureDeferredU s z#AwaitTests.test_basicEnsureDeferredc C sD dd� }t �|� �}| �|�}| �t|j�t� | �|jjd� dS )z� An exception in a coroutine scheduled with L{Deferred.fromCoroutine} will cause the returned L{Deferred} to fire with a failure. c � s �t d�} | I d H td��)Nr" �Oh no!)r � ValueError�r r r r r i s � z&AwaitTests.test_exception.<locals>.run)r. N)r r' �failureResultOfr �type�valuer/ �argsr+ r r r �test_exceptionc s zAwaitTests.test_exceptionc sR dd� }t |�� � fdd�}| �t�|� ��}| �d|�� � | �d|�� � dS )z� When a Deferred is awaited upon that has already failed with a Failure that has a traceback, both the place that the synchronous traceback comes from and the awaiting line are shown in the traceback. c S s t � ��N)r r r r r �raisesz s zCAwaitTests.test_synchronousDeferredFailureTraceback.<locals>.raisesc � � �� I d H S r6 r r ��itr r �doomed � � zCAwaitTests.test_synchronousDeferredFailureTraceback.<locals>.doomed� , in doomed z , in raises N)r r1 r r' �assertIn� getTraceback)r r7 r; �failurer r9 r �(test_synchronousDeferredFailureTracebacks s z3AwaitTests.test_synchronousDeferredFailureTracebackc sj dd� }t � � � fdd�}t �|� �}| �|� � �|� � | �|�}| �d|�� � | �d|�� � dS )z� When a Deferred is awaited upon that later fails with a Failure that has a traceback, both the place that the synchronous traceback comes from and the awaiting line are shown in the traceback. c S s zt � � t y t� Y S w r6 )r r r r r r �returnsFailure� s �zEAwaitTests.test_asyncDeferredFailureTraceback.<locals>.returnsFailurec � r8 r6 r r r9 r r r; � r< z=AwaitTests.test_asyncDeferredFailureTraceback.<locals>.doomedr= z, in returnsFailure N)r r' �assertNoResult�errbackr1 r> r? )r rB r; �startedr@ r r9 r �"test_asyncDeferredFailureTraceback� s z-AwaitTests.test_asyncDeferredFailureTracebackc s� t � � g �� �fdd��� ��fdd�}t�|� �}� �d� | ��ddg� � �d� | ��g d �� � �d� | ��g d �� � �d� | ��g d �� | �|�}| �|d � d S ) z� A coroutine scheduled with L{Deferred.fromCoroutine} that awaits a L{Deferred} suspends its execution until the inner L{Deferred} fires. c � s: ��� d� t� } � �d| jd� | I d H �� d� dS )N� � � �Yay!��appendr � callLater�callbackr0 )�reactor�sectionsr r �runone� s � z'AwaitTests.test_twoDeep.<locals>.runonec � sP ��� d� �� I d H } �� d� t� }� �d|jd� |I d H �� d� | S )NrH � � rK )�resultr �rO rQ rP r r r � s � z$AwaitTests.test_twoDeep.<locals>.rung�������?rH rG 皙�����?)rH rG rI rR )rH rG rI rR rS rJ N)r r r' �advancer r( r+ r rU r � test_twoDeep� s zAwaitTests.test_twoDeepc s. � fdd�}� � t�|� ��}� �|d� dS )zO Awaiting an already failed Deferred will raise the exception. c � sP �z t td��I d H W dS ty' } z� �| jd� W Y d } ~ dS d } ~ ww )N�Boom)rY rH r )r r/ r r4 )�e�r r r �test� s ����z%AwaitTests.test_reraise.<locals>.testrH N)r( r r' r )r r\ r r r[ r � test_reraise� s zAwaitTests.test_reraisec sB t � � � fdd�}t�|� �}� �d� | �|�}| �|d� dS )zd Awaiting a paused & chained Deferred will give the result when it has one. c � sD �t � } t � � | �� fdd�� | �d � ��d� jd� | I d H S )Nc s � S r6 r )�ignored��d2r r �<lambda>� s z7AwaitTests.test_chained.<locals>.test.<locals>.<lambda>r �bye)r � addCallbackrN rM r0 �rO r_ r r\ � s � z%AwaitTests.test_chained.<locals>.testrV rb N)r r r' rW r( r )r r\ r r r rd r � test_chained� s zAwaitTests.test_chainedN)r r r r r r* r, r- r5 rA rF rX r] re r r r r r s + r )r r% �twisted.internet.deferr r r r r �twisted.internet.taskr �twisted.python.failurer �twisted.trial.unittestr � Exceptionr r r r r r �<module> s PK Mb�Z�s]�� � 2 internet/test/__pycache__/__init__.cpython-310.pycnu �[��� o �bp � @ s d Z dS )z Tests for L{twisted.internet}. N)�__doc__� r r �@/usr/lib/python3/dist-packages/twisted/internet/test/__init__.py�<module> s PK Mb�Z��K*N N 7 internet/test/__pycache__/test_protocol.cpython-310.pycnu �[��� o �bXH � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z m Z m Z m Z ddlmZmZmZmZmZmZ ddlmZmZ dd lmZ dd lmZm Z dd l m Z G d d � d e �Z G dd� de �Z G dd� de �Z!G dd� de �Z"G dd� de �Z#dS )z) Tests for L{twisted.internet.protocol}. � )�BytesIO)� implementer)� verifyObject)�CancelledError)� IConsumer�ILoggingContext� IProtocol�IProtocolFactory)� ClientCreator�ConsumerToProtocolAdapter�Factory� FileWrapper�Protocol�ProtocolToConsumerAdapter)�LogLevel�globalLogPublisher)�Failure)�MemoryReactorClock�StringTransport)�TestCasec @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�ClientCreatorTestsz? Tests for L{twisted.internet.protocol.ClientCreator}. c C sD G dd� dt �}t� }t||�}|||�}|�d�}| �||� dS )a Helper for implementing a test to verify that one of the I{connect} methods of L{ClientCreator} passes the right arguments to the right reactor method. @param check: A function which will be invoked with a reactor and a L{ClientCreator} instance and which should call one of the L{ClientCreator}'s I{connect} methods and assert that all of its arguments except for the factory are passed on as expected to the reactor. The factory should be returned. c @ � e Zd ZdS )z:ClientCreatorTests._basicConnectTest.<locals>.SomeProtocolN��__name__� __module__� __qualname__� r r �E/usr/lib/python3/dist-packages/twisted/internet/test/test_protocol.py� SomeProtocol5 � r N)r r r � buildProtocol�assertIsInstance)�self�checkr �reactor�cc�factory�protocolr r r �_basicConnectTest( s z$ClientCreatorTests._basicConnectTestc � � fdd�}� � |� dS )z� L{ClientCreator.connectTCP} calls C{reactor.connectTCP} with the host and port information passed to it, and with a factory which will construct the protocol passed to L{ClientCreator.__init__}. c sX |� dddd� | j�� \}}}}}� �|d� � �|d� � �|d� � �|d� |S )N� example.com�� �� )z1.2.3.4i�& )� connectTCP� tcpClients�pop� assertEqual)r$ r% �host�portr& �timeout� bindAddress�r" r r r# E s z1ClientCreatorTests.test_connectTCP.<locals>.checkN�r( �r" r# r r5 r �test_connectTCP> s z"ClientCreatorTests.test_connectTCPc r) )z� L{ClientCreator.connectUNIX} calls C{reactor.connectUNIX} with the filename passed to it, and with a factory which will construct the protocol passed to L{ClientCreator.__init__}. c sF |� ddd� | j�� \}}}}� �|d� � �|d� � �|� |S )N�/foo/bar�{ T)� connectUNIX� unixClientsr/ r0 � assertTrue)r$ r% �addressr& r3 �checkPIDr5 r r r# W s z2ClientCreatorTests.test_connectUNIX.<locals>.checkNr6 r7 r r5 r �test_connectUNIXP s z#ClientCreatorTests.test_connectUNIXc r) )z� L{ClientCreator.connectSSL} calls C{reactor.connectSSL} with the host, port, and context factory passed to it, and with a factory which will construct the protocol passed to L{ClientCreator.__init__}. c sn t � }|�dd|dd� | j�� \}}}}}}� �|d� � �|d� � �||� � �|d� � �|d� |S )Nr* r+ r, )z4.3.2.1i. )�object� connectSSL� sslClientsr/ r0 �assertIs) r$ r% �expectedContextFactoryr1 r2 r& �contextFactoryr3 r4 r5 r r r# h s$ � � z1ClientCreatorTests.test_connectSSL.<locals>.checkNr6 r7 r r5 r �test_connectSSLa s z"ClientCreatorTests.test_connectSSLc C sN t � }t|t�}||�}|j�� }| �|j� |�� | �|j� | � |t �S )a Helper for implementing a test to verify that cancellation of the L{Deferred} returned by one of L{ClientCreator}'s I{connect} methods is implemented to cancel the underlying connector. @param connect: A function which will be invoked with a L{ClientCreator} instance as an argument and which should call one its I{connect} methods and return the result. @return: A L{Deferred} which fires when the test is complete or fails if there is a problem. ) r r r � connectorsr/ � assertFalse� _disconnected�cancelr= � assertFailurer �r" �connectr$ r% �d� connectorr r r �_cancelConnectTest~ s z%ClientCreatorTests._cancelConnectTestc C � dd� }| � |�S )�� The L{Deferred} returned by L{ClientCreator.connectTCP} can be cancelled to abort the connection attempt before it completes. c S s | � dd�S �Nr* r+ )r- �r% r r r rN � s z9ClientCreatorTests.test_cancelConnectTCP.<locals>.connect�rQ �r" rN r r r �test_cancelConnectTCP� � z(ClientCreatorTests.test_cancelConnectTCPc C rR )rS c S s | � d�S �Nr9 )r; rU r r r rN � s z:ClientCreatorTests.test_cancelConnectUNIX.<locals>.connectrV rW r r r �test_cancelConnectUNIX� rY z)ClientCreatorTests.test_cancelConnectUNIXc C rR )rS c S s | � ddt� �S rT )rB rA rU r r r rN � � z9ClientCreatorTests.test_cancelConnectSSL.<locals>.connectrV rW r r r �test_cancelConnectSSL� rY z(ClientCreatorTests.test_cancelConnectSSLc C sh t � }t|t�}|||�}|j�� }| �t|�� �d� |�� | �|�� g � | � |j � | � |t �S )z� Like L{_cancelConnectTest}, but for the case where the L{Deferred} is cancelled after the connection is set up but before it is fired with the resulting protocol instance. � ) r r r rH r/ r0 �len�getDelayedCallsrK r= rJ rL r rM r r r �_cancelConnectTimeoutTest� s z,ClientCreatorTests._cancelConnectTimeoutTestc C rR )a� L{ClientCreator.connectTCP} inserts a very short delayed call between the time the connection is established and the time the L{Deferred} returned from one of its connect methods actually fires. If the L{Deferred} is cancelled in this interval, the established connection is closed, the timeout is cancelled, and the L{Deferred} fails with L{CancelledError}. c S s> |� dd�}| j�� \}}}}}|�d �}t� } |�| � |S rT )r- r. r/ r r �makeConnection) r$ r% rO r1 r2 r& r3 r4 r' � transportr r r rN � s z@ClientCreatorTests.test_cancelConnectTCPTimeout.<locals>.connect�ra rW r r r � test_cancelConnectTCPTimeout� � z/ClientCreatorTests.test_cancelConnectTCPTimeoutc C rR )a� L{ClientCreator.connectUNIX} inserts a very short delayed call between the time the connection is established and the time the L{Deferred} returned from one of its connect methods actually fires. If the L{Deferred} is cancelled in this interval, the established connection is closed, the timeout is cancelled, and the L{Deferred} fails with L{CancelledError}. c S s: |� d�}| j�� \}}}}|�d �}t� }|�|� |S rZ )r; r< r/ r r rb ) r$ r% rO r> r& r3 r4 r' rc r r r rN � s zAClientCreatorTests.test_cancelConnectUNIXTimeout.<locals>.connectrd rW r r r � test_cancelConnectUNIXTimeout� rf z0ClientCreatorTests.test_cancelConnectUNIXTimeoutc C rR )a� L{ClientCreator.connectSSL} inserts a very short delayed call between the time the connection is established and the time the L{Deferred} returned from one of its connect methods actually fires. If the L{Deferred} is cancelled in this interval, the established connection is closed, the timeout is cancelled, and the L{Deferred} fails with L{CancelledError}. c S sD |� ddt� �}| j�� \}}}}}}|�d �} t� } | �| � |S rT )rB rA rC r/ r r rb ) r$ r% rO r1 r2 r& rF r3 � bindADdressr' rc r r r rN s � z@ClientCreatorTests.test_cancelConnectSSLTimeout.<locals>.connectrd rW r r r � test_cancelConnectSSLTimeout� s z/ClientCreatorTests.test_cancelConnectSSLTimeoutc C st t � }t|t�}|||�\}}|j�� }|�|ttd��� | �t |� � �d� |� � | �|� � g � | � |t �S )z� Like L{_cancelConnectTest}, but for the case where the L{Deferred} is cancelled after the connection attempt has failed but before it is fired with the resulting failure. zSimulated failurer^ )r r r rH r/ �clientConnectionFailedr � Exceptionr0 r_ r` rK rL r )r" rN r$ r% rO r& rP r r r � _cancelConnectFailedTimeoutTest s � z2ClientCreatorTests._cancelConnectFailedTimeoutTestc C rR )zz Similar to L{test_cancelConnectTCPTimeout}, but for the case where the connection attempt fails. c S s( |� dd�}| j�� \}}}}}||fS rT )r- r. r/ )r$ r% rO r1 r2 r& r3 r4 r r r rN 2 s zFClientCreatorTests.test_cancelConnectTCPFailedTimeout.<locals>.connect�rl rW r r r �"test_cancelConnectTCPFailedTimeout, � z5ClientCreatorTests.test_cancelConnectTCPFailedTimeoutc C rR )z{ Similar to L{test_cancelConnectUNIXTimeout}, but for the case where the connection attempt fails. c S s$ |� d�}| j�� \}}}}||fS rZ )r; r< r/ )r$ r% rO r> r& r3 r4 r r r rN ? s zGClientCreatorTests.test_cancelConnectUNIXFailedTimeout.<locals>.connectrm rW r r r �#test_cancelConnectUNIXFailedTimeout9 ro z6ClientCreatorTests.test_cancelConnectUNIXFailedTimeoutc C rR )zz Similar to L{test_cancelConnectSSLTimeout}, but for the case where the connection attempt fails. c S s. |� ddt� �}| j�� \}}}}}}||fS rT )rB rA rC r/ ) r$ r% rO r1 r2 r& rF r3 rh r r r rN L s �zFClientCreatorTests.test_cancelConnectSSLFailedTimeout.<locals>.connectrm rW r r r �"test_cancelConnectSSLFailedTimeoutF s z5ClientCreatorTests.test_cancelConnectSSLFailedTimeoutN)r r r �__doc__r( r8 r@ rG rQ rX r[ r] ra re rg ri rl rn rp rq r r r r r # s$ r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � ProtocolTestsz: Tests for L{twisted.internet.protocol.Protocol}. c C �* t � }| �tt|�� | �tt|�� dS )zT L{Protocol} instances provide L{IProtocol} and L{ILoggingContext}. N)r r= r r r )r" �protor r r �test_interfaces` s z ProtocolTests.test_interfacesc C �& G dd� dt �}| �d|� �� � dS )zJ L{Protocol.logPrefix} returns the protocol class's name. c @ r )z/ProtocolTests.test_logPrefix.<locals>.SomeThingNr r r r r � SomeThingm r rx N)r r0 � logPrefix)r" rx r r r �test_logPrefixh � z ProtocolTests.test_logPrefixc s@ g � G � fdd�dt �}t� }|� }|�|� | �� |g� dS )zz L{Protocol.makeConnection} sets the given transport on itself, and then calls C{connectionMade}. c � e Zd Z� fdd�ZdS )z7ProtocolTests.test_makeConnection.<locals>.SomeProtocolc s � � | j� d S �N)�appendrc r5 ��resultr r �connectionMadez r\ zFProtocolTests.test_makeConnection.<locals>.SomeProtocol.connectionMadeN)r r r r� r r r r r y s r N)r rA rb r0 )r" r rc r' r r r �test_makeConnectionr s z!ProtocolTests.test_makeConnectionN)r r r rr rv rz r� r r r r rs [ s rs c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� FactoryTestsz( Tests for L{protocol.Factory}. c C rt )zg L{Factory} instances provide both L{IProtocolFactory} and L{ILoggingContext}. N)r r= r r r )r" r& r r r rv � s z FactoryTests.test_interfacesc C rw )zM L{Factory.logPrefix} returns the name of the factory class. c @ r )z6FactoryTests.test_logPrefix.<locals>.SomeKindOfFactoryNr r r r r �SomeKindOfFactory� r r� N)r r0 ry )r" r� r r r rz � r{ zFactoryTests.test_logPrefixc C sD G dd� dt �}t� }||_|�d�}| �||� | �|j|� dS )z� L{Factory.buildProtocol} by default constructs a protocol by calling its C{protocol} attribute, and attaches the factory to the result. c @ r )z<FactoryTests.test_defaultBuildProtocol.<locals>.SomeProtocolNr r r r r r � r r N)r r r' r r! rD r& )r" r �fr' r r r �test_defaultBuildProtocol� s z&FactoryTests.test_defaultBuildProtocolc C sT G dd� dt �}|jtdddd�}| �|jt� | �|jd� | �|jddi� d S ) z� L{Factory.forProtocol} constructs a Factory, passing along any additional arguments, and sets its C{protocol} attribute to the given Protocol subclass. c @ s e Zd Zdd� ZdS )z7FactoryTests.test_forProtocol.<locals>.ArgTakingFactoryc _ s ||| _ | _d S r} )�args�kwargs)r" r� r� r r r �__init__� s z@FactoryTests.test_forProtocol.<locals>.ArgTakingFactory.__init__N)r r r r� r r r r �ArgTakingFactory� s r� r^ � � )�foo)r^ r� r� N)r � forProtocolr r0 r' r� r� )r" r� r& r r r �test_forProtocol� s z FactoryTests.test_forProtocolc sr g � t �� j� | �� fdd�� t� }|�� | �� d d |� | �� d d tj � | �� d d d� dS ) z� L{Factory.doStart} logs that it is starting a factory, followed by the L{repr} of the L{Factory} instance that is being started. c � t �� j�S r} �r �removeObserverr~ r ��eventsr r �<lambda>� � z;FactoryTests.test_doStartLoggingStatement.<locals>.<lambda>r r& � log_level� log_formatz Starting factory {factory!r}N) r � addObserverr~ � addCleanupr �doStartrD r0 r �info)r" r� r r� r � test_doStartLoggingStatement� s z)FactoryTests.test_doStartLoggingStatementc s� g � t �� j� | �� fdd�� G dd� dt�}|� }|�� | �� d d |� | �� d d tj � | �� d d d � d S ) z� L{Factory.doStop} logs that it is stopping a factory, followed by the L{repr} of the L{Factory} instance that is being stopped. c r� r} r� r r� r r r� � r� z:FactoryTests.test_doStopLoggingStatement.<locals>.<lambda>c @ s e Zd ZdZdS )z;FactoryTests.test_doStopLoggingStatement.<locals>.MyFactoryr^ N)r r r �numPortsr r r r � MyFactory� s r� r r& r� r� z Stopping factory {factory!r}N) r r� r~ r� r �doStoprD r0 r r� )r" r� r� r r� r �test_doStopLoggingStatement� s z(FactoryTests.test_doStopLoggingStatementN) r r r rr rv rz r� r� r� r� r r r r r� � s r� c @ � e Zd ZdZdd� Zdd� ZdS )� AdapterTestszR Tests for L{ProtocolToConsumerAdapter} and L{ConsumerToProtocolAdapter}. c C sB g }t � }|j|_t|�}|�d� | �|dg� | �|t� dS )z} L{IProtocol} providers can be adapted to L{IConsumer} providers using L{ProtocolToConsumerAdapter}. � helloN)r r~ � dataReceivedr �writer0 r! r )r" r� �p�consumerr r r �test_protocolToConsumer� s z$AdapterTests.test_protocolToConsumerc sT g � t t�G � fdd�d��}|� }t|�}|�d� | �� dg� | �|t� dS )z} L{IConsumer} providers can be adapted to L{IProtocol} providers using L{ProtocolToConsumerAdapter}. c r| )z6AdapterTests.test_consumerToProtocol.<locals>.Consumerc s � � |� d S r} )r~ )r" rO r r r r� � s z<AdapterTests.test_consumerToProtocol.<locals>.Consumer.writeN)r r r r� r r r r �Consumer� s r� r� N)r r r r� r0 r! r )r" r� �cr' r r r �test_consumerToProtocol� s z$AdapterTests.test_consumerToProtocolN)r r r rr r� r� r r r r r� � s r� c @ r� )�FileWrapperTestsz2 L{twisted.internet.protocol.FileWrapper} c C sP t t� �}|�d� | �|j�� d� t t� �}|�d� | �|j�� d� dS )z@ L{twisted.internet.protocol.FileWrapper.write} � test1�stuffN)r r r� r0 �file�getvalue�assertNotEqual�r" �wrapperr r r � test_write s zFileWrapperTests.test_writec C sL t t� �}|�ddg� | �|j�� d� t t� �}| �t|jddg� dS )zH L{twisted.internet.protocol.FileWrapper.writeSequence} r� s test2s test1test2�test3�test4N)r r � writeSequencer0 r� r� � assertRaises� TypeErrorr� r r r �test_writeSequence s z#FileWrapperTests.test_writeSequenceN)r r r rr r� r� r r r r r� s r� N)$rr �ior �zope.interfacer �zope.interface.verifyr �twisted.internet.deferr �twisted.internet.interfacesr r r r �twisted.internet.protocolr r r r r r �twisted.loggerr r �twisted.python.failurer �twisted.test.proto_helpersr r �twisted.trial.unittestr r rs r� r� r� r r r r �<module> s$ :([%PK Mb�Z,4O3 3 internet/test/__pycache__/test_time.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZmZ ddlmZ ddlmZ ddlm Z ddl m Z G dd� de�Z G d d � d e�Z e� �e �� � e� �e �� � d S ) z/ Tests for implementations of L{IReactorTime}. � )�IReactorThreads� IReactorTime)�ReactorBuilder)�msg)�platform)�SkipTestc @ s& e Zd ZdZefZdd� Zdd� ZdS )�TimeTestsBuilderzA Builder for defining tests relating to L{IReactorTime}. c C s" | � � }|�d|j� |�� dS )z? The reactor can be stopped by a delayed call. r N)� buildReactor� callLater�stop�run)�self�reactor� r �A/usr/lib/python3/dist-packages/twisted/internet/test/test_time.py� test_delayedCallStopsReactor s z-TimeTestsBuilder.test_delayedCallStopsReactorc s� | � � �t���rdd� � ntd����dd d dd� �}�fd d ��� �� ��fd d�� ��� | �|�� � | �|�� � � d S ) z Scheduling a delayed call at a point in the extreme future does not prevent normal reactor operation. c S s t d|d� | �|� d S )Nz.Thread-based event-source scheduling %(event)r)�format�event)r �callFromThread)r r r r r � eventSource& s �z=TimeTestsBuilder.test_distantDelayedCall.<locals>.eventSourcez=Do not know how to synthesize non-time event to stop the test� � � c S s d S �Nr r r r r �<lambda>2 s z:TimeTestsBuilder.test_distantDelayedCall.<locals>.<lambda>c s t d� � �� d S )NzStopping the reactor)r r r )r r r r 4 s z6TimeTestsBuilder.test_distantDelayedCall.<locals>.stopc s � ���S r r r �r r r r r r < s N) r r � providedByr r r � assertTrue�active�assertIn�getDelayedCalls)r � delayedCallr r r �test_distantDelayedCall s � z(TimeTestsBuilder.test_distantDelayedCallN)�__name__� __module__� __qualname__�__doc__r �requiredInterfacesr r" r r r r r s r c @ s6 e Zd ZdZefZe�� rdgZnddgZdd� Z dS )�GlibTimeTestsBuilderza Builder for defining tests relating to L{IReactorTime} for reactors based off glib. z/twisted.internet.gtk2reactor.PortableGtkReactorz*twisted.internet.glib2reactor.Glib2Reactorz(twisted.internet.gtk2reactor.Gtk2Reactorc s^ ddl }| �� �g �� �fdd�}��fdd�� ��|jd|� | ��d� | ��d g� dS ) z� A L{reactor.callLater<twisted.internet.interfaces.IReactorTime.callLater>} call scheduled from a C{gobject.timeout_add} call is run on time. r Nc s �� d� � dS )Nr )r r )�callbackr r r � gscheduleh s z8GlibTimeTestsBuilder.test_timeout_add.<locals>.gschedulec s �� d� � �� d S )NT)�appendr r )r �resultr r r) l s z7GlibTimeTestsBuilder.test_timeout_add.<locals>.callback� � T)�gobjectr �callWhenRunning� timeout_add� runReactor� assertEqual)r r/ r* r )r) r r, r �test_timeout_add[ s z%GlibTimeTestsBuilder.test_timeout_addN) r# r$ r% r& r r' r � isWindows� _reactorsr4 r r r r r( K s � r( N)r& �twisted.internet.interfacesr r �#twisted.internet.test.reactormixinsr �twisted.python.logr �twisted.python.runtimer �twisted.trial.unittestr r r( �globals�update�makeTestCaseClassesr r r r �<module> s <*PK Mb�ZO��.E E 4 internet/test/__pycache__/test_error.cpython-310.pycnu �[��� o �bB � @ s0 d Z ddlmZ ddlmZ G dd� de�ZdS )z% Tests for L{twisted.internet.error} � )�error)�SynchronousTestCasec @ s e Zd ZdZdd� Zdd� ZdS )�ConnectionAbortedTestszN Tests for the L{twisted.internet.error.ConnectionAborted} exception. c C s | � dtt�� �� dS )z� The default message of L{ConnectionAborted} is a sentence which points to L{ITCPTransport.abortConnection()} zCConnection was aborted locally using ITCPTransport.abortConnection.N�� assertEqual�strr �ConnectionAborted��self� r �B/usr/lib/python3/dist-packages/twisted/internet/test/test_error.py�test_str s �z ConnectionAbortedTests.test_strc C s | � dtt�dd��� dS )zc Any arguments passed to L{ConnectionAborted} are included in its message. zLConnection was aborted locally using ITCPTransport.abortConnection: foo bar.�foo�barNr r r r r � test_strArgs s �z#ConnectionAbortedTests.test_strArgsN)�__name__� __module__� __qualname__�__doc__r r r r r r r s r N)r �twisted.internetr �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z�9� �; �; 3 internet/test/__pycache__/test_base.cpython-310.pycnu �[��� o �bt5 � @ sn d Z ddlZddlmZ ddlmZmZ ddlmZ ddl m Z ddl m Z ddl mZmZmZ dd lmZ dd lmZ dd lmZmZmZ dd lmZ dd lm Z ddl m Z m Z zddl Z!W n e"yk dZ Y nw e!Z e ee�G dd� d��Z#G dd� de �Z$dd� Z%G dd� d�Z&G dd� de&e �Z'G dd� de&e �Z(G dd � d e�Z)ee d �G d d � d e ��Z*dS ) z% Tests for L{twisted.internet.base}. � N)�Queue)�Any�Callable)�skipIf)� implementer)� FirstOneWins)� DelayedCall� ReactorBase�ThreadedResolver)�Deferred)�DNSLookupError)�IReactorThreads� IReactorTime�IResolverSimple)�Clock)� ThreadPool)�SkipTest�TestCasec @ sl e Zd ZdZdd� Zdedef fdd�Zdd � Zd d � Z d d � Z dd� Z dedef fdd�Z dd� Z dS )� FakeReactorzl A fake reactor implementation which just supports enough reactor APIs for L{ThreadedResolver}. c s> t � � _� jj� _t� � _� j�� � fdd�� _t� � _d S )Nc s � j S �N)� _threadpool� ��selfr �A/usr/lib/python3/dist-packages/twisted/internet/test/test_base.py�<lambda>- s z&FakeReactor.__init__.<locals>.<lambda>) r �_clock� callLaterr r �start� getThreadPoolr � _threadCallsr r r r �__init__' s zFakeReactor.__init__�callable.c O s | j �|||f� d S r )r �put�r r" �args�kwargsr r r �callFromThread1 s zFakeReactor.callFromThreadc C s" | j �� \}}}||i |�� d S r )r �get)r �fr% r& r r r �_runThreadCalls4 s zFakeReactor._runThreadCallsc C s | j �� d S r )r �stopr r r r �_stop8 s zFakeReactor._stopc C � d S r r r r r r �getDelayedCalls; � zFakeReactor.getDelayedCallsc C r- r r r r r r �seconds? r/ zFakeReactor.secondsc O r- r r r$ r r r � callInThreadC r/ zFakeReactor.callInThreadc C r- r r )r �sizer r r �suggestThreadPoolSizeG r/ z!FakeReactor.suggestThreadPoolSizeN)�__name__� __module__� __qualname__�__doc__r! r r r' r* r, r. r0 r1 r3 r r r r r s r c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �ThreadedResolverTestsz( Tests for L{ThreadedResolver}. c s� d� d}d}t � }| �|j� g �g }� �fdd�}| �td|� t|�}|�||f�}|�|j� |� � | � �|g� | � |� g� |j � |d � | � |j j g � dS ) z� L{ThreadedResolver.getHostByName} returns a L{Deferred} which fires with the value returned by the call to L{socket.gethostbyname} in the threadpool of the reactor passed to L{ThreadedResolver.__init__}. z 10.0.0.17zfoo.bar.example.com� c s �� | � � S r )�append��name��ip�lookedUpr r �fakeGetHostByNamea s z=ThreadedResolverTests.test_success.<locals>.fakeGetHostByName� gethostbyname� N)r � addCleanupr, �patch�socketr � getHostByName� addCallbackr; r* � assertEqualr �advance�calls)r r= �timeout�reactor� resolvedTorA �resolver�dr r> r � test_successQ s" z"ThreadedResolverTests.test_successc C s� d}t � }| �|j� dd� }| �td|� g }t|�}|�d|f�}| �|t� |� |j � |� � | � t |�d� |j�|d � | � |jjg � dS )z� L{ThreadedResolver.getHostByName} returns a L{Deferred} which fires a L{Failure} if the call to L{socket.gethostbyname} raises an exception. r: c S s t d��)Nz ENOBUFS (this is a funny joke))�OSErrorr< r r r rA ~ � z=ThreadedResolverTests.test_failure.<locals>.fakeGetHostByNamerB � some.namerC N)r rD r, rE rF r rG � assertFailurer rH r; r* rI �lenr rJ rK �r rL rM rA � failedWithrO rP r r r � test_failuret s z"ThreadedResolverTests.test_failurec s� d}t � }| �|j� t� � � fdd�}| �td|� g }t|�}|�d|f�}| �|t � |� |j � |j � |d � | �|g � |j � d� | �t|�d� � �td�� dS ) z� If L{socket.gethostbyname} does not complete before the specified timeout elapsed, the L{Deferred} returned by L{ThreadedResolver.getHostByName} fails with L{DNSLookupError}. � c s � � � �r )r( r< ��resultr r rA � rS z=ThreadedResolverTests.test_timeout.<locals>.fakeGetHostByNamerB rT rC zThe I/O was errorfulN)r rD r, r rE rF r rG rU r rH r; r rJ rI rV r# �IOErrorrW r r[ r � test_timeout� s z"ThreadedResolverTests.test_timeoutc s g � t t�G � fdd�d��}G dd� dt�}|� }|� }|�|� tt� �}|j�|d� |j�|d� |j�|d� |j�|d� |j�|d� | �t � �d � | �t t t � ��t gd � | �d� d � | �d� d � | �d � d � | �d� d � | �d� d � dS )zm L{ThreadedResolver.getHostByName} is passed L{str}, encoded using IDNA if required. c s e Zd Zd� fdd� ZdS )zAThreadedResolverTests.test_resolverGivenStr.<locals>.FakeResolverr c s � � |� t� S r )r; r )r r= �timeouts�rK r r rG � s zOThreadedResolverTests.test_resolverGivenStr.<locals>.FakeResolver.getHostByNameN)r )r4 r5 r6 rG r r` r r � FakeResolver� s ra c @ s e Zd Zdd� ZdS )zFThreadedResolverTests.test_resolverGivenStr.<locals>.JustEnoughReactorc S r- r r r r r r � installWaker� � zSThreadedResolverTests.test_resolverGivenStr.<locals>.JustEnoughReactor.installWakerN)r4 r5 r6 rb r r r r �JustEnoughReactor� s rd zexample.exampleu vääntynyt.exampleu рф.examplez xn----7sbb4ac0ad0be6cf.xn--p1ai� r rC zxn--vntynyt-5waa.example� zxn--p1ai.example� � N)r r r �installResolverr r � nameResolver�resolveHostNamerI rV �list�map�type�str)r ra rd �fakerM �recr r` r �test_resolverGivenStr� s( z+ThreadedResolverTests.test_resolverGivenStrN)r4 r5 r6 r7 rQ rY r^ rr r r r r r9 L s # !r9 c C � dS )z8 Function used by L{DelayedCallTests.test_str}. Nr r r r r �nothing� � rt c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )�DelayedCallMixin� L{DelayedCall} c C s dd� }t |dd� di ||d�S )z� Get a L{DelayedCall} instance at a given C{time}. @param time: The absolute time at which the returned L{DelayedCall} will be scheduled. c S r- r r )�callr r r �noop� rc z0DelayedCallMixin._getDelayedCallAt.<locals>.noopc S r- r r r r r r r � ru z4DelayedCallMixin._getDelayedCallAt.<locals>.<lambda>r N)r )r �timery r r r �_getDelayedCallAt� s z"DelayedCallMixin._getDelayedCallAtc C s | � d�| _| � d�| _dS )zb Create two L{DelayedCall} instanced scheduled to run at different times. r rC N)r{ �zero�oner r r r �setUp� s zDelayedCallMixin.setUpc C s: t dtdddidddd� �}| �t|�dt|�f � dS ) �� The string representation of a L{DelayedCall} instance, as returned by L{str}, includes the unsigned id of the instance, as well as its state, the function to be called, and the function arguments. � �rg �Are Nc S rs �Ng �?r r r r r r � ru z+DelayedCallMixin.test_str.<locals>.<lambda>z?<DelayedCall 0x%x [10.5s] called=0 cancelled=0 nothing(3, A=5)>)r rt rI ro �id�r �dcr r r �test_str� s ��zDelayedCallMixin.test_strc C s4 t dtdddidddd� �}| �t|�t|�� dS )z� The string representation of a L{DelayedCall} instance, as returned by {repr}, is identical to that returned by L{str}. � )� r� � Nc S rs )Ng�������?r r r r r r ru z,DelayedCallMixin.test_repr.<locals>.<lambda>)r rt rI ro �reprr� r r r � test_repr s zDelayedCallMixin.test_reprc C sJ | j | j}}| �||k � | �||k � | �||k � | �||k � dS )z� For two instances of L{DelayedCall} C{a} and C{b}, C{a < b} is true if and only if C{a} is scheduled to run before C{b}. N�r| r} � assertTrue� assertFalse�r r| r} r r r �test_lt � zDelayedCallMixin.test_ltc C sJ | j | j}}| �||k� | �||k� | �||k� | �||k� dS )z� For two instances of L{DelayedCall} C{a} and C{b}, C{a <= b} is true if and only if C{a} is scheduled to run before C{b} or at the same time as C{b}. Nr� r� r r r �test_le � zDelayedCallMixin.test_lec C sJ | j | j}}| �||k� | �||k� | �||k� | �||k� dS )z� For two instances of L{DelayedCall} C{a} and C{b}, C{a > b} is true if and only if C{a} is scheduled to run after C{b}. Nr� r� r r r �test_gt" r� zDelayedCallMixin.test_gtc C sJ | j | j}}| �||k� | �||k� | �||k� | �||k� dS )z� For two instances of L{DelayedCall} C{a} and C{b}, C{a > b} is true if and only if C{a} is scheduled to run after C{b} or at the same time as C{b}. Nr� r� r r r �test_ge- r� zDelayedCallMixin.test_gec C s: | � | j| jk� | �| j| jk� | �| j| jk� dS )zD A L{DelayedCall} instance is only equal to itself. N)r� r| r} r� r r r r �test_eq9 � zDelayedCallMixin.test_eqc C s: | � | j| jk� | �| j| jk� | �| j| jk� dS )zM A L{DelayedCall} instance is not equal to any other object. N)r� r| r} r� r r r r �test_neC r� zDelayedCallMixin.test_neN)r4 r5 r6 r7 r{ r~ r� r� r� r� r� r� r� r� r r r r rv � s rv c @ � e Zd ZdZdd� Zdd� ZdS )�DelayedCallNoDebugTestsrw c C � | � tdd� t�| � dS )z! Turn debug off. �debugFN�rE r rv r~ r r r r r~ S � z DelayedCallNoDebugTests.setUpc C �> t dtdddidddd� �}d�t|��}| �t|�|� dS ) r r� r� r� re Nc S rs r� r r r r r r ` ru z2DelayedCallNoDebugTests.test_str.<locals>.<lambda>zA<DelayedCall 0x{:x} [10.5s] called=0 cancelled=0 nothing(3, A=5)>)r rt �formatr� rI ro )r r� �expectedr r r r� Z s �z DelayedCallNoDebugTests.test_strN�r4 r5 r6 r7 r~ r� r r r r r� N � r� c @ r� )�DelayedCallDebugTestsrw c C r� )z Turn debug on. r� TNr� r r r r r~ m r� zDelayedCallDebugTests.setUpc C r� ) r r� r� r� re Nc S rs r� r r r r r r z ru z0DelayedCallDebugTests.test_str.<locals>.<lambda>z\<DelayedCall 0x{:x} \[10.5s\] called=0 cancelled=0 nothing\(3, A=5\) traceback at creation:)r rt r� r� � assertRegexro )r r� �expectedRegexpr r r r� t s �z DelayedCallDebugTests.test_strNr� r r r r r� h r� r� c @ s e Zd ZdZdd� ZdS )� TestSpySignalCapturingReactorza Subclass of ReactorBase to capture signals delivered to the reactor for inspection. c C rs )z* Required method, unused. Nr r r r r rb � ru z*TestSpySignalCapturingReactor.installWakerN)r4 r5 r6 r7 rb r r r r r� � s r� zsignal module not availablec @ r8 ) �ReactorBaseSignalTestszE Tests to exercise ReactorBase's signal exit reporting path. c C s t � }| �d|j� dS )zI The default value of the _exitSignal attribute is None. N)r� �assertIs� _exitSignal�r rM r r r � test_exitSignalDefaultsToNone� s z4ReactorBaseSignalTests.test_exitSignalDefaultsToNonec C �( t � }|�tjd� | �tj|j� dS )zn ReactorBase's SIGINT handler saves the value of SIGINT to the _exitSignal attribute. N)r� �sigInt�signal�SIGINT� assertEqualsr� r� r r r �test_captureSIGINT� � z)ReactorBaseSignalTests.test_captureSIGINTc C r� )zp ReactorBase's SIGTERM handler saves the value of SIGTERM to the _exitSignal attribute. N)r� �sigTermr� �SIGTERMr� r� r� r r r �test_captureSIGTERM� r� z*ReactorBaseSignalTests.test_captureSIGTERMc C s: t td�s td��t� }|�tjd� | �tj|j� dS )zr ReactorBase's SIGBREAK handler saves the value of SIGBREAK to the _exitSignal attribute. �SIGBREAKz$signal module does not have SIGBREAKN)�hasattrr� r r� �sigBreakr� r� r� r� r r r �test_captureSIGBREAK� s z+ReactorBaseSignalTests.test_captureSIGBREAKN)r4 r5 r6 r7 r� r� r� r� r r r r r� � s r� )+r7 rF �queuer �typingr r �unittestr �zope.interfacer �twisted.internet._resolverr �twisted.internet.baser r r �twisted.internet.deferr �twisted.internet.errorr �twisted.internet.interfacesr r r �twisted.internet.taskr �twisted.python.threadpoolr �twisted.trial.unittestr r r� �_signal� ImportErrorr r9 rt rv r� r� r� r� r r r r �<module> s> �+ r PK Mb�Z"(�G�# �# 5 internet/test/__pycache__/test_socket.cpython-310.pycnu �[��� o �b�$ � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z m Z ddl m Z mZ ddlmZ dd lmZ G d d � d e �ZG d d � d e �ZG dd� de �ZG dd� de �Ze� �e�� � e� �e�� � e� �e�� � e� �e�� � dS )aD Tests for implementations of L{IReactorSocket}. Generally only tests for failure cases are found here. Success cases for this interface are tested elsewhere. For example, the success case for I{AF_INET} is in L{twisted.internet.test.test_tcp}, since that case should behave exactly the same as L{IReactorTCP.listenTCP}. � N)�verify)�UnsupportedAddressFamily)�IReactorSocket)�DatagramProtocol� ServerFactory)�ReactorBuilder�needsRunningReactor)�err)�platformc @ � e Zd ZdZegZdd� ZdS )�&IReactorSocketVerificationTestsBuilderaO Builder for testing L{IReactorSocket} implementations for required methods and method signatures. L{ReactorBuilder} already runs L{IReactorSocket.providedBy} to ensure that these tests will only be run on reactor classes that claim to implement L{IReactorSocket}. These tests ensure that reactors which claim to provide the L{IReactorSocket} interface actually have all the required methods and that those methods have the expected number of arguments. These tests will be skipped for reactors which do not claim to provide L{IReactorSocket}. c C s | � � }| �t�t|�� dS )zf The reactor instance returned by C{buildReactor} provides L{IReactorSocket}. N)� buildReactor� assertTruer � verifyObjectr )�self�reactor� r �C/usr/lib/python3/dist-packages/twisted/internet/test/test_socket.py� test_provider- s z4IReactorSocketVerificationTestsBuilder.test_providerN)�__name__� __module__� __qualname__�__doc__r �requiredInterfacesr r r r r r s r c @ �. e Zd ZdZegZdd� Zdd� Zdd� ZdS ) �!AdoptStreamPortErrorsTestsBuilderas Builder for testing L{IReactorSocket.adoptStreamPort} implementations. Generally only tests for failure cases are found here. Success cases for this interface are tested elsewhere. For example, the success case for I{AF_INET} is in L{twisted.internet.test.test_tcp}, since that case should behave exactly the same as L{IReactorTCP.listenTCP}. c C �r | � � }t�� }|�� }|�� | �tj|j|tjt� �}t � � r-| � |j d t j� dS | � |j d t j� dS )z� An implementation of L{IReactorSocket.adoptStreamPort} raises L{socket.error} if passed an integer which is not associated with a socket. r N)r �socket�fileno�close� assertRaises�error�adoptStreamPort�AF_INETr r � isWindows� assertEqual�args�errno� WSAENOTSOCK�EBADF�r r �prober �excr r r �test_invalidDescriptorB � �z8AdoptStreamPortErrorsTestsBuilder.test_invalidDescriptorc C sR | � � }t�� }|�d� |�d� | �|j� d}| �t|j|� � |t � � dS )z� An implementation of L{IReactorSocket.adoptStreamPort} raises L{UnsupportedAddressFamily} if passed an address family it does not support. �z 127.0.0.1r � � N) r r �bind�listen� addCleanupr r r r" r r �r r �port� arbitraryr r r �test_invalidAddressFamilyZ s �z;AdoptStreamPortErrorsTestsBuilder.test_invalidAddressFamilyc s� �� � �t�� ����j� ��d� ��d� ��d� ����� �j t � �}|� � � ��fdd�}� � |� � � td� t�� �fdd�� ��� d S ) a9 When the L{IListeningPort} returned by L{IReactorSocket.adoptStreamPort} is stopped using C{stopListening}, the underlying socket is closed but not shutdown. This allows another process which still has a reference to it to continue accepting connections over it. r/ r0 Fc sH �� tj� j�}t�� r��|jd tj � d S ��|jd tj � d S )Nr ) r r r! �acceptr r$ r% r& r' �WSAEWOULDBLOCK�EAGAIN��ignoredr, �� portSocketr r r �stopped� s zFAdoptStreamPortErrorsTestsBuilder.test_stopOnlyCloses.<locals>.stoppedz"Failed to accept on original port.c � � � �fdd��S )Nc � � � � S �N��stop�r= �r r r �<lambda>� � zYAdoptStreamPortErrorsTestsBuilder.test_stopOnlyCloses.<locals>.<lambda>.<locals>.<lambda>�� addCallbackr ��dr r r rH � � zGAdoptStreamPortErrorsTestsBuilder.test_stopOnlyCloses.<locals>.<lambda>N)r r r4 r r2 r3 � setblockingr" r �familyr � stopListeningrK � addErrbackr r �run�r r6 r@ r �rM r? r r r �test_stopOnlyClosesq s" � � z5AdoptStreamPortErrorsTestsBuilder.test_stopOnlyClosesN� r r r r r r r- r8 rV r r r r r 6 s r c @ r )�'AdoptStreamConnectionErrorsTestsBuildera} Builder for testing L{IReactorSocket.adoptStreamConnection} implementations. Generally only tests for failure cases are found here. Success cases for this interface are tested elsewhere. For example, the success case for I{AF_INET} is in L{twisted.internet.test.test_tcp}, since that case should behave exactly the same as L{IReactorTCP.listenTCP}. c C s> | � � }t�� }| �|j� d}| �t|j|�� |t� � dS )z� An implementation of L{IReactorSocket.adoptStreamConnection} raises L{UnsupportedAddressFamily} if passed an address family it does not support. r1 N) r r r4 r r r �adoptStreamConnectionr r )r r � connectionr7 r r r r8 � s �zAAdoptStreamConnectionErrorsTestsBuilder.test_invalidAddressFamilyN)r r r r r r r8 r r r r rX � s rX c @ r ) �#AdoptDatagramPortErrorsTestsBuilderzR Builder for testing L{IReactorSocket.adoptDatagramPort} implementations. c C r )z� An implementation of L{IReactorSocket.adoptDatagramPort} raises L{socket.error} if passed an integer which is not associated with a socket. r N)r r r r r r! �adoptDatagramPortr# r r r$ r% r& r' r( r) r* r r r r- � r. z:AdoptDatagramPortErrorsTestsBuilder.test_invalidDescriptorc C sF | � � }t�tjtj�}| �|j� d}| �t|j|� � |t � � dS )z� An implementation of L{IReactorSocket.adoptDatagramPort} raises L{UnsupportedAddressFamily} if passed an address family it does not support. r1 N) r r r# � SOCK_DGRAMr4 r r r r\ r r r5 r r r r8 � s �z=AdoptDatagramPortErrorsTestsBuilder.test_invalidAddressFamilyc s� �� � �t�tjtj�����j� ��d� ��d� ���� � �j t � �}|� � � ��fdd�}� � |� � �td� t�� �fdd�� ��� dS ) a7 When the L{IListeningPort} returned by L{IReactorSocket.adoptDatagramPort} is stopped using C{stopListening}, the underlying socket is closed but not shutdown. This allows another process which still has a reference to it to continue reading and writing to it. r/ Fc sJ �� tj� jd�}t�� r��|jd tj � d S ��|jd tj � d S )Nr0 r ) r r r! �recvfromr r$ r% r& r' r: r; r< r> r r r@ s zHAdoptDatagramPortErrorsTestsBuilder.test_stopOnlyCloses.<locals>.stoppedz Failed to read on original port.c rA )Nc rB rC rD rF rG r r rH rI z[AdoptDatagramPortErrorsTestsBuilder.test_stopOnlyCloses.<locals>.<lambda>.<locals>.<lambda>rJ r rL r r rH rN zIAdoptDatagramPortErrorsTestsBuilder.test_stopOnlyCloses.<locals>.<lambda>N)r r r# r] r4 r r2 rO r\ r rP r rQ rK rR r r rS rT r rU r rV � s � � z7AdoptDatagramPortErrorsTestsBuilder.test_stopOnlyClosesNrW r r r r r[ � s r[ )r r' r �zope.interfacer �twisted.internet.errorr �twisted.internet.interfacesr �twisted.internet.protocolr r �#twisted.internet.test.reactormixinsr r �twisted.python.logr �twisted.python.runtimer r r rX r[ �globals�update�makeTestCaseClassesr r r r �<module> s$ f#]PK Mb�Z#��i i : internet/test/__pycache__/test_pollingfile.cpython-310.pycnu �[��� o �b � @ sd d Z ddlmZ ddlmZ ddlmZ e�� r ddlm Z ndZ ee du d�G dd � d e��Z dS ) z- Tests for L{twisted.internet._pollingfile}. � )�skipIf)�platform)�TestCase)� _pollingfileNz Test will run only on Windows.c @ s e Zd ZdZdd� Zdd� ZdS )�PollableWritePipeTestsz7 Tests for L{_pollingfile._PollableWritePipe}. c C s$ t �ddd� �}| �t|jd� dS )z� L{_pollingfile._PollableWritePipe.write} raises a C{TypeError} if an attempt is made to append unicode data to the output buffer. � c S � d S �N� r r r �H/usr/lib/python3/dist-packages/twisted/internet/test/test_pollingfile.py�<lambda> � z:PollableWritePipeTests.test_writeUnicode.<locals>.<lambda>�testN)r �_PollableWritePipe� assertRaises� TypeError�write��self�pr r r �test_writeUnicode s z(PollableWritePipeTests.test_writeUnicodec C s6 t �ddd� �}| �t|jdg� | �t|jd� dS )z� L{_pollingfile._PollableWritePipe.writeSequence} raises a C{TypeError} if unicode data is part of the data sequence to be appended to the output buffer. r c S r r r r r r r r ' r zBPollableWritePipeTests.test_writeSequenceUnicode.<locals>.<lambda>r )r N)r r r r � writeSequencer r r r �test_writeSequenceUnicode! s z0PollableWritePipeTests.test_writeSequenceUnicodeN)�__name__� __module__� __qualname__�__doc__r r r r r r r s r ) r �unittestr �twisted.python.runtimer �twisted.trial.unittestr � isWindows�twisted.internetr r r r r r �<module> s PK Mb�Z+T�� � 8 internet/test/__pycache__/test_endpoints.cpython-310.pycnu �[��� o �b�D � @ sR d Z ddlmZ ddlmZmZmZmZmZ ddl m Z ddl m Z ddl mZ ddlmZmZmZ ddlmZ dd lmZmZ dd lmZ dd lmZm Z m Z m Z m Z m Z m!Z!m"Z" dd l#m$Z$ dd l%m&Z&m'Z'm(Z(m)Z)m*Z* ddl+m,Z, ddl-m.Z. ddl/m0Z0m1Z1m2Z2m3Z3m4Z4 ddl5m6Z6m7Z7m8Z8 ddl9m:Z: ddl;m<Z< ddl=m>Z?m@Z@mAZAmBZB ddlCmDZDmEZE ddlFmGZG ddlHmIZImJZJ ddlKmLZL ddlMmNZN ddlOmPZP ddlQmRZR dd lSmTZT dd lUmVZV dd lWmXZX dd lYmZZZm[Z[ dd l\m Z eVd!�j]�^d"�Z_eVd!�j]�^d#�Z`eVd!�j]�^d$�ZaeVeb�j]�^d%�Zcec�dd&�Zee �fe_jg�Zhe �fe`jg�Zie �feajg�Zje �fecjg�Zke �feejg�Zlz:dd'lmmnZompZpmqZqmrZr dd(lsmtZtmuZumvZvmwZwmxZx dd)lymzZz dd*l{m|Z| et�}e_�~� �Zex�}e_�~� �Z�d+Z�d,Z�W n e��y� Z� z d-Z�e�e��Z�W Y d.Z�[�nd.Z�[�ww G d/d0� d0e8�Z�ee j��G d1d2� d2e���Z�ee j��G d3d4� d4e���Z�ee j��G d5d6� d6e���Z�G d7d8� d8e6�Z�G d9d:� d:e6�Z�G d;d<� d<e j��Z�G d=d>� d>�Z�G d?d@� d@�Z�G dAdB� dBe�e��Z�G dCdD� dDe7�Z�G dEdF� dF�Z�G dGdH� dHe j��Z�G dIdJ� dJe j8�Z�ee j��G dKdL� dLeB��Z�ee j0e�� ee j2e�� ee j�e�� ee j��G dMdN� dN��Z�G dOdP� dPe j��Z�G dQdR� dRe j��Z�G dSdT� dTe j��Z�G dUdV� dVe�e j��Z�G dWdX� dXe�e j��Z�G dYdZ� dZe�e j��Z�G d[d\� d\e@e<�Z�d�d^d_�Z�G d`da� dae j��Z�G dbdc� dce j��Z�G ddde� dee��Z�G dfdg� dge�e j��Z�G dhdi� die�e j��Z�G djdk� dke�e j��Z�G dldm� dme�e j��Z�G dndo� doe j��Z�G dpdq� dqe j��Z�G drds� dse j��Z�G dtdu� due j��Z�ee�e��G dvdw� dwe�e j���Z�G dxdy� dye�e j��Z�G dzd{� d{e j��Z�G d|d}� d}e j��Z�d�dd��Z�G d�d�� d�e j��Z�ee�e��G d�d�� d�e j���Z�G d�d�� d�e�e j��Z�G d�d�� d�e j��Z�G d�d�� d�e j��Z�G d�d�� d�e j��Z�G d�d�� d�e j��Z�G d�d�� d�eJj��Z�G d�d�� d�eJj��Z�G d�d�� d�eIj��Z�G d�d�� d�eZ�G d�d�� d�e j��Z�d�d�� Z�ee�e��G d�d�� d�e j���Z�d�d�� Z�G d�d�� d�e j��Z�d.S )�z� Test the C{I...Endpoint} implementations that wrap the L{IReactorTCP}, L{IReactorSSL}, and L{IReactorUNIX} interfaces found in L{twisted.internet.endpoints}. � )�EPERM)�AF_INET�AF_INET6� IPPROTO_TCP� SOCK_STREAM�gaierror)� FunctionType)� normalize)�skipIf)� implementer� providedBy�provider)�InterfaceClass)� verifyClass� verifyObject)�plugins)�defer� endpoints�error� interfaces�protocol�reactor�stdio�threads)� isIPv6Address)�HostnameAddress� IPv4Address� IPv6Address� UNIXAddress�_ProcessAddress)�StandardErrorBehavior)�ConnectingCancelledError)� IConsumer�IHostnameResolver� IPushProducer� IReactorPluggableNameResolver� ITransport)� ClientFactory�Factory�Protocol)� PipeAddress)�Clock)�MemoryReactorClock�RaisingMemoryReactor�StringTransport� StringTransportWithDisconnection)� ILogObserver�globalLogPublisher)� getPlugins)�basic�policies)�log)� nativeString)�proxyForInterface)�Failure)�FilePath)� getModule)� ListenFDs)�connectableEndpoint�connectedServerAndClient)�unittestz twisted.testz server.pemzkey.pem.no_trailing_newlinez cert.pem.no_trailing_newline�fake_CAsz chain.pem)�Context� OP_NO_SSLv3� SSLv23_METHOD� TLSv1_METHOD)� Certificate�CertificateOptions�DiffieHellmanParameters�KeyPair�PrivateCertificate��TLSMemoryBIOFactory)�makeCertificateF� TNc @ �8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � TestProtocolzx Protocol whose only function is to callback deferreds on the factory when it is connected or disconnected. c C s g | _ g | _d| _d S �Nr )�data�connectionsLost�connectionMadeCalls��self� rU �F/usr/lib/python3/dist-packages/twisted/internet/test/test_endpoints.py�__init__| s zTestProtocol.__init__c C s dS )N�A Test ProtocolrU rS rU rU rV � logPrefix� � zTestProtocol.logPrefixc C s | j d7 _ d S �N� )rR rS rU rU rV �connectionMade� � zTestProtocol.connectionMadec C � | j �|� d S �N)rP �append�rT rP rU rU rV � dataReceived� � zTestProtocol.dataReceivedc C r_ r` )rQ ra �rT �reasonrU rU rV �connectionLost� rd zTestProtocol.connectionLostN) �__name__� __module__� __qualname__�__doc__rW rY r] rc rg rU rU rU rV rN v s rN c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �TestHalfCloseableProtocolab A Protocol that implements L{IHalfCloseableProtocol} and records whether its C{readConnectionLost} and {writeConnectionLost} methods are called. @ivar readLost: A C{bool} indicating whether C{readConnectionLost} has been called. @ivar writeLost: A C{bool} indicating whether C{writeConnectionLost} has been called. c C s t �| � d| _d| _d S )NF)rN rW �readLost� writeLostrS rU rU rV rW � s z"TestHalfCloseableProtocol.__init__c C � d| _ d S �NT)rn rS rU rU rV �readConnectionLost� � z,TestHalfCloseableProtocol.readConnectionLostc C rp rq )ro rS rU rU rV �writeConnectionLost� rs z-TestHalfCloseableProtocol.writeConnectionLostN)rh ri rj rk rW rr rt rU rU rU rV rm � s rm c @ � e Zd ZdZdd� Zdd� ZdS )�"TestFileDescriptorReceiverProtocola A Protocol that implements L{IFileDescriptorReceiver} and records how its C{fileDescriptorReceived} method is called. @ivar receivedDescriptors: A C{list} containing all of the file descriptors passed to C{fileDescriptorReceived} calls made on this instance. c C s t �| � g | _d S r` )rN r] �receivedDescriptorsrS rU rU rV r] � � z1TestFileDescriptorReceiverProtocol.connectionMadec C r_ r` )rw ra )rT � descriptorrU rU rV �fileDescriptorReceived� rd z9TestFileDescriptorReceiverProtocol.fileDescriptorReceivedN)rh ri rj rk r] rz rU rU rU rV rv � s rv c @ ru )�TestHandshakeListenera A Protocol that implements L{IHandshakeListener} and records the number of times its C{handshakeCompleted} method has been called. @ivar handshakeCompletedCalls: The number of times C{handshakeCompleted} @type handshakeCompletedCalls: L{int} c C s t �| � d| _d S rO )rN rW �handshakeCompletedCallsrS rU rU rV rW � rx z TestHandshakeListener.__init__c C s | j d7 _ dS )zk Called when a TLS handshake has completed. Implemented per L{IHandshakeListener} r\ N)r| rS rU rU rV �handshakeCompleted� � z(TestHandshakeListener.handshakeCompletedN)rh ri rj rk rW r} rU rU rU rV r{ � s r{ c @ � e Zd ZdZeZdS )� TestFactoryz� Simple factory to be used both when connecting and listening. It contains two deferreds which are called back when my protocol connects and disconnects. N)rh ri rj rk rN r rU rU rU rV r� � s r� c @ � e Zd ZdZdd� ZdS )� NoneFactoryzC A one off factory whose C{buildProtocol} returns L{None}. c C � d S r` rU �rT �addrrU rU rV � buildProtocol� rZ zNoneFactory.buildProtocolN�rh ri rj rk r� rU rU rU rV r� � � r� c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,S )-�WrappingFactoryTestszS Test the behaviour of our ugly implementation detail C{_WrappingFactory}. c C s* t � }t�|�}|�� | �d|j� dS )z� L{_WrappingFactory.doStart} passes through to the wrapped factory's C{doStart} method, allowing application-specific setup and logging. r\ N)r' r �_WrappingFactory�doStart� assertEqual�numPorts�rT �factory�wfrU rU rV � test_doStart� s z!WrappingFactoryTests.test_doStartc C s0 t � }d|_t�|�}|�� | �d|j� dS )z� L{_WrappingFactory.doStop} passes through to the wrapped factory's C{doStop} method, allowing application-specific cleanup and logging. � � N)r' r� r r� �doStopr� r� rU rU rV � test_doStop� s z WrappingFactoryTests.test_doStopc sJ G dd� dt �}t�|� �}|�d� � �|jt�}|�� fdd�� |S )z� An exception raised in C{buildProtocol} of our wrappedFactory results in our C{onConnection} errback being fired. c @ r� )zCWrappingFactoryTests.test_failedBuildProtocol.<locals>.BogusFactoryzZ A one off factory whose C{buildProtocol} raises an C{Exception}. c S s t d��)N� My protocol is poorly defined.)� ValueErrorr� rU rU rV r� s zQWrappingFactoryTests.test_failedBuildProtocol.<locals>.BogusFactory.buildProtocolNr� rU rU rU rV � BogusFactory r� r� Nc s � � | jd�S )N)r� )r� �args)�erS rU rV �<lambda> s z?WrappingFactoryTests.test_failedBuildProtocol.<locals>.<lambda>)r' r r� r� � assertFailure� _onConnectionr� � addCallback)rT r� r� �drU rS rV �test_failedBuildProtocol� s �z-WrappingFactoryTests.test_failedBuildProtocolc C s* t �t� �}|�d� | �|jtj� dS )z� If the wrapped factory's C{buildProtocol} returns L{None} the C{onConnection} errback fires with L{error.NoProtocol}. N)r r� r� r� �failureResultOfr� r � NoProtocol�rT �wrappingFactoryrU rU rV �test_buildNoneProtocol s z+WrappingFactoryTests.test_buildNoneProtocolc C s0 t �t� �}|j�dd� � | �|�d�� dS )z� If the wrapped factory's C{buildProtocol} returns L{None} then L{endpoints._WrappingFactory.buildProtocol} returns L{None}. c S r� r` rU �rf rU rU rV r� & � zDWrappingFactoryTests.test_buildProtocolReturnsNone.<locals>.<lambda>N)r r� r� r� � addErrback� assertIsNoner� r� rU rU rV � test_buildProtocolReturnsNone s z2WrappingFactoryTests.test_buildProtocolReturnsNonec C s* t �t� �}|�d�}| �|�� d� dS )z� If the wrapped protocol provides L{ILoggingContext}, whatever is returned from the wrapped C{logPrefix} method is returned from L{_WrappingProtocol.logPrefix}. NrX )r r� r� r� r� rY )rT r� �wprU rU rV �test_logPrefixPassthrough* s z.WrappingFactoryTests.test_logPrefixPassthroughc C sB G dd� d�}t � }||_t�|�}|�d�}| �|�� d� dS )z� If the wrapped protocol does not provide L{ILoggingContext}, the wrapped protocol's class name is returned from L{_WrappingProtocol.logPrefix}. c @ � e Zd ZdS )z>WrappingFactoryTests.test_logPrefixDefault.<locals>.NoProtocolN�rh ri rj rU rU rU rV r� ; s r� N)r� r r r� r� r� rY )rT r� r� r� r� rU rU rV �test_logPrefixDefault4 s z*WrappingFactoryTests.test_logPrefixDefaultc C s^ t �t� �}|�d�}|�d� |�d� | �|jjdg� |�d� | �|jjddg� dS )z� The wrapped C{Protocol}'s C{dataReceived} will get called when our C{_WrappingProtocol}'s C{dataReceived} gets called. Ns foos bar) r r� r� r� �makeConnectionrc r� �_wrappedProtocolrP )rT r� �prU rU rV � test_wrappedProtocolDataReceivedD s z5WrappingFactoryTests.test_wrappedProtocolDataReceivedc C sH t �t� �}|�d�}t� }|�|� | �|j|� | �|jj|� dS )zo Our transport is properly hooked up to the wrappedProtocol when a connection is made. N) r r� r� r� �objectr� r� � transportr� )rT r� r� �dummyTransportrU rU rV � test_wrappedProtocolTransportS s z2WrappingFactoryTests.test_wrappedProtocolTransportc C s: t � }t�|�}|�d�}|�d� | �|jjdg� dS )z� Our wrappedProtocol's connectionLost method is called when L{_WrappingProtocol.connectionLost} is called. N�fail)r� r r� r� rg r� r� rQ )rT �tfr� r� rU rU rV �"test_wrappedProtocolConnectionLostc s z7WrappingFactoryTests.test_wrappedProtocolConnectionLostc sV t �t� �}ttjdd��}|�d|� g � � fdd�}|j�|� | � � |g� dS )z� Calls to L{_WrappingFactory.clientConnectionLost} should errback the L{_WrappingFactory._onConnection} L{Deferred} r� ��stringNc � � � | � d S r` �ra ��f��errorsrU rV �gotError| � zBWrappingFactoryTests.test_clientConnectionFailed.<locals>.gotError) r r� r� r8 r � ConnectError�clientConnectionFailedr� r� r� )rT r� �expectedFailurer� rU r� rV �test_clientConnectionFailedp s z0WrappingFactoryTests.test_clientConnectionFailedc C s> d}t � }t�||�}| �tj�|�� | �ttj|�� dS )zv Our L{_WrappingProtocol} should be an L{IFileDescriptorReceiver} if the wrapped protocol is. N)rv r �_WrappingProtocol� assertTruer �IFileDescriptorReceiverr r )rT �connectedDeferred�applicationProtocol�wrapperrU rU rV �+test_wrappingProtocolFileDescriptorReceiver� s z@WrappingFactoryTests.test_wrappingProtocolFileDescriptorReceiverc C �( t � }t�d|�}| �tj�|�� dS )z~ Our L{_WrappingProtocol} does not provide L{IHalfCloseableProtocol} if the wrapped protocol doesn't. N)rN r r� � assertFalser r� r �rT �tpr� rU rU rV �.test_wrappingProtocolNotFileDescriptorReceiver� � zCWrappingFactoryTests.test_wrappingProtocolNotFileDescriptorReceiverc C s@ t � }t�t�� |�}|�t� � |�d� | �|j dg� dS )z� L{_WrappingProtocol.fileDescriptorReceived} calls the wrapped protocol's C{fileDescriptorReceived} method. �* N) rv r r� r �Deferredr� r. rz r� rw )rT �wrappedProtocolr� rU rU rV �*test_wrappedProtocolFileDescriptorReceived� s z?WrappingFactoryTests.test_wrappedProtocolFileDescriptorReceivedc C s0 t � }t� }t�||�}| �tj�|�d� dS )zw Our L{_WrappingProtocol} should be an L{IHalfCloseableProtocol} if the C{wrappedProtocol} is. TN)r� rm r r� r� r �IHalfCloseableProtocolr )rT �cd�hcpr� rU rU rV �"test_wrappingProtocolHalfCloseable� s z7WrappingFactoryTests.test_wrappingProtocolHalfCloseablec C s* t � }t�d|�}| �tj�|�d� dS )z� Our L{_WrappingProtocol} should not provide L{IHalfCloseableProtocol} if the C{WrappedProtocol} doesn't. NF)rN r r� r� r r� r r� rU rU rV �%test_wrappingProtocolNotHalfCloseable� s z:WrappingFactoryTests.test_wrappingProtocolNotHalfCloseablec C r� )zs Our L{_WrappingProtocol} should be an L{IHandshakeListener} if the C{wrappedProtocol} is. N)r{ r r� r� r �IHandshakeListenerr )rT �handshakeListener�wrappedrU rU rV �&test_wrappingProtocolHandshakeListener� r� z;WrappingFactoryTests.test_wrappingProtocolHandshakeListenerc C r� )z~ Our L{_WrappingProtocol} should not provide L{IHandshakeListener} if the C{wrappedProtocol} doesn't. N)rN r r� r� r r� r r� rU rU rV �)test_wrappingProtocolNotHandshakeListener� r� z>WrappingFactoryTests.test_wrappingProtocolNotHandshakeListenerc C �* t � }t�d|�}|�� | �|j� dS )z~ L{_WrappingProtocol.readConnectionLost} should proxy to the wrapped protocol's C{readConnectionLost} N)rm r r� rr r� rn �rT r� r� rU rU rV �&test_wrappedProtocolReadConnectionLost� � z;WrappingFactoryTests.test_wrappedProtocolReadConnectionLostc C r� )z� L{_WrappingProtocol.writeConnectionLost} should proxy to the wrapped protocol's C{writeConnectionLost} N)rm r r� rt r� ro r� rU rU rV �'test_wrappedProtocolWriteConnectionLost� r� z<WrappingFactoryTests.test_wrappedProtocolWriteConnectionLostc C s, t � }t�d|�}|�� | �|jd� dS )z~ L{_WrappingProtocol.handshakeCompleted} should proxy to the wrapped protocol's C{handshakeCompleted} Nr\ )r{ r r� r} r� r| )rT �listenerr� rU rU rV �&test_wrappedProtocolHandshakeCompleted� s z;WrappingFactoryTests.test_wrappedProtocolHandshakeCompletedN)rh ri rj rk r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rU rU rU rV r� � s. r� c @ �@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�ClientEndpointTestCaseMixin�Q Generic test methods to be mixed into all client endpoint test classes. c C �0 t � }| �t� |�\}}}| �ttj|�� dS )zK The endpoint provides L{interfaces.IStreamClientEndpoint} N)r� �createClientEndpoint� MemoryReactorr� r r �IStreamClientEndpoint)rT � clientFactory�ep� ignoredArgs�addressrU rU rV �test_interface� � �z*ClientEndpointTestCaseMixin.test_interfacec C � | � |�d d S )z� Retrieve a single factory that has connected using the given reactor. (This behavior is valid for TCP and SSL but needs to be overridden for UNIX.) @param reactor: a L{MemoryReactor} r r� ��expectedClients�rT r rU rU rV �retrieveConnectedFactory� s z4ClientEndpointTestCaseMixin.retrieveConnectedFactoryc s� t � }t� }t � }| �||�\}}}|�|�}g � � fdd�}|�|� | �|�} | j�|� | �� |g� | � |�} | �t | �d� | � | d |� dS )z} A client endpoint can connect and returns a deferred who gets called back with a protocol instance. c r� r` r� �r� ��receivedProtosrU rV � checkProto r� zKClientEndpointTestCaseMixin.test_endpointConnectSuccess.<locals>.checkProtor\ r N) r� r� r� �connectr� r� r� �callbackr� r� �len�assertConnectArgs� rT �proto�mreactorr� r� � expectedArgs� ignoredDestr� r r� r� rU r� rV �test_endpointConnectSuccess� s � z7ClientEndpointTestCaseMixin.test_endpointConnectSuccessc sd t jdd�}t|d�}t� }| �||�\}}}|�|�}g � � fdd�}|�|� | �� |g� dS )�t If an endpoint tries to connect to a non-listening port it gets a C{ConnectError} failure. �Connection Failedr� ��connectExceptionc � � � | j� d S r` �ra �valuer� ��receivedExceptionsrU rV � checkFailure2 rd zMClientEndpointTestCaseMixin.test_endpointConnectFailure.<locals>.checkFailureN)r r� r- r� r� r r� r� ) rT � expectedErrorr r� r� r� r r� r rU r rV �test_endpointConnectFailure s � z7ClientEndpointTestCaseMixin.test_endpointConnectFailurec s� t � }t� }| �||�\}}}|�|�}g � � fdd�}|�|� |�� | �|�}|�dtt � � �� | � t � �d� � d } | � | jt j� | � | jj|� dS )�� Calling L{Deferred.cancel} on the L{Deferred} returned from L{IStreamClientEndpoint.connect} is errbacked with an expected L{ConnectingCancelledError} exception. c r� r` r� r� ��receivedFailuresrU rV r I r� zRClientEndpointTestCaseMixin.test_endpointConnectingCancelled.<locals>.checkFailureNr\ r )r� r� r� r r� �cancelr� r� r8 r � UserErrorr� r �assertIsInstancer r! r� ) rT r r� r� r� r� r� r �attemptFactory�failurerU r rV � test_endpointConnectingCancelled9 s z<ClientEndpointTestCaseMixin.test_endpointConnectingCancelledc C sb t � }t� }| j||fi | �� ��\}}}|�|� | �|�}| �t|�d� | �|d |� dS )zn The endpoint should pass it's connectArgs parameter to the reactor's listen methods. r\ r N) r� r� r� � connectArgsr r� r� r r )rT r� r r� r � ignoredHostr� rU rU rV �"test_endpointConnectNonDefaultArgs\ s � � z>ClientEndpointTestCaseMixin.test_endpointConnectNonDefaultArgsN) rh ri rj rk r� r� r r r r" rU rU rU rV r� � s #r� c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �ServerEndpointTestCaseMixinr� c C r� )zL The endpoint provides L{interfaces.IStreamServerEndpoint}. N)r� �createServerEndpointr� r� r r �IStreamServerEndpoint)rT r� r� r� r rU rU rV r� v r� z*ServerEndpointTestCaseMixin.test_interfacec sh t � }t� }| �||�\}}}|�|�}g � � fdd�}|�|� | �� |g� | �| �|�|g� dS )zs An endpoint can listen and returns a deferred that gets called back with a port instance. c s � � | �� � d S r` )ra �getHost)�port�� receivedHostsrU rV �checkPortAndServer� r^ zRServerEndpointTestCaseMixin.test_endpointListenSuccess.<locals>.checkPortAndServerN)r� r� r% �listenr� r� �expectedServers)rT r r� r� r � expectedHostr� r+ rU r) rV �test_endpointListenSuccess� s z6ServerEndpointTestCaseMixin.test_endpointListenSuccessc sh t � }t�dd|�}t|d�}| �||�\}}}|�t � �}g � � fdd�}|�|� | �� |g� dS )z� When an endpoint tries to listen on an already listening port, a C{CannotListenError} failure is errbacked. rL �P )�listenExceptionc r r` r r� r rU rV r � rd zLServerEndpointTestCaseMixin.test_endpointListenFailure.<locals>.checkFailureN)r� r �CannotListenErrorr- r% r, r� r� ) rT r� � exceptionr r� r� r r� r rU r rV �test_endpointListenFailure� s z6ServerEndpointTestCaseMixin.test_endpointListenFailurec C sP t � }t� }| j||fi | �� ��\}}}|�|� | �|�}| �||g� dS )zm The endpoint should pass it's listenArgs parameter to the reactor's listen methods. N)r� r� r% � listenArgsr, r- r� )rT r� r r� r r! r- rU rU rV �!test_endpointListenNonDefaultArgs� s � � z=ServerEndpointTestCaseMixin.test_endpointListenNonDefaultArgsN)rh ri rj rk r� r/ r4 r6 rU rU rU rV r$ q s r$ c @ � e Zd ZdZdS )�EndpointTestCaseMixinzJ Generic test methods to be mixed into all endpoint test classes. N�rh ri rj rk rU rU rU rV r8 � � r8 c @ ru )�SpecificFactoryz� An L{IProtocolFactory} whose C{buildProtocol} always returns its C{specificProtocol} and sets C{passedAddress}. Raising an exception if C{specificProtocol} has already been used. c C s || _ d S r` )�specificProtocol)rT r< rU rU rV rW � rs zSpecificFactory.__init__c C s" t | jd�r td��|| j_| jS )N� passedAddressz specificProtocol already used.)�hasattrr< r� r= r� rU rU rV r� � s z SpecificFactory.buildProtocolN)rh ri rj rk rW r� rU rU rU rV r; � s r; c @ � e Zd ZdZddd�ZdS )� FakeStdioz_ A L{stdio.StandardIO} like object that simply captures its constructor arguments. Nc C s || _ || _dS )z� @param protocolInstance: like the first argument of L{stdio.StandardIO} @param reactor: like the reactor keyword argument of L{stdio.StandardIO} N)�protocolInstancer )rT rA r rU rU rV rW � s zFakeStdio.__init__r` �rh ri rj rk rW rU rU rU rV r@ � s r@ c @ rl ) �StandardIOEndpointsTestsz* Tests for Standard I/O Endpoints c C sN t � | _t�| j�}| �|jtj� t|_t � | _ | � |� t | j ���| _dS )z� Construct a L{StandardIOEndpoint} with a dummy reactor and a fake L{stdio.StandardIO} like object. Listening on it with a L{SpecificFactory}. N)r� r r �StandardIOEndpoint�assertIs�_stdior � StandardIOr@ r) r< �successResultOfr, r; � fakeStdio�rT �endpointrU rU rV �setUp� s �z StandardIOEndpointsTests.setUpc C s( | � | jj| j� | �| jjjt� dS )z� L{StandardIOEndpoint} returns a L{Deferred} that fires with an instance of a L{stdio.StandardIO} like object that was passed the result of L{SpecificFactory.buildProtocol} which was passed a L{PipeAddress}. N)rE rI rA r< r r= r* rS rU rU rV �test_protocolCreation s �z.StandardIOEndpointsTests.test_protocolCreationc C s | � | jj| j� dS )z� L{StandardIOEndpoint} passes its C{reactor} argument to the constructor of its L{stdio.StandardIO} like object. N)rE rI r rS rU rU rV �test_passedReactor � z+StandardIOEndpointsTests.test_passedReactorN)rh ri rj rk rL rM rN rU rU rU rV rC � s rC c @ ru )�StubApplicationProtocolz# An L{IProtocol} provider. c C � || _ dS )zY @param data: The data received by the protocol. @type data: str N)rP rb rU rU rV rc � z$StubApplicationProtocol.dataReceivedc C rQ )zA @type reason: L{twisted.python.failure.Failure} Nr� re rU rU rV rg � z&StubApplicationProtocol.connectionLostN)rh ri rj rk rc rg rU rU rU rV rP s rP c sZ e Zd ZdZd� fdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z � Z S )�MemoryProcessTransportzC A fake L{IProcessTransport} provider to be used in tests. Nc s. t � jt� t� d� g | _t� | _t� | _d S )N)� hostAddress� peerAddress)�superrW r �signals�set�closedChildFDsr) r �rT r �� __class__rU rV rW , s z MemoryProcessTransport.__init__c C s |dkr | � |� d S d S rO ��write)rT �childFDrP rU rU rV � writeToChild2 s �z#MemoryProcessTransport.writeToChildc C � | � d� d S rO �� closeChildFDrS rU rU rV � closeStdin6 r� z!MemoryProcessTransport.closeStdinc C rb r[ rc rS rU rU rV � closeStdout9 r� z"MemoryProcessTransport.closeStdoutc C rb )Nr� rc rS rU rU rV � closeStderr< r� z"MemoryProcessTransport.closeStderrc C r_ r` )rZ �add)rT �fdrU rU rV rd ? rd z#MemoryProcessTransport.closeChildFDc C r_ r` )rX ra )rT �signalrU rU rV � signalProcessB rd z$MemoryProcessTransport.signalProcessc C r� r` rU rS rU rU rV �pidE s zMemoryProcessTransport.pidr` ) rh ri rj rk rW ra re rf rg rd rk rl � __classcell__rU rU r\ rV rT & s rT c @ s( e Zd ZdZdi dddddfdd�ZdS )�MemoryProcessReactorzA A fake L{IReactorProcess} provider to be used in tests. rU Nr c C sR || _ || _|| _|| _|| _|| _|| _|| _| | _t � | _ | j � | j � | j S )z� @ivar processProtocol: Stores the protocol passed to the reactor. @return: An L{IProcessTransport} provider. ) �processProtocol� executabler� �env�path�uid�gid�usePTY�childFDsrT �processTransportr� ) rT ro rp r� rq rr rs rt ru rv rU rU rV � spawnProcessU s z!MemoryProcessReactor.spawnProcess)rh ri rj rk rx rU rU rU rV rn O s �rn c @ �P e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )�ProcessEndpointsTestsz, Tests for child process endpoints. c C s. t � | _t�| jd�| _t�� | _t| j_d S �N� /bin/executable) rn r r �ProcessEndpointr� r r( r� rP rS rU rU rV rL y s zProcessEndpointsTests.setUpc C s� | � | jjt� | �| jjd� | �| jjd� | �| jji � | �| jj � | �| jj � | �| jj � | �| jj d� | �| jj � | �| jjtj� dS )zU Default values are set for the optional parameters in the endpoint. r| rU r N)r r� �_reactorrn r� � _executable�_args�_envr� �_path�_uid�_gid�_usePTY� _childFDs�_errFlagr �LOGrS rU rU rV �test_constructorDefaults s z.ProcessEndpointsTests.test_constructorDefaultsc C s� ddi}t �t� ddgd|d idddddd d d �tj� }| �|jt� | �|jd� | �|j dg� | �|j d|d i� | �|j d� | �|j d� | �|j d� | �|j� | �|jdd d d �� | �|jtj� dS ) zI The parameters passed to the endpoint are stored in it. � HOMENr| � /runProcessHere/r\ r� T�w�r�r� � � )r r} rn r �DROPr r~ r� r r� r� r� r� r� r� r� r� r� )rT �environr� rU rU rV �test_constructorNonDefaults� s. � z1ProcessEndpointsTests.test_constructorNonDefaultsc C s2 | j �| j�}| �|� | jj}| �|tj� dS )z� The wrapper function _WrapIProtocol gives an IProcessProtocol implementation that wraps over an IProtocol. N) r� r r� rH r ro r r �_WrapIProtocol�rT r� �wpprU rU rV �test_wrappedProtocol� s z*ProcessEndpointsTests.test_wrappedProtocolc C s� ddi}t � }t�|ddgd|d idddddd d d �� }|�| j�}| �|� | �|jtj� | � |j |j � | � |j |j � | � |j|j� | � |j|j� | � |j|j� | � |j|j� | � |j|j� | � |j|j� dS ) z� The parameters for spawnProcess stored in the endpoint are passed when the endpoint's connect method is invoked. r� Nr| r� r\ r� Tr� r� r� )rn r r} r r� rH r ro r� r� rp r r� r� rq r� rr r� rs r� rt r� ru r� rv r� )rT r� � memoryReactorr� r� rU rU rV �test_spawnProcess� s0 � z'ProcessEndpointsTests.test_spawnProcessc C s@ G dd� dt j�}|� }| j�|�}| �|� | �|jt� dS )zz The address passed to the factory's buildProtocol in the endpoint is a _ProcessAddress instance. c @ s e Zd ZeZdZdd� ZdS )zBProcessEndpointsTests.test_processAddress.<locals>.TestAddrFactoryNc S s || _ | �� }| |_|S r` )r� r r� )rT r� r� rU rU rV r� � s zPProcessEndpointsTests.test_processAddress.<locals>.TestAddrFactory.buildProtocol)rh ri rj rP r r� r� rU rU rU rV �TestAddrFactory� s r� N)r r( r� r rH r r� r )rT r� � myFactoryr� rU rU rV �test_processAddress� s z)ProcessEndpointsTests.test_processAddressc C s$ | � | j�| j��}| �|t� dS )zd L{ProcessEndpoint.connect} returns a Deferred with the connected protocol. N)rH r� r r� r rP )rT r rU rU rV � test_connect� s z"ProcessEndpointsTests.test_connectc C s6 dd� }|| j _| j �| j�}| �|�}|�t� dS )zg In case of failure, L{ProcessEndpoint.connect} returns a Deferred that fails. c S s t � �r` )� Exception) �pprp r� rq rr rs rt ru rv rU rU rV �testSpawnProcess� s zCProcessEndpointsTests.test_connectFailure.<locals>.testSpawnProcessN)r� � _spawnProcessr r� r� �trapr� )rT r� r� r rU rU rV �test_connectFailure� s z)ProcessEndpointsTests.test_connectFailureN) rh ri rj rk rL r� r� r� r� r� r� r� rU rU rU rV rz t s rz c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#� ProcessEndpointTransportTestsze Test the behaviour of the implementation detail L{endpoints._ProcessEndpointTransport}. c C sF t � | _t�| jd�| _| �| j�t�t ���}| jj | _ |j | _ d S r{ )rn r r r} rK rH r r( � forProtocolr) rw �processr� �endpointTransportr[ rU rU rV rL s � z#ProcessEndpointTransportTests.setUpc C � t t| j� dS )zE L{_ProcessEndpointTransport}s provide L{IConsumer}. N)r r" r� rS rU rU rV �test_verifyConsumer � z1ProcessEndpointTransportTests.test_verifyConsumerc C r� )zI L{_ProcessEndpointTransport}s provide L{IPushProducer}. N)r r$ r� rS rU rU rV �test_verifyProducer r� z1ProcessEndpointTransportTests.test_verifyProducerc C r� )zF L{_ProcessEndpointTransport}s provide L{ITransport}. N)r r& r� rS rU rU rV �test_verifyTransport r� z2ProcessEndpointTransportTests.test_verifyTransportc C s | � | jj| j� dS )zd The L{_ProcessEndpointTransport} instance stores the process passed to it. N)rE r� �_processr� rS rU rU rV �test_constructor$ rO z.ProcessEndpointTransportTests.test_constructorc C s> t t�G dd� d��}|� }| j�|d� | �| jj|� dS )z� Registering a producer with the endpoint transport registers it with the underlying process transport. c @ r� )zFProcessEndpointTransportTests.test_registerProducer.<locals>.AProducerNr� rU rU rU rV � AProducer1 s r� FN)r r$ r� �registerProducerrE r� �producer)rT r� � aProducerrU rU rV �test_registerProducer+ s z3ProcessEndpointTransportTests.test_registerProducerc C � | j �� | �| jjd� dS )zY Pausing the endpoint transport pauses the underlying process transport. �pausedN)r� �pauseProducingr� r� � producerStaterS rU rU rV �test_pauseProducing9 s z1ProcessEndpointTransportTests.test_pauseProducingc C s& | � � | j�� | �| jjd� dS )zc Resuming the endpoint transport resumes the underlying process transport. � producingN)r� r� �resumeProducingr� r� r� rS rU rU rV �test_resumeProducing@ s z2ProcessEndpointTransportTests.test_resumeProducingc C r� )zo Stopping the endpoint transport as a producer stops the underlying process transport. �stoppedN)r� � stopProducingr� r� r� rS rU rU rV �test_stopProducingI s z0ProcessEndpointTransportTests.test_stopProducingc C s$ | � � | j�� | �| jj� dS )z� Unregistring the endpoint transport's producer unregisters the underlying process transport's producer. N)r� r� �unregisterProducerr� r� r� rS rU rU rV �test_unregisterProducerQ s z5ProcessEndpointTransportTests.test_unregisterProducerc C s g | j _| �tt| jd� dS )z� L{endpoints._ProcessEndpointTransport} filters out extraneous attributes of its underlying transport, to present a more consistent cross-platform view of subprocesses and prevent accidental dependencies. �pipesN)r� r� � assertRaises�AttributeError�getattrr� rS rU rU rV �test_extraneousAttributesZ s z7ProcessEndpointTransportTests.test_extraneousAttributesc C s( | j �g d�� | �| jj�� d� dS )z� The writeSequence method of L{_ProcessEndpointTransport} writes a list of string passed to it to the transport's stdin. )s test1s test2s test3s test1test2test3N)r� � writeSequencer� r� �io�getvaluerS rU rU rV �test_writeSequenced s z0ProcessEndpointTransportTests.test_writeSequencec C s$ | j �d� | �| jj�� d� dS )z� The write method of L{_ProcessEndpointTransport} writes a string of data passed to it to the child process's stdin. s testN)r� r_ r� r� r� r� rS rU rU rV � test_writel s z(ProcessEndpointTransportTests.test_writec C s | j �� | �| jj� dS )z� A call to the loseConnection method of a L{_ProcessEndpointTransport} instance returns a call to the process transport's loseConnection. N)r� �loseConnectionr� r� � connectedrS rU rU rV �test_loseConnectiont s z1ProcessEndpointTransportTests.test_loseConnectionc C �, | j �� }| �|t� | �|| j�� � dS )z� L{_ProcessEndpointTransport.getHost} returns a L{_ProcessAddress} instance matching the process C{getHost}. N)r� r' r r rE r� )rT �hostrU rU rV � test_getHost| � z*ProcessEndpointTransportTests.test_getHostc C r� )z� L{_ProcessEndpointTransport.getPeer} returns a L{_ProcessAddress} instance matching the process C{getPeer}. N)r� �getPeerr r rE r� )rT �peerrU rU rV � test_getPeer� r� z*ProcessEndpointTransportTests.test_getPeerN)rh ri rj rk rL r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rU rU rU rV r� s$ r� c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�WrappedIProtocolTestszL Test the behaviour of the implementation detail C{_WrapIProtocol}. c C s4 t � | _t�| jd�| _d | _t�� | _t | j_d S r{ ) rn r r r} r� �eventLogr r( r� rP rS rU rU rV rL � s zWrappedIProtocolTests.setUpc C sD | j �| j�}| �|� | jj}| �|jt� | � |j | j j � dS )zQ Stores an L{IProtocol} provider and the flag to log/drop stderr N) r� r r� rH r ro r r rP r� �errFlagr� r� rU rU rV r� � s z&WrappedIProtocolTests.test_constructorc C s6 | j �| j�}| �|� | jj}| �|jj|j� dS )zx Our process transport is properly hooked up to the wrappedIProtocol when a connection is made. N) r� r r� rH r ro r� r r� r� rU rU rV �test_makeConnection� s z)WrappedIProtocolTests.test_makeConnectionc C rQ )z! A log observer. N)r� )rT � eventDictrU rU rV �_stdLog� rS z WrappedIProtocolTests._stdLogc C s� | j �| j�}| �|� | jj}t�| j� | � tj | j� |� dd� | � | j d |j� | � | j d d� | � | j d |j� | �dt�| j �� dS )z� When the _errFlag is set to L{StandardErrorBehavior.LOG}, L{endpoints._WrapIProtocol} logs stderr (in childDataReceived). r� s stderr1rp rP r zwrote stderr unhandled byN)r� r r� rH r ro r5 � addObserverr� � addCleanup�removeObserver�childDataReceivedr� r� rp r �assertIn�textFromEventDictr� rU rU rV �test_logStderr� s z$WrappedIProtocolTests.test_logStderrc C sb t j| j_| j�| j�}| �|� | jj}t � | j � | � t j | j � |�dd� | �| j� dS )z� When the _errFlag is set to L{StandardErrorBehavior.DROP}, L{endpoints._WrapIProtocol} ignores stderr. r� s stderr2N)r r� r� r� r r� rH r ro r5 r� r� r� r� r� r� r� r� rU rU rV �test_stderrSkip� s z%WrappedIProtocolTests.test_stderrSkipc C s@ | j �| j�}| �|� | jj}|�dd� | �|jj d� dS )z� In childDataReceived of L{_WrappedIProtocol} instance, the protocol's dataReceived is called when stdout is generated. r\ s stdoutN) r� r r� rH r ro r� r� r rP r� rU rU rV � test_stdout� s z!WrappedIProtocolTests.test_stdoutc C sR | j �| j�}| �|� | jj}|�tt� d��� | � |j j � tj�tj� dS )z� L{error.ProcessDone} with status=0 is turned into a clean disconnect type, i.e. L{error.ConnectionDone}. r N)r� r r� rH r ro � processEndedr8 r � ProcessDoner� r rf �check�ConnectionDoner� rU rU rV �test_processDone� s �z&WrappedIProtocolTests.test_processDonec C sP | j �| j�}| �|� | jj}|�tt� � �� | � |j j � tj�tj� dS )z{ Exceptions other than L{error.ProcessDone} with status=0 are turned into L{error.ConnectionLost}. N)r� r r� rH r ro r� r8 r �ProcessTerminatedr� r rf r� �ConnectionLostr� rU rU rV �test_processEnded� s �z'WrappedIProtocolTests.test_processEndedN) rh ri rj rk rL r� r� r� r� r� r� r� r� rU rU rU rV r� � s r� c @ �H e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�TCP4EndpointsTestsz' Tests for TCP IPv4 Endpoints. c C � |j S �zD @return: List of calls to L{IReactorTCP.listenTCP} �� tcpServersr� rU rU rV r- � z"TCP4EndpointsTests.expectedServersc C r� �zE @return: List of calls to L{IReactorTCP.connectTCP} �� tcpClientsr� rU rU rV r� r� z"TCP4EndpointsTests.expectedClientsc C �P |\}}}}}|\}} } } } | � ||� | � || � | � || � | � || � dS �a] Compare host, port, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorTCP.connectTCP}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorTCP.connectTCP}. N�r� � rT � receivedArgsr r� r( �ignoredFactory�timeout� bindAddressr. � expectedPort�_ignoredFactory�expectedTimeout�expectedBindAddressrU rU rV r � � z$TCP4EndpointsTests.assertConnectArgsc C � ddd�S ��K @return: C{dict} of keyword arguments to pass to connect. � �� localhosti�� �r� r� rU rS rU rU rV r + rS z TCP4EndpointsTests.connectArgsc C r ��I @return: C{dict} of keyword arguments to pass to listen �d � 127.0.0.1��backlog� interfacerU rS rU rU rV r5 1 rS z TCP4EndpointsTests.listenArgsc K sB t ddd�}tj||jfi |��|j||�dd�|�dd�f|fS )a� Create an L{TCP4ServerEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorTCP} that L{TCP4ServerEndpoint} can call L{IReactorTCP.listenTCP} on. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param listenArgs: Optional dictionary of arguments to L{IReactorTCP.listenTCP}. �TCP�0.0.0.0r r �2 r rL )r r �TCP4ServerEndpointr( �get�rT r r� r5 r� rU rU rV r% 7 � ��z'TCP4EndpointsTests.createServerEndpointc K �J t ddd�}tj||j|jfi |��|j|j||�dd�|�dd�f|fS )a� Create an L{TCP4ClientEndpoint} and return the values needed to verify its behavior. @param reactor: A fake L{IReactorTCP} that L{TCP4ClientEndpoint} can call L{IReactorTCP.connectTCP} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorTCP.connectTCP} r r r0 r� � r� N)r r �TCP4ClientEndpointr� r( r �rT r r� r r� rU rU rV r� P � �� ��z'TCP4EndpointsTests.createClientEndpointN� rh ri rj rk r- r� r r r5 r% r� rU rU rU rV r� � s r� c @ r� )�TCP6EndpointsTestsz' Tests for TCP IPv6 Endpoints. c C r� r� r� r� rU rU rV r- r r� z"TCP6EndpointsTests.expectedServersc C r� r� r� r� rU rU rV r� x r� z"TCP6EndpointsTests.expectedClientsc C r� r� r� r� rU rU rV r ~ r z$TCP6EndpointsTests.assertConnectArgsc C r r rU rS rU rU rV r � rS z TCP6EndpointsTests.connectArgsc C r )r r �::1r rU rS rU rU rV r5 � rS z TCP6EndpointsTests.listenArgsc K sF |� dd�}td|d�}tj||jfi |��|j||� dd�|f|fS )a� Create a L{TCP6ServerEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorTCP} that L{TCP6ServerEndpoint} can call L{IReactorTCP.listenTCP} on. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param listenArgs: Optional dictionary of arguments to L{IReactorTCP.listenTCP}. r z::r r r r )r r r �TCP6ServerEndpointr( )rT r r� r5 r r� rU rU rV r% � s �z'TCP6EndpointsTests.createServerEndpointc K r )�� Create a L{TCP6ClientEndpoint} and return the values needed to verify its behavior. @param reactor: A fake L{IReactorTCP} that L{TCP6ClientEndpoint} can call L{IReactorTCP.connectTCP} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorTCP.connectTCP} r r r0 r� r r� N)r r �TCP6ClientEndpointr� r( r r rU rU rV r� � r z'TCP6EndpointsTests.createClientEndpointNr rU rU rU rV r m s r c @ r� )� TCP6EndpointNameResolutionTestszl Tests for a TCP IPv6 Client Endpoint pointed at a hostname instead of an IPv6 address literal. c sd t ddd�}tj|d|jfi |��� _� fdd�}|� j_� j|j|j||�dd�|�d d �f|fS ) r! r �::2r0 �ipv6.example.comc s> � � d| � tttddftttddftttddfg}t�|�S )Nr% rL )r$ r r r )z::3r r r )z::4r r r )r� r r r r �succeed)r� rP rS rU rV �testNameResolution� s � zPTCP6EndpointNameResolutionTests.createClientEndpoint.<locals>.testNameResolutionr� r r� N)r r r" r( r� �_nameResolutionr� r )rT r r� r r� r' rU rS rV r� � s" �� ��z4TCP6EndpointNameResolutionTests.createClientEndpointc C r r rU rS rU rU rV r rS z+TCP6EndpointNameResolutionTests.connectArgsc C r� r� r� r� rU rU rV r� r� z/TCP6EndpointNameResolutionTests.expectedClientsc C r� r� r� r� rU rU rV r r z1TCP6EndpointNameResolutionTests.assertConnectArgsc C s" t �ddd�}| �|jtj� dS )zg By default, L{TCP6ClientEndpoint._deferToThread} is L{threads.deferToThread}. Nzwww.example.com�� )r r" r� �_deferToThreadr � deferToThread�rT r� rU rU rV � test_freeFunctionDeferToThread. s z>TCP6EndpointNameResolutionTests.test_freeFunctionDeferToThreadc sZ g � � fdd�}t �tdd�}t� }||_||_|�t� � | �|ddt fi fg� � dS )zl While resolving hostnames, _nameResolution calls _deferToThread with _getaddrinfo. c s � � | ||f� t�� S r` )ra r r� )r� r� �kwargs��callsrU rV �fakeDeferToThread= s zNTCP6EndpointNameResolutionTests.test_nameResolution.<locals>.fakeDeferToThreadr% r) r N) r r" r r� � _getaddrinfor* r r� r� r )rT r1 rK �fakegetaddrinforU r/ rV �test_nameResolution6 s �z3TCP6EndpointNameResolutionTests.test_nameResolutionN) rh ri rj rk r� r r� r r- r4 rU rU rU rV r# � s ( r# c @ r? )� RaisingMemoryReactorWithClockzE An extension of L{RaisingMemoryReactor} with L{task.Clock}. Nc C s t �| � t�| ||� d S r` )r+ rW r- )rT r1 r rU rU rV rW P s z&RaisingMemoryReactorWithClock.__init__)NNrB rU rU rU rV r5 K s r5 rU c sf �du ri ��� � �tt�G ��fdd�d��� tt�G � fdd�dttdtt| ������}|| �S )ap Create a reactor that will deterministically resolve all hostnames it is passed to the list of addresses given. @param reactor: An object that we wish to add an L{IReactorPluggableNameResolver} to. @type reactor: Any object with some formally-declared interfaces (i.e. one where C{list(providedBy(reactor))} is not empty); usually C{IReactor*} interfaces. @param expectedAddresses: (optional); the addresses expected to be returned for every address. If these are strings, they should be IPv4 or IPv6 literals, and they will be wrapped in L{IPv4Address} and L{IPv6Address} objects in the resolution result. @type expectedAddresses: iterable of C{object} or C{str} @param hostMap: (optional); the names (unicode) mapped to lists of addresses (str or L{IAddress}); in the same format as expectedAddress, which map the results for I{specific} hostnames to addresses. @return: A new reactor which provides all the interfaces previously provided by C{reactor} as well as L{IReactorPluggableNameResolver}. All name resolutions performed with its C{nameResolver} attribute will resolve reentrantly and synchronously with the given C{expectedAddresses}. However, it is not a complete implementation as it does not have an C{installNameResolver} method. Nc s& e Zd Ze d� �fdd� �ZdS )z9deterministicResolvingReactor.<locals>.SimpleNameResolverr Nr c sT | � d � ��|� �D ]}t|t�r ttgt|� d||�}| �|� q | �� d S )Nr ) �resolutionBeganr � isinstance�strr r r �addressResolved�resolutionComplete)�resolutionReceiver�hostName� portNumber� addressTypes�transportSemantics�expectedAddress��expectedAddresses�hostMaprU rV �resolveHostNamew s �� zIdeterministicResolvingReactor.<locals>.SimpleNameResolver.resolveHostName)r Nr )rh ri rj � staticmethodrD rU rA rU rV �SimpleNameResolveru s �rF c s e Zd Z� � ZdS )z3deterministicResolvingReactor.<locals>.WithResolverN)rh ri rj � nameResolverrU )rF rU rV � WithResolver� s rH �*)�copyr r# r% r7 r �tupler )r rB rC rH rU )rF rB rC rV � deterministicResolvingReactorU s �rL c @ rM ) �SimpleHostnameResolverTestsa� Tests for L{endpoints._SimpleHostnameResolver}. @ivar fakeResolverCalls: Arguments with which L{fakeResolver} was called. @type fakeResolverCalls: L{list} of C{(hostName, port)} L{tuple}s. @ivar fakeResolverReturns: The return value of L{fakeResolver}. @type fakeResolverReturns: L{Deferred} @ivar resolver: The instance to test. @type resolver: L{endpoints._SimpleHostnameResolver} @ivar resolutionBeganCalls: Arguments with which receiver's C{resolutionBegan} method was called. @type resolutionBeganCalls: L{list} @ivar addressResolved: Arguments with which C{addressResolved} was called. @type addressResolved: L{list} @ivar resolutionCompleteCallCount: The number of calls to the receiver's C{resolutionComplete} method. @type resolutionCompleteCallCount: L{int} @ivar receiver: A L{interfaces.IResolutionReceiver} provider. c sV g � _ t�� � _t�� j�� _g � _g � _ d� _ t t j �G � fdd�d��}|� _d S )Nr c s< e Zd Ze� fdd��Ze� fdd��Ze� fdd��ZdS )z4SimpleHostnameResolverTests.setUp.<locals>._Receiverc � � j �| � d S r` )�resolutionBeganCallsra )�resolutionInProgressrS rU rV r6 � � zDSimpleHostnameResolverTests.setUp.<locals>._Receiver.resolutionBeganc rN r` )�addressResolvedCallsra )r� rS rU rV r9 � rQ zDSimpleHostnameResolverTests.setUp.<locals>._Receiver.addressResolvedc s � j d7 _ d S r[ )�resolutionCompleteCallCountrU rS rU rV r: � s zGSimpleHostnameResolverTests.setUp.<locals>._Receiver.resolutionCompleteN)rh ri rj rE r6 r9 r: rU rS rU rV � _Receiver� s rT )�fakeResolverCallsr r� �fakeResolverReturnsr �_SimpleHostnameResolver� fakeResolver�resolverrO rR rS r r �IResolutionReceiver�receiver)rT rT rU rS rV rL � s z!SimpleHostnameResolverTests.setUpc C s | j �||f� | jS )z� A fake resolver callable. @param hostName: The hostname to resolve. @param portNumber: The port number the returned address should include. @return: L{fakeResolverCalls} @rtype: L{Deferred} )rU ra rV )rT r< r= rU rU rV rX � s z(SimpleHostnameResolverTests.fakeResolverc C s | � ttj| j�� dS )zs A L{endpoints._SimpleHostnameResolver} instance provides L{interfaces.IHostnameResolver}. N)r� r r r# rY rS rU rU rV r� � � z*SimpleHostnameResolverTests.test_interfacec s g �t t��fdd��� t�� � | �� fdd�� | j�| jd�}| �|| j� | j � t � � | � dt ��� | � dt | �t ��� �\}| �|�d�� | �|�dd�� | �|�d t| j��� | � dt | j�� | � | jd jd� | �| j� | � d| j� d S ) z� A resolution failure is logged with the name that failed to resolve and the callable that tried to resolve it. The resolution receiver begins, receives no addresses, and completes. c r� r` r� )�event)�logsrU rV � captureLogs� s zHSimpleHostnameResolverTests.test_resolveNameFailure.<locals>.captureLogsc s t �� �S r` )r1 r� rU )r_ rU rV r� � s zESimpleHostnameResolverTests.test_resolveNameFailure.<locals>.<lambda>� example.comr\ �isError�name�callabler N)r r0 r1 r� r� rY rD r[ rE rV �errbackr� r� r �flushLoggedErrorsr� r �reprrX rO rb r� rR rS )rT r[ r] rU )r_ r^ rV �test_resolveNameFailure� s$ z3SimpleHostnameResolverTests.test_resolveNameFailurec C s� d}d}d}| j �| jd�}| �|| j� | j�tttd||fft ttd||ffg� | � dt | j �� | � | j d j d� | � | jtd||�td||�g� | � | jd� d S ) zs The resolution receiver begins, and resolved hostnames are delivered before it completes. r0 �1.2.3.4z 1::2::3::4r` rL r\ r r N)rY rD r[ rE rV r r r r r r� r rO rb rR r r rS )rT r( �ipv4Host�ipv6Hostr[ rU rU rV �test_resolveNameDelivers s" ���z4SimpleHostnameResolverTests.test_resolveNameDeliversN) rh ri rj rk rL rX r� rg rk rU rU rU rV rM � s #rM c @ r� )�+HostnameEndpointFallbackNameResolutionTestszd L{HostnameEndpoint._fallbackNameResolution} defers a name resolution call to a thread. c sJ ddl m} tj|ddd�}d\� �|�� ��}� ��fdd�}|�|�S )z� L{_fallbackNameResolution} returns a L{Deferred} that fires with the resoution of the the host and request port. r )r �ignored)r� r( )rh r\ c sL �� t| �d� | \\}}}}}�� |t� �� |t� �� |� �f� d S r[ )r� r r r )�result�family�socktype�_�sockaddr�r� r( rT rU rV � assertHostPortFamilySockType0 s zmHostnameEndpointFallbackNameResolutionTests.test_fallbackNameResolution.<locals>.assertHostPortFamilySockType)�twisted.internetr r �HostnameEndpoint�_fallbackNameResolutionr� )rT r r� �resolutionDeferredrt rU rs rV �test_fallbackNameResolution# s zGHostnameEndpointFallbackNameResolutionTests.test_fallbackNameResolutionN)rh ri rj rk ry rU rU rU rV rl � rl c @ r� )�#_HostnameEndpointMemoryReactorMixinz� Common methods for testing L{HostnameEndpoint} against L{MemoryReactor} instances that do not provide L{IReactorPluggableNameResolver}. c O s8 z ||i |��}W n t y t�� Y S w t�|�S )a� A synchronous version of L{deferToThread}. @param f: The callable to invoke. @type f: L{callable} @param args: Positional arguments to the callable. @param kwargs: Keyword arguments to the callable. @return: A L{Deferred} that fires with the result of applying C{f} to C{args} and C{kwargs} or the exception raised. )� BaseExceptionr r� r& )rT r� r� r. rn rU rU rV �synchronousDeferredToThreadA s � z?_HostnameEndpointMemoryReactorMixin.synchronousDeferredToThreadc C r� )z� Extract expected clients from the reactor. @param reactor: The L{MemoryReactor} under test. @return: List of calls to L{IReactorTCP.connectTCP} r� r� rU rU rV r� V s z3_HostnameEndpointMemoryReactorMixin.expectedClientsc C r )zL @return: C{dict} of keyword arguments to pass to connect. g $@r r rU rS rU rU rV r ` rR z/_HostnameEndpointMemoryReactorMixin.connectArgsc C r� r� r� r� rU rU rV r g r z5_HostnameEndpointMemoryReactorMixin.assertConnectArgsc C �n t jdd�}t|d�}t� }| �||�\}}}|�|�}|�tjj � | � | � |�j |� | � g |� � � dS )z� When L{HostnameEndpoint.connect} cannot connect to its destination, the returned L{Deferred} will fail with C{ConnectError}. r r� r N�r r� r5 r� r� r �advancer rv �_DEFAULT_ATTEMPT_DELAYr� r� r �getDelayedCalls�rT r r r� r� r� r r� rU rU rV r � � � z?_HostnameEndpointMemoryReactorMixin.test_endpointConnectFailurec C s` t � }t� }| �||� | �� }| �dt|�� | �t|d d � | �|d d � d�� dS )z� Instantiating L{HostnameEndpoint} with a reactor that does not provide L{IReactorPluggableResolver} emits a deprecation warning. r\ r �category�messagez�Passing HostnameEndpoint a reactor that does not provide IReactorPluggableNameResolver (twisted.internet.testing.MemoryReactorClock) was deprecated in Twisted 17.5.0; please use a reactor that provides IReactorPluggableNameResolver insteadN) r� r� r� � flushWarningsr� r rE �DeprecationWarningr� � startswith)rT r r� �warningsrU rU rV �test_deprecation� s ��z4_HostnameEndpointMemoryReactorMixin.test_deprecationc C sf t � }t� }| �||�\}}}dd� }||_|�|�}| �| �|�jtj � | � dt | � t ��� dS )z8 Hostname resolution errors are logged. c _ s t dd��)N���z#No address associated with hostname)r )r� r. rU rU rV �getaddrinfoThatFails� rs zS_HostnameEndpointMemoryReactorMixin.test_errorsLogged.<locals>.getaddrinfoThatFailsr\ N)r� r� r� r2 r r r� r r �DNSLookupErrorr� r re r )rT r r� r� r� r r� r� rU rU rV �test_errorsLogged� s � z5_HostnameEndpointMemoryReactorMixin.test_errorsLoggedN) rh ri rj rk r} r� r r r r� r� rU rU rU rV r{ : s r{ c @ r� )�&HostnameEndpointMemoryIPv4ReactorTestsz� IPv4 resolution tests for L{HostnameEndpoint} with L{MemoryReactor} subclasses that do not provide L{IReactorPluggableNameResolver}. c �f d� t dd�}tj|d|jfi |��}� fdd�}||_| j|_|� |j||�dd�|�dd �f|fS ) a� Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv4 address. @param reactor: The L{MemoryReactor} @param clientFactory: The client L{IProtocolFactory} @param connectArgs: Additional arguments to L{HostnameEndpoint.connect} @return: A L{tuple} of the form C{(endpoint, (expectedAddress, expectedPort, clientFactory, timeout, localBindAddress, hostnameAddress))} rh � example.comr0 c � t ttd� dffgS �NrL r0 )r r r �r� r( ro rp �r@ rU rV r3 � � �zTHostnameEndpointMemoryIPv4ReactorTests.createClientEndpoint.<locals>.fakegetaddrinfor� r r� N�r r rv r( r2 r} r* r �rT r r� r r� rK r3 rU r� rV r� � �& �� ��z;HostnameEndpointMemoryIPv4ReactorTests.createClientEndpointN�rh ri rj rk r� rU rU rU rV r� � � r� c @ r� )�&HostnameEndpointMemoryIPv6ReactorTestsz� IPv6 resolution tests for L{HostnameEndpoint} with L{MemoryReactor} subclasses that do not provide L{IReactorPluggableNameResolver}. c r� ) a� Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv6 address. @param reactor: The L{MemoryReactor} @param clientFactory: The client L{IProtocolFactory} @param connectArgs: Additional arguments to L{HostnameEndpoint.connect} @return: A L{tuple} of the form C{(endpoint, (expectedAddress, expectedPort, clientFactory, timeout, localBindAddress, hostnameAddress))} �1:2::3:4� ipv6.example.comr0 c r� r� )r r r r� r� rU rV r3 r� zTHostnameEndpointMemoryIPv6ReactorTests.createClientEndpoint.<locals>.fakegetaddrinfor� r r� Nr� r� rU r� rV r� r� z;HostnameEndpointMemoryIPv6ReactorTests.createClientEndpointNr� rU rU rU rV r� � r� r� c @ sZ e Zd ZdZdd� Zdd� Zdd� Zdd � Zdd d �Zd d� Z dd� Z dd� Z dd� Z d S )� HostnameEndpointsOneIPv4Testsz^ Tests for the hostname based endpoints when GAI returns only one (IPv4) address. c K sT d}t dd�}tjt||g�d|jfi |��}|||j||�dd�|�dd�f|fS )z{ Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv4 address. rh r� r0 r� r r� N�r r rv rL r( r )rT r r� r r@ r� rK rU rU rV r� 7 s$ �� ��z2HostnameEndpointsOneIPv4Tests.createClientEndpointc C r� r� r� r� rU rU rV r� Q r� z-HostnameEndpointsOneIPv4Tests.expectedClientsc C r� r� r� r� rU rU rV r W r z/HostnameEndpointsOneIPv4Tests.assertConnectArgsc C r r rU rS rU rU rV r s rS z)HostnameEndpointsOneIPv4Tests.connectArgsNc C s� t � }t�� }tj|_| �||�\}}}|�|�}|dur"|�|� |�� | �|�}|� dt t � � �� | � |�} | �| jt j� | �| jj|� | �|jd d jj� | �g |�� � dS )z� Calling L{Deferred.cancel} on the L{Deferred} returned from L{IStreamClientEndpoint.connect} will cause it to be errbacked with a L{ConnectingCancelledError} exception. Nr r� )r� r r( r) r� r r� r r� r� r8 r r r� r r r! r� r� r� r� � _connector�stoppedConnectingr� ) rT r� r r� r� r� r� r� r r rU rU rV r y s z>HostnameEndpointsOneIPv4Tests.test_endpointConnectingCancelledc C s$ t jj}||d }| j|d� dS )a Calling L{Deferred.cancel} on the L{Deferred} returned from L{IStreamClientEndpoint.connect} after enough time has passed that all connection attempts have been initiated will cause it to be errbacked with a L{ConnectingCancelledError} exception. g @)r� N)r rv r� r )rT � oneBetweenr� rU rU rV �7test_endpointConnectingCancelledAfterAllAttemptsStarted� s zUHostnameEndpointsOneIPv4Tests.test_endpointConnectingCancelledAfterAllAttemptsStartedc C r~ )z� If L{HostnameEndpoint.connect} is invoked and there is no server listening for connections, the returned L{Deferred} will fail with C{ConnectError}. r r� r Nr r� rU rU rV r � r� z9HostnameEndpointsOneIPv4Tests.test_endpointConnectFailurec C s� t jdd�}t� }t� }| �||�\}}}|�|�}|�d� |jd \}} } } } | �|j d |� | � | � |�j |� | � g |� � � dS )a If a connection attempt initiated by L{HostnameEndpoint.connect} fails only after L{HostnameEndpoint} has exhausted the list of possible server addresses, the returned L{Deferred} will fail with C{ConnectError}. r r� �333333�?r N)r r� r� r� r� r r� r� r� � connectorsr� r� r r� ) rT r r r� r� r� r r� r� r( r� r� r� rU rU rV �)test_endpointConnectFailureAfterIteration� s � zGHostnameEndpointsOneIPv4Tests.test_endpointConnectFailureAfterIterationc s� t � }t� }t � }| �||�\}}}|�|�}g � � fdd�}|�|� | �|�} |�d� | j�|� | � � |g� | � |�} | � t | �d� | � | d |� | � g |� � � dS )a\ If a connection attempt initiated by L{HostnameEndpoint.connect} succeeds only after L{HostnameEndpoint} has exhausted the list of possible server addresses, the returned L{Deferred} will fire with the connected protocol instance and the endpoint will leave no delayed calls in the reactor. c r� r` r� r� r� rU rV r � r� z[HostnameEndpointsOneIPv4Tests.test_endpointConnectSuccessAfterIteration.<locals>.checkProtor� r\ r N)r� r� r� r r� r� r� r� r r� r� r r r� r rU r� rV �)test_endpointConnectSuccessAfterIteration� s$ � zGHostnameEndpointsOneIPv4Tests.test_endpointConnectSuccessAfterIterationr` ) rh ri rj rk r� r� r r r r� r r� r� rU rU rU rV r� 1 s r� c @ r� )� HostnameEndpointsOneIPv6Testsz^ Tests for the hostname based endpoints when GAI returns only one (IPv6) address. c K sP t dd�}tjt|dg�d|jfi |��}|d|j||�dd�|�dd�f|fS )z{ Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv6 address. r� r0 r� r� r r� Nr� )rT r r� r r� rK rU rU rV r� � s" �� ��z2HostnameEndpointsOneIPv6Tests.createClientEndpointc C r� r� r� r� rU rU rV r� r� z-HostnameEndpointsOneIPv6Tests.expectedClientsc C r� r� r� r� rU rU rV r r z/HostnameEndpointsOneIPv6Tests.assertConnectArgsc C r r rU rS rU rU rV r 9 rS z)HostnameEndpointsOneIPv6Tests.connectArgsc C s� t � }t�� }tj|_| �t|dg�|�\}}}|�|�}|�� | �|�}|� dt t � � �� | � |�}| �|jt j� | �|jj|� | �|jd d jj� | �g |�� � dS )r r Nr r� )r� r r( r) r� rL r r r� r� r8 r r r� r r r! r� r� r� r� r� r� r� ) rT r r� r� r� r� r� r r rU rU rV r ? s � z>HostnameEndpointsOneIPv6Tests.test_endpointConnectingCancelledc C sj t jdd�}t|d�}t� }| �||�\}}}|�|�}|�d� | �| �|�j |� | �g |� � � dS )r r r� r r� N) r r� r5 r� r� r r� r� r� r r� r� rU rU rV r \ s � z9HostnameEndpointsOneIPv6Tests.test_endpointConnectFailureN) rh ri rj rk r� r� r r r r rU rU rU rV r� � s r� c @ s8 e Zd ZdZdZdZdd� Zdd� Zdd � Zd d � Z d S ) �HostnameEndpointIDNATestszJ Tests for L{HostnameEndpoint}'s constructor's encoding behavior. � bücher.chs xn--bcher-kva.chc C �> t �tt� dg�| jd�}| �|j| j� | �|j| j� dS )z� A L{HostnameEndpoint} constructed with text will contain an IDNA-encoded bytes representation of that text. r r0 N� r rv rL r� �sampleIDNATextr� � _hostBytes�sampleIDNABytes� _hostTextrJ rU rU rV �test_idnaHostnameTextw � �z/HostnameEndpointIDNATests.test_idnaHostnameTextc C r� )z� A L{HostnameEndpoint} constructed with bytes will contain an IDNA-decoded textual representation of those bytes. r r0 Nr� rJ rU rU rV �test_idnaHostnameBytes� r� z0HostnameEndpointIDNATests.test_idnaHostnameBytesc C sD t �tt� dg�td| j�d�}| �|j| j� | �|j | j� dS )z� A L{HostnameEndpoint} constructed with NFD-normalized text will store the NFC-normalized version of that text. r �NFDr0 N) r rv rL r� r r� r� r� r� r� rJ rU rU rV �test_nonNormalizedText� s �z0HostnameEndpointIDNATests.test_nonNormalizedTextc C s� t �tt� dg�dd�}|�t�t��}| �|t �}| � dt |�� t �tt� dg�dd�}|�t� �}| �|t �}| � dt |�� dS )a& Since any client of L{IStreamClientEndpoint} needs to handle Deferred failures from C{connect}, L{HostnameEndpoint}'s constructor will not raise exceptions when given bad host names, instead deferring to returning a failing L{Deferred} from C{connect}. r � �-garbage-�r0 z\xff-garbage-\xffu ⿰-garbage-⿰z\u2ff0-garbage-\u2ff0N) r rv rL r� r r( r� r) r� r� r� r8 )rT rK �deferred�errrU rU rV � test_deferBadEncodingToConnect� s � � z8HostnameEndpointIDNATests.test_deferBadEncodingToConnectN) rh ri rj rk r� r� r� r� r� r� rU rU rU rV r� o s r� c @ r# ) �HostnameEndpointReprTestsz@ Tests for L{HostnameEndpoint}'s string representation. c C �> t �tt� g �dd�}t|�}| �d|� | �tt|�� dS )z� The string representation of L{HostnameEndpoint} includes the host and port passed to the constructor. r` r0 z!<HostnameEndpoint example.com:80>N� r rv rL r+ rf r� rE r8 �type�rT rK �reprU rU rV � test_allASCII� � � z'HostnameEndpointReprTests.test_allASCIIc C r� )z� When IDN is passed to the L{HostnameEndpoint} constructor the string representation includes the punycode version of the host. r� � z'<HostnameEndpoint xn--bcher-kva.ch:443>Nr� r� rU rU rV �test_idnaHostname� r� z+HostnameEndpointReprTests.test_idnaHostnamec C r� )z� When the host passed to L{HostnameEndpoint} is an IPv6 address it is wrapped in brackets in the string representation, like in a URI. This prevents the colon separating the host from the port from being ambiguous. s ::1� z<HostnameEndpoint [::1]:22>Nr� r� rU rU rV �test_hostIPv6Address� s � z.HostnameEndpointReprTests.test_hostIPv6Addressc C s* t �tt� g �dd�}| �dt|�� dS )z� When a bad hostname is passed to L{HostnameEndpoint}, the string representation displays invalid characters in backslash-escaped form. r� r0 z'<HostnameEndpoint \xff-garbage-\xff:80>N)r rv rL r+ r� rf rJ rU rU rV �test_badEncoding� s ��z*HostnameEndpointReprTests.test_badEncodingN)rh ri rj rk r� r� r� r� rU rU rU rV r� � s r� c @ r� )� HostnameEndpointsGAIFailureTestszM Tests for the hostname based endpoints when GAI returns no address. c C sH t �tt� g �dd�}t� }|�|�}| �|tj�}| � dt |�� dS )z� If no address is returned by GAI for a hostname, the connection attempt fails with L{error.DNSLookupError}. r� r0 r` N) r rv rL r+ r� r r� r r� r� r8 )rT rK r� �dConnect�excrU rU rV � test_failure s � z-HostnameEndpointsGAIFailureTests.test_failureN)rh ri rj rk r� rU rU rU rV r� � r� r� c @ rM ) �&HostnameEndpointsFasterConnectionTestsz� Tests for the hostname based endpoints when gai returns an IPv4 and an IPv6 address, and one connection takes less time than the other. c C s( t � | _t�t| jddg�dd�| _d S )Nrh r� � www.example.comr0 )r� r r rv rL rK rS rU rU rV rL s �z,HostnameEndpointsFasterConnectionTests.setUpc C s� t � | _t�t| jdt� dg�dd�| _d}| j�|� | j�d� | jj d \}}}}}| � t | jj �d� | � |d� | � |d� dS ) z� If an address type other than L{IPv4Address} and L{IPv6Address} is returned by on address resolution, the endpoint ignores that address. rh r� r� r0 Nr� r\ r� ) r� r r rv rL r� rK r r� r� r� r )rT r� r� r( r� r� r� rU rU rV � test_ignoreUnknownAddressTypes s �� zEHostnameEndpointsFasterConnectionTests.test_ignoreUnknownAddressTypesc C s� t �� }t j|_ | j�|�}g }|�|j� | jjd \}}}}}| � |d� | � |d� |� ||f�} t � } | � |g � | � | � | � t |�d� | � |d j|� | � g | j�� � dS )a= The endpoint returns a connection to the IPv4 address. IPv4 ought to be the first attempt, since nameResolution (standing in for GAI here) returns it first. The IPv4 attempt succeeds, the connection is established, and a Deferred fires with the protocol constructed. r rh r0 r\ N)r r( r) rK r r� ra r r� r� r� r� r� r r� r� � rT r� r� �resultsr� r( r� r� r� r � fakeTransportrU rU rV �test_IPv4IsFaster5 s z8HostnameEndpointsFasterConnectionTests.test_IPv4IsFasterc C s� t �� }t j|_ | j�|�}g }|�|j� | j�d� | jj d \}}}}}| � |d� | � |d� |� ||f�} t � } | � |g � | � | � | � t|�d� | � |d j|� | � g | j�� � dS )a= The endpoint returns a connection to the IPv6 address. IPv6 ought to be the second attempt, since nameResolution (standing in for GAI here) returns it second. The IPv6 attempt succeeds, a connection is established, and a Deferred fires with the protocol constructed. r� r\ r� r0 r N)r r( r) rK r r� ra r r� r� r� r� r� r� r r� r� r� rU rU rV �test_IPv6IsFasterT s z8HostnameEndpointsFasterConnectionTests.test_IPv6IsFasterc C s� t �� }t j|_ | j�|�}g }|�|j� | j�d� | jj d \}}}}}|� ||f�} t � } | � | � | � d| jj d d jj� | � g | j�� � dS )a Once the endpoint returns a successful connection, all the other pending connections are cancelled. Here, the second connection attempt, i.e. IPv6, succeeds, and the pending first attempt, i.e. IPv4, is cancelled. r� r\ Tr r� N)r r( r) rK r r� ra r r� r� r� r� r� r� r� r� r� r� rU rU rV � test_otherConnectionsCancelledu s �zEHostnameEndpointsFasterConnectionTests.test_otherConnectionsCancelledN) rh ri rj rk rL r� r� r� r� rU rU rU rV r� s !r� c @ ry )�SSL4EndpointsTestsz" Tests for SSL Endpoints. c C r� )zD @return: List of calls to L{IReactorSSL.listenSSL} )� sslServersr� rU rU rV r- � r� z"SSL4EndpointsTests.expectedServersc C r� )zE @return: List of calls to L{IReactorSSL.connectSSL} )� sslClientsr� rU rU rV r� � r� z"SSL4EndpointsTests.expectedClientsc C s` |\}}}}}}|\} } } } } }| � || � | � || � | � || � | � || � | � ||� dS )a� Compare host, port, contextFactory, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{contextFactory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorSSL.connectSSL}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{contextFactory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorSSL.connectSSL}. Nr� )rT r� r r� r( r� �contextFactoryr� r� r. r� r� �expectedContextFactoryr r rU rU rV r � s* � � z$SSL4EndpointsTests.assertConnectArgsc C r r rU rS rU rU rV r � rS z SSL4EndpointsTests.connectArgsc C r r rU rS rU rU rV r5 � rS z SSL4EndpointsTests.listenArgsc C sL t ddd�\| _| _t ddd�\| _| _t| j| jdd�| _tdd�| _d S ) zF Set up client and server SSL contexts for use later. zServer Test Certificate�server)�O�CNzClient Test Certificate�clientF)� privateKey� certificate�requireCertificate)r� N)rK �sKey�sCert�cKey�cCertrE �serverSSLContext�clientSSLContextrS rU rU rV rL � s �� �zSSL4EndpointsTests.setUpc K sJ t ddd�}tj||j| jfi |��|j|| j|�dd�|�dd�f|fS )a� Create an L{SSL4ServerEndpoint} and return the tools to verify its behaviour. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param reactor: A fake L{IReactorSSL} that L{SSL4ServerEndpoint} can call L{IReactorSSL.listenSSL} on. @param listenArgs: Optional dictionary of arguments to L{IReactorSSL.listenSSL}. r r r r r r rL )r r �SSL4ServerEndpointr( r� r r rU rU rV r% � s �� ��z'SSL4EndpointsTests.createServerEndpointc K sR t ddd�}tj||j|j| jfi |��|j|j|| j|�dd�|�dd�f|fS )a� Create an L{SSL4ClientEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorSSL} that L{SSL4ClientEndpoint} can call L{IReactorSSL.connectSSL} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorSSL.connectSSL} r r r0 r� r r� N)r r �SSL4ClientEndpointr� r( r� r r rU rU rV r� s$ �� ��z'SSL4EndpointsTests.createClientEndpointN) rh ri rj rk r- r� r r r5 rL r% r� rU rU rU rV r� � s & r� c @ ry )�UNIXEndpointsTestsz) Tests for UnixSocket Endpoints. c C r� )z� Override L{EndpointTestCaseMixin.retrieveConnectedFactory} to account for different index of 'factory' in C{connectUNIX} args. r r\ r� r� rU rU rV r� ( r~ z+UNIXEndpointsTests.retrieveConnectedFactoryc C r� )zF @return: List of calls to L{IReactorUNIX.listenUNIX} )� unixServersr� rU rU rV r- / r� z"UNIXEndpointsTests.expectedServersc C r� )zG @return: List of calls to L{IReactorUNIX.connectUNIX} )� unixClientsr� rU rU rV r� 5 r� z"UNIXEndpointsTests.expectedClientsc C s@ |\}}}}|\}}} } | � ||� | � || � | � || � dS )a Compare path, timeout, checkPID in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{path}, C{timeout}, C{checkPID}) that was passed to L{IReactorUNIX.connectUNIX}. @param expectedArgs: C{tuple} of (C{path}, C{timeout}, C{checkPID}) that we expect to have been passed to L{IReactorUNIX.connectUNIX}. Nr� ) rT r� r rr r� r� �checkPID� expectedPathr� r �expectedCheckPIDrU rU rV r ; s � z$UNIXEndpointsTests.assertConnectArgsc C r )r r r\ )r� r� rU rS rU rU rV r T rS z UNIXEndpointsTests.connectArgsc C s dddd�S )r r i� r\ )r �mode�wantPIDrU rS rU rU rV r5 Z s z UNIXEndpointsTests.listenArgsc K sL t | �� �}tj||jfi |��|j||�dd�|�dd�|�dd�f|fS )a� Create an L{UNIXServerEndpoint} and return the tools to verify its behaviour. @param reactor: A fake L{IReactorUNIX} that L{UNIXServerEndpoint} can call L{IReactorUNIX.listenUNIX} on. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param listenArgs: Optional dictionary of arguments to L{IReactorUNIX.listenUNIX}. r r r� � r� r )r �mktempr �UNIXServerEndpointrb r r rU rU rV r% ` s ��z'UNIXEndpointsTests.createServerEndpointc K sB t | �� �}tj||jfi |��|j||�dd�|�dd�f|fS )a� Create an L{UNIXClientEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorUNIX} that L{UNIXClientEndpoint} can call L{IReactorUNIX.connectUNIX} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorUNIX.connectUNIX} r� r r� r )r r� r �UNIXClientEndpointrb r r rU rU rV r� z r z'UNIXEndpointsTests.createClientEndpointN) rh ri rj rk r� r- r� r r r5 r% r� rU rU rU rV r� # s r� c @ sl e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� ZdS )� ParserTestszK Tests for L{endpoints._parseServer}, the low-level parsing logic. r( c O s t j|i |��S )zT Provide a hook for test_strports to substitute the deprecated API. )r � _parseServer)rT �a�kwrU rU rV �parse� r� zParserTests.parsec C �, | � | �d| j�dd| jfddd�f� dS )zN Simple strings with a 'tcp:' prefix should be parsed as TCP. ztcp:80r r0 rL r �r r N�r� r� r� rS rU rU rV �test_simpleTCP� � �zParserTests.test_simpleTCPc C r� )zU TCP port descriptions parse their 'interface' argument as a string. ztcp:80:interface=127.0.0.1r r0 r r r� Nr� rS rU rU rV �test_interfaceTCP� r� z ParserTests.test_interfaceTCPc C r� )zU TCP port descriptions parse their 'backlog' argument as an integer. ztcp:80:backlog=6r r0 rL � r� Nr� rS rU rU rV �test_backlogTCP� r� zParserTests.test_backlogTCPc C �. | � | �d| j�dd| jfdddd�f� dS ) z� L{endpoints._parseServer} returns a C{'UNIX'} port description with defaults for C{'mode'}, C{'backlog'}, and C{'wantPID'} when passed a string with the C{'unix:'} prefix and no other parameter values. zunix:/var/run/finger�UNIX�/var/run/fingerr� r T�r� r r� Nr� rS rU rU rV �test_simpleUNIX� s ��zParserTests.test_simpleUNIXc C r ) zK C{mode} can be set by including C{"mode=<some integer>"}. z unix:/var/run/finger:mode=0660r r i� r Tr Nr� rS rU rU rV � test_modeUNIX� � ��zParserTests.test_modeUNIXc C r ) zM C{wantPID} can be set to false by included C{"lockfile=0"}. z unix:/var/run/finger:lockfile=0r r r� r Fr Nr� rS rU rU rV �test_wantPIDUNIX� r z ParserTests.test_wantPIDUNIXc C r ) zf Backslash can be used to escape colons and backslashes in port descriptions. zunix:foo\:bar\=baz\:qux\\r zfoo:bar=baz:qux\r� r Tr Nr� rS rU rU rV � test_escape� � ��zParserTests.test_escapec C s | � t�d�d� dS )z� L{endpoints.quoteStringArgument} should quote backslashes and colons for interpolation into L{endpoints.serverFromString} and L{endpoints.clientFactory} arguments. zsome : stuff \zsome \: stuff \\N)r� r �quoteStringArgumentrS rU rU rV �test_quoteStringArgument� s �z$ParserTests.test_quoteStringArgumentc C r ) z� In strports descriptions, '=' in a parameter value does not need to be quoted; it will simply be parsed as part of the value. zunix:address=foo=barr zfoo=barr� r Tr Nr� rS rU rU rV �test_impliedEscape� r z ParserTests.test_impliedEscapec C s | � t| jd| j� dS )ze L{strports.parse} raises C{ValueError} when given an unknown endpoint type. zbogus-type:nothingN)r� r� r� r� rS rU rU rV �test_unknownType r\ z ParserTests.test_unknownTypeN)rh ri rj rk r� r� r� r r r r r r r r r rU rU rU rV r� � s r� c @ s� e Zd ZdZdd� Zeee�dd� �Zeee�dd� �Z dZ eee�d d � �Z eee�d d � �Z eee�d d� �Z eee�dd� �Zdd� Zdd� Zdd� ZdS )�ServerStringTestszC Tests for L{twisted.internet.endpoints.serverFromString}. c C s\ t � }t�|d�}| �|tj� | �|j|� | �|jd� | �|j d� | �|j d� dS )z� When passed a TCP strports description, L{endpoints.serverFromString} returns a L{TCP4ServerEndpoint} instance initialized with the values from the string. z&tcp:1234:backlog=12:interface=10.0.0.1r) � �10.0.0.1N) r� r �serverFromStringr r rE r~ r� �_port�_backlog� _interface)rT r r� rU rU rV �test_tcp s �zServerStringTests.test_tcpc C s� t � }t�|dttf �}| �|tj� | �|j|� | �|j d� | �|j d� | �|j d� | �|j j t� |j �� }| �|t� dS )z� When passed an SSL strports description, L{endpoints.serverFromString} returns a L{SSL4ServerEndpoint} instance initialized with the values from the string. �Vssl:1234:backlog=12:privateKey=%s:certKey=%s:sslmethod=TLSv1_METHOD:interface=10.0.0.1r) r r N)r� r r �escapedPEMPathNamer r� rE r~ r� r r r �_sslContextFactory�methodrC � getContext� ContextType�rT r r� �ctxrU rU rV �test_ssl) s �� zServerStringTests.test_sslc C s� t � }t�|dt� ��}| �|tj� | �|j|� | �|j d� | �|j d� | �|j d� | �|j j t� | �|j jt@ � |j �� }| �|t� dS )z� An SSL string endpoint description with minimal arguments returns a properly initialized L{SSL4ServerEndpoint} instance. zssl:4321:privateKey=�� r rL N)r� r r r r r� rE r~ r� r r r r r rB r� �_optionsrA r r r rU rU rV �test_sslWithDefaults@ s � � z&ServerStringTests.test_sslWithDefaultsz(ssl:1234:privateKey=%s:extraCertChain=%sc C st t �t� | jttf �}dd� dD �}|j}| �|jd � d�|d � d�� | �|jd � d�|d � d�� dS )zf Specifying a chain file loads the contained certificates in the right order. c S s& g | ]}t �t�d |f ��� ��qS )z thing%d.pem)rD �loadPEM�casPath�child� getContent)�.0�nrU rU rV � <listcomp>k s ��z8ServerStringTests.test_sslChainLoads.<locals>.<listcomp>)r\ r� r �sha1r\ N) r r r� �SSL_CHAIN_TEMPLATEr �escapedChainPathNamer r� �extraCertChain�digest)rT r� �expectedChainCerts�cfrU rU rV �test_sslChainLoadsZ s$ ��� ���z$ServerStringTests.test_sslChainLoadsc C s� t | �� �}|�� �� | �t��}t�t� | j t t� |j �f � W d � n1 s,w Y | � t|j�d|j f � dS )zy If C{extraCertChain} is passed, it has to contain at least one valid certificate in PEM format. NzOSpecified chain file '%s' doesn't contain any valid certificates in PEM format.)r9 r� �create�closer� r� r r r� r- r r rr r� r8 r3 )rT �fp�caughtrU rU rV � test_sslChainFileMustContainCertw s$ ��� � ��z2ServerStringTests.test_sslChainFileMustContainCertc C sL d}t � }t�|d�tt|��}|j}| �|jt� | � t |�|jj � dS )z� If C{dhParameters} are specified, they are passed as L{DiffieHellmanParameters} into L{CertificateOptions}. �someFilez1ssl:4321:privateKey={}:certKey={}:dhParameters={}N) r� r r �formatr r r � dhParametersrF r� r9 �_dhFile)rT �fileNamer r� r2 rU rU rV �test_sslDHparameters� s ��z&ServerStringTests.test_sslDHparametersc C s� t � }t�|dttf �}| �|tj� | �|j|� | � |j d� | � |j d� | � |j d� | � |j jt� |j �� }| �|t� dS )zq Lack of a trailing newline in key and cert .pem files should not generate an exception. r r) r r N)r� r r �&escapedNoTrailingNewlineKeyPEMPathName�'escapedNoTrailingNewlineCertPEMPathNamer r� rE r~ r� r r r r r rC r r r rU rU rV � test_sslNoTrailingNewlinePem� s" ��� z.ServerStringTests.test_sslNoTrailingNewlinePemc C sh t � }t�|d�}| �|tj� | �|j|� | �|jd� | �|j d� | �|j d� | � |j � dS )z� When passed a UNIX strports description, L{endpoint.serverFromString} returns a L{UNIXServerEndpoint} instance initialized with the values from the string. z0unix:/var/foo/bar:backlog=7:mode=0123:lockfile=1� /var/foo/bar� �S N) r� r r r r� rE r~ r� �_addressr �_moder� �_wantPID)rT r rK rU rU rV � test_unix� s �zServerStringTests.test_unixc C �& | � ttjdd�}| �t|�d� dS )zq L{endpoints.serverFromString} raises C{ValueError} when given an unknown endpoint type. N� ftl:andromeda/carcosa/hali/2387� Unknown endpoint type: 'ftl')r� r� r r r� r8 �rT r rU rU rV r � � �z"ServerStringTests.test_unknownTypec C �b t | � t� }t�|d�}ddlm} | �|j|� | �|j |ddf� | �|j t ddd�� d S ) z� L{endpoints.serverFromString} looks up plugins of type L{IStreamServerEndpoint} and constructs endpoints from them. z fake:hello:world:yes=no:up=downr )�fake�hello�world�no�down)�yes�upN) � addFakePluginr� r r � twisted.plugins.fakeendpointrO rE �parserr� r� r. �dict)rT � notAReactor� fakeEndpointrO rU rU rV �test_typeFromPlugin� s � z%ServerStringTests.test_typeFromPluginN)rh ri rj rk r r �skipSSL� skipSSLReasonr! r$ r- r3 r8 r> rA rH r r\ rU rU rU rV r s& r �fakeendpoint.pyc sx ddl ��j�� � ttj��� ��fdd�}| �|� t| �� �}|� � t t �j � |��|�|�� tj�|j� dS )z� For the duration of C{testCase}, add a fake plugin to twisted.plugins which contains some sample endpoint parsers. r Nc s( �j �� �j �� � �tjd d �< d S r` )�modules�clear�updater �__path__rU �� savedModules�savedPluginPath�sysrU rV �cleanup� s z addFakePlugin.<locals>.cleanup)rg r` rJ �listr rc r� r9 r� �createDirectoryr: rh �filePath�sibling�copyTor' ra rr )�testCase� dropinSourcerh r6 rU rd rV rV � s rV c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�ClientStringTestszC Tests for L{twisted.internet.endpoints.clientFromString}. c C �j t � }t�|d�}| �|tj� | �|j|� | �|jd� | �|j d� | �|j d� | �|j d� dS )z� When passed a TCP strports description, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. z=tcp:host=example.com:port=1234:timeout=7:bindAddress=10.0.0.2r` r) rC �z10.0.0.2r N� r� r �clientFromStringr r rE r~ r� �_hostr �_timeout� _bindAddress�rT r r� rU rU rV r � �zClientStringTests.test_tcpc C rq )z� When passed a TCP strports description using positional arguments, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. z3tcp:example.com:1234:timeout=7:bindAddress=10.0.0.2r` r) rC rr Nrs rx rU rU rV �test_tcpPositionalArgs! ry z(ClientStringTests.test_tcpPositionalArgsc C �2 t � }t�|d�}| �|jd� | �|jd� dS )z� When passed a TCP strports description specifying host as a positional argument, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. z8tcp:example.com:port=1234:timeout=7:bindAddress=10.0.0.2r` r) N�r� r rt r� ru r rx rU rU rV �test_tcpHostPositionalArg2 s �z+ClientStringTests.test_tcpHostPositionalArgc C r{ )z� When passed a TCP strports description specifying port as a positional argument, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. z8tcp:host=example.com:1234:timeout=7:bindAddress=10.0.0.2r` r) Nr| rx rU rU rV �test_tcpPortPositionalArg@ s �z+ClientStringTests.test_tcpPortPositionalArgc C s0 t � }t�|d�}| �|jd� | �|j� dS )z{ A TCP strports description may omit I{timeout} or I{bindAddress} to allow the default to be used. z tcp:host=example.com:port=1234r N)r� r rt r� rv r� rw rx rU rU rV �test_tcpDefaultsM s z"ClientStringTests.test_tcpDefaultsc C �Z t � }t�|d�}| �|tj� | �|j|� | �|jd� | �|j d� | � |j � dS )z� When passed a UNIX strports description, L{endpoints.clientFromString} returns a L{UNIXClientEndpoint} instance initialized with the values from the string. z+unix:path=/var/foo/bar:lockfile=1:timeout=9rB � N� r� r rt r r� rE r~ r� r� rv r� � _checkPIDrx rU rU rV rH W � �zClientStringTests.test_unixc C s, t �t� d�}| �|jd� | �|j� dS )zz A UNIX strports description may omit I{lockfile} or I{timeout} to allow the defaults to be used. zunix:path=/var/foo/barr N)r rt r� r� rv r� r� )rT r� rU rU rV �test_unixDefaultsg s z#ClientStringTests.test_unixDefaultsc C r� )z� When passed a UNIX strports description specifying path as a positional argument, L{endpoints.clientFromString} returns a L{UNIXClientEndpoint} instance initialized with the values from the string. z&unix:/var/foo/bar:lockfile=1:timeout=9rB r� Nr� rx rU rU rV �test_unixPathPositionalArgp r� z,ClientStringTests.test_unixPathPositionalArgc C rN ) z� L{endpoints.clientFromString} looks up plugins of type L{IStreamClientEndpoint} and constructs endpoints from them. � crfake:alpha:beta:cee=dee:num=1r ��fakeClientWithReactor�alpha�beta�dee�1��cee�numN) rV r� r rt rW r� rE rX r� r� r. rY )rT rZ �clientEndpointr� rU rU rV r\ � s � z%ClientStringTests.test_typeFromPluginc C rI )zq L{endpoints.clientFromString} raises C{ValueError} when given an unknown endpoint type. NrJ rK )r� r� r rt r� r8 rL rU rU rV r � rM z"ClientStringTests.test_unknownTypec C sV t | � t� }t�|d�}ddlm} | �|j|j|j f||ddft ddd�f� d S ) z� L{endpoints.clientFromString} will pass a reactor to plugins implementing the L{IStreamClientEndpointStringParserWithReactor} interface. r� r r� r� r� r� r� r� N) rV r� r rt rW r� r� rX r� r. rY )rT r r� r� rU rU rV � test_stringParserWithReactor� s � ��z.ClientStringTests.test_stringParserWithReactorN)rh ri rj rk r rz r} r~ r rH r� r� r\ r r� rU rU rU rV rp s rp c @ rM ) �SSLClientStringTestszU Tests for L{twisted.internet.endpoints.clientFromString} which require SSL. c s` t � }t�|dtttf �}| �|tj� | �|j|� | � |j d� | � |j d� | � |j d� | � |j d� |j}| �|t� | � |jt� | �|jt@ � |�� }| �|t� | � t|j�t� t|j�}|�t |j �� | � |t � dd� t � d�t � d �fD �}g � G � fd d �d �}|j!�"|� � | � t#d d � � D �dd� d�t#|dd� d�� dS )�� When passed an SSL strports description, L{clientFromString} returns a L{SSL4ClientEndpoint} instance initialized with the values from the string. zdssl:host=example.net:port=4321:privateKey=%s:certKey=%s:bindAddress=10.0.0.3:timeout=3:caCertsDir=%s� example.netr" r� �z10.0.0.3r c S s, g | ]}|� � �� �d �rt�|�� ��qS )z.pem)�basename�lower�endswithrD r% r( �r) �xrU rU rV r+ � s � �z1SSLClientStringTests.test_ssl.<locals>.<listcomp>� thing1.pem� thing2.pemc � e Zd Z� fdd�ZdS )z.SSLClientStringTests.test_ssl.<locals>.ListCtxc s G � fdd�d�}|� S )Nc r� )zLSSLClientStringTests.test_ssl.<locals>.ListCtx.get_cert_store.<locals>.Storec s � � |� d S r` r� )rT �cert�� addedCertsrU rV �add_cert� r� zUSSLClientStringTests.test_ssl.<locals>.ListCtx.get_cert_store.<locals>.Store.add_certN)rh ri rj r� rU r� rU rV �Store� � r� rU )rT r� r� rU rV �get_cert_store� s z=SSLClientStringTests.test_ssl.<locals>.ListCtx.get_cert_storeN)rh ri rj r� rU r� rU rV �ListCtx� r� r� c s s � | ]}t |�V qd S r` �rD r� rU rU rV � <genexpr>� s � z0SSLClientStringTests.test_ssl.<locals>.<genexpr>c S � | � � S r` �r0 �r� rU rU rV r� � � z/SSLClientStringTests.test_ssl.<locals>.<lambda>)�keyc S r� r` r� r� rU rU rV r� � r� N)$r� r rt r �escapedCAsPathNamer r� rE r~ r� ru r rv rw r rE r rB r� r# rA r r rD r� �testCertificaterH �_setPrivateKeyrG r� �testPrivateCertificater& r' � trustRoot�_addCACertsToContext�sorted)rT r r� � certOptionsr � privateCert� expectedCertsr� rU r� rV r! � sF �� ���z SSLClientStringTests.test_sslc C st t � }t�|dtttf �}| �|tj� | �|j|� | � |j d� | � |j d� | � |j d� | � |j d� dS )r� zZssl:example.net:4321:privateKey=%s:certKey=%s:bindAddress=10.0.0.3:timeout=3:caCertsDir=%sr� r" r� r� N)r� r rt r r� r r� rE r~ r� ru r rv rw rx rU rU rV �test_sslPositionalArgs� s ��z+SSLClientStringTests.test_sslPositionalArgsc C sz t � }t�|d�}| �|tj� | �|j|� | �|jd� | �|j d� |j }| �|j t � | � |j� | � |j� dS )z� When passed an SSL strports description without extra arguments, L{clientFromString} returns a L{SSL4ClientEndpoint} instance whose context factory is initialized with default values. zssl:example.net:4321r� r" N)r� r rt r r� rE r~ r� ru r r r rB r� r� r� )rT r r� r� rU rU rV r$ s z)SSLClientStringTests.test_sslWithDefaultsc C sX G dd� dt �}t�d��� }||_| �dd� t�|�jD �t � t�d�� � �g� dS )z� If a certificate in the directory is unreadable, L{endpoints._loadCAsFromDir} will ignore that certificate. c @ s e Zd Zdd� ZdS )zKSSLClientStringTests.test_unreadableCertificate.<locals>.UnreadableFilePathc S s( t �| �}|t�d��� krtt��|S )Nr� )r9 r( r& r' �OSErrorr rb rU rU rV r( s zVSSLClientStringTests.test_unreadableCertificate.<locals>.UnreadableFilePath.getContentN)rh ri rj r( rU rU rU rV �UnreadableFilePath s r� rm c S s g | ]}t |��qS rU r� r� rU rU rV r+ ' s zCSSLClientStringTests.test_unreadableCertificate.<locals>.<listcomp>r� N) r9 r& r' �parent� clonePathr� r �_loadCAsFromDir�_caCertsrD r% r( )rT r� � casPathClonerU rU rV �test_unreadableCertificate s �z/SSLClientStringTests.test_unreadableCertificatec C sH t � }t�|d�}|j}| �|t� | �|j� |�� }| �|t � dS )z� When passed an SSL strports description without any extra parameters, L{clientFromString} returns a simple non-verifying endpoint that will speak SSL. z%ssl:host=simple.example.org:port=4321N) r� r rt r r rE r� �verifyr r )rT r r� r� r rU rU rV �test_sslSimple+ s � z#SSLClientStringTests.test_sslSimpleN) rh ri rj rk r! r� r$ r� r� rU rU rU rV r� � s 4 r� c @ r� )� AdoptedStreamServerEndpointTestszA Tests for adopted socket-based stream server endpoints. c C s& t �|||�}dd� |_dd� |_|S )z� Create an L{AdoptedStreamServerEndpoint} which may safely be used with an invalid file descriptor. This is convenient for a number of unit tests. c S r� r` rU �ri rU rU rV r� J r� zPAdoptedStreamServerEndpointTests._createStubbedAdoptedEndpoint.<locals>.<lambda>c S r� r` rU r� rU rU rV r� K r� )r �AdoptedStreamServerEndpoint�_close�_setNonBlocking)rT r �fileno� addressFamilyr� rU rU rV � _createStubbedAdoptedEndpointA s z>AdoptedStreamServerEndpointTests._createStubbedAdoptedEndpointc C s2 d}t }| �|||�}tddd�}||||f|fS )a� Create a new L{AdoptedStreamServerEndpoint} for use by a test. @return: A three-tuple: - The endpoint - A tuple of the arguments expected to be passed to the underlying reactor method - An IAddress object which will match the result of L{IListeningPort.getHost} on the port returned by the endpoint. r r r r) )r r� r )rT r r� r� r� rK r� rU rU rV r% N s z5AdoptedStreamServerEndpointTests.createServerEndpointc C r� )z� @return: The ports which were actually adopted by C{reactor} via calls to its L{IReactorSocket.adoptStreamPort} implementation. )� adoptedPortsr� rU rU rV r- ` s z0AdoptedStreamServerEndpointTests.expectedServersc C s i S )zx @return: A C{dict} of additional keyword arguments to pass to the C{createServerEndpoint}. rU rS rU rU rV r5 g s z+AdoptedStreamServerEndpointTests.listenArgsc sR t � � ��� dt�}|�t� � ��|�t� �tj�}� �fdd�}|�|� |S )z� L{AdoptedStreamServerEndpoint.listen} can only be used once. The file descriptor given is closed after the first use, and subsequent calls to C{listen} return a L{Deferred} that fails with L{AlreadyListened}. � c s �� dt� j�� d S r[ )r� r r� �rm �r rT rU rV � listenFailedy s zEAdoptedStreamServerEndpointTests.test_singleUse.<locals>.listenFailed) r� r� r r, r� r� r �AlreadyListenedr� )rT rK r� r� rU r� rV �test_singleUsen s z/AdoptedStreamServerEndpointTests.test_singleUsec sR t � }��|dt�}g � � fdd�}||_|�t� �}� �fdd�}|�|� |S )zv L{AdoptedStreamServerEndpoint.listen} sets the file description given to it to non-blocking. r� c s � � d| f� d S )N�setNonBlockingr� �r� )�eventsrU rV r� � r^ zTAdoptedStreamServerEndpointTests.test_descriptionNonBlocking.<locals>.setNonBlockingc � �� dg� � d S )N)r� r� r� r� �r� rT rU rV �listened� r^ zNAdoptedStreamServerEndpointTests.test_descriptionNonBlocking.<locals>.listened)r� r� r r� r, r� r� )rT r rK r� r� r� rU r� rV �test_descriptionNonBlocking s z<AdoptedStreamServerEndpointTests.test_descriptionNonBlockingc sT t � ����dt�}g � � �fdd�}||_|�t� �}� �fdd�}|�|� |S )z� L{AdoptedStreamServerEndpoint.listen} closes its file descriptor after adding it to the reactor with L{IReactorSocket.adoptStreamPort}. r� c s � � d| t�j�f� d S )Nr5 )ra r r� r� )r� r rU rV r5 � s zEAdoptedStreamServerEndpointTests.test_descriptorClosed.<locals>.closec r� )N)r5 r� r\ r� r� r� rU rV r� � r^ zHAdoptedStreamServerEndpointTests.test_descriptorClosed.<locals>.listened)r� r� r r� r, r� r� )rT rK r5 r� r� rU )r� r rT rV �test_descriptorClosed� s z6AdoptedStreamServerEndpointTests.test_descriptorClosedN) rh ri rj rk r� r% r- r5 r� r� r� rU rU rU rV r� < s r� c @ sF e Zd ZdZejZdd� Zdd� Zdd� Z dd � Z d d � Z d d � Z dS )�SystemdEndpointPluginTestsz� Unit tests for the systemd stream server endpoint and endpoint string description parser. @see: U{systemd<http://www.freedesktop.org/wiki/Software/systemd>} c C �> t ttj��}|D ] }t|| j�r dS q | �d|��� dS )z� L{endpoints._SystemdParser} is found as a plugin for L{interfaces.IStreamServerEndpointStringParser} interface. z Did not find systemd parser in N�ri r2 r �!IStreamServerEndpointStringParserr7 � _parserClassr� �rT �parsersr� rU rU rV �test_pluginDiscovery� s �z/SystemdEndpointPluginTests.test_pluginDiscoveryc C � | � � }| �ttj|�� dS )zx L{endpoints._SystemdParser} instances provide L{interfaces.IStreamServerEndpointStringParser}. N�r� r� r r r� �rT rX rU rU rV r� � � �z)SystemdEndpointPluginTests.test_interfacec C sj t � }g d�}d}| �� }t|�|_|j||t|�d�}| �|j|� | �|j |� | �|j || � dS )a� Helper for unit tests for L{endpoints._SystemdParser.parseStreamServer} for different address families. Handling of the address family given will be verify. If there is a problem a test-failing exception will be raised. @param addressFamily: An address family constant, like L{socket.AF_INET}. @param addressFamilyString: A string which should be recognized by the parser as representing C{addressFamily}. )r� r rC � r� r� )�domain�indexN) r� r� r; � _sddaemon�parseStreamServerr8 rE r r� r� r� )rT r� �addressFamilyStringr � descriptorsr� rX r� rU rU rV �_parseStreamServerTest� s �z1SystemdEndpointPluginTests._parseStreamServerTestc C � | � td� dS )zC IPv4 can be specified using the string C{"INET"}. �INETN)r� r rS rU rU rV �test_parseStreamServerINET� r� z5SystemdEndpointPluginTests.test_parseStreamServerINETc C r� )zD IPv6 can be specified using the string C{"INET6"}. �INET6N)r� r rS rU rU rV �test_parseStreamServerINET6� r� z6SystemdEndpointPluginTests.test_parseStreamServerINET6c C s: zddl m} W n ty t�d��w | �|d� dS )zS A UNIX domain socket can be specified using the string C{"UNIX"}. r )�AF_UNIXz Platform lacks AF_UNIX supportr N)�socketr� � ImportErrorr> �SkipTestr� )rT r� rU rU rV �test_parseStreamServerUNIX� s �z5SystemdEndpointPluginTests.test_parseStreamServerUNIXN) rh ri rj rk r �_SystemdParserr� r� r� r� r� r� r� rU rU rU rV r� � s r� c @ �. e Zd ZdZejZdd� Zdd� Zdd� Z dS ) � TCP6ServerEndpointPluginTestsz[ Unit tests for the TCP IPv6 stream server endpoint string description parser. c C r� )z� L{endpoints._TCP6ServerParser} is found as a plugin for L{interfaces.IStreamServerEndpointStringParser} interface. z*Did not find TCP6ServerEndpoint parser in Nr� r� rU rU rV r� � �z2TCP6ServerEndpointPluginTests.test_pluginDiscoveryc C r� )z{ L{endpoints._TCP6ServerParser} instances provide L{interfaces.IStreamServerEndpointStringParser}. Nr� r� rU rU rV r� r� z,TCP6ServerEndpointPluginTests.test_interfacec C sX t �t� d�}| �|t j� | �|jt� | �|jd� | �|jd� | �|j d� dS )z� L{serverFromString} returns a L{TCP6ServerEndpoint} instance with a 'tcp6' endpoint string description. z$tcp6:8080:backlog=12:interface=\:\:1i� r r N) r r r� r r r~ r� r r r r, rU rU rV �test_stringDescription s �z4TCP6ServerEndpointPluginTests.test_stringDescriptionN) rh ri rj rk r �_TCP6ServerParserr� r� r� r� rU rU rU rV r� s r� c @ r� ) � StandardIOEndpointPluginTestszM Unit tests for the Standard I/O endpoint string description parser. c C r� )z� L{endpoints._StandardIOParser} is found as a plugin for L{interfaces.IStreamServerEndpointStringParser} interface. z*Did not find StandardIOEndpoint parser in Nr� r� rU rU rV r� 5 r� z2StandardIOEndpointPluginTests.test_pluginDiscoveryc C r� )z{ L{endpoints._StandardIOParser} instances provide L{interfaces.IStreamServerEndpointStringParser}. Nr� r� rU rU rV r� A r� z,StandardIOEndpointPluginTests.test_interfacec C s. t �t� d�}| �|t j� | �|jt� dS )z� L{serverFromString} returns a L{StandardIOEndpoint} instance with a 'stdio' endpoint string description. zstdio:N)r r r� r rD r~ r, rU rU rV r� K s z4StandardIOEndpointPluginTests.test_stringDescriptionN) rh ri rj rk r �_StandardIOParserr� r� r� r� rU rU rU rV r� . s r� c @ ru )�ConnectProtocolTestsz' Tests for C{connectProtocol}. c C sl t � }t�|dd�}t� }t�||� | �t|j�d� |jd d j}| � |t j � | � |� d�|� dS )z� C{endpoints.connectProtocol} calls the given endpoint's C{connect()} method with a factory that will build the given protocol. r r r\ r� N)r� r r r� �connectProtocolr� r r� �_wrappedFactoryr r r( rE r� )rT r rK � theProtocolr� rU rU rV �"test_connectProtocolCreatesFactoryZ s z7ConnectProtocolTests.test_connectProtocolCreatesFactoryc s: t �� � G � fdd�d�}|� }| �� t�|t� �� dS )z~ C{endpoints.connectProtocol} returns the result of calling the given endpoint's C{connect()} method. c r� )zOConnectProtocolTests.test_connectProtocolReturnsConnectResult.<locals>.Endpointc � � S )zR Return a marker object for use in our assertion. rU )rT r� �rn rU rV r t s zWConnectProtocolTests.test_connectProtocolReturnsConnectResult.<locals>.Endpoint.connectN)rh ri rj r rU r rU rV �Endpoints r� r N)r r� rE r r r� )rT r rK rU r rV �(test_connectProtocolReturnsConnectResultl s z=ConnectProtocolTests.test_connectProtocolReturnsConnectResultN)rh ri rj rk r r rU rU rU rV r U s r c s4 e Zd ZdZ� fdd�Z� fdd�Zdd� Z� ZS )�UppercaseWrapperProtocolzL A wrapper protocol which uppercases all strings passed through it. c � t � �|�� � dS )z� Uppercase a string passed in from the transport. @param data: The string to uppercase. @type data: L{bytes} N)rW rc �upperrb r\ rU rV rc � � z%UppercaseWrapperProtocol.dataReceivedc r )z� Uppercase a string passed out to the transport. @param data: The string to uppercase. @type data: L{bytes} N)rW r_ r rb r\ rU rV r_ � r z UppercaseWrapperProtocol.writec C s |D ]}| � |� qdS )zy Uppercase a series of strings passed out to the transport. @param seq: An iterable of strings. Nr^ )rT �seqrP rU rU rV r� � s �z&UppercaseWrapperProtocol.writeSequence)rh ri rj rk rc r_ r� rm rU rU r\ rV r ~ s r c @ r )�UppercaseWrapperFactoryzK A wrapper factory which uppercases all strings passed through it. N)rh ri rj rk r r rU rU rU rV r � s r c @ ru )�NetstringTrackerz� A netstring receiver which keeps track of the strings received. @ivar strings: A L{list} of received strings, in order. c C s g | _ d S r` )�stringsrS rU rU rV rW � rs zNetstringTracker.__init__c C s | j �|� dS )z� Receive a string and append it to C{self.strings}. @param string: The string to be appended to C{self.strings}. N)r ra )rT r� rU rU rV �stringReceived� s z NetstringTracker.stringReceivedN)rh ri rj rk rW r rU rU rU rV r � s r c @ r7 )� FakeErrorz� An error which isn't really an error. This is raised in the L{wrapClientTLS} tests in place of a 'real' exception. Nr9 rU rU rU rV r � r: r c @ r� )�WrapperClientEndpointTestsz. Tests for L{_WrapperClientEndpoint}. c C s6 t � \| _| _t� | _t�| jt�| _t � t �| _ d S r` ) r< rK � completerr� �contextr �_WrapperEndpointr r� r( r� r r� rS rU rU rV rL � s �z WrapperClientEndpointTests.setUpc C sL | j �| j�}| j�� }| �|�}|jj�d� |� � | � |j dg� dS )z� Any modifications performed by the underlying L{ProtocolWrapper} propagate through to the wrapped L{Protocol}. s 5:hello,s HELLON) r� r r� r � succeedOncerH r� r� r_ �flushr� r �rT � connecting�pumpr rU rU rV �test_wrappingBehavior� s z0WrapperClientEndpointTests.test_wrappingBehaviorc C sB | j �| j�}| j�� }| �|�}|�d� | �|j� � d� dS )z� Methods defined on the wrapped L{Protocol} are accessible from the L{Protocol} returned from C{connect}'s L{Deferred}. s spams 4:SPAM,N) r� r r� r r rH � sendStringr� �clientIO� getOutBufferr rU rU rV �test_methodsAvailable� s z0WrapperClientEndpointTests.test_methodsAvailablec C s6 | j �| j�}| �|� | j�t� � | �|t� dS )zS Connection failures propagate upward to C{connect}'s L{Deferred}. N)r� r r� �assertNoResultr �failOncer r� �rT r� rU rU rV �test_connectionFailure� s z1WrapperClientEndpointTests.test_connectionFailurec C s0 | j �| j�}| �|� |�� | �|t� dS )zM Cancellation propagates upward to C{connect}'s L{Deferred}. N)r� r r� r! r r� r! r# rU rU rV �test_connectionCancellation� s z6WrapperClientEndpointTests.test_connectionCancellationc C s8 | j �| j�}| j�� }| �|�}| �|jj|j� dS )z| The transport of the wrapped L{Protocol}'s transport is the transport passed to C{makeConnection}. N) r� r r� r r rH rE r� r r rU rU rV �*test_transportOfTransportOfWrappedProtocol� s zEWrapperClientEndpointTests.test_transportOfTransportOfWrappedProtocolN) rh ri rj rk rL r r r$ r% r& rU rU rU rV r � s r c C s |� d�jS )a, Given a L{MemoryReactor} and the result of calling L{wrapClientTLS}, extract the L{IOpenSSLClientConnectionCreator} associated with it. Implementation presently uses private attributes but could (and should) be refactored to just call C{.connect()} on the endpoint, when L{HostnameEndpoint} starts directing its C{getaddrinfo} call through the reactor it is passed somehow rather than via the global threadpool. @param memoryReactor: the reactor attached to the given endpoint. (Presently unused, but included so tests won't need to be modified to honor it.) @param tlsEndpoint: The result of calling L{wrapClientTLS}. @return: the client connection creator associated with the endpoint wrapper. @rtype: L{IOpenSSLClientConnectionCreator} N)�_wrapperFactory�_connectionCreator)r� � tlsEndpointrU rU rV � connectionCreatorFromEndpoint s r* c @ r# ) �WrapClientTLSParserTestsz0 Tests for L{_TLSClientEndpointParser}. c C sj t � }t�|td��}|j}| �|j|� | �|jd� | �|j d� | �|j d� | �|j td�� dS )zm A L{HostnameEndpoint} is constructed from parameters passed to L{clientFromString}. z4tls:example.com:443:timeout=10:bindAddress=127.0.0.1r� r� r r N) r� r rt r6 �_wrappedEndpointrE r~ r� r� r rv rw )rT r rK �hostnameEndpointrU rU rV �!test_hostnameEndpointConstruction! s �z:WrapClientTLSParserTests.test_hostnameEndpointConstructionc C s> t � }t�|d�}| �|jjd� t||�}| �|jd� dS )z� The hostname passed to L{clientFromString} is treated as utf-8 bytes; it is then encoded as IDNA when it is passed along to L{HostnameEndpoint}, and passed as unicode to L{optionsForClientTLS}. s tls:éxample.example.com:443s xn--xample-9ua.example.comu éxample.example.comN)r� r rt r� r, r� r* � _hostname)rT r rK �connectionCreatorrU rU rV �test_utf8Encoding2 s �� z*WrapClientTLSParserTests.test_utf8Encodingc s| t � }t�t|dg�d�ttt�t�� j ��� d��}|� t � t��}|j�� \}}}}}|�d�� | �|� � dus=J �t�t�� �} t| jj| jt�t�� �jg| d�} t� �t| dt � �fdd��d ��d��t �fd d�� fd d��\} } } �j � d � | � |�}|j � d � | � � | �!�j j"� | �!|j j"� | �!�j j#� | �!|j j#� t�$�j �}| �%|t�t�� �� dS )z� When passed a string endpoint description beginning with C{tls:}, L{clientFromString} returns a client endpoint initialized with the values from the string. r z=tls:localhost:4321:privateKey={}:certificate={}:trustRoots={}�asciiN)r� r� r/ r� Fc r r` rU rU )� plainServerrU rV r� q r� z3WrapClientTLSParserTests.test_tls.<locals>.<lambda>)�isClient�wrappedFactoryc r r` rU rU )�serverProtocolrU rV r� t r� c r r` rU rU )�clientProtocolrU rV r� u r� s hello s hi you too )&r� r rt rL r: r r �pemPathr� rr �encoder r( r� r) r� �popr� r! rH r% r( rE r� �originalrD � chainPathrJ r= r� r_ rH r r� � disconnecting� disconnected�peerFromTransportr� )rT r rK r� r� r( r� r� r� � serverCert� serverOptions�sProto�cProtor � plainClient�peerCertificaterU )r7 r3 r6 rV �test_tlsB sX �� ��� � z!WrapClientTLSParserTests.test_tlsc C s> t � }t�|d�}t||�}| �|jd� | �|jjd� dS )z� When passed a C{tls:} strports description without extra arguments, L{clientFromString} returns a client endpoint whose context factory is initialized with default values. s tls:example.com:443r` r� N)r� r rt r* r� r/ r, r� )rT r rK �creatorrU rU rV �test_tlsWithDefaults� s z-WrapClientTLSParserTests.test_tlsWithDefaultsN)rh ri rj rk r. r1 rF rH rU rU rU rV r+ s Ar+ c K s� z| j }| j}W n ty | j}| j}Y nw |D ] }||vr'td�|���qi }|�|� |�|� t||�}||| j < |S )a� Create a copy of the given function with the given globals substituted. The globals must already exist in the function's existing global scope. @param function: any function object. @type function: L{types.FunctionType} @param newGlobals: each keyword argument should be a global to set in the new function's returned scope. @type newGlobals: L{dict} @return: a new function, like C{function}, but with new global scope. z<Name bound by replacingGlobals but not present in module: {}) � func_code� func_globalsr� �__code__� __globals__� TypeErrorr: rb r rh )�function� newGlobals� codeObject� funcGlobalsr� � mergedGlobals� newFunctionrU rU rV �replacingGlobals� s* ���� rT c @ r� )�WrapClientTLSTestszj Tests for the error-reporting behavior of L{wrapClientTLS} when C{pyOpenSSL} is unavailable. c C s2 t tjdd�}| �t|dd�}| �dt|�� dS )z� If SSL is not supported, L{TLSMemoryBIOFactory} will be L{None}, which causes C{_wrapper} to also be L{None}. If C{_wrapper} is L{None}, then an exception is raised. NrI zOpenSSL not available)rT r � wrapClientTLSr� �NotImplementedErrorr� r8 )rT �replaced�notImplementedrU rU rV �test_noOpenSSL� s z!WrapClientTLSTests.test_noOpenSSLN)rh ri rj rk rZ rU rU rU rV rU � rz rU )rU N)r_ )�rk �errnor r� r r r r r �typesr � unicodedatar r> r �zope.interfacer r r �zope.interface.interfacer �zope.interface.verifyr r �twistedr ru r r r r r r r r �twisted.internet.abstractr �twisted.internet.addressr r r r r �twisted.internet.endpointsr �twisted.internet.errorr! �twisted.internet.interfacesr" r# r$ r% r& �twisted.internet.protocolr' r( r) �twisted.internet.stdior* �twisted.internet.taskr+ �twisted.internet.testingr, r� r- r. r/ �twisted.loggerr0 r1 �twisted.pluginr2 �twisted.protocolsr3 r4 �twisted.pythonr5 �twisted.python.compatr6 �twisted.python.componentsr7 �twisted.python.failurer8 �twisted.python.filepathr9 �twisted.python.modulesr: �twisted.python.systemdr; �twisted.test.iosimr< r= � twisted.trialrk rl r8 �noTrailingNewlineKeyPemPath� noTrailingNewlineCertPemPathrh r& r' r< r rr r r? r@ r� r. � OpenSSL.SSLr@ r rA rB rC �twisted.internet.sslrD rE rF rG rH �twisted.protocols.tlsrJ �twisted.test.test_sslverifyrK r% r( r� r� r] r^ r� r� r8 rN r� rm r� rv r� r{ r� r� �TestCaser� r� r$ r8 r; r@ rC rP �IProcessTransportrT �IReactorProcessrn rz r� r� r� r r# r5 rL �SynchronousTestCaserM rl r{ r� r� r� r� r� r� r� r� r� r� r� r rV rp r� r� r� r� r� r �ProtocolWrapperr �WrappingFactoryr �NetstringReceiverr r� r r r* r+ rT rU rU rU rU rV �<module> s* ( � � �� �� P) # $ ooks < � 4�4 IvHF q b + pU-')! At$PK Mb�Z�� }�0 �0 3 internet/test/__pycache__/test_core.cpython-310.pycnu �[��� o �bu+ � @ s� d Z ddlZddlZddlmZ ddlmZmZmZm Z m Z m Z ddl m Z ddlmZ ddlmZmZ ddlmZ dd lmZ dd lmZ G d d � d e�Ze� �e� � � dS ) z/ Tests for implementations of L{IReactorCore}. � N)� FrameType)�Callable�List�Optional�Tuple�Union�cast)�FileDescriptor)�Deferred)�ReactorAlreadyRunning�ReactorNotRestartable)�ReactorBuilder)�Failure)�SynchronousTestCasec @ s� e Zd ZdZd dd�Zd dd�Zd dd �Zd d d �Zd d d �Zd dd�Z d dd�Z d dd�Z d dd�Z d dd�Z d dd�Zd dd�Zd d d �Zd d d �ZdS )!�SystemEventTestsBuilderz{ Builder defining tests relating to L{IReactorCore.addSystemEventTrigger} and L{IReactorCore.fireSystemEvent}. �returnNc C s | � � }tt| ��t|j� dS )zu C{reactor.stop()} raises L{RuntimeError} when called when the reactor has not been started. N)� buildReactorr r � assertRaises� RuntimeError�stop��self�reactor� r �A/usr/lib/python3/dist-packages/twisted/internet/test/test_core.py�test_stopWhenNotStarted s z/SystemEventTestsBuilder.test_stopWhenNotStartedc C s6 | � � }|�|j� | �|� tt| ��t|j� dS )zr C{reactor.stop()} raises L{RuntimeError} when called after the reactor has been stopped. N)r �callWhenRunningr � runReactorr r r r r r r r �test_stopWhenAlreadyStopped$ s z3SystemEventTestsBuilder.test_stopWhenAlreadyStoppedc C sX | � � }g }|�|jd� |�|jd� |�|j� | �|� tt| ��|ddg� dS )zm Functions are run in the order that they were passed to L{reactor.callWhenRunning}. �first�secondN)r r �appendr r r r � assertEqual)r r �eventsr r r �test_callWhenRunningOrder. s z1SystemEventTestsBuilder.test_callWhenRunningOrderc s� | � � � i �d� �fdd� }d� �fdd� }d� �fdd� }tt| �}� �d d |� � �d d |� � �d d |� � �� j� |��i � | �� � |��d ddd�� dS )z� The reactor is not running when C{"before"} C{"startup"} triggers are called and is running when C{"during"} and C{"after"} C{"startup"} triggers are called. r Nc � � j �d< d S �N�before��runningr �r �stater r � beforeStartupD � zKSystemEventTestsBuilder.test_runningForStartupEvents.<locals>.beforeStartupc r% )N�duringr( r r* r r � duringStartupG r- zKSystemEventTestsBuilder.test_runningForStartupEvents.<locals>.duringStartupc r% �N�afterr( r r* r r � afterStartupJ r- zJSystemEventTestsBuilder.test_runningForStartupEvents.<locals>.afterStartupr' �startupr. r1 FT)r' r. r1 �r N)r r r �addSystemEventTriggerr r r" r )r r, r/ r2 �testCaser r* r � test_runningForStartupEvents; s z4SystemEventTestsBuilder.test_runningForStartupEventsc s� | � � }d� d� fdd� }d� fdd� }|�dd|� |�d d|� g �d td tttgdf ddf� �fd d � }tt| �}|�td|� |� |j � |� � � |� �g � | � |� |�d�� |� � d � dS )ze Signal handlers are installed in responsed to the C{"during"} C{"startup"}. Nr c � d� d S r& r r ��phaser r r, _ � zXSystemEventTestsBuilder.test_signalHandlersInstalledDuringStartup.<locals>.beforeStartupc r8 r0 r r r9 r r r2 c r; zWSystemEventTestsBuilder.test_signalHandlersInstalledDuringStartup.<locals>.afterStartupr' r3 r1 �signum�actionc s �� � � d S �N�r! )r< r= �r: �sawPhaser r � fakeSignall r- zUSystemEventTestsBuilder.test_signalHandlersInstalledDuringStartup.<locals>.fakeSignal�signalr4 )r r5 �intr r r r �patchrC r r � assertIsNoner" r �assertIn)r r r, r2 rB r6 r r@ r �)test_signalHandlersInstalledDuringStartupW s ( zASystemEventTestsBuilder.test_signalHandlersInstalledDuringStartupc s~ | � � }g � |�dd� fdd�� |�dd� fdd�� |�dd� fdd�� |�|j� | �|� tt| ��� g d �� d S ) z� C{reactor.stop()} fires all three phases of shutdown event triggers before it makes C{reactor.run()} return. r' �shutdownc � � � d�S �N�r' rI r? r �r# r r �<lambda>� � zASystemEventTestsBuilder.test_stopShutDownEvents.<locals>.<lambda>r. c rJ )N�r. rI r? r rM r r rN � rO r1 c rJ )N�r1 rI r? r rM r r rN � rO )rL rP rQ N)r r5 r r r r r r" r r rM r �test_stopShutDownEventsy s" ��� �z/SystemEventTestsBuilder.test_stopShutDownEventsc sl | � � �g � ��dd� jd� d � �fdd� }tt| �}��|� |�� g � | ��� |�� ddg� dS ) zl C{"before"} C{"shutdown"} triggers are not run synchronously from L{reactor.stop}. r' rI zbefore shutdownr Nc s �� � � �d� d S )N�stopped)r r! r �r# r r r �stopIt� s zPSystemEventTestsBuilder.test_shutdownFiresTriggersAsynchronously.<locals>.stopItrS r4 )r r5 r! r r r r" r )r rU r6 r rT r �(test_shutdownFiresTriggersAsynchronously� s � z@SystemEventTestsBuilder.test_shutdownFiresTriggersAsynchronouslyc s� dg�G dd� dt �}G �fdd�dt �}tt| �}| �� }t|� |� g�� � fdd�|_|�|j� | �|� |� t |� t ��d� |� �d � d S ) z� A L{IFileDescriptor.connectionLost} implementation which raises an exception does not prevent the remaining L{IFileDescriptor}s from having their C{connectionLost} method called. Fc @ s e Zd Zdeddfdd�ZdS )zZSystemEventTestsBuilder.test_shutdownDisconnectsCleanly.<locals>.ProblematicFileDescriptor�reasonr Nc S s t d��)Nz simulated connectionLost error)r �r rW r r r �connectionLost� s ziSystemEventTestsBuilder.test_shutdownDisconnectsCleanly.<locals>.ProblematicFileDescriptor.connectionLost��__name__� __module__� __qualname__r rY r r r r �ProblematicFileDescriptor� s r^ c s" e Zd Zdeddf� fdd� ZdS )zQSystemEventTestsBuilder.test_shutdownDisconnectsCleanly.<locals>.OKFileDescriptorrW r Nc s d� d< d S )NTr r rX ��lostOKr r rY � s z`SystemEventTestsBuilder.test_shutdownDisconnectsCleanly.<locals>.OKFileDescriptor.connectionLostrZ r r_ r r �OKFileDescriptor� s ra c s � S r> r r )�fdsr r rN � s zISystemEventTestsBuilder.test_shutdownDisconnectsCleanly.<locals>.<lambda>� r N)r r r r �iter� removeAllr r r r" �len�flushLoggedErrorsr � assertTrue)r r^ ra r6 r r )rb r` r � test_shutdownDisconnectsCleanly� s z7SystemEventTestsBuilder.test_shutdownDisconnectsCleanlyc sZ g � t t| ��d� ��fdd� }| �� ���|� ���j� | ��� ��� dg� dS )z{ C{reactor.run()} raises L{ReactorAlreadyRunning} when called when the reactor is already running. r Nc � �� t�j� � �d� d S �N�tested)r r �runr! r �r# r r6 r r � reentrantRun� � z>SystemEventTestsBuilder.test_multipleRun.<locals>.reentrantRunrl r4 )r r r r r r r" )r ro r rn r �test_multipleRun� s z(SystemEventTestsBuilder.test_multipleRunc sp g �dt t f� ��fdd� }dtddf��fdd� � | �� ���dd |� | ��� tt| ���d d g� dS ) z� When there is a C{'before'} C{'startup'} trigger which returns an unfired L{Deferred}, C{reactor.run()} starts the reactor and does not return until after C{reactor.stop()} is called r c s. �� d� t� } | �� � ��d| jd � | S )N�triggerr )r! r � addCallback� callLater�callback)�d�ru r# r r r rr � s zUSystemEventTestsBuilder.test_runWithAsynchronousBeforeStartupTrigger.<locals>.trigger�ignoredNc � � � d� ��� d S )Nru )r! r )rx rT r r ru � � zVSystemEventTestsBuilder.test_runWithAsynchronousBeforeStartupTrigger.<locals>.callbackr' r3 rr ru )r �objectr r5 r r r r" )r rr r rw r �,test_runWithAsynchronousBeforeStartupTrigger� s zDSystemEventTestsBuilder.test_runWithAsynchronousBeforeStartupTriggerc C sT | � � }|�d|j�}t�� }|�d� t�� | }tt| ��|dk � |�� dS )z6 C{reactor.iterate()} does not block. � r � N) r rt �crash�time�iterater r rh �cancel)r r �t�start�elapsedr r r � test_iterate� s z$SystemEventTestsBuilder.test_iteratec sd | � � }g � |�dd� fdd�� |�|jd|j� | �|� tt| �}|�|j � |�� d� dS )zc C{reactor.crash()} stops the reactor and does not fire shutdown triggers. r' rI c rJ rK r? r rM r r rN rO z4SystemEventTestsBuilder.test_crash.<locals>.<lambda>r z8Shutdown triggers invoked but they should not have been.N) r r5 r rt r r r r � assertFalser) )r r r6 r rM r � test_crash� s � �z"SystemEventTestsBuilder.test_crashc sn g � d � �fdd� }| � � ���|� | ��� d � �fdd� }��|� | ��� tt| ��� ddg� dS ) zp C{reactor.run()} restarts the reactor after it has been stopped by C{reactor.crash()}. r Nc ry )Nr )r! r r rT r r r rz z9SystemEventTestsBuilder.test_runAfterCrash.<locals>.crashc s � � d�jf� ��� d S )Nr )r! r) r r rT r r r s z8SystemEventTestsBuilder.test_runAfterCrash.<locals>.stopr )r Tr4 )r r r r r r" )r r r r rT r �test_runAfterCrash s z*SystemEventTestsBuilder.test_runAfterCrashc s^ g � t t| ��d� ��fdd� }| �� ����j� ��dd|� | ��� ��� dg� dS ) z� C{reactor.run()} raises L{ReactorNotRestartable} when called when the reactor is being run after getting stopped priorly. r Nc rj rk )r r rm r! r rn r r �restart1 rp z:SystemEventTestsBuilder.test_runAfterStop.<locals>.restartr1 rI rl r4 )r r r r r r5 r r" )r r� r rn r �test_runAfterStop( s z)SystemEventTestsBuilder.test_runAfterStopr4 )r[ r\ r] �__doc__r r r$ r7 rH rR rV ri rq r| r� r� r� r� r r r r r s " r ) r� rC r� �typesr �typingr r r r r r �twisted.internet.abstractr �twisted.internet.deferr �twisted.internet.errorr r �#twisted.internet.test.reactormixinsr �twisted.python.failurer �twisted.trial.unittestr r �globals�update�makeTestCaseClassesr r r r �<module> s (PK Mb�Z�5T�� � : internet/test/__pycache__/test_win32events.cpython-310.pycnu �[��� o �bI � @ s� d Z zddlZW n ey dZY nw ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZmZ G d d � d �ZG d d � d e �Ze� �e�� � dS ) z6 Tests for implementations of L{IReactorWin32Events}. � N)� verifyObject)�Deferred)�IReactorWin32Events)�ReactorBuilder)�Failure)� getThreadID� isInIOThreadc @ sP e Zd ZdZdZd Z ZZdd� Zdd� Z dd � Z d d � Z d d � Z dd� Z dS )�Listenera� L{Listener} is an object that can be added to a L{IReactorWin32Events} reactor to receive callback notification when a Windows event is set. It records what thread its callback is invoked in and fires a Deferred. @ivar success: A flag which is set to C{True} when the event callback is called. @ivar logThreadID: The id of the thread in which the C{logPrefix} method is called. @ivar eventThreadID: The id of the thread in which the event callback is called. @ivar connLostThreadID: The id of the thread in which the C{connectionLost} method is called. @ivar _finished: The L{Deferred} which will be fired when the event callback is called. FNc C s || _ d S �N)� _finished)�self�finished� r �H/usr/lib/python3/dist-packages/twisted/internet/test/test_win32events.py�__init__/ s zListener.__init__c C s t � | _dS )Nr )r � logThreadID�r r r r � logPrefix2 s zListener.logPrefixc C s d| _ t� | _| j�d � d S )NT)�successr � eventThreadIDr �callbackr r r r �occurred6 s zListener.occurredc C s t d��)Nz Some problem)� RuntimeErrorr r r r �brokenOccurred; � zListener.brokenOccurredc C s t d�S )NzEntirely different problem)�EnvironmentErrorr r r r �returnValueOccurred> r z Listener.returnValueOccurredc C s t � | _| j�|� d S r )r �connLostThreadIDr �errback)r �reasonr r r �connectionLostA s zListener.connectionLost)�__name__� __module__� __qualname__�__doc__r r r r r r r r r r r r r r r s r c @ sF e Zd ZdZegZdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z dS )�Win32EventsTestsBuilderzD Builder defining tests relating to L{IReactorWin32Events}. c C s | � � }tt|� dS )zn An instance of the reactor has all of the methods defined on L{IReactorWin32Events}. N)� buildReactorr r )r �reactorr r r �test_interfaceM s z&Win32EventsTestsBuilder.test_interfacec s� t � }| �� � t�dddd�}t� }|�� fdd�� t|�}� �||d� � �tj |� | � � � | � |j � | � ||j� | � ||j� dS )z� When an event which has been added to the reactor is set, the action associated with the event is invoked in the reactor thread. NFc � � � � S r ��stop��ignored�r' r r �<lambda>^ � z7Win32EventsTestsBuilder.test_addEvent.<locals>.<lambda>r )r r& � win32event� CreateEventr � addCallbackr �addEvent�callWhenRunning�SetEvent� runReactor� assertTruer � assertEqualr r )r �reactorThreadID�eventr �listenerr r. r � test_addEventU s z%Win32EventsTestsBuilder.test_addEventc s� g �� �fdd�}| � � � t�dddd�}t� }t|�}|�|� � �||d� � �tj|� | � � � | � |j � | � dg�� dS )z{ Using L{IReactorWin32Events.addEvent} does not change which thread is reported as the I/O thread. c s �� t� � � �� d S r )�appendr r+ r, �r' �resultsr r �checkn s zAWin32EventsTestsBuilder.test_ioThreadDoesNotChange.<locals>.checkNFr T) r& r1 r2 r r r3 r4 r5 r6 r7 r8 r r9 )r rA r; r r< r r? r �test_ioThreadDoesNotChangeg s z2Win32EventsTestsBuilder.test_ioThreadDoesNotChangec s� t � }| �� � t�dddd�}g }t� }|�|j� |�� fdd�� t|�}� �||d� � � tj |� | � � � | � |d t � |d �t� | �||j� | �dt| �t��� dS )z� If the event handler raises an exception, the event is removed from the reactor and the handler's C{connectionLost} method is called in the I/O thread and the exception is logged. NFc r) r r* r, r. r r r/ � r0 zBWin32EventsTestsBuilder.test_disconnectedOnError.<locals>.<lambda>r r � )r r& r1 r2 r �addBothr> r r4 r5 r6 r7 �assertIsInstancer �trapr r9 r �len�flushLoggedErrors�r r: r; �resultr r< r r. r �test_disconnectedOnError} s z0Win32EventsTestsBuilder.test_disconnectedOnErrorc s� t � }| �� � t�dddd�}g }t� }|�|j� |�� fdd�� t|�}� �||d� � � tj |� | � � � | � |d t � |d �t� | �||j� dS )z� If the event handler returns a value, the event is removed from the reactor and the handler's C{connectionLost} method is called in the I/O thread. NFc r) r r* r, r. r r r/ � r0 zFWin32EventsTestsBuilder.test_disconnectOnReturnValue.<locals>.<lambda>r r )r r& r1 r2 r rD r> r r4 r5 r6 r7 rE r rF r r9 r rI r r. r � test_disconnectOnReturnValue� s z4Win32EventsTestsBuilder.test_disconnectOnReturnValuec C sZ | � � }t�dddd�}t� }t|�}|�||d� |�|j� | �|� | � |j � dS )z� Event handlers added with L{IReactorWin32Events.addEvent} do not have C{connectionLost} called on them if they are still active when the reactor shuts down. NFr ) r& r1 r2 r r r4 r5 r+ r7 � assertIsNoner )r r' r; r r< r r r � test_notDisconnectedOnShutdown� s z6Win32EventsTestsBuilder.test_notDisconnectedOnShutdownN) r! r" r# r$ r �requiredInterfacesr( r= rB rK rL rN r r r r r% F s r% )r$ r1 � ImportError�zope.interface.verifyr �twisted.internet.deferr �twisted.internet.interfacesr �#twisted.internet.test.reactormixinsr �twisted.python.failurer �twisted.python.threadabler r r r% �globals�update�makeTestCaseClassesr r r r �<module> s � 0zPK Mb�Z��=6B 6B 6 internet/test/__pycache__/test_testing.cpython-310.pycnu �[��� o �bo? � @ s� d Z ddlmZ ddlmZ ddlmZmZmZm Z m Z m Z m Z m Z mZ ddlmZmZ ddlmZmZmZmZ ddlmZ ddlmZ G d d � d e�ZG d d � d e�Z G d d� d�Z G dd� de�Z G dd� de�Z dS )z( Tests for L{twisted.internet.testing}. � )� verifyObject)� IPv4Address) �IAddress� IConnector� IConsumer�IListeningPort� IPushProducer� IReactorSSL� IReactorTCP� IReactorUNIX� ITransport)� ClientFactory�Factory)� MemoryReactor�NonStreamingProducer�RaisingMemoryReactor�StringTransport)�namedAny)�TestCasec @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(S ))�StringTransportTestsz@ Tests for L{twisted.internet.testing.StringTransport}. c C s t � | _d S �N)r � transport��self� r �D/usr/lib/python3/dist-packages/twisted/internet/test/test_testing.py�setUp& s zStringTransportTests.setUpc C s: | � tt| j�� | � tt| j�� | � tt| j�� dS )zq L{StringTransport} instances provide L{ITransport}, L{IPushProducer}, and L{IConsumer}. N)� assertTruer r r r r r r r r �test_interfaces) s z$StringTransportTests.test_interfacesc C s> t � }t � }| j�||� | �| jj|� | �| jj|� dS )zz L{StringTransport.registerProducer} records the arguments supplied to it as instance attributes. N)�objectr �registerProducer�assertIs�producer� streaming�r r" r# r r r �test_registerProducer2 s z*StringTransportTests.test_registerProducerc C sL t � }| j�|d� | �t| jjt � d� | �| jj|� | �| jj� dS )zy L{StringTransport.registerProducer} raises L{RuntimeError} if a producer is already registered. TFN) r r r � assertRaises� RuntimeErrorr! r" r r# )r r" r r r � test_disallowedRegisterProducer= s �z4StringTransportTests.test_disallowedRegisterProducerc C sb t � }t � }| j�|d� | j�� | �| jj� | j�|d� | �| jj|� | �| jj� dS )z� L{StringTransport.unregisterProducer} causes the transport to forget about the registered producer and makes it possible to register a new one. FTN) r r r �unregisterProducer� assertIsNoner" r! r r# )r � oldProducer� newProducerr r r �test_unregisterProducerJ s z,StringTransportTests.test_unregisterProducerc C s | � t| jj� dS )z� L{StringTransport.unregisterProducer} raises L{RuntimeError} if called when no producer is registered. N)r& r' r r) r r r r � test_invalidUnregisterProducerY s z3StringTransportTests.test_invalidUnregisterProducerc C s | � | jjd� dS )zO L{StringTransport.producerState} is initially C{'producing'}. � producingN)� assertEqualr � producerStater r r r �test_initialProducerState` s z.StringTransportTests.test_initialProducerStatec C � | j �� | �| j jd� dS )zy L{StringTransport.pauseProducing} changes the C{producerState} of the transport to C{'paused'}. �pausedN)r �pauseProducingr0 r1 r r r r �test_pauseProducingf � z(StringTransportTests.test_pauseProducingc C s( | j �� | j �� | �| j jd� dS )z} L{StringTransport.resumeProducing} changes the C{producerState} of the transport to C{'producing'}. r/ N)r r5 �resumeProducingr0 r1 r r r r �test_resumeProducingn s z)StringTransportTests.test_resumeProducingc C r3 )z{ L{StringTransport.stopProducing} changes the C{'producerState'} of the transport to C{'stopped'}. �stoppedN)r � stopProducingr0 r1 r r r r �test_stopProducingw r7 z'StringTransportTests.test_stopProducingc C � | j �� | �t| j j� dS )zu L{StringTransport.pauseProducing} raises L{RuntimeError} if the transport has been stopped. N)r r; r& r' r5 r r r r � test_stoppedTransportCannotPause r7 z5StringTransportTests.test_stoppedTransportCannotPausec C r= )zv L{StringTransport.resumeProducing} raises L{RuntimeError} if the transport has been stopped. N)r r; r& r' r8 r r r r �!test_stoppedTransportCannotResume� r7 z6StringTransportTests.test_stoppedTransportCannotResumec C r= )zz L{StringTransport.pauseProducing} raises L{RuntimeError} if the transport is being disconnected. N)r �loseConnectionr& r' r5 r r r r �&test_disconnectingTransportCannotPause� r7 z;StringTransportTests.test_disconnectingTransportCannotPausec C r= )z{ L{StringTransport.resumeProducing} raises L{RuntimeError} if the transport is being disconnected. N)r r@ r& r' r8 r r r r �'test_disconnectingTransportCannotResume� r7 z<StringTransportTests.test_disconnectingTransportCannotResumec C s* | � | jj� | j�� | �| jj� dS )zv L{StringTransport.loseConnection} toggles the C{disconnecting} instance variable to C{True}. N)� assertFalser � disconnectingr@ r r r r r �$test_loseConnectionSetsDisconnecting� s z9StringTransportTests.test_loseConnectionSetsDisconnectingc C s t � }| �t|��� |� dS )z� If a host address is passed to L{StringTransport.__init__}, that value is returned from L{StringTransport.getHost}. N)r r! r �getHost�r �addressr r r �test_specifiedHostAddress� s z.StringTransportTests.test_specifiedHostAddressc C s t � }| �t|d��� |� dS )z� If a peer address is passed to L{StringTransport.__init__}, that value is returned from L{StringTransport.getPeer}. )� peerAddressN)r r! r �getPeerrG r r r �test_specifiedPeerAddress� s z.StringTransportTests.test_specifiedPeerAddressc C � t � �� }| �|t� dS )z� If no host address is passed to L{StringTransport.__init__}, an L{IPv4Address} is returned from L{StringTransport.getHost}. N)r rF �assertIsInstancer rG r r r �test_defaultHostAddress� � z,StringTransportTests.test_defaultHostAddressc C rM )z� If no peer address is passed to L{StringTransport.__init__}, an L{IPv4Address} is returned from L{StringTransport.getPeer}. N)r rK rN r rG r r r �test_defaultPeerAddress� rP z,StringTransportTests.test_defaultPeerAddressN)�__name__� __module__� __qualname__�__doc__r r r% r( r- r. r2 r6 r9 r< r> r? rA rB rE rI rL rO rQ r r r r r ! s* r c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� ReactorTestszA Tests for L{MemoryReactor} and L{RaisingMemoryReactor}. c C �( t � }tt|� tt|� tt|� dS )zt L{MemoryReactor} provides all of the attributes described by the interfaces it advertises. N)r r r r r )r � memoryReactorr r r �test_memoryReactorProvides� � z'ReactorTests.test_memoryReactorProvidesc C rW )z{ L{RaisingMemoryReactor} provides all of the attributes described by the interfaces it advertises. N)r r r r r )r �raisingReactorr r r �test_raisingReactorProvides� rZ z(ReactorTests.test_raisingReactorProvidesc C s� t � }|�ddt� �|�ddt� d�fD ] }tt|� |�� }tt|� | �|j d� | �|j d� q|� dt� �}tt|� |�� }tt|� | �|j d� dS )a L{MemoryReactor.connectTCP}, L{MemoryReactor.connectSSL}, and L{MemoryReactor.connectUNIX} will return an L{IConnector} whose C{getDestination} method returns an L{IAddress} with attributes which reflect the values passed. ztest.example.comi� Ns /fake/path) r � connectTCPr � connectSSLr r �getDestinationr r0 �host�port� connectUNIX�name)r rX � connectorrH r r r �test_connectDestination� s � z$ReactorTests.test_connectDestinationc C s� t � }|�dt� �|�dt� d�fD ] }tt|� |�� }tt|� | �|j d� | �|j d� q|� dt� �}tt|� |�� }tt|� | �|j d� dS )a� L{MemoryReactor.listenTCP}, L{MemoryReactor.listenSSL} and L{MemoryReactor.listenUNIX} will return an L{IListeningPort} whose C{getHost} method returns an L{IAddress}; C{listenTCP} and C{listenSSL} will have a default host of C{'0.0.0.0'}, and a port that reflects the value passed, and C{listenUNIX} will have a name that reflects the path passed. i2 Nz0.0.0.0s /path/to/socket) r � listenTCPr � listenSSLr r rF r r0 r` ra � listenUNIXrc )r rX ra rH r r r �test_listenDefaultHost� s � z#ReactorTests.test_listenDefaultHostc C �P t � }t� }|�|� |�|� | �|�� |g� |�|� | �|�� g � dS )z> Adding, removing, and listing readers works. N)r r � addReaderr0 � getReaders� removeReader)r �reader�reactorr r r � test_readers � zReactorTests.test_readersc C rj )z> Adding, removing, and listing writers works. N)r r � addWriterr0 � getWriters� removeWriter)r �writerro r r r � test_writers" rq zReactorTests.test_writersN) rR rS rT rU rY r\ re ri rp rv r r r r rV � s rV c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � TestConsumerzP A very basic test consumer for use with the NonStreamingProducerTests. c C s g | _ d | _d | _d S r )�writesr" �producerStreamingr r r r �__init__8 s zTestConsumer.__init__c C s || _ || _dS )z� Registers a single producer with this consumer. Just keeps track of it. @param producer: The producer to register. @param streaming: Whether the producer is a streaming one or not. N�r" ry r$ r r r r = s z TestConsumer.registerProducerc C s d| _ d| _dS )zC Forget the producer we had previously registered. Nr{ r r r r r) G s z TestConsumer.unregisterProducerc C s | j �|� dS )zz Some data was written to the consumer: stores it for later use. @param data: The data to write. N)rx �append)r �datar r r �writeN s zTestConsumer.writeN)rR rS rT rU rz r r) r~ r r r r rw 3 s rw c @ s e Zd ZdZdd� Zdd� ZdS )�NonStreamingProducerTestszF Tests for the L{NonStreamingProducer} to validate behaviour. c C s� t � }t|�}|�|d� | �|j|� | �|j|� | �|j� td�D ]}|� � q%g d�}| � |j� | � |j� | � |j� | � |j |� | � t|j � dS )z� When the L{NonStreamingProducer} has resumeProducing called 10 times, it writes the counter each time and then fails. F� ) � 0� 1� 2� 3� 4� 5� 6� 7� 8� 9N)rw r r r! r" �consumerrC ry �ranger8 r* r0 rx r& r' )r r� r" �_�expectedWritesr r r �test_producesOnly10Times\ s z2NonStreamingProducerTests.test_producesOnly10Timesc C s4 t � }t|�}|�|d� |�� | �t|j� dS )zb When the L{NonStreamingProducer} is paused, it raises a L{RuntimeError}. FN)rw r r r8 r& r' r5 )r r� r" r r r �test_cannotPauseProductionv s z4NonStreamingProducerTests.test_cannotPauseProductionN)rR rS rT rU r� r� r r r r r W s r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd S )!�DeprecationTestsz8 Deprecations in L{twisted.test.proto_helpers}. c C sd d|j � �}| �|g�}| �t|d d � | �dt|�� | �||d d � | �|t|�� d S )Nztwisted.internet.testing.r �category� �message)rR � flushWarningsr0 �DeprecationWarning�len�assertInr! r )r �test�obj�new_path�warningsr r r �helper� s zDeprecationTests.helperc C � ddl m} | �| j|� d S )Nr )�AccumulatingProtocol)�twisted.test.proto_helpersr� r� �test_accumulatingProtocol)r r� r r r r� � � z*DeprecationTests.test_accumulatingProtocolc C r� )Nr )�LineSendingProtocol)r� r� r� �test_lineSendingProtocol)r r� r r r r� � r� z)DeprecationTests.test_lineSendingProtocolc C r� )Nr )�FakeDatagramTransport)r� r� r� �test_fakeDatagramTransport)r r� r r r r� � r� z+DeprecationTests.test_fakeDatagramTransportc C r� )Nr )r )r� r r� �test_stringTransport)r r r r r r� � r� z%DeprecationTests.test_stringTransportc C r� )Nr )� StringTransportWithDisconnection)r� r� r� �%test_stringTransportWithDisconnection)r r� r r r r� � s �z6DeprecationTests.test_stringTransportWithDisconnectionc C r� )Nr )�StringIOWithoutClosing)r� r� r� �test_stringIOWithoutClosing)r r� r r r r� � r� z,DeprecationTests.test_stringIOWithoutClosingc C r� )Nr )�_FakeConnector)r� r� r� �test__fakeConnector)r r� r r r r� � r� z$DeprecationTests.test__fakeConnectorc C r� )Nr )� _FakePort)r� r� r� �test__fakePort)r r� r r r r� � r� z DeprecationTests.test__fakePortc C r� )Nr )r )r� r r� �test_memoryReactor)r r r r r r� � r� z#DeprecationTests.test_memoryReactorc C r� )Nr )�MemoryReactorClock)r� r� r� �test_memoryReactorClock)r r� r r r r� � r� z(DeprecationTests.test_memoryReactorClockc C r� )Nr )r )r� r r� �test_raisingMemoryReactor)r r r r r r� � r� z*DeprecationTests.test_raisingMemoryReactorc C r� )Nr )r )r� r r� �test_nonStreamingProducer)r r r r r r� � r� z*DeprecationTests.test_nonStreamingProducerc C r� )Nr )�waitUntilAllDisconnected)r� r� r� � test_waitUntilAllDisconnected)r r� r r r r� � r� z.DeprecationTests.test_waitUntilAllDisconnectedc C r� )Nr )�EventLoggingObserver)r� r� r� �test_eventLoggingObserver)r r� r r r r� � r� z*DeprecationTests.test_eventLoggingObserverN)rR rS rT rU r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� � s" r� N) rU �zope.interface.verifyr �twisted.internet.addressr �twisted.internet.interfacesr r r r r r r r r �twisted.internet.protocolr r �twisted.internet.testingr r r r �twisted.python.reflectr �twisted.trial.unittestr r rV rw r r� r r r r �<module> s , )j$.PK Mb�Z�=m�� � 4 internet/test/__pycache__/test_stdio.cpython-310.pycnu �[��� o �b� � @ s` d Z ddlmZ ddlmZ ddlmZ e�� s ddlm Z G dd� de�Z e � � e � � � dS ) z& Tests for L{twisted.internet.stdio}. � )�Protocol)�ReactorBuilder)�platform)� StandardIOc @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z e � � r.dZdS dS )�StdioFilesTestszI L{StandardIO} supports reading and writing to filesystem files. c C s4 | � � }t|d��� t|d�| _| �| jj� d S )N�wbzrb+)�mktemp�open�close� extraFile� addCleanup)�self�path� r �B/usr/lib/python3/dist-packages/twisted/internet/test/test_stdio.py�setUp s zStdioFilesTests.setUpc s� | � � � G � fdd�dt�}| �� }t|d�� }|�d� W d � n1 s'w Y t|d�� }|� }t||�� | j�� � d� | �� � W d � n1 sQw Y | � |j d� dS )zc Adding a filesystem file reader to a reactor will make sure it is polled. c s e Zd ZdZ� fdd�ZdS )z4StdioFilesTests.test_addReader.<locals>.DataProtocol� c s( | j |7 _ | j dkr� �� d S d S )N� hello!)�data�stop)r r ��reactorr r � dataReceived& s �zAStdioFilesTests.test_addReader.<locals>.DataProtocol.dataReceivedN)�__name__� __module__� __qualname__r r r r r r � DataProtocol# s r r r N�rb��stdin�stdoutr ) � buildReactorr r r �writer �filenor � runReactor� assertEqualr )r r r �f�protocolr r r �test_addReader s" � � � z StdioFilesTests.test_addReaderc s� | � � � G � fdd�dt�}| �� }t|d��.}|� }t||�� | j�� � d� |j�d� |j�d� |j� � | � � � W d � n1 sHw Y t|d��}| � |� � d � W d � dS 1 sfw Y dS ) zc Adding a filesystem file writer to a reactor will make sure it is polled. c s e Zd Z� fdd�ZdS )z:StdioFilesTests.test_addWriter.<locals>.DisconnectProtocolc s � � � d S )N)r )r �reasonr r r �connectionLostH s zIStdioFilesTests.test_addWriter.<locals>.DisconnectProtocol.connectionLostN)r r r r* r r r r �DisconnectProtocolG s r+ r �r r r � hellos , worldNr s hello, world) r! r r r r r# r � transportr" �loseConnectionr$ r% �read)r r+ r r& r' r r r �test_addWriter@ s& � � "�z StdioFilesTests.test_addWriterc C s� | � � }| �| j|� | �� }t|d��� t|d��.}tt� |�� | j �� |d�}| � |j |� � � |j � � | �|j |� � � W d � dS 1 sLw Y dS )zq Removing a filesystem file reader from a reactor will make sure it is no longer polled. r r r N)r! r �unbuildReactorr r r r r r# r �assertIn�_reader� getReaders� stopReading� assertNotIn�r r r r& �stdior r r �test_removeReader` s � "�z!StdioFilesTests.test_removeReaderc C s� | � � }| �| j|� t| �� d� | _}t� }t||�� | j �� |d�}|j � d� | � |j |�� � |j �� | �|j |�� � dS )zq Removing a filesystem file writer from a reactor will make sure it is no longer polled. r r, r- N)r! r r2 r r r& r r r# r r. r" r3 �_writer� getWriters� stopWritingr7 )r r r& r' r9 r r r �test_removeWriterw s � z!StdioFilesTests.test_removeWriterc C s� | � � }| �| j|� | �� }t|d��� t|d� | _}tt� |� � | j � � |d�}|� � }| � |j |� | �|j |�� � dS )zk Calling C{removeAll} on a reactor includes descriptors that are filesystem files. r r r N)r! r r2 r r r r& r r r# r � removeAllr3 r4 r7 r5 )r r r r& r9 �removedr r r �test_removeAll� s �z StdioFilesTests.test_removeAllc C s� | � � }| �| j|� | �� }t|d��� t|d�� }tt� |�� | j �� |d�}| � |j |� � � W d � dS 1 s>w Y dS )zW C{reactor.getReaders} includes descriptors that are filesystem files. r r r N) r! r r2 r r r r r r# r r3 r4 r5 r8 r r r �test_getReaders� s �"�z StdioFilesTests.test_getReadersc C sx | � � }| �| j|� t| �� d� | _}tt� |�� | j �� |d�}| � |j |� � � |j � � | �|j |� � � dS )zW C{reactor.getWriters} includes descriptors that are filesystem files. r r, N)r! r r2 r r r& r r r# r r7 r; r< � startWritingr3 )r r r& r9 r r r �test_getWriters� s � z StdioFilesTests.test_getWriterszoStandardIO does not accept stdout as an argument to Windows. Testing redirection to a file is therefore harder.N)r r r �__doc__r r( r1 r: r> rA rB rD r � isWindows�skipr r r r r s $ ��r N)rE �twisted.internet.protocolr �#twisted.internet.test.reactormixinsr �twisted.python.runtimer rF �twisted.internet.stdior r �globals�update�makeTestCaseClassesr r r r �<module> s GPK Mb�Z�H�� 6 internet/test/__pycache__/test_default.cpython-310.pycnu �[��� o �b[ � @ s� d Z ddlZddlZddlmZ ddlmZmZ ddlm Z ddl m Z ddl m Z ddlmZ dd lmZ ed d �Zed d �Zed d�Zed d�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )z( Tests for L{twisted.internet.default}. � N)�default)�_getInstallFunction�install)� IReactorCore)� NoReactor)� requireModule)�Platform)�SynchronousTestCase�posix�other�linux2�nt�win32�darwinc @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �PollReactorTestsz� Tests for the cases of L{twisted.internet.default._getInstallFunction} in which it picks the poll(2) or epoll(7)-based reactors. c C s. t td�r| �|jd� dS | �|jd� dS )zz Assert the given function will install the poll() reactor, or select() if poll() is unavailable. �pollz twisted.internet.pollreactor� twisted.internet.selectreactorN)�hasattr�select� assertEqual� __module__��selfr � r �D/usr/lib/python3/dist-packages/twisted/internet/test/test_default.py� assertIsPoll s z PollReactorTests.assertIsPollc C s t t�}| �|� dS )z� L{_getInstallFunction} chooses the poll reactor on arbitrary Unix platforms, falling back to select(2) if it is unavailable. N)r �unixr r r r r � test_unix* s zPollReactorTests.test_unixc C s4 t t�}td�du r| �|� dS | �|jd� dS )zu L{_getInstallFunction} chooses the epoll reactor on Linux, or poll if epoll is unavailable. z twisted.internet.epollreactorN)r �linuxr r r r r r r r � test_linux2 s zPollReactorTests.test_linuxN)�__name__r � __qualname__�__doc__r r r r r r r r s r c @ � e Zd ZdZdd� Zdd� ZdS )�SelectReactorTestsz� Tests for the cases of L{twisted.internet.default._getInstallFunction} in which it picks the select(2)-based reactor. c C � t t�}| �|jd� dS )zM L{_getInstallFunction} chooses the select reactor on macOS. r N)r �osxr r r r r r �test_osxD � zSelectReactorTests.test_osxc C r% )zO L{_getInstallFunction} chooses the select reactor on Windows. r N)r �windowsr r r r r r � test_windowsK r( z SelectReactorTests.test_windowsN)r r r! r" r' r* r r r r r$ > s r$ c @ r# )�InstallationTestsz7 Tests for actual installation of the reactor. c C s@ t � � t� | �dtj� W d � dS 1 sw Y dS )z0 L{install} installs a reactor. ztwisted.internet.reactorN)r r �assertIn�sys�modules)r r r r � test_installX s "�z InstallationTests.test_installc st g � � fdd�}| � td|� t� � ddlm} | �t�|�� | �� dg� W d � dS 1 s3w Y dS )zr Importing L{twisted.internet.reactor} installs the default reactor if none is installed. c s � � d� t� S )NT)�appendr r �� installedr r � installerg s z1InstallationTests.test_reactor.<locals>.installerr r )�reactorTN) �patchr r �twisted.internetr4 � assertTruer � providedByr )r r3 r4 r r1 r � test_reactor` s "�z InstallationTests.test_reactorN)r r r! r" r/ r9 r r r r r+ S s r+ )r" r r- r6 r �twisted.internet.defaultr r �twisted.internet.interfacesr � twisted.internet.test.test_mainr �twisted.python.reflectr �twisted.python.runtimer �twisted.trial.unittestr r r r) r& r r$ r+ r r r r �<module> s" $PK Mb�Z ��� � 5 internet/test/__pycache__/process_cli.cpython-310.pycnu �[��� o �b# � @ s� d dl Z d dlZzd dlZe�ej�� e j� W n ey! Y nw ejdd� D ]Z e e d � Z ejj � e �e�� d�� ej�� q)dS )� N� �surrogateescape)�os�sys�msvcrt�setmode�stdout�fileno�O_BINARY� ImportError�argv�arg�chr�res�buffer�write�encode�getfilesystemencoding�flush� r r �C/usr/lib/python3/dist-packages/twisted/internet/test/process_cli.py�<module> s � � �PK Mb�ZN �GC C 5 internet/test/__pycache__/test_newtls.cpython-310.pycnu �[��� o �b� � @ s d Z ddlmZ ddlmZmZ ddlmZ ddlm Z ddl m Z m Z m Z mZ ddlmZ zddlmZ dd lmZ W n eyG d ZY nw eZdd lmZ G d d � d ej�ZG dd� d�Zeej�G dd� de��Z G dd� deee �Z e � � e � � � d S )z( Tests for L{twisted.internet._newtls}. � )� interfaces)�ConnectableProtocol�runProtocolsWithReactor)�ReactorBuilder)� TCPCreator)�ContextGeneratingMixin� SSLCreator�StartTLSClientCreator�TLSMixin)�unittest)�_newtls)�tlsN)� implementerc @ s e Zd ZdZes dZdd� ZdS )�BypassTLSTestsz4 Tests for the L{_newtls._BypassTLS} class. z<Couldn't import _newtls, perhaps pyOpenSSL is old or missingc sf t � � g �G � �fdd�d�}t�||� �}|�� | ��� g� t � }|�|� | ��� |g� dS )z� C{_BypassTLS.loseConnection} calls C{loseConnection} on the base class, while preserving any default argument in the base class' C{loseConnection} implementation. c s e Zd Z� f�fdd� ZdS )zDBypassTLSTests.test_loseConnectionPassThrough.<locals>.FakeTransportc s � � |� d S �N)�append)�self� _connDone)�result� �C/usr/lib/python3/dist-packages/twisted/internet/test/test_newtls.py�loseConnection4 s zSBypassTLSTests.test_loseConnectionPassThrough.<locals>.FakeTransport.loseConnectionN)�__name__� __module__� __qualname__r r ��defaultr r r � FakeTransport3 s r N)�objectr � _BypassTLSr � assertEqual)r r �bypass� notDefaultr r r � test_loseConnectionPassThrough* s z-BypassTLSTests.test_loseConnectionPassThroughN)r r r �__doc__r �skipr# r r r r r " s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � FakeProducerz' A producer that does nothing. c C � d S r r �r r r r �pauseProducingH � zFakeProducer.pauseProducingc C r' r r r( r r r �resumeProducingK r* z FakeProducer.resumeProducingc C r' r r r( r r r � stopProducingN r* zFakeProducer.stopProducingN)r r r r$ r) r+ r, r r r r r& C s r& c @ s e Zd ZdZdd� Zdd� ZdS )�ProducerProtocolzy Register a producer, unregister it, and verify the producer hooks up to innards of C{TLSMemoryBIOProtocol}. c C s || _ || _d S r )�producerr )r r. r r r r �__init__Y s zProducerProtocol.__init__c C sf t | jjtj�s td��| j�| jd� | j� | jjj j � | j� � | j� | jjj � | j� � d S )Nz#TLSMemoryBIOProtocol not hooked up.T) � isinstance� transport�protocolr �TLSMemoryBIOProtocol� RuntimeError�registerProducerr. r r � _producer�unregisterProducerr r( r r r �handshakeCompleted] s z#ProducerProtocol.handshakeCompletedN)r r r r$ r/ r8 r r r r r- R s r- c @ s@ e Zd ZdZes dZdd� Zdd� Zdd� Zd d � Z d d � Z d S )�ProducerTestsMixinzM Test the new TLS code integrates C{TLSMemoryBIOProtocol} correctly. z)Could not import twisted.internet._newtlsc C �6 g }t � }t| t� t||�t� � | �||dg� dS )z� C{registerProducer} and C{unregisterProducer} on TLS transports created as SSL from the get go are passed to the C{TLSMemoryBIOProtocol}, not the underlying transport directly. N)r& r r r- r r �r r r. r r r �test_producerSSLFromStartt � �z,ProducerTestsMixin.test_producerSSLFromStartc C r: )z� C{registerProducer} and C{unregisterProducer} on TLS transports created by C{startTLS} are passed to the C{TLSMemoryBIOProtocol}, not the underlying transport directly. N)r& r r r- r r r; r r r �test_producerAfterStartTLS� r= z-ProducerTestsMixin.test_producerAfterStartTLSc sp | � � � | �� �g �t� �G ����fdd�dt�}G � fdd�dt�}t| |� |� t� � | ����g� dS )z� When a producer is registered, and then startTLS is called, the producer is re-registered with the C{TLSMemoryBIOProtocol}. c s e Zd Z� ���fdd�ZdS )zMProducerTestsMixin.startTLSAfterRegisterProducer.<locals>.RegisterTLSProtocolc s� | j �� �� | j ��� �r!��| j jjj� ��| j jj� n��| j jjjj� ��| j jjj� | j �� | j �� d S r ) r1 r5 �startTLSr r2 r6 r. r7 r r( �r. r � serverContext� streamingr r �connectionMade� s z\ProducerTestsMixin.startTLSAfterRegisterProducer.<locals>.RegisterTLSProtocol.connectionMadeN�r r r rC r r@ r r �RegisterTLSProtocol� s rE c s e Zd Z� fdd�ZdS )zJProducerTestsMixin.startTLSAfterRegisterProducer.<locals>.StartTLSProtocolc s | j �� � d S r )r1 r? r( �� clientContextr r rC � s zYProducerTestsMixin.startTLSAfterRegisterProducer.<locals>.StartTLSProtocol.connectionMadeNrD r rF r r �StartTLSProtocol� s rH N)�getClientContext�getServerContextr& r r r r )r rB rE rH r )rG r. r rA rB r � startTLSAfterRegisterProducer� s �z0ProducerTestsMixin.startTLSAfterRegisterProducerc C � | � d� dS )z� When a streaming producer is registered, and then startTLS is called, the producer is re-registered with the C{TLSMemoryBIOProtocol}. TN�rK r( r r r �+test_startTLSAfterRegisterProducerStreaming� s z>ProducerTestsMixin.test_startTLSAfterRegisterProducerStreamingc C rL )z� When a non-streaming producer is registered, and then startTLS is called, the producer is re-registered with the C{TLSMemoryBIOProtocol}. FNrM r( r r r �.test_startTLSAfterRegisterProducerNonStreaming� s zAProducerTestsMixin.test_startTLSAfterRegisterProducerNonStreamingN) r r r r$ r r% r< r> rK rN rO r r r r r9 l s $ r9 )!r$ �twisted.internetr �&twisted.internet.test.connectionmixinsr r �#twisted.internet.test.reactormixinsr � twisted.internet.test.test_tcpr � twisted.internet.test.test_tlsr r r r � twisted.trialr r �__newtls�twisted.protocolsr � ImportError�zope.interfacer �TestCaser r& �IHandshakeListenerr- r9 �globals�update�makeTestCaseClassesr r r r �<module> s* � !^PK Mb�Z�p��( ( 6 internet/test/__pycache__/_posixifaces.cpython-310.pycnu �[��� o �b' � @ s� U d Z ddlZddlZddlmZmZmZmZmZm Z m Z m Z m Z m Z mZmZ ddlmZ ddlmZmZmZ ddlmZmZmZ ddlmZ eed�pMd �Zej � d �sZej d krmd e fd e fgZ eee ef e d< nd e fgZ eee ef e d< G dd� de�Z!G dd� de�Z"G dd� de�Z#G dd� de�Z$G dd� de�Z%G dd� de�Z&ee&�Z'de'fd efd e fd ee#�fd ee#�fd ee#�fd!e fge&_(ej)Z)ee'�ge)_*ee)_+ej,Z,e'ge,_*d"d#� Z-d$d%� Z.d&d'� Z/dS )(z> POSIX implementation of local network interface enumeration. � N) �CDLL�POINTER� Structure�c_char_p�c_int�c_ubyte�c_uint8�c_uint32�c_ushort�c_void_p�cast�pointer)� find_library)�AF_INET�AF_INET6� inet_ntop)�Any�List�Tuple)� nativeString�c� �freebsd�darwin�sin_len� sin_family�_sockaddrCommonc @ s e Zd Zd ed fgZdS )�in_addr� N��__name__� __module__� __qualname__r �_fields_� r$ r$ �D/usr/lib/python3/dist-packages/twisted/internet/test/_posixifaces.pyr , � �r c @ s e Zd Zded fgZdS )�in6_addrr � Nr r$ r$ r$ r% r' 2 r& r' c @ s e Zd Zedefg ZdS )�sockaddr�sin_portN)r r! r" r r r# r$ r$ r$ r% r) 8 s �r) c @ s e Zd Zedefdefg ZdS )� sockaddr_inr* �sin_addrN)r r! r" r r r r# r$ r$ r$ r% r+ > s �r+ c @ s& e Zd Zedefdefdefg ZdS )� sockaddr_in6r* � sin_flowinfor, N)r r! r" r r r r' r# r$ r$ r$ r% r- E s �r- c @ s e Zd ZdS )�ifaddrsN)r r! r" r$ r$ r$ r% r/ M s r/ �ifa_next�ifa_name� ifa_flags�ifa_addr� ifa_netmask� ifa_dstaddr�ifa_datac C s< t j�d�r |dd� dkr |dd� d |dd� S |S )a� On FreeBSD, kill the embedded interface indices in link-local scoped addresses. @param family: The address family of the packed address - one of the I{socket.AF_*} constants. @param packed: The packed representation of the address (ie, the bytes of a I{in_addr} field). @type packed: L{bytes} @return: The packed address with any FreeBSD-specific extra bits cleared. @rtype: L{bytes} @see: U{https://twistedmatrix.com/trac/ticket/6843} @see: U{http://www.freebsd.org/doc/en/books/developers-handbook/ipv6.html#ipv6-scope-index} @note: Indications are that the need for this will be gone in FreeBSD >=10. r N� s ��s r )�sys�platform� startswith)�family�packedr$ r$ r% �_maybeCleanupScopeIndexd s r= c C s� t � } tt| ��dk rt� �g }ze| ro| d jra| d jd j}|tkr/t| d jtt ��}n|t kr>t| d jtt ��}nd}|rat |d j jdd� �}t||�}|�| d j|t||�f� | d j} | sW t| � |S W t| � |S t| � w )z� Call C{getifaddrs(3)} and return a list of tuples of interface name, address family, and human-readable address representing its results. r N)� ifaddrs_p� getifaddrsr �OSErrorr3 r r r r r+ r r- �bytesr, r r= �appendr1 r r0 � freeifaddrs)r/ �resultsr; �addrr< r$ r$ r% � _interfaces} s6 � �� �rF c C sR g } t � D ]!\}}}t|�}t|�}|tjkr&|�d�r&| �|� d|� �� q| S )z� Return a list of strings in colon-hex format representing all the link local IPv6 addresses available on the system, as reported by I{getifaddrs(3)}. zfe80:�%)rF r �socketr r: rB )�retList� interfacer; �addressr$ r$ r% � posixGetLinkLocalIPv6Addresses� s �rL )0�__doc__rH r8 �ctypesr r r r r r r r r r r r � ctypes.utilr r r r �typingr r r �twisted.python.compatr �libcr9 r: r �str�__annotations__r r' r) r+ r- r/ r> r# r? �argtypes�restyperC r= rF rL r$ r$ r$ r% �<module> sL 8 �� � !PK Mb�Z�J?�Y Y < internet/test/__pycache__/test_udp_internals.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z edkr)ddl m Z ndd l m Z G d d � d �Z G d d � d e�ZG dd� de j�ZdS )zK Tests for the internal implementation details of L{twisted.internet.udp}. � N)�udp)�DatagramProtocol)� platformType)�unittest�win32)�WSAEWOULDBLOCK)� EWOULDBLOCKc @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �StringUDPSocketa A fake UDP socket object, which returns a fixed sequence of strings and/or socket errors. Useful for testing. @ivar retvals: A C{list} containing either strings or C{socket.error}s. @ivar connectedAddr: The address the socket is connected to. c C s || _ d | _d S �N)�retvals� connectedAddr)�selfr � r �J/usr/lib/python3/dist-packages/twisted/internet/test/test_udp_internals.py�__init__ s zStringUDPSocket.__init__c C s || _ d S r )r )r �addrr r r �connect$ � zStringUDPSocket.connectc C s$ | j �d�}t|tj�r|�|dfS )zH Return (or raise) the next value from C{self.retvals}. r N)r �pop� isinstance�socket�error)r �size�retr r r �recvfrom' s zStringUDPSocket.recvfromN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r c @ s e Zd ZdZdd� Zdd� ZdS )� KeepReadsz% Accumulate reads in a list. c C s g | _ d S r )�reads)r r r r r 6 r zKeepReads.__init__c C s | j �|� d S r )r �append)r �datar r r r �datagramReceived9 s zKeepReads.datagramReceivedN)r r r r r r# r r r r r 1 s r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � ErrorsTestsz/ Error handling tests for C{udp.Port}. c C s� t j�d� | �t jjd� t� }t �d|�}tddt� d�dt� d�g�|_|� � | � |j ddg� |� � | � |j g d�� dS )z� Socket reads with some good data followed by a socket error which can be ignored causes reading to stop, and no log messages to be logged. i��N� result� 123� 456)r% r& r' ) r �_sockErrReadIgnorer! � addCleanup�remover �Portr r r �doRead� assertEqualr �r �protocol�portr r r �test_socketReadNormalB s �z!ErrorsTests.test_socketReadNormalc C s� t j�d� | �t jjd� t� }dd� |_t �d|�}tdt � d�dt � t �g�|_ |� � | � |jdg� |� � | � |jddg� dS )z� If the socket is unconnected, socket reads with an immediate connection refusal are ignored, and reading stops. The protocol's C{connectionRefused} method is not called. ��c S s dd S )N� r r r r r r �<lambda>e s z5ErrorsTests.test_readImmediateError.<locals>.<lambda>N� a� b)r �_sockErrReadRefuser! r) r* r �connectionRefusedr+ r r r r r, r- r r. r r r �test_readImmediateErrorX s �z#ErrorsTests.test_readImmediateErrorc s� t j�d� | �t jjd� t� }g � � fdd�|_t �d|�}tdt � d�dt � t �g�|_ |� dd� |� � | �|jdg� | �� d g� |� � | �|jddg� | �� d g� dS ) z� If the socket connected, socket reads with an immediate connection refusal are ignored, and reading stops. The protocol's C{connectionRefused} method is called. r2 c s � � d�S )NT)r! r ��refusedr r r4 � s z>ErrorsTests.test_connectedReadImmediateError.<locals>.<lambda>Nr5 r6 z 127.0.0.1i' T)r r7 r! r) r* r r8 r+ r r r r r r, r- r r. r r: r � test_connectedReadImmediateErrort s � z,ErrorsTests.test_connectedReadImmediateErrorc C sJ t � }t�d|�}tdt�d�g�|_| �tj|j� | �|j dg� dS )zG Socket reads with an unknown socket error are raised. Ns goodi���) r r r+ r r r � assertRaisesr, r- r r. r r r �test_readUnknownError� s z!ErrorsTests.test_readUnknownErrorN)r r r r r1 r9 r< r> r r r r r$ = s r$ )r r �twisted.internetr �twisted.internet.protocolr �twisted.python.runtimer � twisted.trialr �errnor r r r �SynchronousTestCaser$ r r r r �<module> s PK Mb�ZLs�ͤ � 6 internet/test/__pycache__/test_sigchld.cpython-310.pycnu �[��� o �bR � @ s~ d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z edkr3ddl m Z m Z ddl mZ nd ZG d d � d e �ZdS ) zX Tests for L{twisted.internet._sigchld}, an alternate, superior SIGCHLD monitoring API. � N)�msg)� platformType)�SynchronousTestCase�posix)�installHandler�isDefaultHandler)�setNonBlockingz,These tests can only run on POSIX platforms.c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�SetWakeupSIGCHLDTestszy Tests for the L{signal.set_wakeup_fd} implementation of the L{installHandler} and L{isDefaultHandler} APIs. c C s@ t �� \}}| �t j|� | �t j|� t|� t|� ||fS )zk Create a non-blocking pipe which will be closed after the currently running test. )�os�pipe� addCleanup�closer ��self�read�write� r �D/usr/lib/python3/dist-packages/twisted/internet/test/test_sigchld.pyr s zSetWakeupSIGCHLDTests.pipec C sr t �t j�}|t jkr|| _t � t jt j� nd| _td�| _| jdur5| jdkr7td| j| jf � dS dS dS )z� Save the current SIGCHLD handler as reported by L{signal.signal} and the current file descriptor registered with L{installHandler}. N���z<Previous test didn't clean up after its SIGCHLD setup: %r %r)�signal� getsignal�SIGCHLD�SIG_DFL�signalModuleHandlerr �oldFDr )r �handlerr r r �setUp+ s ���zSetWakeupSIGCHLDTests.setUpc C sR t d� t�tjtj� | jdurt�tj| j� dS | jdkr't | j� dS dS )zM Restore whatever signal handler was present when setUp ran. r N)r r r r r r �r r r r �tearDown? s �z SetWakeupSIGCHLDTests.tearDownc C sf | � t� � t�tjtj� | �t� � t�tjtj� | � t� � t�tjdd� � | �t� � dS )zn L{isDefaultHandler} returns true if the SIGCHLD handler is SIG_DFL, false otherwise. c W s d S )Nr )�argsr r r �<lambda>W s z=SetWakeupSIGCHLDTests.test_isDefaultHandler.<locals>.<lambda>N)� assertTruer r r �SIG_IGN� assertFalser r r r r �test_isDefaultHandlerM s z+SetWakeupSIGCHLDTests.test_isDefaultHandlerc C s( | � � \}}t|�}| �t|�|� dS )zV L{installHandler} returns the previously registered file descriptor. N)r r � assertEqual)r r r r r r r �test_returnOldFDZ s z&SetWakeupSIGCHLDTests.test_returnOldFDc C sD | � � \}}| �t� � t|� | �t� � td� | �t� � dS )zO C{installHandler(-1)} removes the SIGCHLD handler completely. r N)r r! r r r# r r r r �test_uninstallHandlerb s z+SetWakeupSIGCHLDTests.test_uninstallHandlerc C sd | � � \}}t|� | �ttj|d�}| �|jtj� t� t� � t j � | �t t�|d��d� dS )z� The file descriptor passed to L{installHandler} has a byte written to it when SIGCHLD is delivered to the process. � � N)r r � assertRaises�OSErrorr r r% �errno�EAGAIN�kill�getpidr r �len)r r r �excr r r �test_installHandlerm s z)SetWakeupSIGCHLDTests.test_installHandlerN) �__name__� __module__� __qualname__�__doc__r r r r$ r& r' r2 r r r r r s r )r6 r, r r �twisted.python.logr �twisted.python.runtimer �twisted.trial.unittestr �twisted.internet._signalsr r �twisted.internet.fdescr �skipr r r r r �<module> s PK Mb�Z���b b 8 internet/test/__pycache__/test_gireactor.cpython-310.pycnu �[��� o �bt � @ s� d Z ddlZddlmZ zddlmZ ddlmZ W n e y' dZdZ Y n w eZzddlm Z W n e y= dZ Y n w e Z ddlm Z ddl mZ dd lmZ dd lmZmZ edu r`d ZG d d � d ee�ZG dd� de�ZdS )z GI/GTK3 reactor tests. � N)�skipIf)�Gio)� gireactor)� gtk3reactor)�Gtk)�ReactorAlreadyRunning)�ReactorBuilder)�SkipTest�TestCasezgtk3/gi not importablec @ sV e Zd ZdZdd� Zdd� Zeedu d�dd � �Zd d � Z d d � Z dd� Z dd� Z dS )� GApplicationRegistrationTestsa GtkApplication and GApplication are supported by L{twisted.internet.gtk3reactor} and L{twisted.internet.gireactor}. We inherit from L{ReactorBuilder} in order to use some of its reactor-running infrastructure, but don't need its test-creation functionality. c sr t |d�s td��g �� �fdd��� ��fdd�}|�d|� |�� � �|� t�| � � | ��dd g� d S ) z� Register the app, run the reactor, make sure app was activated, and that reactor was running, and that reactor can be stopped. �quitz Version of PyGObject is too old.c s �� d� � �� d S )N�stopped)�append�stop� )�reactor�resultr �F/usr/lib/python3/dist-packages/twisted/internet/test/test_gireactor.pyr < s z6GApplicationRegistrationTests.runReactor.<locals>.stopc s �� d� � �d�� d S )N� activatedr )r � callLater)�widget�r r r r r �activate@ s z:GApplicationRegistrationTests.runReactor.<locals>.activater r r N)�hasattrr �connect�hold�registerGApplicationr � runReactor� assertEqual)�self�appr r r r r r 2 s z(GApplicationRegistrationTests.runReactorc C s< t jdd�}| �| j|� tjdtjjd�}| �||� dS )zR L{Gio.Application} instances can be registered with a gireactor. F��useGtk�!com.twistedmatrix.trial.gireactor��application_id�flagsN) r � GIReactor� addCleanup�unbuildReactorr � Application�ApplicationFlags� FLAGS_NONEr �r r r r r r �test_gApplicationActivateP s �z7GApplicationRegistrationTests.test_gApplicationActivateNz>Gtk unavailable (may require running with X11 DISPLAY env set)c C s8 t �� }| �| j|� tjdtjjd�}| � ||� dS )zT L{Gtk.Application} instances can be registered with a gtk3reactor. z#com.twistedmatrix.trial.gtk3reactorr$ N) r � Gtk3Reactorr( r) r r* r r+ r, r r- r r r �test_gtkApplicationActivate] s �z9GApplicationRegistrationTests.test_gtkApplicationActivatec C s< t �� }| �| j|� tjdtjjd�}| �t |j |� dS )zo L{gireactor.PortableGIReactor} doesn't support application registration at this time. r# r$ N) r �PortableGIReactorr( r) r r* r+ r, � assertRaises�NotImplementedErrorr r- r r r � test_portablen s �z+GApplicationRegistrationTests.test_portablec C sJ t jdd�}| �| j|� t� }| �t|j|�}| �|j d � d�� dS )zp Older versions of PyGObject lack C{Application.quit}, and so won't allow registration. Fr! r z Application registration is notN) r r' r( r) �objectr2 � RuntimeErrorr � assertTrue�args� startswith)r r r �excr r r � test_noQuit{ s z)GApplicationRegistrationTests.test_noQuitc sX t jdd�����j�� tjdtjjd�� � ��fdd�}��d|� t � ��� dS ) zp It is not possible to register a C{Application} after the reactor has already started. Fr! r# r$ c s. �� t�j� �} ��| jd d� ��� d S )Nr z5Can't register application after reactor was started.)r2 r r r r8 r )r: �r r r r r � tryRegister� s � � zLGApplicationRegistrationTests.test_cantRegisterAfterRun.<locals>.tryRegisterr N) r r' r( r) r r* r+ r, r r r )r r= r r< r �test_cantRegisterAfterRun� s � z7GApplicationRegistrationTests.test_cantRegisterAfterRunc C sn t jdd�}| �| j|� tjdtjjd�}|�|� tjdtjjd�}| � t |j|�}| � |j d d� dS ) zN It is not possible to register more than one C{Application}. Fr! r# r$ z"com.twistedmatrix.trial.gireactor2r z2Can't register more than one application instance.N) r r' r( r) r r* r+ r, r r2 r6 r r8 )r r r �app2r: r r r �test_cantRegisterTwice� s � � �z4GApplicationRegistrationTests.test_cantRegisterTwice) �__name__� __module__� __qualname__�__doc__r r. r r r0 r4 r; r> r@ r r r r r ( s � r c @ s e Zd ZdZdd� ZdS )�PygtkCompatibilityTestsz_ pygtk imports are either prevented, or a compatibility layer is used if possible. c C s0 dt jvr td��ddl}| �|j�d�� dS )zo If compatibility layer is present, importing gobject uses the gi compatibility layer. zgi.pygtkcompatz/This version of gi doesn't include pygtkcompat.r Nzgi.)�sys�modulesr �gobjectr7 rA r9 )r rH r r r �test_compatibilityLayer� s z/PygtkCompatibilityTests.test_compatibilityLayerN)rA rB rC rD rI r r r r rE � s rE )rD rF �unittestr � gi.repositoryr �twisted.internetr � _gireactor� ImportErrorr � _gtk3reactorr �twisted.internet.errorr �#twisted.internet.test.reactormixinsr �twisted.trial.unittestr r �skipr rE r r r r �<module> s4 � � PK Mb�Z� �" " @ internet/test/__pycache__/process_connectionlost.cpython-310.pycnu �[��� o �b~ � @ s8 d dl Z d dlZ ej�� �� ZesdS e �ee�� q )� N)�os�sys�stdin�readline�strip�line�close�int� r r �N/usr/lib/python3/dist-packages/twisted/internet/test/process_connectionlost.py�<module> s �PK Mb�Z�@W�o o : internet/test/__pycache__/test_baseprocess.cpython-310.pycnu �[��� o �b � @ s@ d Z ddlmZ ddlmZmZ ddlmZ G dd� de�ZdS )z� Tests for L{twisted.internet._baseprocess} which implements process-related functionality that is useful in all platforms supporting L{IReactorProcess}. � )� BaseProcess)�getWarningMethod�setWarningMethod)�TestCasec @ s e Zd ZdZdd� Zdd� ZdS )�BaseProcessTestsz� Tests for L{BaseProcess}, a parent class for other classes which represent processes which implements functionality common to many different process implementations. c C sN G dd� d�}t d�}t|� �}|�|� |jj�t � | �||jjj� dS )z� L{BaseProcess._callProcessExited} calls the C{processExited} method of its C{proto} attribute and passes it a L{Failure} wrapping the given exception. c @ s e Zd ZdZdd� ZdS )z:BaseProcessTests.test_callProcessExited.<locals>.FakeProtoNc S s || _ d S �N)�reason)�selfr � r �H/usr/lib/python3/dist-packages/twisted/internet/test/test_baseprocess.py� processExited s zHBaseProcessTests.test_callProcessExited.<locals>.FakeProto.processExited)�__name__� __module__� __qualname__r r r r r r � FakeProto s r z fake reasonN)� RuntimeErrorr �_callProcessExited�protor �trap�assertIs�value)r r r �processr r r �test_callProcessExited s z'BaseProcessTests.test_callProcessExitedc s� G dd� d�}t � }t|� �}| �tt� � g � � fdd�}t|� |�|� � \\}}}| �|d|j|jf � | � |t � | �|d� dS )z� L{BaseProcess._callProcessExited} emits a L{DeprecationWarning} if the object referred to by its C{proto} attribute has no C{processExited} method. c @ s e Zd ZdS )zABaseProcessTests.test_callProcessExitedMissing.<locals>.FakeProtoN)r r r r r r r r / s r c s � � | ||f� d S r )�append)�message�category� stacklevel��warningsr r �collect8 s z?BaseProcessTests.test_callProcessExitedMissing.<locals>.collectzXSince Twisted 8.2, IProcessProtocol.processExited is required. %s.%s must implement it.r N) �objectr � addCleanupr r r � assertEqualr r r �DeprecationWarning)r r r r r r r r r r r � test_callProcessExitedMissing( s" �� z.BaseProcessTests.test_callProcessExitedMissingN)r r r �__doc__r r$ r r r r r s r N) r% � twisted.internet._baseprocessr �twisted.python.deprecater r �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z|ܞq� � 7 internet/test/__pycache__/modulehelpers.cpython-310.pycnu �[��� o �b� � @ sL d Z ddgZddlZddlZddlmZ G dd� de�ZG dd� de�ZdS )z/ Testing helpers related to the module system. � NoReactor�AlternateReactor� N)�SetAsideModulec @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r zc Context manager that uninstalls the reactor, if any, and then restores it afterwards. c C s t �| d� d S �Nztwisted.internet.reactor)r �__init__��self� r �E/usr/lib/python3/dist-packages/twisted/internet/test/modulehelpers.pyr s zNoReactor.__init__c C s" t �| � d| jv rtj`d S d S r )r � __enter__�modules�twisted�internet�reactorr r r r r s �zNoReactor.__enter__c C sT t �| |||� | j�dd �}|d ur|tj_d S ztj`W d S ty) Y d S w r )r �__exit__r �getr r r �AttributeError)r �excType�excValue� tracebackr r r r r s �zNoReactor.__exit__N)�__name__� __module__� __qualname__�__doc__r r r r r r r r s c @ s e Zd ZdZdd� Zdd� ZdS )r zd A context manager which temporarily installs a different object as the global reactor. c C s t �| � || _dS )zN @param reactor: Any object to install as the global reactor. N)r r � alternate)r r r r r r 3 s zAlternateReactor.__init__c C s$ t �| � | jtj_| jtjd< d S r )r r r r r r �sysr r r r r r : s zAlternateReactor.__enter__N)r r r r r r r r r r r - s ) r �__all__r �twisted.internetr �twisted.test.test_twistedr r r r r r r �<module> s PK Mb�Z��� � � > internet/test/__pycache__/test_win32serialport.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl m Z ddl m Z dejv Zz ddlZdd lmZ W n eyM erG� dZdZY nw edurdG d d � d ej�ZG d d � d ej�ZG dd� de�ZG dd� de j�ZdS )z+ Tests for L{twisted.internet.serialport}. � N)�Protocol)� DoNothing)�Failure)�platform)�unittest�TWISTED_FORCE_SERIAL_TESTS)� serialportc s, e Zd Z� fdd�Zdd� Zdd� Z� ZS )�RegularFileSerialc s" t � j|i |�� || _|| _d S �N)�super�__init__� captured_args�captured_kwargs)�self�args�kwargs�� __class__� �L/usr/lib/python3/dist-packages/twisted/internet/test/test_win32serialport.pyr $ s zRegularFileSerial.__init__c C � d S r r �r r r r �_reconfigurePort) � z"RegularFileSerial._reconfigurePortc C r r r r r r r �_reconfigure_port, r z#RegularFileSerial._reconfigure_port)�__name__� __module__� __qualname__r r r � __classcell__r r r r r # s r c s( e Zd ZeZ� fdd�Zdd� Z� ZS )�RegularFileSerialPortc s@ |� d�}d|v r |d= tjj| _|| j_t� j|i |�� d S )N�cbInQue)�get�serial�win32�COMSTAT�comstatr r r )r r r r r r r r 2 s z RegularFileSerialPort.__init__c C s d| j fS )NT)r% r r r r �_clearCommError= � z%RegularFileSerialPort._clearCommError)r r r r �_serialFactoryr r& r r r r r r / s r c @ s e Zd Zdd� Zdd� ZdS )�CollectReceivedProtocolc C s g | _ d S r )� received_datar r r r r B r' z CollectReceivedProtocol.__init__c C s | j �|� d S r )r* �append)r �datar r r � dataReceivedE � z$CollectReceivedProtocol.dataReceivedN)r r r r r- r r r r r) A s r) c @ sz e Zd ZdZese�� sdZnesdZdd� Z dd� Z dd � Z d d � Z d d � Z dd� Zdd� Zdd� Zdd� Zdd� ZdS )�Win32SerialPortTestszB Minimal testing for Twisted's Win32 serial port support. z This test must run on Windows.z-Windows serial port support is not available.c C sl t � | _t� | _t�� | _tj� | jd�| _d}t | jd��}|� |� W d � d S 1 s/w Y d S )N� fake_serials 1234�wb) r �protocolr �reactor�tempfile�mkdtemp� directory�os�path�join�open�write)r r, �fr r r �setUpU s "�zWin32SerialPortTests.setUpc C s t �| j� d S r )�shutil�rmtreer6 r r r r �tearDowna r. z Win32SerialPortTests.tearDownc C s� t | j| j| j�}| �| jf|jj� |jj}| �d|d � | �tj |d � | �tj |d � | �tj |d � | �d|d � | �d|d � | �d |d � |� t td ��� d S ) zx Test correct positional and keyword arguments have been passed to the C{serial.Serial} object. i�% �baudrate�bytesize�parity�stopbitsr �xonxoff�rtsctsN�timeout�Cleanup)r r2 r8 r3 � assertEqual�_serialr r r" � EIGHTBITS� PARITY_NONE� STOPBITS_ONE�connectionLostr � Exception)r �portr r r r �test_serialPortDefaultArgsd s z/Win32SerialPortTests.test_serialPortDefaultArgsc C sf | � d| jj� t| j| j| j�}| � d|j� | � d| jj� | � || jj� |�tt d��� dS )z� Test the port is connected at initialization time, and C{Protocol.makeConnection} has been called on the desired protocol. r � rH N) rI r2 � connectedr r8 r3 � transportrN r rO )r rP r r r �!test_serialPortInitiallyConnectedw s z6Win32SerialPortTests.test_serialPortInitiallyConnectedc C sb t | j| j| j|d�}|�� |�d� |�d� |�d� |�� |�� |�tt d��� d S )N�r2 �deviceNameOrPortNumberr3 r � s abcds ABCDrH ) r r2 r8 r3 �serialReadEventr; �serialWriteEventrN r rO )r r rP r r r �common_exerciseHandleAccess� s � z0Win32SerialPortTests.common_exerciseHandleAccessc C � | j dd� d S �NF�r �r[ r r r r �test_exerciseHandleAccess_1� r. z0Win32SerialPortTests.test_exerciseHandleAccess_1c C r\ �NTr^ r_ r r r r �test_exerciseHandleAccess_2� r. z0Win32SerialPortTests.test_exerciseHandleAccess_2c C sR t � }t|| j| j|d�}|�� | �tdd� |jD ��� |�t t d��� d S )NrV c s s � | ]}t |t�V qd S r )� isinstance�bytes)�.0�dr r r � <genexpr>� s � zEWin32SerialPortTests.common_serialPortReturnsBytes.<locals>.<genexpr>rH ) r) r r8 r3 rY � assertTrue�allr* rN r rO )r r r2 rP r r r � common_serialPortReturnsBytes� s �z2Win32SerialPortTests.common_serialPortReturnsBytesc C r\ r] �rj r r r r � test_serialPortReturnsBytes_1� r. z2Win32SerialPortTests.test_serialPortReturnsBytes_1c C r\ ra rk r r r r � test_serialPortReturnsBytes_2� r. z2Win32SerialPortTests.test_serialPortReturnsBytes_2N)r r r �__doc__� testingForcedr � isWindows�skipr r= r@ rQ rU r[ r` rb rj rl rm r r r r r/ I s" r/ )rn r7 r> r4 �twisted.internet.protocolr �%twisted.internet.test.test_serialportr �twisted.python.failurer �twisted.python.runtimer � twisted.trialr �environro r" �twisted.internetr � ImportError�Serialr � SerialPortr r) �TestCaser/ r r r r �<module> s0 � PK Mb�Z���_ �_ : internet/test/__pycache__/connectionmixins.cpython-310.pycnu �[��� o �b�N � @ s� d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z ddl m Z m Z ddl mZmZ dd lmZmZmZ dd lmZ dd lmZmZ dd lmZ dd lm Z m Z m Z ddl m Z ddl!m"Z" ddl#m$Z$ dej%ej&fdd�Z'G dd� de�Z(G dd� d�Z)G dd� de�Z*dd� Z+d d � Z,G d d � d e�Z-G d d!� d!�Z.G d"d#� d#e�Z/G d$d%� d%e(�Z0G d&d'� d'�Z1G d(d)� d)�Z2G d*d+� d+�Z3G d,d-� d-�Z4dS ).z? Various helpers for tests for connection-oriented transports. � N)�collect)�Optional)�ref)� verifyObject)�Deferred� gatherResults)� IConnector� IReactorFDSet)� ClientFactory�Protocol� ServerFactory)�needsRunningReactor)�context�log)�Failure)� ILogContext�err�msg)�platform)�ClosingProtocol)�SkipTestz 127.0.0.1c C s� t �| d�d d }t � ||�}z.|�|� |t jkr6|�� }t �|t jt jB �d }||d fW |�� S |�� W |�� S |�� w )a� Ask the platform to allocate a free port on the specified interface, then release the socket and return the address which was allocated. @param interface: The local address to try to bind the port on. @type interface: C{str} @param type: The socket type which will use the resulting port. @return: A two-tuple of address and port, like that returned by L{socket.getsockname}. r � � ) �socket� getaddrinfo�bind�AF_INET6� getsockname� getnameinfo�NI_NUMERICHOST�NI_NUMERICSERV�close)� interface�family�type�addr�probe�sockname�hostname� r) �H/usr/lib/python3/dist-packages/twisted/internet/test/connectionmixins.py� findFreePort s �� �r+ c @ �$ e Zd ZdZdZdd� Zdd� ZdS )�ConnectableProtocolab A protocol to be used with L{runProtocolsWithReactor}. The protocol and its pair should eventually disconnect from each other. @ivar reactor: The reactor used in this test. @ivar disconnectReason: The L{Failure} passed to C{connectionLost}. @ivar _done: A L{Deferred} which will be fired when the connection is lost. Nc C s || _ || _dS )aN Set attributes on the protocol that are known only externally; this will be called by L{runProtocolsWithReactor} when this protocol is instantiated. @param reactor: The reactor used in this test. @param done: A L{Deferred} which will be fired when the connection is lost. N)�reactor�_done)�selfr. �doner) r) r* �_setAttributesJ s z"ConnectableProtocol._setAttributesc C s || _ | j�d � | `d S �N)�disconnectReasonr/ �callback�r0 �reasonr) r) r* �connectionLostX s z"ConnectableProtocol.connectionLost)�__name__� __module__� __qualname__�__doc__r4 r2 r8 r) r) r) r* r- : s r- c @ � e Zd ZdZdd� Zdd� ZdS )�EndpointCreatorzT Create client and server endpoints that know how to connect to each other. c C � t � �)z� Return an object providing C{IStreamServerEndpoint} for use in creating a server to use to establish the connection type to be tested. ��NotImplementedError�r0 r. r) r) r* �serverc � zEndpointCreator.serverc C r? )z� Return an object providing C{IStreamClientEndpoint} for use in creating a client to use to establish the connection type to be tested. r@ )r0 r. � serverAddressr) r) r* �clientj rD zEndpointCreator.clientN)r9 r: r; r< rC rF r) r) r) r* r> ^ s r> c @ r= )�_SingleProtocolFactoryz� Factory to be used by L{runProtocolsWithReactor}. It always returns the same protocol (i.e. is intended for only a single connection). c C � || _ d S r3 �� _protocol)r0 �protocolr) r) r* �__init__z � z _SingleProtocolFactory.__init__c C � | j S r3 rI )r0 r% r) r) r* � buildProtocol} � z$_SingleProtocolFactory.buildProtocolN�r9 r: r; r< rL rO r) r) r) r* rG r s rG c s� | � � �|��t� � |��t� � t|�}t|�� ����}|�|�}� ��fdd�}|�|� dd� }t|j|jg��|��fdd�� |� |� |��fdd�� | � �� �S )a� Connect two protocols using endpoints and a new reactor instance. A new reactor will be created and run, with the client and server protocol instances connected to each other using the given endpoint creator. The protocols should run through some set of tests, then disconnect; when both have disconnected the reactor will be stopped and the function will return. @param reactorBuilder: A L{ReactorBuilder} instance. @param serverProtocol: A L{ConnectableProtocol} that will be the server. @param clientProtocol: A L{ConnectableProtocol} that will be the client. @param endpointCreator: An instance of L{EndpointCreator}. @return: The reactor run by this test. c s �� �| �� �}|�� �S r3 )rF �getHost�connect)�p�clientEndpoint)� clientFactory�endpointCreatorr. r) r* �gotPort� s z(runProtocolsWithReactor.<locals>.gotPortc S s t �| d� d S )NzConnection setup failed.)r r )�resultr) r) r* �failed� � z'runProtocolsWithReactor.<locals>.failedc � � S r3 r) ��_)� disconnectedr) r* �<lambda>� � z)runProtocolsWithReactor.<locals>.<lambda>c s t � � j�S r3 )r �stopr] �r. r) r* r` � � ) � buildReactorr2 r rG rC �listen� addCallbackr r/ � addErrback� runReactor) �reactorBuilder�serverProtocol�clientProtocolrW � serverFactory�serverEndpoint�drX rZ r) )rV r_ rW r. r* �runProtocolsWithReactor� s rp c C s2 t �| �r | �� S d| jjv r| jS td| ����)zZ Like L{IReactorFDSet.getWriters}, but with support for IOCP reactor as well. �IOCPzCannot find writers on )r � providedBy� getWriters� __class__r9 �handles� Exceptionrc r) r) r* � _getWriters� s rw c @ r= )�_AcceptOneClientaN This factory fires a L{Deferred} with a protocol instance shortly after it is constructed (hopefully long enough afterwards so that it has been connected to a transport). @ivar reactor: The reactor used to schedule the I{shortly}. @ivar result: A L{Deferred} which will be fired with the protocol instance. c C s || _ || _d S r3 )r. rY )r0 r. rY r) r) r* rL � � z_AcceptOneClient.__init__c C s$ t �| |�}| j�d| jj|� |S )Nr )r rO r. � callLaterrY r5 )r0 r% rK r) r) r* rO � s z _AcceptOneClient.buildProtocolNrQ r) r) r) r* rx � s rx c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �_SimplePullProducerz� A pull producer which writes one byte whenever it is resumed. For use by C{test_unregisterProducerAfterDisconnect}. c C rH r3 )�consumer)r0 r| r) r) r* rL � rM z _SimplePullProducer.__init__c C s d S r3 r) �r0 r) r) r* � stopProducing� s z!_SimplePullProducer.stopProducingc C s t �d� | j�d� d S )N�Producer.resumeProducing� x)r r r| �writer} r) r) r* �resumeProducing� s z#_SimplePullProducer.resumeProducingN)r9 r: r; r< rL r~ r� r) r) r) r* r{ � s r{ c @ r, )�StopzQ A client factory which stops a reactor when a connection attempt fails. Nc C rH r3 rc rB r) r) r* rL � rM z Stop.__init__c C s& || _ td|�� � �� | j�� d S )NzStop(CF) cCFailed: )� failReasonr �getErrorMessager. rb )r0 � connectorr7 r) r) r* �clientConnectionFailed� s zStop.clientConnectionFailed)r9 r: r; r< r� rL r� r) r) r) r* r� � s r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �ClosingLaterProtocolz� ClosingLaterProtocol exchanges one byte with its peer and then disconnects itself. This is mostly a work-around for the fact that connectionMade is called before the SSL handshake has completed. c C s d | _ || _d S r3 )�lostConnectionReason�onConnectionLost)r0 r� r) r) r* rL ry z ClosingLaterProtocol.__init__c C s t d� d S )N�#ClosingLaterProtocol.connectionMade)r r} r) r) r* �connectionMade s r� c C s t d|��� | j�� d S )Nz"ClosingLaterProtocol.dataReceived �r � transport�loseConnection�r0 �bytesr) r) r* � dataReceived � z!ClosingLaterProtocol.dataReceivedc C s t d� || _| j�| � d S )N�#ClosingLaterProtocol.connectionLost)r r� r� r5 r6 r) r) r* r8 s r� N)r9 r: r; r< rL r� r� r8 r) r) r) r* r� � s r� c @ s: e Zd ZU dZdZee ed< dd� Zdd� Z dd � Z dS ) �ConnectionTestsMixinzg This mixin defines test methods which should apply to most L{ITransport} implementations. N� endpointsc C sP G dd� dt �}|d�}|d�}t| ||| j� | �d|j� | �d|j� dS )z� Client and server transports implement L{ILoggingContext.logPrefix} to return a message reflecting the protocol they are running. c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) zDConnectionTestsMixin.test_logPrefix.<locals>.CustomLogPrefixProtocolc S s || _ d | _d S r3 )�_prefix�system)r0 �prefixr) r) r* rL ry zMConnectionTestsMixin.test_logPrefix.<locals>.CustomLogPrefixProtocol.__init__c S s | j �d� d S )N� a)r� r� r} r) r) r* r� $ r[ zSConnectionTestsMixin.test_logPrefix.<locals>.CustomLogPrefixProtocol.connectionMadec S rN r3 )r� r} r) r) r* � logPrefix' rP zNConnectionTestsMixin.test_logPrefix.<locals>.CustomLogPrefixProtocol.logPrefixc S s6 t �t�d | _| j�d� d|v r| j�� d S d S )Nr� � b)r �getr r� r� r� r� r� r) r) r* r� * s �zQConnectionTestsMixin.test_logPrefix.<locals>.CustomLogPrefixProtocol.dataReceivedN)r9 r: r; rL r� r� r� r) r) r) r* �CustomLogPrefixProtocol s r� z Custom Clientz Custom ServerN)r- rp r� �assertInr� )r0 r� rF rC r) r) r* �test_logPrefix s z#ConnectionTestsMixin.test_logPrefixc s� �� � �g � t� ��fdd�}�j����t�|���� ���fdd�����fdd�}t�|� ���� �� � ddg� dS ) z} After a connection is disconnected, L{ITransport.write} and L{ITransport.writeSequence} are no-ops. c � t � �S r3 �r� r) )� serverConnectionLostDeferredr) r* r` B � z@ConnectionTestsMixin.test_writeAfterDisconnect.<locals>.<lambda>c s� t d| �� ��� �j��| �� �}t� � � fdd�}|�t�|��}dd� }|�|� j � �fdd�}� � |� �� |� t � �g�S )N� Listening on c r� r3 r� r) ��lostConnectionDeferredr) r* r` L r� zSConnectionTestsMixin.test_writeAfterDisconnect.<locals>.listening.<locals>.<lambda>c S s t d| ��� | j�d� d S )NzAbout to write to r� )r r� r� ��protor) r) r* r� O s zPConnectionTestsMixin.test_writeAfterDisconnect.<locals>.listening.<locals>.writec s8 t | �d�� | j�d� | j�ddg� � �d� d S )Nz disconnecteds some bytes to get losts somes moreT)r r� r� � writeSequence�appendr� ��finishedr) r* r_ U s zWConnectionTestsMixin.test_writeAfterDisconnect.<locals>.listening.<locals>.disconnected) r rR r� rF r rS r � forProtocol� addCallbacks�errbackrg r )�port�endpointrK rF r� r_ )r� r. r0 r� r� r* � listeningG s zAConnectionTestsMixin.test_writeAfterDisconnect.<locals>.listeningc s* �� � � ��t� �� �fdd�� d S )Nc � � � � S r3 �rb ��ignoredrc r) r* r` b r� zRConnectionTestsMixin.test_writeAfterDisconnect.<locals>.onListen.<locals>.<lambda>)rg rh r r) �r� � portDeferredr. r) r* �onListen_ � z@ConnectionTestsMixin.test_writeAfterDisconnect.<locals>.onListenTN) re r r� rC rf r r� r ri � assertEqual)r0 rK r� r) )r� r� r� r. r0 r� r* �test_writeAfterDisconnect8 s � z.ConnectionTestsMixin.test_writeAfterDisconnectc s� t � �t��� t� �}��� ��j����t�t ���� ���fdd�����fdd�}t �|� �� �� d� t � �� |� � dS )z� After the connection a protocol is being used for is closed, the reactor discards all of its references to the protocol. c s^ t d| �� ��� �j��| �� �}|�t�� fdd���}dd� }|�|� |��j � �S )Nr� c r\ r3 r) r) )rl r) r* r` { ra zaConnectionTestsMixin.test_protocolGarbageAfterLostConnection.<locals>.listening.<locals>.<lambda>c S s t d| ��� | j�� d S )NzAbout to disconnect r� r� r) r) r* � disconnect} r� zcConnectionTestsMixin.test_protocolGarbageAfterLostConnection.<locals>.listening.<locals>.disconnect) r rR r� rF rS r r� rg rh r� )r� r� rF r� )rl r� r. r0 r) r* r� w s zOConnectionTestsMixin.test_protocolGarbageAfterLostConnection.<locals>.listeningc s* �� � � ��t� ���fdd�� d S )Nc r� r3 r� r� rc r) r* r` � r� zcConnectionTestsMixin.test_protocolGarbageAfterLostConnection.<locals>.onListening.<locals>.<lambda>)rg rh r �addBothr) r� r) r* � onListening� r� zQConnectionTestsMixin.test_protocolGarbageAfterLostConnection.<locals>.onListeningN)r r� r re r� rC rf r r� r r ri r � assertIsNone)r0 � clientRefr� r) )rl r� r� r� r. r0 r* �'test_protocolGarbageAfterLostConnectioni s � z<ConnectionTestsMixin.test_protocolGarbageAfterLostConnection) r9 r: r; r< r� r r> �__annotations__r� r� r� r) r) r) r* r� s 1r� c @ s e Zd ZdZdd� ZdS )�LogObserverMixinzL Mixin for L{TestCase} subclasses which want to observe log events. c C s$ g }t �|j� | �t j|j� |S r3 )r � addObserverr� � addCleanup�removeObserver)r0 �loggedMessagesr) r) r* �observe� s zLogObserverMixin.observeN)r9 r: r; r< r� r) r) r) r* r� � s r� c @ s e Zd ZdZdZdd� ZdS )�BrokenContextFactoryzv A context factory with a broken C{getContext} method, for exercising the error handling for such a case. zSome path was wrong maybec C s t | j��r3 )� ValueError�messager} r) r) r* � getContext� rM z BrokenContextFactory.getContextN)r9 r: r; r< r� r� r) r) r) r* r� � s r� c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �StreamClientTestsMixinau This mixin defines tests applicable to SOCK_STREAM client implementations. This must be mixed in to a L{ReactorBuilder <twisted.internet.test.reactormixins.ReactorBuilder>} subclass, as it depends on several of its methods. Then the methods C{connect} and C{listen} must defined, defining a client and a server communicating with each other. c C s* | � � }| �|t� �}| �tt|�� dS )zR The C{connect} method returns an object providing L{IConnector}. N)re rS r � assertTruer r )r0 r. r� r) r) r* �test_interface� s z%StreamClientTestsMixin.test_interfacec s* �� � � t� � �fdd�� ��� � dS )zl The reactor can be stopped by a client factory's C{clientConnectionFailed} method. c s �� � t� ��S r3 )rS r� r) �r. r0 r) r* r` � s zPStreamClientTestsMixin.test_clientConnectionFailedStopsReactor.<locals>.<lambda>N)re r ri r} r) r� r* �'test_clientConnectionFailedStopsReactor� s z>StreamClientTestsMixin.test_clientConnectionFailedStopsReactorc sn �� � ����t�t�� g �G ��fdd�dt�}t��� |� _t�� ��fdd�� ��� �� �� dS )z� This test checks that we correctly get notifications event for a client. This ought to prevent a regression under Windows using the GTK2 reactor. See #3925. c s e Zd Z� �fdd�ZdS )zAStreamClientTestsMixin.test_connectEvent.<locals>.CheckConnectionc s � � | � ��� d S r3 )r� rb r} �� connectedr. r) r* r� � s zPStreamClientTestsMixin.test_connectEvent.<locals>.CheckConnection.connectionMadeN)r9 r: r; r� r) r� r) r* �CheckConnection� s r� c s �� �� �S r3 )rS r) )rV r. r0 r) r* r` � rd z:StreamClientTestsMixin.test_connectEvent.<locals>.<lambda>N) re rf r r� r r� rK r �runr� )r0 r� r) )rV r� r. r0 r* �test_connectEvent� s z(StreamClientTestsMixin.test_connectEventc s� | � � �| ��t�t�� t� � � �tj� � � �fdd�� g �G � ��fdd�dt �}t � }||_ | � �|� | ��� | ��d d� dS )a3 If a producer is unregistered from a transport after the transport has been disconnected (by the peer) and after C{loseConnection} has been called, the transport is not re-added to the reactor as a writer as would be necessary if the transport were still connected. c r� r3 r� ��ignrc r) r* r` � r� zOStreamClientTestsMixin.test_unregisterProducerAfterDisconnect.<locals>.<lambda>c s0 e Zd ZdZdd� Z� ��fdd�Zdd� ZdS ) zUStreamClientTestsMixin.test_unregisterProducerAfterDisconnect.<locals>.ClientProtocolz� Protocol to connect, register a producer, try to lose the connection, wait for the server to disconnect from us, and then unregister the producer. c S s, t �d� | j�t| j�d� | j�� d S )N� ClientProtocol.connectionMadeF)r r r� �registerProducerr{ r� r} r) r) r* r� � s �zdStreamClientTestsMixin.test_unregisterProducerAfterDisconnect.<locals>.ClientProtocol.connectionMadec s4 t �d� | �� ��| jt��v � � �d � d S �Nz ClientProtocol.connectionLost)r r � unregisterr� r� rw r5 r6 �r� r. �writingr) r* r8 s zdStreamClientTestsMixin.test_unregisterProducerAfterDisconnect.<locals>.ClientProtocol.connectionLostc S s t �d� | j�� d S )N�ClientProtocol unregister)r r r� �unregisterProducerr} r) r) r* r� � z`StreamClientTestsMixin.test_unregisterProducerAfterDisconnect.<locals>.ClientProtocol.unregisterN)r9 r: r; r< r� r8 r� r) r� r) r* �ClientProtocol� s r� r z/Transport was writing after unregisterProducer.N)re rf r r� r r rh r r rg r r rK rS ri � assertFalse)r0 r� rV r) r� r* �&test_unregisterProducerAfterDisconnect� s z=StreamClientTestsMixin.test_unregisterProducerAfterDisconnectc s� | � � �ddg}�jj}||v rt�� rtd��G dd� d�� | ��t�t �� t � ��� t j � ���fdd�� G � ��fdd �d t �}t� }||_| ��|� | ��� d S ) z� If C{loseConnection} is called while a producer is registered with the transport, the connection is closed after the producer is unregistered. � Glib2Reactor� Gtk2Reactorz=A pygobject/pygtk bug disables this functionality on Windows.c @ s e Zd Zdd� ZdS )zFStreamClientTestsMixin.test_disconnectWhileProducing.<locals>.Producerc S s t �d� d S )Nr )r r r} r) r) r* r� % s zVStreamClientTestsMixin.test_disconnectWhileProducing.<locals>.Producer.resumeProducingN)r9 r: r; r� r) r) r) r* �Producer$ s r� c r� r3 r� r� rc r) r* r` , r� zFStreamClientTestsMixin.test_disconnectWhileProducing.<locals>.<lambda>c s8 e Zd ZdZ� �fdd�Z��fdd�Z�fdd�ZdS ) zLStreamClientTestsMixin.test_disconnectWhileProducing.<locals>.ClientProtocolz� Protocol to connect, register a producer, try to lose the connection, unregister the producer, and wait for the connection to actually be lost. c s< t �d� | j�� � d� | j�� ��d�jd| j� d S )Nr� Fr )r r r� r� r� rz r� r} )r� r. r) r* r� 5 s z[StreamClientTestsMixin.test_disconnectWhileProducing.<locals>.ClientProtocol.connectionMadec s0 t �d� | j�� ��d� jttd��� d S )Nr� g �?zConnection was not lost)r r r� r� rz r� r rv r} )r� r. r) r* r� ? s �zWStreamClientTestsMixin.test_disconnectWhileProducing.<locals>.ClientProtocol.unregisterc s t �d� � �d � d S r� )r r r5 r6 r� r) r* r8 I r� z[StreamClientTestsMixin.test_disconnectWhileProducing.<locals>.ClientProtocol.connectionLostN)r9 r: r; r< r� r� r8 r) �r� r� r. r) r* r� . s r� N)re rt r9 r � isWindowsr rf r r� r r rh r r rg r rK rS ri )r0 �skippedReactors�reactorClassNamer� rV r) r� r* � test_disconnectWhileProducing s" � z4StreamClientTestsMixin.test_disconnectWhileProducingN) r9 r: r; r< r� r� r� r� r� r) r) r) r* r� � s .r� )5r< r �gcr �typingr �weakrefr �zope.interface.verifyr �twisted.internet.deferr r �twisted.internet.interfacesr r �twisted.internet.protocolr r r �#twisted.internet.test.reactormixinsr �twisted.pythonr r �twisted.python.failurer �twisted.python.logr r r �twisted.python.runtimer �twisted.test.test_tcpr �twisted.trial.unittestr �AF_INET� SOCK_STREAMr+ r- r> rG rp rw rx r{ r� r� r� r� r� r� r) r) r) r* �<module> s> $4 PK Mb�Zp"ڰ�� �� 6 internet/test/__pycache__/test_process.cpython-310.pycnu �[��� o �b|� � @ s$ d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl Z ddl Z ddl m Z ddl mZmZmZ ddlmZmZ ddlmZmZ ddlmZ dd lmZ dd lm Z dd l m Z m Z dd l m!Z!m"Z" dd l#m$Z$ ddl%m&Z& e ej'��(� Z)e e j*��+� �+� Z,dZ-dZ.e/ej0�Z1ej2�3ej4�e1d< zddl5Z6ddl m7Z8 e�9� dkr�dZ-dZ.W n e:y� dZ5dZ7dZ-dZ.Y nw e6Z5e8Z7dd� Z;G dd� de�Z<G dd� de�Z=G d d � d e=�Z>e?� �@e>�A� � G d d � d e=�ZBe?� �@eB�A� � G d d!� d!e&�ZCG d"d#� d#e&�ZDG d$d%� d%e&�ZEdS )&z� Tests for implementations of L{IReactorProcess}. @var properEnv: A copy of L{os.environ} which has L{bytes} keys/values on POSIX platforms and native L{str} keys/values on Windows. � N)�skipIf)�utils)�Deferred�inlineCallbacks�succeed)� ProcessDone�ProcessTerminated)�IProcessTransport�IReactorProcess)�ProcessProtocol)�ReactorBuilder)� networkString)�FilePath�_asFilesystemBytes)�err�msg)�platform)�TestCaseF� � PYTHONPATH��processTz$Cannot change UID/GID except as rootz Cannot change UID/GID on Windowsc C s t du rd| _| S )z� Only run this test on POSIX platforms. @param testMethod: A test function, being decorated. @return: the C{testMethod} argument. Nz%Test only applies to POSIX platforms.)�resource�skip)� testMethod� r �D/usr/lib/python3/dist-packages/twisted/internet/test/test_process.py� onlyOnPOSIX= s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � _ShutdownCallbackProcessProtocolz� An L{IProcessProtocol} which fires a Deferred when the process it is associated with ends. @ivar received: A C{dict} mapping file descriptors to lists of bytes received from the child process on those file descriptors. c C s || _ i | _d S �N)� whenFinished�received)�selfr r r r �__init__S s z)_ShutdownCallbackProcessProtocol.__init__c C s | j �|g ��|� d S r )r! � setdefault�append)r" �fd�bytesr r r �childDataReceivedW � z2_ShutdownCallbackProcessProtocol.childDataReceivedc C s | j �d � d S r )r �callback�r" �reasonr r r � processEndedZ � z-_ShutdownCallbackProcessProtocol.processEndedN)�__name__� __module__� __qualname__�__doc__r# r( r- r r r r r J s r c @ s� e Zd ZdZegZdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z e e edd�du d�dd� �Zdd� Zdd� Zedd� �Zedd� �Zdd � Zd d � Ze ee�d d � �Ze ee�d!d"� �Zd#d$� ZdS )%�ProcessTestsBuilderBasez� Base class for L{IReactorProcess} tests which defines some tests which can be applied to PTY or non-PTY uses of C{spawnProcess}. Subclasses are expected to set the C{usePTY} attribute to C{True} or C{False}. c s` t � }t|�}| �� � � j|ttddg| jd�}| �t�|�� |� � fdd�� | � � � dS )z� L{IReactorProcess.spawnProcess} connects the protocol passed to it to a transport which provides L{IProcessTransport}. � -c� ��usePTYc � � � � S r ��stop��ignored��reactorr r �<lambda>� � zHProcessTestsBuilderBase.test_processTransportInterface.<locals>.<lambda>N) r r � buildReactor� spawnProcess�pyExer7 � assertTruer � providedBy� addCallback� runReactor)r" �ended�protocol� transportr r= r � test_processTransportInterfacei s � z6ProcessTestsBuilderBase.test_processTransportInterfacec s~ | � � �t� }t|��dttj� � d�� ����fdd�}��|� |��fdd�� | ��� | � � d� �j d �� d S ) a� Helper for testing L{IProcessTransport} write functionality. This method spawns a child process and gives C{write} a chance to write some bytes to it. It then verifies that the bytes were actually written to it (by relying on the child process to echo them back). @param write: A two-argument callable. This is invoked with a process transport and some bytes to write to it. s hello, worlds2 import sys sys.stdout.write(sys.stdin.readline()) c sN �� �ttd�g�} z�| � � W d S ty& td d� | �d� Y d S w )Nr4 z!Unhandled exception while writing�KILL)rB rC � BaseExceptionr � signalProcess�rJ �� bytesToSend�programrI r> �writer r �startup� s �z3ProcessTestsBuilderBase._writeTest.<locals>.startupc r8 r r9 r; r= r r r? � r@ z4ProcessTestsBuilderBase._writeTest.<locals>.<lambda>r5 � N) rA r r r �os�linesep�callWhenRunningrF rG � assertEqual�joinr! )r" rS rH rT r rP r � _writeTest� s z"ProcessTestsBuilderBase._writeTestc C � dd� }| � |� dS )z~ L{IProcessTransport.write} writes the specified C{bytes} to the standard input of the child process. c S s | � |� d S r �rS �rJ rQ r r r rS � � z1ProcessTestsBuilderBase.test_write.<locals>.writeN�r[ �r" rS r r r � test_write� � z"ProcessTestsBuilderBase.test_writec C r\ )z� L{IProcessTransport.writeSequence} writes the specified C{list} of C{bytes} to the standard input of the child process. c S s | � |g� d S r )� writeSequencer^ r r r rS � r. z9ProcessTestsBuilderBase.test_writeSequence.<locals>.writeNr` ra r r r �test_writeSequence� rc z*ProcessTestsBuilderBase.test_writeSequencec C r\ )z� L{IProcessTransport.writeToChild} writes the specified C{bytes} to the specified file descriptor of the child process. c S s | � d|� d S )Nr )� writeToChildr^ r r r rS � r. z8ProcessTestsBuilderBase.test_writeToChild.<locals>.writeNr` ra r r r �test_writeToChild� rc z)ProcessTestsBuilderBase.test_writeToChildc s � fdd�}� � |� dS )z� L{IProcessTransport.writeToChild} raises L{KeyError} if passed a file descriptor which is was not set up by L{IReactorProcess.spawnProcess}. c s0 z� � t| jd|� W | �|� d S | �|� w )N� )� assertRaises�KeyErrorrf rS r^ �r" r r rS � s zIProcessTestsBuilderBase.test_writeToChildBadFileDescriptor.<locals>.writeNr` ra r rk r �"test_writeToChildBadFileDescriptor� s z:ProcessTestsBuilderBase.test_writeToChildBadFileDescriptor�SIGCHLDNz;Platform lacks SIGCHLD, early-spawnProcess test can't work.c s� | � � � | jr d}ni }t�� ��fdd�}t�tj|� t� }� jt|�t t ddg| j|d� �� d� �� � s>| � d� g }|� |j� |rJdS |� � fd d �� | �� � | �|� dS ) z� If, before the reactor is started with L{IReactorCore.run}, a process is started with L{IReactorProcess.spawnProcess} and terminates, the process is reaped once the reactor is started. Nc � � � � d S r )�set)�args)�signaledr r �handler� � zGProcessTestsBuilderBase.test_spawnProcessEarlyIsReaped.<locals>.handlerr4 r5 )r7 �childFDs�x z,Timed out waiting for child process to exit.c r8 r r9 r; r= r r r? r@ zHProcessTestsBuilderBase.test_spawnProcessEarlyIsReaped.<locals>.<lambda>)rA r7 � threading�Event�signalrm r rB r rC �wait�isSet�failrF r% rG rD )r" rt rr rH �resultr )r> rq r � test_spawnProcessEarlyIsReaped� s2 � z6ProcessTestsBuilderBase.test_spawnProcessEarlyIsReapedc s� d�t td� ��t� � d}G � �fdd�dt�}��� ��j�j|� ttd|g�jd� ��fdd �}� � |� � � t � � � �fd d �� �� �� d S ) z� The C{reason} argument passed to L{IProcessProtocol.processExited} is a L{ProcessTerminated} instance if the child process exits with a signal. �TERM�SIGsE import sys sys.stdout.write('x') sys.stdout.flush() sys.stdin.read() c s4 e Zd Z�fdd�Zdd� Z� fdd�Zdd� Zd S ) zDProcessTestsBuilderBase.test_processExitedWithSignal.<locals>.Exiterc s t d||f � | j�� � d S �NzchildDataReceived(%d, %r))r rJ rN �r" r& �data)�sigNamer r r( ) � zVProcessTestsBuilderBase.test_processExitedWithSignal.<locals>.Exiter.childDataReceivedc S s t d|f � d S �N�childConnectionLost(%d)�r )r" r& r r r �childConnectionLost- � zXProcessTestsBuilderBase.test_processExitedWithSignal.<locals>.Exiter.childConnectionLostc � t d|�d�� � �|g� d S �NzprocessExited(�)�r r* r+ ��exitedr r � processExited0 s zRProcessTestsBuilderBase.test_processExitedWithSignal.<locals>.Exiter.processExitedc S � t d|�d�� d S �Nz processEnded(r� r� r+ r r r r- 9 � zQProcessTestsBuilderBase.test_processExitedWithSignal.<locals>.Exiter.processEndedN�r/ r0 r1 r( r� r� r- r )r� r� r r �Exiter( s r� r4 r6 c sZ | \}|� t� |j}t�� r � �|j� � �|jd� d S � �|j�� � �|j� d S )NrU ) �trapr �valuer � isWindows� assertIsNonerx rY �exitCode)rp �failurer )r" �sigNumr r �cbExitedE s zFProcessTestsBuilderBase.test_processExitedWithSignal.<locals>.cbExitedc r8 r r9 ��ignr= r r r? Z r@ zFProcessTestsBuilderBase.test_processExitedWithSignal.<locals>.<lambda>N) �getattrrx r r rA rX rB rC r7 rF � addErrbackr rG )r" �sourcer� r� r )r� r> r" r� r� r � test_processExitedWithSignal s& � � z4ProcessTestsBuilderBase.test_processExitedWithSignalc sL | � � � g �� �fdd�}� �|� | �� � | ��dtj�d� g� dS )a� If a child process exits while a system call is in progress, the system call should not be interfered with. In particular, it should not fail with EINTR. Older versions of Twisted installed a SIGCHLD handler on POSIX without using the feature exposed by the SA_RESTART flag to sigaction(2). The most noticeable problem this caused was for blocking reads and writes to sometimes fail with EINTR. c s� zCt �t�� �} t�| ddg� tj| ddgtjd�}|j� ��|j� � � W d � n1 s1w Y W � � � d S W � � � d S � � � w )N�-cz import time; time.sleep(0.1)z)import time; time.sleep(0.5);print('Foo'))�stdout) rC �decode�sys�getfilesystemencoding� subprocess�Popen�PIPEr� r% �readr: )�exe�f2�r> r| r r �fl s � � �zJProcessTestsBuilderBase.test_systemCallUninterruptedByChildExit.<locals>.fs Foo�asciiN)rA rX rG rY rV rW �encode)r" r� r r� r �'test_systemCallUninterruptedByChildExit^ s z?ProcessTestsBuilderBase.test_systemCallUninterruptedByChildExitc s� t d�tj��}t�� \}}| �tj|� | �tj|� d}t� tj �d | }t� ||� | �tj|� t � � � G � �fdd�dt�}| �� ��j�j|� ttdd|g| jd� | ��� tt� �� ��}g d �}| �|�t||g ��t|�� d S ) z� Processes spawned with spawnProcess() close all extraneous file descriptors in the parent. They do have a stdin, stdout, and stderr open. z� import sys sys.path.insert(0, '{}') from twisted.internet import process sys.stdout.write(repr(process._listOpenFDs())) sys.stdout.flush()� r c � e Zd Z� jZ�fdd�ZdS )zKProcessTestsBuilderBase.test_openFileDescriptors.<locals>.GatheringProtocolc rn r r9 r+ r= r r r- � rs zXProcessTestsBuilderBase.test_openFileDescriptors.<locals>.GatheringProtocol.processEndedN)r/ r0 r1 rS � outReceivedr- r ��outputr> r r �GatheringProtocol� � r� s -Wignorer4 r6 �r rU � N)r �format� twistedRoot�pathrV �pipe� addCleanup�closer � getrlimit� RLIMIT_NOFILE�dup2�io�BytesIOr rA rX rB rC r7 rG ro �eval�getvaluerY � intersection) r" r� �r�w� fudgeFactor� unlikelyFDr� �reportedChildFDs�stdFDsr r� r �test_openFileDescriptors� s: �� � �z0ProcessTestsBuilderBase.test_openFileDescriptorsc sr dd� }| � td|� | � tddd� � | �� �t�� � �j� �fdd��}| j�d d � | �d � � � � � � d S ) z� When L{os.execvpe} raises an exception, it will format that exception on stderr as UTF-8, regardless of system encoding information. c _ s0 d}t |t�s |�d�}td|d�}t|� d S )Nu <☃>�utf-8z1/0�single)� isinstance�strr� �compiler� )rp �kw�filename�codeobjr r r �execvpe� s z=ProcessTestsBuilderBase.test_errorDuringExec.<locals>.execvper� r� c S s dS )Nr� r r r r r r? � � z>ProcessTestsBuilderBase.test_errorDuringExec.<locals>.<lambda>c s0 G � �fdd�dt �} ��| � ttddg� d S )Nc r� )z[ProcessTestsBuilderBase.test_errorDuringExec.<locals>.whenRunning.<locals>.TracebackCatcherc rn r r9 r+ r= r r r- � rs zhProcessTestsBuilderBase.test_errorDuringExec.<locals>.whenRunning.<locals>.TracebackCatcher.processEndedN)r/ r0 r1 rS � errReceivedr- r r� r r �TracebackCatcher� r� r� r4 r5 )r rB rC )r� r� r r � whenRunning� s zAProcessTestsBuilderBase.test_errorDuringExec.<locals>.whenRunning� ��timeoutu ☃N) �patchrV r� rA r� r� rX rG �assertInr� r� )r" r� r� r r� r �test_errorDuringExec� s z,ProcessTestsBuilderBase.test_errorDuringExecc s` �� � � G � �fdd�dt�}|� }� j� j|ttddg�jd� �j� dd� ��|j� dS ) zi If a spawned process exits, C{processExited} will be called in a timely manner. c s e Zd ZdZ� �fdd�ZdS )zIProcessTestsBuilderBase.test_timelyProcessExited.<locals>.ExitingProtocolFc s" d| _ � �� ��|jjd� d S )NTr )r� r: rY r� r� )� protoSelfr, �r> r" r r r� � s zWProcessTestsBuilderBase.test_timelyProcessExited.<locals>.ExitingProtocol.processExitedN)r/ r0 r1 r� r� r r� r r �ExitingProtocol� s r� r4 s raise SystemExit(0)r6 r� r� N) rA r rX rB rC r7 rG rD r� )r" r� rI r r� r �test_timelyProcessExited� s � z0ProcessTestsBuilderBase.test_timelyProcessExitedc s� dd|� d�g}g � G � �fdd�dt �}| �� �|� }�j�j|ttdd�|�gfi |di�� | ��� | �d � d jj � d S ) aT Launch a child process, using either the C{uid} or C{gid} argument to L{IReactorProcess.spawnProcess} to change either its UID or GID to a different value. If the child process reports this hasn't happened, raise an exception to fail the test. @param which: Either C{b"uid"} or C{b"gid"}. z import oszraise SystemExit(os.getz() != 1)c � e Zd Z� �fdd�ZdS )z@ProcessTestsBuilderBase._changeIDTest.<locals>.CaptureExitStatusc s � � |� ��� d S r )r% r: r+ �� containerr> r r r- s zMProcessTestsBuilderBase._changeIDTest.<locals>.CaptureExitStatus.processEndedN)r/ r0 r1 r- r r� r r �CaptureExitStatus � r� r� � rU r N) r rA rX rB rC rZ rG rY r� r� )r" �whichrR r� rI r r� r � _changeIDTest s �� z%ProcessTestsBuilderBase._changeIDTestc C � | � d� dS )z� If a value is passed for L{IReactorProcess.spawnProcess}'s C{uid}, the child process is run with that UID. �uidN�r� rk r r r �test_changeUID1 � z&ProcessTestsBuilderBase.test_changeUIDc C r� )z� If a value is passed for L{IReactorProcess.spawnProcess}'s C{gid}, the child process is run with that GID. �gidNr� rk r r r �test_changeGID9 r� z&ProcessTestsBuilderBase.test_changeGIDc s� | � � �G dd� dt�� G � �fdd�dt�}|� }�j|ttddg| jd�}| ��� tdurLttj � � �D ]\}}||ur@q7t� ||� | � d � q7| � d t| �� ��� dS ) zY If L{IProcessProtocol.processExited} raises an exception, it is logged. c @ s e Zd ZdS )zGProcessTestsBuilderBase.test_processExitedRaises.<locals>.TestExceptionN)r/ r0 r1 r r r r � TestExceptionI s r� c r� )zBProcessTestsBuilderBase.test_processExitedRaises.<locals>.Protocolc s �� � � d��)NzprocessedExited raisedr9 r+ �r� r> r r r� M s zPProcessTestsBuilderBase.test_processExitedRaises.<locals>.Protocol.processExitedN)r/ r0 r1 r� r r� r r �ProtocolL r� r� r4 r5 r6 NzEAfter processExited raised, transport was left in reapProcessHandlersrU )rA � Exceptionr rB rC r7 rG r �list�reapProcessHandlers�items� unregisterReapProcessHandlerr{ rY �len�flushLoggedErrors)r" r� rI rJ �pidrr r r� r �test_processExitedRaisesA s" � �z0ProcessTestsBuilderBase.test_processExitedRaises) r/ r0 r1 r2 r �requiredInterfacesrK r[ rb re rg rl r r� rx r} r� r� r r� r� r� r� � _uidgidSkip�_uidgidSkipReasonr� r� r r r r r r3 ^ s6 ! � <J# P " r3 c @ sn e Zd ZdZdZdZe�� rdZndZdd� Z dd � Z d d � Z d d � Z dd� Z dd� Zdd� Zedd� �ZdS )�ProcessTestsBuilderzp Builder defining tests relating to L{IReactorProcess} for child processes which do not have a PTY. Fs$ twisted.internet.test.process_helpers windowsr5 c s� t � � t � t � t � d��G � �fdd�dt�}d}| �� ��j�j|� ttd|gt| jd� �fdd�}� �|� �fd d �}� �|� d d � }� �|� � � t � �fd d�}� �|� | � �� dS )z� L{IProcessProtocol.childConnectionLost} is called each time a file descriptor associated with a child process is closed. r� c s$ e Zd Z� fdd�Z�fdd�ZdS )z<ProcessTestsBuilder.test_childConnectionLost.<locals>.Closerc s � � |� d S r �r* )r" rJ )� connectedr r �makeConnection� r_ zKProcessTestsBuilder.test_childConnectionLost.<locals>.Closer.makeConnectionc s � | � d � d S r r �r" �childFD��lostr r r� � r� zPProcessTestsBuilder.test_childConnectionLost.<locals>.Closer.childConnectionLostN)r/ r0 r1 r r� r )r r r r �Closer� s r s, twisted.internet.test.process_loseconnection� -m��envr7 c � � � d� �d �� fdd��S )Ns 2 r� c � � S r r r� rO r r r? � r� zSProcessTestsBuilder.test_childConnectionLost.<locals>.cbConnected.<locals>.<lambda>�rS rF rO r rO r � cbConnected� � zAProcessTestsBuilder.test_childConnectionLost.<locals>.cbConnectedc r )Ns 1 rU c r r r r� rO r r r? � r� zRProcessTestsBuilder.test_childConnectionLost.<locals>.lostSecond.<locals>.<lambda>r rO r rO r � lostSecond� r z@ProcessTestsBuilder.test_childConnectionLost.<locals>.lostSecondc S s | � d� d S )N� r] rO r r r � lostFirst� r_ z?ProcessTestsBuilder.test_childConnectionLost.<locals>.lostFirstc rn r r9 r; r= r r �cbEnded� rs z=ProcessTestsBuilder.test_childConnectionLost.<locals>.cbEndedN) r r rA rX rB rC � properEnvr7 rF r� r rG )r" r �targetr r r r r )r r r> r �test_childConnectionLostx s. � z,ProcessTestsBuilder.test_childConnectionLostc s� t � � g �G � �fdd�dt�}��� ��j�j|� ttd�jd�jgt�j d� ��fdd�}� � |� � � t � � � �fdd �� �� �� d S ) z� L{IProcessProtocol.processEnded} is called after the child process exits and L{IProcessProtocol.childConnectionLost} is called for each of its file descriptors. c s4 e Zd Zdd� Z�fdd�Zdd� Z� fdd�Zd S ) z4ProcessTestsBuilder.test_processEnded.<locals>.Enderc S s t d||f � | j�� d S r� )r rJ �loseConnectionr� r r r r( � s zFProcessTestsBuilder.test_processEnded.<locals>.Ender.childDataReceivedc s t d|f � � �|� d S r� )r r% r r r r r� � s zHProcessTestsBuilder.test_processEnded.<locals>.Ender.childConnectionLostc S r� r� r� r+ r r r r� � r� zBProcessTestsBuilder.test_processEnded.<locals>.Ender.processExitedc r� r� r� r+ )rH r r r- � r� zAProcessTestsBuilder.test_processEnded.<locals>.Ender.processEndedNr� r )rH r r r �Ender� s r r � childr c s( | \}|� t� ��t� �h d�� d S �N> r rU r� )r� r rY ro �rp r� �r r" r r r � s z6ProcessTestsBuilder.test_processEnded.<locals>.cbEndedc r8 r r9 r� r= r r r? � r@ z7ProcessTestsBuilder.test_processEnded.<locals>.<lambda>N�r r rA rX rB rC �keepStdioOpenProgram�keepStdioOpenArgr r7 rF r� r rG )r" r r r )rH r r> r" r �test_processEnded� s" � z%ProcessTestsBuilder.test_processEndedc s� t � �t � � g �G � ��fdd�dt�}��� ��j�j|� ttdd�jd�jgt�j d� � ��fdd�}�� |� ��fd d �}�� |� �� t � �� �fd d �� �� �� d S )z� L{IProcessProtocol.processExited} is called when the child process exits, even if file descriptors associated with the child are still open. c s. e Zd Zdd� Z� �fdd�Z�fdd�ZdS )z6ProcessTestsBuilder.test_processExited.<locals>.Waiterc S s t d||f � d S r� r� r� r r r r( � r� zHProcessTestsBuilder.test_processExited.<locals>.Waiter.childDataReceivedc s6 t d|f � ��|� t��dkr� �d � d S d S )Nr� � )r r% r r* r )�allLostr r r r� � s �zJProcessTestsBuilder.test_processExited.<locals>.Waiter.childConnectionLostc s* t d|�d�� � �|g� | j�� d S r� )r r* rJ r r+ r� r r r� � s zDProcessTestsBuilder.test_processExited.<locals>.Waiter.processExitedN)r/ r0 r1 r( r� r� r )r* r� r r r �Waiter� s r+ s -ur r! r c s. | \}|� t� td�� �� ���g � � S )NzcbExited; lost = )r� r r rY r# )r* r r" r r r� s z8ProcessTestsBuilder.test_processExited.<locals>.cbExitedc s �� t� �h d�� d S r" )rY ro r; r$ r r � cbAllLost r) z9ProcessTestsBuilder.test_processExited.<locals>.cbAllLostc r8 r r9 r� r= r r r? r@ z8ProcessTestsBuilder.test_processExited.<locals>.<lambda>Nr% )r" r+ r� r, r )r* r� r r> r" r �test_processExited� s4 �� z&ProcessTestsBuilder.test_processExitedc C sZ t | �� �}t|d��}|�tj�|�tj � W d � n1 s"w Y tj�|�S )zj Write the given list of lines to a text file and return the absolute path to it. �wtN) r �mktemp�openrS rV rW rZ r� �abspath)r" � sourceLines�script� scriptFiler r r �makeSourceFile s � z"ProcessTestsBuilder.makeSourceFilec s� d��� d�t�d��dd���d��dg��t��d� ��� ���fdd �� �fd d ��� ���fd d �}��|� ���� dS )z� Spawning a process with an executable which is a script starting with an interpreter definition line (#!) uses that interpreter to evaluate the script. s this is the shebang outputz#!{}r� z import syszsys.stdout.write('{}')zsys.stdout.flush()i� c sD | \}}}t d|||f � � �|�� � �|d� � �|d� d S )Nz cbProcessExited((%r, %r, %d))r5 r )r rY )rp �outr �code)r" � shebangOutputr r �cbProcessExited; s z9ProcessTestsBuilder.test_shebang.<locals>.cbProcessExitedc � � � � | S r r9 )� passthroughr= r r �shutdownB � z2ProcessTestsBuilder.test_shebang.<locals>.shutdownc s0 t j��d�} | ��� | �� � | �t� d S )Nr= )r �getProcessOutputAndValue�addBothrF r� r ��d)r9 r> r4 r< r r �startF s z/ProcessTestsBuilder.test_shebang.<locals>.startN) r5 r� rC r� rV �chmodrA rX rG )r" rB r )r9 r> r4 r" r8 r< r � test_shebang' s �� z ProcessTestsBuilder.test_shebangc s. � fdd�}� � � }|�||� � �|� dS )z< Pause producing and then resume producing. c sJ z t � }| j|ttddg� jd�}|�� |�� W | �� d S | �� w )Nr4 r5 r6 )r rB rC r7 �pauseProducing�resumeProducingr: )r> rI rJ rk r r �pauseAndResumeT s � zHProcessTestsBuilder.test_pauseAndResumeProducing.<locals>.pauseAndResumeN)rA rX rG )r" rG r> r rk r � test_pauseAndResumeProducingO s z0ProcessTestsBuilder.test_pauseAndResumeProducingc s� d�g d�� d� tttdd���}t|t�r|�d� ��� �� �fdd���fd d ��� ����fd d �}��|� �� �� d S )zq Arguments given to spawnProcess are passed to the child process as originally intended. s! twisted.internet.test.process_cli)s hello� "s |<>^&s "\\"hello\\"s "foo\ bar baz\""r rU � r� c s, | \}}}|� d�}|�� ��� |� d S )N� )�split�poprY )� finishedArgsr� r r7 )rp r" r r �processFinishedr s zMProcessTestsBuilder.test_processCommandLineArguments.<locals>.processFinishedc r: r r9 )r| r= r r r< y r= zFProcessTestsBuilder.test_processCommandLineArguments.<locals>.shutdownc s6 t d �} | �� ��fdd�� | ��� | ��� d S )Nc s t jtd�g� t�d�S )Nr )r r> )r r> rC r )�dummy)rp r> �usr r r? � s �zZProcessTestsBuilder.test_processCommandLineArguments.<locals>.spawnChild.<locals>.<lambda>)r rF r? r@ )rp rO r> r< rQ r r � spawnChild} s � zHProcessTestsBuilder.test_processCommandLineArguments.<locals>.spawnChildN) rZ �map�chr�ranger� r� r� rA rX rG )r" �allCharsrR r )rp rO r> r" r< rQ r � test_processCommandLineArgumentsc s z4ProcessTestsBuilder.test_processCommandLineArgumentsc s` g �G �fdd�dt �� t� �fdd��}| �� }|�||� | �|� t��t�dg�� dS )z� Process is removed from reapProcessHandler dict before running ProcessProtocol.processEnded() callback. c s$ e Zd ZdZdd� Z� fdd�ZdS )ziProcessTestsBuilder.test_process_unregistered_before_protocol_ended_callback.<locals>.TestProcessProtocola7 Process protocol captures own presence in process.reapProcessHandlers at time of .processEnded() callback. @ivar deferred: A deferred fired when the .processEnded() callback has completed. @type deferred: L{Deferred<defer.Deferred>} c S s t � | _d S r )r �deferredrk r r r r# � rs zrProcessTestsBuilder.test_process_unregistered_before_protocol_ended_callback.<locals>.TestProcessProtocol.__init__c sJ ddl m} |j}|�� }| j|v r� �d� n� �d� | j�d� dS )z� Capture whether the process has already been removed from process.reapProcessHandlers. @param status: unused r r z!process present but should not be�"process already removed as desiredN)�twisted.internetr r� �valuesrJ r% rX r* )r" �statusr �handlers� processes��resultsr r r- � s zvProcessTestsBuilder.test_process_unregistered_before_protocol_ended_callback.<locals>.TestProcessProtocol.processEndedN)r/ r0 r1 r2 r# r- r r_ r r �TestProcessProtocol� s ra c 3 s~ � z8z� � }| � |ttdg� |jV W n ty+ } z ��|� W Y d}~n d}~ww W | �� dS W | �� dS | �� w )a Launch and wait for a subprocess and allow the TestProcessProtocol to capture the order of the .processEnded() callback vs. removal from process.reapProcessHandlers. @param reactor: Reactor used to spawn the test process and to be stopped when checks are complete. @type reactor: object providing L{twisted.internet.interfaces.IReactorProcess} and L{twisted.internet.interfaces.IReactorCore}. z --versionN)rB rC rX r� r% r: )r> �testProcessProtocol�e�ra r` r r �launchProcessAndWait� s" � � ��� �zjProcessTestsBuilder.test_process_unregistered_before_protocol_ended_callback.<locals>.launchProcessAndWaitrY N)r r rA rX rG �hamcrest� assert_that�equal_to)r" re r> r rd r �8test_process_unregistered_before_protocol_ended_callback� s �zLProcessTestsBuilder.test_process_unregistered_before_protocol_ended_callbackN)r/ r0 r1 r2 r7 r& r r� r' r r( r- r5 rD rH rW r ri r r r r r g s 52> ('r c @ s< e Zd ZdZdZe�� rdZdS e�� r dZddiZ dS dS )�PTYProcessTestsBuilderzi Builder defining tests relating to L{IReactorProcess} for child processes which have a PTY. Tz"PTYs are not supported on Windows.z,PTYs are flaky from a Darwin bug. See #8840.z(twisted.internet.pollreactor.PollReactorz$macOS's poll() does not support PTYsN) r/ r0 r1 r2 r7 r r� r �isMacOSX�skippedReactorsr r r r rj � s ��rj c @ s e Zd ZdZdd� ZdS )�PotentialZombieWarningTestszE Tests for L{twisted.internet.error.PotentialZombieWarning}. c C s\ ddl m} |j | �| jg�}| �|d d t� | �|d d d� | �t|�d� dS )z� Accessing L{PotentialZombieWarning} via the I{PotentialZombieWarning} attribute of L{twisted.internet.error} results in a deprecation warning being emitted. r )�error�category�messagez�twisted.internet.error.PotentialZombieWarning was deprecated in Twisted 10.0.0: There is no longer any potential for zombie process.rU N)rZ rn �PotentialZombieWarning� flushWarnings�test_deprecatedrY �DeprecationWarningr )r" rn �warningsr r r rs � s �z+PotentialZombieWarningTests.test_deprecatedN)r/ r0 r1 r2 rs r r r r rm � s rm c @ s( e Zd ZdZee�� d�dd� �ZdS )�/ProcessIsUnimportableOnUnsupportedPlatormsTestsz� Tests to ensure that L{twisted.internet.process} is unimportable on platforms where it does not work (namely Windows). zOnly relevant on Windows.c C s@ | � t�� ddl}|jj W d � dS 1 sw Y dS )zI L{twisted.internet.process} is unimportable on Windows. r N)ri � ImportError�twisted.internet.process�internetr )r" �twistedr r r �test_unimportableOnWindows s "�zJProcessIsUnimportableOnUnsupportedPlatormsTests.test_unimportableOnWindowsN)r/ r0 r1 r2 r r r� r{ r r r r rv s rv c @ sj e Zd Zze�dd� W n ey& Z zee�Ze e�Z W Y dZ[ndZ[ww e dd� �Z e dd� �Z dS )�ReapingNonePidsLogsProperlyNc C sF t �d d � | �� \}| �t|j�| jd� | �t|j�| jd� d S �NzWrong error type loggedzWrong error message logged) r �registerReapProcessHandlerr rY �typer� � expected_typer� �expected_message)r" rn r r r � test_registerReapProcessHandler" s ��z;ReapingNonePidsLogsProperly.test_registerReapProcessHandlerc C sL t �d �}|�� | �� \}| �t|j�| jd� | �t|j�| j d� d S r} ) r � _BaseProcess� reapProcessr rY r r� r� r� r� )r" � _baseProcessrn r r r � test__BaseProcess_reapProcess2 s ��z9ReapingNonePidsLogsProperly.test__BaseProcess_reapProcess)r/ r0 r1 rV �waitpidr� rc r� r� r r� r r� r� r r r r r| s �� r| )Fr2 r� rV rx r� r� rv �unittestr rf rz rZ r �twisted.internet.deferr r r �twisted.internet.errorr r �twisted.internet.interfacesr r �twisted.internet.protocolr �#twisted.internet.test.reactormixinsr �twisted.python.compatr �twisted.python.filepathr r �twisted.python.logr r �twisted.python.runtimer �twisted.trial.unittestr � executable� _asBytesPathrC �__file__�parentr� r r �dict�environr �pathseprZ r� r � _resourcer �_process�getuidrw r r r3 r �globals�update�makeTestCaseClassesrj rm rv r| r r r r �<module> st � � qPK Mb�Z$V��kK kK 6 internet/test/__pycache__/test_inotify.cpython-310.pycnu �[��� o �b�H � @ sx d Z ddlZddlmZmZ ddlmZmZ ddlm Z ddl m Z e d�dur/ddlm Z ndZ G d d � d e j �ZdS ) z? Tests for the inotify wrapper in L{twisted.internet.inotify}. � N)�defer�reactor)�filepath�runtime)� requireModule)�unittestztwisted.python._inotify)�inotifyc @ s e Zd ZdZej�� s dZdd� Zdd� Z d<dd �Z d d � Z d d � Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Z d.d/� Z d0d1� Z d2d3� Z d4d5� Z d6d7� Z!d8d9� Z"d:d;� Z#dS )=� INotifyTestsz] Define all the tests for the basic functionality exposed by L{inotify.INotify}. z&This platform doesn't support INotify.c C s@ t �| �� �| _| j�� t�� | _| j�� | �| jj � d S �N) r �FilePath�mktemp�dirname�createDirectoryr �INotify� startReading� addCleanup�loseConnection��self� r �D/usr/lib/python3/dist-packages/twisted/internet/test/test_inotify.py�setUp s zINotifyTests.setUpc C s4 G dd� d�}| � tjd|� � | �tjtj� dS )a L{inotify.INotify} emits a C{RuntimeError} when initialized in an environment that doesn't support inotify as we expect it. We just try to raise an exception for every possible case in the for loop in L{inotify.INotify._inotify__init__}. c @ s e Zd Zdd� ZdS )z;INotifyTests.test_initializationErrors.<locals>.FakeINotifyc S s t �� �r )r � INotifyErrorr r r r �init. s z@INotifyTests.test_initializationErrors.<locals>.FakeINotify.initN)�__name__� __module__� __qualname__r r r r r � FakeINotify- s r �_inotifyN)�patchr r � assertRaisesr )r r r r r �test_initializationErrors$ s z&INotifyTests.test_initializationErrorsNc s` � du r �j �d�� t�� �� ��fdd�}��|� �jj�j ��fdd�gd� |� � �S )a� Test notification from some filesystem operation. @param mask: The event mask to use when setting up the watch. @param operation: A function which will be called with the name of a file in the watched directory and which should trigger the event. @param expectedPath: Optionally, the name of the path which is expected to come back in the notification event; this will also be passed to C{operation} (primarily useful when the operation is being done to the directory itself, not a file in it). @return: A L{Deferred} which fires successfully when the expected event has been received or fails otherwise. Nzfoo.barc s0 | \}}}�� |�� � �� � ��|�@ � d S r )� assertEqual� asBytesMode� assertTrue��result�watch�filename�events)� expectedPath�maskr r r � cbNotifiedK s z2INotifyTests._notificationTest.<locals>.cbNotifiedc � � � | �S r ��callback��args��notifiedr r �<lambda>S � z0INotifyTests._notificationTest.<locals>.<lambda>�r+ � callbacks)r �childr �Deferred� addCallbackr r' )r r+ � operationr* r, r )r* r+ r3 r r �_notificationTest4 s �z INotifyTests._notificationTestc C � dd� }| � tj|�S )z{ Reading from a file in a monitored directory sends an C{inotify.IN_ACCESS} event to the callback. c S s | � d� | �� d S )N� foo)� setContent� getContent��pathr r r r; ^ s z+INotifyTests.test_access.<locals>.operation)r< r � IN_ACCESS�r r; r r r � test_accessX � zINotifyTests.test_accessc C r= )zy Writing to a file in a monitored directory sends an C{inotify.IN_MODIFY} event to the callback. c S s: | � d��}|�d� W d � d S 1 sw Y d S )N�wr> )�open�write)rB �fObjr r r r; j s "�z+INotifyTests.test_modify.<locals>.operation)r< r � IN_MODIFYrD r r r � test_modifyd rF zINotifyTests.test_modifyc C r= )z� Changing the metadata of a file in a monitored directory sends an C{inotify.IN_ATTRIB} event to the callback. c S s | � � | � � d S r )�touchrA r r r r; v � z+INotifyTests.test_attrib.<locals>.operation)r< r � IN_ATTRIBrD r r r � test_attribp rF zINotifyTests.test_attribc C r= )z� Closing a file which was open for writing in a monitored directory sends an C{inotify.IN_CLOSE_WRITE} event to the callback. c S � | � d��� d S �NrG �rH �closerA r r r r; � � z/INotifyTests.test_closeWrite.<locals>.operation)r< r �IN_CLOSE_WRITErD r r r �test_closeWrite| s z INotifyTests.test_closeWritec C r= )z� Closing a file which was open for reading but not writing in a monitored directory sends an C{inotify.IN_CLOSE_NOWRITE} event to the callback. c S s | � � | �d��� d S )N�r)rM rH rT rA r r r r; � s z1INotifyTests.test_closeNoWrite.<locals>.operation)r< r �IN_CLOSE_NOWRITErD r r r �test_closeNoWrite� s z INotifyTests.test_closeNoWritec C r= )zt Opening a file in a monitored directory sends an C{inotify.IN_OPEN} event to the callback. c S rQ rR rS rA r r r r; � rU z)INotifyTests.test_open.<locals>.operation)r< r �IN_OPENrD r r r � test_open� � zINotifyTests.test_openc � � fdd�}� � tj|�S )z} Moving a file out of a monitored directory sends an C{inotify.IN_MOVED_FROM} event to the callback. c s& | � d��� | �t�� �� �� d S rR )rH rT �moveTor r r rA r r r r; � s z.INotifyTests.test_movedFrom.<locals>.operation)r< r � IN_MOVED_FROMrD r r r �test_movedFrom� s zINotifyTests.test_movedFromc r^ )zy Moving a file into a monitored directory sends an C{inotify.IN_MOVED_TO} event to the callback. c s$ t �� �� �}|�� |�| � d S r )r r r rM r_ )rB �pr r r r; � s z,INotifyTests.test_movedTo.<locals>.operation)r< r � IN_MOVED_TOrD r r r � test_movedTo� s zINotifyTests.test_movedToc C r= )zw Creating a file in a monitored directory sends an C{inotify.IN_CREATE} event to the callback. c S rQ rR rS rA r r r r; � rU z+INotifyTests.test_create.<locals>.operation)r< r � IN_CREATErD r r r � test_create� r] zINotifyTests.test_createc C r= )zw Deleting a file in a monitored directory sends an C{inotify.IN_DELETE} event to the callback. c S s | � � | �� d S r )rM �removerA r r r r; � rN z+INotifyTests.test_delete.<locals>.operation)r< r � IN_DELETErD r r r � test_delete� rF zINotifyTests.test_deletec C s dd� }| j tj|| jd�S )z{ Deleting the monitored directory itself sends an C{inotify.IN_DELETE_SELF} event to the callback. c S s | � � d S r )rg rA r r r r; � s z/INotifyTests.test_deleteSelf.<locals>.operation�r* )r< r �IN_DELETE_SELFr rD r r r �test_deleteSelf� s �z INotifyTests.test_deleteSelfc sJ �fdd�}�j j�jd� fdd�gd� t�� � � �|� �j�� � S )z� Deleting the monitored directory itself sends an C{inotify.IN_DELETE_SELF} event to the callback even if the mask isn't specified by the call to watch(). c s4 | \}}}� � |�� � j�� � � �|tj@ � d S r )r" r# r r$ r rk r% r r r r, � s z6INotifyTests.test_deleteSelfForced.<locals>.cbNotifiedr c r- r r. r0 )�dr r r4 � r5 z4INotifyTests.test_deleteSelfForced.<locals>.<lambda>r6 )r r' r r r9 r: rg �r r, r �rm r r �test_deleteSelfForced� s � z"INotifyTests.test_deleteSelfForcedc s � fdd�}� j tj|� jd�S )zy Renaming the monitored directory itself sends an C{inotify.IN_MOVE_SELF} event to the callback. c s | � t�� �� �� d S r )r_ r r r rA r r r r; � s z-INotifyTests.test_moveSelf.<locals>.operationrj )r< r � IN_MOVE_SELFr rD r r r � test_moveSelf� s �zINotifyTests.test_moveSelfc �T � ��fdd�}t jt jB }�j j�j|d|gd� �j�d��t�� � ��� � S )z� L{inotify.INotify} when initialized with autoAdd==True adds also adds the created subdirectories to the watchlist. c � � ��fdd�}t �d|� d S )Nc �@ z�� �j���� � �d � W d S ty � �� Y d S w r )r$ r � _isWatchedr/ � Exception�errbackr �rm r �subdirr r �_ � �zIINotifyTests.test_simpleSubdirectoryAutoAdd.<locals>._callback.<locals>._r �r � callLater)�wpr( r+ r{ ry r r � _callback � z>INotifyTests.test_simpleSubdirectoryAutoAdd.<locals>._callbackT�r+ �autoAddr7 �test� r �IN_ISDIRre r' r r8 r r9 r �r r� � checkMaskr ry r � test_simpleSubdirectoryAutoAdd � � z+INotifyTests.test_simpleSubdirectoryAutoAddc sZ g � � ���fdd�}t jt jB }�j j�j|d|gd� �j�d��t�� ���� �S )zz L{inotify.INotify} removes a directory from the watchlist when it's removed from the filesystem. c sN ���fdd�}���fdd�}� s � � |� t�d|� d S t�d|� d S )Nc s> z�� �j���� ��� W d S ty � �� Y d S w r )r$ r rv rg rw rx r ry r r r{ % s �zEINotifyTests.test_simpleDeleteDirectory.<locals>._callback.<locals>._c ru r �� assertFalser rv r/ rw rx r ry r r �_eb, s �zGINotifyTests.test_simpleDeleteDirectory.<locals>._callback.<locals>._ebr )�appendr r~ )r r( r+ r{ r� ��callsrm r rz r r r� " s z:INotifyTests.test_simpleDeleteDirectory.<locals>._callbackTr� r� r� r� r r� r �test_simpleDeleteDirectory s � z'INotifyTests.test_simpleDeleteDirectoryc s\ � �fdd�}�� �jj�jtj�fdd�gd�� t�� ���|� �j�� t�� � � S )z� L{inotify.INotify} closes the file descriptor after removing a directory from the filesystem (and therefore from the watchlist). c sN � �fdd�}| \}}}�� |�� �j�� � ��|tj@ � t�d|� d S )Nc sP z�� �j��j�� �� �jj� � �d � W d S ty' � �� Y d S w r )r� r rv r � connectedr/ rw rx r ro r r r{ L s �zIINotifyTests.test_deleteSelfLoseConnection.<locals>.cbNotified.<locals>._r )r" r# r r$ r rk r r~ )r& r{ �ignoredr( r) ro r r r, K s z>INotifyTests.test_deleteSelfLoseConnection.<locals>.cbNotifiedc r- r r. r0 r2 r r r4 ] r5 z<INotifyTests.test_deleteSelfLoseConnection.<locals>.<lambda>r6 ) r$ r r' r rk r r9 r: rg rn r )rm r3 r r � test_deleteSelfLoseConnectionE s �� z*INotifyTests.test_deleteSelfLoseConnectionc C sL | j j| jdd� | �| j �| j�� | j �| j� | �| j �| j�� dS )zR L{inotify.INotify.ignore} removes a directory from the watchlist T)r� N)r r' r r$ rv �ignorer� r r r r �test_ignoreDirectoryh s z!INotifyTests.test_ignoreDirectoryc C sV t jD ]\}}| �t �|�d |� qt jt jB t jB }| �tt �|��h d�� dS )zy L{inotify.humaReadableMask} translates all the possible event masks to a human readable string. r > rH �access� close_writeN)r �_FLAG_TO_HUMANr" �humanReadableMaskrV rC r[ �set)r r+ �valuer� r r r �test_humanReadableMaskq s �z#INotifyTests.test_humanReadableMaskc C sv | j �d�}|�d�}|�d�}|�� |||g}| jj| j dd� | jj| j dd� |D ] }| �| j�|�� q-dS )z� L{inotify.INotify.watch} with recursive==True will add all the subdirectories under the given path to the watchlist. r� �test2�test3T)� recursiveN)r r8 �makedirsr r' r$ rv )r rz �subdir2�subdir3�dirsrm r r r �test_recursiveWatch s �z INotifyTests.test_recursiveWatchc C s0 ddl }t�� }|�|j� |�� | �� dS )z� L{inotify.INotify.connectionLost} if there's a problem while closing the fd shouldn't raise the exception but should log the error r N)�osr r rT �_fdr �flushLoggedErrors)r r� �in_r r r �test_connectionLostError� s z%INotifyTests.test_connectionLostErrorc rs )z� L{inotify.INotify.watch} with autoAdd==False will stop inotify from watching subdirectories created under the watched one. c rt )Nc ru r r� r ry r r r{ � r| zEINotifyTests.test_noAutoAddSubdirectory.<locals>._callback.<locals>._r r} )r �fpr+ r{ ry r r r� � r� z:INotifyTests.test_noAutoAddSubdirectory.<locals>._callbackFr� r� r� r� r ry r �test_noAutoAddSubdirectory� r� z'INotifyTests.test_noAutoAddSubdirectoryc s� �j �d�� � �� t�� �� �fdd�}�fdd�}���jj� |gd�� �j�� � ���jj� tj |gd�� �� |� � � � �S )z� L{inotify.INotify} will watch a filepath for events even if the same path is repeatedly added/removed/re-added to the watchpoints. �foo.bar2c �2 | \}}}�� |�� � �� � ��|tj@ � d S r �r" r# r$ r rk �r& r� r( r) )r* r r r r, � � z<INotifyTests.test_seriesOfWatchAndIgnore.<locals>.cbNotifiedc � � � | � d S r r. r0 r2 r r �callIt� � z8INotifyTests.test_seriesOfWatchAndIgnore.<locals>.callIt�r7 r6 ) r r8 rM r r9 r$ r r' r� rk r: rg )r r, r� r )r* r3 r r �test_seriesOfWatchAndIgnore� s �� z(INotifyTests.test_seriesOfWatchAndIgnorec s� �j �d�}|�� �j �d�� � �� t�� �� �fdd�}�fdd�}���jj|tj|gd�� �� |� ���jj� tj|gd�� �j� |� |� � � � � �S )zr L{inotify.INotify} will ignore a filepath after it has been removed from the watch list. r� zfoo.bar3c r� r r� r� )� expectedPath2r r r r, � r� z4INotifyTests.test_ignoreFilePath.<locals>.cbNotifiedc r� r r. r0 r2 r r r� � r� z0INotifyTests.test_ignoreFilePath.<locals>.callItr� ) r r8 rM r r9 r$ r r' rk r: r� rg )r r* r, r� r )r� r3 r r �test_ignoreFilePath� s( � �� z INotifyTests.test_ignoreFilePathc C s* | j �d�}|�� | �t| jj|� dS )zf L{inotify.INotify} will raise KeyError if a non-watched filepath is ignored. z foo.ignoredN)r r8 rM r �KeyErrorr r� )r r* r r r �test_ignoreNonWatchedFile s z&INotifyTests.test_ignoreNonWatchedFilec s� t � � � ������fdd�}tjtjB }�jj�j|d|gd� �j�d����d����d��t�� ��� � ��d���d ���d �g�t ��D ]\}}|� |j � t�� �� qK�S ) aB L{inotify.INotify} with autoAdd==True for a watched path generates events for every file or directory already present in a newly created subdirectory under the watched one. This tests that we solve a race condition in inotify even though we may generate duplicate events. c s� � � |� t� �dkr\z;���j���� ���j���� ���j���� ����g }dd� |D �}��t� �t|�� ��� |� W n tyT ��� Y d S w ��d � d S d S )N� c S s h | ]}|� � �qS r )r# )�.0�fr r r � <setcomp> s zRINotifyTests.test_complexSubdirectoryAutoAdd.<locals>._callback.<locals>.<setcomp>) �add�lenr$ r rv r" rw rx r/ )r r( r+ �created�r� rm r � someFilesrz r� r� r r r� s ��z?INotifyTests.test_complexSubdirectoryAutoAdd.<locals>._callbackTr� r� r� r� z file1.datz file2.datz file3.dat)r� r r� re r' r r8 r r9 r� � enumerater? rB �encode�sys�getfilesystemencoding)r r� r� �ir( r r� r � test_complexSubdirectoryAutoAdd s$ � �z,INotifyTests.test_complexSubdirectoryAutoAddr )$r r r �__doc__r �platform�supportsINotify�skipr r! r< rE rL rP rW rZ r\ ra rd rf ri rl rp rr r� r� r� r� r� r� r� r� r� r� r� r� r r r r r s@ $ *# %& r )r� r� �twisted.internetr r �twisted.pythonr r �twisted.python.reflectr � twisted.trialr r �TestCaser r r r r �<module> s PK Mb�Z��(�. . 7 internet/test/__pycache__/test_abstract.cpython-310.pycnu �[��� o �b� � @ s0 d Z ddlmZ ddlmZ G dd� de�ZdS )zY Tests for L{twisted.internet.abstract}, a collection of APIs for implementing reactors. � )� isIPv6Address)�SynchronousTestCasec @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�IPv6AddressTestszw Tests for L{isIPv6Address}, a function for determining if a particular string is an IPv6 address literal. c C � | � td�� dS )zB The empty string is not an IPv6 address literal. � N�� assertFalser ��self� r �E/usr/lib/python3/dist-packages/twisted/internet/test/test_abstract.py� test_empty � zIPv6AddressTests.test_emptyc C r )zA A single C{":"} is not an IPv6 address literal. �:Nr r r r r � test_colon r zIPv6AddressTests.test_colonc C r )z@ C{"::1"} is the IPv6 loopback address literal. z::1N�� assertTruer r r r r � test_loopback r z IPv6AddressTests.test_loopbackc C �. | � td�� | � td�� | � td�� dS )z� An otherwise valid IPv6 address literal may also include a C{"%"} followed by an arbitrary scope identifier. z fe80::1%eth0� fe80::2%1z fe80::3%en2Nr r r r r � test_scopeID& � z IPv6AddressTests.test_scopeIDc C r )zv An otherwise invalid IPv6 address literal is still invalid with a trailing scope identifier. z%eth0z:%eth0� hello%eth0Nr r r r r �test_invalidWithScopeID/ r z(IPv6AddressTests.test_invalidWithScopeIDc C sJ | � td�� | � td�� | �td�� | �td�� | �td�� dS )zQ L{isIPv6Address} evaluates ASCII-encoded bytes as well as text. s fe80::2%1r u 䌡r s hello%eth0N)r r r r r r r �test_unicodeAndBytes8 s z%IPv6AddressTests.test_unicodeAndBytesN) �__name__� __module__� __qualname__�__doc__r r r r r r r r r r r s r N)r �twisted.internet.abstractr �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z��#��$ �$ 6 internet/test/__pycache__/test_address.cpython-310.pycnu �[��� o �bJ � @ s, d dl Z d dlZd dlmZ d dlmZmZmZmZ d dl m Z d dl m Z d dl mZmZ e �� Zzej W n eyC dZY nw dZG d d � d �ZG d d � d e�ZG d d� dee�ZG dd� dee�ZG dd� dee�ZG dd� dee�Zeed�G dd� de��Zeed�G dd� dee��Z dS )� N)�skipIf)�HostnameAddress� IPv4Address� IPv6Address� UNIXAddress)� nativeString)�platform)�SynchronousTestCase�TestCaseTFc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �AddressTestCaseMixinc C s0 | � | �� | �� k� | �| �� | �� k� dS )a Two different address instances, sharing the same properties are considered equal by C{==} and not considered not equal by C{!=}. Note: When applied via UNIXAddress class, this uses the same filename for both objects being compared. N)� assertTrue� buildAddress� assertFalse��self� r �D/usr/lib/python3/dist-packages/twisted/internet/test/test_address.py�test_addressComparison s z+AddressTestCaseMixin.test_addressComparisonc C �& | � � }|di}| �|| � � � dS )z� C{__hash__} can be used to get a hash of an address, allowing addresses to be used as keys in dictionaries, for instance. TN�r r �r �addr�dr r r � test_hash) � z AddressTestCaseMixin.test_hashc C s\ | � | �� | �� k� | � | �� | �� k� | �| �� | �� k� | �| �� | �� k� dS )z~ Check that comparison operators work correctly on address objects when a different name is passed in N)r r �buildDifferentAddressr r r r r � test_differentNamesComparison2 s z2AddressTestCaseMixin.test_differentNamesComparisonc C sH | � |g�}| �|d d t� | �|d d |� | �t|�d� dS )z{ Assert that the a DeprecationWarning with the given message was emitted against the given method. r �category�message� N)� flushWarnings� assertEqual�DeprecationWarning�len)r � testMethodr �warningsr r r �assertDeprecations= s z'AddressTestCaseMixin.assertDeprecationsN)�__name__� __module__� __qualname__r r r r& r r r r r s r c @ s e Zd ZdZdS )�IPv4AddressTestCaseMixin�)�type�%s)�host�%r��portz%dN)r' r( r) �addressArgSpecr r r r r* H s r* c @ s$ e Zd ZdZdZdd� Zdd� ZdS )�HostnameAddressTestsz+ Test case for L{HostnameAddress}. ))�hostnamer- r0 c C � t dd�S )zw Create an arbitrary new L{HostnameAddress} instance. @return: A L{HostnameAddress} instance. s example.comr �r r r r r r S � z!HostnameAddressTests.buildAddressc C r5 )zw Like L{buildAddress}, but with a different hostname. @return: A L{HostnameAddress} instance. s example.netr r6 r r r r r [ r7 z*HostnameAddressTests.buildDifferentAddressN)r' r( r) �__doc__r2 r r r r r r r3 L s r3 c @ � e Zd Zdd� Zdd� ZdS )�IPv4AddressTCPTestsc C � t ddd�S )z� Create an arbitrary new L{IPv4Address} instance with a C{"TCP"} type. A new instance is created for each call, but always for the same address. �TCP� 127.0.0.1r �r r r r r r e � z IPv4AddressTCPTests.buildAddressc C r; )�K Like L{buildAddress}, but with a different fixed address. r< � 127.0.0.2r r> r r r r r m � z)IPv4AddressTCPTests.buildDifferentAddressN�r' r( r) r r r r r r r: d � r: c @ r9 )�IPv4AddressUDPTestsc C r; )z� Create an arbitrary new L{IPv4Address} instance with a C{"UDP"} type. A new instance is created for each call, but always for the same address. �UDPr= r r> r r r r r u r? z IPv4AddressUDPTests.buildAddressc C r; )r@ rF rA r r> r r r r r } rB z)IPv4AddressUDPTests.buildDifferentAddressNrC r r r r rE t rD rE c @ s e Zd ZdZdd� Zdd� ZdS )�IPv6AddressTestsr+ c C r; )z� Create an arbitrary new L{IPv6Address} instance with a C{"TCP"} type. A new instance is created for each call, but always for the same address. r< z::1r �r r r r r r � r? z IPv6AddressTests.buildAddressc C r; )r@ r< z::2r rH r r r r r � rB z&IPv6AddressTests.buildDifferentAddressN)r' r( r) r2 r r r r r r rG � s rG z&Platform doesn't support UNIX sockets.c @ sT e Zd ZdZdd� Zdd� Zdd� Zdd � Zee d �d d � �Z ee d �d d� �Z dS )�UNIXAddressTests�)�namer/ c C s | � � | _| � � | _d S �N)�mktemp�_socketAddress� _otherAddressr r r r �setUp� s zUNIXAddressTests.setUpc C � t | j�S )z� Create an arbitrary new L{UNIXAddress} instance. A new instance is created for each call, but always for the same address. �r rN r r r r r � s z UNIXAddressTests.buildAddressc C rQ )r@ )r rO r r r r r � � z&UNIXAddressTests.buildDifferentAddressc C s" | � t| �� �dt| j� � dS )zn The repr of L{UNIXAddress} returns with the filename that the L{UNIXAddress} is for. zUNIXAddress('%s')N)r! �reprr r rN r r r r � test_repr� s �zUNIXAddressTests.test_repr�"Platform does not support symlinksc C s~ | � � }t| jd��+| _t�tj�| j�|� | �t | j�t |�� | �t |�t | j�� W d � dS 1 s8w Y dS )zU UNIXAddress objects compare as equal if they link to the same file. �wN) rM �openrN �fd�os�symlink�path�abspathr! r �r �linkNamer r r � test_comparisonOfLinkedFiles� s "�z-UNIXAddressTests.test_comparisonOfLinkedFilesc C sp | � � }t| jd��$| _t�tj�| j�|� | �t t | j��t t |��� W d � dS 1 s1w Y dS )zU UNIXAddress Objects that compare as equal have the same hash value. rW N) rM rX rN rY rZ r[ r\ r] r! �hashr r^ r r r �test_hashOfLinkedFiles� s �"�z'UNIXAddressTests.test_hashOfLinkedFilesN) r' r( r) r2 rP r r rU r � symlinkSkipr` rb r r r r rI � s rI z&platform doesn't support UNIX sockets.c @ sF e Zd ZdZdZdd� Zdd� Zdd� Zee d �d d � �Z d d � Z dS )�EmptyUNIXAddressTestszJ Tests for L{UNIXAddress} operations involving a L{None} address. rJ c C s | � � | _d S rL )rM rN r r r r rP � s zEmptyUNIXAddressTests.setUpc C s t d�S )z� Create an arbitrary new L{UNIXAddress} instance. A new instance is created for each call, but always for the same address. This builds it with a fixed address of L{None}. N)r r r r r r � s z"EmptyUNIXAddressTests.buildAddressc C rQ )zN Like L{buildAddress}, but with a random temporary directory. rR r r r r r � rS z+EmptyUNIXAddressTests.buildDifferentAddressrV c C s~ | � � }t| jd��+| _t�tj�| j�|� | �t | j�t d�� | �t d�t | j�� W d � dS 1 s8w Y dS )z� A UNIXAddress referring to a L{None} address does not compare equal to a UNIXAddress referring to a symlink. rW N) rM rX rN rY rZ r[ r\ r] �assertNotEqualr r^ r r r r` � s "�z2EmptyUNIXAddressTests.test_comparisonOfLinkedFilesc C r )z� C{__hash__} can be used to get a hash of an address, even one referring to L{None} rather than a real path. TNr r r r r �test_emptyHash� r z$EmptyUNIXAddressTests.test_emptyHashN) r' r( r) r8 r2 rP r r r rc r` rf r r r r rd � s rd ) rZ �socket�unittestr �twisted.internet.addressr r r r �twisted.python.compatr �twisted.python.runtimer �twisted.trial.unittestr r �_supportsSymlinksrc �AF_UNIX�AttributeError�unixSkipr r* r3 r: rE rG rI rd r r r r �<module> s0 �+6PK Mb�Z#Kd�0O 0O 7 internet/test/__pycache__/test_resolver.cpython-310.pycnu �[��� o �b�L � @ s� d Z ddlmZ ddlmZmZmZmZmZm Z m Z m Z m Z ddl mZmZ ddlmZ ddlmZ ddlmZmZmZ ddlmZmZmZ dd l m Z m Z dd l m Z m!Z! dd l"m#Z# dd l$m%Z% dd l&m'Z'm(Z(m)Z)m*Z* ddl+m,Z, ddl-m.Z/ G dd� de,�Z0dd� Z1dd� Z2G dd� d�Z3ee)�G dd� d��Z4G dd� de/�Z5G d d � d e/�Z6ee*�G d d � d ��Z7G d d!� d!e/�Z8G d"d#� d#e!�Z9G d$d%� d%e/�Z:d&S )'zh Tests for implementations of L{IHostnameResolver} and their interactions with reactor implementations. � )� defaultdict) �AF_INET�AF_INET6� AF_UNSPEC� EAI_NONAME� IPPROTO_TCP� SOCK_DGRAM� SOCK_STREAM�gaierror� getaddrinfo)�Lock�local)� implementer)� verifyObject)� LockWorker�Team�createMemoryWorker)�ComplexResolverSimplifier� GAIResolver�SimpleResolverComplexifier)� IPv4Address� IPv6Address)�PluggableResolverMixin� ReactorBase)�Deferred)�DNSLookupError)�IHostnameResolver� IReactorPluggableNameResolver�IResolutionReceiver�IResolverSimple)� ThreadPool)�SynchronousTestCasec @ � e Zd ZdZdd� ZdS )�DeterministicThreadPoolz6 Create a deterministic L{ThreadPool} object. c C s" d| _ d| _d| _g | _|| _dS )zE Create a L{DeterministicThreadPool} from a L{Team}. � N)�min�max�name�threads�_team)�self�team� r, �E/usr/lib/python3/dist-packages/twisted/internet/test/test_resolver.py�__init__4 s z DeterministicThreadPool.__init__N)�__name__� __module__� __qualname__�__doc__r. r, r, r, r- r# / � r# c s4 t � \� } tttt� t� �� fdd�dd� ��| fS )z� Create a deterministic threadpool. @return: 2-tuple of L{ThreadPool}, 0-argument C{work} callable; when C{work} is called, do the work. c s � S �Nr, r, ��workerr, r- �<lambda>I � z#deterministicPool.<locals>.<lambda>c S s d S r4 r, r, r, r, r- r7 I r8 )r r# r r r r )�doerr, r5 r- �deterministicPool? s ��r: c s& t � \� } G � fdd�d�}|� | fS )z� Create a deterministic L{IReactorThreads} @return: a 2-tuple consisting of an L{IReactorThreads}-like object and a 0-argument callable that will perform one unit of work invoked via that object's C{callFromThread} method. c s e Zd Z� fdd�ZdS )z(deterministicReactorThreads.<locals>.CFTc s �� � ��fdd�� d S )Nc s �� i ���S r4 r, r, ��a�f�kr, r- r7 [ s zIdeterministicReactorThreads.<locals>.CFT.callFromThread.<locals>.<lambda>)�do)r* r= r< r> r5 r; r- �callFromThreadZ s z7deterministicReactorThreads.<locals>.CFT.callFromThreadN)r/ r0 r1 r@ r, r5 r, r- �CFTY s rA )r )r9 rA r, r5 r- �deterministicReactorThreadsO s rB c @ s4 e Zd ZdZdd� Zd dd�Zeeedfdd �Z d S ) �FakeAddrInfoGetterz/ Test object implementing getaddrinfo. c C s g | _ tt�| _dS )z1 Create a L{FakeAddrInfoGetter}. N)�callsr �list�results�r* r, r, r- r. e s zFakeAddrInfoGetter.__init__r c C s4 | j �||||||f� | j| }|r|S ttd��)a� Mock for L{socket.getaddrinfo}. @param host: see L{socket.getaddrinfo} @param port: see L{socket.getaddrinfo} @param family: see L{socket.getaddrinfo} @param socktype: see L{socket.getaddrinfo} @param proto: see L{socket.getaddrinfo} @param flags: see L{socket.getaddrinfo} @return: L{socket.getaddrinfo} z,nodename nor servname provided, or not known)rD �appendrF r r )r* �host�port�family�socktype�proto�flagsrF r, r, r- r l s z FakeAddrInfoGetter.getaddrinfo� c C s | j | �|||||f� dS )a� Add a result for a given hostname. When this hostname is resolved, the result will be a L{list} of all results C{addResultForHost} has been called with using that hostname so far. @param host: The hostname to give this result for. This will be the next result from L{FakeAddrInfoGetter.getaddrinfo} when passed this host. @type canonname: native L{str} @param sockaddr: The resulting socket address; should be a 2-tuple for IPv4 or a 4-tuple for IPv6. @param family: An C{AF_*} constant that will be returned from C{getaddrinfo}. @param socktype: A C{SOCK_*} constant that will be returned from C{getaddrinfo}. @param proto: An C{IPPROTO_*} constant that will be returned from C{getaddrinfo}. @param canonname: A canonical name that will be returned from C{getaddrinfo}. @type canonname: native L{str} N)rF rH )r* rI �sockaddrrK rL rM � canonnamer, r, r- �addResultForHost� s $z#FakeAddrInfoGetter.addResultForHostN)r r r r ) r/ r0 r1 r2 r. r r r r rR r, r, r, r- rC ` s �rC c @ s8 e Zd ZdZdZdZdd� Zdd� Zdd� Zd d � Z d S ) � ResultHolderzI A resolution receiver which holds onto the results it received. Fc C s || _ dS )z> Create a L{ResultHolder} with a L{UnitTest}. N)� _testCase)r* �testCaser, r, r- r. � � zResultHolder.__init__c C s d| _ || _g | _dS )zg Hostname resolution began. @param hostResolution: see L{IResolutionReceiver} TN)�_started� _resolution� _addresses)r* �hostResolutionr, r, r- �resolutionBegan� s z ResultHolder.resolutionBeganc C s | j �|� dS )z^ An address was resolved. @param address: see L{IResolutionReceiver} N)rY rH )r* �addressr, r, r- �addressResolved� s z ResultHolder.addressResolvedc C s d| _ dS )z2 Hostname resolution is complete. TN)�_endedrG r, r, r- �resolutionComplete� rV z ResultHolder.resolutionCompleteN) r/ r0 r1 r2 rW r^ r. r[ r] r_ r, r, r, r- rS � s rS c @ r" )� HelperTestsz? Tests for error cases of helpers used in this module. c C sD t � \| _| _dd� }| j�|� | �� | �t| �t��d� dS )zq L{DeterministicThreadPool} will log any exceptions that its "thread" workers encounter. c S s dd S )Nr$ r r, r, r, r, r- � divideByZero� s z9HelperTests.test_logErrorsInThreads.<locals>.divideByZeror$ N)r: �pool� doThreadWork� callInThread� assertEqual�len�flushLoggedErrors�ZeroDivisionError)r* ra r, r, r- �test_logErrorsInThreads� s z#HelperTests.test_logErrorsInThreadsN)r/ r0 r1 r2 ri r, r, r, r- r` � r3 r` c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )�HostnameResolutionTestsz( Tests for hostname resolution. c sD t � \� _� _t� \� _� _t� � _t� j� fdd�� jj �� _ dS )z* Set up a L{GAIResolver}. c � � j S r4 �rb r, rG r, r- r7 � � z/HostnameResolutionTests.setUp.<locals>.<lambda>N) r: rb rc rB �reactor� doReactorWorkrC �getterr r �resolverrG r, rG r- �setUp� s �z HostnameResolutionTests.setUpc C s� t | �}| j�dd� | j�|d�}| �|j|� | �|jd� | �|j d� | � � | � � | �|j d� | �|j t ddd�g� dS ) z� Resolving an individual hostname that results in one address from getaddrinfo results in a single call each to C{resolutionBegan}, C{addressResolved}, and C{resolutionComplete}. �sample.example.com)�4.3.2.1r TF�TCPrt r N)rS rp rR rq �resolveHostName�assertIsrX re rW r^ rc ro rY r �r* �receiver� resolutionr, r, r- �test_resolveOneHost� s z+HostnameResolutionTests.test_resolveOneHostc C s� t | �}d}d}| jjddd||ftd� | j�|d�}| �|j|� | �|j d� | �|j d� | � � | � � | �|j d� | �|j td dd||�g� d S ) a Resolving an individual hostname that results in one address from getaddrinfo results in a single call each to C{resolutionBegan}, C{addressResolved}, and C{resolutionComplete}; C{addressResolved} will receive an L{IPv6Address}. r$ � rs �::1r )rK TFru N)rS rp rR r rq rv rw rX re rW r^ rc ro rY r )r* ry �flowInfo�scopeIDrz r, r, r- �test_resolveOneIPv6Host s ��z/HostnameResolutionTests.test_resolveOneIPv6Hostc C sb t | �}| j�|d�}| �|j|� | �� | �� | �|jd� | �|j d� | �|j g � dS )a Resolving a hostname that results in C{getaddrinfo} raising a L{gaierror} will result in the L{IResolutionReceiver} receiving a call to C{resolutionComplete} with no C{addressResolved} calls in between; no failure is logged. rs TN) rS rq rv rw rX rc ro re rW r^ rY rx r, r, r- � test_gaierror! s z%HostnameResolutionTests.test_gaierrorc C s` t | �}| jj|d|d�}| �|j|� | �� | �� | jjd \}}}}} } | � ||� dS )z� Verify that the given set of address types results in the given C{AF_} constant being passed to C{getaddrinfo}. @param addrTypes: iterable of L{IAddress} implementers @param expectedAF: an C{AF_*} constant rs )� addressTypesr N) rS rq rv rw rX rc ro rp rD re ) r* � addrTypes� expectedAFry rz rI rJ rK rL rM rN r, r, r- �_resolveOnlyTest1 s �z(HostnameResolutionTests._resolveOnlyTestc C � | � tgt� dS )z� When passed an C{addressTypes} parameter containing only L{IPv4Address}, L{GAIResolver} will pass C{AF_INET} to C{getaddrinfo}. N)r� r r rG r, r, r- �test_resolveOnlyIPv4D � z,HostnameResolutionTests.test_resolveOnlyIPv4c C r� )z� When passed an C{addressTypes} parameter containing only L{IPv6Address}, L{GAIResolver} will pass C{AF_INET6} to C{getaddrinfo}. N)r� r r rG r, r, r- �test_resolveOnlyIPv6K r� z,HostnameResolutionTests.test_resolveOnlyIPv6c C s | � ttgt� | � dt� dS )z� When passed an C{addressTypes} parameter containing both L{IPv4Address} and L{IPv6Address} (or the default of C{None}, which carries the same meaning), L{GAIResolver} will pass C{AF_UNSPEC} to C{getaddrinfo}. N)r� r r r rG r, r, r- �test_resolveBothR s z(HostnameResolutionTests.test_resolveBothc C s� t | �}| jj|ddd� t | �}| jj|ddd� | �� | �� | �� | �� | jjd \}}}}}}| jjd \}}}} }}| �|t� | �| t � dS )z� When passed a C{transportSemantics} paramter, C{'TCP'} (the value present in L{IPv4Address.type} to indicate a stream transport) maps to C{SOCK_STREAM} and C{'UDP'} maps to C{SOCK_DGRAM}. � example.comru )�transportSemantics�UDPr r$ N) rS rq rv rc ro rp rD re r r ) r* ry � receiver2rI rJ rK � socktypeTrM rN � socktypeUr, r, r- �#test_transportSemanticsToSocketType[ s � z;HostnameResolutionTests.test_transportSemanticsToSocketTypec C s� t | �}d}d}ttfD ]}| jjddd||ft|d� | jjddt|d� q | j�|d� | � � | � � |j \}}}}| � |j d� | � |j d� | � |j d � | � |j d � d S ) z� When L{GAIResolver} receives a C{SOCK_DGRAM} result from C{getaddrinfo}, it returns a C{'TCP'} L{IPv4Address} or L{IPv6Address}; if it receives C{SOCK_STREAM} then it returns a C{'UDP'} type of same. r$ r| r� r} r )rK rL )z 127.0.0.3r ru r� N)rS r r rp rR r r rq rv rc ro rY re �type) r* ry r~ r rL �stream4�stream6�dgram4�dgram6r, r, r- � test_socketTypeToAddressTypep s* ��z4HostnameResolutionTests.test_socketTypeToAddressTypeN)r/ r0 r1 r2 rr r{ r� r� r� r� r� r� r� r� r, r, r, r- rj � s rj c @ s" e Zd ZdZdd� Zddd�ZdS ) �SillyResolverSimplez6 Trivial implementation of L{IResolverSimple} c C s g | _ dS )zd Create a L{SillyResolverSimple} with a queue of requests it is working on. N)� _requestsrG r, r, r- r. � s z SillyResolverSimple.__init__r, c C s | j �t� � | j d S )z� Implement L{IResolverSimple.getHostByName}. @param name: see L{IResolverSimple.getHostByName}. @param timeout: see L{IResolverSimple.getHostByName}. @return: see L{IResolverSimple.getHostByName}. ���)r� rH r )r* r' �timeoutr, r, r- � getHostByName� s z!SillyResolverSimple.getHostByNameN)r, )r/ r0 r1 r2 r. r� r, r, r, r- r� � s r� c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �LegacyCompatibilityTestsz� Older applications may supply an object to the reactor via C{installResolver} that only provides L{IResolverSimple}. L{SimpleResolverComplexifier} is a wrapper for an L{IResolverSimple}. c C s� t � }t|�}t| �}| �|jd� |�|d� | �|jd� | �|jd� | �|jg � |jd � d� | �|jt ddd�g� | �|jd� dS )z� L{SimpleResolverComplexifier} translates C{resolveHostName} into L{IResolutionReceiver.addressResolved}. Fr� Tr � 192.168.1.1ru N) r� r rS re rW rv r^ rY r� �callbackr �r* �simple�complexry r, r, r- � test_success� s z%LegacyCompatibilityTests.test_successc C s� t � }t|�}t| �}| �|jd� |�|d� | �|jd� | �|jd� | �|jg � |jd � t d�� | �|jd� | �|jg � dS )z� L{SimpleResolverComplexifier} translates a known error result from L{IResolverSimple.resolveHostName} into an empty result. Fr� Tr �nopeN) r� r rS re rW rv r^ rY r� �errbackr r� r, r, r- � test_failure� s z%LegacyCompatibilityTests.test_failurec C s� t � }t|�}t| �}| �|jd� |�|d� | �|jd� | �|jd� | �|jg � |jd � t d�� | �t | � t ��d� | �|jd� | �|jg � dS )z� L{SimpleResolverComplexifier} translates an unknown error result from L{IResolverSimple.resolveHostName} into an empty result and a logged error. Fr� Tr �zowr$ N) r� r rS re rW rv r^ rY r� r� rh rf rg r� r, r, r- � test_error� s z#LegacyCompatibilityTests.test_errorc s� t � \� _� _t� \� _� _t� � _t� j� fdd�� jj �� _ t � j �}� j� dd� |� d�}|� d�}� �� � �� � �� � �� � �� �|�jt� � �� �|�d� dS )z� L{ComplexResolverSimplifier} translates an L{IHostnameResolver} into an L{IResolverSimple} for applications that still expect the old interfaces to be in place. c rk r4 rl r, rG r, r- r7 � rm z:LegacyCompatibilityTests.test_simplifier.<locals>.<lambda>r� )� 192.168.3.4�� znx.example.comr� N)r: rb rc rB rn ro rC rp r r rq r rR r� re �failureResultOfr� r �successResultOf)r* �simpleResolver�success�failurer, rG r- �test_simplifier� s � z(LegacyCompatibilityTests.test_simplifierc C s� t � }t|�}t| �}|�|dd� | �|jd� | �|jd� | �|jg � |jd � d� | �|jt ddd�g� | �|jd� dS ) z� L{SimpleResolverComplexifier} preserves the C{port} argument passed to C{resolveHostName} in its returned addresses. r� r� TFr r� ru N) r� r rS rv re rW r^ rY r� r� r r� r, r, r- �test_portNumber� s z(LegacyCompatibilityTests.test_portNumberN) r/ r0 r1 r2 r� r� r� r� r� r, r, r, r- r� � s r� c @ r" )�JustEnoughReactorzT Just enough subclass implementation to be a valid L{ReactorBase} subclass. c C s dS )z Do nothing. Nr, rG r, r, r- � installWaker r8 z JustEnoughReactor.installWakerN)r/ r0 r1 r2 r� r, r, r, r- r� r3 r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �ReactorInstallationTestsz� Tests for installing old and new resolvers onto a L{PluggableResolverMixin} and L{ReactorBase} (from which all of Twisted's reactor implementations derive). c C s, t � }tt|� tt|j� tt|j� dS )z� L{PluggableResolverMixin} (and its subclasses) implement both L{IReactorPluggableNameResolver} and L{IReactorPluggableResolver}. N)r r r r rq r � nameResolver�r* rn r, r, r- �test_interfaceCompliance s z1ReactorInstallationTests.test_interfaceCompliancec C s> t � }t� }tt|�|�� | �|jt� | �|jj |� dS )zf L{PluggableResolverMixin} will wrap an L{IResolverSimple} in a complexifier. N) r r� r r �installResolver�assertIsInstancer� r rw �_simpleResolver)r* rn �itr, r, r- � test_installingOldStyleResolver( s z8ReactorInstallationTests.test_installingOldStyleResolverc C sX t � }| �|jt� | �|jjt� | �|jt� | �|jj |� | �|jj |j� dS )zD L{ReactorBase} defaults to using a L{GAIResolver}. N) r� r� r� r rw � _getaddrinfor rq r �_reactor� _nameResolverr� r, r, r- �test_defaultToGAIResolver3 s z2ReactorInstallationTests.test_defaultToGAIResolverN)r/ r0 r1 r2 r� r� r� r, r, r, r- r� s r� N);r2 � collectionsr �socketr r r r r r r r r � threadingr r �zope.interfacer �zope.interface.verifyr �twisted._threadsr r r �twisted.internet._resolverr r r �twisted.internet.addressr r �twisted.internet.baser r �twisted.internet.deferr �twisted.internet.errorr �twisted.internet.interfacesr r r r �twisted.python.threadpoolr �twisted.trial.unittestr! �UnitTestr# r: rB rC rS r` rj r� r� r� r� r, r, r, r- �<module> s: , L' &d PK Mb�Z�WwR� � < internet/test/__pycache__/test_kqueuereactor.cpython-310.pycnu �[��� o �b= � @ sx d Z ddlZddlmZ ddlmZ z ddlmZmZ dZ W n e y) dZ Y nw dd� Z d d � Z G d d � d e�Z dS ) z. Tests for L{twisted.internet.kqueuereactor}. � N)� implementer)�TestCase)� KQueueReactor�_IKQueuezKQueue not available.c O s dS )z Do nothing. N� )�args�kwargsr r �J/usr/lib/python3/dist-packages/twisted/internet/test/test_kqueuereactor.py� _fakeKEvent s r c s" t t�G � �fdd�d��}|� S )a Create a fake that implements L{_IKQueue}. @param testKQueue: Something that acts like L{select.kqueue}. @param testKEvent: Something that acts like L{select.kevent}. @return: An implementation of L{_IKQueue} that includes C{testKQueue} and C{testKEvent}. c s e Zd Z�Z� ZdS )z"makeFakeKQueue.<locals>.FakeKQueueN)�__name__� __module__� __qualname__�kqueue�keventr �� testKEvent� testKQueuer r � FakeKQueue& s r )r r )r r r r r r �makeFakeKQueue s r c @ s e Zd ZdZeZdd� ZdS )� KQueueTestsz� These are tests for L{KQueueReactor}'s implementation, not its real world behaviour. For that, look at L{twisted.internet.test.reactormixins.ReactorBuilder}. c C s* G dd� d�}t t|t��}|�d� dS )zV L{KQueueReactor} handles L{errno.EINTR} in C{doKEvent} by returning. c @ s e Zd ZdZdd� ZdS )z*KQueueTests.test_EINTR.<locals>.FakeKQueuez� A fake KQueue that raises L{errno.EINTR} when C{control} is called, like a real KQueue would if it was interrupted. c _ s t tjd��)N� Interrupted)�OSError�errno�EINTR)�selfr r r r r �controlB s z2KQueueTests.test_EINTR.<locals>.FakeKQueue.controlN)r r r �__doc__r r r r r r < s r r N)r r r �doKEvent)r r �reactorr r r � test_EINTR7 s zKQueueTests.test_EINTRN)r r r r � kqueueSkip�skipr r r r r r . s r )r r �zope.interfacer �twisted.trial.unittestr �twisted.internet.kqreactorr r r � ImportErrorr r r r r r r �<module> s �PK Mb�Z~ wh h 6 internet/test/__pycache__/_win32ifaces.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZmZmZmZmZmZmZm Z m Z m Z ddl m Z mZm Z ed�ZeZeZeZeZeZeZeZeZeZejZeeeeeeeeeg e_ee_ej Z eeeeege _ee _dZ dZ G dd� de�Z d d � Z!d d � Z"d S )z@ Windows implementation of local network interface enumeration. � ) �POINTER� Structure�WinDLL�byref�c_int�c_void_p�cast�create_string_buffer�create_unicode_buffer� wstring_at)�AF_INET6� SOCK_STREAM�socket�ws2_32i Hi ' c @ s e Zd ZdefdefgZdS )�SOCKET_ADDRESS� lpSockaddr�iSockaddrLengthN)�__name__� __module__� __qualname__r r �_fields_� r r �D/usr/lib/python3/dist-packages/twisted/internet/test/_win32ifaces.pyr M s r c s G � fdd�dt �}|S )Nc s e Zd Zdefde� fgZdS )z%make_SAL.<locals>.SOCKET_ADDRESS_LIST� iAddressCount�AddressN)r r r r r r r ��lnr r �SOCKET_ADDRESS_LISTR s r )r )r r r r r �make_SALQ s r c C s t tt�} d}t� }td�D ] }t|�}t| �� tdd||t |�dd� }|r-|j r-|j }q |r4t d��t |t td���}|d j}t |t t|���}d}t|�} g } t|d j�D ]%}||_ |d j| } t| j| jd| t |��}|rxt d��| �t| �� qZdd� | D �S ) z� Return a list of strings in colon-hex format representing all the link local IPv6 addresses available on the system, as reported by I{WSAIoctl}/C{SIO_ADDRESS_LIST_QUERY}. i � r zWSAIoctl failurei zWSAAddressToString failurec S s g | ]}d |v r|�qS )�%r )�.0�addrr r r � <listcomp>� s z2win32GetLinkLocalIPv6Addresses.<locals>.<listcomp>)r r r r �ranger �WSAIoctl�fileno�SIO_ADDRESS_LIST_QUERYr �value� RuntimeErrorr r r r r r �WSAAddressToStringr r �appendr ) �s�size�retBytes�i�buf�ret�addrList� addrCount�addressStringBufLength�addressStringBuf�retList�addressr r r � win32GetLinkLocalIPv6AddressesX sB � �r8 N)#�__doc__�ctypesr r r r r r r r r r r r r �WS2_32�SOCKET�DWORD�LPVOID� LPSOCKADDR�LPWSAPROTOCOL_INFO�LPTSTR�LPDWORD�LPWSAOVERLAPPED�"LPWSAOVERLAPPED_COMPLETION_ROUTINEr% �argtypes�restype�WSAAddressToStringWr* r' � WSAEFAULTr r r8 r r r r �<module> sB 0 � PK Mb�ZlY{� � > internet/test/__pycache__/test_defer_yieldfrom.cpython-310.pycnu �[��� o �b� � @ sP d Z ddlZddlmZmZmZmZ ddlmZ ddl m Z G dd� de �Z dS )z/ Tests for C{yield from} support in Deferreds. � N)�Deferred�ensureDeferred�fail�succeed)�Clock)�TestCasec @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�YieldFromTestsz@ Tests for using Deferreds in conjunction with PEP-380. c C sJ dd� }|� }| � |tj� t|�}| � |t� | �|�}| �|d� dS )zM L{ensureDeferred} will turn a coroutine into a L{Deferred}. c s � � t d�} | E d H }|S �N�foo�r ��d�res� r �L/usr/lib/python3/dist-packages/twisted/internet/test/test_defer_yieldfrom.py�run � � z/YieldFromTests.test_ensureDeferred.<locals>.runr N)�assertIsInstance�types� GeneratorTyper r �successResultOf� assertEqual��selfr �rr r r r r �test_ensureDeferred s z"YieldFromTests.test_ensureDeferredc sX � fdd�}dd� � |� }| � |tj� t�|�}| � |t� | �|�}| �|d� dS )zU L{Deferred.fromCoroutine} will turn a coroutine into a L{Deferred}. c 3 s$ � t d�} | E d H � � E d H }|S )N�barr r ��run2r r r 0 s � z6YieldFromTests.test_DeferredfromCoroutine.<locals>.runc s r r r r r r r r 6 r z7YieldFromTests.test_DeferredfromCoroutine.<locals>.run2r N)r r r r � fromCoroutiner r r r r r �test_DeferredfromCoroutine+ s z)YieldFromTests.test_DeferredfromCoroutinec C s. dd� }t �|� �}| �|�}| �|d� dS )ze L{Deferred.fromCoroutine} allows a function to C{yield from} a L{Deferred}. c s r r r r r r r r M r z&YieldFromTests.test_basic.<locals>.runr N)r r r r �r r r r r r r � test_basicG s zYieldFromTests.test_basicc C sD dd� }t �|� �}| �|�}| �t|j�t� | �|jjd� dS )�� An exception in a generator scheduled with L{Deferred.fromCoroutine} will cause the returned L{Deferred} to fire with a failure. c s s � t d�} | E d H td��)Nr �Oh no!)r � ValueError�r r r r r \ s � z*YieldFromTests.test_exception.<locals>.run)r% N)r r �failureResultOfr �type�valuer& �argsr" r r r �test_exceptionV s z YieldFromTests.test_exceptionc s� t � � g �� �fdd��� ��fdd�}t�|� �}� �d� | ��ddg� � �d� | ��g d �� � �d� | ��g d �� � �d� | ��g d �� | �|�}| �|d � d S ) r$ c 3 s: � �� d� t� } � �d| jd � | E d H �� d� dS )N� � � �Yay!��appendr � callLater�callbackr' )�reactor�sectionsr r �runonen s � z+YieldFromTests.test_twoDeep.<locals>.runonec 3 sP � �� d� �� E d H } �� d� t� }� �d|jd � |E d H �� d� | S )Nr. � � r1 )�resultr �r5 r7 r6 r r r v s � z(YieldFromTests.test_twoDeep.<locals>.rung�������?r. r- 皙�����?)r. r- r/ r8 )r. r- r/ r8 r9 r0 N)r r r �advancer r r" r r; r � test_twoDeepf s zYieldFromTests.test_twoDeepc s. � fdd�}� � t�|� ��}� �|d� dS )zT Yielding from an already failed Deferred will raise the exception. c 3 sP � z t td��E d H W dS ty' } z� �| jd� W Y d } ~ dS d } ~ ww )N�Boom)r? r. r )r r& r r+ )�e�r r r �test� s ����z)YieldFromTests.test_reraise.<locals>.testr. N)r r r r )r rB r r rA r � test_reraise� s zYieldFromTests.test_reraisec sB t � � � fdd�}t�|� �}� �d� | �|�}| �|d� dS )zi Yielding from a paused & chained Deferred will give the result when it has one. c 3 sH � t � } t � � | �� fdd�� | �d � ��d� jd� | E d H }|S )Nc s � S )Nr )�ignored��d2r r �<lambda>� s z;YieldFromTests.test_chained.<locals>.test.<locals>.<lambda>r �bye)r � addCallbackr4 r3 r �r5 rE r rB � s � z)YieldFromTests.test_chained.<locals>.testr< rH N)r r r r= r r )r rB r r r rJ r � test_chained� s zYieldFromTests.test_chainedN) �__name__� __module__� __qualname__�__doc__r r! r# r, r> rC rK r r r r r s + r ) rO r �twisted.internet.deferr r r r �twisted.internet.taskr �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z��S�CE CE 2 internet/test/__pycache__/test_udp.cpython-310.pycnu �[��� o �b�A � @ sL d Z ddlZddlmZ ddlmZ ddlmZmZ ddl m Z m Z ddl m Z mZ ddlmZmZmZmZ dd lmZ dd lmZmZ dd lmZ dd lm Z dd l m Z m Z ddl m!Z!m"Z" ddl#m$Z$ dd� Z%e%� Z&dd� Z'G dd� de�Z(G dd� d�Z)G dd� dee)e(�Z*G dd� dee)e(�Z+e,� �-e*�.� � e,� �-e+�.� � dS ) zU Tests for implementations of L{IReactorUDP} and the UDP parts of L{IReactorSocket}. � N)� implementer)� verifyObject)�defer�error)� IPv4Address� IPv6Address)�Deferred� maybeDeferred)�IListeningPort�ILoggingContext�IReactorSocket� IReactorUDP)�DatagramProtocol)�LogObserverMixin� findFreePort)�ReactorBuilder)�context)� ILogContext�err)� GoodClient�Server)�SkipTestc C sJ d} d}zt � t j�} | �d� d}W n ty Y nw | r#| �� |S )z4Returns True if the system can bind an IPv6 address.NF)�::1r T)�socket�AF_INET6�bind�OSError�close)�sock�has_ipv6� r �@/usr/lib/python3/dist-packages/twisted/internet/test/test_udp.py� _has_ipv6! s �r" c C s t sd| _| S )Nz.Does not work on systems without IPv6 support.)�HAS_IPV6�skip)�fr r r! �skipWithoutIPv65 s r& c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �DatagramTransportTestsMixinzP Mixin defining tests which apply to any port/datagram based transport. c C sd | � � }| �� }tt�G dd� dt��}|� }| �||�}d|�� jf }| �|f|d d � dS )zu When a port starts, a message including a description of the associated protocol is logged. c @ s e Zd Zdd� ZdS )zQDatagramTransportTestsMixin.test_startedListeningLogMessage.<locals>.SomeProtocolc S s dS )NzCrazy Protocolr ��selfr r r! � logPrefixJ s z[DatagramTransportTestsMixin.test_startedListeningLogMessage.<locals>.SomeProtocol.logPrefixN)�__name__� __module__� __qualname__r* r r r r! � SomeProtocolH s r. z Crazy Protocol starting on %dr �messageN) �observe� buildReactorr r r �getListeningPort�getHost�port� assertEqual)r) �loggedMessages�reactorr. �protocol�p�expectedMessager r r! � test_startedListeningLogMessage@ s z;DatagramTransportTestsMixin.test_startedListeningLogMessagec sz | � � � | �� �| ��t� ��d��� j� d�}�fdd��� ��fdd�}��|� | ��� | �|f� d d � d S ) z� When a connection is lost a message is logged containing an address identifying the port and the fact that it was closed. z (UDP Port z Closed)c s � � � d S �N��stop��ignored�r7 r r! � stopReactor] � zNDatagramTransportTestsMixin.test_connectionLostLogMessage.<locals>.stopReactorc s � d d �= t �j���� d S r< )r � stopListening� addCallbackr )r6 r9 rB r r! �doStopListening` s zRDatagramTransportTestsMixin.test_connectionLostLogMessage.<locals>.doStopListeningr r/ N) r0 r1 r2 r r3 r4 �callWhenRunning� runReactorr5 )r) r: rF r )r6 r9 r7 rB r! � test_connectionLostLogMessageS s z9DatagramTransportTestsMixin.test_connectionLostLogMessagec s` G � fdd�dt �}| �� � |� }| �� |� | �� � | �|j� | �|j� | �|j� dS )z� L{DatagramProtocol.stopProtocol} is called asynchronously (ie, not re-entrantly) when C{stopListening} is used to stop the datagram transport. c s0 e Zd ZdZdZdZdZdd� Z� fdd�ZdS )zVDatagramTransportTestsMixin.test_stopProtocolScheduling.<locals>.DisconnectingProtocolFc S s d| _ d| _| j�� d| _d S )NTF)�started�inStartProtocol� transportrD r( r r r! � startProtocolw s zdDatagramTransportTestsMixin.test_stopProtocolScheduling.<locals>.DisconnectingProtocol.startProtocolc s d| _ | j| _� �� d S )NT)�stoppedrK �stoppedInStartr> r( rA r r! � stopProtocol} s zcDatagramTransportTestsMixin.test_stopProtocolScheduling.<locals>.DisconnectingProtocol.stopProtocolN) r+ r, r- rJ rN rK rO rM rP r rA r r! �DisconnectingProtocolp s rQ N) r r1 r2 rH � assertTruerJ rN � assertFalserO )r) rQ r8 r rA r! �test_stopProtocolSchedulingi s z7DatagramTransportTestsMixin.test_stopProtocolSchedulingN)r+ r, r- �__doc__r; rI rT r r r r! r' ; s r' c @ s� e Zd ZdZdd� Zdd� Zedd� �Zdd � Zd d � Z d d � Z dd� Z dd� Z edd� �Z edd� �Zdd� Zedd� �Zedd� �Zd d � Zd d � Zd S )!�UDPPortTestsMixinzY Tests for L{IReactorUDP.listenUDP} and L{IReactorSocket.adoptDatagramPort}. c C s* | � � }| �|t� �}| �tt|�� dS )zY L{IReactorUDP.listenUDP} returns an object providing L{IListeningPort}. N)r1 r2 r rR r r �r) r7 r4 r r r! �test_interface� s z UDPPortTestsMixin.test_interfacec C sH t tjd�\}}| �� }| j|t� ||d�}| �|�� td||�� dS )z� L{IListeningPort.getHost} returns an L{IPv4Address} giving a dotted-quad of the IPv4 address the port is listening on as well as the port number. )�type)r4 � interface�UDPN) r r � SOCK_DGRAMr1 r2 r r5 r3 r )r) �host� portNumberr7 r4 r r r! � test_getHost� s � z UDPPortTestsMixin.test_getHostc C s@ | � � }| j|t� dd�}|�� }| �|jd� | �|t� dS )zr L{IListeningPort.getHost} returns an L{IPv6Address} when listening on an IPv6 interface. r �rZ N)r1 r2 r r3 r5 r] �assertIsInstancer )r) r7 r4 �addrr r r! �test_getHostIPv6� s z"UDPPortTestsMixin.test_getHostIPv6c C s& | � � }| jtj|jt� ddd� dS )z� An L{InvalidAddressError} is raised when trying to listen on an address that isn't a valid IPv4 or IPv6 address. r z example.comr` N)r1 � assertRaisesr �InvalidAddressError� listenUDPr )r) r7 r r r! �test_invalidInterface� s �z'UDPPortTestsMixin.test_invalidInterfacec s� G dd� dt �}��� � |d�}|j}��� |�}|�� }�fdd�}|�|� |�t� |�� fdd�� |�dd |j f� �� � � d S ) z� Datagram transports implement L{ILoggingContext.logPrefix} to return a message reflecting the protocol they are running. c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )zIUDPPortTestsMixin.test_logPrefix.<locals>.CustomLogPrefixDatagramProtocolc S s || _ t� | _d S r< )�_prefixr �system)r) �prefixr r r! �__init__� s zRUDPPortTestsMixin.test_logPrefix.<locals>.CustomLogPrefixDatagramProtocol.__init__c S s | j S r< )rh r( r r r! r* � s zSUDPPortTestsMixin.test_logPrefix.<locals>.CustomLogPrefixDatagramProtocol.logPrefixc S s2 | j d ur| j }d | _ |�t�t�d � d S d S )Nri )ri �callbackr �getr )r) �bytesrb ri r r r! �datagramReceived� s �zZUDPPortTestsMixin.test_logPrefix.<locals>.CustomLogPrefixDatagramProtocol.datagramReceivedN)r+ r, r- rk r* ro r r r r! � CustomLogPrefixDatagramProtocol� s rp zCustom Datagramsc s � � d| � d S )NzCustom Datagrams (UDP))r5 )ri r( r r! � gotSystem� � z3UDPPortTestsMixin.test_logPrefix.<locals>.gotSystemc � � � � S r< r= r? rA r r! �<lambda>� � z2UDPPortTestsMixin.test_logPrefix.<locals>.<lambda>s some bytes� 127.0.0.1N) r r1 ri r2 r3 rE � addErrbackr �writer4 rH )r) rp r8 �dr4 �addressrq r )r7 r) r! �test_logPrefix� s z UDPPortTestsMixin.test_logPrefixc s� G dd� dt �}��� �|� }|j}���|�}|�� }d� � �fdd�}|�|� |�t� |��fdd�� |�� d|j f� �� �� d S ) zH Write a sequence of L{bytes} to a L{DatagramProtocol}. c @ s e Zd Zdd� Zdd� ZdS )zDUDPPortTestsMixin.test_writeSequence.<locals>.SimpleDatagramProtocolc S s t � | _d S r< )r r r( r r r! rk � rC zMUDPPortTestsMixin.test_writeSequence.<locals>.SimpleDatagramProtocol.__init__c S s | j �|� d S r< )r rl )r) �datarb r r r! ro � rr zUUDPPortTestsMixin.test_writeSequence.<locals>.SimpleDatagramProtocol.datagramReceivedN)r+ r, r- rk ro r r r r! �SimpleDatagramProtocol� s r} )s somes bytess tos writec s �� d�� �| � d S )N� )r5 �join)r| )� dataToWriter) r r! �gotData� s z5UDPPortTestsMixin.test_writeSequence.<locals>.gotDatac rs r< r= r? rA r r! rt � ru z6UDPPortTestsMixin.test_writeSequence.<locals>.<lambda>rv N) r r1 r r2 r3 rE rw r � writeSequencer4 rH )r) r} r8 r r4 rz r� r )r� r7 r) r! �test_writeSequence� s z$UDPPortTestsMixin.test_writeSequencec C s4 | � � }| �|t� �}| �t|�� j�t|�� dS )zQ C{str()} on the listening port object includes the port number. N)r1 r2 r �assertIn�strr3 r4 rW r r r! �test_str � zUDPPortTestsMixin.test_strc C s4 | � � }| �|t� �}| �t|�� j�t|�� dS )zR C{repr()} on the listening port object includes the port number. N)r1 r2 r r� �reprr3 r4 r� rW r r r! � test_repr r� zUDPPortTestsMixin.test_reprc �� | � � �t� �t�� }�_| j��dd� t� � t�� }� _| j�� dd� � j�� }� �fdd�}�fdd�}t� ||g�}|� |� |� |� |� t � | � �� �jd }| �|d|j|jff� d S ) zS Writing to an IPv6 UDP socket on the loopback interface succeeds. r r` c s, � j �dd�j �� jf� t�� }�_|S )�� Send a datagram from the client once it's started. @param ignored: a list of C{[None, None]}, which is ignored @returns: a deferred which fires when the server has received a datagram. � spamr )rL rx r3 r4 r r �packetReceived�r@ �serverReceived��client�serverr r! �cbClientStarted s zDUDPPortTestsMixin.test_writeToIPv6Interface.<locals>.cbClientStartedc � � � � dS �z� Stop the reactor after a datagram is received. @param ignored: L{None}, which is ignored @returns: L{None} Nr= r? rA r r! �cbServerReceived, s zEUDPPortTestsMixin.test_writeToIPv6Interface.<locals>.cbServerReceivedr r� N�r1 r r r �startedDeferredr2 r rL r3 � gatherResultsrE rw r rH �packetsr5 r] r4 �r) � serverStarted� clientStarted�cAddrr� r� ry �packetr �r� r7 r� r! �test_writeToIPv6Interface s" z+UDPPortTestsMixin.test_writeToIPv6Interfacec r� ) z� An IPv6 address can be passed as the C{interface} argument to L{listenUDP}. The resulting Port accepts IPv6 datagrams. r r` c s4 � j �d�j �� j� � j �d� t�� }�_|S )r� r r� )rL �connectr3 r4 rx r r r� r� r� r r! r� N s zMUDPPortTestsMixin.test_connectedWriteToIPv6Interface.<locals>.cbClientStartedc r� r� r= r? rA r r! r� \ s zNUDPPortTestsMixin.test_connectedWriteToIPv6Interface.<locals>.cbServerReceivedr r� Nr� r� r r� r! �"test_connectedWriteToIPv6Interface> s" z4UDPPortTestsMixin.test_connectedWriteToIPv6Interfacec C �. | � � }| �|t� �}| �tj|jdd� dS )zn Writing to a hostname instead of an IP address will raise an L{InvalidAddressError}. �spam)�example.invalid� N�r1 r2 r rd r re rx rW r r r! �/test_writingToHostnameRaisesInvalidAddressErroro s �zAUDPPortTestsMixin.test_writingToHostnameRaisesInvalidAddressErrorc C �2 | � � }| j|t� dd�}| �tj|jdd� dS )�l Writing to an IPv6 address on an IPv4 socket will raise an L{InvalidAddressError}. rv r` r� )r r� Nr� rW r r r! �1test_writingToIPv6OnIPv4RaisesInvalidAddressErrorz s zCUDPPortTestsMixin.test_writingToIPv6OnIPv4RaisesInvalidAddressErrorc C r� )r� r r` r� )rv r� Nr� rW r r r! �1test_writingToIPv4OnIPv6RaisesInvalidAddressError� s �zCUDPPortTestsMixin.test_writingToIPv4OnIPv6RaisesInvalidAddressErrorc C r� )zq Connecting to a hostname instead of an IP address will raise an L{InvalidAddressError}. r� r� N)r1 r2 r rd r re r� rW r r r! �2test_connectingToHostnameRaisesInvalidAddressError� s zDUDPPortTestsMixin.test_connectingToHostnameRaisesInvalidAddressErrorc C s2 | � � }| �|t� �}|�d� | �|�� � dS )zk L{IListeningPort.setBroadcastAllowed} sets broadcast to be allowed on the socket. TN)r1 r2 r �setBroadcastAllowedrR �getBroadcastAllowedrW r r r! �test_allowBroadcast� s z%UDPPortTestsMixin.test_allowBroadcastN)r+ r, r- rU rX r_ r& rc rg r{ r� r� r� r� r� r� r� r� r� r� r r r r! rV � s, $ , 0 rV c @ �" e Zd ZdZefZ ddd�ZdS ) �UDPServerTestsBuilderzM Run L{UDPPortTestsMixin} tests using newly created UDP sockets. r � � c C s |j ||||d�S )aB Get a UDP port from a reactor. @param reactor: A reactor used to build the returned L{IListeningPort} provider. @type reactor: L{twisted.internet.interfaces.IReactorUDP} @see: L{twisted.internet.IReactorUDP.listenUDP} for other argument and return types. )rZ � maxPacketSize)rf )r) r7 r8 r4 rZ r� r r r! r2 � s �z&UDPServerTestsBuilder.getListeningPortN�r r� r� )r+ r, r- rU r �requiredInterfacesr2 r r r r! r� � s �r� c @ r� ) �UDPFDServerTestsBuilderzC Run L{UDPPortTestsMixin} tests using adopted UDP sockets. r r� r� c C s� t �|�rMd|v rtj}t�||�d d }ntj}||f}t�|tj�}|�|� |�d� z|� |� � |j ||�W |� � |� � S |� � |� � w t d��)a� Get a UDP port from a reactor, wrapping an already-initialized file descriptor. @param reactor: A reactor used to build the returned L{IListeningPort} provider. @type reactor: L{twisted.internet.interfaces.IReactorSocket} @param port: A port number to which the adopted socket will be bound. @type port: C{int} @param interface: The local IPv4 or IPv6 address to which the adopted socket will be bound. defaults to '', ie all IPv4 addresses. @type interface: C{str} @see: L{twisted.internet.IReactorSocket.adoptDatagramPort} for other argument and return types. �:r � Fz'Reactor does not provide IReactorSocket)r � providedByr r � getaddrinfo�AF_INETr\ r � setblocking�adoptDatagramPort�fileno�familyr r ) r) r7 r8 r4 rZ r� �domainrz �portSockr r r! r2 � s$ � � z(UDPFDServerTestsBuilder.getListeningPortNr� )r+ r, r- rU r r� r2 r r r r! r� � s �r� )/rU r �zope.interfacer �zope.interface.verifyr �twisted.internetr r �twisted.internet.addressr r �twisted.internet.deferr r �twisted.internet.interfacesr r r r �twisted.internet.protocolr �&twisted.internet.test.connectionmixinsr r �#twisted.internet.test.reactormixinsr �twisted.pythonr �twisted.python.logr r �twisted.test.test_udpr r �twisted.trial.unittestr r" r# r& r' rV r� r� �globals�update�makeTestCaseClassesr r r r! �<module> s< Q � �9PK Mb�Z�Ti^N N 6 internet/test/__pycache__/fakeendpoint.cpython-310.pycnu �[��� o �b � @ s� d Z ddlmZ ddlmZmZmZmZ ddlm Z ee �G dd� d��Z ee�G dd� de ��Z ee�G d d � d e ��Z G d d � d �Z ee�G d d� de ��Zee�G dd� de ��Ze d�Ze d�Ze d�ZdS )zM Fake client and server endpoint string parser plugins for testing purposes. � )� implementer)�IStreamClientEndpoint�,IStreamClientEndpointStringParserWithReactor�IStreamServerEndpoint�!IStreamServerEndpointStringParser)�IPluginc @ � e Zd Zdd� ZdS )� PluginBasec C s || _ d S �N)�prefix)�self�pfx� r �D/usr/lib/python3/dist-packages/twisted/internet/test/fakeendpoint.py�__init__ s zPluginBase.__init__N��__name__� __module__� __qualname__r r r r r r � r c @ r )�FakeClientParserWithReactorc O � t | ||�S r )� StreamClient�r �a�kwr r r �parseStreamClient � z-FakeClientParserWithReactor.parseStreamClientN)r r r r r r r r r r r c @ r )� FakeParserc O r r )� StreamServerr r r r �parseStreamServer# r z FakeParser.parseStreamServerN)r r r r r r r r r ! r r c @ r )� EndpointBasec C s || _ || _|| _d S r )�parser�args�kwargs)r r" r# r$ r r r r ( s zEndpointBase.__init__Nr r r r r r! ' s r! c @ � e Zd Zddd�ZdS )r Nc C � d S r r �r �protocolFactoryr r r �connect0 � zStreamClient.connectr )r r r r) r r r r r . � r c @ r% )r Nc C r& r r r' r r r �listen7 r* zStreamServer.listenr )r r r r, r r r r r 5 r+ r �fake�crfake�cpfakeN)�__doc__�zope.interface.declarationsr �twisted.internet.interfacesr r r r �twisted.pluginr r r r r! r r r- �fakeClientWithReactor�"fakeClientWithReactorAndPreferencer r r r �<module> s$ PK Mb�Z �� 3 internet/test/__pycache__/test_main.cpython-310.pycnu �[��� o �b3 � @ sJ d Z ddlmZ ddlmZ ddlmZ ddlmZ G dd� dej �Z dS ) z% Tests for L{twisted.internet.main}. � )� ReactorAlreadyInstalledError)�installReactor)� NoReactor)�unittestc @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �InstallReactorTestsz& Tests for L{installReactor}. c C sR t � � t� }t|� ddlm} | �||� W d � dS 1 s"w Y dS )zN L{installReactor} installs a new reactor if none is present. r )�reactorN)r �objectr �twisted.internetr �assertIs)�self� newReactorr � r �A/usr/lib/python3/dist-packages/twisted/internet/test/test_main.py�test_installReactor s "�z'InstallReactorTests.test_installReactorc C sF t � � tt� � | �ttt� � W d � dS 1 s w Y dS )zv If a reactor is already installed, L{installReactor} raises L{ReactorAlreadyInstalledError}. N)r r r � assertRaisesr �r r r r �test_alreadyInstalled s "�z)InstallReactorTests.test_alreadyInstalledc C s | � ttt�� dS )zo For backwards compatibility, L{ReactorAlreadyInstalledError} is an L{AssertionError}. N)� assertTrue� issubclassr �AssertionErrorr r r r � test_errorIsAnAssertionError( s z0InstallReactorTests.test_errorIsAnAssertionErrorN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r N) r �twisted.internet.errorr �twisted.internet.mainr �#twisted.internet.test.modulehelpersr � twisted.trialr �SynchronousTestCaser r r r r �<module> s PK Mb�Z6�� � C internet/test/__pycache__/process_gireactornocompat.cpython-310.pycnu �[��� o �b0 � @ s� d dl Z d dlmZ d dlmZ ejg i d�e_ed�ZejD ]Z e je dur:e j � de e jd f � e � d � q zd dl Z W n eyQ e j � d� Y dS w e j � d e j� d �� dS ) � N)�modules)� requireModule)� moduleDictztwisted.internet.gireactorz/failure, sys.modules[%r] is %r, instead of None�gobject�successz failure: z was imported)�sys�twisted.pythonr �twisted.python.reflectr � PythonPath� theSystemPath� gireactor�_PYGTK_MODULES�name�stdout�write�exitr � ImportError�__path__� r r �Q/usr/lib/python3/dist-packages/twisted/internet/test/process_gireactornocompat.py�<module> s( �� � �PK Mb�Zl[:�p8 p8 7 internet/test/__pycache__/test_inlinecb.cpython-310.pycnu �[��� o �b�, � @ s� d Z ddlmZmZmZmZ ddlmZmZ G dd� de�Z G dd� de�Z G dd � d e�Z G d d � d e �Z G d d � d e �ZG dd� de �ZG dd� de�ZdS )z� Tests for L{twisted.internet.defer.inlineCallbacks}. Some tests for inlineCallbacks are defined in L{twisted.test.test_defgen} as well. � )�CancelledError�Deferred�inlineCallbacks� returnValue)�SynchronousTestCase�TestCasec @ � e Zd ZdZdd� ZdS )�StopIterationReturnTestsz� On Python 3.4 and newer generator functions may use the C{return} statement with a value, which is attached to the L{StopIteration} exception that is raised. L{inlineCallbacks} will use this value when it fires the C{callback}. c C sD dt i}td|� t� }|d |�}|�d� | �| �|�d� dS )z� If the C{return} statement has a value it is propagated back to the L{Deferred} that the C{inlineCallbacks} function returned. r z> @inlineCallbacks def f(d): yield d return 14 �fN� )r �execr �callback� assertEqual�successResultOf)�self�environ�d1�d2� r �E/usr/lib/python3/dist-packages/twisted/internet/test/test_inlinecb.py�test_returnWithValue s � z-StopIterationReturnTests.test_returnWithValueN)�__name__� __module__� __qualname__�__doc__r r r r r r s r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �NonLocalExitTestsa� It's possible for L{returnValue} to be (accidentally) invoked at a stack level below the L{inlineCallbacks}-decorated function which it is exiting. If this happens, L{returnValue} should report useful errors. If L{returnValue} is invoked from a function not decorated by L{inlineCallbacks}, it will emit a warning if it causes an L{inlineCallbacks} function further up the stack to exit. c C s t d� dS )z� This method mistakenly invokes L{returnValue}, despite the fact that it is not decorated with L{inlineCallbacks}. � N)r �r r r r �mistakenMethod? s z NonLocalExitTests.mistakenMethodc C sZ | � |dg� | j| jgd�}| � t|�d� | � |d d t� | � |d d d� dS )ac Flush the current warnings and assert that we have been told that C{mistakenMethod} was invoked, and that the result from the Deferred that was fired (appended to the given list) is C{mistakenMethod}'s result. The warning should indicate that an inlineCallbacks function called 'inline' was made to exit. r )�offendingFunctionsr �category�messagez�returnValue() in 'mistakenMethod' causing 'inline' to exit: returnValue should only be invoked by functions decorated with inlineCallbacksN)r � flushWarningsr �len�DeprecationWarning)r � resultList�warningsr r r �assertMistakenMethodWarningF s �z-NonLocalExitTests.assertMistakenMethodWarningc s4 t � fdd��}|� }g }|�|j� � �|� dS )z� L{returnValue} will emit a non-local exit warning in the simplest case, where the offending function is invoked immediately. c 3 s � � � � td� dV d S )N� r �r r r r r r �inline_ s � zANonLocalExitTests.test_returnValueNonLocalWarning.<locals>.inlineN)r � addCallback�appendr' )r r* �d�resultsr r r � test_returnValueNonLocalWarningY s z1NonLocalExitTests.test_returnValueNonLocalWarningc sR t � � t� �fdd��}|� }g }|�|j� ��|g � � �d� ��|� dS )z� L{returnValue} will emit a non-local warning in the case where the L{inlineCallbacks}-decorated function has already yielded a Deferred and therefore moved its generator function along. c 3 s � � V �� � td� d S )Nr( r) r ��causer r r r* r s � zBNonLocalExitTests.test_returnValueNonLocalDeferred.<locals>.inliner N)r r r+ r, r r r' )r r* �effectr. r r0 r � test_returnValueNonLocalDeferredj s z2NonLocalExitTests.test_returnValueNonLocalDeferredN)r r r r r r' r/ r3 r r r r r 4 s r c @ s e Zd Zdd� Zdd� ZdS )�ForwardTraceBackTestsc s\ t dd� �� t � fdd��}|� }| �|�}|�� }| �d|� | �d|� | �d|� dS ) z� Chained inlineCallbacks are forwarding the traceback information from generator to generator. A first simple test with a couple of inline callbacks. c s � � dV t d���Nzforcing generator� Error Marker�� Exceptionr r r r �erroring� � �z>ForwardTraceBackTests.test_forwardTracebacks.<locals>.erroringc 3 � � � � V d S �Nr r �r: r r �calling� � � z=ForwardTraceBackTests.test_forwardTracebacks.<locals>.calling� in erroring� in callingr7 N)r �failureResultOf� getTraceback�assertIn�r r? r- r �tbr r> r �test_forwardTracebacks� s z,ForwardTraceBackTests.test_forwardTracebacksc s� t dd� ��t �fdd���t �fdd��� t � fdd��}|� }| �|�}|�� }| �d |� | �d |� | �d |� | �d |� | �d |� | �d|� | �d |�� � dS )a� Several Chained inlineCallbacks gives information about all generators. A wider test with a 4 chained inline callbacks. Application stack-trace should be reported, and implementation details like "throwExceptionIntoGenerator" symbols are omitted from the stack. Note that the previous test is testing the simple case, and this one is testing the deep recursion case. That case needs specific code in failure.py to accomodate to stack breakage introduced by throwExceptionIntoGenerator. Hence we keep the two tests in order to sort out which code we might have regression in. c s r5 r6 r8 r r r r r: � r; zDForwardTraceBackTests.test_forwardLotsOfTracebacks.<locals>.erroringc 3 r< r= r r r> r r �calling3� r@ zDForwardTraceBackTests.test_forwardLotsOfTracebacks.<locals>.calling3c 3 r< r= r r )rI r r �calling2� r@ zDForwardTraceBackTests.test_forwardLotsOfTracebacks.<locals>.calling2c 3 r< r= r r )rJ r r r? � r@ zCForwardTraceBackTests.test_forwardLotsOfTracebacks.<locals>.callingrA rB z in calling2z in calling3�throwExceptionIntoGeneratorr7 N)r rC rD rE � assertNotInrF r )rJ rI r: r � test_forwardLotsOfTracebacks� s$ z2ForwardTraceBackTests.test_forwardLotsOfTracebacksN)r r r rH rM r r r r r4 � s r4 c @ � e Zd ZdZdS )�UntranslatedErrorzL Untranslated exception type when testing an exception translation. N�r r r r r r r r rO � � rO c @ rN )�TranslatedErrorzJ Translated exception type when testing an exception translation. NrP r r r r rR � rQ rR c @ r )�DontFailz Sample exception type. c C s t �| � || _d S r= )r9 �__init__� actualValue)r �actualr r r rT � s zDontFail.__init__N)r r r r rT r r r r rS � s rS c @ sh e Zd ZdZdd� Zdd� Zeddd��Zd d � Zdd d �Z d d� Z dd� Z dd� Z dd� Z dd� ZdS )�CancellationTestsa! Tests for cancellation of L{Deferred}s returned by L{inlineCallbacks}. For each of these tests, let: - C{G} be a generator decorated with C{inlineCallbacks} - C{D} be a L{Deferred} returned by C{G} - C{C} be a L{Deferred} awaited by C{G} with C{yield} c C s g | _ dS )z> Set up the list of outstanding L{Deferred}s. N)�deferredsOutstandingr r r r �setUp� s zCancellationTests.setUpc C s | j r | �� | j sdS dS )zG If any L{Deferred}s are still outstanding, fire them. N)rX �deferredGottenr r r r �tearDown� s �zCancellationTests.tearDownNc c sn � |du r| j }z|� V }W n ty t� � ty. } z |jd }W Y d}~nd}~ww t|d � dS )z� Generator for testing cascade cancelling cases. @param getChildDeferred: Some callable returning L{Deferred} that we awaiting (with C{yield}) Nr( r )� getDeferredrO rR rS rU r )r �getChildDeferred�x�dfr r r �sampleInlineCB� s � ��z CancellationTests.sampleInlineCBc C s | j �t� � | j d S )z� A sample function that returns a L{Deferred} that can be fired on demand, by L{CancellationTests.deferredGotten}. @return: L{Deferred} that can be fired on demand. ���)rX r, r r r r r r\ s z CancellationTests.getDeferredc C s | j �d��|� dS )z� Fire the L{Deferred} returned from the least-recent call to L{CancellationTests.getDeferred}. @param result: result object to be used when firing the L{Deferred}. r N)rX �popr )r �resultr r r rZ s z CancellationTests.deferredGottenc sJ dg� � fdd�}| j |d�}|�dd� � |�� | �� d td� d S ) zN When C{D} cancelled, C{C} will be immediately cancelled too. �FAILUREc s t � } � fdd�}| �|� | S )Nc s | � t�� d< | S )Nr )�checkr �rc ��childResultHolderr r �_eb# s zWCancellationTests.test_cascadeCancellingOnCancel.<locals>.getChildDeferred.<locals>._eb�r � addErrback)r- ri rg r r r] s zJCancellationTests.test_cascadeCancellingOnCancel.<locals>.getChildDeferred�r] c S s d S r= r rf r r r �<lambda>+ � zBCancellationTests.test_cascadeCancellingOnCancel.<locals>.<lambda>r z no cascade cancelling occursN)r` rk �cancelr r )r r] r- r rg r � test_cascadeCancellingOnCancel s �z0CancellationTests.test_cascadeCancellingOnCancelc C s( | � � }|�� | �t| �|�j� dS )zg When C{D} cancelled, CancelledError from C{C} will be errbacked through C{D}. N)r` ro � assertRaisesr rC �raiseException)r r- r r r �"test_errbackCancelledErrorOnCancel3 s �z4CancellationTests.test_errbackCancelledErrorOnCancelc sB dd� }t |�� | �� fdd��}|�� | �t| �|�j� dS )z� When C{D} is cancelled, and C raises a particular type of error, C{G} may catch that error at the point of yielding and translate it into a different error which may be received by application code. c S s | � t� � d S r= )�errbackrO ��itr r r ro F s z>CancellationTests.test_errorToErrorTranslation.<locals>.cancelc � � S r= r r ��ar r rm J rn z@CancellationTests.test_errorToErrorTranslation.<locals>.<lambda>N)r r` ro rq rR rC rr )r ro r- r rx r � test_errorToErrorTranslation? s �z.CancellationTests.test_errorToErrorTranslationc sL dd� }t |�� | �� fdd��}g }|�|j� |�� | �|dg� dS )z� When C{D} is cancelled, and C{C} raises a particular type of error, C{G} may catch that error at the point of yielding and translate it into a result value which may be received by application code. c S s | � td�� d S )Ni� )rt rS ru r r r ro X s z@CancellationTests.test_errorToSuccessTranslation.<locals>.cancelc rw r= r r rx r r rm \ rn zBCancellationTests.test_errorToSuccessTranslation.<locals>.<lambda>i� N)r r` r+ r, ro � assertEquals)r ro r- r. r rx r � test_errorToSuccessTranslationQ s z0CancellationTests.test_errorToSuccessTranslationc s\ t � ��fdd�� � fdd�}| j|d�}|�� | �|� ��d� | �| �|�d� dS ) a" When C{D} is cancelled, it won't reach the callbacks added to it by application code until C{C} reaches the point in its callback chain where C{G} awaits it. Otherwise, application code won't be able to track resource usage that C{D} may be using. c s | � t� � S r= )�trapr rf )� moreDeferredr r � deferMeMorek s zDCancellationTests.test_asynchronousCancellation.<locals>.deferMeMorec s t � } | �� � | S r= rj )r- )r r r �deferMeo s z@CancellationTests.test_asynchronousCancellation.<locals>.deferMerl i� i� N)r r` ro �assertNoResultr r r )r r� r- r )r r~ r � test_asynchronousCancellationb s z/CancellationTests.test_asynchronousCancellationr= )r r r r rY r[ r r` r\ rZ rp rs rz r| r� r r r r rW � s rW N)r �twisted.internet.deferr r r r �twisted.trial.unittestr r r r r4 r9 rO rR rS rW r r r r �<module> s LI PK Mb�Z�\B8 B8 4 internet/test/__pycache__/test_fdset.cpython-310.pycnu �[��� o �b�4 � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl m Z m Z ddl mZmZ ddlmZ dd lmZ dd lmZ d d � ZG d d� de�Zee �G dd� d��Ze� �e�� � dS )z0 Tests for implementations of L{IReactorFDSet}. � N)�skipIf)� implementer)�FileDescriptor)� IReactorFDSet�IReadDescriptor)� EINPROGRESS� EWOULDBLOCK)�ReactorBuilder)�platform)�SkipTestc C s� t � � } | �d� | �d� zQt � � }z7|�d� z |�d| �� d f� W n tyB } z|jd tt fvr8� W Y d }~nd }~ww | � � \}}W n t yV |� � � w W | � � ||fS | � � w )N)� 127.0.0.1r � Fr r ) �socket�bind�listen� setblocking�connect� getsockname�OSError�argsr r �accept� BaseException�close)� serverSocket�client�e�server�addr� r �B/usr/lib/python3/dist-packages/twisted/internet/test/test_fdset.py� socketpair s0 ��� �� �r c @ s� e Zd ZdZegZdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zee�� d�dd � �Zd d � Zd S ) �ReactorFDSetTestsBuilderz> Builder defining tests relating to L{IReactorFDSet}. c C s* t � \}}| �|j� | �|j� ||fS )zL Return the two sockets which make up a new TCP connection. )r � addCleanupr )�selfr r r r r �_connectedPair8 s z'ReactorFDSetTestsBuilder._connectedPairc C s. | � � }| �� \}}t|�}|j|_|||fS �N)� buildReactorr$ r �fileno)r# �reactorr r �fdr r r � _simpleSetupA s z%ReactorFDSetTestsBuilder._simpleSetupc sD | � � \�� }� �fdd�}|� _��� � |�d� | ��� dS )z� C{reactor.addReader()} accepts an L{IReadDescriptor} provider and calls its C{doRead} method when there may be data available on its C{fileno}. c � �� � � ��� d S r% )� removeReader�stopr �r) r( r r � removeAndStopR � z>ReactorFDSetTestsBuilder.test_addReader.<locals>.removeAndStop� xN)r* �doRead� addReader�sendall� runReactor�r# r r/ r r. r �test_addReaderK s z'ReactorFDSetTestsBuilder.test_addReaderc s` � � � \}}}� fdd�}||_|�|� |�|� |�d� |�d|jd|j� � �|� dS )z� L{reactor.removeReader()} accepts an L{IReadDescriptor} provider previously passed to C{reactor.addReader()} and causes it to no longer be monitored for input events. c � � � d� d S �NzdoRead should not be called��failr �r# r r r; f � z8ReactorFDSetTestsBuilder.test_removeReader.<locals>.failr1 r N)r* r2 r3 r, r4 � callLaterr- r5 �r# r( r) r r; r r< r �test_removeReader^ s z*ReactorFDSetTestsBuilder.test_removeReaderc s: | � � \�� }� �fdd�}|� _��� � | ��� dS )z� C{reactor.addWriter()} accepts an L{IWriteDescriptor} provider and calls its C{doWrite} method when it may be possible to write to its C{fileno}. c r+ r% )� removeWriterr- r r. r r r/ ~ r0 z>ReactorFDSetTestsBuilder.test_addWriter.<locals>.removeAndStopN)r* �doWrite� addWriterr5 r6 r r. r �test_addWriterv s z'ReactorFDSetTestsBuilder.test_addWriterc C s� | � � }t|d| d �}t|d| �}t|d| �}| �� \}}| �||� � | �||� � ||� | �||� � | �||� � ||� | �||� � | �||� � dS )z= Helper for getReaders and getWriters tests. �get�s�add�removeN)r& �getattrr$ � assertNotIn�assertIn)r# �kindr( rE rG rH r r r r r � _getFDTest� s z#ReactorFDSetTestsBuilder._getFDTestc C � | � d� dS )z� L{IReactorFDSet.getReaders} reflects the additions and removals made with L{IReactorFDSet.addReader} and L{IReactorFDSet.removeReader}. �ReaderN�rM r< r r r �test_getReaders� � z(ReactorFDSetTestsBuilder.test_getReadersc sV � � � \}}}� fdd�}||_|�|� |�|� |�d|jd|j� � �|� dS )z� L{reactor.removeWriter()} accepts an L{IWriteDescriptor} provider previously passed to C{reactor.addWriter()} and causes it to no longer be monitored for outputability. c r8 �Nz doWrite should not be calledr: r r< r r r; � r= z8ReactorFDSetTestsBuilder.test_removeWriter.<locals>.failr N)r* rB rC rA r> r- r5 r? r r< r �test_removeWriter� s z*ReactorFDSetTestsBuilder.test_removeWriterc C rN )z� L{IReactorFDSet.getWriters} reflects the additions and removals made with L{IReactorFDSet.addWriter} and L{IReactorFDSet.removeWriter}. �WriterNrP r< r r r �test_getWriters� rR z(ReactorFDSetTestsBuilder.test_getWritersc s� � � � }� �� \}}}� fdd�|_� fdd�|_|�d� |�|� |�|� |�� }|�d|jd|j � � � |� � � ||g� dS )z� C{reactor.removeAll()} removes all registered L{IReadDescriptor} providers and all registered L{IWriteDescriptor} providers and returns them. c � � � d�S r9 r: r r< r r �<lambda>� � z9ReactorFDSetTestsBuilder.test_removeAll.<locals>.<lambda>c rW rS r: r r< r r rX � rY r1 r N) r& r* r2 rB r4 r3 rC � removeAllr> r- r5 � assertEqual)r# r( r) r �removedr r< r �test_removeAll� s z'ReactorFDSetTestsBuilder.test_removeAllc C s8 | � � }t|�}|�|j� | �|� | �|jg � dS )z� A descriptor's C{fileno} method should not be called after the descriptor has been removed from the reactor. N)r& �RemovingDescriptor�callWhenRunning�startr5 r[ �calls)r# r( � descriptorr r r �test_removedFromReactor� s z0ReactorFDSetTestsBuilder.test_removedFromReactorc sd | � � �| �� \� �G � ��fdd�dt�}|��}��|� � �d� | ��� | �|jd� dS )zp If L{FileDescriptor.fileno} returns C{-1}, the descriptor is removed from the reactor. c s: e Zd Z��� ZdZdd� Z� �fdd�Z�fdd�ZdS ) zWReactorFDSetTestsBuilder.test_negativeOneFileDescriptor.<locals>.DisappearingDescriptor� c S s | j S r% )�_filenor< r r r r' � s z^ReactorFDSetTestsBuilder.test_negativeOneFileDescriptor.<locals>.DisappearingDescriptor.filenoc s( d| _ | j��d�7 _� �d� d S )N���r � y)re � _received�recv�sendr< )r r r r r2 � s z^ReactorFDSetTestsBuilder.test_negativeOneFileDescriptor.<locals>.DisappearingDescriptor.doReadc s � � � d S r% �r- �r# �reason�r( r r �connectionLost s zfReactorFDSetTestsBuilder.test_negativeOneFileDescriptor.<locals>.DisappearingDescriptor.connectionLostN)�__name__� __module__� __qualname__r' re rh r2 ro r �r r( r r r �DisappearingDescriptor� s rt r1 N)r& r$ r r3 rj r5 r[ rh )r# rt rb r rs r � test_negativeOneFileDescriptor� s z7ReactorFDSetTestsBuilder.test_negativeOneFileDescriptorz*Cannot duplicate socket filenos on Windowsc s� �� � � � jj}|dv rt|�d������ \}�G � �fdd�dt�}� �|� � ��fdd�}� �d|� ��� � �� t j � dS ) a The file descriptor underlying a FileDescriptor may be closed and replaced by another at some point. Bytes which arrive on the new descriptor must not be delivered to the FileDescriptor which was originally registered with the original descriptor of the same number. Practically speaking, this is difficult or impossible to detect. The implementation relies on C{fileno} raising an exception if the original descriptor has gone away. If C{fileno} continues to return the original file descriptor value, the reactor may deliver events from that descriptor. This is a best effort attempt to ease certain debugging situations. Applications should not rely on it intentionally. )� EPollReactor� KQueueReactor� CFReactor�AsyncioSelectorReactorz$ cannot detect lost file descriptorsc s0 e Zd ZdZ�fdd�Zdd� Z� fdd�ZdS ) z@ReactorFDSetTestsBuilder.test_lostFileDescriptor.<locals>.Victima� This L{FileDescriptor} will have its socket closed out from under it and another socket will take its place. It will raise a socket.error from C{fileno} after this happens (because socket objects remember whether they have been closed), so as long as the reactor calls the C{fileno} method the problem will be detected. c s � � � S r% )r' r< )r r r r' 3 � zGReactorFDSetTestsBuilder.test_lostFileDescriptor.<locals>.Victim.filenoc S s t d��)Nz$Victim.doRead should never be called)� Exceptionr< r r r r2 6 rz zGReactorFDSetTestsBuilder.test_lostFileDescriptor.<locals>.Victim.doReadc s � � � dS )z� When the problem is detected, the reactor should disconnect this file descriptor. When that happens, stop the reactor so the test ends. Nrk rl rn r r ro 9 s zOReactorFDSetTestsBuilder.test_lostFileDescriptor.<locals>.Victim.connectionLostN)rp rq rr �__doc__r' r2 ro r )r( r r r �Victim* s r} c s: � � � \} }��� }��� t�|�� |� | �d� d S )Nr1 )r$ r' r �os�dup2rj )�newC�newSr' )r# r r r �messItUpH s zBReactorFDSetTestsBuilder.test_lostFileDescriptor.<locals>.messItUpr N) r& � __class__rp r r$ r r3 r> r5 �flushLoggedErrorsr �error)r# �namer r} r� r )r( r# r r �test_lostFileDescriptor s z0ReactorFDSetTestsBuilder.test_lostFileDescriptorc C s� | � � }G dd� dt�}| �� \}}||�}|j|_||�}|j|_|�|� |�|� |�|j� | �|� | � |j � | � |j � dS )z� Any file descriptors added to the reactor have their C{connectionLost} called when C{reactor.stop} is called. c @ s e Zd Zdd� Zdd� ZdS )zSReactorFDSetTestsBuilder.test_connectionLostOnShutdown.<locals>.DoNothingDescriptorc S � d S r% r r< r r r r2 _ � zZReactorFDSetTestsBuilder.test_connectionLostOnShutdown.<locals>.DoNothingDescriptor.doReadc S r� r% r r< r r r rB b r� z[ReactorFDSetTestsBuilder.test_connectionLostOnShutdown.<locals>.DoNothingDescriptor.doWriteN)rp rq rr r2 rB r r r r �DoNothingDescriptor^ s r� N) r& r r$ r' r3 rC r_ r- r5 � assertTrue� disconnected)r# r( r� r r �fd1�fd2r r r � test_connectionLostOnShutdownW s z6ReactorFDSetTestsBuilder.test_connectionLostOnShutdownN)rp rq rr r| r �requiredInterfacesr$ r* r7 r@ rD rM rQ rT rV r] rc ru r r � isWindowsr� r� r r r r r! 1 s$ Lr! c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )r^ a� A read descriptor which removes itself from the reactor as soon as it gets a chance to do a read and keeps track of when its own C{fileno} method is called. @ivar insideReactor: A flag which is true as long as the reactor has this descriptor as a reader. @ivar calls: A list of the bottom of the call stack for any call to C{fileno} when C{insideReactor} is false. c C s$ || _ d| _g | _t� \| _| _d S �NF)r( � insideReactorra r �read�write)r# r( r r r �__init__� s zRemovingDescriptor.__init__c C s" d| _ | j�| � | j�d� d S )NT� a)r� r( r3 r� rj r< r r r r` � s zRemovingDescriptor.startc C s dS )N�foor r< r r r � logPrefix� r� z RemovingDescriptor.logPrefixc C s4 | j �| � d| _| j �� | j�� | j�� d S r� )r( r, r� r- r� r r� r< r r r r2 � s zRemovingDescriptor.doReadc C s, | j s| j�tjdd�d d� � | j�� S )N� )�limitrf )r� ra �append� traceback� extract_stackr� r' r< r r r r' � s zRemovingDescriptor.filenoc C r� r% r rl r r r ro � s z!RemovingDescriptor.connectionLostN) rp rq rr r| r� r` r� r2 r' ro r r r r r^ t s r^ ) r| r~ r r� �unittestr �zope.interfacer �twisted.internet.abstractr �twisted.internet.interfacesr r �twisted.internet.tcpr r �#twisted.internet.test.reactormixinsr �twisted.python.runtimer �twisted.trial.unittestr r r! r^ �globals�update�makeTestCaseClassesr r r r �<module> s& E.PK Mb�Z�7�u� � 7 internet/test/__pycache__/test_glibbase.cpython-310.pycnu �[��� o �b� � @ s8 d Z ddlZddlmZ ddlmZ G dd� de�ZdS )z& Tests for twisted.internet.glibbase. � N)�ensureNotImported)�TestCasec @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �EnsureNotImportedTestszQ L{ensureNotImported} protects against unwanted past and future imports. c C s@ i }| � td|� tddgdg d�d� | �|dddd�� dS )z� If the specified modules have never been imported, and import prevention is requested, L{ensureNotImported} makes sure they will not be imported in the future. �modules�m1�m2� A message.)r r �m3��preventImportsN��patch�sysr � assertEqual��selfr � r �E/usr/lib/python3/dist-packages/twisted/internet/test/test_glibbase.py�test_ensureWhenNotImported s z1EnsureNotImportedTests.test_ensureWhenNotImportedc C s0 i }| � td|� tddgd� | �|i � dS )z� If the specified modules have never been imported, and import prevention is not requested, L{ensureNotImported} has no effect. r r r r Nr r r r r �%test_ensureWhenNotImportedDontPrevent s z<EnsureNotImportedTests.test_ensureWhenNotImportedDontPreventc C sB ddi}| � td|� tddgdddgd� | �|ddd�� dS )z� If the specified modules have been set to L{None} in C{sys.modules}, L{ensureNotImported} does not complain. r Nr r r r )r r r r r r r � test_ensureWhenFailedToImport) s z4EnsureNotImportedTests.test_ensureWhenFailedToImportc C sZ t � }d|i}| �td|� | jttddgdddgd�}| �|d|i� | �|jd� dS )z� If one of the specified modules has been previously imported, L{ensureNotImported} raises an exception. r r r r r )r N)�objectr r � assertRaises� ImportErrorr r �args)r �moduler �er r r � test_ensureFailsWhenImported3 s �z3EnsureNotImportedTests.test_ensureFailsWhenImportedN)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s r )r! r �twisted.internet._glibbaser �twisted.trial.unittestr r r r r r �<module> s PK Mb�Z̝]�� � 9 internet/test/__pycache__/test_serialport.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ zddl m Z W n e y- dZ Y nw e Z G dd � d �Z G d d � d ej�ZdS ) z+ Tests for L{twisted.internet.serialport}. � )�ConnectionDone)�Protocol)�Failure)�unittest)� serialportNc @ s e Zd ZdZdd� Zdd� ZdS )� DoNothingz. Object with methods that do nothing. c O � d S �N� )�self�args�kwargsr r �G/usr/lib/python3/dist-packages/twisted/internet/test/test_serialport.py�__init__ � zDoNothing.__init__c C s dd� S )Nc _ r r r )r r r r r �<lambda> s z'DoNothing.__getattr__.<locals>.<lambda>r )r �attrr r r � __getattr__ s zDoNothing.__getattr__N)�__name__� __module__� __qualname__�__doc__r r r r r r r s r c @ s$ e Zd ZdZedu r dZdd� ZdS )�SerialPortTestszt Minimal testing for Twisted's serial port support. See ticket #2462 for the eventual full test suite. Nz%Serial port support is not available.c sv G dd� dt j�}g � G � fdd�dt�}||� dt� d�}| �� dg� tt� �}|�|� | �� dd|fg� d S ) zr C{connectionMade} and C{connectionLost} are called on the protocol by the C{SerialPort}. c @ s e Zd ZeZdd� ZdS )z@SerialPortTests.test_connectionMadeLost.<locals>.DummySerialPortc S r r r �r r r r �_finishPortSetup4 r zQSerialPortTests.test_connectionMadeLost.<locals>.DummySerialPort._finishPortSetupN)r r r r �_serialFactoryr r r r r �DummySerialPort1 s r c s$ e Zd Z� fdd�Z� fdd�ZdS )z?SerialPortTests.test_connectionMadeLost.<locals>.SerialProtocolc s � � d� d S )N�connectionMade��appendr ��eventsr r r : s zNSerialPortTests.test_connectionMadeLost.<locals>.SerialProtocol.connectionMadec s � � d|f� d S )N�connectionLostr )r �reasonr r r r" = s zNSerialPortTests.test_connectionMadeLost.<locals>.SerialProtocol.connectionLostN)r r r r r" r r r r �SerialProtocol9 s r$ � )�reactorr r" N)r � SerialPortr r � assertEqualr r r" )r r r$ �port�fr r r �test_connectionMadeLost+ s z'SerialPortTests.test_connectionMadeLost)r r r r r �skipr+ r r r r r ! s r )r �twisted.internet.errorr �twisted.internet.protocolr �twisted.python.failurer � twisted.trialr �twisted.internetr � _serialport� ImportErrorr �TestCaser r r r r �<module> s � PK Mb�Z�o\.68 68 2 internet/test/__pycache__/test_tls.cpython-310.pycnu �[��� o �b%4 � @ s0 d Z ddlmZmZmZ ddlmZmZ ddlm Z m Z ddl m Z m Z mZ ddlmZ ddlmZmZmZ ddlmZmZmZ dd lmZ dd lm Z m Z m Z dd l m Z dd l!m"Z"m#Z#m$Z$ dd l%m&Z& ddl'm(Z( ddl)m*Z* ddl+m,Z, zddl-m.Z. W n e/y� dZ.Y n w ddl0m1Z1m2Z2m3Z3 G dd� d�Z4G dd� d�Z5ee�G dd� d��Z6G dd� de e5�Z7G d d � d �Z8G d d � d e4e e �Z9G d d!� d!e e5�Z:G d"d#� d#e4e e5e e8�Z;G d$d%� d%e4e5e8e#e$e �Z<e=� �>e;�?� � e=� �>e9�?� � e=� �>e<� �?� � G d&d'� d'e e"e5�Z@e=� �>e@�?� � dS )(z0 Tests for implementations of L{ITLSTransport}. � )�Optional�Sequence�Type)� Interface� implementer)�Deferred� DeferredList)�SSL4ClientEndpoint�SSL4ServerEndpoint�TCP4ClientEndpoint)�ConnectionClosed)� IReactorSSL�IStreamClientEndpoint� ITLSTransport)� ClientFactory�Protocol� ServerFactory)� Cooperator)�BrokenContextFactory�ConnectionTestsMixin�EndpointCreator)�ReactorBuilder)�AbortConnectionMixin�ConnectToTCPListenerMixin�StreamTransportTestsMixin)� networkString)�FilePath)�platform)�SkipTest)� FILETYPE_PEMN)�ClientContextFactory�KeyPair�PrivateCertificatec @ sB e Zd ZU egZeeee e d< e � � r dZ e e d�Z dS dS )�TLSMixin�requiredInterfaceszcFor some reason, these reactors don't deal with SSL disconnection correctly on Windows. See #3371.)z*twisted.internet.glib2reactor.Glib2Reactorz(twisted.internet.gtk2reactor.Gtk2ReactorN)�__name__� __module__� __qualname__r r$ r r r r �__annotations__r � isWindows�msg�skippedReactors� r, r, �@/usr/lib/python3/dist-packages/twisted/internet/test/test_tls.pyr# 3 s � ��r# c @ s@ e Zd ZddlZeeej���d��d�Z [dd� Z dd� Z dS ) �ContextGeneratingMixinr Ns tests server.pemc C s( | j �� }t�|t�|t�t�}|�� S )zM Return a new SSL context suitable for use in a test server. )�_pem� getContentr" �loadr! r �options)�self�pem�certr, r, r- �getServerContextI s �z'ContextGeneratingMixin.getServerContextc C s t � S �N)r �r3 r, r, r- �getClientContextS s z'ContextGeneratingMixin.getClientContext) r% r& r' �twistedr r �__file__�sibling�childr/ r6 r9 r, r, r, r- r. A s � r. c @ � e Zd ZdZdd� Zdd� ZdS )�StartTLSClientEndpointa! An endpoint which wraps another one and adds a TLS layer immediately when connections are set up. @ivar wrapped: A L{IStreamClientEndpoint} provider which will be used to really set up connections. @ivar contextFactory: A L{ContextFactory} to use to do TLS. c C s || _ || _d S r7 )�wrapped�contextFactory)r3 r@ rA r, r, r- �__init__c s z StartTLSClientEndpoint.__init__c s$ G � �fdd�dt �}�j�|� �S )z� Establish a connection using a protocol build by C{factory} and immediately start TLS on it. Return a L{Deferred} which fires with the protocol instance. c s e Zd Z� �fdd�ZdS )z6StartTLSClientEndpoint.connect.<locals>.WrapperFactoryc s( �� |�� � jf� �fdd� }|� _� S )Nc s � j ��j� | � d S r7 )� transport�startTLSrA )�orig)�protocolr3 r, r- �connectionMades s z\StartTLSClientEndpoint.connect.<locals>.WrapperFactory.buildProtocol.<locals>.connectionMade)� buildProtocolrG )� wrapperSelf�addrrG ��factoryr3 )rF r- rH p s zDStartTLSClientEndpoint.connect.<locals>.WrapperFactory.buildProtocolN)r% r& r' rH r, rK r, r- �WrapperFactoryo s rM )r r@ �connect)r3 rL rM r, rK r- rN g s z StartTLSClientEndpoint.connectN)r% r& r' �__doc__rB rN r, r, r, r- r? W s r? c @ r> )�StartTLSClientCreatorz{ Create L{ITLSTransport.startTLS} endpoint for the client, and normal SSL for server just because it's easier. c C � t |d| �� �S )z� Construct an SSL server endpoint. This should be constructing a TCP server endpoint which immediately calls C{startTLS} instead, but that is hard. r �r r6 �r3 �reactorr, r, r- �server� s z StartTLSClientCreator.serverc C s t t|d|j�t� �S )zS Construct a TCP client endpoint wrapped to immediately start TLS. � 127.0.0.1)r? r �portr �r3 rT � serverAddressr, r, r- �client� s �z StartTLSClientCreator.clientN�r% r& r' rO rU rZ r, r, r, r- rP } s rP c @ s e Zd ZdZdd� ZdS )�BadContextTestsMixinz� Mixin for L{ReactorBuilder} subclasses which defines a helper for testing the handling of broken context factories. c C s0 | � � }| �t||t� �}| �tjt|�� dS )a� Assert that the exception raised by a broken context factory's C{getContext} method is raised by some reactor method. If it is not, an exception will be raised to fail the test. @param useIt: A two-argument callable which will be called with a reactor and a broken context factory and which is expected to raise the same exception as the broken context factory's C{getContext} method. N)� buildReactor� assertRaises� ValueErrorr � assertEqual�message�str)r3 �useItrT �excr, r, r- �_testBadContext� s z$BadContextTestsMixin._testBadContextN)r% r& r' rO re r, r, r, r- r\ � s r\ c @ s e Zd ZdZe� ZdS )�StartTLSClientTestsMixinz� Tests for TLS connections established using L{ITLSTransport.startTLS} (as opposed to L{IReactorSSL.connectSSL} or L{IReactorSSL.listenSSL}). N)r% r& r' rO rP � endpointsr, r, r, r- rf � s rf c @ r> )� SSLCreatorz Create SSL endpoints. c C rQ )zQ Create an SSL server endpoint on a TCP/IP-stack allocated port. r rR rS r, r, r- rU � s zSSLCreator.serverc C s t |d|jt� �S )z� Create an SSL client endpoint which will connect localhost on the port given by C{serverAddress}. @type serverAddress: L{IPv4Address} rV )r rW r rX r, r, r- rZ � s �zSSLCreator.clientNr[ r, r, r, r- rh � s rh c @ s& e Zd ZdZe� Zdd� Zdd� ZdS )�SSLClientTestsMixinz< Mixin defining tests relating to L{ITLSTransport}. c C � dd� }| � |� dS )z� If the context factory passed to L{IReactorSSL.connectSSL} raises an exception from its C{getContext} method, that exception is raised by L{IReactorSSL.connectSSL}. c S s | � ddt� |�S )NrV i� )� connectSSLr �rT rA r, r, r- rc � s �z2SSLClientTestsMixin.test_badContext.<locals>.useItN�re �r3 rc r, r, r- �test_badContext� s z#SSLClientTestsMixin.test_badContextc s G dd� dt �}| �� �t� }t� |_||_| �� |_t� }t� |_||_| � � |_|jj |j_ g � t |j|jgdd�}� fdd�}|� |� �j d|dd �}| �|j� ��|�� j|�� j|�}| �|j� |� �fd d �� | ��� � d �t� � d �t� d S )aO L{ITCPTransport.loseConnection} ends a connection which was set up with L{ITLSTransport.startTLS} and which has recently been written to. This is intended to verify that a socket send error masked by the TLS implementation doesn't prevent the connection from being reported as closed. c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )zQSSLClientTestsMixin.test_disconnectAfterWriteAfterStartTLS.<locals>.ShortProtocolc S sN t �| j�s| jj}d | j_|�td�� d S | j�| jj� | j� d� d S )NzNo ITLSTransport support� x) r � providedByrC rL �finished�errbackr rD �context�write)r3 rr r, r, r- rG � s z`SSLClientTestsMixin.test_disconnectAfterWriteAfterStartTLS.<locals>.ShortProtocol.connectionMadec S s | j �d� | j �� d S )N� y)rC ru �loseConnection)r3 �datar, r, r- � dataReceived� s z^SSLClientTestsMixin.test_disconnectAfterWriteAfterStartTLS.<locals>.ShortProtocol.dataReceivedc S s* | j j}|d urd | j _|�|� d S d S r7 )rL rr �callback)r3 �reasonrr r, r, r- �connectionLost s �z`SSLClientTestsMixin.test_disconnectAfterWriteAfterStartTLS.<locals>.ShortProtocol.connectionLostN)r% r& r' rG ry r| r, r, r, r- � ShortProtocol� s r} T)� consumeErrorsc s" � � | d d | d d g� d S )Nr � )�extend)�results)�lostConnectionResultsr, r- � cbFinished" s "zNSSLClientTestsMixin.test_disconnectAfterWriteAfterStartTLS.<locals>.cbFinishedr rV )� interfacec s � � � S r7 )�stop)�ign�rT r, r- �<lambda>/ s zLSSLClientTestsMixin.test_disconnectAfterWriteAfterStartTLS.<locals>.<lambda>r N)r r] r r rr rF r6 rt r r9 �methodr � addCallback� listenTCP� addCleanup� stopListening� connectTCP�getHost�hostrW � disconnect� runReactor�trapr )r3 r} � serverFactory� clientFactoryrr r� rW � connectorr, )r� rT r- �&test_disconnectAfterWriteAfterStartTLS� s6 ! � � z:SSLClientTestsMixin.test_disconnectAfterWriteAfterStartTLSN)r% r& r' rO rh rg ro r� r, r, r, r- ri � s ri c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �TLSPortTestsBuilderz, Tests for L{IReactorSSL.listenSSL} c C s |� d|| �� �S )z0 Get a TLS port from a reactor. r )� listenSSLr6 )r3 rT rL r, r, r- �getListeningPortA � z$TLSPortTestsBuilder.getListeningPortc C s d||� � jf S )zY Get the message expected to be logged when a TLS port starts listening. z%s (TLS) starting on %d�r� rW )r3 rW rL r, r, r- �#getExpectedStartListeningLogMessageG r� z7TLSPortTestsBuilder.getExpectedStartListeningLogMessagec C s d|� � j� d�S )zJ Get the expected connection lost message for a TLS port. z (TLS Port z Closed)r� )r3 rW r, r, r- � getExpectedConnectionLostLogMsgM r� z3TLSPortTestsBuilder.getExpectedConnectionLostLogMsgc C rj )z� If the context factory passed to L{IReactorSSL.listenSSL} raises an exception from its C{getContext} method, that exception is raised by L{IReactorSSL.listenSSL}. c S s | � dt� |�S )Nr )r� r rl r, r, r- rc Z s z2TLSPortTestsBuilder.test_badContext.<locals>.useItNrm rn r, r, r- ro S s z#TLSPortTestsBuilder.test_badContextc C s |� | j|j|| �� �S )a Connect to the given listening TLS port, assuming the underlying transport is TCP. @param reactor: The reactor under test. @type reactor: L{IReactorSSL} @param address: The listening's address. Only the C{port} component is used; see L{ConnectToTCPListenerMixin.LISTENER_HOST}. @type address: L{IPv4Address} or L{IPv6Address} @param factory: The client factory. @type factory: L{ClientFactory} @return: The connector )rk � LISTENER_HOSTrW r9 )r3 rT �addressrL r, r, r- �connectToListener_ s �z%TLSPortTestsBuilder.connectToListenerN) r% r& r' rO r� r� r� ro r� r, r, r, r- r� 5 s r� c @ s, e Zd ZdZefZe� Zdd� Zdd� Z dS )�AbortSSLConnectionTestsz- C{abortConnection} tests using SSL. c s< t �| �� ddlm} t� fdd�d�}| �|d|j� � S )Nr )�_producer_helpersc s � � d| �S )Ng�h㈵��>)� callLater)�xr� r, r- r� � s z6AbortSSLConnectionTests.buildReactor.<locals>.<lambda>)� scheduler� cooperate)r r] �twisted.internetr� r �patchr� )r3 r� � cooperatorr, r� r- r] � s z$AbortSSLConnectionTests.buildReactorc C s t d u rtd��d S )NzOpenSSL not available.)r r r8 r, r, r- �setUp� s �z AbortSSLConnectionTests.setUpN) r% r& r' rO r r$ rh rg r] r� r, r, r, r- r� ~ s r� )ArO �typingr r r �zope.interfacer r �twisted.internet.deferr r �twisted.internet.endpointsr r r �twisted.internet.errorr �twisted.internet.interfacesr r r �twisted.internet.protocolr r r �twisted.internet.taskr �&twisted.internet.test.connectionmixinsr r r �#twisted.internet.test.reactormixinsr � twisted.internet.test.test_tcpr r r �twisted.python.compatr �twisted.python.filepathr �twisted.python.runtimer �twisted.trial.unittestr �OpenSSL.cryptor � ImportError�twisted.internet.sslr r! r" r# r. r? rP r\ rf rh ri r� �globals�update�makeTestCaseClassesr� r, r, r, r- �<module> sh �% � j�D �PK Mb�Z�~�P�+ �+ ; internet/test/__pycache__/test_posixprocess.cpython-310.pycnu �[��� o �b�+ � @ s� U d Z ddlZddlZddlZddlmZ ee ed< zddlZW n e y, dZ Y n w ddl m Z dZ ddl mZ G dd � d �ZG d d � d �ZG d d � d e�ZG dd� de�ZdS )z; Tests for POSIX-based L{IReactorProcess} implementations. � N)�Optional� platformSkipznon-POSIX platform)�process)�TestCasec @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �FakeFilez> A dummy file object which records when it is closed. c C s || _ || _d S �N)�testcase�fd)�selfr r � r �I/usr/lib/python3/dist-packages/twisted/internet/test/test_posixprocess.py�__init__ s zFakeFile.__init__c C s | j j�| j� d S r )r �_files�remover �r r r r �close$ s zFakeFile.closec C s | S r r r r r r � __enter__' s zFakeFile.__enter__c C s | � � d S r )r )r �exc_type� exc_value� tracebackr r r �__exit__* s zFakeFile.__exit__N)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s r c @ s$ e Zd ZdZdZdd� Zdd� ZdS )�FakeResourceModulez� Fake version of L{resource} which hard-codes a particular rlimit for maximum open files. @ivar _limit: The value to return for the hard limit of number of open files. � c C s || _ d S r )�_limit�r �limitr r r r 8 s zFakeResourceModule.__init__c C s || j kr d| jgS ddgS )zX A fake of L{resource.getrlimit} which returns a pre-determined result. r �{ i� )� RLIMIT_NOFILEr )r �nor r r � getrlimit; s z FakeResourceModule.getrlimitN)r r r r r! r r# r r r r r . s r c @ s� e Zd ZdZeZdZdZdZdd� Z dd� Z dd� Z d d � Z d d � Z d d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �FDDetectorTestsa� Tests for _FDDetector class in twisted.internet.process, which detects which function to drop in place for the _listOpenFDs method. @ivar devfs: A flag indicating whether the filesystem fake will indicate that /dev/fd exists. @ivar accurateDevFDResults: A flag indicating whether the /dev/fd fake returns accurate open file information. @ivar procfs: A flag indicating whether the filesystem fake will indicate that /proc/<pid>/fd exists. Fc C s dS )z> Fake os.getpid, always return the same thing r r r r r r �getpidZ s zFDDetectorTests.getpidc C sN t t| j�}| jr|d| �� f kr|S | jr$|dkr$| jr |S g d�S t� �)z� Fake os.listdir, depending on what mode we're in to simulate behaviour. @param arg: the directory to list z /proc/%d/fdz/dev/fd)�0�1�2)�map�strr �procfsr% �devfs�accurateDevFDResults�OSError)r �arg�accurater r r �listdir` s zFDDetectorTests.listdirc C s2 t | tttd��t| j� ��}| j�|j� |S )aO This is a mock for L{open}. It keeps track of opened files so extra descriptors can be returned from the mock for L{os.listdir} when used on one of the list-of-filedescriptors directories. A L{FakeFile} is returned which can be closed to remove the new descriptor from the open list. � )r �min�set�ranger �appendr )r �fname�mode�fr r r �openfileo s zFDDetectorTests.openfilec C s dt jd< dS )zp Make the L{resource} module unimportable for the remainder of the current test method. N�resource)�sys�modulesr r r r �hideResourceModule} s z"FDDetectorTests.hideResourceModulec C s t |�tjd< dS )a Make a L{FakeResourceModule} instance importable at the L{resource} name. @param limit: The value which will be returned for the hard limit of number of open files by the fake resource module's C{getrlimit} function. r; N)r r< r= r r r r �revealResourceModule� s z$FDDetectorTests.revealResourceModulec C s: |du rzt jd= W dS ty Y dS w |t jd< dS )zI Restore the original resource module to L{sys.modules}. Nr; )r< r= �KeyError)r �valuer r r �replaceResourceModule� s �z%FDDetectorTests.replaceResourceModulec C sL t �� | _| j| j_| j| j_| j| j_g d�| _| �| jt j � d�� dS )z� Set up the tests, giving ourselves a detector object to play with and setting up its testable knobs to refer to our mocked versions. �r r � r; N) r � _FDDetector�detectorr1 r% r: r � addCleanuprB r< r= �getr r r r �setUp� s zFDDetectorTests.setUpc s@ dd� }dd� }� fdd�}|||g� j _� �|� j �� � dS )z� L{FDDetector._getImplementation} returns the first method from its C{_implementations} list which returns results which reflect a newly opened file descriptor. c S s t d��)NzThis does not work)� ValueErrorr r r r �failWithException� � zBFDDetectorTests.test_selectFirstWorking.<locals>.failWithExceptionc S � g d�S �NrC r r r r r �failWithWrongResults� rL zEFDDetectorTests.test_selectFirstWorking.<locals>.failWithWrongResultsc s � j d d � S r )r r r r r �correct� s z8FDDetectorTests.test_selectFirstWorking.<locals>.correctN�rF �_implementations�assertIs�_getImplementation)r rK rO rP r r r �test_selectFirstWorking� s �z'FDDetectorTests.test_selectFirstWorkingc C s2 dd� }dd� }||g| j _| �|| j �� � dS )z� L{FDDetector._getImplementation} returns the last method from its C{_implementations} list if none of the implementations manage to return results which reflect a newly opened file descriptor. c S rM )N)� � � r r r r r rO � rL z=FDDetectorTests.test_selectLast.<locals>.failWithWrongResultsc S rM rN r r r r r �failWithOtherWrongResults� rL zBFDDetectorTests.test_selectLast.<locals>.failWithOtherWrongResultsNrQ )r rO rY r r r �test_selectLast� s �z FDDetectorTests.test_selectLastc C sL t �� }|jj}|�� |jj}|�� |jj}| �||� | �||� dS )z� Check that the identity of _listOpenFDs changes after running _listOpenFDs the first time, but not after the second time it's run. In other words, check that the monkey patching actually works. N)r rE � _listOpenFDsr �assertNotEqual� assertEqual)r rF �first�second�thirdr r r �!test_identityOfListOpenFDsChanges� s z1FDDetectorTests.test_identityOfListOpenFDsChangesc C s< d| _ | �t| jj� d| _ d| _| �g d�| j�� � dS )z� L{_FDDetector._devFDImplementation} raises L{OSError} if there is no I{/dev/fd} directory, otherwise it returns the basenames of its children interpreted as integers. FTrC N)r, � assertRaisesr. rF �_devFDImplementationr- r] r r r r �test_devFDImplementation� s z(FDDetectorTests.test_devFDImplementationc C s6 d| _ | �t| jj� d| _ | �g d�| j�� � dS )z� L{_FDDetector._procFDImplementation} raises L{OSError} if there is no I{/proc/<pid>/fd} directory, otherwise it returns the basenames of its children interpreted as integers. FTrC N)r+ rb r. rF �_procFDImplementationr] r r r r �test_procFDImplementation� s z)FDDetectorTests.test_procFDImplementationc C sT | � d� | �ttd��t| j�� �� | � d� | �ttd��t| j�� �� dS )z� L{_FDDetector._fallbackFDImplementation} uses the L{resource} module if it is available, returning a range of integers from 0 to the minimum of C{1024} and the hard I{NOFILE} limit. i i r2 N)r? r] �listr5 rF �_fallbackFDImplementationr r r r � test_resourceFDImplementation� s � �z-FDDetectorTests.test_resourceFDImplementationc C s* | � � | �ttd��t| j�� �� dS )z� L{_FDDetector._fallbackFDImplementation}, the implementation of last resort, succeeds with a fixed range of integers from 0 to 1024 when the L{resource} module is not importable. r2 N)r> r] rg r5 rF rh r r r r � test_fallbackFDImplementation s �z-FDDetectorTests.test_fallbackFDImplementationN)r r r r r �skipr, r- r+ r% r1 r: r> r? rB rI rU rZ ra rd rf ri rj r r r r r$ D s( r$ c @ s$ e Zd ZdZeZdd� Zdd� ZdS )�FileDescriptorTestsz< Tests for L{twisted.internet.process._listOpenFDs} c C sd t �� D ]+}z t�|tj� W q ty/ } z| �tj|jd||jf � W Y d}~qd}~ww dS )z� File descriptors returned by L{_listOpenFDs} are mostly open. This test assumes that zero-legth writes fail with EBADF on closed file descriptors. z2fcntl(%d, F_GETFL) failed with unexpected errno %dN)r r[ �fcntl�F_GETFLr. r] �errno�EBADF)r r �errr r r � test_openFDs" s �����z FileDescriptorTests.test_openFDsc C s� t tj�}t�� }| �|�� |� t�|�� �}| �||�� kd� z|� � | �|t�� � W t� |� nt� |� w | � |t�� � dS )zB L{_listOpenFDs} lists expected file descriptors. z>Expected duplicate file descriptor to be greater than originalN) �open�os�devnullr r[ �assertIn�fileno�dup� assertTruer � assertNotIn)r r9 �openfdsr r r r �test_expectedFDs4 s �z$FileDescriptorTests.test_expectedFDsN)r r r r r rk rr r| r r r r rl s rl )r ro rt r< �typingr r* �__annotations__rm � ImportErrorr �twisted.internetr �twisted.trial.unittestr r r r$ rl r r r r �<module> s& � XPK Mb�Z���3�2 �2 8 internet/test/__pycache__/test_posixbase.cpython-310.pycnu �[��� o �b�% � @ s� d Z ddlmZ ddlmZmZ ddlmZ ddlm Z dZ zddl m Z ddl mZ W n ey7 d Z Y nw dd l mZ dd lmZ G d d � d e�ZG dd� de �ZG dd� de �ZG dd� de�ZG dd� de �ZG dd� de �ZG dd� de �ZdS )z> Tests for L{twisted.internet.posixbase} and supporting code. � )�Deferred)�PosixReactorBase�_Waker)� ServerFactory)�TestCaseN)�unix)� ClientProtoz)Platform does not support AF_UNIX sockets��reactor)�Portc @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �TrivialReactorc C s i | _ i | _t�| � d S �N)�_readers�_writersr �__init__��self� r �F/usr/lib/python3/dist-packages/twisted/internet/test/test_posixbase.pyr s zTrivialReactor.__init__c C � d| j |< d S �NT�r �r �readerr r r � addReader � zTrivialReactor.addReaderc C � | j |= d S r r r r r r � removeReader" � zTrivialReactor.removeReaderc C r r �r �r �writerr r r � addWriter% r zTrivialReactor.addWriterc C r r r r r r r � removeWriter( r zTrivialReactor.removeWriterN)�__name__� __module__� __qualname__r r r r" r# r r r r r s r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �PosixReactorBaseTestsz( Tests for L{PosixReactorBase}. c C s2 | � |jt� | �|j|j� | �|j|j� d S r )�assertIsInstance�wakerr �assertIn�_internalReadersr �r r r r r � _checkWaker1 s z!PosixReactorBaseTests._checkWakerc C s t � }| �|� dS )z When L{PosixReactorBase} is instantiated, it creates a waker and adds it to its internal readers set. N)r r- r, r r r �test_wakerIsInternalReader6 s z0PosixReactorBaseTests.test_wakerIsInternalReaderc C s\ t � }t� }|j�|� |�|� |�|j|j� | �|� | � ||j� | � ||j� dS )z� Any L{IReadDescriptors} in L{PosixReactorBase._internalReaders} are left alone by L{PosixReactorBase._removeAll}. N) r �objectr+ �addr � _removeAllr r r- r* )r r �extrar r r �"test_removeAllSkipsInternalReaders> s z8PosixReactorBaseTests.test_removeAllSkipsInternalReadersc C sj t � }t� }t� }|�|� |�|� |�|j|j�}| �t|�||h� | � ||j� | � ||j� dS )z� L{PosixReactorBase._removeAll} returns a list of removed L{IReadDescriptor} and L{IWriteDescriptor} objects. N) r r/ r r" r1 r r � assertEqual�set� assertNotIn)r r r r! �removedr r r �'test_removeAllReturnsRemovedDescriptorsL s z=PosixReactorBaseTests.test_removeAllReturnsRemovedDescriptorsN)r$ r% r& �__doc__r- r. r3 r8 r r r r r' , s r' c @ s& e Zd ZdZeee�s dZdd� ZdS )� TCPPortTestsz1 Tests for L{twisted.internet.tcp.Port}. zNon-posixbase reactorc C s, t dt� �}d|_dd� |_| �|�� t�S )z� L{Port.stopListening} returns a L{Deferred} which errbacks if L{Port.connectionLost} raises an exception. i90 Tc S s dd S )N� r r )�reasonr r r �<lambda>k � z8TCPPortTests.test_connectionLostFailed.<locals>.<lambda>)r r � connected�connectionLost� assertFailure� stopListening�ZeroDivisionError)r �portr r r �test_connectionLostFailedd s z&TCPPortTests.test_connectionLostFailedN) r$ r% r& r9 � isinstancer r �skiprE r r r r r: \ s r: c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �TimeoutReportReactorz� A reactor which is just barely runnable and which cannot monitor any readers or writers, and which fires a L{Deferred} with the timeout passed to its C{doIteration} method as soon as that method is invoked. c C s t �| � t� | _d| _d S )N�d )r r r �iterationTimeout�nowr r r r r v s z TimeoutReportReactor.__init__c C s dS )z� Ignore the reader. This is necessary because the waker will be added. However, we won't actually monitor it for any events. Nr r r r r r { � z TimeoutReportReactor.addReaderc C s g S )z� There are no readers or writers, so there is nothing to remove. This will be called when the reactor stops, though, so it must be implemented. r r r r r � removeAll� s z TimeoutReportReactor.removeAllc C s | j S )zx Override the real clock with a deterministic one that can be easily controlled in a unit test. )rK r r r r �seconds� s z TimeoutReportReactor.secondsc C s& | j }|d urd | _ |�|� d S d S r )rJ �callback)r �timeout�dr r r � doIteration� s �z TimeoutReportReactor.doIterationN) r$ r% r& r9 r r rM rN rR r r r r rH o s rH c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )�IterationTimeoutTestsz� Tests for the timeout argument L{PosixReactorBase.run} calls L{PosixReactorBase.doIteration} with in the presence of various delayed calls. c s6 g }� j �|j� � j �� fdd�� � �� |d S )Nc s � � � S r )�stop)�ignoredr r r r= � r> z>IterationTimeoutTests._checkIterationTimeout.<locals>.<lambda>r )rJ � addCallback�append�run�r r rP r r r �_checkIterationTimeout� s z,IterationTimeoutTests._checkIterationTimeoutc C s t � }| �|�}| �|� dS )zl If there are no delayed calls, C{doIteration} is called with a timeout of L{None}. N)rH rZ � assertIsNonerY r r r � test_noCalls� s z"IterationTimeoutTests.test_noCallsc C s0 t � }|�ddd� � | �|�}| �|d� dS )z� If there is a delayed call, C{doIteration} is called with a timeout which is the difference between the current time and the time at which that call is to run. rI c S � d S r r r r r r r= � rL z8IterationTimeoutTests.test_delayedCall.<locals>.<lambda>N�rH � callLaterrZ r4 rY r r r �test_delayedCall� s z&IterationTimeoutTests.test_delayedCallc C s> t � }|�ddd� � | jd7 _| �|�}| �|d� dS )z� If a delayed call is scheduled and then some time passes, the timeout passed to C{doIteration} is reduced by the amount of time which passed. rI c S r] r r r r r r r= � rL z7IterationTimeoutTests.test_timePasses.<locals>.<lambda>� �K N)rH r_ rK rZ r4 rY r r r �test_timePasses� s z%IterationTimeoutTests.test_timePassesc C sP t � }|�ddd� � |�ddd� � |�ddd� � | �|�}| �|d� dS ) z� If there are several delayed calls, C{doIteration} is called with a timeout which is the difference between the current time and the time at which the earlier of the two calls is to run. �2 c S r] r r r r r r r= � rL zAIterationTimeoutTests.test_multipleDelayedCalls.<locals>.<lambda>� c S r] r r r r r r r= � rL rI c S r] r r r r r r r= � rL Nr^ rY r r r �test_multipleDelayedCalls� s z/IterationTimeoutTests.test_multipleDelayedCallsc C sH t � }|�ddd� �}| jd7 _|�d� | �|�}| �|d� dS )z� If a delayed call is reset, the timeout passed to C{doIteration} is based on the interval between the time when reset is called and the new delay of the call. rd c S r] r r r r r r r= � rL z=IterationTimeoutTests.test_resetDelayedCall.<locals>.<lambda>ra � N)rH r_ rK �resetrZ r4 �r r �callrP r r r �test_resetDelayedCall� s z+IterationTimeoutTests.test_resetDelayedCallc C sH t � }|�ddd� �}| jd7 _|�d� | �|�}| �|d� dS )z� If a delayed call is re-delayed, the timeout passed to C{doIteration} is based on the remaining time before the call would have been made and the additional amount of time passed to the delay method. rd c S r] r r r r r r r= � rL z=IterationTimeoutTests.test_delayDelayedCall.<locals>.<lambda>re � �< N)rH r_ rK �delayrZ r4 ri r r r �test_delayDelayedCall� s z+IterationTimeoutTests.test_delayDelayedCallc C s6 t � }|�ddd� �}|�� | �|�}| �|� dS )zp If the only delayed call is canceled, L{None} is the timeout passed to C{doIteration}. rd c S r] r r r r r r r= � rL z>IterationTimeoutTests.test_cancelDelayedCall.<locals>.<lambda>N)rH r_ �cancelrZ r[ ri r r r �test_cancelDelayedCall� s z,IterationTimeoutTests.test_cancelDelayedCallN) r$ r% r& r9 rZ r\ r` rc rf rk ro rq r r r r rS � s rS c @ s, e Zd ZdZedur eZdd� Zdd� ZdS )�ConnectedDatagramPortTestsz/ Test connected datagram UNIX sockets. Nc s. � fdd�}t �dt� �}||_|�d� dS )z� L{ConnectedDatagramPort} does not call the deprecated C{loseConnection} in L{ConnectedDatagramPort.connectionFailed}. c s � � d� dS )z� Dummy C{loseConnection} method. C{loseConnection} is deprecated and should not get called. z7loseConnection is deprecated and should not get called.N)�failr r r r �loseConnection s z`ConnectedDatagramPortTests.test_connectionFailedDoesntCallLoseConnection.<locals>.loseConnectionN�goodbye)r �ConnectedDatagramPortr rt �connectionFailed)r rt rD r r r �-test_connectionFailedDoesntCallLoseConnection s zHConnectedDatagramPortTests.test_connectionFailedDoesntCallLoseConnectionc s@ d� _ � fdd�}t�dt� �}||_|�d� � �� j � dS )z� L{ConnectedDatagramPort} calls L{ConnectedDatagramPort.stopListening} instead of the deprecated C{loseConnection} in L{ConnectedDatagramPort.connectionFailed}. Fc s d� _ dS )z8 Dummy C{stopListening} method. TN)�calledr r r r rB s zYConnectedDatagramPortTests.test_connectionFailedCallsStopListening.<locals>.stopListeningNru )ry r rv r rB rw � assertTrue)r rB rD r r r �'test_connectionFailedCallsStopListening s zBConnectedDatagramPortTests.test_connectionFailedCallsStopListening)r$ r% r& r9 � skipSocketsrG rx r{ r r r r rr � s rr c @ s e Zd Zdd� ZdS )� WakerTestsc C s0 t d d�}| �� }|�d � | �t|�d� d S )Nr r )r � flushWarningsr@ r4 �len)r r) �warningsr r r � test_noWakerConstructionWarnings' s z+WakerTests.test_noWakerConstructionWarningsN)r$ r% r& r� r r r r r} & s r} )r9 �twisted.internet.deferr �twisted.internet.posixbaser r �twisted.internet.protocolr �twisted.trial.unittestr r| �twisted.internetr �twisted.test.test_unixr � ImportErrorr �twisted.internet.tcpr r r' r: rH rS rr r} r r r r �<module> s* � 0(b-PK Mb�Z~� ! internet/test/test_pollingfile.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.internet._pollingfile}. """ from unittest import skipIf from twisted.python.runtime import platform from twisted.trial.unittest import TestCase if platform.isWindows(): from twisted.internet import _pollingfile else: _pollingfile = None # type: ignore[assignment] @skipIf(_pollingfile is None, "Test will run only on Windows.") class PollableWritePipeTests(TestCase): """ Tests for L{_pollingfile._PollableWritePipe}. """ def test_writeUnicode(self): """ L{_pollingfile._PollableWritePipe.write} raises a C{TypeError} if an attempt is made to append unicode data to the output buffer. """ p = _pollingfile._PollableWritePipe(1, lambda: None) self.assertRaises(TypeError, p.write, "test") def test_writeSequenceUnicode(self): """ L{_pollingfile._PollableWritePipe.writeSequence} raises a C{TypeError} if unicode data is part of the data sequence to be appended to the output buffer. """ p = _pollingfile._PollableWritePipe(1, lambda: None) self.assertRaises(TypeError, p.writeSequence, ["test"]) self.assertRaises(TypeError, p.writeSequence, ("test",)) PK Mb�ZL�'�� � internet/test/modulehelpers.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Testing helpers related to the module system. """ __all__ = ["NoReactor", "AlternateReactor"] import sys import twisted.internet from twisted.test.test_twisted import SetAsideModule class NoReactor(SetAsideModule): """ Context manager that uninstalls the reactor, if any, and then restores it afterwards. """ def __init__(self): SetAsideModule.__init__(self, "twisted.internet.reactor") def __enter__(self): SetAsideModule.__enter__(self) if "twisted.internet.reactor" in self.modules: del twisted.internet.reactor def __exit__(self, excType, excValue, traceback): SetAsideModule.__exit__(self, excType, excValue, traceback) # Clean up 'reactor' attribute that may have been set on # twisted.internet: reactor = self.modules.get("twisted.internet.reactor", None) if reactor is not None: twisted.internet.reactor = reactor else: try: del twisted.internet.reactor except AttributeError: pass class AlternateReactor(NoReactor): """ A context manager which temporarily installs a different object as the global reactor. """ def __init__(self, reactor): """ @param reactor: Any object to install as the global reactor. """ NoReactor.__init__(self) self.alternate = reactor def __enter__(self): NoReactor.__enter__(self) twisted.internet.reactor = self.alternate sys.modules["twisted.internet.reactor"] = self.alternate PK Mb�Z���� � internet/test/test_abstract.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.internet.abstract}, a collection of APIs for implementing reactors. """ from twisted.internet.abstract import isIPv6Address from twisted.trial.unittest import SynchronousTestCase class IPv6AddressTests(SynchronousTestCase): """ Tests for L{isIPv6Address}, a function for determining if a particular string is an IPv6 address literal. """ def test_empty(self): """ The empty string is not an IPv6 address literal. """ self.assertFalse(isIPv6Address("")) def test_colon(self): """ A single C{":"} is not an IPv6 address literal. """ self.assertFalse(isIPv6Address(":")) def test_loopback(self): """ C{"::1"} is the IPv6 loopback address literal. """ self.assertTrue(isIPv6Address("::1")) def test_scopeID(self): """ An otherwise valid IPv6 address literal may also include a C{"%"} followed by an arbitrary scope identifier. """ self.assertTrue(isIPv6Address("fe80::1%eth0")) self.assertTrue(isIPv6Address("fe80::2%1")) self.assertTrue(isIPv6Address("fe80::3%en2")) def test_invalidWithScopeID(self): """ An otherwise invalid IPv6 address literal is still invalid with a trailing scope identifier. """ self.assertFalse(isIPv6Address("%eth0")) self.assertFalse(isIPv6Address(":%eth0")) self.assertFalse(isIPv6Address("hello%eth0")) def test_unicodeAndBytes(self): """ L{isIPv6Address} evaluates ASCII-encoded bytes as well as text. """ self.assertTrue(isIPv6Address(b"fe80::2%1")) self.assertTrue(isIPv6Address("fe80::2%1")) self.assertFalse(isIPv6Address("\u4321")) self.assertFalse(isIPv6Address("hello%eth0")) self.assertFalse(isIPv6Address(b"hello%eth0")) PK Mb�Z��ʋ " " internet/test/test_threads.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for implementations of L{IReactorThreads}. """ import gc import threading from weakref import ref from twisted.internet.interfaces import IReactorThreads from twisted.internet.test.reactormixins import ReactorBuilder from twisted.python.threadable import isInIOThread from twisted.python.threadpool import ThreadPool from twisted.python.versions import Version class ThreadTestsBuilder(ReactorBuilder): """ Builder for defining tests relating to L{IReactorThreads}. """ requiredInterfaces = (IReactorThreads,) def test_getThreadPool(self): """ C{reactor.getThreadPool()} returns an instance of L{ThreadPool} which starts when C{reactor.run()} is called and stops before it returns. """ state = [] reactor = self.buildReactor() pool = reactor.getThreadPool() self.assertIsInstance(pool, ThreadPool) self.assertFalse(pool.started, "Pool should not start before reactor.run") def f(): # Record the state for later assertions state.append(pool.started) state.append(pool.joined) reactor.stop() reactor.callWhenRunning(f) self.runReactor(reactor, 2) self.assertTrue(state[0], "Pool should start after reactor.run") self.assertFalse(state[1], "Pool should not be joined before reactor.stop") self.assertTrue(pool.joined, "Pool should be stopped after reactor.run returns") def test_suggestThreadPoolSize(self): """ C{reactor.suggestThreadPoolSize()} sets the maximum size of the reactor threadpool. """ reactor = self.buildReactor() reactor.suggestThreadPoolSize(17) pool = reactor.getThreadPool() self.assertEqual(pool.max, 17) def test_delayedCallFromThread(self): """ A function scheduled with L{IReactorThreads.callFromThread} invoked from a delayed call is run immediately in the next reactor iteration. When invoked from the reactor thread, previous implementations of L{IReactorThreads.callFromThread} would skip the pipe/socket based wake up step, assuming the reactor would wake up on its own. However, this resulted in the reactor not noticing an insert into the thread queue at the right time (in this case, after the thread queue has been processed for that reactor iteration). """ reactor = self.buildReactor() def threadCall(): reactor.stop() # Set up the use of callFromThread being tested. reactor.callLater(0, reactor.callFromThread, threadCall) before = reactor.seconds() self.runReactor(reactor, 60) after = reactor.seconds() # We specified a timeout of 60 seconds. The timeout code in runReactor # probably won't actually work, though. If the reactor comes out of # the event notification API just a little bit early, say after 59.9999 # seconds instead of after 60 seconds, then the queued thread call will # get processed but the timeout delayed call runReactor sets up won't! # Then the reactor will stop and runReactor will return without the # timeout firing. As it turns out, select() and poll() are quite # likely to return *slightly* earlier than we ask them to, so the # timeout will rarely happen, even if callFromThread is broken. So, # instead we'll measure the elapsed time and make sure it's something # less than about half of the timeout we specified. This is heuristic. # It assumes that select() won't ever return after 30 seconds when we # asked it to timeout after 60 seconds. And of course like all # time-based tests, it's slightly non-deterministic. If the OS doesn't # schedule this process for 30 seconds, then the test might fail even # if callFromThread is working. self.assertTrue(after - before < 30) def test_callFromThread(self): """ A function scheduled with L{IReactorThreads.callFromThread} invoked from another thread is run in the reactor thread. """ reactor = self.buildReactor() result = [] def threadCall(): result.append(threading.current_thread()) reactor.stop() reactor.callLater(0, reactor.callInThread, reactor.callFromThread, threadCall) self.runReactor(reactor, 5) self.assertEqual(result, [threading.current_thread()]) def test_stopThreadPool(self): """ When the reactor stops, L{ReactorBase._stopThreadPool} drops the reactor's direct reference to its internal threadpool and removes the associated startup and shutdown triggers. This is the case of the thread pool being created before the reactor is run. """ reactor = self.buildReactor() threadpool = ref(reactor.getThreadPool()) reactor.callWhenRunning(reactor.stop) self.runReactor(reactor) gc.collect() self.assertIsNone(threadpool()) def test_stopThreadPoolWhenStartedAfterReactorRan(self): """ We must handle the case of shutting down the thread pool when it was started after the reactor was run in a special way. Some implementation background: The thread pool is started with callWhenRunning, which only returns a system trigger ID when it is invoked before the reactor is started. This is the case of the thread pool being created after the reactor is started. """ reactor = self.buildReactor() threadPoolRefs = [] def acquireThreadPool(): threadPoolRefs.append(ref(reactor.getThreadPool())) reactor.stop() reactor.callWhenRunning(acquireThreadPool) self.runReactor(reactor) gc.collect() self.assertIsNone(threadPoolRefs[0]()) def test_cleanUpThreadPoolEvenBeforeReactorIsRun(self): """ When the reactor has its shutdown event fired before it is run, the thread pool is completely destroyed. For what it's worth, the reason we support this behavior at all is because Trial does this. This is the case of the thread pool being created without the reactor being started at al. """ reactor = self.buildReactor() threadPoolRef = ref(reactor.getThreadPool()) reactor.fireSystemEvent("shutdown") if reactor.__class__.__name__ == "AsyncioSelectorReactor": self.assertIsNone(reactor.threadpool) # ReactorBase.__init__ sets self.crash as a 'shutdown' # event, which in turn calls stop on the underlying # asyncio event loop, which in turn sets a _stopping # attribute on it that's only unset after an iteration of # the loop. Subsequent tests can only reuse the asyncio # loop if it's allowed to run and unset that _stopping # attribute. self.runReactor(reactor) else: gc.collect() self.assertIsNone(threadPoolRef()) def test_isInIOThread(self): """ The reactor registers itself as the I/O thread when it runs so that L{twisted.python.threadable.isInIOThread} returns C{True} if it is called in the thread the reactor is running in. """ results = [] reactor = self.buildReactor() def check(): results.append(isInIOThread()) reactor.stop() reactor.callWhenRunning(check) self.runReactor(reactor) self.assertEqual([True], results) def test_isNotInIOThread(self): """ The reactor registers itself as the I/O thread when it runs so that L{twisted.python.threadable.isInIOThread} returns C{False} if it is called in a different thread than the reactor is running in. """ results = [] reactor = self.buildReactor() def check(): results.append(isInIOThread()) reactor.callFromThread(reactor.stop) reactor.callInThread(check) self.runReactor(reactor) self.assertEqual([False], results) def test_threadPoolCurrentThreadDeprecated(self): self.callDeprecated( version=( Version("Twisted", 22, 1, 0), "threading.current_thread", ), f=ThreadPool.currentThread, ) globals().update(ThreadTestsBuilder.makeTestCaseClasses()) PK Mb�Zn�t5 t5 internet/test/test_base.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.internet.base}. """ import socket from queue import Queue from typing import Any, Callable from unittest import skipIf from zope.interface import implementer from twisted.internet._resolver import FirstOneWins from twisted.internet.base import DelayedCall, ReactorBase, ThreadedResolver from twisted.internet.defer import Deferred from twisted.internet.error import DNSLookupError from twisted.internet.interfaces import IReactorThreads, IReactorTime, IResolverSimple from twisted.internet.task import Clock from twisted.python.threadpool import ThreadPool from twisted.trial.unittest import SkipTest, TestCase try: import signal as _signal except ImportError: signal = None else: signal = _signal @implementer(IReactorTime, IReactorThreads) class FakeReactor: """ A fake reactor implementation which just supports enough reactor APIs for L{ThreadedResolver}. """ def __init__(self): self._clock = Clock() self.callLater = self._clock.callLater self._threadpool = ThreadPool() self._threadpool.start() self.getThreadPool = lambda: self._threadpool self._threadCalls = Queue() def callFromThread(self, callable: Callable[..., Any], *args, **kwargs): self._threadCalls.put((callable, args, kwargs)) def _runThreadCalls(self): f, args, kwargs = self._threadCalls.get() f(*args, **kwargs) def _stop(self): self._threadpool.stop() def getDelayedCalls(self): # IReactorTime.getDelayedCalls pass def seconds(self): # IReactorTime.seconds pass def callInThread(self, callable: Callable[..., Any], *args, **kwargs): # IReactorInThreads.callInThread pass def suggestThreadPoolSize(self, size): # IReactorThreads.suggestThreadPoolSize pass class ThreadedResolverTests(TestCase): """ Tests for L{ThreadedResolver}. """ def test_success(self): """ L{ThreadedResolver.getHostByName} returns a L{Deferred} which fires with the value returned by the call to L{socket.gethostbyname} in the threadpool of the reactor passed to L{ThreadedResolver.__init__}. """ ip = "10.0.0.17" name = "foo.bar.example.com" timeout = 30 reactor = FakeReactor() self.addCleanup(reactor._stop) lookedUp = [] resolvedTo = [] def fakeGetHostByName(name): lookedUp.append(name) return ip self.patch(socket, "gethostbyname", fakeGetHostByName) resolver = ThreadedResolver(reactor) d = resolver.getHostByName(name, (timeout,)) d.addCallback(resolvedTo.append) reactor._runThreadCalls() self.assertEqual(lookedUp, [name]) self.assertEqual(resolvedTo, [ip]) # Make sure that any timeout-related stuff gets cleaned up. reactor._clock.advance(timeout + 1) self.assertEqual(reactor._clock.calls, []) def test_failure(self): """ L{ThreadedResolver.getHostByName} returns a L{Deferred} which fires a L{Failure} if the call to L{socket.gethostbyname} raises an exception. """ timeout = 30 reactor = FakeReactor() self.addCleanup(reactor._stop) def fakeGetHostByName(name): raise OSError("ENOBUFS (this is a funny joke)") self.patch(socket, "gethostbyname", fakeGetHostByName) failedWith = [] resolver = ThreadedResolver(reactor) d = resolver.getHostByName("some.name", (timeout,)) self.assertFailure(d, DNSLookupError) d.addCallback(failedWith.append) reactor._runThreadCalls() self.assertEqual(len(failedWith), 1) # Make sure that any timeout-related stuff gets cleaned up. reactor._clock.advance(timeout + 1) self.assertEqual(reactor._clock.calls, []) def test_timeout(self): """ If L{socket.gethostbyname} does not complete before the specified timeout elapsed, the L{Deferred} returned by L{ThreadedResolver.getHostByName} fails with L{DNSLookupError}. """ timeout = 10 reactor = FakeReactor() self.addCleanup(reactor._stop) result = Queue() def fakeGetHostByName(name): raise result.get() self.patch(socket, "gethostbyname", fakeGetHostByName) failedWith = [] resolver = ThreadedResolver(reactor) d = resolver.getHostByName("some.name", (timeout,)) self.assertFailure(d, DNSLookupError) d.addCallback(failedWith.append) reactor._clock.advance(timeout - 1) self.assertEqual(failedWith, []) reactor._clock.advance(1) self.assertEqual(len(failedWith), 1) # Eventually the socket.gethostbyname does finish - in this case, with # an exception. Nobody cares, though. result.put(IOError("The I/O was errorful")) def test_resolverGivenStr(self): """ L{ThreadedResolver.getHostByName} is passed L{str}, encoded using IDNA if required. """ calls = [] @implementer(IResolverSimple) class FakeResolver: def getHostByName(self, name, timeouts=()): calls.append(name) return Deferred() class JustEnoughReactor(ReactorBase): def installWaker(self): pass fake = FakeResolver() reactor = JustEnoughReactor() reactor.installResolver(fake) rec = FirstOneWins(Deferred()) reactor.nameResolver.resolveHostName(rec, "example.example") reactor.nameResolver.resolveHostName(rec, "example.example") reactor.nameResolver.resolveHostName(rec, "v\xe4\xe4ntynyt.example") reactor.nameResolver.resolveHostName(rec, "\u0440\u0444.example") reactor.nameResolver.resolveHostName(rec, "xn----7sbb4ac0ad0be6cf.xn--p1ai") self.assertEqual(len(calls), 5) self.assertEqual(list(map(type, calls)), [str] * 5) self.assertEqual("example.example", calls[0]) self.assertEqual("example.example", calls[1]) self.assertEqual("xn--vntynyt-5waa.example", calls[2]) self.assertEqual("xn--p1ai.example", calls[3]) self.assertEqual("xn----7sbb4ac0ad0be6cf.xn--p1ai", calls[4]) def nothing(): """ Function used by L{DelayedCallTests.test_str}. """ class DelayedCallMixin: """ L{DelayedCall} """ def _getDelayedCallAt(self, time): """ Get a L{DelayedCall} instance at a given C{time}. @param time: The absolute time at which the returned L{DelayedCall} will be scheduled. """ def noop(call): pass return DelayedCall(time, lambda: None, (), {}, noop, noop, None) def setUp(self): """ Create two L{DelayedCall} instanced scheduled to run at different times. """ self.zero = self._getDelayedCallAt(0) self.one = self._getDelayedCallAt(1) def test_str(self): """ The string representation of a L{DelayedCall} instance, as returned by L{str}, includes the unsigned id of the instance, as well as its state, the function to be called, and the function arguments. """ dc = DelayedCall(12, nothing, (3,), {"A": 5}, None, None, lambda: 1.5) self.assertEqual( str(dc), "<DelayedCall 0x%x [10.5s] called=0 cancelled=0 nothing(3, A=5)>" % (id(dc),), ) def test_repr(self): """ The string representation of a L{DelayedCall} instance, as returned by {repr}, is identical to that returned by L{str}. """ dc = DelayedCall(13, nothing, (6,), {"A": 9}, None, None, lambda: 1.6) self.assertEqual(str(dc), repr(dc)) def test_lt(self): """ For two instances of L{DelayedCall} C{a} and C{b}, C{a < b} is true if and only if C{a} is scheduled to run before C{b}. """ zero, one = self.zero, self.one self.assertTrue(zero < one) self.assertFalse(one < zero) self.assertFalse(zero < zero) self.assertFalse(one < one) def test_le(self): """ For two instances of L{DelayedCall} C{a} and C{b}, C{a <= b} is true if and only if C{a} is scheduled to run before C{b} or at the same time as C{b}. """ zero, one = self.zero, self.one self.assertTrue(zero <= one) self.assertFalse(one <= zero) self.assertTrue(zero <= zero) self.assertTrue(one <= one) def test_gt(self): """ For two instances of L{DelayedCall} C{a} and C{b}, C{a > b} is true if and only if C{a} is scheduled to run after C{b}. """ zero, one = self.zero, self.one self.assertTrue(one > zero) self.assertFalse(zero > one) self.assertFalse(zero > zero) self.assertFalse(one > one) def test_ge(self): """ For two instances of L{DelayedCall} C{a} and C{b}, C{a > b} is true if and only if C{a} is scheduled to run after C{b} or at the same time as C{b}. """ zero, one = self.zero, self.one self.assertTrue(one >= zero) self.assertFalse(zero >= one) self.assertTrue(zero >= zero) self.assertTrue(one >= one) def test_eq(self): """ A L{DelayedCall} instance is only equal to itself. """ # Explicitly use == here, instead of assertEqual, to be more # confident __eq__ is being tested. self.assertFalse(self.zero == self.one) self.assertTrue(self.zero == self.zero) self.assertTrue(self.one == self.one) def test_ne(self): """ A L{DelayedCall} instance is not equal to any other object. """ # Explicitly use != here, instead of assertEqual, to be more # confident __ne__ is being tested. self.assertTrue(self.zero != self.one) self.assertFalse(self.zero != self.zero) self.assertFalse(self.one != self.one) class DelayedCallNoDebugTests(DelayedCallMixin, TestCase): """ L{DelayedCall} """ def setUp(self): """ Turn debug off. """ self.patch(DelayedCall, "debug", False) DelayedCallMixin.setUp(self) def test_str(self): """ The string representation of a L{DelayedCall} instance, as returned by L{str}, includes the unsigned id of the instance, as well as its state, the function to be called, and the function arguments. """ dc = DelayedCall(12, nothing, (3,), {"A": 5}, None, None, lambda: 1.5) expected = ( "<DelayedCall 0x{:x} [10.5s] called=0 cancelled=0 " "nothing(3, A=5)>".format(id(dc)) ) self.assertEqual(str(dc), expected) class DelayedCallDebugTests(DelayedCallMixin, TestCase): """ L{DelayedCall} """ def setUp(self): """ Turn debug on. """ self.patch(DelayedCall, "debug", True) DelayedCallMixin.setUp(self) def test_str(self): """ The string representation of a L{DelayedCall} instance, as returned by L{str}, includes the unsigned id of the instance, as well as its state, the function to be called, and the function arguments. """ dc = DelayedCall(12, nothing, (3,), {"A": 5}, None, None, lambda: 1.5) expectedRegexp = ( "<DelayedCall 0x{:x} \\[10.5s\\] called=0 cancelled=0 " "nothing\\(3, A=5\\)\n\n" "traceback at creation:".format(id(dc)) ) self.assertRegex(str(dc), expectedRegexp) class TestSpySignalCapturingReactor(ReactorBase): """ Subclass of ReactorBase to capture signals delivered to the reactor for inspection. """ def installWaker(self): """ Required method, unused. """ @skipIf(not signal, "signal module not available") class ReactorBaseSignalTests(TestCase): """ Tests to exercise ReactorBase's signal exit reporting path. """ def test_exitSignalDefaultsToNone(self): """ The default value of the _exitSignal attribute is None. """ reactor = TestSpySignalCapturingReactor() self.assertIs(None, reactor._exitSignal) def test_captureSIGINT(self): """ ReactorBase's SIGINT handler saves the value of SIGINT to the _exitSignal attribute. """ reactor = TestSpySignalCapturingReactor() reactor.sigInt(signal.SIGINT, None) self.assertEquals(signal.SIGINT, reactor._exitSignal) def test_captureSIGTERM(self): """ ReactorBase's SIGTERM handler saves the value of SIGTERM to the _exitSignal attribute. """ reactor = TestSpySignalCapturingReactor() reactor.sigTerm(signal.SIGTERM, None) self.assertEquals(signal.SIGTERM, reactor._exitSignal) def test_captureSIGBREAK(self): """ ReactorBase's SIGBREAK handler saves the value of SIGBREAK to the _exitSignal attribute. """ if not hasattr(signal, "SIGBREAK"): raise SkipTest("signal module does not have SIGBREAK") reactor = TestSpySignalCapturingReactor() reactor.sigBreak(signal.SIGBREAK, None) self.assertEquals(signal.SIGBREAK, reactor._exitSignal) PK Mb�Z���$J J internet/test/test_address.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import os import socket from unittest import skipIf from twisted.internet.address import ( HostnameAddress, IPv4Address, IPv6Address, UNIXAddress, ) from twisted.python.compat import nativeString from twisted.python.runtime import platform from twisted.trial.unittest import SynchronousTestCase, TestCase symlinkSkip = not platform._supportsSymlinks() try: socket.AF_UNIX except AttributeError: unixSkip = True else: unixSkip = False class AddressTestCaseMixin: def test_addressComparison(self): """ Two different address instances, sharing the same properties are considered equal by C{==} and not considered not equal by C{!=}. Note: When applied via UNIXAddress class, this uses the same filename for both objects being compared. """ self.assertTrue(self.buildAddress() == self.buildAddress()) self.assertFalse(self.buildAddress() != self.buildAddress()) def test_hash(self): """ C{__hash__} can be used to get a hash of an address, allowing addresses to be used as keys in dictionaries, for instance. """ addr = self.buildAddress() d = {addr: True} self.assertTrue(d[self.buildAddress()]) def test_differentNamesComparison(self): """ Check that comparison operators work correctly on address objects when a different name is passed in """ self.assertFalse(self.buildAddress() == self.buildDifferentAddress()) self.assertFalse(self.buildDifferentAddress() == self.buildAddress()) self.assertTrue(self.buildAddress() != self.buildDifferentAddress()) self.assertTrue(self.buildDifferentAddress() != self.buildAddress()) def assertDeprecations(self, testMethod, message): """ Assert that the a DeprecationWarning with the given message was emitted against the given method. """ warnings = self.flushWarnings([testMethod]) self.assertEqual(warnings[0]["category"], DeprecationWarning) self.assertEqual(warnings[0]["message"], message) self.assertEqual(len(warnings), 1) class IPv4AddressTestCaseMixin(AddressTestCaseMixin): addressArgSpec = (("type", "%s"), ("host", "%r"), ("port", "%d")) class HostnameAddressTests(TestCase, AddressTestCaseMixin): """ Test case for L{HostnameAddress}. """ addressArgSpec = (("hostname", "%s"), ("port", "%d")) def buildAddress(self): """ Create an arbitrary new L{HostnameAddress} instance. @return: A L{HostnameAddress} instance. """ return HostnameAddress(b"example.com", 0) def buildDifferentAddress(self): """ Like L{buildAddress}, but with a different hostname. @return: A L{HostnameAddress} instance. """ return HostnameAddress(b"example.net", 0) class IPv4AddressTCPTests(SynchronousTestCase, IPv4AddressTestCaseMixin): def buildAddress(self): """ Create an arbitrary new L{IPv4Address} instance with a C{"TCP"} type. A new instance is created for each call, but always for the same address. """ return IPv4Address("TCP", "127.0.0.1", 0) def buildDifferentAddress(self): """ Like L{buildAddress}, but with a different fixed address. """ return IPv4Address("TCP", "127.0.0.2", 0) class IPv4AddressUDPTests(SynchronousTestCase, IPv4AddressTestCaseMixin): def buildAddress(self): """ Create an arbitrary new L{IPv4Address} instance with a C{"UDP"} type. A new instance is created for each call, but always for the same address. """ return IPv4Address("UDP", "127.0.0.1", 0) def buildDifferentAddress(self): """ Like L{buildAddress}, but with a different fixed address. """ return IPv4Address("UDP", "127.0.0.2", 0) class IPv6AddressTests(SynchronousTestCase, AddressTestCaseMixin): addressArgSpec = (("type", "%s"), ("host", "%r"), ("port", "%d")) def buildAddress(self): """ Create an arbitrary new L{IPv6Address} instance with a C{"TCP"} type. A new instance is created for each call, but always for the same address. """ return IPv6Address("TCP", "::1", 0) def buildDifferentAddress(self): """ Like L{buildAddress}, but with a different fixed address. """ return IPv6Address("TCP", "::2", 0) @skipIf(unixSkip, "Platform doesn't support UNIX sockets.") class UNIXAddressTests(SynchronousTestCase): addressArgSpec = (("name", "%r"),) def setUp(self): self._socketAddress = self.mktemp() self._otherAddress = self.mktemp() def buildAddress(self): """ Create an arbitrary new L{UNIXAddress} instance. A new instance is created for each call, but always for the same address. """ return UNIXAddress(self._socketAddress) def buildDifferentAddress(self): """ Like L{buildAddress}, but with a different fixed address. """ return UNIXAddress(self._otherAddress) def test_repr(self): """ The repr of L{UNIXAddress} returns with the filename that the L{UNIXAddress} is for. """ self.assertEqual( repr(self.buildAddress()), "UNIXAddress('%s')" % (nativeString(self._socketAddress)), ) @skipIf(symlinkSkip, "Platform does not support symlinks") def test_comparisonOfLinkedFiles(self): """ UNIXAddress objects compare as equal if they link to the same file. """ linkName = self.mktemp() with open(self._socketAddress, "w") as self.fd: os.symlink(os.path.abspath(self._socketAddress), linkName) self.assertEqual(UNIXAddress(self._socketAddress), UNIXAddress(linkName)) self.assertEqual(UNIXAddress(linkName), UNIXAddress(self._socketAddress)) @skipIf(symlinkSkip, "Platform does not support symlinks") def test_hashOfLinkedFiles(self): """ UNIXAddress Objects that compare as equal have the same hash value. """ linkName = self.mktemp() with open(self._socketAddress, "w") as self.fd: os.symlink(os.path.abspath(self._socketAddress), linkName) self.assertEqual( hash(UNIXAddress(self._socketAddress)), hash(UNIXAddress(linkName)) ) @skipIf(unixSkip, "platform doesn't support UNIX sockets.") class EmptyUNIXAddressTests(SynchronousTestCase, AddressTestCaseMixin): """ Tests for L{UNIXAddress} operations involving a L{None} address. """ addressArgSpec = (("name", "%r"),) def setUp(self): self._socketAddress = self.mktemp() def buildAddress(self): """ Create an arbitrary new L{UNIXAddress} instance. A new instance is created for each call, but always for the same address. This builds it with a fixed address of L{None}. """ return UNIXAddress(None) def buildDifferentAddress(self): """ Like L{buildAddress}, but with a random temporary directory. """ return UNIXAddress(self._socketAddress) @skipIf(symlinkSkip, "Platform does not support symlinks") def test_comparisonOfLinkedFiles(self): """ A UNIXAddress referring to a L{None} address does not compare equal to a UNIXAddress referring to a symlink. """ linkName = self.mktemp() with open(self._socketAddress, "w") as self.fd: os.symlink(os.path.abspath(self._socketAddress), linkName) self.assertNotEqual(UNIXAddress(self._socketAddress), UNIXAddress(None)) self.assertNotEqual(UNIXAddress(None), UNIXAddress(self._socketAddress)) def test_emptyHash(self): """ C{__hash__} can be used to get a hash of an address, even one referring to L{None} rather than a real path. """ addr = self.buildAddress() d = {addr: True} self.assertTrue(d[self.buildAddress()]) PK Mb�ZcL?I I ! internet/test/test_win32events.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for implementations of L{IReactorWin32Events}. """ try: import win32event # type: ignore[import] except ImportError: win32event = None from zope.interface.verify import verifyObject from twisted.internet.defer import Deferred from twisted.internet.interfaces import IReactorWin32Events from twisted.internet.test.reactormixins import ReactorBuilder from twisted.python.failure import Failure from twisted.python.threadable import getThreadID, isInIOThread class Listener: """ L{Listener} is an object that can be added to a L{IReactorWin32Events} reactor to receive callback notification when a Windows event is set. It records what thread its callback is invoked in and fires a Deferred. @ivar success: A flag which is set to C{True} when the event callback is called. @ivar logThreadID: The id of the thread in which the C{logPrefix} method is called. @ivar eventThreadID: The id of the thread in which the event callback is called. @ivar connLostThreadID: The id of the thread in which the C{connectionLost} method is called. @ivar _finished: The L{Deferred} which will be fired when the event callback is called. """ success = False logThreadID = eventThreadID = connLostThreadID = None def __init__(self, finished): self._finished = finished def logPrefix(self): self.logThreadID = getThreadID() return "Listener" def occurred(self): self.success = True self.eventThreadID = getThreadID() self._finished.callback(None) def brokenOccurred(self): raise RuntimeError("Some problem") def returnValueOccurred(self): return EnvironmentError("Entirely different problem") def connectionLost(self, reason): self.connLostThreadID = getThreadID() self._finished.errback(reason) class Win32EventsTestsBuilder(ReactorBuilder): """ Builder defining tests relating to L{IReactorWin32Events}. """ requiredInterfaces = [IReactorWin32Events] def test_interface(self): """ An instance of the reactor has all of the methods defined on L{IReactorWin32Events}. """ reactor = self.buildReactor() verifyObject(IReactorWin32Events, reactor) def test_addEvent(self): """ When an event which has been added to the reactor is set, the action associated with the event is invoked in the reactor thread. """ reactorThreadID = getThreadID() reactor = self.buildReactor() event = win32event.CreateEvent(None, False, False, None) finished = Deferred() finished.addCallback(lambda ignored: reactor.stop()) listener = Listener(finished) reactor.addEvent(event, listener, "occurred") reactor.callWhenRunning(win32event.SetEvent, event) self.runReactor(reactor) self.assertTrue(listener.success) self.assertEqual(reactorThreadID, listener.logThreadID) self.assertEqual(reactorThreadID, listener.eventThreadID) def test_ioThreadDoesNotChange(self): """ Using L{IReactorWin32Events.addEvent} does not change which thread is reported as the I/O thread. """ results = [] def check(ignored): results.append(isInIOThread()) reactor.stop() reactor = self.buildReactor() event = win32event.CreateEvent(None, False, False, None) finished = Deferred() listener = Listener(finished) finished.addCallback(check) reactor.addEvent(event, listener, "occurred") reactor.callWhenRunning(win32event.SetEvent, event) self.runReactor(reactor) self.assertTrue(listener.success) self.assertEqual([True], results) def test_disconnectedOnError(self): """ If the event handler raises an exception, the event is removed from the reactor and the handler's C{connectionLost} method is called in the I/O thread and the exception is logged. """ reactorThreadID = getThreadID() reactor = self.buildReactor() event = win32event.CreateEvent(None, False, False, None) result = [] finished = Deferred() finished.addBoth(result.append) finished.addBoth(lambda ignored: reactor.stop()) listener = Listener(finished) reactor.addEvent(event, listener, "brokenOccurred") reactor.callWhenRunning(win32event.SetEvent, event) self.runReactor(reactor) self.assertIsInstance(result[0], Failure) result[0].trap(RuntimeError) self.assertEqual(reactorThreadID, listener.connLostThreadID) self.assertEqual(1, len(self.flushLoggedErrors(RuntimeError))) def test_disconnectOnReturnValue(self): """ If the event handler returns a value, the event is removed from the reactor and the handler's C{connectionLost} method is called in the I/O thread. """ reactorThreadID = getThreadID() reactor = self.buildReactor() event = win32event.CreateEvent(None, False, False, None) result = [] finished = Deferred() finished.addBoth(result.append) finished.addBoth(lambda ignored: reactor.stop()) listener = Listener(finished) reactor.addEvent(event, listener, "returnValueOccurred") reactor.callWhenRunning(win32event.SetEvent, event) self.runReactor(reactor) self.assertIsInstance(result[0], Failure) result[0].trap(EnvironmentError) self.assertEqual(reactorThreadID, listener.connLostThreadID) def test_notDisconnectedOnShutdown(self): """ Event handlers added with L{IReactorWin32Events.addEvent} do not have C{connectionLost} called on them if they are still active when the reactor shuts down. """ reactor = self.buildReactor() event = win32event.CreateEvent(None, False, False, None) finished = Deferred() listener = Listener(finished) reactor.addEvent(event, listener, "occurred") reactor.callWhenRunning(reactor.stop) self.runReactor(reactor) self.assertIsNone(listener.connLostThreadID) globals().update(Win32EventsTestsBuilder.makeTestCaseClasses()) PK Mb�Z UVX�D �D internet/test/test_endpoints.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test the C{I...Endpoint} implementations that wrap the L{IReactorTCP}, L{IReactorSSL}, and L{IReactorUNIX} interfaces found in L{twisted.internet.endpoints}. """ from errno import EPERM from socket import AF_INET, AF_INET6, IPPROTO_TCP, SOCK_STREAM, gaierror from types import FunctionType from unicodedata import normalize from unittest import skipIf from zope.interface import implementer, providedBy, provider from zope.interface.interface import InterfaceClass from zope.interface.verify import verifyClass, verifyObject from twisted import plugins from twisted.internet import ( defer, endpoints, error, interfaces, protocol, reactor, stdio, threads, ) from twisted.internet.abstract import isIPv6Address from twisted.internet.address import ( HostnameAddress, IPv4Address, IPv6Address, UNIXAddress, _ProcessAddress, ) from twisted.internet.endpoints import StandardErrorBehavior from twisted.internet.error import ConnectingCancelledError from twisted.internet.interfaces import ( IConsumer, IHostnameResolver, IPushProducer, IReactorPluggableNameResolver, ITransport, ) from twisted.internet.protocol import ClientFactory, Factory, Protocol from twisted.internet.stdio import PipeAddress from twisted.internet.task import Clock from twisted.internet.testing import ( MemoryReactorClock as MemoryReactor, RaisingMemoryReactor, StringTransport, StringTransportWithDisconnection, ) from twisted.logger import ILogObserver, globalLogPublisher from twisted.plugin import getPlugins from twisted.protocols import basic, policies from twisted.python import log from twisted.python.compat import nativeString from twisted.python.components import proxyForInterface from twisted.python.failure import Failure from twisted.python.filepath import FilePath from twisted.python.modules import getModule from twisted.python.systemd import ListenFDs from twisted.test.iosim import connectableEndpoint, connectedServerAndClient from twisted.trial import unittest pemPath = getModule("twisted.test").filePath.sibling("server.pem") noTrailingNewlineKeyPemPath = getModule("twisted.test").filePath.sibling( "key.pem.no_trailing_newline" ) noTrailingNewlineCertPemPath = getModule("twisted.test").filePath.sibling( "cert.pem.no_trailing_newline" ) casPath = getModule(__name__).filePath.sibling("fake_CAs") chainPath = casPath.child("chain.pem") escapedPEMPathName = endpoints.quoteStringArgument(pemPath.path) escapedNoTrailingNewlineKeyPEMPathName = endpoints.quoteStringArgument( noTrailingNewlineKeyPemPath.path ) escapedNoTrailingNewlineCertPEMPathName = endpoints.quoteStringArgument( noTrailingNewlineCertPemPath.path ) escapedCAsPathName = endpoints.quoteStringArgument(casPath.path) escapedChainPathName = endpoints.quoteStringArgument(chainPath.path) try: from OpenSSL.SSL import ( Context as ContextType, OP_NO_SSLv3, SSLv23_METHOD, TLSv1_METHOD, ) from twisted.internet.ssl import ( Certificate, CertificateOptions, DiffieHellmanParameters, KeyPair, PrivateCertificate, ) from twisted.protocols.tls import TLSMemoryBIOFactory from twisted.test.test_sslverify import makeCertificate testCertificate = Certificate.loadPEM(pemPath.getContent()) testPrivateCertificate = PrivateCertificate.loadPEM(pemPath.getContent()) skipSSL = False skipSSLReason = "" except ImportError as e: skipSSL = True skipSSLReason = str(e) class TestProtocol(Protocol): """ Protocol whose only function is to callback deferreds on the factory when it is connected or disconnected. """ def __init__(self): self.data = [] self.connectionsLost = [] self.connectionMadeCalls = 0 def logPrefix(self): return "A Test Protocol" def connectionMade(self): self.connectionMadeCalls += 1 def dataReceived(self, data): self.data.append(data) def connectionLost(self, reason): self.connectionsLost.append(reason) @implementer(interfaces.IHalfCloseableProtocol) class TestHalfCloseableProtocol(TestProtocol): """ A Protocol that implements L{IHalfCloseableProtocol} and records whether its C{readConnectionLost} and {writeConnectionLost} methods are called. @ivar readLost: A C{bool} indicating whether C{readConnectionLost} has been called. @ivar writeLost: A C{bool} indicating whether C{writeConnectionLost} has been called. """ def __init__(self): TestProtocol.__init__(self) self.readLost = False self.writeLost = False def readConnectionLost(self): self.readLost = True def writeConnectionLost(self): self.writeLost = True @implementer(interfaces.IFileDescriptorReceiver) class TestFileDescriptorReceiverProtocol(TestProtocol): """ A Protocol that implements L{IFileDescriptorReceiver} and records how its C{fileDescriptorReceived} method is called. @ivar receivedDescriptors: A C{list} containing all of the file descriptors passed to C{fileDescriptorReceived} calls made on this instance. """ def connectionMade(self): TestProtocol.connectionMade(self) self.receivedDescriptors = [] def fileDescriptorReceived(self, descriptor): self.receivedDescriptors.append(descriptor) @implementer(interfaces.IHandshakeListener) class TestHandshakeListener(TestProtocol): """ A Protocol that implements L{IHandshakeListener} and records the number of times its C{handshakeCompleted} method has been called. @ivar handshakeCompletedCalls: The number of times C{handshakeCompleted} @type handshakeCompletedCalls: L{int} """ def __init__(self): TestProtocol.__init__(self) self.handshakeCompletedCalls = 0 def handshakeCompleted(self): """ Called when a TLS handshake has completed. Implemented per L{IHandshakeListener} """ self.handshakeCompletedCalls += 1 class TestFactory(ClientFactory): """ Simple factory to be used both when connecting and listening. It contains two deferreds which are called back when my protocol connects and disconnects. """ protocol = TestProtocol class NoneFactory(ClientFactory): """ A one off factory whose C{buildProtocol} returns L{None}. """ def buildProtocol(self, addr): return None class WrappingFactoryTests(unittest.TestCase): """ Test the behaviour of our ugly implementation detail C{_WrappingFactory}. """ def test_doStart(self): """ L{_WrappingFactory.doStart} passes through to the wrapped factory's C{doStart} method, allowing application-specific setup and logging. """ factory = ClientFactory() wf = endpoints._WrappingFactory(factory) wf.doStart() self.assertEqual(1, factory.numPorts) def test_doStop(self): """ L{_WrappingFactory.doStop} passes through to the wrapped factory's C{doStop} method, allowing application-specific cleanup and logging. """ factory = ClientFactory() factory.numPorts = 3 wf = endpoints._WrappingFactory(factory) wf.doStop() self.assertEqual(2, factory.numPorts) def test_failedBuildProtocol(self): """ An exception raised in C{buildProtocol} of our wrappedFactory results in our C{onConnection} errback being fired. """ class BogusFactory(ClientFactory): """ A one off factory whose C{buildProtocol} raises an C{Exception}. """ def buildProtocol(self, addr): raise ValueError("My protocol is poorly defined.") wf = endpoints._WrappingFactory(BogusFactory()) wf.buildProtocol(None) d = self.assertFailure(wf._onConnection, ValueError) d.addCallback( lambda e: self.assertEqual(e.args, ("My protocol is poorly defined.",)) ) return d def test_buildNoneProtocol(self): """ If the wrapped factory's C{buildProtocol} returns L{None} the C{onConnection} errback fires with L{error.NoProtocol}. """ wrappingFactory = endpoints._WrappingFactory(NoneFactory()) wrappingFactory.buildProtocol(None) self.failureResultOf(wrappingFactory._onConnection, error.NoProtocol) def test_buildProtocolReturnsNone(self): """ If the wrapped factory's C{buildProtocol} returns L{None} then L{endpoints._WrappingFactory.buildProtocol} returns L{None}. """ wrappingFactory = endpoints._WrappingFactory(NoneFactory()) # Discard the failure this Deferred will get wrappingFactory._onConnection.addErrback(lambda reason: None) self.assertIsNone(wrappingFactory.buildProtocol(None)) def test_logPrefixPassthrough(self): """ If the wrapped protocol provides L{ILoggingContext}, whatever is returned from the wrapped C{logPrefix} method is returned from L{_WrappingProtocol.logPrefix}. """ wf = endpoints._WrappingFactory(TestFactory()) wp = wf.buildProtocol(None) self.assertEqual(wp.logPrefix(), "A Test Protocol") def test_logPrefixDefault(self): """ If the wrapped protocol does not provide L{ILoggingContext}, the wrapped protocol's class name is returned from L{_WrappingProtocol.logPrefix}. """ class NoProtocol: pass factory = TestFactory() factory.protocol = NoProtocol wf = endpoints._WrappingFactory(factory) wp = wf.buildProtocol(None) self.assertEqual(wp.logPrefix(), "NoProtocol") def test_wrappedProtocolDataReceived(self): """ The wrapped C{Protocol}'s C{dataReceived} will get called when our C{_WrappingProtocol}'s C{dataReceived} gets called. """ wf = endpoints._WrappingFactory(TestFactory()) p = wf.buildProtocol(None) p.makeConnection(None) p.dataReceived(b"foo") self.assertEqual(p._wrappedProtocol.data, [b"foo"]) p.dataReceived(b"bar") self.assertEqual(p._wrappedProtocol.data, [b"foo", b"bar"]) def test_wrappedProtocolTransport(self): """ Our transport is properly hooked up to the wrappedProtocol when a connection is made. """ wf = endpoints._WrappingFactory(TestFactory()) p = wf.buildProtocol(None) dummyTransport = object() p.makeConnection(dummyTransport) self.assertEqual(p.transport, dummyTransport) self.assertEqual(p._wrappedProtocol.transport, dummyTransport) def test_wrappedProtocolConnectionLost(self): """ Our wrappedProtocol's connectionLost method is called when L{_WrappingProtocol.connectionLost} is called. """ tf = TestFactory() wf = endpoints._WrappingFactory(tf) p = wf.buildProtocol(None) p.connectionLost("fail") self.assertEqual(p._wrappedProtocol.connectionsLost, ["fail"]) def test_clientConnectionFailed(self): """ Calls to L{_WrappingFactory.clientConnectionLost} should errback the L{_WrappingFactory._onConnection} L{Deferred} """ wf = endpoints._WrappingFactory(TestFactory()) expectedFailure = Failure(error.ConnectError(string="fail")) wf.clientConnectionFailed(None, expectedFailure) errors = [] def gotError(f): errors.append(f) wf._onConnection.addErrback(gotError) self.assertEqual(errors, [expectedFailure]) def test_wrappingProtocolFileDescriptorReceiver(self): """ Our L{_WrappingProtocol} should be an L{IFileDescriptorReceiver} if the wrapped protocol is. """ connectedDeferred = None applicationProtocol = TestFileDescriptorReceiverProtocol() wrapper = endpoints._WrappingProtocol(connectedDeferred, applicationProtocol) self.assertTrue(interfaces.IFileDescriptorReceiver.providedBy(wrapper)) self.assertTrue(verifyObject(interfaces.IFileDescriptorReceiver, wrapper)) def test_wrappingProtocolNotFileDescriptorReceiver(self): """ Our L{_WrappingProtocol} does not provide L{IHalfCloseableProtocol} if the wrapped protocol doesn't. """ tp = TestProtocol() p = endpoints._WrappingProtocol(None, tp) self.assertFalse(interfaces.IFileDescriptorReceiver.providedBy(p)) def test_wrappedProtocolFileDescriptorReceived(self): """ L{_WrappingProtocol.fileDescriptorReceived} calls the wrapped protocol's C{fileDescriptorReceived} method. """ wrappedProtocol = TestFileDescriptorReceiverProtocol() wrapper = endpoints._WrappingProtocol(defer.Deferred(), wrappedProtocol) wrapper.makeConnection(StringTransport()) wrapper.fileDescriptorReceived(42) self.assertEqual(wrappedProtocol.receivedDescriptors, [42]) def test_wrappingProtocolHalfCloseable(self): """ Our L{_WrappingProtocol} should be an L{IHalfCloseableProtocol} if the C{wrappedProtocol} is. """ cd = object() hcp = TestHalfCloseableProtocol() p = endpoints._WrappingProtocol(cd, hcp) self.assertEqual(interfaces.IHalfCloseableProtocol.providedBy(p), True) def test_wrappingProtocolNotHalfCloseable(self): """ Our L{_WrappingProtocol} should not provide L{IHalfCloseableProtocol} if the C{WrappedProtocol} doesn't. """ tp = TestProtocol() p = endpoints._WrappingProtocol(None, tp) self.assertEqual(interfaces.IHalfCloseableProtocol.providedBy(p), False) def test_wrappingProtocolHandshakeListener(self): """ Our L{_WrappingProtocol} should be an L{IHandshakeListener} if the C{wrappedProtocol} is. """ handshakeListener = TestHandshakeListener() wrapped = endpoints._WrappingProtocol(None, handshakeListener) self.assertTrue(interfaces.IHandshakeListener.providedBy(wrapped)) def test_wrappingProtocolNotHandshakeListener(self): """ Our L{_WrappingProtocol} should not provide L{IHandshakeListener} if the C{wrappedProtocol} doesn't. """ tp = TestProtocol() p = endpoints._WrappingProtocol(None, tp) self.assertFalse(interfaces.IHandshakeListener.providedBy(p)) def test_wrappedProtocolReadConnectionLost(self): """ L{_WrappingProtocol.readConnectionLost} should proxy to the wrapped protocol's C{readConnectionLost} """ hcp = TestHalfCloseableProtocol() p = endpoints._WrappingProtocol(None, hcp) p.readConnectionLost() self.assertTrue(hcp.readLost) def test_wrappedProtocolWriteConnectionLost(self): """ L{_WrappingProtocol.writeConnectionLost} should proxy to the wrapped protocol's C{writeConnectionLost} """ hcp = TestHalfCloseableProtocol() p = endpoints._WrappingProtocol(None, hcp) p.writeConnectionLost() self.assertTrue(hcp.writeLost) def test_wrappedProtocolHandshakeCompleted(self): """ L{_WrappingProtocol.handshakeCompleted} should proxy to the wrapped protocol's C{handshakeCompleted} """ listener = TestHandshakeListener() wrapped = endpoints._WrappingProtocol(None, listener) wrapped.handshakeCompleted() self.assertEqual(listener.handshakeCompletedCalls, 1) class ClientEndpointTestCaseMixin: """ Generic test methods to be mixed into all client endpoint test classes. """ def test_interface(self): """ The endpoint provides L{interfaces.IStreamClientEndpoint} """ clientFactory = object() ep, ignoredArgs, address = self.createClientEndpoint( MemoryReactor(), clientFactory ) self.assertTrue(verifyObject(interfaces.IStreamClientEndpoint, ep)) def retrieveConnectedFactory(self, reactor): """ Retrieve a single factory that has connected using the given reactor. (This behavior is valid for TCP and SSL but needs to be overridden for UNIX.) @param reactor: a L{MemoryReactor} """ return self.expectedClients(reactor)[0][2] def test_endpointConnectSuccess(self): """ A client endpoint can connect and returns a deferred who gets called back with a protocol instance. """ proto = object() mreactor = MemoryReactor() clientFactory = object() ep, expectedArgs, ignoredDest = self.createClientEndpoint( mreactor, clientFactory ) d = ep.connect(clientFactory) receivedProtos = [] def checkProto(p): receivedProtos.append(p) d.addCallback(checkProto) factory = self.retrieveConnectedFactory(mreactor) factory._onConnection.callback(proto) self.assertEqual(receivedProtos, [proto]) expectedClients = self.expectedClients(mreactor) self.assertEqual(len(expectedClients), 1) self.assertConnectArgs(expectedClients[0], expectedArgs) def test_endpointConnectFailure(self): """ If an endpoint tries to connect to a non-listening port it gets a C{ConnectError} failure. """ expectedError = error.ConnectError(string="Connection Failed") mreactor = RaisingMemoryReactor(connectException=expectedError) clientFactory = object() ep, ignoredArgs, ignoredDest = self.createClientEndpoint( mreactor, clientFactory ) d = ep.connect(clientFactory) receivedExceptions = [] def checkFailure(f): receivedExceptions.append(f.value) d.addErrback(checkFailure) self.assertEqual(receivedExceptions, [expectedError]) def test_endpointConnectingCancelled(self): """ Calling L{Deferred.cancel} on the L{Deferred} returned from L{IStreamClientEndpoint.connect} is errbacked with an expected L{ConnectingCancelledError} exception. """ mreactor = MemoryReactor() clientFactory = object() ep, ignoredArgs, address = self.createClientEndpoint(mreactor, clientFactory) d = ep.connect(clientFactory) receivedFailures = [] def checkFailure(f): receivedFailures.append(f) d.addErrback(checkFailure) d.cancel() # When canceled, the connector will immediately notify its factory that # the connection attempt has failed due to a UserError. attemptFactory = self.retrieveConnectedFactory(mreactor) attemptFactory.clientConnectionFailed(None, Failure(error.UserError())) # This should be a feature of MemoryReactor: <http://tm.tl/5630>. self.assertEqual(len(receivedFailures), 1) failure = receivedFailures[0] self.assertIsInstance(failure.value, error.ConnectingCancelledError) self.assertEqual(failure.value.address, address) def test_endpointConnectNonDefaultArgs(self): """ The endpoint should pass it's connectArgs parameter to the reactor's listen methods. """ factory = object() mreactor = MemoryReactor() ep, expectedArgs, ignoredHost = self.createClientEndpoint( mreactor, factory, **self.connectArgs() ) ep.connect(factory) expectedClients = self.expectedClients(mreactor) self.assertEqual(len(expectedClients), 1) self.assertConnectArgs(expectedClients[0], expectedArgs) class ServerEndpointTestCaseMixin: """ Generic test methods to be mixed into all client endpoint test classes. """ def test_interface(self): """ The endpoint provides L{interfaces.IStreamServerEndpoint}. """ factory = object() ep, ignoredArgs, ignoredDest = self.createServerEndpoint( MemoryReactor(), factory ) self.assertTrue(verifyObject(interfaces.IStreamServerEndpoint, ep)) def test_endpointListenSuccess(self): """ An endpoint can listen and returns a deferred that gets called back with a port instance. """ mreactor = MemoryReactor() factory = object() ep, expectedArgs, expectedHost = self.createServerEndpoint(mreactor, factory) d = ep.listen(factory) receivedHosts = [] def checkPortAndServer(port): receivedHosts.append(port.getHost()) d.addCallback(checkPortAndServer) self.assertEqual(receivedHosts, [expectedHost]) self.assertEqual(self.expectedServers(mreactor), [expectedArgs]) def test_endpointListenFailure(self): """ When an endpoint tries to listen on an already listening port, a C{CannotListenError} failure is errbacked. """ factory = object() exception = error.CannotListenError("", 80, factory) mreactor = RaisingMemoryReactor(listenException=exception) ep, ignoredArgs, ignoredDest = self.createServerEndpoint(mreactor, factory) d = ep.listen(object()) receivedExceptions = [] def checkFailure(f): receivedExceptions.append(f.value) d.addErrback(checkFailure) self.assertEqual(receivedExceptions, [exception]) def test_endpointListenNonDefaultArgs(self): """ The endpoint should pass it's listenArgs parameter to the reactor's listen methods. """ factory = object() mreactor = MemoryReactor() ep, expectedArgs, ignoredHost = self.createServerEndpoint( mreactor, factory, **self.listenArgs() ) ep.listen(factory) expectedServers = self.expectedServers(mreactor) self.assertEqual(expectedServers, [expectedArgs]) class EndpointTestCaseMixin(ServerEndpointTestCaseMixin, ClientEndpointTestCaseMixin): """ Generic test methods to be mixed into all endpoint test classes. """ class SpecificFactory(Factory): """ An L{IProtocolFactory} whose C{buildProtocol} always returns its C{specificProtocol} and sets C{passedAddress}. Raising an exception if C{specificProtocol} has already been used. """ def __init__(self, specificProtocol): self.specificProtocol = specificProtocol def buildProtocol(self, addr): if hasattr(self.specificProtocol, "passedAddress"): raise ValueError("specificProtocol already used.") self.specificProtocol.passedAddress = addr return self.specificProtocol class FakeStdio: """ A L{stdio.StandardIO} like object that simply captures its constructor arguments. """ def __init__(self, protocolInstance, reactor=None): """ @param protocolInstance: like the first argument of L{stdio.StandardIO} @param reactor: like the reactor keyword argument of L{stdio.StandardIO} """ self.protocolInstance = protocolInstance self.reactor = reactor class StandardIOEndpointsTests(unittest.TestCase): """ Tests for Standard I/O Endpoints """ def setUp(self): """ Construct a L{StandardIOEndpoint} with a dummy reactor and a fake L{stdio.StandardIO} like object. Listening on it with a L{SpecificFactory}. """ self.reactor = object() endpoint = endpoints.StandardIOEndpoint(self.reactor) self.assertIs(endpoint._stdio, stdio.StandardIO) endpoint._stdio = FakeStdio self.specificProtocol = Protocol() self.fakeStdio = self.successResultOf( endpoint.listen(SpecificFactory(self.specificProtocol)) ) def test_protocolCreation(self): """ L{StandardIOEndpoint} returns a L{Deferred} that fires with an instance of a L{stdio.StandardIO} like object that was passed the result of L{SpecificFactory.buildProtocol} which was passed a L{PipeAddress}. """ self.assertIs(self.fakeStdio.protocolInstance, self.specificProtocol) self.assertIsInstance( self.fakeStdio.protocolInstance.passedAddress, PipeAddress ) def test_passedReactor(self): """ L{StandardIOEndpoint} passes its C{reactor} argument to the constructor of its L{stdio.StandardIO} like object. """ self.assertIs(self.fakeStdio.reactor, self.reactor) class StubApplicationProtocol(protocol.Protocol): """ An L{IProtocol} provider. """ def dataReceived(self, data): """ @param data: The data received by the protocol. @type data: str """ self.data = data def connectionLost(self, reason): """ @type reason: L{twisted.python.failure.Failure} """ self.reason = reason @implementer(interfaces.IProcessTransport) class MemoryProcessTransport(StringTransportWithDisconnection): """ A fake L{IProcessTransport} provider to be used in tests. """ def __init__(self, protocol=None): super().__init__(hostAddress=_ProcessAddress(), peerAddress=_ProcessAddress()) self.signals = [] self.closedChildFDs = set() self.protocol = Protocol() def writeToChild(self, childFD, data): if childFD == 0: self.write(data) def closeStdin(self): self.closeChildFD(0) def closeStdout(self): self.closeChildFD(1) def closeStderr(self): self.closeChildFD(2) def closeChildFD(self, fd): self.closedChildFDs.add(fd) def signalProcess(self, signal): self.signals.append(signal) def pid(self): # IProcessTransport.pid pass verifyClass(interfaces.IConsumer, MemoryProcessTransport) verifyClass(interfaces.IPushProducer, MemoryProcessTransport) verifyClass(interfaces.IProcessTransport, MemoryProcessTransport) @implementer(interfaces.IReactorProcess) class MemoryProcessReactor: """ A fake L{IReactorProcess} provider to be used in tests. """ def spawnProcess( self, processProtocol, executable, args=(), env={}, path=None, uid=None, gid=None, usePTY=0, childFDs=None, ): """ @ivar processProtocol: Stores the protocol passed to the reactor. @return: An L{IProcessTransport} provider. """ self.processProtocol = processProtocol self.executable = executable self.args = args self.env = env self.path = path self.uid = uid self.gid = gid self.usePTY = usePTY self.childFDs = childFDs self.processTransport = MemoryProcessTransport() self.processProtocol.makeConnection(self.processTransport) return self.processTransport class ProcessEndpointsTests(unittest.TestCase): """ Tests for child process endpoints. """ def setUp(self): self.reactor = MemoryProcessReactor() self.ep = endpoints.ProcessEndpoint(self.reactor, b"/bin/executable") self.factory = protocol.Factory() self.factory.protocol = StubApplicationProtocol def test_constructorDefaults(self): """ Default values are set for the optional parameters in the endpoint. """ self.assertIsInstance(self.ep._reactor, MemoryProcessReactor) self.assertEqual(self.ep._executable, b"/bin/executable") self.assertEqual(self.ep._args, ()) self.assertEqual(self.ep._env, {}) self.assertIsNone(self.ep._path) self.assertIsNone(self.ep._uid) self.assertIsNone(self.ep._gid) self.assertEqual(self.ep._usePTY, 0) self.assertIsNone(self.ep._childFDs) self.assertEqual(self.ep._errFlag, StandardErrorBehavior.LOG) def test_constructorNonDefaults(self): """ The parameters passed to the endpoint are stored in it. """ environ = {b"HOME": None} ep = endpoints.ProcessEndpoint( MemoryProcessReactor(), b"/bin/executable", [b"/bin/executable"], {b"HOME": environ[b"HOME"]}, b"/runProcessHere/", 1, 2, True, {3: "w", 4: "r", 5: "r"}, StandardErrorBehavior.DROP, ) self.assertIsInstance(ep._reactor, MemoryProcessReactor) self.assertEqual(ep._executable, b"/bin/executable") self.assertEqual(ep._args, [b"/bin/executable"]) self.assertEqual(ep._env, {b"HOME": environ[b"HOME"]}) self.assertEqual(ep._path, b"/runProcessHere/") self.assertEqual(ep._uid, 1) self.assertEqual(ep._gid, 2) self.assertTrue(ep._usePTY) self.assertEqual(ep._childFDs, {3: "w", 4: "r", 5: "r"}) self.assertEqual(ep._errFlag, StandardErrorBehavior.DROP) def test_wrappedProtocol(self): """ The wrapper function _WrapIProtocol gives an IProcessProtocol implementation that wraps over an IProtocol. """ d = self.ep.connect(self.factory) self.successResultOf(d) wpp = self.reactor.processProtocol self.assertIsInstance(wpp, endpoints._WrapIProtocol) def test_spawnProcess(self): """ The parameters for spawnProcess stored in the endpoint are passed when the endpoint's connect method is invoked. """ environ = {b"HOME": None} memoryReactor = MemoryProcessReactor() ep = endpoints.ProcessEndpoint( memoryReactor, b"/bin/executable", [b"/bin/executable"], {b"HOME": environ[b"HOME"]}, b"/runProcessHere/", 1, 2, True, {3: "w", 4: "r", 5: "r"}, ) d = ep.connect(self.factory) self.successResultOf(d) self.assertIsInstance(memoryReactor.processProtocol, endpoints._WrapIProtocol) self.assertEqual(memoryReactor.executable, ep._executable) self.assertEqual(memoryReactor.args, ep._args) self.assertEqual(memoryReactor.env, ep._env) self.assertEqual(memoryReactor.path, ep._path) self.assertEqual(memoryReactor.uid, ep._uid) self.assertEqual(memoryReactor.gid, ep._gid) self.assertEqual(memoryReactor.usePTY, ep._usePTY) self.assertEqual(memoryReactor.childFDs, ep._childFDs) def test_processAddress(self): """ The address passed to the factory's buildProtocol in the endpoint is a _ProcessAddress instance. """ class TestAddrFactory(protocol.Factory): protocol = StubApplicationProtocol address = None def buildProtocol(self, addr): self.address = addr p = self.protocol() p.factory = self return p myFactory = TestAddrFactory() d = self.ep.connect(myFactory) self.successResultOf(d) self.assertIsInstance(myFactory.address, _ProcessAddress) def test_connect(self): """ L{ProcessEndpoint.connect} returns a Deferred with the connected protocol. """ proto = self.successResultOf(self.ep.connect(self.factory)) self.assertIsInstance(proto, StubApplicationProtocol) def test_connectFailure(self): """ In case of failure, L{ProcessEndpoint.connect} returns a Deferred that fails. """ def testSpawnProcess( pp, executable, args, env, path, uid, gid, usePTY, childFDs ): raise Exception() self.ep._spawnProcess = testSpawnProcess d = self.ep.connect(self.factory) error = self.failureResultOf(d) error.trap(Exception) class ProcessEndpointTransportTests(unittest.TestCase): """ Test the behaviour of the implementation detail L{endpoints._ProcessEndpointTransport}. """ def setUp(self): self.reactor = MemoryProcessReactor() self.endpoint = endpoints.ProcessEndpoint(self.reactor, b"/bin/executable") protocol = self.successResultOf( self.endpoint.connect(Factory.forProtocol(Protocol)) ) self.process = self.reactor.processTransport self.endpointTransport = protocol.transport def test_verifyConsumer(self): """ L{_ProcessEndpointTransport}s provide L{IConsumer}. """ verifyObject(IConsumer, self.endpointTransport) def test_verifyProducer(self): """ L{_ProcessEndpointTransport}s provide L{IPushProducer}. """ verifyObject(IPushProducer, self.endpointTransport) def test_verifyTransport(self): """ L{_ProcessEndpointTransport}s provide L{ITransport}. """ verifyObject(ITransport, self.endpointTransport) def test_constructor(self): """ The L{_ProcessEndpointTransport} instance stores the process passed to it. """ self.assertIs(self.endpointTransport._process, self.process) def test_registerProducer(self): """ Registering a producer with the endpoint transport registers it with the underlying process transport. """ @implementer(IPushProducer) class AProducer: pass aProducer = AProducer() self.endpointTransport.registerProducer(aProducer, False) self.assertIs(self.process.producer, aProducer) def test_pauseProducing(self): """ Pausing the endpoint transport pauses the underlying process transport. """ self.endpointTransport.pauseProducing() self.assertEqual(self.process.producerState, "paused") def test_resumeProducing(self): """ Resuming the endpoint transport resumes the underlying process transport. """ self.test_pauseProducing() self.endpointTransport.resumeProducing() self.assertEqual(self.process.producerState, "producing") def test_stopProducing(self): """ Stopping the endpoint transport as a producer stops the underlying process transport. """ self.endpointTransport.stopProducing() self.assertEqual(self.process.producerState, "stopped") def test_unregisterProducer(self): """ Unregistring the endpoint transport's producer unregisters the underlying process transport's producer. """ self.test_registerProducer() self.endpointTransport.unregisterProducer() self.assertIsNone(self.process.producer) def test_extraneousAttributes(self): """ L{endpoints._ProcessEndpointTransport} filters out extraneous attributes of its underlying transport, to present a more consistent cross-platform view of subprocesses and prevent accidental dependencies. """ self.process.pipes = [] self.assertRaises(AttributeError, getattr, self.endpointTransport, "pipes") def test_writeSequence(self): """ The writeSequence method of L{_ProcessEndpointTransport} writes a list of string passed to it to the transport's stdin. """ self.endpointTransport.writeSequence([b"test1", b"test2", b"test3"]) self.assertEqual(self.process.io.getvalue(), b"test1test2test3") def test_write(self): """ The write method of L{_ProcessEndpointTransport} writes a string of data passed to it to the child process's stdin. """ self.endpointTransport.write(b"test") self.assertEqual(self.process.io.getvalue(), b"test") def test_loseConnection(self): """ A call to the loseConnection method of a L{_ProcessEndpointTransport} instance returns a call to the process transport's loseConnection. """ self.endpointTransport.loseConnection() self.assertFalse(self.process.connected) def test_getHost(self): """ L{_ProcessEndpointTransport.getHost} returns a L{_ProcessAddress} instance matching the process C{getHost}. """ host = self.endpointTransport.getHost() self.assertIsInstance(host, _ProcessAddress) self.assertIs(host, self.process.getHost()) def test_getPeer(self): """ L{_ProcessEndpointTransport.getPeer} returns a L{_ProcessAddress} instance matching the process C{getPeer}. """ peer = self.endpointTransport.getPeer() self.assertIsInstance(peer, _ProcessAddress) self.assertIs(peer, self.process.getPeer()) class WrappedIProtocolTests(unittest.TestCase): """ Test the behaviour of the implementation detail C{_WrapIProtocol}. """ def setUp(self): self.reactor = MemoryProcessReactor() self.ep = endpoints.ProcessEndpoint(self.reactor, b"/bin/executable") self.eventLog = None self.factory = protocol.Factory() self.factory.protocol = StubApplicationProtocol def test_constructor(self): """ Stores an L{IProtocol} provider and the flag to log/drop stderr """ d = self.ep.connect(self.factory) self.successResultOf(d) wpp = self.reactor.processProtocol self.assertIsInstance(wpp.protocol, StubApplicationProtocol) self.assertEqual(wpp.errFlag, self.ep._errFlag) def test_makeConnection(self): """ Our process transport is properly hooked up to the wrappedIProtocol when a connection is made. """ d = self.ep.connect(self.factory) self.successResultOf(d) wpp = self.reactor.processProtocol self.assertEqual(wpp.protocol.transport, wpp.transport) def _stdLog(self, eventDict): """ A log observer. """ self.eventLog = eventDict def test_logStderr(self): """ When the _errFlag is set to L{StandardErrorBehavior.LOG}, L{endpoints._WrapIProtocol} logs stderr (in childDataReceived). """ d = self.ep.connect(self.factory) self.successResultOf(d) wpp = self.reactor.processProtocol log.addObserver(self._stdLog) self.addCleanup(log.removeObserver, self._stdLog) wpp.childDataReceived(2, b"stderr1") self.assertEqual(self.eventLog["executable"], wpp.executable) self.assertEqual(self.eventLog["data"], b"stderr1") self.assertEqual(self.eventLog["protocol"], wpp.protocol) self.assertIn("wrote stderr unhandled by", log.textFromEventDict(self.eventLog)) def test_stderrSkip(self): """ When the _errFlag is set to L{StandardErrorBehavior.DROP}, L{endpoints._WrapIProtocol} ignores stderr. """ self.ep._errFlag = StandardErrorBehavior.DROP d = self.ep.connect(self.factory) self.successResultOf(d) wpp = self.reactor.processProtocol log.addObserver(self._stdLog) self.addCleanup(log.removeObserver, self._stdLog) wpp.childDataReceived(2, b"stderr2") self.assertIsNone(self.eventLog) def test_stdout(self): """ In childDataReceived of L{_WrappedIProtocol} instance, the protocol's dataReceived is called when stdout is generated. """ d = self.ep.connect(self.factory) self.successResultOf(d) wpp = self.reactor.processProtocol wpp.childDataReceived(1, b"stdout") self.assertEqual(wpp.protocol.data, b"stdout") def test_processDone(self): """ L{error.ProcessDone} with status=0 is turned into a clean disconnect type, i.e. L{error.ConnectionDone}. """ d = self.ep.connect(self.factory) self.successResultOf(d) wpp = self.reactor.processProtocol wpp.processEnded(Failure(error.ProcessDone(0))) self.assertEqual( wpp.protocol.reason.check(error.ConnectionDone), error.ConnectionDone ) def test_processEnded(self): """ Exceptions other than L{error.ProcessDone} with status=0 are turned into L{error.ConnectionLost}. """ d = self.ep.connect(self.factory) self.successResultOf(d) wpp = self.reactor.processProtocol wpp.processEnded(Failure(error.ProcessTerminated())) self.assertEqual( wpp.protocol.reason.check(error.ConnectionLost), error.ConnectionLost ) class TCP4EndpointsTests(EndpointTestCaseMixin, unittest.TestCase): """ Tests for TCP IPv4 Endpoints. """ def expectedServers(self, reactor): """ @return: List of calls to L{IReactorTCP.listenTCP} """ return reactor.tcpServers def expectedClients(self, reactor): """ @return: List of calls to L{IReactorTCP.connectTCP} """ return reactor.tcpClients def assertConnectArgs(self, receivedArgs, expectedArgs): """ Compare host, port, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorTCP.connectTCP}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorTCP.connectTCP}. """ (host, port, ignoredFactory, timeout, bindAddress) = receivedArgs ( expectedHost, expectedPort, _ignoredFactory, expectedTimeout, expectedBindAddress, ) = expectedArgs self.assertEqual(host, expectedHost) self.assertEqual(port, expectedPort) self.assertEqual(timeout, expectedTimeout) self.assertEqual(bindAddress, expectedBindAddress) def connectArgs(self): """ @return: C{dict} of keyword arguments to pass to connect. """ return {"timeout": 10, "bindAddress": ("localhost", 49595)} def listenArgs(self): """ @return: C{dict} of keyword arguments to pass to listen """ return {"backlog": 100, "interface": "127.0.0.1"} def createServerEndpoint(self, reactor, factory, **listenArgs): """ Create an L{TCP4ServerEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorTCP} that L{TCP4ServerEndpoint} can call L{IReactorTCP.listenTCP} on. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param listenArgs: Optional dictionary of arguments to L{IReactorTCP.listenTCP}. """ address = IPv4Address("TCP", "0.0.0.0", 0) return ( endpoints.TCP4ServerEndpoint(reactor, address.port, **listenArgs), ( address.port, factory, listenArgs.get("backlog", 50), listenArgs.get("interface", ""), ), address, ) def createClientEndpoint(self, reactor, clientFactory, **connectArgs): """ Create an L{TCP4ClientEndpoint} and return the values needed to verify its behavior. @param reactor: A fake L{IReactorTCP} that L{TCP4ClientEndpoint} can call L{IReactorTCP.connectTCP} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorTCP.connectTCP} """ address = IPv4Address("TCP", "localhost", 80) return ( endpoints.TCP4ClientEndpoint( reactor, address.host, address.port, **connectArgs ), ( address.host, address.port, clientFactory, connectArgs.get("timeout", 30), connectArgs.get("bindAddress", None), ), address, ) class TCP6EndpointsTests(EndpointTestCaseMixin, unittest.TestCase): """ Tests for TCP IPv6 Endpoints. """ def expectedServers(self, reactor): """ @return: List of calls to L{IReactorTCP.listenTCP} """ return reactor.tcpServers def expectedClients(self, reactor): """ @return: List of calls to L{IReactorTCP.connectTCP} """ return reactor.tcpClients def assertConnectArgs(self, receivedArgs, expectedArgs): """ Compare host, port, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorTCP.connectTCP}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorTCP.connectTCP}. """ (host, port, ignoredFactory, timeout, bindAddress) = receivedArgs ( expectedHost, expectedPort, _ignoredFactory, expectedTimeout, expectedBindAddress, ) = expectedArgs self.assertEqual(host, expectedHost) self.assertEqual(port, expectedPort) self.assertEqual(timeout, expectedTimeout) self.assertEqual(bindAddress, expectedBindAddress) def connectArgs(self): """ @return: C{dict} of keyword arguments to pass to connect. """ return {"timeout": 10, "bindAddress": ("localhost", 49595)} def listenArgs(self): """ @return: C{dict} of keyword arguments to pass to listen """ return {"backlog": 100, "interface": "::1"} def createServerEndpoint(self, reactor, factory, **listenArgs): """ Create a L{TCP6ServerEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorTCP} that L{TCP6ServerEndpoint} can call L{IReactorTCP.listenTCP} on. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param listenArgs: Optional dictionary of arguments to L{IReactorTCP.listenTCP}. """ interface = listenArgs.get("interface", "::") address = IPv6Address("TCP", interface, 0) return ( endpoints.TCP6ServerEndpoint(reactor, address.port, **listenArgs), (address.port, factory, listenArgs.get("backlog", 50), interface), address, ) def createClientEndpoint(self, reactor, clientFactory, **connectArgs): """ Create a L{TCP6ClientEndpoint} and return the values needed to verify its behavior. @param reactor: A fake L{IReactorTCP} that L{TCP6ClientEndpoint} can call L{IReactorTCP.connectTCP} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorTCP.connectTCP} """ address = IPv6Address("TCP", "::1", 80) return ( endpoints.TCP6ClientEndpoint( reactor, address.host, address.port, **connectArgs ), ( address.host, address.port, clientFactory, connectArgs.get("timeout", 30), connectArgs.get("bindAddress", None), ), address, ) class TCP6EndpointNameResolutionTests(ClientEndpointTestCaseMixin, unittest.TestCase): """ Tests for a TCP IPv6 Client Endpoint pointed at a hostname instead of an IPv6 address literal. """ def createClientEndpoint(self, reactor, clientFactory, **connectArgs): """ Create a L{TCP6ClientEndpoint} and return the values needed to verify its behavior. @param reactor: A fake L{IReactorTCP} that L{TCP6ClientEndpoint} can call L{IReactorTCP.connectTCP} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorTCP.connectTCP} """ address = IPv6Address("TCP", "::2", 80) self.ep = endpoints.TCP6ClientEndpoint( reactor, "ipv6.example.com", address.port, **connectArgs ) def testNameResolution(host): self.assertEqual("ipv6.example.com", host) data = [ (AF_INET6, SOCK_STREAM, IPPROTO_TCP, "", ("::2", 0, 0, 0)), (AF_INET6, SOCK_STREAM, IPPROTO_TCP, "", ("::3", 0, 0, 0)), (AF_INET6, SOCK_STREAM, IPPROTO_TCP, "", ("::4", 0, 0, 0)), ] return defer.succeed(data) self.ep._nameResolution = testNameResolution return ( self.ep, ( address.host, address.port, clientFactory, connectArgs.get("timeout", 30), connectArgs.get("bindAddress", None), ), address, ) def connectArgs(self): """ @return: C{dict} of keyword arguments to pass to connect. """ return {"timeout": 10, "bindAddress": ("localhost", 49595)} def expectedClients(self, reactor): """ @return: List of calls to L{IReactorTCP.connectTCP} """ return reactor.tcpClients def assertConnectArgs(self, receivedArgs, expectedArgs): """ Compare host, port, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorTCP.connectTCP}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorTCP.connectTCP}. """ (host, port, ignoredFactory, timeout, bindAddress) = receivedArgs ( expectedHost, expectedPort, _ignoredFactory, expectedTimeout, expectedBindAddress, ) = expectedArgs self.assertEqual(host, expectedHost) self.assertEqual(port, expectedPort) self.assertEqual(timeout, expectedTimeout) self.assertEqual(bindAddress, expectedBindAddress) def test_freeFunctionDeferToThread(self): """ By default, L{TCP6ClientEndpoint._deferToThread} is L{threads.deferToThread}. """ ep = endpoints.TCP6ClientEndpoint(None, "www.example.com", 1234) self.assertEqual(ep._deferToThread, threads.deferToThread) def test_nameResolution(self): """ While resolving hostnames, _nameResolution calls _deferToThread with _getaddrinfo. """ calls = [] def fakeDeferToThread(f, *args, **kwargs): calls.append((f, args, kwargs)) return defer.Deferred() endpoint = endpoints.TCP6ClientEndpoint(reactor, "ipv6.example.com", 1234) fakegetaddrinfo = object() endpoint._getaddrinfo = fakegetaddrinfo endpoint._deferToThread = fakeDeferToThread endpoint.connect(TestFactory()) self.assertEqual( [(fakegetaddrinfo, ("ipv6.example.com", 0, AF_INET6), {})], calls ) class RaisingMemoryReactorWithClock(RaisingMemoryReactor, Clock): """ An extension of L{RaisingMemoryReactor} with L{task.Clock}. """ def __init__(self, listenException=None, connectException=None): Clock.__init__(self) RaisingMemoryReactor.__init__(self, listenException, connectException) def deterministicResolvingReactor(reactor, expectedAddresses=(), hostMap=None): """ Create a reactor that will deterministically resolve all hostnames it is passed to the list of addresses given. @param reactor: An object that we wish to add an L{IReactorPluggableNameResolver} to. @type reactor: Any object with some formally-declared interfaces (i.e. one where C{list(providedBy(reactor))} is not empty); usually C{IReactor*} interfaces. @param expectedAddresses: (optional); the addresses expected to be returned for every address. If these are strings, they should be IPv4 or IPv6 literals, and they will be wrapped in L{IPv4Address} and L{IPv6Address} objects in the resolution result. @type expectedAddresses: iterable of C{object} or C{str} @param hostMap: (optional); the names (unicode) mapped to lists of addresses (str or L{IAddress}); in the same format as expectedAddress, which map the results for I{specific} hostnames to addresses. @return: A new reactor which provides all the interfaces previously provided by C{reactor} as well as L{IReactorPluggableNameResolver}. All name resolutions performed with its C{nameResolver} attribute will resolve reentrantly and synchronously with the given C{expectedAddresses}. However, it is not a complete implementation as it does not have an C{installNameResolver} method. """ if hostMap is None: hostMap = {} hostMap = hostMap.copy() @implementer(IHostnameResolver) class SimpleNameResolver: @staticmethod def resolveHostName( resolutionReceiver, hostName, portNumber=0, addressTypes=None, transportSemantics="TCP", ): resolutionReceiver.resolutionBegan(None) for expectedAddress in hostMap.get(hostName, expectedAddresses): if isinstance(expectedAddress, str): expectedAddress = [IPv4Address, IPv6Address][ isIPv6Address(expectedAddress) ]("TCP", expectedAddress, portNumber) resolutionReceiver.addressResolved(expectedAddress) resolutionReceiver.resolutionComplete() @implementer(IReactorPluggableNameResolver) class WithResolver( proxyForInterface(InterfaceClass("*", tuple(providedBy(reactor)))) ): nameResolver = SimpleNameResolver() return WithResolver(reactor) class SimpleHostnameResolverTests(unittest.SynchronousTestCase): """ Tests for L{endpoints._SimpleHostnameResolver}. @ivar fakeResolverCalls: Arguments with which L{fakeResolver} was called. @type fakeResolverCalls: L{list} of C{(hostName, port)} L{tuple}s. @ivar fakeResolverReturns: The return value of L{fakeResolver}. @type fakeResolverReturns: L{Deferred} @ivar resolver: The instance to test. @type resolver: L{endpoints._SimpleHostnameResolver} @ivar resolutionBeganCalls: Arguments with which receiver's C{resolutionBegan} method was called. @type resolutionBeganCalls: L{list} @ivar addressResolved: Arguments with which C{addressResolved} was called. @type addressResolved: L{list} @ivar resolutionCompleteCallCount: The number of calls to the receiver's C{resolutionComplete} method. @type resolutionCompleteCallCount: L{int} @ivar receiver: A L{interfaces.IResolutionReceiver} provider. """ def setUp(self): self.fakeResolverCalls = [] self.fakeResolverReturns = defer.Deferred() self.resolver = endpoints._SimpleHostnameResolver(self.fakeResolver) self.resolutionBeganCalls = [] self.addressResolvedCalls = [] self.resolutionCompleteCallCount = 0 @provider(interfaces.IResolutionReceiver) class _Receiver: @staticmethod def resolutionBegan(resolutionInProgress): self.resolutionBeganCalls.append(resolutionInProgress) @staticmethod def addressResolved(address): self.addressResolvedCalls.append(address) @staticmethod def resolutionComplete(): self.resolutionCompleteCallCount += 1 self.receiver = _Receiver def fakeResolver(self, hostName, portNumber): """ A fake resolver callable. @param hostName: The hostname to resolve. @param portNumber: The port number the returned address should include. @return: L{fakeResolverCalls} @rtype: L{Deferred} """ self.fakeResolverCalls.append((hostName, portNumber)) return self.fakeResolverReturns def test_interface(self): """ A L{endpoints._SimpleHostnameResolver} instance provides L{interfaces.IHostnameResolver}. """ self.assertTrue(verifyObject(interfaces.IHostnameResolver, self.resolver)) def test_resolveNameFailure(self): """ A resolution failure is logged with the name that failed to resolve and the callable that tried to resolve it. The resolution receiver begins, receives no addresses, and completes. """ logs = [] @provider(ILogObserver) def captureLogs(event): logs.append(event) globalLogPublisher.addObserver(captureLogs) self.addCleanup(lambda: globalLogPublisher.removeObserver(captureLogs)) receiver = self.resolver.resolveHostName(self.receiver, "example.com") self.assertIs(receiver, self.receiver) self.fakeResolverReturns.errback(Exception()) self.assertEqual(1, len(logs)) self.assertEqual(1, len(self.flushLoggedErrors(Exception))) [event] = logs self.assertTrue(event.get("isError")) self.assertTrue(event.get("name", "example.com")) self.assertTrue(event.get("callable", repr(self.fakeResolver))) self.assertEqual(1, len(self.resolutionBeganCalls)) self.assertEqual(self.resolutionBeganCalls[0].name, "example.com") self.assertFalse(self.addressResolvedCalls) self.assertEqual(1, self.resolutionCompleteCallCount) def test_resolveNameDelivers(self): """ The resolution receiver begins, and resolved hostnames are delivered before it completes. """ port = 80 ipv4Host = "1.2.3.4" ipv6Host = "1::2::3::4" receiver = self.resolver.resolveHostName(self.receiver, "example.com") self.assertIs(receiver, self.receiver) self.fakeResolverReturns.callback( [ (AF_INET, SOCK_STREAM, IPPROTO_TCP, "", (ipv4Host, port)), (AF_INET6, SOCK_STREAM, IPPROTO_TCP, "", (ipv6Host, port)), ] ) self.assertEqual(1, len(self.resolutionBeganCalls)) self.assertEqual(self.resolutionBeganCalls[0].name, "example.com") self.assertEqual( self.addressResolvedCalls, [IPv4Address("TCP", ipv4Host, port), IPv6Address("TCP", ipv6Host, port)], ) self.assertEqual(self.resolutionCompleteCallCount, 1) class HostnameEndpointFallbackNameResolutionTests(unittest.TestCase): """ L{HostnameEndpoint._fallbackNameResolution} defers a name resolution call to a thread. """ def test_fallbackNameResolution(self): """ L{_fallbackNameResolution} returns a L{Deferred} that fires with the resoution of the the host and request port. """ from twisted.internet import reactor ep = endpoints.HostnameEndpoint(reactor, host="ignored", port=0) host, port = ("1.2.3.4", 1) resolutionDeferred = ep._fallbackNameResolution(host, port) def assertHostPortFamilySockType(result): self.assertEqual(len(result), 1) [(family, socktype, _, _, sockaddr)] = result self.assertEqual(family, AF_INET) self.assertEqual(socktype, SOCK_STREAM) self.assertEqual(sockaddr, (host, port)) return resolutionDeferred.addCallback(assertHostPortFamilySockType) class _HostnameEndpointMemoryReactorMixin(ClientEndpointTestCaseMixin): """ Common methods for testing L{HostnameEndpoint} against L{MemoryReactor} instances that do not provide L{IReactorPluggableNameResolver}. """ def synchronousDeferredToThread(self, f, *args, **kwargs): """ A synchronous version of L{deferToThread}. @param f: The callable to invoke. @type f: L{callable} @param args: Positional arguments to the callable. @param kwargs: Keyword arguments to the callable. @return: A L{Deferred} that fires with the result of applying C{f} to C{args} and C{kwargs} or the exception raised. """ try: result = f(*args, **kwargs) except BaseException: return defer.fail() else: return defer.succeed(result) def expectedClients(self, reactor): """ Extract expected clients from the reactor. @param reactor: The L{MemoryReactor} under test. @return: List of calls to L{IReactorTCP.connectTCP} """ return reactor.tcpClients def connectArgs(self): """ @return: C{dict} of keyword arguments to pass to connect. """ return {"timeout": 10.0, "bindAddress": ("localhost", 49595)} def assertConnectArgs(self, receivedArgs, expectedArgs): """ Compare host, port, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorTCP.connectTCP}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorTCP.connectTCP}. """ (host, port, ignoredFactory, timeout, bindAddress) = receivedArgs ( expectedHost, expectedPort, _ignoredFactory, expectedTimeout, expectedBindAddress, ) = expectedArgs self.assertEqual(host, expectedHost) self.assertEqual(port, expectedPort) self.assertEqual(timeout, expectedTimeout) self.assertEqual(bindAddress, expectedBindAddress) def test_endpointConnectFailure(self): """ When L{HostnameEndpoint.connect} cannot connect to its destination, the returned L{Deferred} will fail with C{ConnectError}. """ expectedError = error.ConnectError(string="Connection Failed") mreactor = RaisingMemoryReactorWithClock(connectException=expectedError) clientFactory = object() ep, ignoredArgs, ignoredDest = self.createClientEndpoint( mreactor, clientFactory ) d = ep.connect(clientFactory) mreactor.advance(endpoints.HostnameEndpoint._DEFAULT_ATTEMPT_DELAY) self.assertEqual(self.failureResultOf(d).value, expectedError) self.assertEqual([], mreactor.getDelayedCalls()) def test_deprecation(self): """ Instantiating L{HostnameEndpoint} with a reactor that does not provide L{IReactorPluggableResolver} emits a deprecation warning. """ mreactor = MemoryReactor() clientFactory = object() self.createClientEndpoint(mreactor, clientFactory) warnings = self.flushWarnings() self.assertEqual(1, len(warnings)) self.assertIs(DeprecationWarning, warnings[0]["category"]) self.assertTrue( warnings[0]["message"].startswith( "Passing HostnameEndpoint a reactor that does not provide" " IReactorPluggableNameResolver" " (twisted.internet.testing.MemoryReactorClock)" " was deprecated in Twisted 17.5.0;" " please use a reactor that provides" " IReactorPluggableNameResolver instead" ) ) def test_errorsLogged(self): """ Hostname resolution errors are logged. """ mreactor = MemoryReactor() clientFactory = object() ep, ignoredArgs, ignoredDest = self.createClientEndpoint( mreactor, clientFactory ) def getaddrinfoThatFails(*args, **kwargs): raise gaierror(-5, "No address associated with hostname") ep._getaddrinfo = getaddrinfoThatFails d = ep.connect(clientFactory) self.assertIsInstance(self.failureResultOf(d).value, error.DNSLookupError) self.assertEqual(1, len(self.flushLoggedErrors(gaierror))) class HostnameEndpointMemoryIPv4ReactorTests( _HostnameEndpointMemoryReactorMixin, unittest.TestCase ): """ IPv4 resolution tests for L{HostnameEndpoint} with L{MemoryReactor} subclasses that do not provide L{IReactorPluggableNameResolver}. """ def createClientEndpoint(self, reactor, clientFactory, **connectArgs): """ Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv4 address. @param reactor: The L{MemoryReactor} @param clientFactory: The client L{IProtocolFactory} @param connectArgs: Additional arguments to L{HostnameEndpoint.connect} @return: A L{tuple} of the form C{(endpoint, (expectedAddress, expectedPort, clientFactory, timeout, localBindAddress, hostnameAddress))} """ expectedAddress = "1.2.3.4" address = HostnameAddress(b"example.com", 80) endpoint = endpoints.HostnameEndpoint( reactor, b"example.com", address.port, **connectArgs ) def fakegetaddrinfo(host, port, family, socktype): return [ (AF_INET, SOCK_STREAM, IPPROTO_TCP, "", (expectedAddress, 80)), ] endpoint._getaddrinfo = fakegetaddrinfo endpoint._deferToThread = self.synchronousDeferredToThread return ( endpoint, ( expectedAddress, address.port, clientFactory, connectArgs.get("timeout", 30), connectArgs.get("bindAddress", None), ), address, ) class HostnameEndpointMemoryIPv6ReactorTests( _HostnameEndpointMemoryReactorMixin, unittest.TestCase ): """ IPv6 resolution tests for L{HostnameEndpoint} with L{MemoryReactor} subclasses that do not provide L{IReactorPluggableNameResolver}. """ def createClientEndpoint(self, reactor, clientFactory, **connectArgs): """ Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv6 address. @param reactor: The L{MemoryReactor} @param clientFactory: The client L{IProtocolFactory} @param connectArgs: Additional arguments to L{HostnameEndpoint.connect} @return: A L{tuple} of the form C{(endpoint, (expectedAddress, expectedPort, clientFactory, timeout, localBindAddress, hostnameAddress))} """ expectedAddress = "1:2::3:4" address = HostnameAddress(b"ipv6.example.com", 80) endpoint = endpoints.HostnameEndpoint( reactor, b"ipv6.example.com", address.port, **connectArgs ) def fakegetaddrinfo(host, port, family, socktype): return [ (AF_INET6, SOCK_STREAM, IPPROTO_TCP, "", (expectedAddress, 80)), ] endpoint._getaddrinfo = fakegetaddrinfo endpoint._deferToThread = self.synchronousDeferredToThread return ( endpoint, ( expectedAddress, address.port, clientFactory, connectArgs.get("timeout", 30), connectArgs.get("bindAddress", None), ), address, ) class HostnameEndpointsOneIPv4Tests(ClientEndpointTestCaseMixin, unittest.TestCase): """ Tests for the hostname based endpoints when GAI returns only one (IPv4) address. """ def createClientEndpoint(self, reactor, clientFactory, **connectArgs): """ Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv4 address. """ expectedAddress = "1.2.3.4" address = HostnameAddress(b"example.com", 80) endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(reactor, [expectedAddress]), b"example.com", address.port, **connectArgs, ) return ( endpoint, ( expectedAddress, address.port, clientFactory, connectArgs.get("timeout", 30), connectArgs.get("bindAddress", None), ), address, ) def expectedClients(self, reactor): """ @return: List of calls to L{IReactorTCP.connectTCP} """ return reactor.tcpClients def assertConnectArgs(self, receivedArgs, expectedArgs): """ Compare host, port, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorTCP.connectTCP}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorTCP.connectTCP}. """ (host, port, ignoredFactory, timeout, bindAddress) = receivedArgs ( expectedHost, expectedPort, _ignoredFactory, expectedTimeout, expectedBindAddress, ) = expectedArgs self.assertEqual(host, expectedHost) self.assertEqual(port, expectedPort) self.assertEqual(timeout, expectedTimeout) self.assertEqual(bindAddress, expectedBindAddress) def connectArgs(self): """ @return: C{dict} of keyword arguments to pass to connect. """ return {"timeout": 10, "bindAddress": ("localhost", 49595)} def test_endpointConnectingCancelled(self, advance=None): """ Calling L{Deferred.cancel} on the L{Deferred} returned from L{IStreamClientEndpoint.connect} will cause it to be errbacked with a L{ConnectingCancelledError} exception. """ mreactor = MemoryReactor() clientFactory = protocol.Factory() clientFactory.protocol = protocol.Protocol ep, ignoredArgs, address = self.createClientEndpoint(mreactor, clientFactory) d = ep.connect(clientFactory) if advance is not None: mreactor.advance(advance) d.cancel() # When canceled, the connector will immediately notify its factory that # the connection attempt has failed due to a UserError. attemptFactory = self.retrieveConnectedFactory(mreactor) attemptFactory.clientConnectionFailed(None, Failure(error.UserError())) # This should be a feature of MemoryReactor: <http://tm.tl/5630>. failure = self.failureResultOf(d) self.assertIsInstance(failure.value, error.ConnectingCancelledError) self.assertEqual(failure.value.address, address) self.assertTrue(mreactor.tcpClients[0][2]._connector.stoppedConnecting) self.assertEqual([], mreactor.getDelayedCalls()) def test_endpointConnectingCancelledAfterAllAttemptsStarted(self): """ Calling L{Deferred.cancel} on the L{Deferred} returned from L{IStreamClientEndpoint.connect} after enough time has passed that all connection attempts have been initiated will cause it to be errbacked with a L{ConnectingCancelledError} exception. """ oneBetween = endpoints.HostnameEndpoint._DEFAULT_ATTEMPT_DELAY advance = oneBetween + (oneBetween / 2.0) self.test_endpointConnectingCancelled(advance=advance) def test_endpointConnectFailure(self): """ If L{HostnameEndpoint.connect} is invoked and there is no server listening for connections, the returned L{Deferred} will fail with C{ConnectError}. """ expectedError = error.ConnectError(string="Connection Failed") mreactor = RaisingMemoryReactorWithClock(connectException=expectedError) clientFactory = object() ep, ignoredArgs, ignoredDest = self.createClientEndpoint( mreactor, clientFactory ) d = ep.connect(clientFactory) mreactor.advance(endpoints.HostnameEndpoint._DEFAULT_ATTEMPT_DELAY) self.assertEqual(self.failureResultOf(d).value, expectedError) self.assertEqual([], mreactor.getDelayedCalls()) def test_endpointConnectFailureAfterIteration(self): """ If a connection attempt initiated by L{HostnameEndpoint.connect} fails only after L{HostnameEndpoint} has exhausted the list of possible server addresses, the returned L{Deferred} will fail with C{ConnectError}. """ expectedError = error.ConnectError(string="Connection Failed") mreactor = MemoryReactor() clientFactory = object() ep, ignoredArgs, ignoredDest = self.createClientEndpoint( mreactor, clientFactory ) d = ep.connect(clientFactory) mreactor.advance(0.3) host, port, factory, timeout, bindAddress = mreactor.tcpClients[0] factory.clientConnectionFailed(mreactor.connectors[0], expectedError) self.assertEqual(self.failureResultOf(d).value, expectedError) self.assertEqual([], mreactor.getDelayedCalls()) def test_endpointConnectSuccessAfterIteration(self): """ If a connection attempt initiated by L{HostnameEndpoint.connect} succeeds only after L{HostnameEndpoint} has exhausted the list of possible server addresses, the returned L{Deferred} will fire with the connected protocol instance and the endpoint will leave no delayed calls in the reactor. """ proto = object() mreactor = MemoryReactor() clientFactory = object() ep, expectedArgs, ignoredDest = self.createClientEndpoint( mreactor, clientFactory ) d = ep.connect(clientFactory) receivedProtos = [] def checkProto(p): receivedProtos.append(p) d.addCallback(checkProto) factory = self.retrieveConnectedFactory(mreactor) mreactor.advance(0.3) factory._onConnection.callback(proto) self.assertEqual(receivedProtos, [proto]) expectedClients = self.expectedClients(mreactor) self.assertEqual(len(expectedClients), 1) self.assertConnectArgs(expectedClients[0], expectedArgs) self.assertEqual([], mreactor.getDelayedCalls()) class HostnameEndpointsOneIPv6Tests(ClientEndpointTestCaseMixin, unittest.TestCase): """ Tests for the hostname based endpoints when GAI returns only one (IPv6) address. """ def createClientEndpoint(self, reactor, clientFactory, **connectArgs): """ Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv6 address. """ address = HostnameAddress(b"ipv6.example.com", 80) endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(reactor, ["1:2::3:4"]), b"ipv6.example.com", address.port, **connectArgs, ) return ( endpoint, ( "1:2::3:4", address.port, clientFactory, connectArgs.get("timeout", 30), connectArgs.get("bindAddress", None), ), address, ) def expectedClients(self, reactor): """ @return: List of calls to L{IReactorTCP.connectTCP} """ return reactor.tcpClients def assertConnectArgs(self, receivedArgs, expectedArgs): """ Compare host, port, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorTCP.connectTCP}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorTCP.connectTCP}. """ (host, port, ignoredFactory, timeout, bindAddress) = receivedArgs ( expectedHost, expectedPort, _ignoredFactory, expectedTimeout, expectedBindAddress, ) = expectedArgs self.assertEqual(host, expectedHost) self.assertEqual(port, expectedPort) self.assertEqual(timeout, expectedTimeout) self.assertEqual(bindAddress, expectedBindAddress) def connectArgs(self): """ @return: C{dict} of keyword arguments to pass to connect. """ return {"timeout": 10, "bindAddress": ("localhost", 49595)} def test_endpointConnectingCancelled(self): """ Calling L{Deferred.cancel} on the L{Deferred} returned from L{IStreamClientEndpoint.connect} is errbacked with an expected L{ConnectingCancelledError} exception. """ mreactor = MemoryReactor() clientFactory = protocol.Factory() clientFactory.protocol = protocol.Protocol ep, ignoredArgs, address = self.createClientEndpoint( deterministicResolvingReactor(mreactor, ["127.0.0.1"]), clientFactory ) d = ep.connect(clientFactory) d.cancel() # When canceled, the connector will immediately notify its factory that # the connection attempt has failed due to a UserError. attemptFactory = self.retrieveConnectedFactory(mreactor) attemptFactory.clientConnectionFailed(None, Failure(error.UserError())) # This should be a feature of MemoryReactor: <http://tm.tl/5630>. failure = self.failureResultOf(d) self.assertIsInstance(failure.value, error.ConnectingCancelledError) self.assertEqual(failure.value.address, address) self.assertTrue(mreactor.tcpClients[0][2]._connector.stoppedConnecting) self.assertEqual([], mreactor.getDelayedCalls()) def test_endpointConnectFailure(self): """ If an endpoint tries to connect to a non-listening port it gets a C{ConnectError} failure. """ expectedError = error.ConnectError(string="Connection Failed") mreactor = RaisingMemoryReactorWithClock(connectException=expectedError) clientFactory = object() ep, ignoredArgs, ignoredDest = self.createClientEndpoint( mreactor, clientFactory ) d = ep.connect(clientFactory) mreactor.advance(0.3) self.assertEqual(self.failureResultOf(d).value, expectedError) self.assertEqual([], mreactor.getDelayedCalls()) class HostnameEndpointIDNATests(unittest.SynchronousTestCase): """ Tests for L{HostnameEndpoint}'s constructor's encoding behavior. """ sampleIDNAText = "b\xfccher.ch" sampleIDNABytes = b"xn--bcher-kva.ch" def test_idnaHostnameText(self): """ A L{HostnameEndpoint} constructed with text will contain an IDNA-encoded bytes representation of that text. """ endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(MemoryReactor(), ["127.0.0.1"]), self.sampleIDNAText, 80, ) self.assertEqual(endpoint._hostBytes, self.sampleIDNABytes) self.assertEqual(endpoint._hostText, self.sampleIDNAText) def test_idnaHostnameBytes(self): """ A L{HostnameEndpoint} constructed with bytes will contain an IDNA-decoded textual representation of those bytes. """ endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(MemoryReactor(), ["127.0.0.1"]), self.sampleIDNAText, 80, ) self.assertEqual(endpoint._hostBytes, self.sampleIDNABytes) self.assertEqual(endpoint._hostText, self.sampleIDNAText) def test_nonNormalizedText(self): """ A L{HostnameEndpoint} constructed with NFD-normalized text will store the NFC-normalized version of that text. """ endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(MemoryReactor(), ["127.0.0.1"]), normalize("NFD", self.sampleIDNAText), 80, ) self.assertEqual(endpoint._hostBytes, self.sampleIDNABytes) self.assertEqual(endpoint._hostText, self.sampleIDNAText) def test_deferBadEncodingToConnect(self): """ Since any client of L{IStreamClientEndpoint} needs to handle Deferred failures from C{connect}, L{HostnameEndpoint}'s constructor will not raise exceptions when given bad host names, instead deferring to returning a failing L{Deferred} from C{connect}. """ endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(MemoryReactor(), ["127.0.0.1"]), b"\xff-garbage-\xff", 80, ) deferred = endpoint.connect(Factory.forProtocol(Protocol)) err = self.failureResultOf(deferred, ValueError) self.assertIn("\\xff-garbage-\\xff", str(err)) endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(MemoryReactor(), ["127.0.0.1"]), "\u2ff0-garbage-\u2ff0", 80, ) deferred = endpoint.connect(Factory()) err = self.failureResultOf(deferred, ValueError) self.assertIn("\\u2ff0-garbage-\\u2ff0", str(err)) class HostnameEndpointReprTests(unittest.SynchronousTestCase): """ Tests for L{HostnameEndpoint}'s string representation. """ def test_allASCII(self): """ The string representation of L{HostnameEndpoint} includes the host and port passed to the constructor. """ endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(Clock(), []), "example.com", 80, ) rep = repr(endpoint) self.assertEqual("<HostnameEndpoint example.com:80>", rep) self.assertIs(str, type(rep)) def test_idnaHostname(self): """ When IDN is passed to the L{HostnameEndpoint} constructor the string representation includes the punycode version of the host. """ endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(Clock(), []), "b\xfccher.ch", 443, ) rep = repr(endpoint) self.assertEqual("<HostnameEndpoint xn--bcher-kva.ch:443>", rep) self.assertIs(str, type(rep)) def test_hostIPv6Address(self): """ When the host passed to L{HostnameEndpoint} is an IPv6 address it is wrapped in brackets in the string representation, like in a URI. This prevents the colon separating the host from the port from being ambiguous. """ endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(Clock(), []), b"::1", 22, ) rep = repr(endpoint) self.assertEqual("<HostnameEndpoint [::1]:22>", rep) self.assertIs(str, type(rep)) def test_badEncoding(self): """ When a bad hostname is passed to L{HostnameEndpoint}, the string representation displays invalid characters in backslash-escaped form. """ endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(Clock(), []), b"\xff-garbage-\xff", 80 ) self.assertEqual( "<HostnameEndpoint \\xff-garbage-\\xff:80>", repr(endpoint), ) class HostnameEndpointsGAIFailureTests(unittest.TestCase): """ Tests for the hostname based endpoints when GAI returns no address. """ def test_failure(self): """ If no address is returned by GAI for a hostname, the connection attempt fails with L{error.DNSLookupError}. """ endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(Clock(), []), b"example.com", 80 ) clientFactory = object() dConnect = endpoint.connect(clientFactory) exc = self.failureResultOf(dConnect, error.DNSLookupError) self.assertIn("example.com", str(exc)) class HostnameEndpointsFasterConnectionTests(unittest.TestCase): """ Tests for the hostname based endpoints when gai returns an IPv4 and an IPv6 address, and one connection takes less time than the other. """ def setUp(self): self.mreactor = MemoryReactor() self.endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor(self.mreactor, ["1.2.3.4", "1:2::3:4"]), b"www.example.com", 80, ) def test_ignoreUnknownAddressTypes(self): """ If an address type other than L{IPv4Address} and L{IPv6Address} is returned by on address resolution, the endpoint ignores that address. """ self.mreactor = MemoryReactor() self.endpoint = endpoints.HostnameEndpoint( deterministicResolvingReactor( self.mreactor, ["1.2.3.4", object(), "1:2::3:4"] ), b"www.example.com", 80, ) clientFactory = None self.endpoint.connect(clientFactory) self.mreactor.advance(0.3) (host, port, factory, timeout, bindAddress) = self.mreactor.tcpClients[1] self.assertEqual(len(self.mreactor.tcpClients), 2) self.assertEqual(host, "1:2::3:4") self.assertEqual(port, 80) def test_IPv4IsFaster(self): """ The endpoint returns a connection to the IPv4 address. IPv4 ought to be the first attempt, since nameResolution (standing in for GAI here) returns it first. The IPv4 attempt succeeds, the connection is established, and a Deferred fires with the protocol constructed. """ clientFactory = protocol.Factory() clientFactory.protocol = protocol.Protocol d = self.endpoint.connect(clientFactory) results = [] d.addCallback(results.append) (host, port, factory, timeout, bindAddress) = self.mreactor.tcpClients[0] self.assertEqual(host, "1.2.3.4") self.assertEqual(port, 80) proto = factory.buildProtocol((host, port)) fakeTransport = object() self.assertEqual(results, []) proto.makeConnection(fakeTransport) self.assertEqual(len(results), 1) self.assertEqual(results[0].factory, clientFactory) self.assertEqual([], self.mreactor.getDelayedCalls()) def test_IPv6IsFaster(self): """ The endpoint returns a connection to the IPv6 address. IPv6 ought to be the second attempt, since nameResolution (standing in for GAI here) returns it second. The IPv6 attempt succeeds, a connection is established, and a Deferred fires with the protocol constructed. """ clientFactory = protocol.Factory() clientFactory.protocol = protocol.Protocol d = self.endpoint.connect(clientFactory) results = [] d.addCallback(results.append) self.mreactor.advance(0.3) (host, port, factory, timeout, bindAddress) = self.mreactor.tcpClients[1] self.assertEqual(host, "1:2::3:4") self.assertEqual(port, 80) proto = factory.buildProtocol((host, port)) fakeTransport = object() self.assertEqual(results, []) proto.makeConnection(fakeTransport) self.assertEqual(len(results), 1) self.assertEqual(results[0].factory, clientFactory) self.assertEqual([], self.mreactor.getDelayedCalls()) def test_otherConnectionsCancelled(self): """ Once the endpoint returns a successful connection, all the other pending connections are cancelled. Here, the second connection attempt, i.e. IPv6, succeeds, and the pending first attempt, i.e. IPv4, is cancelled. """ clientFactory = protocol.Factory() clientFactory.protocol = protocol.Protocol d = self.endpoint.connect(clientFactory) results = [] d.addCallback(results.append) self.mreactor.advance(0.3) (host, port, factory, timeout, bindAddress) = self.mreactor.tcpClients[1] proto = factory.buildProtocol((host, port)) fakeTransport = object() proto.makeConnection(fakeTransport) self.assertEqual( True, self.mreactor.tcpClients[0][2]._connector.stoppedConnecting ) self.assertEqual([], self.mreactor.getDelayedCalls()) @skipIf(skipSSL, skipSSLReason) class SSL4EndpointsTests(EndpointTestCaseMixin, unittest.TestCase): """ Tests for SSL Endpoints. """ def expectedServers(self, reactor): """ @return: List of calls to L{IReactorSSL.listenSSL} """ return reactor.sslServers def expectedClients(self, reactor): """ @return: List of calls to L{IReactorSSL.connectSSL} """ return reactor.sslClients def assertConnectArgs(self, receivedArgs, expectedArgs): """ Compare host, port, contextFactory, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{contextFactory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorSSL.connectSSL}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{contextFactory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorSSL.connectSSL}. """ ( host, port, ignoredFactory, contextFactory, timeout, bindAddress, ) = receivedArgs ( expectedHost, expectedPort, _ignoredFactory, expectedContextFactory, expectedTimeout, expectedBindAddress, ) = expectedArgs self.assertEqual(host, expectedHost) self.assertEqual(port, expectedPort) self.assertEqual(contextFactory, expectedContextFactory) self.assertEqual(timeout, expectedTimeout) self.assertEqual(bindAddress, expectedBindAddress) def connectArgs(self): """ @return: C{dict} of keyword arguments to pass to connect. """ return {"timeout": 10, "bindAddress": ("localhost", 49595)} def listenArgs(self): """ @return: C{dict} of keyword arguments to pass to listen """ return {"backlog": 100, "interface": "127.0.0.1"} def setUp(self): """ Set up client and server SSL contexts for use later. """ self.sKey, self.sCert = makeCertificate( O="Server Test Certificate", CN="server" ) self.cKey, self.cCert = makeCertificate( O="Client Test Certificate", CN="client" ) self.serverSSLContext = CertificateOptions( privateKey=self.sKey, certificate=self.sCert, requireCertificate=False ) self.clientSSLContext = CertificateOptions(requireCertificate=False) def createServerEndpoint(self, reactor, factory, **listenArgs): """ Create an L{SSL4ServerEndpoint} and return the tools to verify its behaviour. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param reactor: A fake L{IReactorSSL} that L{SSL4ServerEndpoint} can call L{IReactorSSL.listenSSL} on. @param listenArgs: Optional dictionary of arguments to L{IReactorSSL.listenSSL}. """ address = IPv4Address("TCP", "0.0.0.0", 0) return ( endpoints.SSL4ServerEndpoint( reactor, address.port, self.serverSSLContext, **listenArgs ), ( address.port, factory, self.serverSSLContext, listenArgs.get("backlog", 50), listenArgs.get("interface", ""), ), address, ) def createClientEndpoint(self, reactor, clientFactory, **connectArgs): """ Create an L{SSL4ClientEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorSSL} that L{SSL4ClientEndpoint} can call L{IReactorSSL.connectSSL} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorSSL.connectSSL} """ address = IPv4Address("TCP", "localhost", 80) return ( endpoints.SSL4ClientEndpoint( reactor, address.host, address.port, self.clientSSLContext, **connectArgs, ), ( address.host, address.port, clientFactory, self.clientSSLContext, connectArgs.get("timeout", 30), connectArgs.get("bindAddress", None), ), address, ) class UNIXEndpointsTests(EndpointTestCaseMixin, unittest.TestCase): """ Tests for UnixSocket Endpoints. """ def retrieveConnectedFactory(self, reactor): """ Override L{EndpointTestCaseMixin.retrieveConnectedFactory} to account for different index of 'factory' in C{connectUNIX} args. """ return self.expectedClients(reactor)[0][1] def expectedServers(self, reactor): """ @return: List of calls to L{IReactorUNIX.listenUNIX} """ return reactor.unixServers def expectedClients(self, reactor): """ @return: List of calls to L{IReactorUNIX.connectUNIX} """ return reactor.unixClients def assertConnectArgs(self, receivedArgs, expectedArgs): """ Compare path, timeout, checkPID in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{path}, C{timeout}, C{checkPID}) that was passed to L{IReactorUNIX.connectUNIX}. @param expectedArgs: C{tuple} of (C{path}, C{timeout}, C{checkPID}) that we expect to have been passed to L{IReactorUNIX.connectUNIX}. """ (path, ignoredFactory, timeout, checkPID) = receivedArgs ( expectedPath, _ignoredFactory, expectedTimeout, expectedCheckPID, ) = expectedArgs self.assertEqual(path, expectedPath) self.assertEqual(timeout, expectedTimeout) self.assertEqual(checkPID, expectedCheckPID) def connectArgs(self): """ @return: C{dict} of keyword arguments to pass to connect. """ return {"timeout": 10, "checkPID": 1} def listenArgs(self): """ @return: C{dict} of keyword arguments to pass to listen """ return {"backlog": 100, "mode": 0o600, "wantPID": 1} def createServerEndpoint(self, reactor, factory, **listenArgs): """ Create an L{UNIXServerEndpoint} and return the tools to verify its behaviour. @param reactor: A fake L{IReactorUNIX} that L{UNIXServerEndpoint} can call L{IReactorUNIX.listenUNIX} on. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param listenArgs: Optional dictionary of arguments to L{IReactorUNIX.listenUNIX}. """ address = UNIXAddress(self.mktemp()) return ( endpoints.UNIXServerEndpoint(reactor, address.name, **listenArgs), ( address.name, factory, listenArgs.get("backlog", 50), listenArgs.get("mode", 0o666), listenArgs.get("wantPID", 0), ), address, ) def createClientEndpoint(self, reactor, clientFactory, **connectArgs): """ Create an L{UNIXClientEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorUNIX} that L{UNIXClientEndpoint} can call L{IReactorUNIX.connectUNIX} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorUNIX.connectUNIX} """ address = UNIXAddress(self.mktemp()) return ( endpoints.UNIXClientEndpoint(reactor, address.name, **connectArgs), ( address.name, clientFactory, connectArgs.get("timeout", 30), connectArgs.get("checkPID", 0), ), address, ) class ParserTests(unittest.TestCase): """ Tests for L{endpoints._parseServer}, the low-level parsing logic. """ f = "Factory" def parse(self, *a, **kw): """ Provide a hook for test_strports to substitute the deprecated API. """ return endpoints._parseServer(*a, **kw) def test_simpleTCP(self): """ Simple strings with a 'tcp:' prefix should be parsed as TCP. """ self.assertEqual( self.parse("tcp:80", self.f), ("TCP", (80, self.f), {"interface": "", "backlog": 50}), ) def test_interfaceTCP(self): """ TCP port descriptions parse their 'interface' argument as a string. """ self.assertEqual( self.parse("tcp:80:interface=127.0.0.1", self.f), ("TCP", (80, self.f), {"interface": "127.0.0.1", "backlog": 50}), ) def test_backlogTCP(self): """ TCP port descriptions parse their 'backlog' argument as an integer. """ self.assertEqual( self.parse("tcp:80:backlog=6", self.f), ("TCP", (80, self.f), {"interface": "", "backlog": 6}), ) def test_simpleUNIX(self): """ L{endpoints._parseServer} returns a C{'UNIX'} port description with defaults for C{'mode'}, C{'backlog'}, and C{'wantPID'} when passed a string with the C{'unix:'} prefix and no other parameter values. """ self.assertEqual( self.parse("unix:/var/run/finger", self.f), ( "UNIX", ("/var/run/finger", self.f), {"mode": 0o666, "backlog": 50, "wantPID": True}, ), ) def test_modeUNIX(self): """ C{mode} can be set by including C{"mode=<some integer>"}. """ self.assertEqual( self.parse("unix:/var/run/finger:mode=0660", self.f), ( "UNIX", ("/var/run/finger", self.f), {"mode": 0o660, "backlog": 50, "wantPID": True}, ), ) def test_wantPIDUNIX(self): """ C{wantPID} can be set to false by included C{"lockfile=0"}. """ self.assertEqual( self.parse("unix:/var/run/finger:lockfile=0", self.f), ( "UNIX", ("/var/run/finger", self.f), {"mode": 0o666, "backlog": 50, "wantPID": False}, ), ) def test_escape(self): """ Backslash can be used to escape colons and backslashes in port descriptions. """ self.assertEqual( self.parse("unix:foo\x5c:bar\x5c=baz\x5c:qux\x5c\x5c", self.f), ( "UNIX", ("foo:bar=baz:qux\x5c", self.f), {"mode": 0o666, "backlog": 50, "wantPID": True}, ), ) def test_quoteStringArgument(self): """ L{endpoints.quoteStringArgument} should quote backslashes and colons for interpolation into L{endpoints.serverFromString} and L{endpoints.clientFactory} arguments. """ self.assertEqual( endpoints.quoteStringArgument("some : stuff \x5c"), "some \x5c: stuff \x5c\x5c", ) def test_impliedEscape(self): """ In strports descriptions, '=' in a parameter value does not need to be quoted; it will simply be parsed as part of the value. """ self.assertEqual( self.parse(r"unix:address=foo=bar", self.f), ( "UNIX", ("foo=bar", self.f), {"mode": 0o666, "backlog": 50, "wantPID": True}, ), ) def test_unknownType(self): """ L{strports.parse} raises C{ValueError} when given an unknown endpoint type. """ self.assertRaises(ValueError, self.parse, "bogus-type:nothing", self.f) class ServerStringTests(unittest.TestCase): """ Tests for L{twisted.internet.endpoints.serverFromString}. """ def test_tcp(self): """ When passed a TCP strports description, L{endpoints.serverFromString} returns a L{TCP4ServerEndpoint} instance initialized with the values from the string. """ reactor = object() server = endpoints.serverFromString( reactor, "tcp:1234:backlog=12:interface=10.0.0.1" ) self.assertIsInstance(server, endpoints.TCP4ServerEndpoint) self.assertIs(server._reactor, reactor) self.assertEqual(server._port, 1234) self.assertEqual(server._backlog, 12) self.assertEqual(server._interface, "10.0.0.1") @skipIf(skipSSL, skipSSLReason) def test_ssl(self): """ When passed an SSL strports description, L{endpoints.serverFromString} returns a L{SSL4ServerEndpoint} instance initialized with the values from the string. """ reactor = object() server = endpoints.serverFromString( reactor, "ssl:1234:backlog=12:privateKey=%s:" "certKey=%s:sslmethod=TLSv1_METHOD:interface=10.0.0.1" % (escapedPEMPathName, escapedPEMPathName), ) self.assertIsInstance(server, endpoints.SSL4ServerEndpoint) self.assertIs(server._reactor, reactor) self.assertEqual(server._port, 1234) self.assertEqual(server._backlog, 12) self.assertEqual(server._interface, "10.0.0.1") self.assertEqual(server._sslContextFactory.method, TLSv1_METHOD) ctx = server._sslContextFactory.getContext() self.assertIsInstance(ctx, ContextType) @skipIf(skipSSL, skipSSLReason) def test_sslWithDefaults(self): """ An SSL string endpoint description with minimal arguments returns a properly initialized L{SSL4ServerEndpoint} instance. """ reactor = object() server = endpoints.serverFromString( reactor, f"ssl:4321:privateKey={escapedPEMPathName}" ) self.assertIsInstance(server, endpoints.SSL4ServerEndpoint) self.assertIs(server._reactor, reactor) self.assertEqual(server._port, 4321) self.assertEqual(server._backlog, 50) self.assertEqual(server._interface, "") self.assertEqual(server._sslContextFactory.method, SSLv23_METHOD) self.assertTrue( server._sslContextFactory._options & OP_NO_SSLv3, ) ctx = server._sslContextFactory.getContext() self.assertIsInstance(ctx, ContextType) # Use a class variable to ensure we use the exactly same endpoint string # except for the chain file itself. SSL_CHAIN_TEMPLATE = "ssl:1234:privateKey=%s:extraCertChain=%s" @skipIf(skipSSL, skipSSLReason) def test_sslChainLoads(self): """ Specifying a chain file loads the contained certificates in the right order. """ server = endpoints.serverFromString( object(), self.SSL_CHAIN_TEMPLATE % ( escapedPEMPathName, escapedChainPathName, ), ) # Test chain file is just a concatenation of thing1.pem and thing2.pem # so we can check that loading has succeeded and order has been # preserved. expectedChainCerts = [ Certificate.loadPEM(casPath.child("thing%d.pem" % (n,)).getContent()) for n in [1, 2] ] cf = server._sslContextFactory self.assertEqual( cf.extraCertChain[0].digest("sha1"), expectedChainCerts[0].digest("sha1") ) self.assertEqual( cf.extraCertChain[1].digest("sha1"), expectedChainCerts[1].digest("sha1") ) @skipIf(skipSSL, skipSSLReason) def test_sslChainFileMustContainCert(self): """ If C{extraCertChain} is passed, it has to contain at least one valid certificate in PEM format. """ fp = FilePath(self.mktemp()) fp.create().close() # The endpoint string is the same as in the valid case except for # a different chain file. We use an empty temp file which obviously # will never contain any certificates. with self.assertRaises(ValueError) as caught: endpoints.serverFromString( object(), self.SSL_CHAIN_TEMPLATE % ( escapedPEMPathName, endpoints.quoteStringArgument(fp.path), ), ) # The raised exception should list what file it is attempting to find # the chain in. self.assertEqual( str(caught.exception), ( "Specified chain file '%s' doesn't contain any valid" " certificates in PEM format." ) % (fp.path,), ) @skipIf(skipSSL, skipSSLReason) def test_sslDHparameters(self): """ If C{dhParameters} are specified, they are passed as L{DiffieHellmanParameters} into L{CertificateOptions}. """ fileName = "someFile" reactor = object() server = endpoints.serverFromString( reactor, "ssl:4321:privateKey={}:certKey={}:dhParameters={}".format( escapedPEMPathName, escapedPEMPathName, fileName ), ) cf = server._sslContextFactory self.assertIsInstance(cf.dhParameters, DiffieHellmanParameters) self.assertEqual(FilePath(fileName), cf.dhParameters._dhFile) @skipIf(skipSSL, skipSSLReason) def test_sslNoTrailingNewlinePem(self): """ Lack of a trailing newline in key and cert .pem files should not generate an exception. """ reactor = object() server = endpoints.serverFromString( reactor, "ssl:1234:backlog=12:privateKey=%s:" "certKey=%s:sslmethod=TLSv1_METHOD:interface=10.0.0.1" % ( escapedNoTrailingNewlineKeyPEMPathName, escapedNoTrailingNewlineCertPEMPathName, ), ) self.assertIsInstance(server, endpoints.SSL4ServerEndpoint) self.assertIs(server._reactor, reactor) self.assertEqual(server._port, 1234) self.assertEqual(server._backlog, 12) self.assertEqual(server._interface, "10.0.0.1") self.assertEqual(server._sslContextFactory.method, TLSv1_METHOD) ctx = server._sslContextFactory.getContext() self.assertIsInstance(ctx, ContextType) def test_unix(self): """ When passed a UNIX strports description, L{endpoint.serverFromString} returns a L{UNIXServerEndpoint} instance initialized with the values from the string. """ reactor = object() endpoint = endpoints.serverFromString( reactor, "unix:/var/foo/bar:backlog=7:mode=0123:lockfile=1" ) self.assertIsInstance(endpoint, endpoints.UNIXServerEndpoint) self.assertIs(endpoint._reactor, reactor) self.assertEqual(endpoint._address, "/var/foo/bar") self.assertEqual(endpoint._backlog, 7) self.assertEqual(endpoint._mode, 0o123) self.assertTrue(endpoint._wantPID) def test_unknownType(self): """ L{endpoints.serverFromString} raises C{ValueError} when given an unknown endpoint type. """ value = self.assertRaises( # faster-than-light communication not supported ValueError, endpoints.serverFromString, None, "ftl:andromeda/carcosa/hali/2387", ) self.assertEqual(str(value), "Unknown endpoint type: 'ftl'") def test_typeFromPlugin(self): """ L{endpoints.serverFromString} looks up plugins of type L{IStreamServerEndpoint} and constructs endpoints from them. """ # Set up a plugin which will only be accessible for the duration of # this test. addFakePlugin(self) # Plugin is set up: now actually test. notAReactor = object() fakeEndpoint = endpoints.serverFromString( notAReactor, "fake:hello:world:yes=no:up=down" ) from twisted.plugins.fakeendpoint import fake # type: ignore[import] self.assertIs(fakeEndpoint.parser, fake) self.assertEqual(fakeEndpoint.args, (notAReactor, "hello", "world")) self.assertEqual(fakeEndpoint.kwargs, dict(yes="no", up="down")) def addFakePlugin(testCase, dropinSource="fakeendpoint.py"): """ For the duration of C{testCase}, add a fake plugin to twisted.plugins which contains some sample endpoint parsers. """ import sys savedModules = sys.modules.copy() savedPluginPath = list(plugins.__path__) def cleanup(): sys.modules.clear() sys.modules.update(savedModules) plugins.__path__[:] = savedPluginPath testCase.addCleanup(cleanup) fp = FilePath(testCase.mktemp()) fp.createDirectory() getModule(__name__).filePath.sibling(dropinSource).copyTo(fp.child(dropinSource)) plugins.__path__.append(fp.path) class ClientStringTests(unittest.TestCase): """ Tests for L{twisted.internet.endpoints.clientFromString}. """ def test_tcp(self): """ When passed a TCP strports description, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. """ reactor = object() client = endpoints.clientFromString( reactor, "tcp:host=example.com:port=1234:timeout=7:bindAddress=10.0.0.2" ) self.assertIsInstance(client, endpoints.TCP4ClientEndpoint) self.assertIs(client._reactor, reactor) self.assertEqual(client._host, "example.com") self.assertEqual(client._port, 1234) self.assertEqual(client._timeout, 7) self.assertEqual(client._bindAddress, ("10.0.0.2", 0)) def test_tcpPositionalArgs(self): """ When passed a TCP strports description using positional arguments, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. """ reactor = object() client = endpoints.clientFromString( reactor, "tcp:example.com:1234:timeout=7:bindAddress=10.0.0.2" ) self.assertIsInstance(client, endpoints.TCP4ClientEndpoint) self.assertIs(client._reactor, reactor) self.assertEqual(client._host, "example.com") self.assertEqual(client._port, 1234) self.assertEqual(client._timeout, 7) self.assertEqual(client._bindAddress, ("10.0.0.2", 0)) def test_tcpHostPositionalArg(self): """ When passed a TCP strports description specifying host as a positional argument, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. """ reactor = object() client = endpoints.clientFromString( reactor, "tcp:example.com:port=1234:timeout=7:bindAddress=10.0.0.2" ) self.assertEqual(client._host, "example.com") self.assertEqual(client._port, 1234) def test_tcpPortPositionalArg(self): """ When passed a TCP strports description specifying port as a positional argument, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. """ reactor = object() client = endpoints.clientFromString( reactor, "tcp:host=example.com:1234:timeout=7:bindAddress=10.0.0.2" ) self.assertEqual(client._host, "example.com") self.assertEqual(client._port, 1234) def test_tcpDefaults(self): """ A TCP strports description may omit I{timeout} or I{bindAddress} to allow the default to be used. """ reactor = object() client = endpoints.clientFromString(reactor, "tcp:host=example.com:port=1234") self.assertEqual(client._timeout, 30) self.assertIsNone(client._bindAddress) def test_unix(self): """ When passed a UNIX strports description, L{endpoints.clientFromString} returns a L{UNIXClientEndpoint} instance initialized with the values from the string. """ reactor = object() client = endpoints.clientFromString( reactor, "unix:path=/var/foo/bar:lockfile=1:timeout=9" ) self.assertIsInstance(client, endpoints.UNIXClientEndpoint) self.assertIs(client._reactor, reactor) self.assertEqual(client._path, "/var/foo/bar") self.assertEqual(client._timeout, 9) self.assertTrue(client._checkPID) def test_unixDefaults(self): """ A UNIX strports description may omit I{lockfile} or I{timeout} to allow the defaults to be used. """ client = endpoints.clientFromString(object(), "unix:path=/var/foo/bar") self.assertEqual(client._timeout, 30) self.assertFalse(client._checkPID) def test_unixPathPositionalArg(self): """ When passed a UNIX strports description specifying path as a positional argument, L{endpoints.clientFromString} returns a L{UNIXClientEndpoint} instance initialized with the values from the string. """ reactor = object() client = endpoints.clientFromString( reactor, "unix:/var/foo/bar:lockfile=1:timeout=9" ) self.assertIsInstance(client, endpoints.UNIXClientEndpoint) self.assertIs(client._reactor, reactor) self.assertEqual(client._path, "/var/foo/bar") self.assertEqual(client._timeout, 9) self.assertTrue(client._checkPID) def test_typeFromPlugin(self): """ L{endpoints.clientFromString} looks up plugins of type L{IStreamClientEndpoint} and constructs endpoints from them. """ addFakePlugin(self) notAReactor = object() clientEndpoint = endpoints.clientFromString( notAReactor, "crfake:alpha:beta:cee=dee:num=1"