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

首先对于这样的任务要建立文件目录，不能将所有的代码放在一个文件夹下。文件目录，先两个大目录，客户端FTP_client，服务端FTP_server。

服务端FTP_server下面肯定还要文件夹bin（放启动文件），conf（放配置文件，方便后续修改），core（放主逻辑，主程序），home，logger（放日志，这个作业用不到）。

下面按顺序介绍，先是bin文件下，有一个ftp_server.py，代码如下：

import os,sys

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # 将当前搜索路径返回FTP_server这级
sys.path.append(BASE_DIR)
from core import main

if __name__ == '__main__':

    main.ArgvHandler()

启动文件，顾名思义，相当于其他文件夹下的其他文件都是复制到这个目录下执行的，所以有关涉及路径操作时注意。

下面是core文件下的两个.py文件：

import optparse
import socketserver
from conf import settings
from core import server
'''
core文件下面放的是主逻辑
'''


class ArgvHandler(object):

    def __init__(self):                                            # 接收参数，解析命令
        self.op=optparse.OptionParser()

        # op.add_option("-s","--host",dest="host",help="server IP address")
        # op.add_option("-P","--port",dest="port",help="server port")

        options,args=self.op.parse_args()                          # options返回的类，里面有你add_option加入的属性，加入的其他放在args中
        # print(options,args)
        # print(options.host,options.port)

        self.verify_argv(options,args)                             # 这个函数相当于是一个命令的分发，比如在命令行中输入Python ftp_server.py start


    def verify_argv(self,options,args):                            # 命令行的分发，这里args[0]，就是start，所以取得函数名后，对应执行

        if hasattr(self,args[0]):
            func=getattr(self,args[0])
            func()

        else:
            self.op.print_help()


    def start(self):
        print('server is working ....')
        ser=socketserver.ThreadingTCPServer((settings.IP,settings.PORT),server.ServerHandler)                # 建立TCP链接循环，而且是可并发的
        ser.serve_forever()

import socketserver
import json
import configparser
import os
from conf import settings
import hashlib
import shutil


STATUS_CODE  = {
    250 : "Invalid cmd format, e.g: {'action':'get','filename':'test.py','size':344}",
    251 : "Invalid cmd ",
    252 : "Invalid auth data",
    253 : "Wrong username or password",
    254 : "Passed authentication",
    255 : "Filename doesn't provided",
    256 : "File doesn't exist on server",
    257 : "ready to send file",
    258 : "md5 verification",

    800 : "the file exist,but not enough ,is continue? ",
    801 : "the file exist !",
    802 : " ready to receive datas",

    900 : "md5 valdate success"

}
'''
写socketserver首先得写一个自己的类，里面要重写handle函数，里面在写通讯循环；然后外面写链接循环（main里面已经写了）
'''

class ServerHandler(socketserver.BaseRequestHandler):

    def handle(self):

        while 1:                         # 这里不断循环，其实就是与一个客户端不断的通讯（交互）

            data=self.request.recv(1024).strip()
            print("data-----",data)
            if len(data)==0:break

            data=json.loads(data.decode("utf8"))
            print("data:",data)

            '''
            data = {'action':'auth',
                    'username':user,
                    'password':password}
            '''

            if data.get("action"):                                             # 这里又是一个命令行的分发，其实啰嗦的写可以用多个if,稍微好一点是用字典，这样写最好
                if hasattr(self,'_%s'%data.get("action")):
                    func=getattr(self,'_%s'%data.get("action"))
                    func(**data)

                else:
                    print("Invalid cmd!")
                    self.send_response(251)

            else:
                print("invalid cmd format")
                self.send_response(250)


    def send_response(self,status_code,data=None):
        '''向客户端返回数据'''
        response = {'status_code':status_code,'status_msg':STATUS_CODE[status_code]}
        if data:
            response.update(data)
        self.request.send(json.dumps(response).encode())


    def _auth(self,**data):

        if data.get("username") is None or data.get("password") is None:
            self.send_response(252)

        user=self.authenticate(data.get("username"),data.get("password"))

        if user is None:
            print("")
            self.send_response(253)

        else:
            self.user=user
            print("passed authentication",user)
            self.send_response(254)
            self.mainPath=os.path.join(settings.BASE_DIR,"home",self.user)


    def authenticate(self,username,password):           # 用户名与密码验证，相当于是跟数据库中的信息匹配，看有没有这个用户，看密码对不对

        cfp=configparser.ConfigParser()
        cfp.read(settings.ACCOUNT_PATH)

        if username in cfp.sections():
            print(".....",cfp[username]["Password"])

            Password=cfp[username]["Password"]
            if Password==password:
                print("auth pass!")
                return username


    def _post(self,**data): # 文件上传功能实现
        # 上传文件有几种可能：1，文件已经存在（就算存在，也分两种情况，1）存在的是完整的；2）存在的不完整（又分两种情况，是否需要续传））；
        # 2，原来不存在

        file_name=data.get("file_name")
        file_size=data.get("file_size")
        target_path=data.get("target_path")
        print(file_name,file_size,target_path)
        abs_path=os.path.join(self.mainPath,target_path,file_name)
        print("abs_path",abs_path)

        has_received=0


        if os.path.exists(abs_path):
            has_file_size=os.stat(abs_path).st_size
            if has_file_size <file_size:
               self.request.sendall(b"800")

               is_continue=str(self.request.recv(1024),"utf8")
               if is_continue=="Y":
                    self.request.sendall(bytes(str(has_file_size),"utf8"))
                    has_received+=has_file_size
                    f=open(abs_path,"ab")

               else:
                    f=open(abs_path,"wb")
            else:
                self.request.sendall(b"801")
                return #注意这个return必须有

        else:
            self.request.sendall(b"802")
            f=open(abs_path,"wb")


        while has_received<file_size:
            try:
                data=self.request.recv(1024)
                if not data:
                    raise Exception
            except Exception:

                break

            f.write(data)
            has_received+=len(data)

        f.close()


    def _post_md5(self,**data):

        file_name=data.get("file_name")
        file_size=data.get("file_size")
        target_path=data.get("target_path")
        print(file_name,file_size,target_path)
        abs_path=os.path.join(self.mainPath,target_path,file_name)
        print("abs_path",abs_path)

        has_received=0


        if os.path.exists(abs_path):
            has_file_size=os.stat(abs_path).st_size
            if has_file_size <file_size:
               self.request.sendall(b"800")

               is_continue=str(self.request.recv(1024),"utf8")
               if is_continue=="Y":
                    self.request.sendall(bytes(str(has_file_size),"utf8"))
                    has_received+=has_file_size
                    f=open(abs_path,"ab")

               else:
                    f=open(abs_path,"wb")
            else:
                self.request.sendall(b"801")
                return #注意这个return必须有

        else:
            self.request.sendall(b"802")
            f=open(abs_path,"wb")


        if data.get('md5'):
                print("hhhhhhhhhhh")
                md5_obj = hashlib.md5()

                while has_received<file_size:

                    try:
                        data=self.request.recv(1024)
                        if not data:
                            raise Exception
                    except Exception:

                        break

                    f.write(data)
                    has_received+=len(data)
                    recv_file_md5=md5_obj.update(data)
                    print("mmmmmm")

                else:
                    self.request.sendall(b"ok")#解决粘包
                    send_file_md5=self.request.recv(1024).decode("utf8")
                    print("send_file_md5",send_file_md5)
                    self.request.sendall("900".encode("utf8"))

        else:

            while has_received<file_size:

                try:
                    data=self.request.recv(1024)
                    if not data:
                        raise Exception
                except Exception:

                    break
            f.write(data)
            has_received+=len(data)

        f.close()



    def _ls(self,**data):

        file_list=os.listdir(self.mainPath)

        file_str='
'.join(file_list)
        if not file_list:
            file_str="<empty directory>"
        self.request.send(file_str.encode("utf8"))


    def _cd(self,**data):

        path=data.get("path")

        if path=="..":
            self.mainPath=os.path.dirname(self.mainPath)
        else:
            self.mainPath=os.path.join(self.mainPath,path)

        self.request.send(self.mainPath.encode("utf8"))




    def _mkdir(self,**data):

        dirname = data.get("dirname")
        tar_path=os.path.join(self.mainPath,dirname)
        if not os.path.exists(tar_path):
            if "/" in dirname:
                os.makedirs(tar_path) #创建多级目录
            else:
                os.mkdir(tar_path) #创建单级目录

            self.request.send(b"mkdir_success!")

        else:
            self.request.send(b"dir_exists!")


    def _rmdir(self,**data):
        dirname =data.get("dirname")

        tar_path=os.path.join(self.mainPath,dirname)
        if os.path.exists(tar_path):
            if os.path.isfile(tar_path):
                os.remove(tar_path) #删除文件
            else:
                shutil.rmtree(tar_path) #删除目录

            self.request.send(b"rm_success!")
        else:
            self.request.send(b"the file or dir does not exist!")


    def _pwd(self,**data):
        self.request.send(self.mainPath.encode("utf8"))

下面是conf文件下的两个文件，一个.py，一个.cfg相当于数据库功能。

import os

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))



IP="127.0.0.1"
PORT=8088


ACCOUNT_PATH=os.path.join(BASE_DIR,"conf","accounts.cfg")

[DEFAULT]

[yuan]
Password = 123
Quotation = 100

[root]
Password = root
Quotation = 100

home文件夹下面还有两个文件夹，家目录root文件夹，与一个用户文件夹yuan。

yuan文件夹下面还有一个images文件夹。（调试时，就将用户yuan的一张图片上传到服务器的这个文件夹下）。上传前，它们都是空。

关于FTP的客户端，那就简单了，所有程序都在文件FTP_client下，里面有一个.py文件与一张要测试上传的图片。

import optparse
import socket
import json,os,sys,time,hashlib

STATUS_CODE  = {
    250 : "Invalid cmd format, e.g: {'action':'get','filename':'test.py','size':344}",
    251 : "Invalid cmd ",
    252 : "Invalid auth data",
    253 : "Wrong username or password",
    254 : "Passed authentication",

    800 : "the file exist,but not enough ,is continue? ",
    801 : "the file exist !",
    802 : " ready to receive datas",

    900 : "md5 valdate success"

}

class ClientHanlder(object):

    def __init__(self):

        self.op=optparse.OptionParser()
        self.op.add_option("-s","--server",dest="server")
        self.op.add_option("-P","--port",dest="port")
        self.op.add_option("-u","--username",dest="username")
        self.op.add_option("-p","--password",dest="password")
        self.options , self.args=self.op.parse_args()
        self.verify_args()
        self.make_connection()
        self.mainPath=os.path.dirname(os.path.abspath(__file__))
        self.last=0



    def verify_args(self,):
        if self.options.server and self.options.port:
            #print(options)
            if int(self.options.port) >0 and int(self.options.port) <65535:
                return True
            else:
                exit("Err:host port must in 0-65535")

    def make_connection(self):

        self.sock = socket.socket()
        self.sock.connect((self.options.server,int(self.options.port)))


    def interactive(self):

        if self.authenticate():

            print("---start interactive with you ...")
            while 1:
                cmd_info=input("[%s]"%self.current_path).strip()
                if len(cmd_info)==0:continue
                cmd_list = cmd_info.split()
                if hasattr(self,"_%s"%cmd_list[0]):
                    func=getattr(self,"_%s"%cmd_list[0])
                    func(cmd_list)

                else:
                    print("Invalid cmd")




    def authenticate(self):

        if self.options.username and self.options.password:
            return self.get_auth_result(self.options.username,self.options.password)
        else:

            username=input("username: ")
            password=input("password: ")
            return self.get_auth_result(username,password)

    def get_auth_result(self,username,password):

        data = {'action':'auth',
                'username':username,
                'password':password}

        self.sock.send(json.dumps(data).encode())
        response = self.get_response()
        print("response",response)
        if response.get('status_code') == 254:
            print("Passed authentication!")
            self.user = username
            self.current_path = '/'+username

            return True
        else:
            print(response.get("status_msg"))

    def get_response(self):

        data = self.sock.recv(1024)
        data = json.loads(data.decode())
        return data

    def progress_percent(self,has,total,):


        rate = float(has) / float(total)
        rate_num = int(rate * 100)

        if self.last!=rate_num:

            sys.stdout.write("%s%% %s
"%(rate_num,"#"*rate_num))

        self.last=rate_num


    def _post(self,cmd_list):

        action,local_path,target_path=cmd_list

        if "/" in local_path:
            local_path=os.path.join(self.mainPath,local_path.split("/"))
        local_path=os.path.join(self.mainPath,local_path)

        file_name=os.path.basename(local_path)
        file_size=os.stat(local_path).st_size

        data_header = {
            'action':'post',
            'file_name': file_name,
            'file_size': file_size,
            'target_path':target_path
         }

        self.sock.send(json.dumps(data_header).encode())

        result_exist=str(self.sock.recv(1024),"utf8")
        has_sent=0

        if result_exist=="800":
            choice=input("the file exist ,is_continue?").strip()
            if choice.upper()=="Y":
                self.sock.sendall(bytes("Y","utf8"))
                result_continue_pos=str(self.sock.recv(1024),"utf8")
                print(result_continue_pos)
                has_sent=int(result_continue_pos)

            else:
                self.sock.sendall(bytes("N","utf8"))

        elif result_exist=="801":
            print(STATUS_CODE[801])
            return


        file_obj=open(local_path,"rb")
        file_obj.seek(has_sent)
        start=time.time()

        while has_sent<file_size:

            data=file_obj.read(1024)
            self.sock.sendall(data)
            has_sent+=len(data)

            self.progress_percent(has_sent,file_size)

        file_obj.close()
        end=time.time()
        print("cost %s s"% (end-start))
        print("post success!")

    def _post_md5(self,cmd_list):


        if len(cmd_list)==3:

            action,local_path,target_path=cmd_list
        else:
            action,local_path,target_path,is_md5=cmd_list

        if "/" in local_path:
            local_path=os.path.join(self.mainPath,local_path.split("/"))
        local_path=os.path.join(self.mainPath,local_path)

        file_name=os.path.basename(local_path)
        file_size=os.stat(local_path).st_size

        data_header = {
            'action':'post_md5',
            'file_name': file_name,
            'file_size': file_size,
            'target_path':target_path
         }

        if self.__md5_required(cmd_list):
            data_header['md5'] = True


        self.sock.send(json.dumps(data_header).encode())

        result_exist=str(self.sock.recv(1024),"utf8")
        has_sent=0

        if result_exist=="800":
            choice=input("the file exist ,is_continue?").strip()
            if choice.upper()=="Y":
                self.sock.sendall(bytes("Y","utf8"))
                result_continue_pos=str(self.sock.recv(1024),"utf8")
                print(result_continue_pos)
                has_sent=int(result_continue_pos)

            else:
                self.sock.sendall(bytes("N","utf8"))

        elif result_exist=="801":
            print(STATUS_CODE[801])
            return


        file_obj=open(local_path,"rb")
        file_obj.seek(has_sent)
        start=time.time()

        if self.__md5_required(cmd_list):
                md5_obj = hashlib.md5()

                while has_sent<file_size:

                    data=file_obj.read(1024)
                    self.sock.sendall(data)
                    has_sent+=len(data)
                    md5_obj.update(data)
                    self.progress_percent(has_sent,file_size)

                else:
                    print("post success!")
                    md5_val = md5_obj.hexdigest()
                    self.sock.recv(1024)#解决粘包
                    self.sock.sendall(md5_val.encode("utf8"))
                    response=self.sock.recv(1024).decode("utf8")
                    print("response",response)
                    if response=="900":
                        print(STATUS_CODE[900])

        else:
                while has_sent<file_size:

                    data=file_obj.read(1024)
                    self.sock.sendall(data)
                    has_sent+=len(data)

                    self.progress_percent(has_sent,file_size)

                else:
                    file_obj.close()
                    end=time.time()
                    print("
cost %s s"% (end-start))
                    print("post success!")



    def __md5_required(self,cmd_list):
        '''检测命令是否需要进行MD5验证'''
        if '--md5' in cmd_list:
            return True


    def _ls(self,cmd_list):

        data_header = {
            'action':'ls',
        }
        self.sock.send(json.dumps(data_header).encode())

        data = self.sock.recv(1024)

        print(data.decode("utf8"))


    def _cd(self,cmd_list):

        data_header = {

             'action':'cd',

             'path':cmd_list[1]
         }

        self.sock.send(json.dumps(data_header).encode())

        data = self.sock.recv(1024)
        print(data.decode("utf8"))
        self.current_path='/'+os.path.basename(data.decode("utf8"))

    def _mkdir(self,cmd_list):

        data_header = {
            'action':'mkdir',
             'dirname':cmd_list[1]
         }

        self.sock.send(json.dumps(data_header).encode())
        data = self.sock.recv(1024)
        print(data.decode("utf8"))

    def _rmdir(self,cmd_list):
        data_header = {
             'action':'rm',
             'target_path':cmd_list[1]
         }
        self.sock.send(json.dumps(data_header).encode())
        data = self.sock.recv(1024)
        print(data.decode("utf8"))


    def _pwd(self,cmd_list):

        data_header = {
            'action':'pwd',
         }

        self.sock.send(json.dumps(data_header).encode())
        data = self.sock.recv(1024)
        print(data.decode("utf8"))


ch=ClientHanlder()
ch.interactive()

以上就是全部内容，但是注意，这个服务器打开，客户端上传下载都是用指令行完成的。

比如打开服务器，就先找到启动文件位置，然后python ftp_server.py start

客户端注册，就是Python ftp_client.py -s 127.0.0.1, -P 8088 -u 用户名 -p 密码。

上传就是 put 12.jpg(文件名)  images(目标位置)

等等