day36---并发编程之I/O模型

1. I/O模型

种类：
- blocking IO(阻塞IO)
- non-blocking IO(非阻塞IO)
- multiplexing IO(多路复用IO)
- signal-driven IO(信号驱动IO，实例中不常用)
- asynchronous IO(异步IO)
说明：
- 同步：就是在发出一个功能调用时，在没有得到结果之前，该调用就不会返回。按照这个定义，其实绝大多数函数都是同步调用
- 异步：当一个异步功能调用发出后，调用者不能立刻得到结果。当该异步功能完成后，通过状态、通知或回调来通知调用者。如果异步功能用状态来通知，那么调用者就需要每隔一定时间检查一次，效率就很低（有些初学多线程编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一种很严重的错误）。如果是使用通知的方式，效率则很高，因为异步功能几乎不需要做额外的操作
- 阻塞：是指调用结果返回之前，当前线程会被挂起（如遇到io操作）。函数只有在得到结果之后才会将阻塞的线程激活
- 非阻塞：在不能立刻得到结果之前也会立刻返回，同时该函数不会阻塞当前线程
描述：
- 同步与异步针对的是函数/任务的调用方式：同步就是当一个进程发起一个函数（任务）调用的时候，一直等到函数（任务）完成，而进程继续处于激活状态。而异步情况下是当一个进程发起一个函数（任务）调用的时候，不会等函数返回，而是继续往下执行当，函数返回的时候通过状态、通知、事件等方式通知进程任务完成
- 阻塞与非阻塞针对的是进程或线程，阻塞是当请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程
IO发生时涉及的对象和步骤：对于一个network IO)，它会涉及到两个系统对象，一个是调用这个IO的process (or thread)，另一个就是系统内核(kernel)。当一个read操作发生时，该操作会经历两个阶段：
- 等待数据准备 (Waiting for the data to be ready)
- 将数据从内核拷贝到进程中(Copying the data from the kernel to the process)

2. 阻塞I/O

在linux中，默认情况下所有的socket都是blocking
阻塞型接口是指系统调用（一般是IO接口）不返回调用结果并让当前线程一直阻塞，只有当该系统调用获得结果或者超时出错时才返回
阻塞I/O的特点：在IO执行的两个阶段(等待数据和拷贝数据)都被block了
同时出现的上千甚至上万次的客户端请求，'线程池'或'进程池'或许可以缓解部分压力，但是不能解决所有问题。总之，多线程模型可以方便高效的解决小规模的服务请求，但面对大规模的服务请求，多线程模型也会遇到瓶颈

3. 非阻塞I/O

特点：用户进程需要不断的主动询问kernel中是否有所需数据存在
优点：能够在等待任务的时间运行其他任务(可以有多个任务同时运行)
缺点：
- 循环调用将大幅度提高CPU占用率
- 任务完成的响应延迟增大了，因为每过一段时间才去轮询一次read操作，而任务可能在两次轮询之间的任意时间完成。这会导致整体数据吞吐量的降低

4. 异步I/O

说明：用户进程发起read操作之后，立刻就可以开始去做其它的事。而另一方面，从kernel的角度，当它受到一个asynchronous read之后，首先它会立刻返回，所以不会对用户进程产生任何block。然后，kernel会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，kernel会给用户进程发送一个signal，告诉它read操作完成了

5. I/O多路复用

说明：如果处理的连接数不是很高的话，使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。在多路复用模型中，对于每一个socket，一般都设置成为non-blocking，但是，如上图所示，整个用户的process其实是一直被block的。只不过process是被select这个函数block，而不是被socket IO给block。select的优势在于可以处理多个连接，不适用于单个连接
select监听fd变化的过程分析：用户进程创建socket对象，拷贝监听的fd到内核空间，每一个fd会对应一张系统文件表，内核空间的fd响应到数据后，就会发送信号给用户进程数据已到；用户进程再发送系统调用，比如（accept）将内核空间的数据copy到用户空间，同时作为接受数据端内核空间的数据清除，这样重新监听时fd再有新的数据又可以响应到了(发送端因为基于TCP协议所以需要收到应答后才会清除)
优点：相比其他模型，使用select() 的事件驱动模型只用单线程（进程）执行，占用资源少，不消耗太多 CPU，同时能够为多客户端提供服务。如果试图建立一个简单的事件驱动的服务器程序，这个模型有一定的参考价值
缺点：首先select()接口并不是实现“事件驱动”的最好选择。因为当需要探测的句柄值较大时，select()接口本身需要消耗大量时间去轮询各个句柄。很多操作系统提供了更为高效的接口，如linux提供了epoll，BSD提供了kqueue，Solaris提供了/dev/poll，…。如果需要实现更高效的服务器程序，类似epoll这样的接口更被推荐。遗憾的是不同的操作系统特供的epoll接口有很大差异，所以使用类似于epoll的接口实现具有较好跨平台能力的服务器会比较困难；其次，该模型将事件探测和事件响应夹杂在一起，一旦事件响应的执行体庞大，则对整个模型是灾难性的
使用IO模型实现TCP的socket套接字并发

# 服务端
import select
import subprocess
import json
import struct
from socket import *
def shell_result(ip, port):
        server = socket(AF_INET, SOCK_STREAM)
        server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
        server.bind((ip, port))
        server.listen(5)
        server.setblocking(False)
        read_list = [server]
        while True:
            rl, wl, xl = select.select(read_list, [], [])
            for i in rl:
                if i is server:
                    conn, add = i.accept()
                    print('客户端[%s]成功连接，端口是[%s]' % (add[0], add[1]))
                    read_list.append(conn)
                else:
                    try:
                        shell = i.recv(1024)
                        if not shell:
                            i.close()
                            read_list.remove(i)
                            continue
                        obj = subprocess.Popen(shell.decode('utf-8'), shell=True, stdout=subprocess.PIPE,stderr=subprocess.PIPE)
                        stdout = obj.stdout.read()
                        stderr = obj.stderr.read()
                        header_dict = {'total_size': len(stdout) + len(stderr)}
                        header_json = json.dumps(header_dict)
                        header_bytes = header_json.encode('utf-8')
                        header_size = struct.pack('i', len(header_bytes))
                        i.send(header_size)
                        i.send(header_bytes)
                        i.send(stdout)
                        i.send(stderr)
                    except ConnectionResetError:
                        i.close()
                        read_list.remove(i)
        server.close()
if __name__ == '__main__':
        ip = '127.0.0.1'
        port = 8080
        shell_result(ip, port)

# 客户端1
import json
import struct
from socket import *
ip = '127.0.0.1'
port = 8080
client = socket(AF_INET, SOCK_STREAM)
client.connect((ip, port))
def shell_run(shell):
        client.send(shell.encode('utf-8'))
        header_len = client.recv(4)
        header_size = struct.unpack('i', header_len)[0]
        header_bytes = client.recv(header_size)
        header_json = header_bytes.decode('utf-8')
        header_dict = json.loads(header_json)
        total_size = header_dict['total_size']
        recv_size = 0
        data = b''
        while recv_size < total_size:
            recv_data = client.recv(1024)
            data += recv_data
            recv_size += len(recv_data)
        print(data.decode('gbk'))
if __name__ == '__main__':
        while True:
            shell = input('请输入需要执行的系统命令：').strip()
            if not shell:
                continue
            shell_run(shell)
        client.close()

# 客户端2
import json
import struct
from socket import *
ip = '127.0.0.1'
port = 8080
client = socket(AF_INET, SOCK_STREAM)
client.connect((ip, port))
def shell_run(shell):
        client.send(shell.encode('utf-8'))
        header_len = client.recv(4)
        header_size = struct.unpack('i', header_len)[0]
        header_bytes = client.recv(header_size)
        header_json = header_bytes.decode('utf-8')
        header_dict = json.loads(header_json)
        total_size = header_dict['total_size']
        recv_size = 0
        data = b''
        while recv_size < total_size:
            recv_data = client.recv(1024)
            data += recv_data
            recv_size += len(recv_data)
        print(data.decode('gbk'))
if __name__ == '__main__':
        while True:
            shell = input('请输入需要执行的系统命令：').strip()
            if not shell:
                continue
            shell_run(shell)
        client.close()

6. selectors模块

IO复用：为了解释这个名词，首先来理解下复用这个概念，复用也就是共用的意思，这样理解还是有些抽象，为此，咱们来理解下复用在通信领域的使用，在通信领域中为了充分利用网络连接的物理介质，往往在同一条网络链路上采用时分复用或频分复用的技术使其在同一链路上传输多路信号，到这里我们就基本上理解了复用的含义，即公用某个“介质”来尽可能多的做同一类(性质)的事，那IO复用的“介质”是什么呢？为此我们首先来看看服务器编程的模型，客户端发来的请求服务端会产生一个进程来对其进行服务，每当来一个客户请求就产生一个进程来服务，然而进程不可能无限制的产生，因此为了解决大量客户端访问的问题，引入了IO复用技术，即：一个进程可以同时对多个客户请求进行服务。也就是说IO复用的“介质”是进程(准确的说复用的是select和poll，因为进程也是靠调用select和poll来实现的)，复用一个进程(select和poll)来对多个IO进行服务，虽然客户端发来的IO是并发的但是IO所需的读写数据多数情况下是没有准备好的，因此就可以利用一个函数(select和poll)来监听IO所需的这些数据的状态，一旦IO有数据可以进行读写了，进程就来对这样的IO进行服务
实现IO复用中的三个API(select、poll和epoll)的区别和联系：select，poll，epoll都是IO多路复用的机制，I/O多路复用就是通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知应用程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间
select的第一个参数nfds为fdset集合中最大描述符值加1，fdset是一个位数组，其大小限制为__FD_SETSIZE（1024），位数组的每一位代表其对应的描述符是否需要被检查。第二三四参数表示需要关注读、写、错误事件的文件描述符位数组，这些参数既是输入参数也是输出参数，可能会被内核修改用于标示哪些描述符上发生了关注的事件，所以每次调用select前都需要重新初始化fdset。timeout参数为超时时间，该结构会被内核修改，其值为超时剩余的时间
select的调用步骤如下：
- 使用copy_from_user从用户空间拷贝fdset到内核空间
- 注册回调函数__pollwait
- 遍历所有fd，调用其对应的poll方法（对于socket，这个poll方法是sock_poll，sock_poll根据情况会调用到tcp_poll,udp_poll或者datagram_poll）
- 以tcp_poll为例，其核心实现就是__pollwait，也就是上面注册的回调函数
- __pollwait的主要工作就是把current（当前进程）挂到设备的等待队列中，不同的设备有不同的等待队列，对于tcp_poll 来说，其等待队列是sk->sk_sleep（注意把进程挂到等待队列中并不代表进程已经睡眠了）。在设备收到一条消息（网络设备）或填写完文件数据（磁盘设备）后，会唤醒设备等待队列上睡眠的进程，这时current便被唤醒了
- poll方法返回时会返回一个描述读写操作是否就绪的mask掩码，根据这个mask掩码给fd_set赋值
- 如果遍历完所有的fd，还没有返回一个可读写的mask掩码，则会调用schedule_timeout是调用select的进程（也就是 current）进入睡眠。当设备驱动发生自身资源可读写后，会唤醒其等待队列上睡眠的进程。如果超过一定的超时时间（schedule_timeout 指定），还是没人唤醒，则调用select的进程会重新被唤醒获得CPU，进而重新遍历fd，判断有没有就绪的fd
- 把fd_set从内核空间拷贝到用户空间
select的缺点：
- 每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大
- 同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大
- select支持的文件描述符数量太小了，默认是1024
poll与select不同，通过一个pollfd数组向内核传递需要关注的事件，故没有描述符个数的限制，pollfd中的events字段和revents分别用于标示关注的事件和发生的事件，故pollfd数组只需要被初始化一次。poll的实现机制与select类似，其对应内核中的sys_poll，只不过poll向内核传递pollfd数组，然后对pollfd中的每个描述符进行poll，相比处理fdset来说，poll效率更高。poll返回后，需要对pollfd中的每个元素检查其revents值，来得指事件是否发生
直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。epoll既然是对select和poll的改进，就应该能避免上述的三个缺点。那epoll都是怎么解决的呢？在此之前，我们先看一下epoll 和select和poll的调用接口上的不同，select和poll都只提供了一个函数——select或者poll函数。而epoll提供了三个函数，epoll_create,epoll_ctl和epoll_wait，epoll_create是创建一个epoll句柄；epoll_ctl是注册要监听的事件类型；epoll_wait则是等待事件的产生。对于第一个缺点，epoll的解决方案在epoll_ctl函数中。每次注册新的事件到epoll句柄中时（在epoll_ctl中指定 EPOLL_CTL_ADD），会把所有的fd拷贝进内核，而不是在epoll_wait的时候重复拷贝。epoll保证了每个fd在整个过程中只会拷贝一次；对于第二个缺点，epoll的解决方案不像select或poll一样每次都把current轮流加入fd对应的设备等待队列中，而只在 epoll_ctl时把current挂一遍（这一遍必不可少）并为每个fd指定一个回调函数，当设备就绪，唤醒等待队列上的等待者时，就会调用这个回调函数，而这个回调函数会把就绪的fd加入一个就绪链表）。epoll_wait的工作实际上就是在这个就绪链表中查看有没有就绪的fd（利用 schedule_timeout()实现睡一会，判断一会的效果，和select实现中的第7步是类似的）；对于第三个缺点，epoll没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子, 在1GB内存的机器上大约是10万左右，具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大
select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。而epoll其实也需要调用 epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在 epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在“醒着”的时候要遍历整个fd集合，而epoll在“醒着”的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间，这就是回调机制带来的性能提升
select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，并且要把current往设备等待队列中挂一次，而epoll只要一次拷贝，而且把current往等待队列上挂也只挂一次（在epoll_wait的开始，注意这里的等待队列并不是设备等待队列，只是一个epoll内部定义的等待队列），这也能节省不少的开销
三种IO多路复用模型在不同的平台有着不同的支持，而epoll在windows下就不支持，selectors模块会帮我们默认选择当前平台下最合适的

7. socketserver模块

说明：socketserver模块中分两大类：server类（解决链接问题）和request类（解决通信问题）
基于tcp的socketserver我们自己定义的类中：
- self.server：套接字对象
- self.request：一个链接
- self.client_address：客户端地址
基于udp的socketserver我们自己定义的类中：
- self.request是一个元组（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象）
- self.client_address：客户端地址
使用socketserver实现TCP的套接字并发

# 服务端
import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler):
        def handle(self):
            while True:
                print(self.client_address)
                try:
                    data = self.request.recv(1024)
                    self.request.send(data.upper())
                except ConnectionResetError:
                    break
if __name__ == '__main__':
        server = socketserver.ThreadingTCPServer(('127.0.0.1', 8080), MyTCPHandler)
        server.serve_forever()

# 客户端1
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8080))
while True:
        msg = input('>>>：').strip()
        if not msg:
            continue
        client.send(msg.encode('utf-8'))
        data = client.recv(1024)
        print(data.decode('utf-8'))

# 客户端2
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8080))
while True:
        msg = input('>>>：').strip()
        if not msg:
            continue
        client.send(msg.encode('utf-8'))
        data = client.recv(1024)
        print(data.decode('utf-8'))

使用socketserver实现UDP的套接字并发

# 服务端
import socketserver
class MyUDPHandler(socketserver.BaseRequestHandler):
        def handle(self):
            data = self.request[0]
            print(data.decode('utf-8'))
            self.request[1].sendto(data.upper(), self.client_address)
if __name__ == '__main__':
        server = socketserver.ThreadingUDPServer(('127.0.0.1', 8080), MyUDPHandler)
        server.serve_forever()

# 客户端1
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
        msg = input('>>>：').strip()
        if not msg:
            continue
        client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
        data, server_address = client.recvfrom(1024)
        print(data.decode('utf-8'))

# 客户端2
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
        msg = input('>>>：').strip()
        if not msg:
            continue
        client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
        data, server_address = client.recvfrom(1024)
        print(data.decode('utf-8'))

9. paramiko模块

说明：远程控制模块，可以对远程的服务器进程命令和文件等操作
应用：ansible、fabric等开源软件内部的远程管理机制
安装：pip install paramiko
SSHClient：连接远程服务器并执行基本命令
SFTPClient：用于连接远程服务器并执行上传下载
SSHClient基于用户名密码连接：

import paramiko
hostname = '192.168.21.130'
port = 22
username = 'root'
password = '123456'
# 创建SSH对象
ssh = paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 连接服务器
# ssh.connect(hostname=hostname, port=port, username=username, password=password)
ssh.connect(hostname, port, username, password)
# 执行命令
stdin, stdout, stderr = ssh.exec_command('hostname')
# 获取命令结果
result = stdout.read()
print(result.decode('utf-8'))
# 关闭连接
ssh.close()
>>>
localhost.localdomain

SSHClient基于公钥密钥连接：

import paramiko
ip = '192.168.21.130'
port = 22
username = 'root'
private_key = paramiko.RSAKey.from_private_key_file(r'd:\\id_rsa')
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(hostname=ip, port=port, username=username, pkey=private_key)
stdin, stdout, stderr = ssh.exec_command('whoami')
result = stdout.read()
print(result.decode('utf-8'))
ssh.close()
>>>
root

SSHClient封装Transport

# 密码认证
import paramiko
ip = '192.168.21.130'
port = 22
username = 'root'
password = '123456'
t = paramiko.Transport((ip, port))
t.connect(username=username, password=password)
ssh = paramiko.SSHClient()
ssh._transport = t
stdin, stdout, stderr = ssh.exec_command('uname -r')
result = stdout.read()
print(result.decode('utf-8'))
t.close()
>>>
3.10.0-693.5.2.el7.x86_64

# 密钥认证
import paramiko
ip = '192.168.21.130'
port = 22
username = 'root'
private_key = paramiko.RSAKey.from_private_key_file(r'd:\\id_rsa')
transport = paramiko.Transport((ip, port))
transport.connect(username=username, pkey=private_key)
ssh = paramiko.SSHClient()
ssh._transport = transport
stdin, stdout, stderr = ssh.exec_command('who am i')
res = stdout.read()
print(res.decode('utf-8'))
transport.close()
>>>
root     pts/1        2017-12-06 19:16 (192.168.21.27)

# 密钥字符串认证
import paramiko
from io import StringIO
ip = '192.168.21.130'
port = 22
username = 'root'
key_str = """-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEAuQH+Vlk/93IoFJFajI6FDObab7+90Ujvyd3KTtYR4g6XQiAS
psDpAHUsd9Umjww1W8YNjN1kuSrkUfgcRq5hy3+pvNqtAfkXcKnVv2Ja8WisCmy+
15piXncKAsF58yTYOlnaN1L6HNu09da5+R8fBJr4sZuMSsJaREn+7ulk6PDGtZW6
zxowYYcbIbUAMMj27TTuh/binbil+gWgb36fdfHhpD0vgCNgQCNf5rM5CqwLdsx6
qzH6Xctrsyvi52VStpAPwxjHK7qAL4bjNEjDoJwacm0xYpOG93PRDef4ek7ZP8j3
oclCH3t+735bNLrASc75CZP1Dj5ozhp39fGA2QIDAQABAoIBAQCenmvuopSqVdCx
WbIVwnemiSMNHorjLbKRE7xJfVZVx4a95fu3xru+bbfTggeOK7xv0814UbTy4Shi
cuPjYc1tCSaBScd9YpBLQwGFFhG82q5uPbAd8DqYnV0S4cjpw1Q0KydhuZ3BMknj
YNeQFLOmYiwJMsDEs/9qfzq4oZin8Zh8QZmmUKluvKz5Qg4Tgu/IN5XwIpTWfOth
9HcW86HoQE47XoOabXbCJDDMFnuu0hKIVd7wwnoUb6xHmTEOwCeBrCVVPSJlNEec
mZKp41wPHwY5xtr7JyaiO3fguAFFMF3egU4svtV3eR0N0N10VGvztGUPNNWXW0cf
OzxQNTBVAoGBAPEIxGy8zWY9+E/OsqXyiHyD4iytfv1tKIbUctCQz4DtivceWki1
+w3QnwSKMZx/qkpI3rBsqo0GrSPtrov7t6L0JdtfCPCuebW0slOjKwXW+XeBKJ3h
IWChIv9OrOCvUPvon73p7m0U2DkSF4iu7SnsIaH3kSytGHdGwYpOTa5DAoGBAMR+
r+ssdHABNGT1jP8HR0rtc5+3VryH+yYCPfNlY7nzC2fViVDlVYRnVHyZ3a06/XKR
QzujD5qKkiaypMTolXz6fN7q5pD1M6XG3GHhmBuoiQL9TySNVQBIhP6mjR2XhzTf
NotUnDxSQHDNKOGwWkSSD56qfR5CnA6TZYFPVjizAoGAUqQU5MtfCT0aFBLkga1E
SpzVQUhDEBULHh9dNlFQM/499Th88A0lBLmQq/fNxsCm3E1bvNWlLDErz/PAMtKd
Rcu75xkQcaUAqeJIehCpwZjRc73e9TKpRP46h5qr/2VcuOIrUuwQCWpqMDcZxo1j
V0pUxbmiFtVKXCrwVMFANQ0CgYEAo35N3b31fCRkdgSiNqjVtxBv/lrMPr5eSDfh
WB3qppQFz3WrdbX8O9jGQY69FiBZNfSMHpkEqK/X/37w/i4QBBdfwxNsmPyM5sja
Ik9VAt5uciBWs7EtIrk0f7YRAKhOBb4cYj4aaU5+89ygwXi9AwUNHhX5WS5PLwmR
kdBzi2UCgYBfs4FoaREA/tOC3+0qCnKTFj74k+j8BPR7rpPGlSpIIVnIQZlCA65Z
QBVrZ6rWSTjNQK6z9Ez1DFNFCSxArrqjMcqwXUpdN8Uwt+6IndL89dEHpx7H4zsB
VcbNxXH6phxLe/oslegBT6L5qkZmnKIZwdrKnmUXMZTDF71MSJOLqA==
-----END RSA PRIVATE KEY-----"""
private_key = paramiko.RSAKey(file_obj=StringIO(key_str))
transport = paramiko.Transport((ip, port))
transport.connect(username=username, pkey=private_key)
ssh = paramiko.SSHClient()
ssh._transport = transport
stdin, stdout, stderr = ssh.exec_command('who')
result = stdout.read()
print(result.decode('utf-8'))
transport.close()
print(result)
>>>
root     tty1         2017-12-06 19:00
root     pts/0        2017-12-06 19:01 (192.168.21.27)
root     pts/1        2017-12-06 19:16 (192.168.21.27)

SFTPClient基于用户名密码上传下载：

import paramiko
ip = '192.168.21.130'
port = 22
username = 'root'
password = '123456'
t = paramiko.Transport((ip, port))
t.connect(username=username, password=password)
sftp = paramiko.SFTPClient.from_transport(t)
sftp.put(r'd:\\aaa.txt', r'/tmp/123.txt')
sftp.get(r'/etc/passwd', r'd:\\passwd.txt')
t.close()

SFTPClient基于公钥密钥上传下载：

import paramiko
ip = '192.168.21.130'
port = 22
username = 'root'
private_key = paramiko.RSAKey.from_private_key_file(r'd:\\id_rsa')
t = paramiko.Transport((ip, port))
t.connect(username=username, pkey=private_key)
sftp = paramiko.SFTPClient.from_transport(t)
sftp.put(r'd:\\aaa.txt', r'/tmp/123.txt')
sftp.get(r'/etc/passwd', r'd:\\passwd.txt')
t.close()

posted @ 2017-12-06 14:46 _岩哥阅读(232) 评论(0) 收藏举报

刷新页面返回顶部

世上无难事，只怕有心人

不积跬步，无以至千里；不积小流，无以成江海

day36---并发编程之I/O模型

1. I/O模型

种类：

blocking IO(阻塞IO)

non-blocking IO(非阻塞IO)

multiplexing IO(多路复用IO)

signal-driven IO(信号驱动IO，实例中不常用)

asynchronous IO(异步IO)

说明：

同步：就是在发出一个功能调用时，在没有得到结果之前，该调用就不会返回。按照这个定义，其实绝大多数函数都是同步调用

阻塞：是指调用结果返回之前，当前线程会被挂起（如遇到io操作）。函数只有在得到结果之后才会将阻塞的线程激活

非阻塞：在不能立刻得到结果之前也会立刻返回，同时该函数不会阻塞当前线程

描述：

阻塞与非阻塞针对的是进程或线程，阻塞是当请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程

IO发生时涉及的对象和步骤：对于一个network IO)，它会涉及到两个系统对象，一个是调用这个IO的process (or thread)，另一个就是系统内核(kernel)。当一个read操作发生时，该操作会经历两个阶段：

等待数据准备 (Waiting for the data to be ready)

将数据从内核拷贝到进程中(Copying the data from the kernel to the process)

2. 阻塞I/O

在linux中，默认情况下所有的socket都是blocking

阻塞型接口是指系统调用（一般是IO接口）不返回调用结果并让当前线程一直阻塞，只有当该系统调用获得结果或者超时出错时才返回

阻塞I/O的特点：在IO执行的两个阶段(等待数据和拷贝数据)都被block了

同时出现的上千甚至上万次的客户端请求，'线程池'或'进程池'或许可以缓解部分压力，但是不能解决所有问题。总之，多线程模型可以方便高效的解决小规模的服务请求，但面对大规模的服务请求，多线程模型也会遇到瓶颈

3. 非阻塞I/O

特点：用户进程需要不断的主动询问kernel中是否有所需数据存在

优点：能够在等待任务的时间运行其他任务(可以有多个任务同时运行)

缺点：

循环调用将大幅度提高CPU占用率

任务完成的响应延迟增大了，因为每过一段时间才去轮询一次read操作，而任务可能在两次轮询之间的任意时间完成。这会导致整体数据吞吐量的降低

4. 异步I/O

5. I/O多路复用

优点：相比其他模型，使用select() 的事件驱动模型只用单线程（进程）执行，占用资源少，不消耗太多 CPU，同时能够为多客户端提供服务。如果试图建立一个简单的事件驱动的服务器程序，这个模型有一定的参考价值

使用IO模型实现TCP的socket套接字并发

6. selectors模块

select的调用步骤如下：

使用copy_from_user从用户空间拷贝fdset到内核空间

注册回调函数__pollwait

遍历所有fd，调用其对应的poll方法（对于socket，这个poll方法是sock_poll，sock_poll根据情况会调用到tcp_poll,udp_poll或者datagram_poll）

以tcp_poll为例，其核心实现就是__pollwait，也就是上面注册的回调函数

poll方法返回时会返回一个描述读写操作是否就绪的mask掩码，根据这个mask掩码给fd_set赋值

把fd_set从内核空间拷贝到用户空间

select的缺点：

每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大

同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大

select支持的文件描述符数量太小了，默认是1024

三种IO多路复用模型在不同的平台有着不同的支持，而epoll在windows下就不支持，selectors模块会帮我们默认选择当前平台下最合适的

7. socketserver模块

说明：socketserver模块中分两大类：server类（解决链接问题）和request类（解决通信问题）

基于tcp的socketserver我们自己定义的类中：

self.server：套接字对象

self.request：一个链接

self.client_address：客户端地址

基于udp的socketserver我们自己定义的类中：

self.request是一个元组（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象）

self.client_address：客户端地址

使用socketserver实现TCP的套接字并发

使用socketserver实现UDP的套接字并发

9. paramiko模块

说明：远程控制模块，可以对远程的服务器进程命令和文件等操作

应用：ansible、fabric等开源软件内部的远程管理机制

安装：pip install paramiko

SSHClient：连接远程服务器并执行基本命令

SFTPClient：用于连接远程服务器并执行上传下载

SSHClient基于用户名密码连接：

SSHClient基于公钥密钥连接：

SSHClient封装Transport

SFTPClient基于用户名密码上传下载：

SFTPClient基于公钥密钥上传下载：

公告