python【项目】：基于socket的FTP服务器

• 功能要求

1. 用户加密认证

2. 服务端采用 SocketServer实现，支持多客户端连接

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

4. 对用户进行磁盘配额、不同用户配额可不同

5. 用户可以登陆server后，可切换目录

6. 能查看当前目录下文件

7. 上传下载文件，保证文件一致性

8. 传输过程中实现进度条展示

9．用户可在自己家目录进行创建目录、文件、删除目录及文件

10．服务端可实现增加用户、删除用户

11．支持上传时断点续传

• 应用知识点　

a) 类的应用

b) 函数的使用

c) 多进程

d) 反射

e)  socket、socketserver、hashlib、configparser、logging

f)  文件的读写

• 开发环境

1. python 3.6.1
2. PyCharm 2016.2.3

• 目录结构

FTPClient

       |--bin              (主接口目录)

    　　|--ftpclient.py    (客户端主程序接口文件)

      |--config           (配置文件目录)

   　　 |--code.py       (状态码文件)

   　　 |--settings.py    (配置文件)

   　　 |--template.py   (模板文件)

      |--download        (下载存放目录)

      |--lib              (模块目录)

   　　 |--client.py      (客户端各类接口封装)

   　　 |--common.py   (公共接口)

      |--logs            (日志目录)

   　　 |--ftpclient.log  (日志文件)

　　|--clientRun.py     (主执行程序)

 

FTPServer

       |--bin               (主接口目录)

    　　|--ftpserver.py      (服务端socket接口文件)

     　　 |--main.py        (主程序接口文件)

      |--config            (配置目录)

   　　 |--settings.py     (配置文件)

  　　  |--template.py    (模板文件)

　　|--database          (数据保存目录)

　　　|--user.ini        (用户信息文件)

　　|--dbhelper          (数据目录)

   　　|--dbapi.py       (数据操作接口)

　　|--lib               (模块目录)

   　　|--user.py        (用户类文件用来实例化对象)

   　　 |--server.py      (服务端模块，各类所有命令方法)

    　　|--common.py    (公共模块文件)

      |--logs

    　　|--ftpserver.log   (日志文件)

 　 |--upload           (上传文件存放的目录)

　  |--serverRun.py     (主执行程序)

• 模块功能系统图

1、思维导图

2､功能接口关系图

客户端：

服务端：

• 关键代码段

1､服务端

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


import socketserver,os,sys
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from config import settings,template
from lib import common,server



logger = common.Logger('ftpserver').getlog()

class MyServer(socketserver.BaseRequestHandler):

    def handle(self):
        try:
            client_socket = self.request
            client_addr = self.client_address
            logger.info("client {0} connected".format(client_addr))
            #发送成功标识给客户端
            client_socket.sendall(bytes("OK",encoding='utf-8'))
            client_user = None

            while True:
                #获取客户端命令
                ret_client_data = str(client_socket.recv(1024),encoding='utf-8')

                #判断客户端是否退出
                if ret_client_data == b'':
                    logger.info("client {0} is exit".format(client_addr))
                    client_socket.close()

                #取出客户端命令
                cmd = ret_client_data.split("|")[0]

                logger.info("client {0} send command {1}".format(client_addr,cmd))
                #判断是否登录认证状态
                if cmd == 'auth':
                    client_user = server.client_auth(client_socket, ret_client_data)
                else:
                   try:
                        #通过反射寻找模块的命令
                        if hasattr(server,cmd):
                            func = getattr(server,cmd)
                            func(client_socket, client_user, ret_client_data)
                        else:
                            logger.error("command {0} not found".format(cmd))
                   except Exception as e:
                       logger.error(e)
                       client_socket.close()

        except Exception as e:
            logger.error(e)

def process():
    """
    启动服务
    :return:
    """
    server = socketserver.ThreadingTCPServer((settings.FTP_SERVER_IP,settings.FTP_SERVER_PORT),MyServer)
    server.serve_forever()

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


import os,sys,configparser
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from config import settings

def readall_sections():
    """
    读取user.ini文件所有的用户名
    :return: 返回所有的用户名列表
    """
    con = configparser.ConfigParser()
    con.read(settings.USER_INI, encoding='utf-8')
    result = con.sections()
    return result

def GetValue(key,value):
    """
    获取user.ini文件键名值
    :param key: 键名
    :param value: 键值
    :return:
    """
    con = configparser.ConfigParser()
    con.read(settings.USER_INI, encoding='utf-8')
    result = con.get(key,value)
    return result

def CheckSections(sections_name):
    """
    检查sections项名是否存在
    :param sections_name: 用户名
    :return:
    """
    con = configparser.ConfigParser()
    con.read(settings.USER_INI, encoding='utf-8')
    result = con.has_section(sections_name)
    return result

def AddOption(sections_name, **args):
    """
    添加用户信息
    :param sections_name:用户名
    :param args: 字典格式：('test3',password='aa',totalspace='bb',userspace='cc')
    :return:
    """
    con = configparser.ConfigParser()
    with open(settings.USER_INI,'a+',encoding='utf-8') as f:
        con.add_section(sections_name)
        for key in args:
            con.set(sections_name, key, args[key])
        con.write(f)

def DelSections(sections_name):
    """
    删除用户信息
    :param sections_name:
    :return:
    """
    con = configparser.ConfigParser()
    con.read(settings.USER_INI, encoding='utf-8')
    with open(settings.USER_INI,'w') as f:
        con.remove_section(sections_name)
        con.write(f)

def ModifyOption(sections_name, **args):
    """
    修改磁盘配额空间
    :param sections_name: 用户名
    :param args:用户字典信息
    :return:
    """
    con = configparser.ConfigParser()
    con.read(settings.USER_INI, encoding='utf-8')
    for key in args:
        con.set(sections_name, key, args[key])
    with open(settings.USER_INI, 'w', encoding='utf-8') as f:
        con.write(f)

def load_info(sections_name):
    """
    加载用户信息
    :param sections_name: 用户名
    :return: 返回字典用户信息
    """
    con = configparser.ConfigParser()
    con.read(settings.USER_INI, encoding='utf-8')
    user_dict = {}
    for i, j in con.items(sections_name):
        user_dict[i] = j
    return user_dict

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


import os,sys,time
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from lib.common import Logger
from lib.user import Users
from lib import common


logger = Logger('serverr').getlog()



def client_auth(client_socket,args):

    """
    客户端认证
    :param client_socket: 客户端socket对象
    :param args: 用户发送过来的数据 ex: "auth|test|a7470858e79c282bc2f6adfd831b132672dfd1224c1e78cbf5bcd057"
    :return: success：认证成功；user_error：用户名不存在；fail：认证失败
    """
    recv_data_list = args.split("|")
    username = recv_data_list[1]
    passwd = recv_data_list[2]
    client_user = Users(username)
    #判断用户名是否存在
    if client_user.check_user():
        msg = client_user.load_user_info()
        password,totalspace,userspace = msg.strip().split("|")
        user_info = "{0}|{1}".format(totalspace, userspace)
        #判断密码是否正确
        if password == passwd:
            auth_status = "success"
        else:
            auth_status = "fail"
    else:
        auth_status = "user_error"

    #将认证状态发送给客户端
    client_socket.sendall(bytes(auth_status,encoding='utf-8'))
    if auth_status == "success":
        # 认证成功将用户空间消息发给客户端
        client_socket.sendall(bytes(user_info, encoding='utf-8'))
    return client_user


def cd(client_socket,client_user,ret_data):
    """
    切换目录路径
    :param client_socket: 客户端socket对象
    :param client_user: 客户端用户对象
    :param ret_data: 接收客户命令消息体  例如：cd|..或cd|test或cd|/test/aa/bb
    :return:
    """
    #获取命令行消息体
    cd_folder = ret_data.split("|")[1]
    try:
        #判断是否当前根目录
        if cd_folder == "..":
            if client_user.userpath == client_user.homepath:
                sed_msg = "0|{0}".format(os.path.basename(client_user.userpath))
            else:
                #返回上一级目录
                client_user.userpath = os.path.dirname(client_user.userpath)
                sed_msg = "1|{0}".format(os.path.basename(client_user.userpath))
        elif cd_folder == "." or cd_folder == "":
            sed_msg = "3|{0}".format(cd_folder)
        else:
            #组合路径目录
            tmp_path = os.path.join(client_user.userpath, cd_folder)
            if os.path.isdir(tmp_path):
                client_user.userpath = tmp_path
                sed_msg = "1|{0}".format(os.path.basename(client_user.userpath))
            else:
                # 不是文件夹
                sed_msg = "2|{0}".format(cd_folder)
        # 开始发送结果
        client_socket.sendall(bytes(sed_msg,encoding='utf-8'))
    except Exception as e:
        logger.error(e)

def put(client_socket,client_user,ret_data):
    """
    上传文件
    :param client_socket:
    :param client_user:
    :param ret_data:
    :return:
    """
    # 初始化上传文件的基本信息
    filename = ret_data.split("|")[1]
    filesize = int(ret_data.split("|")[2])
    filemd5 = ret_data.split("|")[3]
    put_folder = client_user.userpath
    check_filename = os.path.isfile(os.path.join(put_folder,filename))
    save_path = os.path.join(put_folder, filename)
    fmd5 = common.md5sum(save_path)
    #不存在文件名，正常传输
    if not check_filename:
        client_socket.sendall(bytes("ok",encoding='utf-8'))
        # 全新的文件的话,更新用户使用空间大小
        client_user.update_quota(filesize)
        # 已经接收的文件大小
        has_recv = 0
        with open(save_path,'wb') as f:
            while True:
                # 如果文件总大小等于已经接收的文件大小，则退出
                if filesize == has_recv:
                    break
                data = client_socket.recv(1024)
                f.write(data)
                has_recv += len(data)
    else:
        #存在文件名条件，做判断分析是否存在断点
        if fmd5 == filemd5:
            client_socket.sendall(bytes("full", encoding='utf-8'))
            # 已经接收的文件大小
            has_recv = 0
            with open(save_path, 'wb') as f:
                while True:
                    # 如果文件总大小等于已经接收的文件大小，则退出
                    if filesize == has_recv:
                        break
                    data = client_socket.recv(1024)
                    f.write(data)
                    has_recv += len(data)
        else:
            #存在断点文件，发起请求续签标志
            recv_size = os.stat(save_path).st_size
            ready_status = "{0}|{1}".format("continue", str(recv_size))
            client_socket.sendall(bytes(ready_status, encoding='utf-8'))
            # 已经接收的文件大小
            has_recv = 0
            with open(save_path, 'wb') as f:
                while True:
                    # 如果文件总大小等于已经接收的文件大小，则退出
                    if filesize == has_recv:
                        break
                    data = client_socket.recv(1024)
                    f.write(data)
                    has_recv += len(data)

def get(client_socket,client_user,ret_data):
    """
    下载文件
    :param client_socket:
    :param client_user:
    :param ret_data:
    :return:
    """
    # 获取文件名
    filename = ret_data.split("|")[1]
    # 文件存在吗
    file = os.path.join(client_user.userpath, filename)
    if os.path.exists(file):
        # 先告诉客户端文件存在标识
        client_socket.send(bytes("1", 'utf8'))
        # 得到客户端回应
        client_socket.recv(1024)
        # 发送文件的基本信息 "filesize|file_name|file_md5"
        filesize = os.stat(file).st_size
        file_md5 = common.md5sum(file)
        sent_data = "{fsize}|{fname}|{fmd5}".format(fsize=str(filesize),
                                                    fname=filename,
                                                    fmd5=file_md5)
        client_socket.sendall(bytes(sent_data, 'utf8'))

        # 客户端收到ready
        if str(client_socket.recv(1024), 'utf-8') == "ready":
            # 开始发送数据了
            with open(file, 'rb') as f:
                new_size = 0
                for line in f:
                    client_socket.sendall(line)
                    new_size += len(line)
                    if new_size >= filesize:
                        break
    else:
        # 文件不存在
        client_socket.send(bytes("0", 'utf8'))


def mk(client_socket,client_user,ret_data):
    """
    创建目录
    :param client_socket: 客户端socket对象
    :param client_user: 客户端用户对象
    :param ret_data: 接收客户命令消息体  例如：mk|test
    :return:
    """
    mk_folder = ret_data.split("|")[1]
    if mk_folder:
        try:
            folder_path = os.path.join(client_user.homepath, mk_folder)
            os.makedirs(folder_path)
            client_socket.sendall(bytes("5000",encoding='utf-8'))
        except Exception as e:
            client_socket.sendall(bytes("5001",encoding='utf-8'))
            logger.error("create directory failure: %s" % e)
    else:
        client_socket.sendall(bytes("5002", encoding='utf-8'))

def delete(client_socket,client_user,ret_data):
    """
    删除目录或文件
    :param client_socket:客户端socket对象
    :param client_user:客户端用户对象
    :param ret_data:接收消息体：样本格式：delete|/test/aa
    :return:
    """
    del_folder = ret_data.split("|")[1]
    if del_folder:
        try:
            #判断文件名是否存在
            folder_path = os.path.join(client_user.homepath, del_folder)
            filesize = os.stat(folder_path).st_size
            if os.path.isfile(folder_path):
                os.remove(folder_path)
                client_user.update_down_quota(filesize)
                sent_data = "{staus}|{fsize}".format(staus="6001",
                                                    fsize=str(filesize)
                                                    )

                client_socket.sendall(bytes(sent_data, encoding='utf-8'))
            #判断目录是否存在
            elif os.path.isdir(folder_path):
                os.removedirs(folder_path)
                client_socket.sendall(bytes("6000", encoding='utf-8'))
            else:
                #目录或文件名不存在情况，删除失败
                client_socket.sendall(bytes("6002", encoding='utf-8'))
        except Exception as e:
                #当前路径目录下不是空目录，不能删除
                client_socket.sendall(bytes("6004", encoding='utf-8'))
                logger.error("Delete directory or filename failure: %s" % e)
    else:
        #命令行后是空白目录
        client_socket.sendall(bytes("6003", encoding='utf-8'))


def ls(client_socket,client_user,ret_data):
    """
    显示当前文件目录及文件名
    :param client_socket: 客户端socket对象
    :param client_user: 客户端用户对象
    :param ret_data: 接收消息体样本格式：ls|
    :return:
    """
    check_folder = client_user.userpath
    #获取用户目录下的文件目录或文件名列表
    file_list = os.listdir(check_folder)
    #目录下的文件个数
    file_count = len(file_list)
    if file_count > 0:
        return_list = "{filecount}|".format(filecount=file_count)
        for rootpath in file_list:
            file = os.path.join(check_folder,rootpath)
            stat = os.stat(file)
            create_time = time.strftime('%Y:%m-%d %X', time.localtime(stat.st_mtime))
            file_size = stat.st_size
            if os.path.isfile(file):
                return_list += "{ctime}        {fsize}    {fname}
".format(ctime=create_time,
                                                                            fsize=str(file_size).rjust(10, " "),
                                                                            fname=rootpath)
            if os.path.isdir(file):
                return_list += "{ctime}  <DIR> {fsize}    {fname}
".format(ctime=create_time,
                                                                            fsize=str(file_size).rjust(10, " "),
                                                                            fname=rootpath)
    else:
        return_list = "0|"

    try:
        # 开始发送信息到客户端
        # 1 先把结果串的大小发过去
        str_len = len(return_list.encode("utf-8"))
        client_socket.sendall(bytes(str(str_len), encoding='utf-8'))
        # 2 接收客户端 read 标识，防止粘包
        read_stat = client_socket.recv(1024).decode()
        if read_stat == "ready":
            client_socket.sendall(bytes(return_list, encoding='utf-8'))
        else:
            logger.error("client send show command，send 'ready' status fail")
    except Exception as e:
        logger.error(e)

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


import os,sys
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from config import settings
from dbhelper import dbapi
from lib.common import Logger

logger = Logger('user').getlog()

"""
服务端用户信息类
"""

class Users(object):
    def __init__(self,username):
        self.username = username
        self.password = ""
        self.totalspace = 0
        self.userspace = 0
        self.homepath = os.path.join(settings.USER_HOME_FOLDER, self.username)
        self.userpath = self.homepath

    def create_user(self):
        """
        创建用户
        :return: True:创建用户成功； False: 创建用户失败
        """
        args = dict(password=str(self.password), totalspace=str(self.totalspace), userspace=str(self.userspace))
        dbapi.AddOption(self.username, **args)
        self.__create_folder()

    def del_user(self):
        """
        删除用户
        :return: True；删除用户成功；False: 删除用户失败
        """
        dbapi.DelSections(self.username)
        self.__del_folder()

    def check_user(self):
        """
        判断用户是否存在
        :return:
        """
        if dbapi.CheckSections(self.username):
            return True
        return False


    def load_user_info(self):
        """
        加载用户信息，赋值给属性
        :return:
        """
        user_info = dbapi.load_info(self.username)
        self.password = user_info["password"]
        self.totalspace = int(user_info["totalspace"])
        self.userspace = int(user_info["userspace"])
        msg = "{0}|{1}|{2}".format(self.password, self.totalspace, self.userspace)
        return msg

    def __create_folder(self):
        """
        创建用户的目录
        :return:
        """
        os.mkdir(self.homepath)

    def __del_folder(self):
        """
        删除用户目录
        :return:
        """
        os.removedirs(self.homepath)


    def update_quota(self,filesize):
        """
        更新用户磁盘配额数据
        :param filesize: 上传文件大小
        :return: True: 更新磁盘配额成功；False：更新磁盘配额失败
        """
        if dbapi.CheckSections(self.username):
            self.userspace += filesize
            args = dict(userspace=str(self.userspace))
            dbapi.ModifyOption(self.username, **args)
            return True
        return False

    def update_down_quota(self,filesize):
        """
        用户删除文件情况，自动减少对应文件大小并更新用户磁盘配额空间
        :param filesize:
        :return:
        """
        if dbapi.CheckSections(self.username):
            self.userspace -= filesize
            args = dict(userspace=str(self.userspace))
            dbapi.ModifyOption(self.username, **args)
            return True
        return False

2、客户端

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'

import os,sys
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from config import settings,template,code
from lib import common
from lib.client import client

logger = common.Logger('ftpclient').getlog()


def run():
    common.message(template.START_MENU,"INFO")
    common.message("正在连接服务器 {0}:{1}......".format(settings.FTP_SERVER_IP,settings.FTP_SERVER_PORT),"INFO")

    #创建对象
    client_obj = client(settings.FTP_SERVER_IP,settings.FTP_SERVER_PORT)
    #连接服务器，返回结果
    conn_result = client_obj.connect()
    if conn_result == code.CONN_SUCC:
        common.message("连接成功！", "INFO")
        #客户端登录
        login_result = client_obj.login()
        if login_result:
            exit_flag = False
            while not exit_flag:
                show_menu = template.LOGINED_MENU.format(client_obj.username,
                                                         str(int(client_obj.totalspace / 1024 / 1024)),
                                                         str(int(client_obj.userspace / 1024 / 1024)))
                common.message(show_menu,"INFO")
                inp_command = common.input_command("[请输入命令]：")
                if inp_command == "quit":
                    exit_flag = True
                else:
                    #获取命令
                    func = inp_command.split("|")[0]
                    try:
                        if hasattr(client, func):
                            #从模块寻找到函数
                            target_func = getattr(client, func)
                            #执行函数
                            target_func(client_obj, inp_command)
                        else:
                            common.message("Client {0} 未找到".format(inp_command), "ERROR")
                    except Exception as e:
                        logger.error(e)
    else:
        common.message("连接失败！", "ERROR")

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


import os,sys,socket
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from config import settings
from config import code
from lib import common

logger = common.Logger('client').getlog()

class client(object):
    def __init__(self,server_addr, server_port):
        self.username =""
        self.totalspace = 0
        self.userspace = 0
        self.client = socket.socket()
        self.__server = (server_addr, server_port)

    def connect(self):
        """
        客户端连接验证
        :return: 连接成功返回1000；连接失败返回1001
        """
        try:
            self.client.connect(self.__server)
            ret_bytes = self.client.recv(1024)
            #接收服务端消息
            ret_str = str(ret_bytes, encoding='utf-8')
            if ret_str == "OK":
                return code.CONN_SUCC
            else:
                return code.CONN_FAIL
        except Exception as e:
            logger.error(e)

    def check_auth(self,user, passwd):
        """
        客户端状态发送给服务端验证，并返回结果
        :param user: 用户名
        :param passwd: 密码
        :return:
        """
        sendmsg = "{cmd}|{user}|{passwd}".format(cmd="auth",
                                                 user=user,
                                                 passwd=passwd)
        self.client.sendall(bytes(sendmsg,encoding='utf-8'))
        ret_bytes = self.client.recv(1024)
        #获取服务端返回的认证状态信息
        auth_info = str(ret_bytes, encoding='utf-8')
        if auth_info == "success":
            self.username = user
            #获取服务端返回用户空间信息
            user_info = str(self.client.recv(1024),encoding='utf-8')
            self.totalspace = int(user_info.split("|")[0])
            self.userspace = int(user_info.split("|")[1])
            return code.AUTH_SUCC
        if auth_info == "user_error":
            return code.AUTH_USER_ERROR
        if auth_info == "fail":
            return code.AUTH_FAIL

    def login(self):
        while True:
            username = str(input("请输入用户名：")).strip()
            password = str(input("请输入密码：")).strip()
            #对密码进行md5加密
            password = common.md5(password)
            #登录认证
            auth_status = self.check_auth(username,password)
            if auth_status == code.AUTH_SUCC:
                common.message(">>>>>>>登录成功","INFO")
                return True
            elif auth_status == code.AUTH_USER_ERROR:
                common.message(">>>>>>>用户名不存在","ERROR")
                return False
            else:
                common.message(">>>>>>>用户名或密码错误！","ERROR")
                return False

    def mk(self,command):
        """
        创建目录
        :param command: 发送命令消息格式；mk|test或mk|/test/yj
        :return:
        """
        #发送命令消息给服务端
        self.client.sendall(bytes(command,encoding='utf-8'))
        #接收服务端发来的回应消息
        mk_msg = str(self.client.recv(1024), encoding='utf-8')
        mk_msg = int(mk_msg)
        if mk_msg == code.FILE_MK_SUCC:
            common.message(">>>>>>>创建目录成功","INFO")
        elif mk_msg == code.FILE_MK_FAIL:
            common.message(">>>>>>>创建目录失败","ERROR")
        else:
            common.message(">>>>>>>请输入文件夹名","ERROR")

    def delete(self,command):
        """
        删除目录或文件名
        :param command: delete|PycharmProjects/untitled/project/FTPv1/FTPServer/upload/admin/test/aa
        :return:
        """
        # 发送命令消息给服务端
        self.client.sendall(bytes(command, encoding='utf-8'))
        # 接收服务端发来的回应消息
        del_msg = str(self.client.recv(1024), encoding='utf-8')
        reve_status = int(del_msg.split("|")[0])
        reve_delfilename_fsize = int(del_msg.split("|")[1])

        if del_msg == code.FOLDER_DEL_SUCC:
            common.message(">>>>>>>删除目录成功","INFO")
        elif reve_status == code.FILE_DEL_SUCC:
            #更新用户空间配额大小
            self.userspace -= reve_delfilename_fsize
            common.message(">>>>>>>删除文件名成功","INFO")
        elif reve_status == code.FILE_DEL_FAIL:
            common.message(">>>>>>>删除目录或文件名失败","ERROR")
        elif reve_status == code.FILE_DEL_EMPTY:
            common.message(">>>>>>>当前目录下不是空目录，无法删除！","ERROR")
        else:
            common.message(">>>>>>>命令行请输入需要删除的路径目录或文件名!","ERROR")

    def cd(self,command):
        """
        切换目录路径
        :param command: cd|.. 或cd|foldername
        :return: 返回状态信息
        """
        # 发送命令消息给服务端
        self.client.sendall(bytes(command, encoding='utf-8'))
        # 接收服务端发来的回应消息
        cd_msg = str(self.client.recv(1024), encoding='utf-8')
        result_status,result_folder = cd_msg.split("|")
        if result_status == "0":
            result_value = "当前是根目录"
        elif result_status == "1":
            result_value = "目录已切换到:{0}".format(result_folder)
        elif result_status == "2":
            result_value = "切换失败, {0} 不是一个目录".format(result_folder)
        elif result_status == "3":
            result_value = "命令无效：{0}".format(result_folder)
        common.message(result_value,"INFO")

    def ls(self,*args):
        """
        显示客户端的文件列表详细信息
        :param args:
        :return: 返回文件列表
        """
        try:
            # 发送命令到服务端
            self.client.send(bytes("ls|", encoding='utf-8'))
            # 接收服务端发送结果的大小
            total_data_len = self.client.recv(1024).decode()
            # 收到了并发送一个ready标识给服务端
            self.client.send(bytes("ready", 'utf-8'))

            # 开始接收数据
            total_size = int(total_data_len)  # 文件总大小
            has_recv = 0  # 已经接收的文件大小
            exec_result = bytes("", 'utf8')
            while True:
                # 如果文件总大小等于已经接收的文件大小，则退出
                if total_size == has_recv:
                    break
                data = self.client.recv(1024)
                has_recv += len(data)
                exec_result += data
            # 获取结果中文件及文件夹的数量
            return_result = str(exec_result, 'utf-8')
            file_count = int(return_result.split("|")[0])
            if file_count == 0:
                return_result = "目前无上传记录"
            else:
                return_result = return_result.split("|")[1]
            common.message(return_result,"INFO")
        except Exception as e:
            logger.error("client ls:{0}".format(e))

    def put(self,command):
        """
        上传文件
        :param command: put|folderfile
        :return:
        """
        file_name = command.split("|")[1]
        if os.path.isfile(file_name):
            filename = os.path.basename(file_name)
            fsize = os.stat(file_name).st_size
            fmd5 = common.md5sum(file_name)

            # 将基本信息发给服务端
            file_msg = "{cmd}|{file}|{filesize}|{filemd5}".format(cmd='put',
                                                                  file=filename,
                                                                  filesize=fsize,
                                                                  filemd5=fmd5)
            self.client.send(bytes(file_msg, encoding='utf8'))
            logger.info("send file info: {0}".format(file_msg))
            #接收来自服务端数据
            put_msg = str(self.client.recv(1024),encoding='utf-8')
            try:
                #正常上传文件
                if put_msg == "ok":
                    #判断是否超过用户空间配额
                    if self.userspace + fsize > self.totalspace:
                        common.message("用户磁盘空间不足,无法上传文件,请联系管理员!","ERROR")
                    else:
                        self.userspace += fsize
                        new_size = 0
                        with open(file_name,'rb') as f:
                            for line in f:
                                self.client.sendall(line)
                                new_size += len(line)
                                # 打印上传进度条
                                common.progress_bar(new_size,fsize)
                                if new_size >= fsize:
                                    break
                #断点续传文件
                if put_msg.split("|")[0] == "continue":
                    send_size = int(put_msg.split("|")[1])
                    common.message("服务端存在此文件，但未上传完，开始断点续传......","INFO")
                    new_size = 0
                    with open(file_name,'rb') as f:
                        #用seek来进行文件指针的偏移，实现断点续传的功能
                        f.seek(send_size)
                        while fsize - send_size > 1024:
                            revedata = f.read(1024)
                            self.client.sendall(revedata)
                            new_size += len(revedata)
                            #打印上传进度条
                            common.progress_bar(new_size, fsize)
                        else:
                            revedata = f.read(fsize - send_size)
                            self.client.sendall(revedata)
                            # 打印上传进度条
                            common.progress_bar(new_size, fsize)

                #不存在断点文件情况，询问是否覆盖掉原文件
                if put_msg == "full":
                    inp_msg = common.message("服务端存在完整文件，是否覆盖掉原文件[输入y或n]：","INFO")
                    inp = str(input(inp_msg)).strip().lower()
                    if inp == "y":
                        with open(file_name, 'rb') as f:
                            new_size = 0
                            for line in f:
                                self.client.sendall(line)
                                new_size += len(line)
                                #打印上传进度条
                                common.progress_bar(new_size, fsize)
                                if new_size >= fsize:
                                    break
                    elif inp == "n":
                        sys.exit()
                    else:
                       common.message("无效命令", "ERROR")
                logger.info("upload file<{0}> successful".format(file_name))
                common.message("文件上传成功", "INFO")
            except Exception as e:
                logger.error("文件上传失败:{0}".format(e))
                common.message("文件上传失败！", "ERROR")
        else:
            common.message("文件不存在！", "ERROR")

    def get(self,command):
        """
        下载文件
        :param command:
        :return:
        """
        return_result = ""
        # 发送基本信息到服务端 (command,username,file)
        self.client.send(bytes(command, encoding='utf-8'))
        # 先接收到命令是否正确标识,1 文件存在, 0 文件不存在
        ack_by_server = self.client.recv(1024)
        try:
            # 文件名错误,当前路径下找不到
            if str(ack_by_server, encoding='utf-8') == "0":
                return_result = "
当前目录下未找到指定的文件,请到存在目录下执行get操作!"
            else:
                # 给服务端回应收到，防止粘包
                self.client.send(bytes("ok", 'utf8'))

                # 文件存在,开始接收文件基本信息(大小,文件名)
                file_info = self.client.recv(1024).decode()
                file_size = int(file_info.split("|")[0])
                file_name = file_info.split("|")[1]
                file_md5 = file_info.split("|")[2]

                # 2 发送 ready 标识，准备开始接收文件
                self.client.send(bytes("ready", 'utf8'))

                # 3 开始接收数据了
                has_recv = 0
                with open(os.path.join(settings.DOWNLOAD_FILE_PATH, file_name), 'wb') as f:
                    while True:
                        # 如果文件总大小等于已经接收的文件大小，则退出
                        if file_size == has_recv:
                            break
                        data = self.client.recv(1024)
                        f.write(data)
                        has_recv += len(data)
                        # 打印下载进度条
                        common.progress_bar(has_recv, file_size)
                return_result = "
文件下载成功"
                logger.info("download file<{0}> from server successful".format(file_name))
                # md5文件验证
                check_md5 = common.md5sum(os.path.join(settings.DOWNLOAD_FILE_PATH, file_name))
                if check_md5 == file_md5:
                    logger.info("md5 check for file<{0}> succ!".format(file_name))
                    return_result += ", MD5 验证成功! "
                else:
                    return_result += ", MD5 验证文件不匹配! "
            common.message(return_result,"INFO")
        except Exception as e:
            logger.error(e)

#!/usr/bin/env python
#coding=utf-8
__author__ = 'yinjia'


import os,sys,logging,hashlib,time
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from config import settings

class Logger(object):
    """
    日志记录,写入指定日志文件
    """
    def __init__(self,logger):

        create_time = time.strftime('%Y-%m-%d %H:%M:%S')
        format = '[%(name)s]:[%(asctime)s] [%(filename)s|%(funcName)s] [line:%(lineno)d] %(levelname)-8s: %(message)s'

        # 创建一个logger
        self.logger = logging.getLogger(logger)
        self.logger.setLevel(logging.INFO)

        # 创建一个handler,用于写入日志文件
        fp = logging.FileHandler(settings.LOGS)

        # 定义handler的输出格式formatter
        fpmatter = logging.Formatter(format)
        fp.setFormatter(fpmatter)

        # 给logging添加handler
        self.logger.addHandler(fp)

    def getlog(self):
        return self.logger


def md5(arg):
    """
    密码进行md5加密
    :param arg: 用户的密码
    :return: 返回进行加密后的密码
    """
    result = hashlib.md5()
    result.update(arg.encode())
    return result.hexdigest()


def md5sum(filename):
    """
    用于获取文件的md5值
    :param filename: 文件名
    :return: MD5码
    """
    if not os.path.isfile(filename):  # 如果校验md5的文件不是文件，返回空
        return False
    myhash = hashlib.md5()
    f = open(filename, 'rb')
    while True:
        b = f.read(1024)
        if not b:
            break
        myhash.update(b)
    f.close()
    return myhash.hexdigest()

def message(msg,type):
    """
    根据不同的消息类型，打印出消息内容以不同的颜色显示
    :param msg: 消息内容
    :param type: 消息类型
    :return: 返回格式化后的消息内容
    """
    if type == "CRITICAL":
        show_msg = "
33[1;33m{0}33[0m
".format(msg)
    elif type == "ERROR":
        show_msg = "
33[1;31m{0}33[0m
".format(msg)
    elif type == "WARNING":
        show_msg = "
33[1;32m{0}33[0m
".format(msg)
    elif type == "INFO":
        show_msg = "
33[1;36m{0}33[0m
".format(msg)
    else:
        show_msg = "
{0}
".format(msg)
    print(show_msg)

def progress_bar(cache, totalsize):
    """
    打印进度条
    :param cache: 缓存字节大小
    :param totalsize: 文件总共字节
    :return:
    """
    ret = cache / totalsize
    num = int(ret * 100)
    view = '
%d%% |%s' % (num, num * "*")
    sys.stdout.write(view)
    sys.stdout.flush()

def input_command(msg):
    flag = False
    while not flag:
        command_list = ["put","get","ls","cd","mk","delete","quit"]
        command_inp = input(msg).strip()
        if command_inp == "ls":
            return_command = "{0}|".format(command_inp)
            flag = True
        elif command_inp == "quit":
            return_command = command_inp
            flag = True
        else:
            if command_inp.count("|") != 1:
                message("输入命令不合法！","ERROR")
            else:
                #获取命令
                cmd,args = command_inp.strip().lower().split("|")
                if cmd not in command_list:
                    message("输入命令不合法！", "ERROR")
                else:
                    return_command = "{0}|{1}".format(cmd, args)
                    flag = True
    return return_command

•  部分效果展示图

• ［备注］：完整代码详见：

  Hithub: https://github.com/yingoja/FTPServer