基于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) #
         # unpack 返回的是元组(1999,)
         info_len = struct.unpack("i",info_len)[0] 

     # (2) 接受服务端返回的数据
     file_info = sk.recv(info_len).decode() #
     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\n" % (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) #

         # 发送出去
         self.request.send(send_info) #

     # 下载方法
     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/ftp\myvideo\ceshivideo.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()