@electerm/electerm-react 1.80.5 → 1.80.6

package/client/components/file-transfer/transfer.jsx

@@ -28,6 +28,7 @@ export default class TransportAction extends Component {
     refsTransfers.add(this.id, this)
     this.total = 0
     this.transferred = 0
+    this.currentProgress = 1
   }
 
   componentDidMount () {
@@ -421,11 +422,11 @@ export default class TransportAction extends Component {
     }
     this.transferred += transferred
     const up = {}
-    let percent = this.total === 0
-      ? 0
-      : Math.floor(100 * this.transferred / this.total)
-    percent = percent >= 100 ? 99 : percent
-    up.percent = percent
+
+    // Increment progress slightly with each file/folder (but never exceed 99%)
+    this.currentProgress = Math.min(this.currentProgress + 0.2, 99)
+
+    up.percent = Math.floor(this.currentProgress)
     up.status = 'active'
     up.transferred = this.transferred
     up.startTime = this.startTime
@@ -505,49 +506,157 @@ export default class TransportAction extends Component {
     return transfer
   }
 
-  transferFolderRecursive = async (transfer = this.getDefaultTransfer()) => {
+  // Handle file transfers in parallel batches
+  transferFiles = async (files, batch, transfer) => {
+    if (this.onCancel) {
+      return
+    }
+
+    const { fromPath, toPath } = transfer
+
+    // Process files in batches
+    for (let i = 0; i < files.length; i += batch) {
+      if (this.onCancel) {
+        return
+      }
+
+      const batchFiles = files.slice(i, i + batch)
+      const promises = batchFiles.map(file => {
+        if (this.onCancel) {
+          return Promise.resolve(0)
+        }
+
+        const fromItemPath = resolve(fromPath, file.name)
+        const toItemPath = resolve(toPath, file.name)
+
+        const itemTransfer = {
+          ...transfer,
+          fromPath: fromItemPath,
+          toPath: toItemPath,
+          fromFile: file
+        }
+
+        return this.transferFileAsSubTransfer(itemTransfer)
+      })
+
+      // Wait for all files in batch to complete
+      const results = await Promise.all(promises)
+
+      // Update progress once for the entire batch
+      const batchTotalSize = results.reduce((sum, size) => sum + size, 0)
+      if (batchTotalSize > 0) {
+        this.onFolderData(batchTotalSize)
+      }
+    }
+  }
+
+  // Handle folder transfers sequentially to prevent concurrency explosion
+  transferFolders = async (folders, batch, transfer) => {
+    if (this.onCancel) {
+      return
+    }
+
+    const { fromPath, toPath } = transfer
+
+    // Step 1: Create all folders concurrently in batches
+    for (let i = 0; i < folders.length; i += batch) {
+      if (this.onCancel) {
+        return
+      }
+
+      const batchFolders = folders.slice(i, i + batch)
+      const createFolderPromises = batchFolders.map(folder => {
+        const toItemPath = resolve(toPath, folder.name)
+
+        // Create folder itself (don't process contents)
+        const createTransfer = {
+          ...transfer,
+          toPath: toItemPath,
+          fromFile: folder
+        }
+
+        return this.mkdir(createTransfer)
+      })
+
+      // Create all folders in this batch concurrently
+      await Promise.all(createFolderPromises)
+    }
+
+    // Step 2: Process contents of each folder sequentially
+    for (const folder of folders) {
+      if (this.onCancel) {
+        return
+      }
+
+      const fromItemPath = resolve(fromPath, folder.name)
+      const toItemPath = resolve(toPath, folder.name)
+
+      const itemTransfer = {
+        ...transfer,
+        fromPath: fromItemPath,
+        toPath: toItemPath,
+        fromFile: folder
+      }
+
+      // Transfer folder contents (set createFolder = false since we already created it)
+      await this.transferFolderRecursive(itemTransfer, false)
+    }
+  }
+
+  // Main recursive function using the separate handlers
+  transferFolderRecursive = async (transfer = this.getDefaultTransfer(), createFolder = true) => {
     if (this.onCancel) {
       return
     }
     const {
       fromPath,
-      toPath,
       typeFrom,
-      typeTo,
       sessionId,
       toFile,
       isRenamed
     } = transfer
-    if (!toFile || isRenamed) {
+
+    if (createFolder && (!toFile || isRenamed)) {
       const folderCreated = await this.mkdir(transfer)
       if (!folderCreated) {
         return
       }
     }
+
     const list = await this.list(typeFrom, fromPath, sessionId)
+    const bigFileSize = 1024 * 1024
+    const smallFilesBatch = 30
+    const BigFilesBatch = 3
+    const foldersBatch = 50
 
-    for (const item of list) {
-      if (!item.isDirectory) {
-        this.total += item.size
+    const {
+      folders,
+      smallFiles,
+      largeFiles
+    } = list.reduce((p, c) => {
+      if (c.isDirectory) {
+        p.folders.push(c)
+      } else {
+        this.total += c.size
+        if (c.size < bigFileSize) {
+          p.smallFiles.push(c)
+        } else {
+          p.largeFiles.push(c)
+        }
       }
-      const fromItemPath = resolve(fromPath, item.name)
-      const toItemPath = resolve(toPath, item.name)
+      return p
+    }, {
+      folders: [],
+      smallFiles: [],
+      largeFiles: []
+    })
 
-      const itemTransfer = {
-        ...transfer,
-        fromPath: fromItemPath,
-        toPath: toItemPath,
-        fromFile: item
-      }
+    // Process files with parallel batching
+    await this.transferFiles(smallFiles, smallFilesBatch, transfer)
+    await this.transferFiles(largeFiles, BigFilesBatch, transfer)
 
-      const toFile = await this.checkExist(typeTo, toItemPath, sessionId)
-      itemTransfer.toFile = toFile
-      if (item.isDirectory) {
-        await this.transferFolderRecursive(itemTransfer)
-      } else {
-        await this.transferFileAsSubTransfer(itemTransfer)
-      }
-    }
+    // Process folders sequentially
+    await this.transferFolders(folders, foldersBatch, transfer)
   }
 
   onError = (e) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@electerm/electerm-react",
-  "version": "1.80.5",
+  "version": "1.80.6",
   "description": "react components src for electerm",
   "main": "./client/components/main/main.jsx",
   "license": "MIT",