🐛 Fix browser object storage uploads

This commit is contained in:
eust-w 2026-07-11 00:00:30 +08:00
parent a2423dafa7
commit d097d32aa5
3 changed files with 185 additions and 33 deletions

View File

@ -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<string, string> | 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);
});
}

View File

@ -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<T>(path: string, formData: FormData) {
return (await response.json()) as T;
}
function mergeUploadHeaders(headers?: Record<string, string>) {
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<string, string>) {
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<number, number>();
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<ObjectStorageBrowseResult>(

View File

@ -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;
});
});