twisted 示例文件传输

python
服务端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#!/usr/bin/env python
# -*- coding:utf-8 -*-

# This is the Twisted Fast Poetry Server, version 1.0

import optparse, os

from twisted.internet.protocol import ServerFactory, Protocol


"""
这个函数定义了服务端执行的参数有2个port和iface【端口和网络接口】以及返回获取参数和值以及文件名路径
"""
def parse_args():
    usage = """usage: %prog [options] poetry-file

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

  python twisted_sendfile.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-1/fastpoetry.py poetry/ecstasy.txt

to serve up John Donne's Ecstasy, which I know you want to do.
"""
    # 实例化OptionParser
    parser = optparse.OptionParser(usage)
    
    # 关于port参数的相关定义，帮助是的说明，传值的类型，
    help = "The port to listen on. Default to a random available port."
    parser.add_option('--port', type='int', help=help)

    # 关于iface参数的相关定义，帮助是的说明，传值的类型，
    help = "The interface to listen on. Default is localhost."
    parser.add_option('--iface', help=help, default='localhost')
     
    # 通过parse_args()方法获取到option，args 分别赋给这2个变量
    options, args = parser.parse_args()
    #print("--arg:",options,args)
    #print("-->",options.port)

    # 如果指定了多个文件，会出现错误，这里定义了一次传一个文件
    if len(args) != 1:
        parser.error('Provide exactly one poetry file.')
    poetry_file = args[0]

    # 如果文件不存在，的错误异常
    if not os.path.exists(args[0]):
        parser.error('No such file: %s' % poetry_file)
    # 返回脚本选项和要传输的文件路径
    return options, poetry_file


# 定义Protocol （用于连接建立以后，如果对数据进行交互，以及连接的关闭）
class PoetryProtocol(Protocol): #handle
    def connectionMade(self):
        """
        当连接建立以后，直接发送文件，然后关闭连接
        """
        self.transport.write(self.factory.poem)
        self.transport.loseConnection()

# 集成了ServerFactory的factory 定义了协议对象的生成，另外为了让构造时能够获取到文件的句柄，重写了构造函数， 
class PoetryFactory(ServerFactory): #基础类
    protocol = PoetryProtocol
    def __init__(self, poem):
        self.poem = poem

# 主要运行程序，就相当于上面几个部分的组合
def main():
    # 获取参数和文件路径
    options, poetry_file = parse_args() 
    # 得到要传输的文件句柄
    poem = open(poetry_file).read()
    # 实例化factory类，由于重写了构造函数，把文件的句柄作为参数传入进去
    factory = PoetryFactory(poem)
    from twisted.internet import reactor
    # 实例化监听对象，默认使用9000端口
    port = reactor.listenTCP(options.port or 9000, factory,
                             interface=options.iface)
    print 'Serving %s on %s.' % (poetry_file, port.getHost())
    # 调用run方法
    reactor.run()


if __name__ == '__main__':
    main()
客户端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 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-1.py port1 port2 port3 ...
"""
    # 获取到用户输入，
    parser = optparse.OptionParser(usage)
    # parse_args()方法返回一个元组，第一个值是配置本身，第二值是用户输入的全部value，这边只是获取用户输入的地址
    _, addresses = parser.parse_args()
    print('==addr:',_,addresses)
    if not addresses: # 如果用户没有输入地址输出帮助信息，退出
        print parser.format_help()
        parser.exit()

    # 对于用户传入进来的addresses进行匹配判断正确的输入方法是Host:port，当然如果host不指定就是相当于127.0.0.1
    def parse_address(addr):
        if ':' not in addr: #如果输入格式不符合host:port，就定义host=127.0.0.1
            host = '127.0.0.1'
            port = addr
        else: #用户输入符合规范
            host, port = addr.split(':', 1)
        if not port.isdigit(): # 对port进行类型判断，必须为整形数字，否则就抛错
            parser.error('Ports must be integers.')
        return host, int(port)
    #return  parse_address(addresses)
    return map(parse_address, addresses) # 对于addresses数据进行格式化，为了接下来程序调用使用


# 同样需要定义协议Protocol的类，用于当连接简历成功以后的handl处理
class PoetryProtocol(Protocol):

    poem = ''
    def dataReceived(self, data): #定义了数据接收方法，如何处理数据
        self.poem += data
        #self.factory = PoetryClientFactory #
        print('[%s] recv:[%s]' %(self.transport.getPeer(),len(self.poem))) #打印当前收到的数据大小和服务端连接信息
    def connectionLost(self, reason): #定义连接端开的时候调用poemReceived()，把收到的数据作为参数传入
        self.poemReceived(self.poem)  #相当于子类调用父类，twisted写死了如果想调用，必须通过factory关键字调用

    def poemReceived(self, poem):     # poemReceived() 调用了factory中poem_finished()，参数传入接收到的数据，
    	self.factory.poem_finished(poem)

# 继承ClinetFactory定义factory的基类，用于指定Protocol以及建立连接的动作
class PoetryClientFactory(ClientFactory):
	#标准格式，绑定PoetryProtocol类，绑定必须通过protocol关键字
    protocol = PoetryProtocol #handle method 指定protocol是上面定义过的PoetryProtocol
    def __init__(self, callback): #构造函数需要回调函数callback作为参数传入
        self.callback = callback
    def poem_finished(self, poem):# 自定义方法在PoetryProtocol中会被调用到
        self.callback(poem)       # 实例化的时候callback方法对象本身有传入，进来现在是执行这个callback方法，把数据作为参数传入
        #self.get_poem(poem)

# 由于客户端是可以从多个服务器上接收数据，其实这个方法是用于定义一个”从服务端接收数据“ 这个动作如何执行，然后多个连接只要并发执行即可
def get_poetry(host, port, callback):
    """
    Download a poem from the given host and port and invoke
      callback(poem)
    when the poem is complete.
    """
    # twisted 三个元素，factory 实例化，在factory中指定Protocol，这里使用reactor 进行监听处理
    from twisted.internet import reactor
    factory = PoetryClientFactory(callback)
    reactor.connectTCP(host, port, factory)

# 前面的都是做零件，这里是组装执行
def poetry_main():
	# 获取那些接收那些服务器端数据
    addresses = parse_args() #((172.0.0.1,9000),(...))
    from twisted.internet import reactor
    # 定义文件数组
    poems = [] 
     
    # 定义什么时候reactor可以停止了，也就说文件传输完毕了，文件的数量和服务器连接信息相等就是传送完毕
    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) #这里的got_poem就是callback，也就说

    # reactor运行
    reactor.run()

    print("main loop done...")
    #for poem in poems:
    #    Eprint poem

if __name__ == '__main__':
    poetry_main()
文章目录
  1. 1. 服务端
  2. 2. 客户端