Update index.js

index.js

@@ -17,6 +17,42 @@ const createRequestWithCancel = (cancelToken) => {
   }
 }
 
+// 完整下载文件（用于不支持范围请求的情况）
+async function downloadFullFileWithRetry(request, finalUrl, maxRetries = 30) {
+  let lastError = null
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await request.get(finalUrl, {
+        responseType: 'arraybuffer'
+      })
+
+      if (response.status !== 200) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+      }
+
+      console.log(`完整文件下载成功 (尝试 ${attempt})`)
+      return response.data
+
+    } catch (error) {
+      if (http.isCancel(error)) {
+        throw error
+      }
+
+      lastError = error
+      console.warn(`完整文件下载失败 (尝试 ${attempt}/${maxRetries}):`, error.message)
+
+      if (attempt < maxRetries) {
+        const waitTime = 300
+        console.log(`等待 ${waitTime}ms 后重试完整下载`)
+        await new Promise(resolve => setTimeout(resolve, waitTime))
+      }
+    }
+  }
+
+  throw new Error(`完整文件下载失败，已达到最大重试次数: ${lastError.message}`)
+}
+
 // 带重试功能的分片下载函数
 async function downloadChunkWithRetry(request, finalUrl, start, end, partNumber, maxRetries = 30) {
   let lastError = null
@@ -44,7 +80,6 @@ async function downloadChunkWithRetry(request, finalUrl, start, end, partNumber,
       return arrayBuffer
 
     } catch (error) {
-      // 如果是取消请求，直接抛出
       if (http.isCancel(error)) {
         throw error
       }
@@ -53,8 +88,6 @@ async function downloadChunkWithRetry(request, finalUrl, start, end, partNumber,
       console.warn(`分片 ${partNumber} 下载失败 (尝试 ${attempt}/${maxRetries}):`, error.message)
 
       if (attempt < maxRetries) {
-        // 指数退避策略，等待时间逐渐增加
-        // const waitTime = Math.min(500 * Math.pow(2, attempt - 1), 5000)
         const waitTime = 300
         console.log(`等待 ${waitTime}ms 后重试分片 ${partNumber}`)
         await new Promise(resolve => setTimeout(resolve, waitTime))
@@ -103,7 +136,6 @@ async function uploadChunkWithRetry(request, uploadUrl, arrayBuffer, partNumber,
         throw new Error(`CRC32 校验失败: 期望 ${crc32_text}, 实际 ${upload_result.data.data?.crc32}`)
       }
     } catch (error) {
-      // 如果是取消请求，直接抛出
       if (http.isCancel(error)) {
         throw error
       }
@@ -112,7 +144,6 @@ async function uploadChunkWithRetry(request, uploadUrl, arrayBuffer, partNumber,
       console.warn(`分片 ${partNumber}  ${upload_host} (尝试 ${attempt}/${maxRetries}):`, error.message)
 
       if (attempt < maxRetries) {
-        // const waitTime = Math.min(500 * Math.pow(2, attempt - 1), 5000)
         const waitTime = 300
         console.log(`等待 ${waitTime}ms 后重试上传分片 ${partNumber}`)
         await new Promise(resolve => setTimeout(resolve, waitTime))
@@ -129,7 +160,6 @@ async function runWithConcurrency(tasks, maxConcurrency = 50, cancelToken) {
   const executing = new Set()
 
   for (let i = 0; i < tasks.length; i++) {
-    // 检查是否已取消
     if (cancelToken && cancelToken.reason) {
       console.log('检测到取消信号，停止创建新任务')
       break
@@ -137,7 +167,6 @@ async function runWithConcurrency(tasks, maxConcurrency = 50, cancelToken) {
 
     const task = tasks[i]
 
-    // 如果当前执行的任务数达到最大并发数，等待其中一个完成
     if (executing.size >= maxConcurrency) {
       await Promise.race(executing)
     }
@@ -154,16 +183,13 @@ async function runWithConcurrency(tasks, maxConcurrency = 50, cancelToken) {
     results.push(promise)
   }
 
-  // 等待所有剩余任务完成
   return Promise.allSettled(results)
 }
 
 app.get('*', async (req, res) => {
-  // 创建取消令牌
   const cancelTokenSource = http.CancelToken.source()
   let isRequestCancelled = false
 
-  // 监听连接关闭事件
   req.on('close', () => {
     if (!res.headersSent) {
       console.log('用户断开连接，取消所有请求...')
@@ -174,11 +200,11 @@ app.get('*', async (req, res) => {
 
   try {
     const videoUrl = req.originalUrl.replace(/^\//, '')
+    console.log(videoUrl)
     if (/favicon.ico/gim.test(videoUrl)) {
       return
     }
 
-    // 创建带取消令牌的请求实例
     const request = createRequestWithCancel(cancelTokenSource.token)
 
     // 获取上传信息
@@ -193,7 +219,6 @@ app.get('*', async (req, res) => {
     const uploadid = upload_part_info.data.data.uploadid
     const upload_list = {}
 
-    // 检查是否已取消
     if (isRequestCancelled) {
       return
     }
@@ -207,21 +232,141 @@ app.get('*', async (req, res) => {
     const contentLength = headResponse.headers['content-length']
     const acceptRanges = headResponse.headers['accept-ranges']
 
+    const contenType = headResponse.headers['content-type']
+
+		if (/^image|^text|^application/gim.test(contenType)) {
+			if (!/application\/octet-stream/gim.test(contenType)) {
+				return res.json({
+					video_url: videoUrl,
+					message: `文件类型不支持 ${contenType}`
+				})
+			}
+		}
+
+    const fileSize = parseInt(contentLength)
+    const chunkSize = 2000 * 1024
+
     // 检查服务器是否支持范围请求
     if (!acceptRanges || acceptRanges === 'none' || !contentLength) {
+      // 不支持范围请求：完整下载后分片上传
+      console.log('服务器不支持范围请求，将完整下载文件...')
+
+      // 完整下载文件
+      const fullFileBuffer = await downloadFullFileWithRetry(request, finalUrl)
+
+      if (isRequestCancelled) {
+        return
+      }
+
+      const threadCount = Math.ceil(fileSize / chunkSize)
+      console.log(`文件大小: ${fileSize} bytes, 分片数: ${threadCount}`)
+
+      const tasks = []
+      for (let i = 0; i < threadCount; i++) {
+        const start = i * chunkSize
+        const end = Math.min(start + chunkSize, fileSize)
+        const partNumber = i + 1
+
+        tasks.push(() => (async () => {
+          try {
+            if (isRequestCancelled) {
+              throw new http.Cancel('请求已取消')
+            }
+
+            const chunkBuffer = fullFileBuffer.slice(start, end)
+            const crc32_text = crc32(chunkBuffer)
+
+            const uploadResult = await uploadChunkWithRetry(
+              request,
+              upload_info.data.url,
+              chunkBuffer,
+              partNumber,
+              crc32_text,
+              uploadid,
+              upload_info.data.authorization
+            )
+
+            upload_list[partNumber] = crc32_text
+            return uploadResult
+
+          } catch (error) {
+            if (http.isCancel(error)) {
+              console.log(`分片 ${partNumber} 处理被取消`)
+              throw error
+            }
+            console.error(`分片 ${partNumber} 处理失败:`, error.message)
+            return {
+              part_number: partNumber,
+              status: 'failed',
+              error: error.message
+            }
+          }
+        })())
+      }
+
+      const chunksResults = await runWithConcurrency(tasks, 100, cancelTokenSource)
+
+      if (isRequestCancelled) {
+        return
+      }
+
+      const chunks = chunksResults.map(result =>
+        result.status === 'fulfilled' ? result.value : result.reason
+      )
+
+      const validChunks = chunks.filter(chunk => !(chunk instanceof Error && http.isCancel(chunk)))
+
+      const failedChunks = validChunks.filter(chunk => chunk && chunk.status === 'failed')
+      if (failedChunks.length > 0) {
+        return res.status(500).json({
+          video_url: videoUrl,
+          message: '部分分片处理失败',
+          failed_chunks: failedChunks,
+          success_count: validChunks.length - failedChunks.length,
+          failed_count: failedChunks.length
+        })
+      }
+
+      const successChunks = validChunks.filter(chunk => chunk && chunk.status === 'success')
+      if (successChunks.length === 0) {
+        return res.status(500).json({
+          video_url: videoUrl,
+          message: '所有分片处理失败'
+        })
+      }
+
+      const finish = Object.entries(upload_list).map(i => i.join(':')).join(',')
+
+      const upload_result = await request.post(`${upload_info.data.url}?uploadid=${uploadid}&uploadmode=part&phase=finish`, finish, {
+        headers: {
+          'authorization': upload_info.data.authorization
+        }
+      })
+      console.log(upload_result.data)
+
+      if (upload_result.data.code == 2000) {
+        return res.json({
+          vid: upload_info.data.vid,
+          url: `https://data.emmmm.eu.org/parse/zj/${upload_info.data.uri}`,
+          message: '文件上传成功',
+          total_chunks: successChunks.length
+        })
+      }
+
       return res.json({
         video_url: videoUrl,
-        message: '不支持范围请求'
+        chunks: successChunks,
+        upload_list,
+        fileSize,
+        chunkSize,
+        threadCount
       })
     }
 
-    const fileSize = parseInt(contentLength)
-    const chunkSize = 2000 * 1024
+    // 支持范围请求：继续原有逻辑
     const threadCount = Math.ceil(fileSize / chunkSize)
-
     console.log(`文件大小: ${fileSize} bytes, 分片数: ${threadCount}`)
 
-    // 2. 创建所有分片任务
     const tasks = []
     for (let i = 0; i < threadCount; i++) {
       const start = i * chunkSize
@@ -230,23 +375,18 @@ app.get('*', async (req, res) => {
 
       tasks.push(() => (async () => {
         try {
-          // 检查是否已取消
           if (isRequestCancelled) {
             throw new http.Cancel('请求已取消')
           }
 
-          // 下载分片（带重试）
           const arrayBuffer = await downloadChunkWithRetry(request, finalUrl, start, end, partNumber)
 
-          // 检查是否已取消
           if (isRequestCancelled) {
             throw new http.Cancel('请求已取消')
           }
 
-          // 计算 CRC32
           const crc32_text = crc32(arrayBuffer)
 
-          // 上传分片（带重试）
           const uploadResult = await uploadChunkWithRetry(
             request,
             upload_info.data.url,
@@ -257,9 +397,7 @@ app.get('*', async (req, res) => {
             upload_info.data.authorization
           )
 
-          // 保存到上传列表
           upload_list[partNumber] = crc32_text
-
           return uploadResult
 
         } catch (error) {
@@ -277,23 +415,18 @@ app.get('*', async (req, res) => {
       })())
     }
 
-    // 3. 并行执行所有分片任务，但限制最大并发数为100
     const chunksResults = await runWithConcurrency(tasks, 100, cancelTokenSource)
 
-    // 检查是否已取消
     if (isRequestCancelled) {
       return
     }
 
-    // 处理任务结果
     const chunks = chunksResults.map(result =>
       result.status === 'fulfilled' ? result.value : result.reason
     )
 
-    // 过滤掉取消错误
     const validChunks = chunks.filter(chunk => !(chunk instanceof Error && http.isCancel(chunk)))
 
-    // 检查是否所有分片都成功处理
     const failedChunks = validChunks.filter(chunk => chunk && chunk.status === 'failed')
     if (failedChunks.length > 0) {
       return res.status(500).json({
@@ -305,7 +438,6 @@ app.get('*', async (req, res) => {
       })
     }
 
-    // 检查是否有足够的成功分片
     const successChunks = validChunks.filter(chunk => chunk && chunk.status === 'success')
     if (successChunks.length === 0) {
       return res.status(500).json({
@@ -342,7 +474,6 @@ app.get('*', async (req, res) => {
     })
 
   } catch (error) {
-    // 如果是取消请求，不发送错误响应
     if (http.isCancel(error)) {
       console.log('请求已被用户取消')
       return