断点传续 # 补充 mysql

断点传续   # 补充 mysql

断点续传

任务进行过程中,由于某些原因导致任务没有完成
在重新启动程序之后 可以接着上次断掉的位置继续传输

===========    ================  服务器
=========== 50
               ================


1.客户端  需下载某个文件
    输入一个文件名称
    判断该文件是否已经下载
    判断文件是否传输完毕
    一个任务存在的状态


    1.新任务   本地没有
        文件不存在   并且任务记录中也不存在
    2.任务未完成  本地有 但是不完整
        文件已经存在 但是任务记录标记为未完成
    3.任务已完成  本地有完整的数据
         文件已经存在 任务标记为已完成
    4.任务已经完成 但是数据被删除
         文件不存在  任务标记为完成

    任务记录?
        新任务 需要添加到记录中   未完成
        下载完成 修改记录为完成
        需要哪些数据?
            任务名称
                文件名称
            状态
                未完成
                已完成
        {"name":False}

        字典存储任务 需要永久存储



使用方法
将测试文件放在服务器的 serverFiles中

{"5.u534fu7a0b.mp4": true}

import json
import os
import socket

import struct

import logging

server = socket.socket()

server.bind(("127.0.0.1",1688))
server.listen()


def recv_head(client):
    head_len = client.recv(4)
    if not head_len:
        raise Exception("对方下线了!")
    lens = struct.unpack("i",head_len)[0]
    req = json.loads(client.recv(lens).decode("utf-8"))
    return req


def send_rep(client,rep):
    jdata = json.dumps(rep).encode("utf-8")
    client.send(struct.pack("i",len(jdata)))
    client.send(jdata)

while True:
    client,addr = server.accept()
    while True:
        try:
            req = recv_head(client)
            # rep中必须包含 文件名称
            filename = req["filename"]


            path = os.path.join("serverFiles",filename)
            if not os.path.exists(path):
                rep = {"msg":"服务器不存在该文件!"}
                send_rep(client,rep)
            else:
                # 发送文件信息
                info = {"filename":filename,"filesize":os.path.getsize(path)}
                send_rep(client,info)

                # 发送文件数据
                with open(path,"rb") as f:
                    f.seek(req["recv_size"],0)
                    while True:
                        data = f.read(2048)
                        if not data :break
                        client.send(data)
                # 文件传输完毕
                print("文件传输完毕!")
                client.close()
                break
        except Exception as e:
            logging.error(e)
            client.close()
            break

import os

import time
from mylib import *
import socket















# 用于处理任务状态的工具类
class LogTool:
    # 日志记录的文件名称
    log_file = "file_log.txt"
    #　初始化方法
    def __init__(self):
        #创建 记录文件
        if not os.path.exists(self.log_file):
            self.write_info({})

    # 用于获取文件状态的方法
    def get_file_status(self,filename):
        """
        :param filename:
        :return: 1 表示完成  0 已存在但表示未完成  2 新任务  3 文件被删除
        """
        # 先找任务记录看看
        info = self.read_info()
        if filename in info:  #存在记录
            if info[filename]:
                # 记录显示为True 在判断文件是否已经存在
                if os.path.exists(os.path.join("clientFiles",filename)):
                    return 1
                else:
                    return 3
            else:
                return 0
        else:# 不存在记录
            return 2

    def read_info(self):
        with open(self.log_file,"rt") as f:
            return json.load(f)

    def write_info(self,info):
        with open(self.log_file,"wt") as f:
            json.dump(info,f)

    # 添加新的新记录
    def newtask(self,filename):
        info = self.read_info()
        info[filename] = False
        self.write_info(info)

    #标记为任务完成
    def task_done(self, filename):
        info = self.read_info()
        info[filename] = True
        self.write_info(info)


# =======================================TCP 部分





# 输入文件名称
filename = input("filename:").strip()

# 创建小工具
tool = LogTool()

# 获取任务的状态
st = tool.get_file_status(filename)
# "  :return: 1 表示完成  0 已存在但表示未完成  2 新任务  3 文件被删除"

# 表示已经下载的大小
recv_size = 0

if st == 0:
    # 要断点续传 要读取文件大小发给服务器
    recv_size = os.path.getsize(os.path.join("clientFiles",filename))
elif st == 1:
    print("该任务已经完成!")
    exit()
elif st == 2:
    print("新任务")
else:
    if input("文件被删除!是否重新下载?(y/n)") != "y":
        exit()

# 信息中要包含已接受文件大小
info = {"filename":filename,"recv_size":recv_size}


client = socket.socket()
client.connect(("127.0.0.1",1688))

# 发送报头信息
send_rep(client,info)

# 接收报头信息
rep = recv_head(client)


#　判断是文件信息还是错误信息　
if "filename" in rep:
    # 拼接文件路径
    path = os.path.join("clientFiles", rep["filename"])


    buff_size = 2048

    # 添加下载记录
    tool.newtask(filename)

    # 注意 必须使用ab模式 才能断点续传
    with open(path,"ab") as f:
        while recv_size < rep["filesize"]:
            if buff_size < rep["filesize"] - recv_size:
                data = client.recv(buff_size)
            else:
                data = client.recv(rep["filesize"] - recv_size)
            f.write(data)
            recv_size += len(data)
            # print(recv_size/rep["filesize"])

    # 标记完成
    tool.task_done(filename)

else:
    print("error")
    print(rep)







# 发送文件报头

import json
import struct
def recv_head(client):
    head_len = client.recv(4)
    if not head_len:
        raise Exception("对方下线了!")
    lens = struct.unpack("i", head_len)[0]
    req = json.loads(client.recv(lens).decode("utf-8"))
    return req


def send_rep(client,rep):
    jdata = json.dumps(rep).encode("utf-8")
    client.send(struct.pack("i",len(jdata)))
    client.send(jdata)