From d097d32aa55e6be0458eedb65f0ff5087f425f49 Mon Sep 17 00:00:00 2001 From: eust-w Date: Sat, 11 Jul 2026 00:00:30 +0800 Subject: [PATCH] =?UTF-8?q?=F0=9F=90=9B=20Fix=20browser=20object=20storage?= =?UTF-8?q?=20uploads?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib/object-storage-upload.js | 63 +++++++++++++ src/services/api/object-storage.ts | 67 +++++++------- tests/frontend/object-storage-upload.test.mjs | 88 +++++++++++++++++++ 3 files changed, 185 insertions(+), 33 deletions(-) diff --git a/src/lib/object-storage-upload.js b/src/lib/object-storage-upload.js index 66df1899..168e5d2d 100644 --- a/src/lib/object-storage-upload.js +++ b/src/lib/object-storage-upload.js @@ -25,3 +25,66 @@ export function parseObjectStorageUploadETag(rawValue) { const value = String(rawValue || "").trim(); return value ? value.replace(/^"+|"+$/g, "") : ""; } + +function objectStorageUploadHost(url) { + try { + return new URL(url).host; + } catch { + return "object storage"; + } +} + +function objectStorageUploadNetworkError(url) { + return new Error( + `对象存储直传失败:浏览器未收到来自 ${objectStorageUploadHost(url)} 的可访问响应。` + + "请检查 BOS CORS、HTTPS 和浏览器网络策略后重试。", + ); +} + +/** + * Upload a Blob to a presigned URL without sending cookies or HTTP credentials. + * XMLHttpRequest is used because Fetch does not expose upload progress events. + * + * @param {string} url + * @param {Blob} body + * @param {Record | undefined} headers + * @param {((loadedBytes: number, totalBytes: number) => void) | undefined} onProgress + * @param {(() => XMLHttpRequest) | undefined} createRequest + * @returns {Promise<{status: number, headers: {get(name: string): string | null}}>} + */ +export function uploadObjectStoragePresignedURL(url, body, headers, onProgress, createRequest = undefined) { + return new Promise((resolve, reject) => { + const request = createRequest ? createRequest() : new XMLHttpRequest(); + request.open("PUT", url, true); + request.withCredentials = false; + + for (const [key, rawValue] of Object.entries(headers || {})) { + const value = String(rawValue || "").trim(); + if (value) { + request.setRequestHeader(key, value); + } + } + + request.upload.onprogress = (event) => { + const totalBytes = event.lengthComputable && event.total > 0 ? event.total : body.size; + onProgress?.(Math.min(event.loaded, totalBytes), totalBytes); + }; + request.onload = () => { + if (request.status >= 200 && request.status < 300) { + resolve({ + status: request.status, + headers: { + get: (name) => request.getResponseHeader(name), + }, + }); + return; + } + const responseText = String(request.responseText || "").trim(); + reject(new Error(responseText || `Object storage upload failed: ${request.status}`)); + }; + request.onerror = () => reject(objectStorageUploadNetworkError(url)); + request.onabort = () => reject(new Error("对象存储直传已取消。")); + request.ontimeout = () => reject(new Error("对象存储直传超时,请重试。")); + request.send(body); + }); +} diff --git a/src/services/api/object-storage.ts b/src/services/api/object-storage.ts index f02188a9..6ed56c91 100644 --- a/src/services/api/object-storage.ts +++ b/src/services/api/object-storage.ts @@ -12,6 +12,7 @@ import { objectStorageMultipartParts, objectStorageUploadMode, parseObjectStorageUploadETag, + uploadObjectStoragePresignedURL, } from "../../lib/object-storage-upload.js"; import { buildAPIURL } from "./base-url.js"; import { apiFetch, apiRequest } from "./client"; @@ -132,29 +133,6 @@ async function uploadWithFormData(path: string, formData: FormData) { return (await response.json()) as T; } -function mergeUploadHeaders(headers?: Record) { - const result = new Headers(); - for (const [key, value] of Object.entries(headers || {})) { - if (value.trim()) { - result.set(key, value); - } - } - return result; -} - -async function uploadToPresignedURL(url: string, body: BodyInit, headers?: Record) { - const response = await fetch(url, { - method: "PUT", - body, - headers: mergeUploadHeaders(headers), - }); - if (!response.ok) { - const text = await response.text(); - throw new Error(text || `Object storage upload failed: ${response.status}`); - } - return response; -} - async function uploadMultipartObject( file: File, options: { connectionId: string; bucket?: string; key: string; contentType?: string }, @@ -175,6 +153,18 @@ async function uploadMultipartObject( let completedBytes = 0; let nextIndex = 0; let aborted = false; + const activePartBytes = new Map(); + + const reportMultipartProgress = (partNumber?: number) => { + const activeBytes = Array.from(activePartBytes.values()).reduce((total, loadedBytes) => total + loadedBytes, 0); + onProgress?.({ + mode: "multipart", + loadedBytes: Math.min(completedBytes + activeBytes, file.size), + totalBytes: file.size, + partNumber, + partCount: parts.length, + }); + }; const abortUpload = async () => { if (aborted) { @@ -207,20 +197,25 @@ async function uploadMultipartObject( expiresInSeconds: PRESIGN_EXPIRES_SECONDS, }, ); - const response = await uploadToPresignedURL(partURL.url, file.slice(part.start, part.end), partURL.headers); + const partSize = part.end - part.start; + activePartBytes.set(part.partNumber, 0); + const response = await uploadObjectStoragePresignedURL( + partURL.url, + file.slice(part.start, part.end), + partURL.headers, + (loadedBytes) => { + activePartBytes.set(part.partNumber, Math.min(loadedBytes, partSize)); + reportMultipartProgress(part.partNumber); + }, + ); const eTag = parseObjectStorageUploadETag(response.headers.get("ETag")); if (!eTag) { throw new Error(`Object storage upload part ${part.partNumber} did not return ETag`); } uploadedParts.push({ partNumber: part.partNumber, eTag }); - completedBytes += part.end - part.start; - onProgress?.({ - mode: "multipart", - loadedBytes: Math.min(completedBytes, file.size), - totalBytes: file.size, - partNumber: part.partNumber, - partCount: parts.length, - }); + activePartBytes.delete(part.partNumber); + completedBytes += partSize; + reportMultipartProgress(part.partNumber); } }; @@ -255,7 +250,13 @@ async function uploadDirectObject( }, ); onProgress?.({ mode: "direct", loadedBytes: 0, totalBytes: file.size }); - await uploadToPresignedURL(presigned.url, file, presigned.headers); + await uploadObjectStoragePresignedURL(presigned.url, file, presigned.headers, (loadedBytes) => { + onProgress?.({ + mode: "direct", + loadedBytes: Math.min(loadedBytes, file.size), + totalBytes: file.size, + }); + }); onProgress?.({ mode: "direct", loadedBytes: file.size, totalBytes: file.size }); const prefix = options.key.includes("/") ? options.key.slice(0, options.key.lastIndexOf("/")) : ""; const listed = await apiRequest( diff --git a/tests/frontend/object-storage-upload.test.mjs b/tests/frontend/object-storage-upload.test.mjs index 7407701f..cdb3a2dc 100644 --- a/tests/frontend/object-storage-upload.test.mjs +++ b/tests/frontend/object-storage-upload.test.mjs @@ -7,8 +7,36 @@ import { objectStorageMultipartParts, objectStorageUploadMode, parseObjectStorageUploadETag, + uploadObjectStoragePresignedURL, } from "../../src/lib/object-storage-upload.js"; +class FakeUploadRequest { + upload = {}; + headers = new Map(); + responseHeaders = new Map(); + responseText = ""; + status = 0; + withCredentials = true; + + open(method, url, async) { + this.method = method; + this.url = url; + this.async = async; + } + + setRequestHeader(name, value) { + this.headers.set(name.toLowerCase(), value); + } + + getResponseHeader(name) { + return this.responseHeaders.get(name.toLowerCase()) || null; + } + + send(body) { + this.body = body; + } +} + test("objectStorageUploadMode chooses direct below threshold and multipart at threshold", () => { assert.equal(objectStorageUploadMode(DIRECT_UPLOAD_THRESHOLD_BYTES - 1), "direct"); assert.equal(objectStorageUploadMode(DIRECT_UPLOAD_THRESHOLD_BYTES), "multipart"); @@ -30,3 +58,63 @@ test("parseObjectStorageUploadETag strips quotes and rejects empty values", () = assert.equal(parseObjectStorageUploadETag(""), ""); assert.equal(parseObjectStorageUploadETag(null), ""); }); + +test("uploadObjectStoragePresignedURL sends PUT without credentials and reports progress", async () => { + const request = new FakeUploadRequest(); + const progress = []; + const body = new Blob(["acceptance payload"]); + const upload = uploadObjectStoragePresignedURL( + "https://bucket.example.com/path?authorization=redacted", + body, + { "Content-Type": "text/plain", Empty: "" }, + (loadedBytes, totalBytes) => progress.push({ loadedBytes, totalBytes }), + () => request, + ); + + assert.equal(request.method, "PUT"); + assert.equal(request.async, true); + assert.equal(request.withCredentials, false); + assert.equal(request.headers.get("content-type"), "text/plain"); + assert.equal(request.headers.has("empty"), false); + assert.equal(request.body, body); + + request.upload.onprogress({ lengthComputable: true, loaded: 5, total: body.size }); + request.status = 200; + request.responseHeaders.set("etag", '"etag-123"'); + request.onload(); + + const response = await upload; + assert.deepEqual(progress, [{ loadedBytes: 5, totalBytes: body.size }]); + assert.equal(response.status, 200); + assert.equal(response.headers.get("ETag"), '"etag-123"'); +}); + +test("uploadObjectStoragePresignedURL preserves BOS HTTP errors", async () => { + const request = new FakeUploadRequest(); + const upload = uploadObjectStoragePresignedURL( + "https://bucket.example.com/path?authorization=redacted", + new Blob(["payload"]), + undefined, + undefined, + () => request, + ); + request.status = 403; + request.responseText = "SignatureDoesNotMatch"; + request.onload(); + + await assert.rejects(upload, /SignatureDoesNotMatch/); +}); + +test("uploadObjectStoragePresignedURL reports browser network failures without leaking the signed URL", async () => { + const request = new FakeUploadRequest(); + const signedURL = "https://bucket.example.com/path?authorization=secret"; + const upload = uploadObjectStoragePresignedURL(signedURL, new Blob(["payload"]), undefined, undefined, () => request); + request.onerror(); + + await assert.rejects(upload, (error) => { + assert.match(error.message, /bucket\.example\.com/); + assert.doesNotMatch(error.message, /authorization=secret/); + assert.match(error.message, /BOS CORS/); + return true; + }); +});