断点续传与个人网盘系统的前后端设计

// 前端vue-simple-uploader配置项
options: {
  target: (instance, chunk, isTest) => isTest ? '/api/storage/testUpload' : '/api/storage/upload',  query: () => {
    return {
      targetPath: this.currentPath
    }
  },
  chunkSize: CHUNK_SIZE,
  allowDuplicateUploads: false,
  checkChunkUploadedByResponse: (chunk, message) => {
    const response = JSON.parse(message)
    const existChunk = response.data.map(item => ~~item)
    return existChunk.includes(chunk.offset + 1)  }
}

router.get('/testUpload', async ctx => {
  const { identifier, filename, targetPath = '$Root', totalChunks } = ctx.query
  const chunkFolderURL = `${storageChunkPath}/${identifier}`
  try {
    const checkExistResult = await query(`select * from storage where id = ? and isComplete = 1 and isDel = 0`, identifier)
    // 检查是否已经完整上传过该文件
    if (checkExistResult.length > 0) {
      let { fullPath } = checkExistResult[0]
      let realPath = fullPath.replace('$Root', storageRootPath)
      // 检查当前DB信息是否与物理存储相符
      if (fs.existsSync(realPath)) {
        // 检查目标位置是否与之前上传的位置一样，不一致则复制过去
        let targetFilePath = `${targetPath}/${filename}`
        if (fullPath !== targetFilePath) {
          targetFilePath = targetFilePath.replace('$Root', storageRootPath)
          fs.copyFileSync(realPath, targetFilePath)
        }
        // 返回全部分片数组
        const chunksArr = Array.from({ length: totalChunks }, (item, index) => index + 1)        ctx.body = r.successData(chunksArr)
        return
      }
    }
    if (!fs.existsSync(chunkFolderURL)) {
      fs.mkdirSync(chunkFolderURL, { recursive: true })
      const now = DateFormat(new Date(), 'yyyy-MM-dd HH:mm:ss')
      const sql = `replace into storage(id, fullPath, updatedTime, isComplete, isDel) values(?, ?, ?, 0, 0)`
      await query(sql, [identifier, `${targetPath}/${filename}`, now])
      ctx.body = r.successData([])
    } else {
      const ls = fs.readdirSync(chunkFolderURL)
      ctx.body = r.successData(ls)
    }
  } catch (e) {
    ctx.status = 501
    ctx.body = r.error(306, e)
  }
})

router.post('/upload', async ctx => {
  const { chunkNumber, identifier, filename, totalChunks, targetPath = '$Root' } = ctx.request.body
  const { file } = ctx.request.files
  const chunkFolderURL = `./public/storage-chunk/${identifier}`
  const chunkFileURL = `${chunkFolderURL}/${chunkNumber}`
  if (chunkNumber !== totalChunks) {
    const reader = fs.createReadStream(file.path)    const upStream = fs.createWriteStream(chunkFileURL)    reader.pipe(upStream)    ctx.body = r.success()
  } else {
    const targetFile = `${targetPath}/${filename}`.replace('$Root', storageRootPath)
    fs.writeFileSync(targetFile, '')
    try {
      for (let i = 1; i <= totalChunks; i++) {
        const url = i == totalChunks ? file.path : `${chunkFolderURL}/${i}`
        const buffer = fs.readFileSync(url)
        fs.appendFileSync(targetFile, buffer)
      }
      const now = DateFormat(new Date(), 'yyyy-MM-dd HH:mm:ss')
      const sql = `update storage set isComplete = 1, updatedTime = ? where id = ?`
      await query(sql, [now, identifier])
      ctx.body = r.success()
      deleteFolder(chunkFolderURL)
      logger('文件上传成功', 1, `targetFile: ${targetFile}, MD5:${identifier}, 切片源删除成功`)
    } catch (e) {
      ctx.status = 501
      ctx.body = r.error(501, e)
      logger('文件合并失败', 0, `分片丢失 => ${e}`)
      fs.unlinkSync(targetFile)    }
  }
})