webui/kpm: write parallelly in uploadFile

Author: KOWX712

webui/page/kpm.js

@@ -154,35 +154,80 @@ async function renderKpmList() {
 
 async function uploadFile(file, targetPath, onProgress, signal) {
     const CHUNK_SIZE = 96 * 1024; // 96KB chunks
-    let offset = 0;
+    const totalChunks = Math.ceil(file.size / CHUNK_SIZE);
+    const CONCURRENCY = 8;
 
-    await exec(`mkdir -p "$(dirname "${targetPath}")" && : > "${targetPath}"`);
+    await exec(`mkdir -p "$(dirname "${targetPath}")"`);
+
+    let uploadedBytes = 0;
+    let nextChunkIdx = 0;
+
+    const processChunk = async (index) => {
+        if (signal?.aborted) return;
+
+        const start = index * CHUNK_SIZE;
+        const end = Math.min(start + CHUNK_SIZE, file.size);
+        const chunk = file.slice(start, end);
 
-    while (offset < file.size) {
-        if (signal?.aborted) throw new DOMException('Aborted', 'AbortError');
-        const chunk = file.slice(offset, offset + CHUNK_SIZE);
         const base64 = await new Promise((resolve, reject) => {
             const reader = new FileReader();
             reader.onload = () => resolve(reader.result.split(',')[1]);
             reader.onerror = reject;
             reader.readAsDataURL(chunk);
         });
 
-        const result = await new Promise((resolve, reject) => {
-            const child = spawn(`echo '${base64}' | base64 -d >> "${targetPath}"`);
-            child.on('exit', (code) => {
-                if (code === 0) resolve({ errno: 0 });
-                else resolve({ errno: code, stderr: `Exit code ${code}` });
-            });
-            child.on('error', (err) => reject(err));
+        const partPath = `${targetPath}.part${index}`;
+        const result = await new Promise((resolve) => {
+            const child = spawn(`echo '${base64}' | base64 -d > "${partPath}"`);
+            child.on('exit', (code) => resolve({ errno: code }));
         });
 
         if (result.errno !== 0) {
-            throw new Error(result.stderr || 'Write error');
+            throw new Error(`Write error at chunk ${index}`);
         }
 
-        offset += CHUNK_SIZE;
-        if (onProgress) onProgress(Math.min(offset, file.size) / file.size);
+        uploadedBytes += (end - start);
+        if (onProgress) {
+            onProgress(uploadedBytes / file.size);
+        }
+    };
+
+    try {
+        const workers = [];
+        for (let i = 0; i < Math.min(CONCURRENCY, totalChunks); i++) {
+            workers.push((async () => {
+                while (nextChunkIdx < totalChunks && !signal?.aborted) {
+                    const index = nextChunkIdx++;
+                    await processChunk(index);
+                }
+            })());
+        }
+
+        await Promise.all(workers);
+
+        if (signal?.aborted) throw new DOMException('Aborted', 'AbortError');
+
+        // Combine files
+        await exec(`: > "${targetPath}"`);
+        const BATCH_SIZE = 500;
+        for (let i = 0; i < totalChunks; i += BATCH_SIZE) {
+            const batch = [];
+            for (let j = i; j < Math.min(i + BATCH_SIZE, totalChunks); j++) {
+                batch.push(`"${targetPath}.part${j}"`);
+            }
+            const partsStr = batch.join(' ');
+            const combineResult = await new Promise((resolve) => {
+                const child = spawn(`cat ${partsStr} >> "${targetPath}" && rm -f ${partsStr}`);
+                child.on('exit', (code) => resolve({ errno: code }));
+                child.on('error', (err) => resolve({ errno: -1, stderr: err.message }));
+            });
+            if (combineResult.errno !== 0) {
+                throw new Error(combineResult.stderr || 'Merge error');
+            }
+        }
+    } catch (err) {
+        await exec(`rm -f "${targetPath}.part"*`);
+        throw err;
     }
 }