基于socketsever下实现的FTP

# ### 客户端client
import socket
import json
import struct
import os

sk = socket.socket()
sk.connect( ("127.0.0.1" , 9000) )


def myrecv(info_len = 1024,sign=False):
    # 要考虑黏包
    if sign:
        # (1) 先接受发送数据的实际长度
        info_len = sk.recv(4) # 1
        # unpack 返回的是元组(1999,)
        info_len = struct.unpack("i",info_len)[0] 
    
    # (2) 接受服务端返回的数据
    file_info = sk.recv(info_len).decode() # 2
    file_dic = json.loads(file_info)
    return file_dic



# 处理收发数据的逻辑
def auth(opt):
    """
    opt: login 登录 or register 注册
    """
    usr = input("username: ").strip()
    pwd = input("password: ").strip()
    dic = {"user":usr,"pwd":pwd,"operate":opt}
    str_dic = json.dumps(dic)
    # 把数据发送给服务端
    sk.send(str_dic.encode())
    return myrecv()

    
# 1.注册
# res = auth("register")
# print(res)

def register():
    res = auth("register")
    return res
    
# 2.登录
# res = auth("login")
# print(res)
def login():
    res = auth("login")
    return res

# 3.退出
def myexit():
    opt_dic = {"operate":"myexit"}
    sk.send(json.dumps(opt_dic).encode())
    exit("欢迎下次再来 ... ")
# myexit()

# 4.下载
def download():
    operate_dict = {
    "operate":"download",
    "filename":"ceshivideo.mp4"
    }
    
    opt_str = json.dumps(operate_dict)
    sk.send(opt_str.encode("utf-8"))
    
    # (1) 为了避免黏包,接受两次数据
    res = myrecv(sign=True)
    print(res) # {'result': True, 'info': '改文件存在'}
    if res["result"]:
        # 创建文件夹
        try:
            os.mkdir("mydownload")
        except:
            pass
            
        # (2) 接受文件名字 和 文件大小
        dic = myrecv(sign=True)
        print(dic,"<2>") # {'filename': 'ceshivideo.mp4', 'filesize': 54822153} <2>
    
        # (3) 接受文件数据
        with open("./mydownload/" + dic["filename"],mode="wb") as fp:
            while dic["filesize"]:
                content = sk.recv(1024)
                fp.write(content)
                dic["filesize"] -= len(content)
        print("客户端下载完毕")
    else:
        print("文件不存在")
    
    
    

# 第一套界面
operate_lst1 = [ ("登录",login) , ("注册",register) ,("退出",myexit)]
# 第二套界面
operate_lst2 = [("下载",download),("退出",myexit)]
"""
( 1, ('登录', <function login at 0x00000234890402F0>)   )
(2, ('注册', <function register at 0x0000023489040268>))
(3, ('退出', <function myexit at 0x0000023489040378>))
"""
def main(operate_lst):
    for i,tup in enumerate(operate_lst,start=1):
        print(i,tup[0])
        
    num = int(input("请选择要执行的号码:>>>").strip()) 
    # 调用函数
    res = operate_lst[num-1][1]() # login()
    # 返回结果
    return res



# 循环调用1号操作界面
while True:
    # 开启第一套操作界面
    res = main(operate_lst1)
    print(res)
    # 开启第二套操作界面
    if res["result"]:
        while True:
            res = main(operate_lst2)
            print(res)

sk.close()

# ### 服务端   server
import socketserver
import json
import os
import hashlib
import struct

# print(os.getcwd())
print(__file__)
print(os.path.dirname(__file__))
base_path = os.path.dirname(__file__)

# 获取当前账户文件所在的完整绝对路径
userinfo = os.path.join(base_path,"db","userinfo.txt")
print(userinfo)
""""""
class Auth():
    
    @staticmethod
    def md5(usr,pwd):
        md5_obj = hashlib.md5(usr.encode())
        md5_obj.update(pwd.encode())
        return md5_obj.hexdigest()

    # 注册
    @classmethod
    def register(cls,opt_dic) :
        # opt_dic = {'user': 'lisi', 'pwd': '222', 'operate': 'register'}
        # 1.监测数据库当中是否存在该用户
        with open(userinfo,mode="r",encoding="utf-8") as fp:            
            for line in fp:
                username = line.split(":")[0] 
                if username == opt_dic["user"]:
                    return {"result":False,"info":"用户名已经存在了"}
                    
        # 2.当前这个用户允许注册
        with open(userinfo,mode="a+",encoding="utf-8") as fp:
            # 用户名:密码 换行
            fp.write("%s:%s
" % (opt_dic["user"] , cls.md5(opt_dic["user"],opt_dic["pwd"])))
        
        """
            当用户上传文件的时候,动态给用户创建文件夹
        """
        
        # 3.直接返回对应的状态
        return {"result":True,"info":"注册成功"}
        
    # 登录
    @classmethod
    def login(cls,opt_dic):
        # opt_dic = {'user': 'lisi', 'pwd': '222', 'operate': 'register'}
        with open(userinfo,mode="r",encoding="utf-8") as fp:
            for line in fp:
                username,password = line.strip().split(":")
                if username == opt_dic["user"] and password == cls.md5(opt_dic["user"],opt_dic["pwd"]):
                    return {"result":True,"info":"登陆成功"}
            return {"result":False,"info":"登录失败"}
            
    # 退出
    @classmethod
    def myexit(cls,opt_dic):
        return {"result":"myexit"}

class FTPServer(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            # 接受服务端发送过来的数据
            opt_dic = self.myrecv()
            print(opt_dic)
            
            # 判断类当中是否含有register这个方法,如果有就反射
            if hasattr(Auth,opt_dic["operate"]):
                # getattr 反射出对应的register函数
                res = getattr(Auth,opt_dic["operate"])(opt_dic)
                
                # 判断是myexit,代表退出
                if res["result"] == "myexit":
                    return
                
                # 把返回值发送给客户端
                self.mysend(res)
                
                # 等待处理用户第二套操作界面的逻辑
                if res["result"]:
                    while True:
                        opt_dic = self.myrecv()
                        print(opt_dic)
                        
                        # 如果operate接受的是myexit 直接终止handle函数;
                        if opt_dic["operate"] == "myexit":
                            return                 
                        
                        # 可以反射 类 或者 对象 或者 模块响应的属性和方法
                        if hasattr(self,opt_dic["operate"]):
                            getattr(self,opt_dic["operate"])(opt_dic)
                
                
            # 如果Auth当中没有该操作的应急处理
            else:
                dic = {"result":False,"info":"没有该操作"}
                self.mysend(dic)

                
            
        
    # 接受数据的方法
    def myrecv(self):
        info = self.request.recv(1024)
        opt_str = info.decode()
        opt_dic = json.loads(opt_str)
        return opt_dic
        
    # 发送数据的方法
    def mysend(self,send_info,sign=False):
        # 先把字典变成字符串,然后变成字节流发送出去
        send_info = json.dumps(send_info).encode()
        
        # 增加代码
        if sign:
            # 通过pack转化成居右固定4个字节长度的字节流
            res = struct.pack("i",len(send_info))
            # 把接下来要发送的数据长度发送给客户端
            self.request.send(res) # 1
        
        # 发送出去
        self.request.send(send_info) # 2
        
    # 下载方法
    def download(self,opt_dic):
        # {'operate': 'download', 'filename': 'ceshivideo.mp4'}
        # print(opt_dic)
        # 先判断是否存在该文件
        filename = opt_dic["filename"]
        file_abs = os.path.join(base_path,"myvideo",filename)
        # print(filename) # ceshivideo.mp4
        # print(file_abs) # D:/gongxiang8/day31/ftpmyvideoceshivideo.mp4
        
        if os.path.exists(file_abs):
            # 1.先告诉用户,可以操作,存在该文件
            dic = {"result":True,"info":"改文件存在"}
            self.mysend(dic,sign=True)
            
            # 2.把对应的文件名,以及文件的大小发过去
            filesize = os.path.getsize(file_abs)
            dic = {"filename":filename,"filesize":filesize}
            self.mysend(dic,sign=True)
            
            
            # 3.真正开始发送文件内容
            with open(file_abs,mode="rb") as fp:
                while filesize:
                    # 一次性最多读取1024个字节
                    content = fp.read(1024)
                    self.request.send(content)
                    filesize -= len(content)
            print("服务器下载完毕")
            
        else:
            dic = {"result":False,"info":"改文件不存在"}
            self.mysend(dic,True)
        
        
        
        
        
        
        
myserver = socketserver.ThreadingTCPServer( ("127.0.0.1" , 9000)  , FTPServer)
# 让一个端口绑定多个程序(测试时使用)
socketserver.TCPServer.allow_reuse_address = True
myserver.serve_forever()