1051 lines
37 KiB
TypeScript
1051 lines
37 KiB
TypeScript
// 分块上传工具函数
|
||
// 支持断点续传，自动重试，静默处理错误
|
||
|
||
import { getOptimalChunkSize, getChunkTimeout, getOptimalConcurrency } from './chunk-upload-config'
|
||
import { resolveUploadChunkSize } from './material-upload-chunk-policy'
|
||
|
||
interface ChunkUploadOptions {
|
||
chunkSize?: number // 每块大小（字节），默认根据网络环境自动选择（内网20MB，公网10MB）
|
||
onProgress?: (progress: number, speed?: number) => void // progress: 0-100, speed: 字节/秒
|
||
onError?: (error: Error) => void
|
||
maxRetries?: number // 最大重试次数，默认5次
|
||
retryDelay?: number // 重试延迟（毫秒），默认1000ms
|
||
onStageChange?: (
|
||
stage: 'uploading' | 'processing',
|
||
payload?: {
|
||
message?: string
|
||
}
|
||
) => void
|
||
onRequest?: (xhr: XMLHttpRequest | null) => void // 暴露当前的XHR请求以便取消
|
||
skipComplete?: boolean // 如果为true，分片上传完成后立即返回，不调用completeUpload（用于后台异步处理）
|
||
retainStateOnSkipComplete?: boolean // 仅特殊批次使用：建档确认前保留 IndexedDB 断点
|
||
isCancelled?: () => boolean // 取消检查回调，返回 true 时停止上传
|
||
onActiveXhrChange?: (xhrs: Set<XMLHttpRequest>) => void // 暴露所有活跃的XHR请求集合（用于批量取消）
|
||
requestHeaders?: Record<string, string> // 供钉钉等独立登录态透传认证头
|
||
chunkConcurrency?: number // 单次文件上传的并发块数；不传时继续按网络环境自动选择
|
||
}
|
||
|
||
interface ChunkUploadState {
|
||
fileId: string // 文件唯一ID（基于文件内容hash）
|
||
fileName: string
|
||
fileSize: number
|
||
chunkSize: number
|
||
totalChunks: number
|
||
uploadedChunks: Set<number> // 已上传的块索引
|
||
uploadId?: string // 服务器返回的上传ID
|
||
metadata?: Record<string, any> // 表单元数据（用于恢复时预填）
|
||
}
|
||
|
||
interface UploadHttpError extends Error {
|
||
status?: number
|
||
retryable?: boolean
|
||
outcomeUncertain?: boolean
|
||
}
|
||
|
||
function createUploadHttpError(message: string, status?: number, retryable: boolean = true): UploadHttpError {
|
||
const error = new Error(message) as UploadHttpError
|
||
error.status = status
|
||
error.retryable = retryable
|
||
return error
|
||
}
|
||
|
||
function createUncertainUploadError(message: string): UploadHttpError {
|
||
const error = createUploadHttpError(message, undefined, true)
|
||
error.outcomeUncertain = true
|
||
return error
|
||
}
|
||
|
||
function isUploadOutcomeUncertain(error: unknown): boolean {
|
||
return Boolean(
|
||
error
|
||
&& typeof error === 'object'
|
||
&& 'outcomeUncertain' in error
|
||
&& (error as UploadHttpError).outcomeUncertain,
|
||
)
|
||
}
|
||
|
||
function isRetryableUploadError(error: unknown): boolean {
|
||
if (error && typeof error === 'object' && 'retryable' in error) {
|
||
return Boolean((error as UploadHttpError).retryable)
|
||
}
|
||
return true
|
||
}
|
||
|
||
function isNonRetryableUploadError(error: unknown): boolean {
|
||
return !isRetryableUploadError(error)
|
||
}
|
||
|
||
function isRetryableHttpStatus(status: number): boolean {
|
||
return status >= 500 || status === 408 || status === 429
|
||
}
|
||
|
||
function getUploadHttpErrorMessage(action: string, status: number, fallback: string): string {
|
||
if (status === 413) {
|
||
return `${action}失败：上传分片超过入口服务器限制（413），请联系管理员检查公网入口上传大小限制`
|
||
}
|
||
|
||
if (status === 401 || status === 403) {
|
||
return `${action}失败：登录状态已失效或无权限，请重新登录后再试`
|
||
}
|
||
|
||
return fallback
|
||
}
|
||
|
||
// 存储上传状态到IndexedDB
|
||
const DB_NAME = 'chunk-upload-db'
|
||
const STORE_NAME = 'upload-states'
|
||
|
||
async function getDB(): Promise<IDBDatabase> {
|
||
return new Promise((resolve, reject) => {
|
||
const request = indexedDB.open(DB_NAME, 1)
|
||
|
||
request.onerror = () => reject(request.error)
|
||
request.onsuccess = () => resolve(request.result)
|
||
|
||
request.onupgradeneeded = (event) => {
|
||
const db = (event.target as IDBOpenDBRequest).result
|
||
if (!db.objectStoreNames.contains(STORE_NAME)) {
|
||
db.createObjectStore(STORE_NAME, { keyPath: 'fileId' })
|
||
}
|
||
}
|
||
})
|
||
}
|
||
|
||
async function saveUploadState(state: ChunkUploadState): Promise<void> {
|
||
try {
|
||
const db = await getDB()
|
||
const transaction = db.transaction([STORE_NAME], 'readwrite')
|
||
const store = transaction.objectStore(STORE_NAME)
|
||
await new Promise<void>((resolve, reject) => {
|
||
const request = store.put(state)
|
||
request.onsuccess = () => resolve()
|
||
request.onerror = () => reject(request.error)
|
||
})
|
||
} catch (error) {
|
||
console.error('[ChunkUpload] Failed to save state:', error)
|
||
}
|
||
}
|
||
|
||
async function loadUploadState(fileId: string): Promise<ChunkUploadState | null> {
|
||
try {
|
||
const db = await getDB()
|
||
const transaction = db.transaction([STORE_NAME], 'readonly')
|
||
const store = transaction.objectStore(STORE_NAME)
|
||
return new Promise<ChunkUploadState | null>((resolve, reject) => {
|
||
const request = store.get(fileId)
|
||
request.onsuccess = () => resolve(request.result || null)
|
||
request.onerror = () => reject(request.error)
|
||
})
|
||
} catch (error) {
|
||
console.error('[ChunkUpload] Failed to load state:', error)
|
||
return null
|
||
}
|
||
}
|
||
|
||
export async function deleteUploadState(fileId: string): Promise<void> {
|
||
try {
|
||
const db = await getDB()
|
||
const transaction = db.transaction([STORE_NAME], 'readwrite')
|
||
const store = transaction.objectStore(STORE_NAME)
|
||
await new Promise<void>((resolve, reject) => {
|
||
const request = store.delete(fileId)
|
||
request.onsuccess = () => resolve()
|
||
request.onerror = () => reject(request.error)
|
||
})
|
||
} catch (error) {
|
||
console.error('[ChunkUpload] Failed to delete state:', error)
|
||
}
|
||
}
|
||
|
||
// 导出：按fileId获取上传状态（用于恢复预填）
|
||
export async function getUploadStateById(fileId: string): Promise<ChunkUploadState | null> {
|
||
return loadUploadState(fileId)
|
||
}
|
||
|
||
// 生成文件唯一ID（基于文件名、大小、修改时间）
|
||
export function generateFileId(file: File): string {
|
||
const data = `${file.name}-${file.size}-${file.lastModified}`
|
||
// 简单的稳定hash函数（不包含时间），确保同一文件生成相同ID以便恢复
|
||
let hash = 0
|
||
for (let i = 0; i < data.length; i++) {
|
||
const char = data.charCodeAt(i)
|
||
hash = ((hash << 5) - hash) + char
|
||
hash = hash & hash // Convert to 32bit integer
|
||
}
|
||
return `file-${Math.abs(hash)}`
|
||
}
|
||
|
||
// 初始化上传（获取uploadId）
|
||
async function initUpload(
|
||
fileName: string,
|
||
fileSize: number,
|
||
totalChunks: number,
|
||
chunkSize: number,
|
||
uploadPurpose: string | undefined,
|
||
requestHeaders: Record<string, string> = {},
|
||
): Promise<string> {
|
||
const response = await fetch('/api/materials/upload/init', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json', ...requestHeaders },
|
||
body: JSON.stringify({ fileName, fileSize, totalChunks, chunkSize, uploadPurpose }),
|
||
})
|
||
|
||
if (!response.ok) {
|
||
let errorMessage = `初始化上传失败: ${response.status}`
|
||
try {
|
||
const errorData = await response.json()
|
||
errorMessage = errorData?.error || errorData?.message || errorMessage
|
||
} catch {
|
||
// 忽略错误响应解析失败，保留默认文案
|
||
}
|
||
|
||
const retryable = isRetryableHttpStatus(response.status)
|
||
throw createUploadHttpError(errorMessage, response.status, retryable)
|
||
}
|
||
|
||
const data = await response.json()
|
||
return data.uploadId
|
||
}
|
||
|
||
// 上传单个块
|
||
async function uploadChunk(
|
||
uploadId: string,
|
||
chunkIndex: number,
|
||
chunk: Blob,
|
||
fileName: string,
|
||
options: {
|
||
onChunkProgress?: (loaded: number, total: number) => void
|
||
onRequest?: (xhr: XMLHttpRequest | null) => void
|
||
requestHeaders?: Record<string, string>
|
||
} = {}
|
||
): Promise<void> {
|
||
const startTime = Date.now()
|
||
let uploadStartTime = 0
|
||
let firstByteTime = 0
|
||
let lastProgressTime = 0
|
||
let lastProgressLoaded = 0
|
||
|
||
return new Promise((resolve, reject) => {
|
||
const xhr = new XMLHttpRequest()
|
||
|
||
// 设置超时时间：根据分片大小动态调整
|
||
// 10MB在500KB/s下需要20秒，20MB需要40秒，加上50%缓冲
|
||
xhr.timeout = getChunkTimeout(chunk.size)
|
||
|
||
options.onRequest?.(xhr)
|
||
|
||
xhr.open('POST', '/api/materials/upload/chunk')
|
||
xhr.setRequestHeader('Content-Type', 'application/octet-stream')
|
||
xhr.setRequestHeader('X-Upload-Id', uploadId)
|
||
xhr.setRequestHeader('X-Chunk-Index', chunkIndex.toString())
|
||
xhr.setRequestHeader('X-File-Name', encodeURIComponent(fileName))
|
||
xhr.setRequestHeader('X-Chunk-Size', chunk.size.toString())
|
||
Object.entries(options.requestHeaders || {}).forEach(([key, value]) => xhr.setRequestHeader(key, value))
|
||
|
||
// 记录开始上传时间
|
||
xhr.upload.onloadstart = () => {
|
||
uploadStartTime = Date.now()
|
||
const prepareTime = uploadStartTime - startTime
|
||
console.log(`[ChunkUpload] 🚀 Chunk ${chunkIndex} 开始上传 (准备耗时: ${prepareTime}ms)`)
|
||
}
|
||
|
||
xhr.upload.onprogress = (event) => {
|
||
if (event.lengthComputable) {
|
||
// 记录第一个字节发送时间
|
||
if (firstByteTime === 0 && event.loaded > 0) {
|
||
firstByteTime = Date.now()
|
||
const firstByteDelay = firstByteTime - uploadStartTime
|
||
console.log(`[ChunkUpload] 📤 Chunk ${chunkIndex} 首字节发送: ${firstByteDelay}ms`)
|
||
}
|
||
|
||
options.onChunkProgress?.(event.loaded, event.total)
|
||
|
||
// 每秒输出一次进度和速度
|
||
const now = Date.now()
|
||
if (now - lastProgressTime >= 1000) {
|
||
const elapsed = (now - uploadStartTime) / 1000
|
||
const speed = event.loaded / elapsed / 1024 / 1024
|
||
const instantSpeed = (event.loaded - lastProgressLoaded) / ((now - lastProgressTime) / 1000) / 1024 / 1024
|
||
console.log(`[ChunkUpload] 📊 Chunk ${chunkIndex} 进度: ${(event.loaded/event.total*100).toFixed(1)}%, 平均速度: ${speed.toFixed(2)}MB/s, 瞬时速度: ${instantSpeed.toFixed(2)}MB/s`)
|
||
lastProgressTime = now
|
||
lastProgressLoaded = event.loaded
|
||
}
|
||
}
|
||
}
|
||
|
||
xhr.onload = () => {
|
||
options.onRequest?.(null)
|
||
const totalTime = Date.now() - startTime
|
||
const uploadTime = Date.now() - uploadStartTime
|
||
const serverTime = totalTime - uploadTime
|
||
|
||
console.log(`[ChunkUpload] ✅ Chunk ${chunkIndex} 完成:`, {
|
||
总耗时: `${totalTime}ms`,
|
||
上传耗时: `${uploadTime}ms (${(uploadTime/totalTime*100).toFixed(1)}%)`,
|
||
服务器处理: `${serverTime}ms (${(serverTime/totalTime*100).toFixed(1)}%)`,
|
||
大小: `${(chunk.size / 1024 / 1024).toFixed(2)}MB`,
|
||
平均速度: `${(chunk.size / 1024 / 1024 / (uploadTime / 1000)).toFixed(2)}MB/s`
|
||
})
|
||
|
||
if (xhr.status >= 200 && xhr.status < 300) {
|
||
try {
|
||
const response = JSON.parse(xhr.responseText)
|
||
if (response.serverProcessTime) {
|
||
console.log(`[ChunkUpload] 🖥️ Chunk ${chunkIndex} 服务器详细耗时: ${response.serverProcessTime}ms`)
|
||
}
|
||
} catch (e) {
|
||
// 忽略JSON解析错误
|
||
}
|
||
resolve()
|
||
} else if (xhr.status === 404) {
|
||
// 会话不存在或已过期，抛出特殊错误以便重新初始化
|
||
console.warn(`[ChunkUpload] ⚠️ Chunk ${chunkIndex} 会话不存在（可能已过期），需要重新初始化`)
|
||
reject(new Error('UPLOAD_SESSION_EXPIRED'))
|
||
} else {
|
||
const retryable = isRetryableHttpStatus(xhr.status)
|
||
const message = getUploadHttpErrorMessage(
|
||
`上传块 ${chunkIndex}`,
|
||
xhr.status,
|
||
`上传块 ${chunkIndex} 失败: ${xhr.status}`,
|
||
)
|
||
reject(createUploadHttpError(message, xhr.status, retryable))
|
||
}
|
||
}
|
||
|
||
xhr.onerror = () => {
|
||
options.onRequest?.(null)
|
||
const totalTime = Date.now() - startTime
|
||
console.error(`[ChunkUpload] ❌ Chunk ${chunkIndex} 失败 (耗时: ${totalTime}ms)`)
|
||
reject(new Error(`上传块 ${chunkIndex} 失败: 网络错误`))
|
||
}
|
||
|
||
xhr.onabort = () => {
|
||
options.onRequest?.(null)
|
||
reject(new Error('上传已取消'))
|
||
}
|
||
|
||
xhr.ontimeout = () => {
|
||
options.onRequest?.(null)
|
||
const totalTime = Date.now() - startTime
|
||
console.error(`[ChunkUpload] ❌ Chunk ${chunkIndex} 超时 (耗时: ${totalTime}ms, 超过60秒)`)
|
||
reject(new Error(`上传块 ${chunkIndex} 超时`))
|
||
}
|
||
|
||
xhr.send(chunk)
|
||
})
|
||
}
|
||
|
||
// 完成上传（合并所有块）
|
||
export async function completeUpload(
|
||
uploadId: string | null,
|
||
metadata: Record<string, any>
|
||
): Promise<any> {
|
||
// 添加超时控制（5分钟）
|
||
const timeout = 5 * 60 * 1000 // 5分钟
|
||
const controller = new AbortController()
|
||
const timeoutId = setTimeout(() => controller.abort(), timeout)
|
||
|
||
try {
|
||
const response = await fetch('/api/materials/upload/complete', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ uploadId: uploadId || null, metadata }),
|
||
signal: controller.signal,
|
||
})
|
||
|
||
clearTimeout(timeoutId)
|
||
|
||
if (!response.ok) {
|
||
const errorData = await response.json().catch(() => ({}))
|
||
const errorMessage = errorData.error || `完成上传失败: ${response.status}`
|
||
|
||
// 如果是会话过期错误，抛出特殊错误以便前端处理
|
||
if (response.status === 404 && errorMessage.includes('会话')) {
|
||
throw new Error('UPLOAD_SESSION_EXPIRED')
|
||
}
|
||
|
||
const retryable = isRetryableHttpStatus(response.status)
|
||
throw createUploadHttpError(errorMessage, response.status, retryable)
|
||
}
|
||
|
||
try {
|
||
return await response.json()
|
||
} catch {
|
||
// 2xx 已由服务器返回，但响应体在链路中截断时，服务端可能已经完成合并。
|
||
throw createUncertainUploadError('完成响应不完整，服务器处理结果尚未确认')
|
||
}
|
||
} catch (error) {
|
||
clearTimeout(timeoutId)
|
||
|
||
if (error instanceof Error) {
|
||
if (error.name === 'AbortError') {
|
||
throw createUncertainUploadError('完成请求超时，服务器处理结果尚未确认')
|
||
}
|
||
if (error.message === 'UPLOAD_SESSION_EXPIRED') {
|
||
throw error
|
||
}
|
||
if ('retryable' in error || isUploadOutcomeUncertain(error)) {
|
||
throw error
|
||
}
|
||
}
|
||
|
||
// fetch 的网络错误没有可靠的“服务端未执行”语义，必须按结果不确定处理。
|
||
throw createUncertainUploadError(
|
||
error instanceof Error
|
||
? `完成请求中断：${error.message}`
|
||
: '完成请求中断，服务器处理结果尚未确认',
|
||
)
|
||
}
|
||
}
|
||
|
||
// 主上传函数
|
||
const activeFileUploadIds = new Set<string>()
|
||
|
||
export async function chunkUpload(
|
||
file: File,
|
||
metadata: Record<string, any>,
|
||
options: ChunkUploadOptions = {},
|
||
): Promise<any> {
|
||
const fileId = file?.name?.trim() && Number.isFinite(file.size)
|
||
? generateFileId(file)
|
||
: ''
|
||
|
||
if (fileId && activeFileUploadIds.has(fileId)) {
|
||
throw new Error(`文件 ${file.name} 正在上传，请勿在同一批次重复选择`)
|
||
}
|
||
|
||
if (fileId) {
|
||
activeFileUploadIds.add(fileId)
|
||
}
|
||
|
||
try {
|
||
return await runChunkUpload(file, metadata, options)
|
||
} finally {
|
||
if (fileId) {
|
||
activeFileUploadIds.delete(fileId)
|
||
}
|
||
}
|
||
}
|
||
|
||
async function runChunkUpload(
|
||
file: File,
|
||
metadata: Record<string, any>,
|
||
options: ChunkUploadOptions = {}
|
||
): Promise<any> {
|
||
if (!file || !file.name?.trim()) {
|
||
throw new Error('文件名不能为空，无法上传')
|
||
}
|
||
|
||
if (!Number.isFinite(file.size) || file.size <= 0) {
|
||
throw new Error(`文件 ${file.name} 为空，无法上传`)
|
||
}
|
||
|
||
// 如果没有指定chunkSize，根据网络环境自动选择最优值
|
||
let defaultChunkSize = 10 * 1024 * 1024 // 默认10MB（公网配置）
|
||
if (!options.chunkSize) {
|
||
try {
|
||
defaultChunkSize = await getOptimalChunkSize()
|
||
} catch (error) {
|
||
console.warn('[ChunkUpload] 获取最优分片大小失败，使用默认10MB:', error)
|
||
}
|
||
}
|
||
|
||
const {
|
||
chunkSize: requestedChunkSize = defaultChunkSize, // 根据网络环境自动选择（内网20MB，公网10MB）
|
||
onProgress,
|
||
maxRetries = 5,
|
||
retryDelay = 1000,
|
||
onStageChange,
|
||
onRequest,
|
||
skipComplete = false, // 默认不跳过complete
|
||
retainStateOnSkipComplete = false,
|
||
isCancelled, // 取消检查回调
|
||
onActiveXhrChange, // 活跃XHR集合回调
|
||
requestHeaders = {},
|
||
} = options
|
||
|
||
// 跟踪所有活跃的 XHR 请求（用于批量取消）
|
||
const activeXhrs = new Set<XMLHttpRequest>()
|
||
|
||
onStageChange?.('uploading', { message: '正在上传素材文件…' })
|
||
|
||
const fileId = generateFileId(file)
|
||
let chunkSize = Number(requestedChunkSize)
|
||
let totalChunks = Math.ceil(file.size / chunkSize)
|
||
if (resolveUploadChunkSize(file.size, totalChunks, chunkSize) !== chunkSize) {
|
||
throw new Error('上传文件大小或分片配置无效（单文件最多10GB、单分片最多20MB）')
|
||
}
|
||
|
||
// 加载已有状态
|
||
let state = await loadUploadState(fileId)
|
||
|
||
if (state) {
|
||
const requestedUploadPurpose = typeof metadata?.uploadPurpose === 'string'
|
||
? metadata.uploadPurpose.trim()
|
||
: ''
|
||
const storedUploadPurpose = typeof state.metadata?.uploadPurpose === 'string'
|
||
? state.metadata.uploadPurpose.trim()
|
||
: ''
|
||
const storedUploadedChunks = state.uploadedChunks instanceof Set
|
||
? state.uploadedChunks
|
||
: null
|
||
const storedChunkSize = resolveUploadChunkSize(
|
||
file.size,
|
||
Number(state.totalChunks),
|
||
state.chunkSize,
|
||
)
|
||
const storedStateMatchesFile = state.fileName === file.name
|
||
&& state.fileSize === file.size
|
||
&& storedUploadedChunks !== null
|
||
&& Array.from(storedUploadedChunks).every((index) => (
|
||
Number.isInteger(index)
|
||
&& index >= 0
|
||
&& index < state!.totalChunks
|
||
))
|
||
const storedStateMatchesPurpose = storedUploadPurpose === requestedUploadPurpose
|
||
|
||
if (state.uploadId && storedStateMatchesFile && storedChunkSize && storedStateMatchesPurpose) {
|
||
// 服务端会话的分片布局在 init 时已经固定。网络从公网切到内网（或反向）
|
||
// 时仍沿用已保存的 10/20MiB 布局，不能拿新探测值切旧会话。
|
||
chunkSize = storedChunkSize
|
||
totalChunks = state.totalChunks
|
||
} else if (state.uploadId || !storedStateMatchesFile || !storedChunkSize || !storedStateMatchesPurpose) {
|
||
// 无法安全证明旧状态与当前文件/布局一致时，清理旧会话并重新初始化，
|
||
// 避免把错误切片继续写进服务端既有会话。
|
||
if (state.uploadId) {
|
||
fetch('/api/materials/upload/cleanup', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ uploadId: state.uploadId }),
|
||
}).catch(() => undefined)
|
||
}
|
||
await deleteUploadState(fileId).catch(() => undefined)
|
||
state = null
|
||
} else {
|
||
// 尚未拿到服务端 uploadId，不存在可恢复的远端进度，按本次网络配置重建。
|
||
state.chunkSize = chunkSize
|
||
state.totalChunks = totalChunks
|
||
state.uploadedChunks.clear()
|
||
}
|
||
}
|
||
|
||
if (!state) {
|
||
// 初始化新上传
|
||
state = {
|
||
fileId,
|
||
fileName: file.name,
|
||
fileSize: file.size,
|
||
chunkSize,
|
||
totalChunks,
|
||
uploadedChunks: new Set(),
|
||
metadata, // 首次保存metadata
|
||
}
|
||
await saveUploadState(state)
|
||
} else {
|
||
// 恢复上传
|
||
console.log(`[ChunkUpload] 恢复上传: ${state.uploadedChunks.size}/${totalChunks} 块已上传`)
|
||
// 用最新metadata覆盖旧值（以便完成时使用最新表单信息）
|
||
state.metadata = metadata
|
||
await saveUploadState(state)
|
||
}
|
||
|
||
// 初始化上传（如果需要）
|
||
if (!state.uploadId) {
|
||
try {
|
||
state.uploadId = await initUpload(
|
||
file.name,
|
||
file.size,
|
||
totalChunks,
|
||
chunkSize,
|
||
typeof metadata?.uploadPurpose === 'string' ? metadata.uploadPurpose : undefined,
|
||
requestHeaders,
|
||
)
|
||
await saveUploadState(state)
|
||
} catch (error) {
|
||
if (!isRetryableUploadError(error)) {
|
||
await deleteUploadState(fileId).catch(() => {})
|
||
throw error
|
||
}
|
||
|
||
// 自动重试初始化
|
||
let retries = 0
|
||
while (retries < maxRetries) {
|
||
await new Promise(resolve => setTimeout(resolve, retryDelay))
|
||
try {
|
||
state.uploadId = await initUpload(
|
||
file.name,
|
||
file.size,
|
||
totalChunks,
|
||
chunkSize,
|
||
typeof metadata?.uploadPurpose === 'string' ? metadata.uploadPurpose : undefined,
|
||
requestHeaders,
|
||
)
|
||
await saveUploadState(state)
|
||
break
|
||
} catch (e) {
|
||
if (!isRetryableUploadError(e)) {
|
||
await deleteUploadState(fileId).catch(() => {})
|
||
throw e
|
||
}
|
||
|
||
retries++
|
||
if (retries >= maxRetries) {
|
||
throw new Error('初始化上传失败，已重试多次')
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 网速计算相关变量
|
||
let lastUpdateTime = Date.now()
|
||
let lastUploadedBytes = 0
|
||
// 计算已上传的字节数（包括恢复上传时已上传的块）
|
||
let completedBytes = 0
|
||
for (let i = 0; i < totalChunks; i++) {
|
||
if (state.uploadedChunks.has(i)) {
|
||
const start = i * chunkSize
|
||
const end = Math.min(start + chunkSize, file.size)
|
||
completedBytes += (end - start)
|
||
}
|
||
}
|
||
lastUploadedBytes = completedBytes // 初始化已上传字节数
|
||
const speedHistory: number[] = [] // 用于平滑网速计算
|
||
const SPEED_HISTORY_SIZE = 5 // 保留最近5次的速度记录
|
||
const inFlightChunkBytes = new Map<number, number>()
|
||
|
||
const getInFlightBytes = () => {
|
||
let total = 0
|
||
inFlightChunkBytes.forEach((bytes) => {
|
||
total += bytes
|
||
})
|
||
return total
|
||
}
|
||
|
||
const updateProgress = (uploadedBytes: number) => {
|
||
const clampedBytes = Math.min(file.size, Math.max(0, uploadedBytes))
|
||
const progress = Math.max(
|
||
uploadedBytes > 0 ? 1 : 0,
|
||
Math.min(100, Math.round((clampedBytes / file.size) * 100))
|
||
)
|
||
|
||
const currentTime = Date.now()
|
||
const timeDelta = (currentTime - lastUpdateTime) / 1000 // 秒
|
||
const bytesDelta = clampedBytes - lastUploadedBytes
|
||
|
||
// 优化：降低速度显示更新频率，从0.1秒改为1秒
|
||
// 避免速度数字跳动过快，用户无法看清
|
||
const UPDATE_INTERVAL = 1 // 1秒更新一次
|
||
|
||
if (timeDelta >= UPDATE_INTERVAL) {
|
||
const currentSpeed = bytesDelta / timeDelta
|
||
|
||
if (currentSpeed > 0 && currentSpeed < file.size * 100) {
|
||
speedHistory.push(currentSpeed)
|
||
if (speedHistory.length > SPEED_HISTORY_SIZE) {
|
||
speedHistory.shift()
|
||
}
|
||
}
|
||
|
||
let avgSpeed = 0
|
||
if (speedHistory.length > 0) {
|
||
avgSpeed = speedHistory.reduce((sum, s) => sum + s, 0) / speedHistory.length
|
||
}
|
||
|
||
onProgress?.(progress, avgSpeed > 0 ? avgSpeed : undefined)
|
||
|
||
lastUpdateTime = currentTime
|
||
lastUploadedBytes = clampedBytes
|
||
} else {
|
||
// 在更新间隔内，使用上一次的速度显示（避免数字跳动）
|
||
if (speedHistory.length > 0) {
|
||
const lastSpeed = speedHistory[speedHistory.length - 1]
|
||
onProgress?.(progress, lastSpeed)
|
||
} else {
|
||
onProgress?.(progress)
|
||
}
|
||
}
|
||
}
|
||
|
||
if (completedBytes > 0) {
|
||
updateProgress(completedBytes)
|
||
}
|
||
|
||
// 动态并发上传配置（根据网络环境自动调整）
|
||
let defaultConcurrency = options.chunkConcurrency ?? 2 // 默认2并发
|
||
if (options.chunkConcurrency === undefined) {
|
||
try {
|
||
defaultConcurrency = await getOptimalConcurrency()
|
||
} catch (error) {
|
||
console.warn('[ChunkUpload] 获取最优并发数失败，使用默认值（2）:', error)
|
||
}
|
||
}
|
||
const CONCURRENT_CHUNKS = Math.max(1, Math.min(8, Math.floor(Number(defaultConcurrency) || 1)))
|
||
|
||
// 创建待上传chunk队列
|
||
const pendingChunks: number[] = []
|
||
for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
|
||
if (!state.uploadedChunks.has(chunkIndex)) {
|
||
pendingChunks.push(chunkIndex)
|
||
}
|
||
}
|
||
|
||
console.log(`[ChunkUpload] 开始并发上传: ${pendingChunks.length}个chunk待上传，${CONCURRENT_CHUNKS}个并发`)
|
||
|
||
// 会话过期标志（用于协调所有worker）
|
||
let sessionExpired = false
|
||
let reinitPromise: Promise<void> | null = null
|
||
|
||
// 并发上传worker
|
||
const uploadWorker = async () => {
|
||
while (pendingChunks.length > 0) {
|
||
// 检查取消状态
|
||
if (isCancelled?.()) {
|
||
console.log('[ChunkUpload] Worker 检测到取消信号，停止上传')
|
||
throw new Error('上传已取消')
|
||
}
|
||
|
||
const chunkIndex = pendingChunks.shift()
|
||
if (chunkIndex === undefined) break
|
||
|
||
// 读取块
|
||
const start = chunkIndex * chunkSize
|
||
const end = Math.min(start + chunkSize, file.size)
|
||
const chunk = file.slice(start, end)
|
||
const chunkSizeBytes = end - start
|
||
|
||
// 上传块（带自动重试）
|
||
let retries = 0
|
||
let success = false
|
||
while (!success && retries < maxRetries) {
|
||
// 每次重试前检查取消状态
|
||
if (isCancelled?.()) {
|
||
console.log('[ChunkUpload] Worker 检测到取消信号，停止上传')
|
||
throw new Error('上传已取消')
|
||
}
|
||
|
||
// 当前分片的 XHR 引用
|
||
let currentXhr: XMLHttpRequest | null = null
|
||
|
||
try {
|
||
await uploadChunk(state.uploadId!, chunkIndex, chunk, file.name, {
|
||
onChunkProgress: (loaded) => {
|
||
inFlightChunkBytes.set(chunkIndex, Math.min(loaded, chunkSizeBytes))
|
||
updateProgress(completedBytes + getInFlightBytes())
|
||
},
|
||
onRequest: (xhr) => {
|
||
// 跟踪所有活跃的 XHR
|
||
if (xhr) {
|
||
currentXhr = xhr
|
||
activeXhrs.add(xhr)
|
||
onActiveXhrChange?.(activeXhrs)
|
||
} else if (currentXhr) {
|
||
// XHR 完成，从集合中移除
|
||
activeXhrs.delete(currentXhr)
|
||
onActiveXhrChange?.(activeXhrs)
|
||
currentXhr = null
|
||
}
|
||
// 同时调用原来的回调
|
||
onRequest?.(xhr)
|
||
},
|
||
requestHeaders,
|
||
})
|
||
|
||
state.uploadedChunks.add(chunkIndex)
|
||
await saveUploadState(state)
|
||
success = true
|
||
|
||
// 更新已上传字节数（完成整个块）
|
||
inFlightChunkBytes.delete(chunkIndex)
|
||
completedBytes += chunkSizeBytes
|
||
updateProgress(completedBytes + getInFlightBytes())
|
||
|
||
console.log(`[ChunkUpload] Chunk ${chunkIndex}/${totalChunks} 完成，剩余 ${pendingChunks.length} 个`)
|
||
} catch (error) {
|
||
inFlightChunkBytes.delete(chunkIndex)
|
||
updateProgress(completedBytes + getInFlightBytes())
|
||
|
||
// 清理当前 XHR
|
||
if (currentXhr) {
|
||
activeXhrs.delete(currentXhr)
|
||
onActiveXhrChange?.(activeXhrs)
|
||
currentXhr = null
|
||
}
|
||
|
||
if ((error as Error)?.message === '上传已取消') {
|
||
onRequest?.(null)
|
||
// 取消时清理 IndexedDB 状态
|
||
await deleteUploadState(fileId).catch(() => {})
|
||
// 调用后端清理 API 删除服务器临时文件
|
||
if (state.uploadId) {
|
||
console.log('[ChunkUpload] 取消上传，调用后端清理临时文件...')
|
||
fetch('/api/materials/upload/cleanup', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ uploadId: state.uploadId })
|
||
}).catch(err => {
|
||
console.warn('[ChunkUpload] 清理临时文件失败（忽略）:', err)
|
||
})
|
||
}
|
||
throw error
|
||
}
|
||
|
||
if (isNonRetryableUploadError(error)) {
|
||
await deleteUploadState(fileId).catch(() => {})
|
||
if (state.uploadId) {
|
||
console.log('[ChunkUpload] 上传分片失败且不可重试，调用后端清理临时文件...')
|
||
fetch('/api/materials/upload/cleanup', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ uploadId: state.uploadId })
|
||
}).catch(err => {
|
||
console.warn('[ChunkUpload] 清理临时文件失败（忽略）:', err)
|
||
})
|
||
}
|
||
throw error
|
||
}
|
||
|
||
// 如果是会话过期，尝试刷新会话（保留进度）
|
||
if ((error as Error)?.message === 'UPLOAD_SESSION_EXPIRED') {
|
||
// ⚠️ 重要修复：如果所有分片都已上传成功，不要重新初始化
|
||
// 这种情况可能是 complete 阶段的竞争条件导致的，应该直接继续到 complete
|
||
if (state.uploadedChunks.size >= totalChunks) {
|
||
console.warn(`[ChunkUpload] ⚠️ 会话过期但所有分片已上传完成 (${state.uploadedChunks.size}/${totalChunks})，跳过重新初始化`)
|
||
sessionExpired = false
|
||
continue
|
||
}
|
||
|
||
// 如果已经有其他worker在处理，等待它完成
|
||
if (reinitPromise) {
|
||
console.log(`[ChunkUpload] 等待其他worker完成会话刷新...`)
|
||
await reinitPromise
|
||
continue
|
||
}
|
||
|
||
// 标记会话过期，防止其他worker重复处理
|
||
if (!sessionExpired) {
|
||
sessionExpired = true
|
||
console.warn(`[ChunkUpload] 🔄 检测到会话过期，尝试刷新会话（保留已上传进度）...`)
|
||
|
||
reinitPromise = (async () => {
|
||
try {
|
||
// 尝试刷新会话（保留uploadId和已上传进度）
|
||
const refreshResponse = await fetch('/api/materials/upload/refresh', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ uploadId: state.uploadId })
|
||
})
|
||
|
||
const refreshResult = await refreshResponse.json()
|
||
|
||
if (refreshResult.success) {
|
||
console.log(`[ChunkUpload] ✅ 会话刷新成功，保留 ${state.uploadedChunks.size} 个已上传分片，继续上传`)
|
||
sessionExpired = false
|
||
// 不清空 uploadedChunks，保留进度
|
||
return
|
||
} else {
|
||
// ⚠️ 修复：如果刷新失败但所有分片已上传，不要重新初始化
|
||
if (state.uploadedChunks.size >= totalChunks) {
|
||
console.warn(`[ChunkUpload] ⚠️ 会话刷新失败但所有分片已上传完成，跳过重新初始化`)
|
||
sessionExpired = false
|
||
return
|
||
}
|
||
|
||
console.warn(`[ChunkUpload] ⚠️ 会话刷新失败（${refreshResult.error}），重新初始化上传...`)
|
||
// 刷新失败，需要重新初始化
|
||
state.uploadId = await initUpload(
|
||
file.name,
|
||
file.size,
|
||
totalChunks,
|
||
chunkSize,
|
||
typeof metadata?.uploadPurpose === 'string' ? metadata.uploadPurpose : undefined,
|
||
requestHeaders,
|
||
)
|
||
state.uploadedChunks.clear()
|
||
completedBytes = 0
|
||
await saveUploadState(state)
|
||
// 将所有chunk重新加入队列
|
||
pendingChunks.length = 0
|
||
for (let i = 0; i < totalChunks; i++) {
|
||
pendingChunks.push(i)
|
||
}
|
||
console.log(`[ChunkUpload] ✅ 会话重新初始化成功，重新开始上传`)
|
||
sessionExpired = false
|
||
return
|
||
}
|
||
} catch (refreshError) {
|
||
console.error(`[ChunkUpload] ❌ 会话刷新/重新初始化失败:`, refreshError)
|
||
throw new Error('上传会话已过期且无法恢复，请刷新页面后重试')
|
||
}
|
||
})()
|
||
|
||
await reinitPromise
|
||
reinitPromise = null
|
||
// 不增加重试次数，直接继续
|
||
continue
|
||
} else {
|
||
// 等待刷新/重新初始化完成
|
||
if (reinitPromise) {
|
||
await reinitPromise
|
||
continue
|
||
}
|
||
}
|
||
}
|
||
|
||
retries++
|
||
if (retries < maxRetries) {
|
||
// 等待后重试
|
||
await new Promise(resolve => setTimeout(resolve, retryDelay * retries))
|
||
} else {
|
||
throw new Error(`上传块 ${chunkIndex} 失败，已重试多次`)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 启动多个并发worker
|
||
const workers = []
|
||
for (let i = 0; i < CONCURRENT_CHUNKS; i++) {
|
||
workers.push(uploadWorker())
|
||
}
|
||
|
||
// 等待所有worker完成
|
||
await Promise.all(workers)
|
||
|
||
// 如果设置了skipComplete，分片上传完成后立即返回，不调用completeUpload
|
||
if (skipComplete) {
|
||
console.log('[ChunkUpload] 分片上传完成，跳过complete处理（将在后台异步处理）')
|
||
if (!retainStateOnSkipComplete) {
|
||
try {
|
||
await deleteUploadState(fileId)
|
||
} catch (cleanupError) {
|
||
console.warn('[ChunkUpload] 清理上传状态失败（将忽略并继续）:', cleanupError)
|
||
}
|
||
}
|
||
return {
|
||
uploadId: state.uploadId,
|
||
metadata,
|
||
chunksUploaded: true,
|
||
...(retainStateOnSkipComplete
|
||
? {
|
||
confirmMaterialCreated: async () => {
|
||
await deleteUploadState(fileId)
|
||
},
|
||
}
|
||
: {}),
|
||
}
|
||
}
|
||
|
||
// 完成上传
|
||
let retries = 0
|
||
let result: any = null
|
||
|
||
while (!result && retries < maxRetries) {
|
||
try {
|
||
onStageChange?.('processing', {
|
||
message:
|
||
metadata?.materialType === '模特' || metadata?.materialType === '实拍图片' || metadata?.materialType === '买家秀图片' || metadata?.materialType === '小红书种草' || metadata?.materialType === '主图模版' || metadata?.materialType === 'SKU模版'
|
||
? `展示图处理中（共 ${metadata?.modelImages?.length || 0} 张）…`
|
||
: '正在处理素材，请稍候…',
|
||
})
|
||
result = await completeUpload(state.uploadId!, metadata)
|
||
// 删除保存的状态
|
||
await deleteUploadState(fileId)
|
||
return result
|
||
} catch (error) {
|
||
// 如果是会话过期错误，不再重试，直接抛出
|
||
if (error instanceof Error && error.message === 'UPLOAD_SESSION_EXPIRED') {
|
||
await deleteUploadState(fileId)
|
||
// 清理后端临时文件
|
||
if (state.uploadId) {
|
||
fetch('/api/materials/upload/cleanup', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ uploadId: state.uploadId })
|
||
}).catch(() => {})
|
||
}
|
||
throw new Error('上传会话已过期，请重新上传文件')
|
||
}
|
||
|
||
if (isNonRetryableUploadError(error)) {
|
||
await deleteUploadState(fileId).catch(() => {})
|
||
if (state.uploadId) {
|
||
fetch('/api/materials/upload/cleanup', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ uploadId: state.uploadId })
|
||
}).catch(() => {})
|
||
}
|
||
throw error
|
||
}
|
||
|
||
retries++
|
||
if (retries < maxRetries) {
|
||
await new Promise(resolve => setTimeout(resolve, retryDelay * retries))
|
||
} else {
|
||
// 5xx、超时和网络错误都不能证明服务端没有完成合并。保留本地断点，
|
||
// 且绝不 destructive cleanup，避免删除一个已经成功生成的 merged 文件。
|
||
const detail = error instanceof Error ? error.message : '服务器处理结果尚未确认'
|
||
const suffix = isUploadOutcomeUncertain(error)
|
||
? '服务器可能已经完成处理'
|
||
: '服务暂时不可用'
|
||
throw createUncertainUploadError(
|
||
`${detail}；${suffix}，已保留上传断点，请稍后重试确认`,
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
// 检查是否有未完成的上传
|
||
export async function hasPendingUploads(): Promise<boolean> {
|
||
try {
|
||
const db = await getDB()
|
||
const transaction = db.transaction([STORE_NAME], 'readonly')
|
||
const store = transaction.objectStore(STORE_NAME)
|
||
return new Promise<boolean>((resolve) => {
|
||
const request = store.count()
|
||
request.onsuccess = () => resolve(request.result > 0)
|
||
request.onerror = () => resolve(false)
|
||
})
|
||
} catch {
|
||
return false
|
||
}
|
||
}
|
||
|
||
// 获取所有未完成的上传状态
|
||
export async function getAllPendingUploads(): Promise<ChunkUploadState[]> {
|
||
try {
|
||
const db = await getDB()
|
||
const transaction = db.transaction([STORE_NAME], 'readonly')
|
||
const store = transaction.objectStore(STORE_NAME)
|
||
return new Promise<ChunkUploadState[]>((resolve) => {
|
||
const request = store.getAll()
|
||
request.onsuccess = () => resolve(request.result || [])
|
||
request.onerror = () => resolve([])
|
||
})
|
||
} catch (error) {
|
||
console.error('[ChunkUpload] Failed to get pending uploads:', error)
|
||
return []
|
||
}
|
||
}
|
||
|
||
// 清理所有上传状态
|
||
export async function clearAllUploadStates(): Promise<void> {
|
||
try {
|
||
const db = await getDB()
|
||
const transaction = db.transaction([STORE_NAME], 'readwrite')
|
||
const store = transaction.objectStore(STORE_NAME)
|
||
await new Promise<void>((resolve, reject) => {
|
||
const request = store.clear()
|
||
request.onsuccess = () => resolve()
|
||
request.onerror = () => reject(request.error)
|
||
})
|
||
} catch (error) {
|
||
console.error('[ChunkUpload] Failed to clear states:', error)
|
||
}
|
||
}
|