day8--socketserver作业

fileno()文件描述符

handle_request()处理单个请求

server_forever(poll_interval=0.5)处理多个请求，poll_interval每0.5秒检测是否关闭，

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

要求：

    1.用户加密认证；

    2.允许同时多用户登录；

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

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

    5.允许用户在ftp.server上随意切换目录；

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

    7.允许上传和下载文件，保证文件一致性；

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

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

发送文件的大致思路：

接收文件的大致思路：

遍历空的文件，如果一个文件是空的，Python是不会执行后面缩进的代码的，空的文件。

http://www.cnblogs.com/liujiacai/p/7417953.html

http://www.cnblogs.com/lianzhilei/p/5869205.html

http://www.bubuko.com/infodetail-1758633.html

    由于不是做运维的，对一些系统的操作不是很熟悉，因此首先完成了文件的上传与下载：下面来看看这两个功能：

   

    客户端：

import socket,os,json,sys


class Myclient(object):
    '''定义客户端'''
    def __init__(self):
        '''定义socket()实例'''
        self.client = socket.socket()                                         #生成soket()实例

    def connect(self,ip,port):
        """定义连接"""
        self.client.connect((ip,port))

    def interactive(self):
        '''定义和用户交互'''
        while True:
            cmd = input("请输入指令>>：").strip()                              #用户输入指令
            if len(cmd) == 0:
                print("指令不能为空!!!")
                continue                                                      #指令不能为空
            cmd_str = cmd.split()[0]                                          #指令由两种形式
            if hasattr(self,cmd_str):                                         #判断指令是否存在
                func = getattr(self,cmd_str)                                  #指令存在，则获取对应的方法
                func(cmd)
            elif cmd_str == 'q':
                break
            else:
                self.help()
                continue


    def help(self):
        msg = """
        ls
        pwd
        cd
        put   filename
        get   filename
        """
        print("指令名称",msg)

    def put(self,cmd):
        '''定义上传数据接口'''
        cmd_list = cmd.split()
        if len(cmd_list) > 1:
            '''指令是由指令名和文件名构成'''
            filename = cmd_list[1]                                              #获取文件名
            if os.path.isfile(filename):                                        #检测上传的文件名是否存在
                '''文件名存在，则要告诉服务器端上传的文件名，文件大小，并检测服务器是否有相应的方法'''
                filesize = os.stat(filename).st_size
                msg_dic = {
                    "action":"put",
                    "filename":filename,
                    "filesize":filesize
                }
                '''转换为字节码的形式进行传输'''
                self.client.send(json.dumps(msg_dic).encode("utf-8"))           #转换为json格式进行上传，便于服务器接收后处理
                server_response = self.client.recv(1024)                        #等待服务器传回信息，防止粘包
                self.client.send("收到了".encode("utf-8"))
                if int(server_response.decode("utf-8")):
                    '''根据客户端反馈，服务器端是否存在相同的文件名'''
                    file_exist = int(self.client.recv(1024).decode("utf-8"))
                    if file_exist:
                        '''服务器端存在相应的文件'''
                        while True:
                            cover_flag = input("文件已存在，是否覆盖原文件(y/n)：")
                            if cover_flag == "y":
                                self.client.send("y".encode("utf-8"))
                                break
                            elif cover_flag == "n":
                                new_filename = input("请输入新的文件名>>：")
                                self.client.send(("n "+new_filename).encode("utf-8"))
                                break
                            else:
                                print("您输入的指令有误，请重新输入！！！")
                                continue
                    else:
                        self.client.send("新创建".encode("utf-8"))

                    '''上面准备工作完毕，开始传输文件'''
                    with open(filename,'rb') as f:
                        for line in f:
                            self.client.send(line)                                  #发送数据
                    '''客户端等待服务器端传来消息，告知上传成功'''
                    response = self.client.recv(1024)
                    print(response.decode("utf-8"))                                 #数据是否上传成功，告知用户
                else:
                    print("服务器端不存在相应的指令!!!")

            else:
                print("要上传的文件名不存在！")


        else:
            print("没有输入要上传的文件名！！！")

    def get(self,cmd):
        '''从服务器端下载数据'''
        cmd_list = cmd.split()                                                    #获取用户输入指令
        if len(cmd_list) > 1:                                                     #是由指令和文件名构成
            filename = cmd_list[1]
            msg_dic = {
                "filename":filename,
                "action":"get"
            }                                                                     #把指令封装成字典发送给服务器
            self.client.send(json.dumps(msg_dic).encode("utf-8"))                 #把指令以json形式传给服务器
            server_response = int(self.client.recv(1024).decode("utf-8"))         #接收服务端发挥的指令，判断是否支持此方法
            self.client.send("收到指令!".encode("utf-8"))
            if server_response:
                file_exists = int(self.client.recv(1024).decode("utf-8"))         #下载文件存在与否标识符
                self.client.send("收到标识符".encode("utf-8"))                     #告知服务器收到标识符，防止粘包
                if file_exists:
                    '''文件存在，则准备接收数据，会接收服务器发送过来的文件大小'''
                    file_mess = json.loads(self.client.recv(3072).decode("utf-8"))
                    self.client.send("文件信息接收成功，开始进行文件接收！".encode("utf-8"))
                    filesize = file_mess["filesize"]
                    while True:
                        '''确定文件名'''
                        if os.path.isfile(filename):
                            '''说明客户端存在文件，就要让用户选择是否覆盖'''
                            choice_cover = input("文件名重复，是否覆盖现有文件(y/n)>>：")
                            if choice_cover == "y":
                                filename = filename
                                break                                       #覆盖文件之后退出循环
                            elif choice_cover == "n":
                                filename = input("请输入新的文件名>>：")
                                '''由于用户输入了新的用户名，我们不知道此文件是否重名，因此重新检测一下，确保不重名'''
                                continue
                        else:
                            filename = filename
                            break                                           #得到文件名之后退出循环
                    recvive_size = 0
                    with open(filename,'wb') as file:
                        while recvive_size < filesize:
                            data = self.client.recv(1024)
                            file.write(data)
                            recvive_size += len(data)
                        print("数据下载完成！！！")
                        self.client.send("接收完毕".encode("utf-8"))
                else:
                    print("要下载的文件不存在！！！")

            else:
                print("服务器不支持此功能！！！")

        else:
            print("对不起，输入有误！")
            self.help()

if __name__ == "__main__":
    try:
        client = Myclient()
        client.connect("localhost",9998)
        client.interactive()
    except KeyboardInterrupt as e:
        print("客户端断开!!!",e)

    上面客户端只实现了上传和下载功能，没有实现其他系统操作有关的功能，后续将逐步完善；

    服务器端：

'''定义服务器端'''
import socketserver,json,os

class MyTcpServer(socketserver.BaseRequestHandler):
    '''定义服务器端，socketserver，继承的是BaseRequestHandler类'''
    def handle(self):
        '''服务器端所有的功能都在handle()里面进行处理，因此接收数据也是在handle()中，只是处理的时候，调用下面模块而已'''
        while True:
            data = self.request.recv(3072)
            if len(data) == 0:
                print("客户端断开")
                break
            msg_dic = json.loads(data.decode("utf-8"))            #服务器端接收指令
            cmd = msg_dic["action"]
            if hasattr(self,cmd):                                                    #判断服务器是否有相应的指令
                self.request.send("1".encode("utf-8"))
                self.request.recv(1024)
                func = getattr(self,cmd)
                func(msg_dic)
            else:
                self.request.send("0".encode("utf-8"))
                self.request.recv(1024)

    def put(self,msg_dic):
        '''定义上传的服务器代码'''
        filename = msg_dic['filename']
        filesize = msg_dic["filesize"]
        '''判断服务器端是否存在对应的文件名'''
        recvive_size = 0
        if os.path.isfile(filename):
            '''如果服务器存在相应的文件名，则询问客户端是否覆盖'''
            self.request.send("1".encode("utf-8"))                              #文件存在，循环客户端是否覆盖
            response = self.request.recv(1024).decode("utf-8")
            response = response.split()
            '''如果用户让覆盖则覆盖，否则重新创建'''

            if response[0] == "y":
                '''覆盖'''
                with open(filename,"wb") as f1:
                   while recvive_size < filesize:
                       data = self.request.recv(1024)
                       f1.write(data)
                       recvive_size += len(data)
                self.request.send("文件接收成功！".encode("utf-8"))

            else:
                '''不覆盖,新创建'''
                new_filename = response[1]
                with open(new_filename,'wb') as f:
                    while recvive_size < filesize:
                        data1 = self.request.recv(1024)
                        f.write(data1)
                        recvive_size += len(data1)
                self.request.send("文件接收成功！".encode("utf-8"))

        else:
            '''如果服务器不存在相应文件名，则创建'''
            self.request.send("0".encode("utf-8"))
            self.request.recv(1024)
            with open(filename,'wb') as f2:
                while recvive_size < filesize:
                    data1 = self.request.recv(1024)
                    f2.write(data1)
                    recvive_size += len(data1)
            self.request.send("文件接收成功！".encode("utf-8"))

    def get(self,msg_dict):
        '''基础交流结束，服务器支持文件下载功能，开始文件下载操作'''
        filename = msg_dict["filename"]
        if os.path.isfile(filename):
            self.request.send("1".encode("utf-8"))                             #文件存在告知客户端
            self.request.recv(1024)
            filesize = os.stat(filename).st_size
            '''首先告知客户端文件大小，让这边做好接收准备'''
            file_mess = {
                "filesize":filesize,
            }
            self.request.send(json.dumps(file_mess).encode("utf-8"))           #以json格式发送给客户端
            self.request.recv(1024)                                            #防止粘包，客户端回应服务器接收完毕
            with open(filename,"rb") as f_obj:
                for line in f_obj:
                    self.request.send(line)
            self.request.recv(1024)

        else:
            self.request.send("0".encode("utf-8"))                             #文件不存在，告知客户端
            self.request.recv(1024)

if __name__ == "__main__":
    try:
        IP,PORT = "localhost",9998
        server = socketserver.ThreadingTCPServer((IP,PORT),MyTcpServer)              #定义socketserver实例
        server.serve_forever()
    except KeyboardInterrupt as e:
        print("关闭服务器")

    上面代码是服务器端，客户端与服务器端其实是相呼应的，两者实现数据的交换；其实就是收发数据，中间掺杂我们想要实现的功能。

    下面来看几个容易犯错的地方：

    1、BrokenPipeError: [Errno 32] Broken pipe

　　客户端代码：

import socket,os,json,sys


class Myclient(object):
    '''定义客户端'''
    def __init__(self):
        '''定义socket()实例'''
        self.client = socket.socket()                                         #生成soket()实例

    def connect(self,ip,port):
        """定义连接"""
        self.client.connect((ip,port))

    def interactive(self):
        '''定义和用户交互'''
        while True:
            cmd = input("请输入指令>>：").strip()                              #用户输入指令
            if len(cmd) == 0:
                print("指令不能为空!!!")
                continue                                                      #指令不能为空
            cmd_str = cmd.split()[0]                                          #指令由两种形式
            if hasattr(self,cmd_str):                                         #判断指令是否存在
                func = getattr(self,cmd_str)                                  #指令存在，则获取对应的方法
                func(cmd)
            elif cmd_str == 'q':
                break
            else:
                self.help()
                continue


    def help(self):
        msg = """
        ls
        pwd
        cd
        put   filename
        get   filename
        """
        print("指令名称",msg)

    def put(self,cmd):
        '''定义上传数据接口'''
        cmd_list = cmd.split()
        if len(cmd_list) > 1:
            '''指令是由指令名和文件名构成'''
            filename = cmd_list[1]                                              #获取文件名
            if os.path.isfile(filename):                                        #检测上传的文件名是否存在
                '''文件名存在，则要告诉服务器端上传的文件名，文件大小，并检测服务器是否有相应的方法'''
                filesize = os.stat(filename).st_size
                msg_dic = {
                    "action":"put",
                    "filename":filename,
                    "filesize":filesize
                }
                '''转换为字节码的形式进行传输'''
                self.client.send(json.dumps(msg_dic).encode("utf-8"))           #转换为json格式进行上传，便于服务器接收后处理
                server_response = self.client.recv(1024)                        #等待服务器传回信息，防止粘包
                self.client.send("收到了".encode("utf-8"))
                if int(server_response.decode("utf-8")):
                    '''根据客户端反馈，服务器端是否存在相同的文件名'''
                    file_exist = int(self.client.recv(1024).decode("utf-8"))
                    if file_exist:
                        '''服务器端存在相应的文件'''
                        while True:
                            cover_flag = input("文件已存在，是否覆盖原文件(y/n)：")
                            if cover_flag == "y":
                                self.client.send("y".encode("utf-8"))
                                break
                            elif cover_flag == "n":
                                new_filename = input("请输入新的文件名>>：")
                                self.client.send(("n "+new_filename).encode("utf-8"))
                                break
                            else:
                                print("您输入的指令有误，请重新输入！！！")
                                continue
                    else:
                        self.client.send("新创建".encode("utf-8"))

                    '''上面准备工作完毕，开始传输文件'''
                    with open(filename,'rb') as f:
                        for line in f:
                            self.client.send(line)                                  #发送数据
                    '''客户端等待服务器端传来消息，告知上传成功'''
                    response = self.client.recv(1024)
                    print(response.decode("utf-8"))                                 #数据是否上传成功，告知用户
                else:
                    print("服务器端不存在相应的指令!!!")

            else:
                print("要上传的文件名不存在！")


        else:
            print("没有输入要上传的文件名！！！")

    def get(self,cmd):
        '''从服务器端下载数据'''
        cmd_list = cmd.split()                                                    #获取用户输入指令
        if len(cmd_list) > 1:                                                     #是由指令和文件名构成
            filename = cmd_list[1]
            msg_dic = {
                "filename":filename,
                "action":"get"
            }                                                                     #把指令封装成字典发送给服务器
            self.client.send(json.dumps(msg_dic).encode("utf-8"))                 #把指令以json形式传给服务器
            server_response = int(self.client.recv(1024).decode("utf-8"))         #接收服务端发挥的指令，判断是否支持此方法
            self.client.send("收到指令!".encode("utf-8"))
            if server_response:
                file_exists = int(self.client.recv(1024).decode("utf-8"))         #下载文件存在与否标识符
                self.client.send("收到标识符".encode("utf-8"))                     #告知服务器收到标识符，防止粘包
                if file_exists:
                    '''文件存在，则准备接收数据，会接收服务器发送过来的文件大小'''
                    file_mess = json.loads(self.client.recv(3072).decode("utf-8"))
                    self.client.send("文件信息接收成功，开始进行文件接收！".encode("utf-8"))
                    filesize = file_mess["filesize"]
                    while True:
                        '''确定文件名'''
                        if os.path.isfile(filename):
                            '''说明客户端存在文件，就要让用户选择是否覆盖'''
                            choice_cover = input("文件名重复，是否覆盖现有文件(y/n)>>：")
                            if choice_cover == "y":
                                filename = filename
                                break                                       #覆盖文件之后退出循环
                            elif choice_cover == "n":
                                filename = input("请输入新的文件名>>：")
                                '''由于用户输入了新的用户名，我们不知道此文件是否重名，因此重新检测一下，确保不重名'''
                                continue
                        else:
                            filename = filename
                            break                                           #得到文件名之后退出循环
                    recvive_size = 0
                    with open(filename,'wb') as file:
                        while recvive_size < filesize:
                            data = self.client.recv(1024)
                            file.write(data)
                            recvive_size += len(data)
                        print("数据下载完成！！！")
                        self.client.send("接收完毕".encode("utf-8"))
                else:
                    print("要下载的文件不存在！！！")

            else:
                print("服务器不支持此功能！！！")

        else:
            print("对不起，输入有误！")
            self.help()

if __name__ == "__main__":
    try:
        client = Myclient()
        client.connect("localhost",9998)
        client.interactive()
    except KeyboardInterrupt as e:
        print("客户端断开!!!",e)

    服务器端：

'''定义服务器端'''
import socketserver,json,os

class MyTcpServer(socketserver.BaseRequestHandler):
    '''定义服务器端，socketserver，继承的是BaseRequestHandler类'''
    def handle(self):
        '''服务器端所有的功能都在handle()里面进行处理，因此接收数据也是在handle()中，只是处理的时候，调用下面模块而已'''
        # while True:
        data = self.request.recv(3072)
        if len(data) == 0:
            print("客户端断开")
                # break
        msg_dic = json.loads(data.decode("utf-8"))            #服务器端接收指令
        cmd = msg_dic["action"]
        if hasattr(self,cmd):                                                    #判断服务器是否有相应的指令
            self.request.send("1".encode("utf-8"))
            self.request.recv(1024)
            func = getattr(self,cmd)
            func(msg_dic)
        else:
            self.request.send("0".encode("utf-8"))
            self.request.recv(1024)

    def put(self,msg_dic):
        '''定义上传的服务器代码'''
        filename = msg_dic['filename']
        filesize = msg_dic["filesize"]
        '''判断服务器端是否存在对应的文件名'''
        recvive_size = 0
        if os.path.isfile(filename):
            '''如果服务器存在相应的文件名，则询问客户端是否覆盖'''
            self.request.send("1".encode("utf-8"))                              #文件存在，循环客户端是否覆盖
            response = self.request.recv(1024).decode("utf-8")
            response = response.split()
            '''如果用户让覆盖则覆盖，否则重新创建'''

            if response[0] == "y":
                '''覆盖'''
                with open(filename,"wb") as f1:
                   while recvive_size < filesize:
                       data = self.request.recv(1024)
                       f1.write(data)
                       recvive_size += len(data)
                self.request.send("文件接收成功！".encode("utf-8"))

            else:
                '''不覆盖,新创建'''
                new_filename = response[1]
                with open(new_filename,'wb') as f:
                    while recvive_size < filesize:
                        data1 = self.request.recv(1024)
                        f.write(data1)
                        recvive_size += len(data1)
                self.request.send("文件接收成功！".encode("utf-8"))

        else:
            '''如果服务器不存在相应文件名，则创建'''
            self.request.send("0".encode("utf-8"))
            self.request.recv(1024)
            with open(filename,'wb') as f2:
                while recvive_size < filesize:
                    data1 = self.request.recv(1024)
                    f2.write(data1)
                    recvive_size += len(data1)
            self.request.send("文件接收成功！".encode("utf-8"))

    def get(self,msg_dict):
        '''基础交流结束，服务器支持文件下载功能，开始文件下载操作'''
        filename = msg_dict["filename"]
        if os.path.isfile(filename):
            self.request.send("1".encode("utf-8"))                             #文件存在告知客户端
            self.request.recv(1024)
            filesize = os.stat(filename).st_size
            '''首先告知客户端文件大小，让这边做好接收准备'''
            file_mess = {
                "filesize":filesize,
            }
            self.request.send(json.dumps(file_mess).encode("utf-8"))           #以json格式发送给客户端
            self.request.recv(1024)                                            #防止粘包，客户端回应服务器接收完毕
            with open(filename,"rb") as f_obj:
                for line in f_obj:
                    self.request.send(line)
            self.request.recv(1024)

        else:
            self.request.send("0".encode("utf-8"))                             #文件不存在，告知客户端
            self.request.recv(1024)

if __name__ == "__main__":
    try:
        IP,PORT = "localhost",9998
        server = socketserver.ThreadingTCPServer((IP,PORT),MyTcpServer)              #定义socketserver实例
        server.serve_forever()
    except KeyboardInterrupt as e:
        print("关闭服务器")

    上面代码是我遇到的坑，客户端没有变，只变了服务器端接收的代码，因为socketserver.serve_forever()持续的响应链接。结果客户端输入命令如下：

请输入指令>>：gcx
指令名称 
        ls
        pwd
        cd
        put   filename
        get   filename
        
请输入指令>>：put gcx
文件已存在，是否覆盖原文件(y/n)：y
文件接收成功！
请输入指令>>：put gcx
Traceback (most recent call last):
  File "/home/zhuzhu/day8作业/FTP/Ftpclient/ftp_client.py", line 154, in <module>
    client.interactive()
  File "/home/zhuzhu/day8作业/FTP/Ftpclient/ftp_client.py", line 24, in interactive
    func(cmd)
  File "/home/zhuzhu/day8作业/FTP/Ftpclient/ftp_client.py", line 59, in put
    self.client.send("收到了".encode("utf-8"))
BrokenPipeError: [Errno 32] Broken pipe

    上面客户端执行结果可以看出，第一次执行没有问题，程序成功的接收到了服务器下载的数据，但是第二次操作的时候，开始报错，提示BrokenPipeError，这是什么错误呢？
　　ThreadingHTTPServer 实现的 http 服务，如果客户端在服务器返回前，主动断开连接，则服务器端会报 [Errno 32] Broken pipe 错，并导致处理线程 crash.

    上面说明，我们交互一次之后，服务器端已经断开了，不是说socketserver()的客户端一直处在活跃状态吗？是处在活跃状态没错，但是上一个链接其实已经断开了，这是socket的特性，如果没有程序接收数据，接收一次就会断开，因此要修改接收的代码，如下：

class MyTcpServer(socketserver.BaseRequestHandler):
    '''定义服务器端，socketserver，继承的是BaseRequestHandler类'''
    def handle(self):
        '''服务器端所有的功能都在handle()里面进行处理，因此接收数据也是在handle()中，只是处理的时候，调用下面模块而已'''
        while True:
            data = self.request.recv(3072)
            if len(data) == 0:
                print("客户端断开")
                break
            msg_dic = json.loads(data.decode("utf-8"))            #服务器端接收指令
            cmd = msg_dic["action"]
            if hasattr(self,cmd):                                                    #判断服务器是否有相应的指令
                self.request.send("1".encode("utf-8"))
                self.request.recv(1024)
                func = getattr(self,cmd)
                func(msg_dic)
            else:
                self.request.send("0".encode("utf-8"))
                self.request.recv(1024)

    上面只需修改handle()中的代码，让服务器端能够持续不断的接收数据，如上面代码所示，加上一个while循环，让服务器能够不断接收此链接的信息，除非这个链接断开，否则是不会终端这个链接与服务端的交互，socketserver()实现的功能时多个客户端与服务端能够同时进行交互，使其相互之间不受影响，本质上单个客户端与服务器之间的交互还是基础的socket实现的，如果不持续的接收，那么交互一次就会断开。

    上面的交互如下所示：

请输入指令>>：put gcx
文件已存在，是否覆盖原文件(y/n)：y
文件接收成功！
请输入指令>>：put zmz
文件已存在，是否覆盖原文件(y/n)：y
文件接收成功！
请输入指令>>：put gcx
文件已存在，是否覆盖原文件(y/n)：y
文件接收成功！
请输入指令>>：客户端断开!!! 

    从上面代码可以看出，我们实现了持续的数据交换情况，没有发生太大的问题。

    2、反射的时候，反射是判断类中是否具有某种方法，hasattr(),getattr()是最常使用的方法；

    3、while a < b:

　　　　  with open(filename) as f:

　　　　　　  for line in f

    与

　　wiht open(filename) as f:

　　　　while a < b:

　　　　　　for line in f

    上面两种写法是不一样的，为什么说呢，第一种方法，当文件遍历玩的时候，不管条件成立与否，文件都是要关闭的，这是因为with打开文件具有自动关闭文件的特性，当文件遍历完成之后，就会自动关闭文件。

　　建议使用第二种方式，第二种方式就会杜绝这种情况，让程序能够即完成比较，由遍历完成文件。

    4、socketserver与socket的区别，其实两者本质都是一样的，原则上都是交互一次结束，只是socketserver封装了很多方法，能够实现不相互干扰下的交互；

    5、文件传输，要告知文件大小，方便接收，json的使用，序列化，让彼此接受的时候，容易得到之前存储的结果；

    6、规范化封装；