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基类,是事件驱动框架中的操作实例,里面可以有connectionMadedataReceivedconnectionLost方法,这些方法在调用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 # 创建一个事件驱动中事件触发后,要执行的操作步骤类,此类有connectionMadedataReceivedconnectionLost方法
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()
# 上面的代码能看懂,但是这个绕啊,只能模仿了,让我写我是暂时写不出来