Twisted框架学习

　　Twisted是用Python实现的基于事件驱动的网络引擎框架，是python中一个强大的异步IO库。理解twisted的一个前提是弄清楚twisted中几个核心的概念: reactor, Protocl, ProtocolFactory, Deffered

1 reactor

twisted.internet.reactor

https://twistedmatrix.com/documents/current/core/howto/reactor-basics.html

reactor是twisted异步框架中的核心组件，是一个基于select，poll或epoll的事件循环，其监听socket的状态，当socket状态有变化时（有新的连接请求，或接受到数据等）时，调用相应的组件来进行处理。如下图的reactor loop一样，不断的循环扫描socket列表中监听对象的状态，当有特定事件发生时（socket状态变化）调用回调函数callback，来处理事件，这时候执行权限交给回调函数，当我们的代码处理完事件后，将执行权返回给reactor，继续进行循环监听。

Twisted框架学习

2，Factory和Protocol

twisted.internet.protocol.Factory

twisted.internet.protocol.Protocol

参考文章：

https://twistedmatrix.com/documents/current/core/howto/servers.html

https://twistedmatrix.com/documents/current/core/howto/clients.html

https://zhuanlan.zhihu.com/p/28763807?utm_source=wechat_session&utm_medium=social

　　Factory和Protocol都是用来处理一些配置和协议相关的底层业务，如socket之间连接，数据的发送格式等。Factory设置持久的，多个socket可共享的通用配置，Protocol为设置单个socket的特定配置。当有一个socket连接请求时，Factory创建一个Protocol实例，并将该实例的factory属性指向自己，请求断开时，protocol即被销毁。如下第一幅图中，基于twisted的一个异步服务器，其中endpiont为绑定的ip和端口，reactor监听其socket的状态，当有连接请求时，reactor调用Factory来设置相关配置，其随后会创建（buildProtocol）Protocol实例，Protocol实例的Transport属性会处理客户端socket的请求，并执行相应的回调函数。在第二幅图中可以看到，reactor共监听四个socket，一个是服务端listening socket（其绑定的ip和port），和三个客户端socket，而每个客户端socket都有自己的Protocol来处理相应的数据交互请求，这些Protocol都由Factory创建。（也可以有多个Factory，每个Factory创建多个Protocol）

Twisted框架学习

Factory: 主要用来创建protocol，也可以定义其他操作

twisted.internet.protocol.Factory

　　Factory类的源码如下，其有属性protocol和方法buildProtocol()较为重要，其中protocol指向需要创建的Protocol类，从buildProtocol()方法可以看到其创建了Protocol实例，并且将该实例的factory属性指向了Factory 实例。startFactory()和stopFactory()相当于钩子函数，在factory和端口连接和断开时调用。在实际应用时，一般选择继承Factory的子类，并实现相应的方法，如ClientFactory，SeverFactory。

@implementer(interfaces.IProtocolFactory, interfaces.ILoggingContext)
class Factory:
    """
    This is a factory which produces protocols.

    By default, buildProtocol will create a protocol of the class given in
    self.protocol.
    """

    # put a subclass of Protocol here:
    protocol = None

    numPorts = 0
    noisy = True

    @classmethod
    def forProtocol(cls, protocol, *args, **kwargs):
        """
        Create a factory for the given protocol.

        It sets the C{protocol} attribute and returns the constructed factory
        instance.

        @param protocol: A L{Protocol} subclass

        @param args: Positional arguments for the factory.

        @param kwargs: Keyword arguments for the factory.

        @return: A L{Factory} instance wired up to C{protocol}.
        """
        factory = cls(*args, **kwargs)
        factory.protocol = protocol
        return factory


    def logPrefix(self):
        """
        Describe this factory for log messages.
        """
        return self.__class__.__name__


    def doStart(self):
        """Make sure startFactory is called.

        Users should not call this function themselves!
        """
        if not self.numPorts:
            if self.noisy:
                _loggerFor(self).info("Starting factory {factory!r}",
                                      factory=self)
            self.startFactory()
        self.numPorts = self.numPorts + 1

    def doStop(self):
        """Make sure stopFactory is called.

        Users should not call this function themselves!
        """
        if self.numPorts == 0:
            # this shouldn't happen, but does sometimes and this is better
            # than blowing up in assert as we did previously.
            return
        self.numPorts = self.numPorts - 1
        if not self.numPorts:
            if self.noisy:
                _loggerFor(self).info("Stopping factory {factory!r}",
                                      factory=self)
            self.stopFactory()

    def startFactory(self):
        """This will be called before I begin listening on a Port or Connector.

        It will only be called once, even if the factory is connected
        to multiple ports.

        This can be used to perform 'unserialization' tasks that
        are best put off until things are actually running, such
        as connecting to a database, opening files, etcetera.
        """

    def stopFactory(self):
        """This will be called before I stop listening on all Ports/Connectors.

        This can be overridden to perform 'shutdown' tasks such as disconnecting
        database connections, closing files, etc.

        It will be called, for example, before an application shuts down,
        if it was connected to a port. User code should not call this function
        directly.
        """


    def buildProtocol(self, addr):
        """
        Create an instance of a subclass of Protocol.

        The returned instance will handle input on an incoming server
        connection, and an attribute "factory" pointing to the creating
        factory.

        Alternatively, L{None} may be returned to immediately close the
        new connection.

        Override this method to alter how Protocol instances get created.

        @param addr: an object implementing L{twisted.internet.interfaces.IAddress}
        """
        p = self.protocol()
        p.factory = self
        return p

Factory