File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/application.tar
Back
twist/__pycache__/_twist.cpython-310.pyc 0000644 00000006576 15030043552 0014153 0 ustar 00 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 twist/__pycache__/_options.cpython-310.pyc 0000644 00000014344 15030043552 0014464 0 ustar 00 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 $ " twist/__pycache__/__init__.cpython-310.pyc 0000644 00000000312 15030043552 0014357 0 ustar 00 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 twist/_options.py 0000644 00000014722 15030043552 0010125 0 ustar 00 # -*- 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.") twist/test/test_twist.py 0000644 00000017621 15030043552 0011464 0 ustar 00 # 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) twist/test/__pycache__/test_options.cpython-310.pyc 0000644 00000027666 15030043552 0016356 0 ustar 00 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" twist/test/__pycache__/__init__.cpython-310.pyc 0000644 00000000333 15030043552 0015341 0 ustar 00 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 twist/test/__pycache__/test_twist.cpython-310.pyc 0000644 00000021252 15030043552 0016016 0 ustar 00 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$ $ twist/test/test_options.py 0000644 00000026252 15030043552 0012005 0 ustar 00 # 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) twist/test/__init__.py 0000644 00000000262 15030043552 0011003 0 ustar 00 # -*- test-case-name: twisted.application.twist.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.application.twist}. """ twist/_twist.py 0000644 00000006762 15030043552 0007611 0 ustar 00 # -*- 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) twist/__init__.py 0000644 00000000246 15030043552 0010026 0 ustar 00 # -*- test-case-name: twisted.application.twist.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ C{twist} command line tool. """ service.py 0000644 00000026746 15030043552 0006572 0 ustar 00 # -*- 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", ] __pycache__/internet.cpython-310.pyc 0000644 00000110126 15030043552 0013303 0 ustar 00 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 w __pycache__/__init__.cpython-310.pyc 0000644 00000000330 15030043552 0013205 0 ustar 00 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 __pycache__/strports.cpython-310.pyc 0000644 00000005112 15030043552 0013351 0 ustar 00 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. ���� � �� � __pycache__/app.cpython-310.pyc 0000644 00000053202 15030043552 0012234 0 ustar 00 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~ __pycache__/service.cpython-310.pyc 0000644 00000032520 15030043552 0013114 0 ustar 00 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 __pycache__/reactors.cpython-310.pyc 0000644 00000005413 15030043552 0013277 0 ustar 00 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 test/__pycache__/__init__.cpython-310.pyc 0000644 00000000330 15030043552 0014164 0 ustar 00 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 test/__pycache__/test_internet.cpython-310.pyc 0000644 00000117121 15030043552 0015323 0 ustar 00 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> @ # test/__pycache__/test_service.cpython-310.pyc 0000644 00000013756 15030043552 0015144 0 ustar 00 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 W1 test/test_internet.py 0000644 00000121517 15030043552 0010770 0 ustar 00 # -*- 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 ) test/test_service.py 0000644 00000011457 15030043552 0010601 0 ustar 00 # 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))) test/__init__.py 0000644 00000000174 15030043552 0007633 0 ustar 00 # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.internet.application}. """ reactors.py 0000644 00000004441 15030043552 0006740 0 ustar 00 # -*- 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) strports.py 0000644 00000005041 15030043552 0007013 0 ustar 00 # -*- 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"] app.py 0000644 00000055161 15030043552 0005703 0 ustar 00 # -*- 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) runner/__pycache__/_exit.cpython-310.pyc 0000644 00000005345 15030043552 0014102 0 ustar 00 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 �$( runner/__pycache__/__init__.cpython-310.pyc 0000644 00000000335 15030043552 0014523 0 ustar 00 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 runner/__pycache__/_pidfile.cpython-310.pyc 0000644 00000022023 15030043552 0014535 0 ustar 00 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/ runner/__pycache__/_runner.cpython-310.pyc 0000644 00000012235 15030043552 0014436 0 ustar 00 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 $ runner/_pidfile.py 0000644 00000016364 15030043552 0010211 0 ustar 00 # -*- 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. """ runner/test/__pycache__/test_pidfile.cpython-310.pyc 0000644 00000033727 15030043552 0016431 0 ustar 00 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" $" & runner/test/__pycache__/__init__.cpython-310.pyc 0000644 00000000335 15030043552 0015502 0 ustar 00 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 runner/test/__pycache__/test_runner.cpython-310.pyc 0000644 00000036121 15030043552 0016315 0 ustar 00 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 , $ @ runner/test/__pycache__/test_exit.cpython-310.pyc 0000644 00000005350 15030043552 0015755 0 ustar 00 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 5 runner/test/test_pidfile.py 0000644 00000031073 15030043552 0012062 0 ustar 00 # 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 runner/test/test_exit.py 0000644 00000004221 15030043552 0011412 0 ustar 00 # 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 runner/test/test_runner.py 0000644 00000034245 15030043552 0011763 0 ustar 00 # 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. """ runner/test/__init__.py 0000644 00000000264 15030043552 0011144 0 ustar 00 # -*- test-case-name: twisted.application.runner.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.application.runner}. """ runner/_runner.py 0000644 00000012774 15030043552 0010107 0 ustar 00 # -*- 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) runner/_exit.py 0000644 00000005574 15030043552 0007547 0 ustar 00 # -*- 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) runner/__init__.py 0000644 00000000271 15030043552 0010163 0 ustar 00 # -*- test-case-name: twisted.application.runner.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Facilities for running a Twisted application. """ internet.py 0000644 00000110454 15030043552 0006750 0 ustar 00 # -*- 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", ] __init__.py 0000644 00000000201 15030043552 0006643 0 ustar 00 # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Configuration objects for Twisted Applications. """
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.03 |
proxy
|
phpinfo
|
Settings