day8(老男孩-Python3.5-S14期全栈开发)

作者：赵俊            发布日期：2020/09/15

三、Socket实现简单的ssh客户端

1、os.system和os.popen的区别

　　os.system     返回值是脚本的退出状态码，只有0,1,2三种状态，直接输出命令结果在控制台

　　os.popen      返回值是一个内存地址，需要用read（）方法取出返回值

　　print(os.system("dir"))
　　print(os.popen("ipconfig").read())

2、注意

　　　服务器端绑定IP和端口，客户端连接IP和端口，传递的参数为元祖（“localhost”，9999），容易忽略少个括号

3、代码

　　服务器端

# Author:ZHJ
import socket
import os

server = socket.socket()
server.bind(("localhost",9999))
server.listen(10)

# print(server.accept())
while True:

    conn, add = server.accept()
    # print(add)
    print("%s:%s连接服务器" % (add[0],add[1]))
    while True:

        data = conn.recv(1024)
        if not data:
            print("%s:%s断开服务器连接" % (add[0],add[1]))
            break
        cmd_data = os.popen(data.decode("utf-8")).read()
        print(len(cmd_data))
        if not cmd_data:
            conn.send("指令错误".encode("utf-8"))
        else:
            conn.send(cmd_data.encode("utf-8"))

　　客户端

# Author:ZHJ
import socket

client = socket.socket()
client.connect(("localhost",9999))
while True:

    data = input(">>")
    if len(data) == 0:
        continue
    client.send(data.encode("utf-8"))

    print(client.recv(512).decode("utf-8"))

这样有一个问题需要解决

　　在客户端缓冲区比较小时，服务器返回的数据大于客户端接收缓冲区，这就造成返回的数据不能一次性接收完毕，导致下一次命令执行时，返回的是上一次命令剩余的数据

四、Socket实现简单的ssh服务端（解决数据缓冲区不足以接收数据）

 解决缓冲区小不足以接收全部数据的方法：

　　服务器发送数据时，把要发送数据的大小也发给客户端，然后客户端比较实际接收大小和总大小的差额来决定是否退出接收循环

期间有一个坑，需要注意↓

　　在比较长度大小时，必须都是编码过得bytes型，或者解码的str型（因为同样的数据，bytes型和str型长度是不一样的）

　len()——返回对象的长度（元素个数）

　例如下：

>>> len("前")
1
>>> len("前".encode("utf-8"))
3
>>>

 解决方法的具体代码

服务器端

# Author:ZHJ
import socket
import os

server = socket.socket()
server.bind(("localhost",9999))
server.listen(10)

# print(server.accept())
while True:

    conn, add = server.accept()
    # print(add)
    print("%s:%s连接服务器" % (add[0],add[1]))
    while True:

        data = conn.recv(1024)
        if not data:
            print("%s:%s断开服务器连接" % (add[0],add[1]))
            break
        cmd_data = os.popen(data.decode("utf-8")).read()
        # print(len(cmd_data))
        #服务器端增加发送返回结果的大小（建议计算“字节”的大小）
        #步骤-先把返回数据变成字节-取字节长度-把整型长度变成字符串-把长度字符串变成字节发送
        conn.send(str(len(cmd_data.encode("utf-8"))).encode("utf-8"))
        if not cmd_data:
            conn.send("指令错误".encode("utf-8"))
        else:
            conn.send(cmd_data.encode("utf-8"))

客户端

# Author:ZHJ
import socket

client = socket.socket()
client.connect(("localhost",9999))
while True:

    data = input(">>")
    if len(data) == 0:
        continue
    client.send(data.encode("utf-8"))
    # 客户端先接受总大小，然后转成整型数字，以便比较大小
    cmd_total_size = int(client.recv(512).decode("utf-8"))
    print(cmd_total_size)
    cmd_res_size = 0 # 实际接收数据大小
    rev_data = b"" #接收数据存储
    while cmd_res_size < cmd_total_size:
        rev_data += client.recv(512)
        cmd_res_size = len(rev_data)#接收数据的 长度赋值给cmd_res_size，以便每次循环比较大小
    print(rev_data.decode("utf-8"))

五、鸡汤

 略

六、Socket粘包1

 粘包的问题解决思路，服务器给客户端发送完大小，客户端发送一个确认指令，服务器接收这个指令（可以不做任何处理）再发送有效数据，这样可以把上下两条发送分隔开

七、Socket 编程FTP 文件传输

 服务器

# Author:ZHJ
import socket
import os

server = socket.socket()
server.bind(("localhost",9999))
server.listen(10)

# print(server.accept())
while True:

    conn, add = server.accept()
    # print(add)
    print("%s:%s连接服务器" % (add[0],add[1]))
    while True:

        fileName = conn.recv(1024)
        if not fileName:
            print("%s:%s断开服务器连接" % (add[0],add[1]))
            break
        if os.path.isfile(fileName.decode("utf-8")):
            f = open(fileName,"rb")
            fileSize = os.stat(fileName).st_size
            print(fileSize)
            conn.send(str(fileSize).encode("utf-8"))
            print("来自客户端：%s" % conn.recv(1024).decode("utf-8"))
            conn.send(f.read())
            f.close()

客户端

# Author:ZHJ
import socket

client = socket.socket()
client.connect(("localhost",9999))
while True:

    fileName = input(">>")
    if len(fileName) == 0:
        continue
    client.send(fileName.encode("utf-8"))
    # 客户端先接受总大小，然后转成整型数字，以便比较大小
    file_total_size = int(client.recv(512).decode("utf-8"))
    client.send("我已经收到文件大小，请发文件".encode("utf-8"))
    print(file_total_size)
    file_rev_size = 0 # 实际接收数据大小
    rev_data = b"" #接收数据存储
    f = open(fileName.split(".")[0] + "副本."+ fileName.split(".")[1], "wb")
    while file_rev_size < file_total_size:
        rev_data = client.recv(512)
        f.write(rev_data)
        file_rev_size += len(rev_data)#接收数据的 长度赋值给cmd_res_size，以便每次循环比较大小
    else:
        print("done")
    f.close()

八、Socket粘包深入编码(内涵进度条编写)

1、进度条的编写 

　　利用这个语句   sys.stdout.write("我和我的祖国")，这个语句输出没有换行，如果在写的字符串前加\r（回车符），那么光标会退到行首写，会覆盖原来的输出

2、又一个坑，前面把文件迭代了，后面再读文件，读不出来，因为迭代后光标到最末尾了

3、发送和接收交替进行可以避免粘包（往往循环时，不知道什么时候结束，还得用发送总大小来判断是否发送完毕）

带有MD5的代码

服务器

# Author:ZHJ
import socket
import os
import hashlib
server = socket.socket()
server.bind(("localhost",9999))
server.listen(10)

# print(server.accept())
while True:

    conn, add = server.accept()
    # print(add)
    print("%s:%s连接服务器" % (add[0],add[1]))
    while True:

        fileName = conn.recv(1024)
        if not fileName:
            print("%s:%s断开服务器连接" % (add[0],add[1]))
            break
        if os.path.isfile(fileName.decode("utf-8")):
            f = open(fileName,"rb")
            fileSize = os.stat(fileName).st_size
            print(fileSize)
            conn.send(str(fileSize).encode("utf-8"))
            print("来自客户端：%s" % conn.recv(1024).decode("utf-8"))
            m = hashlib.md5()
            for line in f:
                m.update(line)
                # print(len(line))
                con = conn.send(line)
                # print(con)
            conn.recv(1024)# 可以避免粘包
            f.close()
            print(m.hexdigest())
            conn.send(m.hexdigest().encode())

客户端

# Author:ZHJ
import socket
import hashlib
import sys
client = socket.socket()
client.connect(("localhost",9999))
while True:

    fileName = input(">>")
    if len(fileName) == 0:
        continue
    client.send(fileName.encode("utf-8"))
    # 客户端先接受总大小，然后转成整型数字，以便比较大小
    file_total_size = int(client.recv(512).decode("utf-8"))
    client.send("我已经收到文件大小，请发文件".encode("utf-8"))
    print(file_total_size)
    file_rev_size = 0 # 实际接收数据大小
    rev_data = b"" #接收数据存储
    f = open(fileName.split(".")[0] + "副本."+ fileName.split(".")[1], "wb")
    m = hashlib.md5()
    while file_rev_size < file_total_size:
        rev_data = client.recv(1024)
        # print("每次接收的大小：%s"%len(rev_data))
        f.write(rev_data)
        m.update(rev_data)
        file_rev_size += len(rev_data)#接收数据的 长度赋值给cmd_res_size，以便每次循环比较大小
        # print("接收的总大小：%s" % file_rev_size)
        bar = int((file_rev_size/file_total_size)*100)#进度百分比
        sys.stdout.write("\r"+int(bar/5)*"■"+"%s%%"%bar)#进度条显示

    else:
        print("")
        print("done")
        client.send(b"ok")# 可以避免粘包
        rev_md5 = client.recv(512).decode("utf-8")
        print("源文件的md5：%s" % rev_md5)
        print("接收文件的md5：%s" % m.hexdigest())
    f.close()

 

九、SocketServer

1、socketserver 提供多用户也就是并发功能，其实就是对socket的一个封装，使其更简单

2、分为几种类型

　　class socketserver.TCPServer(server_address, RequestHandlerClass, bind_and_activate=True)

　　class socketserver.UDPServer(server_address, RequestHandlerClass, bind_and_activate=True)

　　底下两个不常用

　　class socketserver.UnixStreamServer(server_address, RequestHandlerClass, bind_and_activate=True)

　　class socketserver.UnixDatagramServer(server_address, RequestHandlerClass,bind_and_activate=True)

3、创建一个socketServer需要以下几步

　　1、你必须 自己创建一个请求处理类，并继承BaseRequestHandler类，还要重写父类的handle()方法,和客户端所有的交互都在handle里完成。

　　2、必须实例化一个TCPServer或UDPServer，并传递ip和上面创建的请求处理类给这个TCPServer或UDPServer

　　3、实例.handle_request()（只处理一个请求）或者 实例.server_forever(poll_interval=0.5)（处理多个请求,参数意思每0.5秒检测一次关闭请求）

　　4、实例.server_close()关闭套接字

简单的socketserver代码实例

服务器

# Author:ZHJ
# import socketserver
from socketserver import *


class MyRequest(BaseRequestHandler):
    def handle(self):
        while True:
            self.data = self.request.recv(1024).strip()
            if not self.data:
                print("客户端断开")
                break
            print(self.data)
            self.request.send(self.data.upper())

server = TCPServer(("localhost",9999), MyRequest)
server.serve_forever()
18 server.close_request()

客户端

client = socket.socket()# 创建一个socket对象
client.connect(("localhost",9999))# 连接指定ip和端口
while True:
    da = input("send>>>")
    if len(da) == 0:#不能send空字符
        continue
    client.send(da.encode("utf-8"))
    # print("\033[1;31msend:%s\033[0m" % da)
    data = client.recv(1024)
    print("\033[1;32mrecv:%s\033[0m" % str(data,encoding="utf-8"))
client.close()

十、SocketServer多并发

 实例化时使用ThreadingTCPServer就可以多线程实现多并发

 实例化时使用ForkingingTCPServer就可以多进程实现多并发（windows上用不了，在windows上无法使用fork创建新进程，linux上可以）

例：server = ThreadingTCPServer(("localhost",9999), MyRequest)

十一、作业，多用户在线FTP程序

开发一个支持多用户在线的FPT程序

要求：

　　1、用户加密认证

　　2、允许同时多用户登录

　　3、每个用户有自己的家目录，且只能访问自己的家目录

　　4、对用户进行磁盘配额，每个用户的可用空间不同

　　5、允许用户在FTPserver上随意切换目录

　　6、允许用户查看当前目录下文件

　　7、允许用户上传和下载文件，保证文件一致性

　　8、文件传输过程中显示进度条

　　9、附加功能，支持文件的断点续传