python简单的消息并发及FTP作业分析

socketserver模块实现并发
tcp协议的socket一次只能和一个客户端通信,如果用socketserver可以实现和多个客户端通信;它是在socket的基础上进行了一层封装,也就是说底层还是调用的socket,在py2.7里面叫做SocketServer也就是大写了两个S,在py3里面就小写了;用它来实现并发,也就是同时可以和多个客户端进行通信,多个人可以同时进行上传下载等(一个服务端与每个客户端都建立一个线程连接交互)

服务端
import socketserver

# 写一个类名字随便起,然后继承socketserver这个模块里面的BaseRequestHandler这个类
class Myserver(socketserver.BaseRequestHandler):

    # 写一个handle方法,必须用这个名字
    def handle(self):
        while 1:

            # 收消息,self.request相当于一个conn
            from_client_msg = self.request.recv(1024)
13 # 同下边功能一样
            # self.from_client_msg = self.request.recv(1024).strip()

            # 打印接收到的客户端消息
            print('客户端消息:',from_client_msg.decode('utf-8'))
18 # 同下边功能一样
            # 打印的是客户端IP和进程号
            # print('客户端消息:',self.client_address)
            # print(str(self.from_client_msg,'utf-8'))

            # request.send服务端发送消息
            self.server_msg = input('服务端消息:')
            self.request.send(self.server_msg.encode('utf-8'))
            # self.request.sendall(bytes(self.server_msg,'utf-8'))

            # self.request.close()  #关闭链接

if __name__ == '__main__':
    ip_port = ('127.0.0.1',8888)

    # 使用socketserver的ThreadingTCPServer这个类(ThreadingTCPServer 多线程),将IP和端口传进去,还需要将上面自己定义的类传进去,得到一个对象.相当于我们通过它进行了bind、listen
    server = socketserver.ThreadingTCPServer(ip_port,Myserver)

    # 让server永远运行下去,除非强制停止程序;使用上面这个类的对象来执行serve_forever()方法,并且serve_forever()帮我们进行了accept
    server.serve_forever()
38 # 同下边代码一样
    # HOST, PORT = "127.0.0.1", 9999
    # 设置allow_reuse_address允许服务器重用地址
    # socketserver.TCPServer.allow_reuse_address = True
    # 创建一个server, 将服务地址绑定到127.0.0.1:9999
    #server = socketserver.TCPServer((HOST, PORT),Myserver)
    # server = socketserver.ThreadingTCPServer((HOST, PORT),Myserver)


客户端
import socket
client = socket.socket()
client.connect(('127.0.0.1',8888))
while 1:

    # 发送给服务端的消息
    client_msg = input('客户端消息:')
    # client.sendall(bytes(client_msg,'utf-8'))
56 # 同下边的代码一样的功能
    client.send(client_msg.encode('utf-8'))

    # 接收并打印客户端的消息
    # from_server_msg = str(client.recv(1024),'utf-8')
    # print('服务端消息:',from_server_msg)
62 # 同下边的代码一样的功能
    from_server_msg = client.recv(1024)
    print('服务端消息:',from_server_msg.decode('utf-8'))

send()与sendall()区别:

    使用send()进行发送的时候,Python将内容传递给系统底层的send接口,也就是说,Python并不知道这次调用是否会全部发送完成,比如MTU是1500,但是此次发送的内容是2000,那么除了包头等等其他信息占用,发送的量可能在1000左右,还有1000未发送完毕,但是send()不会继续发送剩下的包,因为它只会发送一次,发送成功之后会返回此次发送的字节数,会返回数字1000给用户,然后就结束了,如果需要将剩下的1000发送完毕,需要用户自行获取返回结果,然后将内容剩下的部分继续调用send()进行发送

    sendall()是对send()的包装,完成了用户需要手动完成的部分,它会自动判断每次发送的内容量,然后从总内容中删除已发送的部分,将剩下的继续传给send()进行发送,发送完整的TCP数据,成功返回None,失败抛出异常

 实现简单的文件上传

服务端:
import socket,subprocess,struct,json,os
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind(('127.0.0.1',8888))
server.listen(5)

file_base_path = 'd:\上传下载'
conn, addr = server.accept()

# 1,接受4个字节
head_dic_json_bytes_size_strcut = conn.recv(4)

# 2,利用struct反解出head_dic_json_bytes的具体size
head_dic_json_bytes_size = struct.unpack('i',head_dic_json_bytes_size_strcut)[0]

# 3,接受head_dic_json_bytes具体数据
head_dic_json_bytes = conn.recv(head_dic_json_bytes_size)

# 4,将head_dic_json_bytes转化成json的格式
head_dic_json = head_dic_json_bytes.decode('utf-8')

# 5, head_dic_json 反序列化成字典类型
head_dic = json.loads(head_dic_json)

# 6 循环接收数据
file_path = os.path.join(file_base_path,head_dic['file_name'])

with open(file_path,mode='wb') as f1:
    total_data_size = 0
    while total_data_size < head_dic['file_size']:
        every_data = conn.recv(1024)
        f1.write(every_data)
        total_data_size += len(every_data)

conn.close()
server.close()


客户端
import socket,struct,json,os
client = socket.socket()
client.connect(('127.0.0.1',8888))

# 1, 自定制报头
head_dic = {
    'file_name': '测试.mp4',
    'file_md5': 13213213343244343423,
    'file_path': r'C:\Users\oldboy\PycharmProjects\s19\day30\06 文件的上传下载\测试.mp4',
    'file_size': None,
}
head_dic['file_size'] = os.path.getsize(head_dic['file_path'])

# 2,将head_dic利用json转化成json字符串
head_dic_json = json.dumps(head_dic)

# 3,将json字符串转化成bytes
head_dic_json_bytes = head_dic_json.encode('utf-8')

# 4,利用strcut将head_dic_json_bytes转化成固定的4个字节(内容bytes长度固定的4个字节)
head_dic_json_bytes_struct = struct.pack('i', len(head_dic_json_bytes))

# 5,发送固定4个字节
client.send(head_dic_json_bytes_struct)

# 6,发送bytes类型的字典的报头数据head_dic_json_bytes
client.send(head_dic_json_bytes)

# 7, 发送数据
with open(head_dic['file_path'],mode='rb') as f1:
    # 利用for循环每次如果读取一行,对于这种非文字类的文件会出现问题.
    total_data_size = 0
    while total_data_size < head_dic['file_size']:
        every_data = f1.read(1024)
        client.send(every_data)
        total_data_size += len(every_data)
client.close()

练习

服务端
import json
import socket
import struct

server = socket.socket()
server.bind(('127.0.0.1',8888))
server.listen()
conn,addr = server.accept()

# 首先接收文件的描述信息的长度
struct_data_len = conn.recv(4)
data_len = struct.unpack('i',struct_data_len)[0]

# 通过文件信息的长度将文件的描述信息全部接收
print('data_len>>',data_len)        #data_len>> 47
file_info_bytes = conn.recv(data_len)

# 将文件描述信息转换为字典类型,以便操作
file_info_json = file_info_bytes.decode('utf-8')
file_info_dict = json.loads(file_info_json)     #{'file_name': 'aaa.mp4', 'file_size': 24409470}

print(file_info_dict)

# 统计每次接收的累计长度
recv_sum = 0

# 根据文件描述信息,指定文件路径和文件名称
file_path = 'E:\Py3Practise\\test' + '\\' + file_info_dict['file_name']

# 接收文件的真实数据
with open(file_path,'wb')as f:

    #循环接收,循环结束的依据是文件描述信息中文件的大小,也是通过一个初始值为0的变量来统计
    while recv_sum < file_info_dict['file_size']:
        every_recv_data = conn.recv(1024)
        recv_sum += len(every_recv_data)
        f.write(every_recv_data)


客户端
import os
import socket
import json
import struct

client = socket.socket()
client.connect(('127.0.0.1',8888))

#统计文件大小
file_size = os.path.getsize(r'E:\知识总结\python开发\day029 socketserver ftp功能简单讲解\代码\day029\aaa.mp4')

#统计文件描述信息,给服务端,服务端按照我的文件描述信息来保存文件,命名文件等等,现在放到一个字典里面了
file_info = {
    'file_name':'aaa.mp4',
    'file_size': file_size,
}

#由于字典无法直接转换成bytes类型的数据,所以需要json来将字典转换为json字符串.在把字符串转换为字节类型的数据进行发送
#json.dumps是将字典转换为json字符串的方法
file_info_json = json.dumps(file_info)

#将字符串转换成bytes类型的数据
file_info_byte = file_info_json.encode('utf-8')

#为了防止黏包现象,将文件描述信息的长度打包后和文件的描述信息的数据一起发送过去
data_len = len(file_info_byte)
data_len_struct = struct.pack('i',data_len)

#发送文件描述信息
client.send(data_len_struct + file_info_byte)

#定义一个变量,=0,作为每次读取文件的长度的累计值
sum = 0

#打开的aaa.mp4文件,rb的形式,
with open(r'E:\知识总结\python开发\day029 socketserver ftp功能简单讲解\代码\day029\aaa.mp4','rb') as f:
    #循环读取文件内容
    while sum < file_size:
        #每次读取的文件内容,每次读取1024B大小的数据
        every_read_data = f.read(1024)
        #将sum累加,统计长度
        sum += len(every_read_data)
        #将每次读取的文件的真实数据返送给服务端
        client.send(every_read_data)

验证客户端的链接合法性

1、os.urandom(n)

    其中os.urandom(n) 是一种bytes类型的随机生成n个字节字符串的方法,而且每次生成的值都不相同.再加上md5等加密的处理,就能够成内容不同长度相同的字符串了

os.urandom(n)函数在python官方文档中做出了这样的解释

函数定位: Return a string of n random bytes suitable for cryptographic use. 
意思就是,返回一个有n个byte那么长的一个string,然后很适合用于加密.

然后这个函数,在文档中,被归结于os这个库的Miscellaneous Functions,意思是不同种类的函数(也可以说是混种函数) 
原因是: This function returns random bytes from an OS-specific randomness source. (函数返回的随机字节是根据不同的操作系统特定的随机函数资源.即,这个函数是调用OS内部自带的随机函数的.有特异性)


使用方法:
import os
from hashlib import md5

for i in range(10):
    print md5(os.urandom(24)).hexdigest()

2、hmac: 我们完全可以用hashlib来实现,但是这个操作更方便一些

    Python自带的hmac模块实现了标准的Hmac算法,我们首先需要准备待计算的原始消息message,随机key,哈希算法,这里采用MD5,使用hmac的代码如下:
import hmac
message = b'Hello world'
key = b'secret'
h = hmac.new(key,message,digestmod='MD5')
print(h.hexdigest())
比较两个密文是否相同,可以用hmac.compare_digest(密文、密文),然会True或者False.


可见使用hmac和普通hash算法非常类似.hmac输出的长度和原始哈希算法的长度一致.需要注意传入的key和message都是bytes类型,str类型需要首先编码为bytes.
def hmac_md5(key, s):
    return hmac.new(key.encode('utf-8'), s.encode('utf-8'), 'MD5').hexdigest()

class User(object):
    def __init__(self, username, password):
        self.username = username
        self.key = ''.join([chr(random.randint(48, 122)) for i in range(20)])
        self.password = hmac_md5(self.key, password)

事例

服务端
from socket import *
import hmac,os

secret_key=b'Jedan has a big key!'
def conn_auth(conn):
    '''
    认证客户端链接
    :param conn:
    :return:
    '''
    print('开始验证新链接的合法性')
    msg=os.urandom(32)#生成一个32字节的随机字符串
    conn.sendall(msg)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    respone=conn.recv(len(digest))
    return hmac.compare_digest(respone,digest)

def data_handler(conn,bufsize=1024):
    if not conn_auth(conn):
        print('该链接不合法,关闭')
        conn.close()
        return
    print('链接合法,开始通信')
    while True:
        data=conn.recv(bufsize)
        if not data:break
        conn.sendall(data.upper())

def server_handler(ip_port,bufsize,backlog=5):
    '''
    只处理链接
    :param ip_port:
    :return:
    '''
    tcp_socket_server=socket(AF_INET,SOCK_STREAM)
    tcp_socket_server.bind(ip_port)
    tcp_socket_server.listen(backlog)
    while True:
        conn,addr=tcp_socket_server.accept()
        print('新连接[%s:%s]' %(addr[0],addr[1]))
        data_handler(conn,bufsize)

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    server_handler(ip_port,bufsize)


客户端
from socket import *
import hmac,os

secret_key=b'Jedan has a big key!'
def conn_auth(conn):
    '''
    验证客户端到服务器的链接
    :param conn:
    :return:
    '''
    msg=conn.recv(32)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    conn.sendall(digest)

def client_handler(ip_port,bufsize=1024):
    tcp_socket_client=socket(AF_INET,SOCK_STREAM)
    tcp_socket_client.connect(ip_port)

    conn_auth(tcp_socket_client)

    while True:
        data=input('>>: ').strip()
        if not data:continue
        if data == 'quit':break

        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    client_handler(ip_port,bufsize)