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("關閉服務器")

    上面代碼是服務器端，客戶端與服務器端實際上是相呼應的，二者實現數據的交換；其實就是收發數據，中間摻雜咱們想要實現的功能。

    下面來看幾個容易犯錯的地方：

    一、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
文件接收成功！
請輸入指令>>：客戶端斷開!!! 

    從上面代碼能夠看出，咱們實現了持續的數據交換狀況，沒有發生太大的問題。

    二、反射的時候，反射是判斷類中是否具備某種方法，hasattr(),getattr()是最常使用的方法；

    三、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打開文件具備自動關閉文件的特性，當文件遍歷完成以後，就會自動關閉文件。

　　建議使用第二種方式，第二種方式就會杜絕這種狀況，讓程序可以即完成比較，由遍歷完成文件。

    四、socketserver與socket的區別，其實二者本質都是同樣的，原則上都是交互一次結束，只是socketserver封裝了不少方法，可以實現不相互干擾下的交互；

    五、文件傳輸，要告知文件大小，方便接收，json的使用，序列化，讓彼此接受的時候，容易獲得以前存儲的結果；

    六、規範化封裝；