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.
事件驱动
    简而言之，事件驱动分为二个部分：第一，注册事件；第二，触发事件。

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

 1         #!/usr/bin/env python
 2         # -*- coding:utf-8 -*-
 3          
 4         # event_drive.py
 5         '''假设是最牛逼的事件驱动框架'''
 6          
 7         event_list = [] #所有要被触发的事件,都要在此注册
 8          
 9         def run():      # 触发的方法
10             for event in event_list:    # 遍历事件列表
11                 obj = event()           # 把列表中的每一个事件实例化
12                 obj.execute()           # 实例化后执行一个execute()方法
13                                         # 所以也就是说,肯定要求所有注册在这个列表里的所有事件要遵守这个规则,要有这个方法
14                                         # 那么没有这个方法怎么办?所以避免有些注册的事件没有execute()方法,它紧接着定义一个基类.
15                                         # 基类中就有一个execute()方法.所有要注册的类,就要继承这个类,那么这些事件类就有这个方法.继承后你就必须重写这个execute()方法
16                                         # 这就是一个典型的一个基本的事件驱动模型.一回讲的Twisted ,它的本质也是这样的.就是你自己先写好一个事件,然后把这个事件交给事件管理器进行管理.注册完,你就开始触发它,接下来它就帮你维护了.
17         class BaseHandler(object):  # 定义一个事件基类,基类中有execute()方法.
18             """
19             用户必须继承该类，从而规范所有类的方法（类似于接口的功能）
20             """
21             def execute(self):
22                 raise Exception('you must overwrite execute')

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

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

 1             #!/usr/bin/env python
 2             # -*- coding:utf-8 -*-
 3 
 4             from source import event_drive
 5 
 6 
 7             class MyHandler(event_drive.BaseHandler):
 8 
 9                 def execute(self):
10                     print 'event-drive execute MyHandler'
11 
12 
13             event_drive.event_list.append(MyHandler)
14             event_drive.run()

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

1         于是readme上就这么写的:
2             1. 你自定义的事件,要继承我这个框架中的一个事件基类 这里的基类是 "BaseHandler"
3             2. 必须在你的类中写一个execute()方法
4             3. 把你自定义的事件类,注册到event_list
5             4. 你执行我指定的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端代码:

 1         #!/usr/bin/env python3.5
 2         #__author__:'ted.zhou'
 3         '''
 4         使用twisted框架实现echo_server
 5         '''
 6         from twisted.internet import protocol # 从twisted的一个功能框架twisted.internet 中导入protocol模块
 7         from twisted.internet import reactor    # 从twisted 的功能框架twisted.internet 中导入reactor模块,可以把reactor模块看作是类似socketserver模块中的socketserver.ThreadingTCPServer()方法整成了一个模块
 8 
 9         class Echo(protocol.Protocol):  # 首先创建一个类,但是这个类要继承protocol模块中的一个Protocol类,这个protocal基类,是事件驱动框架中的操作实例,里面可以有connectionMade\dataReceived\connectionLost方法,这些方法在调用reactor.run方法后触发
10             def dataReceived(self, data):   # 这里就定义了一个在实例化后要调用的函数
11                 self.transport.write(data)  # 这里调用transport.write()方法,九会触发client端的dataReceived的方法
12 
13         def main():
14             factory = protocol.ServerFactory() # 服务工厂类,被监控的实例对象
15             factory.protocol = Echo            # 把被监控的实例对象和操作实例对象进行绑定,这步代码后,factory和echo就你中有我我中有你,factory.protocal = echo ,同样echo 的self.factory = factory
16             reactor.listenTCP(1234,factory)     # reactor相当于socketserver.ThreadingTCPServer,port传进去,可以传入IP,port的元组如('0.0.0.0',9000)
17             # 也可以理解成
18             reactor.run()                       # 调用启动twisted.internet模块的方法
19 
20         if __name__ == '__main__':
21             main()

    echo_client端代码:

 1         #!/usr/bin/env python3.5
 2         #__author__:'ted.zhou'
 3         '''
 4         twisted.internet里的protocal
 5         '''
 6         from twisted.internet import reactor, protocol  # 导入reactor和protocal模块
 7 
 8         # a client protocol
 9 
10         # 创建一个事件驱动中事件触发后,要执行的操作步骤类,此类有connectionMade\dataReceived\connectionLost方法
11         class EchoClient(protocol.Protocol):
12 
13             """Once connected, send a message, then print the result."""
14 
15             def connectionMade(self): #定义connectionMade方法,当连接建立起来后调用
16                 self.transport.write("hello alex!")
17 
18             def dataReceived(self, data): # 定义dataReceived方法,接收数据时调用
19                 "As soon as any data is received, write it back."
20                 print("Server said:", data)
21                 self.transport.loseConnection() # 调用连接关闭方法
22 
23             def connectionLost(self, reason):  # 定义connectionLost方法,关闭连接时调用
24                 print("connection lost")    # 打印关闭信息
25 
26         # 创建一个客户端Factory,事件驱动框架监控的实例对象
27         class EchoFactory(protocol.ClientFactory):
28             protocol = EchoClient   # 将客户端Facotory和Protocol绑定,绑定后你中有我,我中有你,即EchoFactory.protocol = EchoClient
29                                     # 而 EchoClient 的类EchoClient.factory = EchoFactory
30 
31             def clientConnectionFailed(self, connector, reason): # 定义一个方法,当连接失败时调用
32                 print("Connection failed - goodbye!")
33                 reactor.stop()
34 
35             def clientConnectionLost(self, connector, reason):  # 定义一个方法,当连接断开后调用,这个和protocol里的connectionLost()方法类似,只是这是操作对象中定义的,也是当连接关闭后调用,但是它的顺序要在protocol里的connectionLost()方法之后
36                 print("Connection lost - goodbye!")
37                 reactor.stop()
38 
39 
40         # this connects the protocol to a server running on port 8000
41         def main():
42             f = EchoFactory()       # 实例化EchoFactory对象
43             reactor.connectTCP("localhost", 1234, f)  # 监控指定主机\端口 以及 Facotory 实例
44             reactor.run()
45 
46         # this only runs if the module was *not* imported
47         if __name__ == '__main__':
48             main()

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

  1  #!/usr/bin/env python3.5
  2         #_*_coding:utf-8_*_
  3         #__author__:"ted.zhou"
  4         # This is the Twisted Fast Poetry Server, version 1.0
  5 
  6         import optparse, os
  7         # optparse 模块自动的处理程序执行的参数
  8 
  9         from twisted.internet.protocol import ServerFactory, Protocol
 10 
 11 
 12         def parse_args():
 13             # 定一个变量说明文档用于实例化optparse对象时使用,这个信息会在参数输入错误,或者不加参数时输出
 14             usage = """usage: %prog [options] poetry-file
 15          
 16         This is the Fast Poetry Server, Twisted edition.
 17         Run it like this:
 18          
 19           python fastpoetry.py <path-to-poetry-file>
 20          
 21         If you are in the base directory of the twisted-intro package,
 22         you could run it like this:
 23          
 24           python twisted-server-1/fastpoetry.py poetry/ecstasy.txt
 25          
 26         to serve up John Donne's Ecstasy, which I know you want to do.
 27         """
 28 
 29             parser = optparse.OptionParser(usage)   # 实例化optparse.OptionParser()对象,此实例默认有一个-h选项,
 30 
 31             help = "The port to listen on. Default to a random available port."
 32             parser.add_option('--port', type='int', help=help)  # 给parser对象添加一个选项, 参数介绍:'--port'选项为'--port', type='int'选项的参数指定为int类型, help=help 此选项的说明.会在parser对象调用-h选项时打印
 33 
 34             help = "The interface to listen on. Default is localhost."
 35             parser.add_option('--iface', help=help, default='localhost') # 给parser对象添加一个选项, 参数介绍:'--ifce'选项为'--ifce',  help=help 此选项的说明.会在parser对象调用-h选项时打印,default='localhost'如果程序运行时不指定使用此参数时,参数的值为'localhost'
 36 
 37             options, args = parser.parse_args()     # 获取options 和参数的值.
 38             print("--arg:",options,args)
 39 
 40             if len(args) != 1:                      # 如果获得的参数数量为0,则调用parser.error()方法报错
 41                 parser.error('Provide exactly one poetry file.')
 42 
 43             poetry_file = args[0]                   # 如果不为0,那么取参数的第一个
 44 
 45             if not os.path.exists(args[0]):         # 判断这个参数是不是一个文件
 46                 parser.error('No such file: %s' % poetry_file)  # 如果不是一个文件则调用parser.error()方法报错
 47 
 48             return options, poetry_file         # 如果parser最终没有报错,则返回 选项字典 和 文件url
 49 
 50 
 51 
 52         class PoetryProtocol(Protocol): # 自定义一个Protocol,要继承Protocol,
 53 
 54             def connectionMade(self):   # 定义connectionMade 方法 ,当网络连接成功后触发调用此方法,reactor.run()方法管理维护factor,连接事件触发factor
 55                 #reactor.run()方法管理维护factor,我们可以想象,reactor.run方法就是twsited.internet框架中的运行方法,
 56                 # 我们猜想在调用reactor.run()方法后,它内部到底做了什么样的事情呢?既然是猜想,我们就大胆的想,假设reactor.run()方法里有很多像select()中监控的列表实现异步IO.当连接进来了,它就调用你传入的需要维护factor中的protocal的connectionMade()方法进行调用.
 57                 # 这里我们调用transport.write()方法,这时我们可想,根据protocal的方法,客户端如果用的也是twisted.internet框架,此时这里的write()事件,就会触发客户端调用客户端factor.protocal的dateReceived()方法
 58                 self.transport.write(self.factory.poem) # 对连接通道发送数据,是客户端twisted.internet框架触发调用clientfactor.protocal的dataReceived()方法
 59                 self.transport.loseConnection() # 发送完成后这里调用loseConnection关闭这个连接,那么又会触发客户端调用clientfactor.protocal的connectionLost()方法,其实也会调用服务端的,只是服务端没有定义connectionLost()方法,所以服务端不调用
 60 
 61 
 62         class PoetryFactory(ServerFactory): # 定义一个服务端的Factory,要继承ServerFactory基类
 63 
 64             protocol = PoetryProtocol       # 定义服务端Factory的protocol变量为PoetryProtocol,PS:这里要重点说明下
 65                                             # 简简单单的protocol = PoetryProtocol的一句代码,其实实现了很多内容
 66                                             # 1. protocol这个变量 赋予的是 实例化后的PoetryProtocol(),不然后面事件是没有办法触发PoetryProtocol.connectionMade()方法
 67                                             # 2. 建立了Factory和Protocal之间的关联,也就是说Factory可以通过Factory.protocal调用protocal中的方法,而protocal可以通过protocal.factor.xx 来调用factor的方法
 68 
 69             def __init__(self, poem):   # 定义构造方法,只是为了传入值
 70                 self.poem = poem
 71 
 72 
 73         def main():                                 # 定义main()方法
 74             options, poetry_file = parse_args()     # 首先获取运行程序的选项,和文件参数(这时获得的肯定是文件参数,不然parser参数处理在报错时就直接退出了)
 75 
 76             poem = open(poetry_file).read()         # 把文件读出来
 77 
 78             factory = PoetryFactory(poem)           # 实例化服务器段的Factory,这里是PoetryFactory(),把读到的字符串作为参数传入
 79 
 80             from twisted.internet import reactor    # 导入reactor,我觉得reactor就是twisted.internet框架的主监控模块,把factor传给reactor进行实例化后,在调用reactor.run()方法,监控事件循环了.
 81 
 82             port = reactor.listenTCP(options.port or 9000, factory,interface=options.iface) # 实例化reactor,实例化的时候要输入端口,和IP,因为这是twsited.internet框架
 83 
 84             print('Serving %s on %s.' % (poetry_file, port.getHost())) # 打印启动的提示信息
 85 
 86             reactor.run()       # 程序进入阻塞状态,具体阻塞在哪里,可能是阻塞在reactor模块类似select()的地方.这样好理解
 87 
 88 
 89         if __name__ == '__main__':
 90             main()
 91 
 92         # 总结:理解twisted.internet框架,要记住下面几个知识点
 93         # 1.这是一个事件驱动的异步IO框架
 94         # 2.事件驱动框架就有一系列的事件循环和操作对象和操作内容,那循环监控的事件是哪些呢?就是连接建立事件,连接关闭事件,数据接收事件,数据发送事件,这几个事件都是在twisted.internet框架里实现的.代码是通过实例化reactor对象,并调用run()方法实现的
 95         # 这些监控的事件理清了,就会想到这些事件一旦发生了,对什么做哪些操作的.这就是操作的对象和内容.操作的对象我们理解成ServerFactory和ClientFactory对象,所以你想自己定义,就需要继承上面的两个类
 96         # 操作对象有了,就差操作内容了. 操作内容就是protocal.Protocal类,所以你要定义自己的也需要继承这个类.
 97         # 3.循环内容\操作对象\操作内容都有了,下面要知道的就是什么事件调用什么操作内容了? 那就是上面的知识点
 98         # Protocols
 99         # Protocols描述了如何以异步的方式处理网络中的事件。HTTP、DNS以及IMAP是应用层协议中的例子。Protocols实现了IProtocol接口，它包含如下的方法：
100         # makeConnection               在transport对象和服务器之间建立一条连接
101         # connectionMade               连接建立起来后调用
102         # dataReceived                 接收数据时调用
103         # connectionLost               关闭连接时调用
104         # 4.所以你想利用事件驱动触发动作,就需要在自己的protocal中定义上面的3中方法,其他自定义的貌似不会触发,除非内部调用

    client_side端

  1         #!/usr/bin/evn python3.5
  2         #__author__:"ted.zhou"
  3         # This is the Twisted Get Poetry Now! client, version 3.0.
  4 
  5         # NOTE: This should not be used as the basis for production code.
  6 
  7         import optparse
  8 
  9         from twisted.internet.protocol import Protocol, ClientFactory
 10 
 11 
 12         # 定义一个参数类
 13         def parse_args():
 14             usage = """usage: %prog [options] [hostname]:port ...
 15          
 16         This is the Get Poetry Now! client, Twisted version 3.0
 17         Run it like this:
 18          
 19           python get-poetry-1.py port1 port2 port3 ...
 20         """
 21 
 22             parser = optparse.OptionParser(usage)   # 实例化参数,usage默认的说明文档
 23 
 24             _, addresses = parser.parse_args()      # 获得执行程序本身,和参数
 25 
 26             if not addresses:                       # 如果没有参数,则打印帮助文档并退出程序
 27                 print(parser.format_help())
 28                 parser.exit()
 29 
 30             def parse_address(addr):                # 定义地址的处理参数
 31                 if ':' not in addr:                 # 如果参数只是一个端口整数
 32                     host = '127.0.0.1'              # 设置默认主机地址为127.0.0.1
 33                     port = addr                     # 端口为参数传入的值
 34                 else:
 35                     host, port = addr.split(':', 1) # 否则用:隔开前面的为地址,后面的是端口
 36 
 37                 if not port.isdigit():              # 判断获得的端口是不是数字
 38                     parser.error('Ports must be integers.')
 39 
 40                 return host, int(port)              # 返回地址和端口
 41 
 42             return map(parse_address, addresses)    # 使用map关键字,获得地址端口的组合[('192.168.1.1',9000),('192.168.2.1',9001)]
 43 
 44 
 45         class PoetryProtocol(Protocol):     # 定义一个事件触发后操作内容类
 46 
 47             poem = ''                       #
 48 
 49             def dataReceived(self, data):  # 定义dataReceived方法
 50                 self.poem += data
 51 
 52             def connectionLost(self, reason):   # 定义connectionLost方法,当连接关闭时触发此方法
 53                 self.poemReceived(self.poem)    # 调用poemReceived方法
 54 
 55             def poemReceived(self, poem):       # 定义poemReceived方法,
 56                 self.factory.poem_finished(poem)    # 调用factory.poem_finished方法
 57 
 58 
 59         class PoetryClientFactory(ClientFactory): # 定义客户端Factory方法
 60 
 61             protocol = PoetryProtocol   # 绑定PoetryClientFactory的Protocol  和 PoetryProtocol 的factory
 62 
 63             def __init__(self, callback):   # 定义构造方法,传入callback方法
 64                 self.callback = callback
 65 
 66             def poem_finished(self, poem):  # 定义一个poem_finished()方法
 67                 self.callback(poem)         # 调用self.callback()方法
 68 
 69 
 70         def get_poetry(host, port, callback):
 71             """
 72             Download a poem from the given host and port and invoke
 73          
 74               callback(poem)
 75          
 76             when the poem is complete.
 77             """
 78             from twisted.internet import reactor    # 导入reactor
 79             factory = PoetryClientFactory(callback) # 实例化被监控的对象 PoetryClientFactory
 80             reactor.connectTCP(host, port, factory) # 监控主机\端口和被监控对象
 81 
 82 
 83         def poetry_main():
 84             addresses = parse_args()                # 获得客户端监控的对象
 85 
 86             from twisted.internet import reactor    # 导入reactor
 87 
 88             poems = []                              # 初始化一个列表,用于存储接收的诗集
 89 
 90             def got_poem(poem):                     # 定义接收服务器传过来的诗集的函数
 91                 poems.append(poem)                  # 把接收到的诗集加入列表中
 92                 if len(poems) == len(addresses):    # 如果诗集元素的个数等于地址的个数,说明接收完成,否则接收继续
 93                     reactor.stop()
 94 
 95             for address in addresses:               # 循环地址元组列表
 96                 host, port = address                # 获得地址和端口
 97                 get_poetry(host, port, got_poem)    # 启动监控,有几个元素启几个
 98 
 99             reactor.run()                           # 开启事件监控
100 
101             for poem in poems:                      #
102                 print(poem)
103 
104         if __name__ == '__main__':
105             poetry_main()

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