python2.0_s12_day10_Twsited异步网络框架

Twsited异步网络框架
    Twisted是一个事件驱动的网络框架，其中包含了诸多功能，例如：网络协议、线程、数据库管理、网络操作、电子邮件等。
            Package     application     Configuration objects for Twisted Applications
            Package     conch           Twisted Conch:The Twisted Shell.Terminal emulation,SSHv2 and telnet
            Module      copyright       Copyright information for Twisted
            Package     cred            Twisted Cred;Support for verifying credentials,and providing services to user based on those credentials
            Package     enterprise      Twisted Enterprise;Database support for Twisted services.
 (用的比较多)Package     internet        Twisted Internet;Asynchronous I/O and Events.
            Package     logger          Twisted Logger;Classes and functions to do granular logging.
            Package     mail            Twisted Mail;Servers and clients for POP3,ESMTP,and IMAP.
            Package     manhole         Twisted Manhole;interactive interpreter and direct manipulation support for Twisted.
            Package     names           Twisted Names;DNS server and client implementations.
            Package     news            Twisted News;A NNTP-based news service.
            Package     pair            Twisted Pair.The framework of your ethernet.
            Package     persisted       Twisted Persisted;Utilities for managing persistence.
            Module      plugin          Plugin system for Twisted.
            Package     plugins         Plugin for services implemented in Twisted.
            Package     positioning     Twisted Positioning;Framework for applications that make use of positioning.
            Package     protocols       Twisted Protocols;A collection of internet protocol implementations.
            Package     python          Twisted Python;Utilities and Enhancements for Python.
            Package     runner          Twisted Runner;Run and monitor processes.
            Package     scripts         Subpackage containing the modules that implement the command line tools.
            Package     spread          Twisted Spread;Spreadable (Distributed) Computing.
            Package     tap             Twisted TAP;Twisted Application Persistence builders for other Twisted servers.
            Package     test            Twisted's unit tests.
            Package     trial           Twisted Trial:Asynchronous unit testing framework.
            Package     web             Twisted Web:HTTP clients and servers,plus tools for implementing them.
            Package     words           Twisted Words:Client and server implementations for IRC.XMPP,and other chat services.
事件驱动
    简而言之，事件驱动分为二个部分：第一，注册事件；第二，触发事件。

自定义事件驱动框架，命名为：“弑君者”：

         #!/usr/bin/env python
         # -*- coding:utf- -*-

         # event_drive.py
         '''假设是最牛逼的事件驱动框架'''

         event_list = [] #所有要被触发的事件,都要在此注册

         def run():      # 触发的方法
             for event in event_list:    # 遍历事件列表
                 obj = event()           # 把列表中的每一个事件实例化
                 obj.execute()           # 实例化后执行一个execute()方法
                                         # 所以也就是说,肯定要求所有注册在这个列表里的所有事件要遵守这个规则,要有这个方法
                                         # 那么没有这个方法怎么办?所以避免有些注册的事件没有execute()方法,它紧接着定义一个基类.
                                         # 基类中就有一个execute()方法.所有要注册的类,就要继承这个类,那么这些事件类就有这个方法.继承后你就必须重写这个execute()方法
                                         # 这就是一个典型的一个基本的事件驱动模型.一回讲的Twisted ,它的本质也是这样的.就是你自己先写好一个事件,然后把这个事件交给事件管理器进行管理.注册完,你就开始触发它,接下来它就帮你维护了.
         class BaseHandler(object):  # 定义一个事件基类,基类中有execute()方法.
             """
             用户必须继承该类，从而规范所有类的方法（类似于接口的功能）
             """
             def execute(self):
                 raise Exception('you must overwrite execute')

     PS: 这就是一个典型的一个基本的事件驱动模型.一会讲的Twisted事件驱动的框架 ,它的本质也是这样的.就是你自己先写好一个事件,然后把这个事件交给事件管理器进行管理.注册完,你就开始触发它,接下来它就帮你维护了.

         
        程序员使用“弑君者框架”：　　

             #!/usr/bin/env python
             # -*- coding:utf- -*-

             from source import event_drive

             class MyHandler(event_drive.BaseHandler):

                 def execute(self):
                     print 'event-drive execute MyHandler'

             event_drive.event_list.append(MyHandler)
             event_drive.run()

        PS: 假设“弑君者”这个就是一个史上最牛的一个事件驱动框架.
        你想使用这个框架,并且还想在框架中添加一个事件.这时候你去看这个框架的Readme文档.

         于是readme上就这么写的:
             . 你自定义的事件,要继承我这个框架中的一个事件基类 这里的基类是 "BaseHandler"
             . 必须在你的类中写一个execute()方法
             . 把你自定义的事件类,注册到event_list
             . 你执行我指定的run()方法,

        只要你按照上面的4条指定了,那么这个牛逼框架就应用上了,框架在执行过程中就会调用你写的类的execute()方法.

twisted网络框架中的twisted.internet (这个标题是我加上的,我认为下面的protocols)

    Protocols
        Protocols描述了如何以异步的方式处理网络中的事件。HTTP、DNS以及IMAP是应用层协议中的例子。Protocols实现了IProtocol接口，它包含如下的方法：
            makeConnection               在transport对象和服务器之间建立一条连接
            connectionMade               连接建立起来后调用
            dataReceived                 接收数据时调用
            connectionLost               关闭连接时调用

    Transports
        Transports代表网络中两个通信结点之间的连接。Transports负责描述连接的细节，比如连接是面向流式的还是面向数据报的，流控以及可靠性。TCP、UDP和Unix套接字可作为transports的例子。它们被设计为“满足最小功能单元，同时具有最大程度的可复用性”，而且从协议实现中分离出来，这让许多协议可以采用相同类型的传输。Transports实现了ITransports接口，它包含如下的方法：
            write                   以非阻塞的方式按顺序依次将数据写到物理连接上
            writeSequence           将一个字符串列表写到物理连接上
            loseConnection          将所有挂起的数据写入，然后关闭连接
            getPeer                 取得连接中对端的地址信息
            getHost                 取得连接中本端的地址信息
            将transports从协议中分离出来也使得对这两个层次的测试变得更加简单。可以通过简单地写入一个字符串来模拟传输，用这种方式来检查。
    我们学习到此处时,基础都已经差不多了,接下来就是对框架\模块\常用的写法进行熟悉.所以在学习此类知识的时候,就不能像之前学习基础一样的要求自己都记住.因为你根本不可能记住,这尼玛都是用到的时候差资料的.
    所以关键点是清楚某一个模块有几种应用场景,代码能够看懂即可,用的时候就去查看总结.如果你没有总结,就需要查了,所以建议大家在学习的时候要做下笔记,写下博客,自己总结出来的东西带着你自己的思路,再次翻阅就会很快记起来.
    下面我门来总结下twsited的两种应用场景
    1.用twsited.internet模块书写一个echo server
    2.用twsited.internet模块写一个可以同时从多个server上获取信息的客户端工具

    具体代码范例如下:
    1.用twsited.internet模块书写一个echo server
    echo server端代码:

         #!/usr/bin/env python3.
         #__author__:'ted.zhou'
         '''
         使用twisted框架实现echo_server
         '''
         from twisted.internet import protocol # 从twisted的一个功能框架twisted.internet 中导入protocol模块
         from twisted.internet import reactor    # 从twisted 的功能框架twisted.internet 中导入reactor模块,可以把reactor模块看作是类似socketserver模块中的socketserver.ThreadingTCPServer()方法整成了一个模块

         class Echo(protocol.Protocol):  # 首先创建一个类,但是这个类要继承protocol模块中的一个Protocol类,这个protocal基类,是事件驱动框架中的操作实例,里面可以有connectionMade\dataReceived\connectionLost方法,这些方法在调用reactor.run方法后触发
             def dataReceived(self, data):   # 这里就定义了一个在实例化后要调用的函数
                 self.transport.write(data)  # 这里调用transport.write()方法,九会触发client端的dataReceived的方法

         def main():
             factory = protocol.ServerFactory() # 服务工厂类,被监控的实例对象
             factory.protocol = Echo            # 把被监控的实例对象和操作实例对象进行绑定,这步代码后,factory和echo就你中有我我中有你,factory.protocal = echo ,同样echo 的self.factory = factory
             reactor.listenTCP(,factory)     # reactor相当于socketserver.ThreadingTCPServer,port传进去,可以传入IP,port的元组如('0.0.0.0',)
             # 也可以理解成
             reactor.run()                       # 调用启动twisted.internet模块的方法

         if __name__ == '__main__':
             main()

    echo_client端代码:

         #!/usr/bin/env python3.
         #__author__:'ted.zhou'
         '''
         twisted.internet里的protocal
         '''
         from twisted.internet import reactor, protocol  # 导入reactor和protocal模块

         # a client protocol

         # 创建一个事件驱动中事件触发后,要执行的操作步骤类,此类有connectionMade\dataReceived\connectionLost方法
         class EchoClient(protocol.Protocol):

             """Once connected, send a message, then print the result."""

             def connectionMade(self): #定义connectionMade方法,当连接建立起来后调用
                 self.transport.write("hello alex!")

             def dataReceived(self, data): # 定义dataReceived方法,接收数据时调用
                 "As soon as any data is received, write it back."
                 print("Server said:", data)
                 self.transport.loseConnection() # 调用连接关闭方法

             def connectionLost(self, reason):  # 定义connectionLost方法,关闭连接时调用
                 print("connection lost")    # 打印关闭信息

         # 创建一个客户端Factory,事件驱动框架监控的实例对象
         class EchoFactory(protocol.ClientFactory):
             protocol = EchoClient   # 将客户端Facotory和Protocol绑定,绑定后你中有我,我中有你,即EchoFactory.protocol = EchoClient
                                     # 而 EchoClient 的类EchoClient.factory = EchoFactory

             def clientConnectionFailed(self, connector, reason): # 定义一个方法,当连接失败时调用
                 print("Connection failed - goodbye!")
                 reactor.stop()

             def clientConnectionLost(self, connector, reason):  # 定义一个方法,当连接断开后调用,这个和protocol里的connectionLost()方法类似,只是这是操作对象中定义的,也是当连接关闭后调用,但是它的顺序要在protocol里的connectionLost()方法之后
                 print("Connection lost - goodbye!")
                 reactor.stop()

         # this connects the protocol to a server running on port
         def main():
             f = EchoFactory()       # 实例化EchoFactory对象
             reactor.connectTCP("localhost", , f)  # 监控指定主机\端口 以及 Facotory 实例
             reactor.run()

         # this only runs if the module was *not* imported
         if __name__ == '__main__':
             main()

    2.用twsited.internet模块写一个可以同时从多个server上获取信息的客户端工具
    server_side端代码:

  #!/usr/bin/env python3.
         #_*_coding:utf-8_*_
         #__author__:"ted.zhou"
         # This is the Twisted Fast Poetry Server, version 1.0

         import optparse, os
         # optparse 模块自动的处理程序执行的参数

         from twisted.internet.protocol import ServerFactory, Protocol

         def parse_args():
             # 定一个变量说明文档用于实例化optparse对象时使用,这个信息会在参数输入错误,或者不加参数时输出
             usage = """usage: %prog [options] poetry-file

         This is the Fast Poetry Server, Twisted edition.
         Run it like this:

           python fastpoetry.py <path-to-poetry-file>

         If you are in the base directory of the twisted-intro package,
         you could run it like this:

           python twisted-server-/fastpoetry.py poetry/ecstasy.txt

         to serve up John Donne's Ecstasy, which I know you want to do.
         """

             parser = optparse.OptionParser(usage)   # 实例化optparse.OptionParser()对象,此实例默认有一个-h选项,

             help = "The port to listen on. Default to a random available port."
             parser.add_option('--port', type='int', help=help)  # 给parser对象添加一个选项, 参数介绍:'--port'选项为'--port', type='int'选项的参数指定为int类型, help=help 此选项的说明.会在parser对象调用-h选项时打印

             help = "The interface to listen on. Default is localhost."
             parser.add_option('--iface', help=help, default='localhost') # 给parser对象添加一个选项, 参数介绍:'--ifce'选项为'--ifce',  help=help 此选项的说明.会在parser对象调用-h选项时打印,default='localhost'如果程序运行时不指定使用此参数时,参数的值为'localhost'

             options, args = parser.parse_args()     # 获取options 和参数的值.
             print("--arg:",options,args)

             if len(args) != :                      # 如果获得的参数数量为0,则调用parser.error()方法报错
                 parser.error('Provide exactly one poetry file.')

             poetry_file = args[]                   # 如果不为0,那么取参数的第一个

             if not os.path.exists(args[]):         # 判断这个参数是不是一个文件
                 parser.error('No such file: %s' % poetry_file)  # 如果不是一个文件则调用parser.error()方法报错

             return options, poetry_file         # 如果parser最终没有报错,则返回 选项字典 和 文件url

         class PoetryProtocol(Protocol): # 自定义一个Protocol,要继承Protocol,

             def connectionMade(self):   # 定义connectionMade 方法 ,当网络连接成功后触发调用此方法,reactor.run()方法管理维护factor,连接事件触发factor
                 #reactor.run()方法管理维护factor,我们可以想象,reactor.run方法就是twsited.internet框架中的运行方法,
                 # 我们猜想在调用reactor.run()方法后,它内部到底做了什么样的事情呢?既然是猜想,我们就大胆的想,假设reactor.run()方法里有很多像select()中监控的列表实现异步IO.当连接进来了,它就调用你传入的需要维护factor中的protocal的connectionMade()方法进行调用.
                 # 这里我们调用transport.write()方法,这时我们可想,根据protocal的方法,客户端如果用的也是twisted.internet框架,此时这里的write()事件,就会触发客户端调用客户端factor.protocal的dateReceived()方法
                 self.transport.write(self.factory.poem) # 对连接通道发送数据,是客户端twisted.internet框架触发调用clientfactor.protocal的dataReceived()方法
                 self.transport.loseConnection() # 发送完成后这里调用loseConnection关闭这个连接,那么又会触发客户端调用clientfactor.protocal的connectionLost()方法,其实也会调用服务端的,只是服务端没有定义connectionLost()方法,所以服务端不调用

         class PoetryFactory(ServerFactory): # 定义一个服务端的Factory,要继承ServerFactory基类

             protocol = PoetryProtocol       # 定义服务端Factory的protocol变量为PoetryProtocol,PS:这里要重点说明下
                                             # 简简单单的protocol = PoetryProtocol的一句代码,其实实现了很多内容
                                             # . protocol这个变量 赋予的是 实例化后的PoetryProtocol(),不然后面事件是没有办法触发PoetryProtocol.connectionMade()方法
                                             # . 建立了Factory和Protocal之间的关联,也就是说Factory可以通过Factory.protocal调用protocal中的方法,而protocal可以通过protocal.factor.xx 来调用factor的方法

             def __init__(self, poem):   # 定义构造方法,只是为了传入值
                 self.poem = poem

         def main():                                 # 定义main()方法
             options, poetry_file = parse_args()     # 首先获取运行程序的选项,和文件参数(这时获得的肯定是文件参数,不然parser参数处理在报错时就直接退出了)

             poem = open(poetry_file).read()         # 把文件读出来

             factory = PoetryFactory(poem)           # 实例化服务器段的Factory,这里是PoetryFactory(),把读到的字符串作为参数传入

             from twisted.internet import reactor    # 导入reactor,我觉得reactor就是twisted.internet框架的主监控模块,把factor传给reactor进行实例化后,在调用reactor.run()方法,监控事件循环了.

             port = reactor.listenTCP(options.port or , factory,interface=options.iface) # 实例化reactor,实例化的时候要输入端口,和IP,因为这是twsited.internet框架

             print('Serving %s on %s.' % (poetry_file, port.getHost())) # 打印启动的提示信息

             reactor.run()       # 程序进入阻塞状态,具体阻塞在哪里,可能是阻塞在reactor模块类似select()的地方.这样好理解

         if __name__ == '__main__':
             main()

         # 总结:理解twisted.internet框架,要记住下面几个知识点
         # .这是一个事件驱动的异步IO框架
         # .事件驱动框架就有一系列的事件循环和操作对象和操作内容,那循环监控的事件是哪些呢?就是连接建立事件,连接关闭事件,数据接收事件,数据发送事件,这几个事件都是在twisted.internet框架里实现的.代码是通过实例化reactor对象,并调用run()方法实现的
         # 这些监控的事件理清了,就会想到这些事件一旦发生了,对什么做哪些操作的.这就是操作的对象和内容.操作的对象我们理解成ServerFactory和ClientFactory对象,所以你想自己定义,就需要继承上面的两个类
         # 操作对象有了,就差操作内容了. 操作内容就是protocal.Protocal类,所以你要定义自己的也需要继承这个类.
         # .循环内容\操作对象\操作内容都有了,下面要知道的就是什么事件调用什么操作内容了? 那就是上面的知识点
         # Protocols
         # Protocols描述了如何以异步的方式处理网络中的事件。HTTP、DNS以及IMAP是应用层协议中的例子。Protocols实现了IProtocol接口，它包含如下的方法：
         # makeConnection               在transport对象和服务器之间建立一条连接
         # connectionMade               连接建立起来后调用
         # dataReceived                 接收数据时调用
         # connectionLost               关闭连接时调用
         # .所以你想利用事件驱动触发动作,就需要在自己的protocal中定义上面的3中方法,其他自定义的貌似不会触发,除非内部调用

    client_side端

         #!/usr/bin/evn python3.
         #__author__:"ted.zhou"
         # This is the Twisted Get Poetry Now! client, version 3.0.

         # NOTE: This should not be used as the basis for production code.

         import optparse

         from twisted.internet.protocol import Protocol, ClientFactory

         # 定义一个参数类
         def parse_args():
             usage = """usage: %prog [options] [hostname]:port ...

         This is the Get Poetry Now! client, Twisted version 3.0
         Run it like this:

           python get-poetry-.py port1 port2 port3 ...
         """

             parser = optparse.OptionParser(usage)   # 实例化参数,usage默认的说明文档

             _, addresses = parser.parse_args()      # 获得执行程序本身,和参数

             if not addresses:                       # 如果没有参数,则打印帮助文档并退出程序
                 print(parser.format_help())
                 parser.exit()

             def parse_address(addr):                # 定义地址的处理参数
                 if ':' not in addr:                 # 如果参数只是一个端口整数
                     host = '127.0.0.1'              # 设置默认主机地址为127.0.0.
                     port = addr                     # 端口为参数传入的值
                 else:
                     host, port = addr.split(':', ) # 否则用:隔开前面的为地址,后面的是端口

                 if not port.isdigit():              # 判断获得的端口是不是数字
                     parser.error('Ports must be integers.')

                 return host, int(port)              # 返回地址和端口

             return map(parse_address, addresses)    # 使用map关键字,获得地址端口的组合[('192.168.1.1',),('192.168.2.1',)]

         class PoetryProtocol(Protocol):     # 定义一个事件触发后操作内容类

             poem = ''                       #

             def dataReceived(self, data):  # 定义dataReceived方法
                 self.poem += data

             def connectionLost(self, reason):   # 定义connectionLost方法,当连接关闭时触发此方法
                 self.poemReceived(self.poem)    # 调用poemReceived方法

             def poemReceived(self, poem):       # 定义poemReceived方法,
                 self.factory.poem_finished(poem)    # 调用factory.poem_finished方法

         class PoetryClientFactory(ClientFactory): # 定义客户端Factory方法

             protocol = PoetryProtocol   # 绑定PoetryClientFactory的Protocol  和 PoetryProtocol 的factory

             def __init__(self, callback):   # 定义构造方法,传入callback方法
                 self.callback = callback

             def poem_finished(self, poem):  # 定义一个poem_finished()方法
                 self.callback(poem)         # 调用self.callback()方法

         def get_poetry(host, port, callback):
             """
             Download a poem from the given host and port and invoke

               callback(poem)

             when the poem is complete.
             """
             from twisted.internet import reactor    # 导入reactor
             factory = PoetryClientFactory(callback) # 实例化被监控的对象 PoetryClientFactory
             reactor.connectTCP(host, port, factory) # 监控主机\端口和被监控对象

         def poetry_main():
             addresses = parse_args()                # 获得客户端监控的对象

             from twisted.internet import reactor    # 导入reactor

             poems = []                              # 初始化一个列表,用于存储接收的诗集

             def got_poem(poem):                     # 定义接收服务器传过来的诗集的函数
                 poems.append(poem)                  # 把接收到的诗集加入列表中
                 if len(poems) == len(addresses):    # 如果诗集元素的个数等于地址的个数,说明接收完成,否则接收继续
                     reactor.stop()

             for address in addresses:               # 循环地址元组列表
                 host, port = address                # 获得地址和端口
                 get_poetry(host, port, got_poem)    # 启动监控,有几个元素启几个

             reactor.run()                           # 开启事件监控

             for poem in poems:                      #
                 print(poem)

         if __name__ == '__main__':
             poetry_main()

        # 上面的代码能看懂,但是这个绕啊,只能模仿了,让我写我是暂时写不出来