Remove third_party/twisted_8_1

third_party/twisted_8_1/twisted/application/internet.py

-# -*- test-case-name: twisted.test.test_application,twisted.test.test_cooperator -*-
-
-# Copyright (c) 2001-2007 Twisted Matrix Laboratories.
-# See LICENSE for details.
-
-"""
-Reactor-based Services
-
-Here are services to run clients, servers and periodic services using
-the reactor.
-
-This module (dynamically) defines various Service subclasses that let
-you represent clients and servers in a Service hierarchy.
-
-They are as follows::
-
-  TCPServer, TCPClient,
-  UNIXServer, UNIXClient,
-  SSLServer, SSLClient,
-  UDPServer, UDPClient,
-  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.
-
-Maintainer: U{Moshe Zadka<mailto:moshez@twistedmatrix.com>}
-"""
-
-from twisted.python import log
-from twisted.application import service
-from twisted.internet import task
-
-
-class _VolatileDataService(service.Service):
-
-    volatile = []
-
-    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 C{IListeningPort}.
-    """
-
-    volatile = ['_port']
-    method = None
-    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{IListeningPort}.
-        """
-        if self.reactor is None:
-            from twisted.internet import reactor
-        else:
-            reactor = self.reactor
-        return getattr(reactor, 'listen%s' % (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 C{IConnector}.
-    """
-    volatile = ['_connection']
-    method = None
-    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{IConnector}.
-        """
-        if self.reactor is None:
-            from twisted.internet import reactor
-        else:
-            reactor = self.reactor
-        return getattr(reactor, 'connect%s' % (self.method,))(
-            *self.args, **self.kwargs)
-
-
-
-_doc={
-'Client':
-"""Connect to %(tran)s
-
-Call reactor.connect%(method)s when the service starts, with the
-arguments given to the constructor.
-""",
-'Server':
-"""Serve %(tran)s clients
-
-Call reactor.listen%(method)s 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.
-""",
-}
-
-import new
-for tran in 'Generic TCP UNIX SSL UDP UNIXDatagram Multicast'.split():
-    for side in 'Server Client'.split():
-        if tran == "Multicast" and side == "Client":
-            continue
-        base = globals()['_Abstract'+side]
-        method = {'Generic': 'With'}.get(tran, tran)
-        doc = _doc[side]%vars()
-        klass = new.classobj(tran+side, (base,),
-                             {'method': method, '__doc__': doc})
-        globals()[tran+side] = klass
-
-
-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.
-    """
-
-    volatile = ['_loop']
-
-    def __init__(self, step, callable, *args, **kwargs):
-        self.step = step
-        self.call = (callable, args, kwargs)
-
-    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.start(self.step, now=True).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):
-        if self._loop.running:
-            self._loop.stop()
-        return service.Service.stopService(self)
-
-
-
-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()
-
-
-
-__all__ = (['TimerService', 'CooperatorService'] +
-           [tran+side
-         for tran in 'Generic TCP UNIX SSL UDP UNIXDatagram Multicast'.split()
-         for side in 'Server Client'.split()])