@electerm/electerm-react 1.72.48 → 1.80.3

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

@@ -0,0 +1,582 @@
+import { Component } from 'react'
+import copy from 'json-deep-copy'
+import { isFunction } from 'lodash-es'
+import generate from '../../common/uid'
+import { typeMap, transferTypeMap, fileOperationsMap, fileActions } from '../../common/constants'
+import fs from '../../common/fs'
+import format, { computeLeftTime, computePassedTime } from './transfer-speed-format'
+import {
+  getLocalFileInfo,
+  getRemoteFileInfo,
+  getFolderFromFilePath
+} from '../sftp/file-read'
+import resolve from '../../common/resolve'
+import { refsTransfers, refsStatic, refs } from '../common/ref'
+import './transfer.styl'
+
+const { assign } = Object
+
+export default class TransportAction extends Component {
+  constructor (props) {
+    super(props)
+    this.sessionId = props.transfer.sessionId
+    const {
+      id,
+      transferBatch = ''
+    } = props.transfer
+    this.id = `tr-${transferBatch}-${id}`
+    refsTransfers.add(this.id, this)
+    this.total = 0
+    this.transferred = 0
+  }
+
+  componentDidMount () {
+    if (this.props.inited) {
+      this.initTransfer()
+    }
+  }
+
+  componentDidUpdate (prevProps) {
+    if (
+      prevProps.inited !== this.props.inited &&
+      this.props.inited === true
+    ) {
+      this.initTransfer()
+    }
+    if (
+      this.props.pausing !== prevProps.pausing
+    ) {
+      if (this.props.pausing) {
+        this.pause()
+      } else {
+        this.resume()
+      }
+    }
+  }
+
+  componentWillUnmount () {
+    this.transport && this.transport.destroy()
+    this.transport = null
+    this.fromFile = null
+    refsTransfers.remove(this.id)
+  }
+
+  localCheckExist = (path) => {
+    return getLocalFileInfo(path).catch(console.log)
+  }
+
+  remoteCheckExist = (path, sessionId) => {
+    // return true
+    const sftp = refs.get('sftp-' + sessionId)?.sftp
+    if (!sftp) {
+      console.log('remoteCheckExist error', 'sftp not exist')
+      return false
+    }
+    return getRemoteFileInfo(sftp, path)
+      .then(r => r)
+      .catch((e) => {
+        console.log('remoteCheckExist error', e)
+        return false
+      })
+  }
+
+  checkExist = (type, path, sessionId) => {
+    return this[type + 'CheckExist'](path, sessionId)
+  }
+
+  update = (up) => {
+    const { id } = this.props.transfer
+    refsStatic.get('transfer-queue')?.addToQueue(
+      'update',
+      id,
+      up
+    )
+  }
+
+  tagTransferError = (id, errorMsg) => {
+    // this.clear()
+    const { store } = window
+    const { fileTransfers } = store
+    const index = fileTransfers.findIndex(d => d.id === id)
+    if (index < 0) {
+      return
+    }
+
+    const tr = copy(fileTransfers[index])
+    assign(tr, {
+      host: tr.host,
+      error: errorMsg,
+      finishTime: Date.now()
+    })
+    store.addTransferHistory(tr)
+    refsStatic.get('transfer-queue')?.addToQueue(
+      'delete',
+      id
+    )
+  }
+
+  // insert = (insts) => {
+  //   const { fileTransfers } = window.store
+  //   const { index } = this.props
+  //   fileTransfers.splice(index, 1, ...insts)
+  // }
+
+  remoteList = () => {
+    window.store.remoteList(this.sessionId)
+  }
+
+  localList = () => {
+    window.store.localList(this.sessionId)
+  }
+
+  onEnd = (update = {}) => {
+    if (this.onCancel) {
+      return
+    }
+    const {
+      transfer,
+      config
+    } = this.props
+    const {
+      typeTo
+    } = transfer
+    const finishTime = Date.now()
+    if (!config.disableTransferHistory) {
+      const fromFile = transfer.fromFile || this.fromFile
+      const size = update.size || fromFile.size
+      const r = copy(transfer)
+      assign(r, {
+        finishTime,
+        startTime: this.startTime,
+        size,
+        next: null,
+        speed: format(size, this?.startTime)
+      })
+      window.store.addTransferHistory(
+        r
+      )
+    }
+    const cbs = [
+      this[typeTo + 'List']
+    ]
+    const cb = () => {
+      cbs.forEach(cb => cb())
+    }
+    this.cancel(cb)
+  }
+
+  onData = (transferred) => {
+    if (this.onCancel) {
+      return
+    }
+    const { transfer } = this.props
+    const up = {}
+    const total = transfer.fromFile.size
+    let percent = total === 0
+      ? 0
+      : Math.floor(100 * transferred / total)
+    percent = percent >= 100 ? 99 : percent
+    up.percent = percent
+    up.status = 'active'
+    up.transferred = transferred
+    up.startTime = this.startTime
+    up.speed = format(transferred, up.startTime)
+    assign(
+      up,
+      computeLeftTime(transferred, total, up.startTime)
+    )
+    up.passedTime = computePassedTime(up.startTime)
+    this.update(up)
+  }
+
+  cancel = (callback) => {
+    if (this.onCancel) {
+      return
+    }
+    this.onCancel = true
+    this.transport && this.transport.destroy()
+    this.transport = null
+    // window.store.cancelTransfer(this.props.transfer.id)
+    refsStatic.get('transfer-queue')?.addToQueue(
+      'delete',
+      this.props.transfer.id
+    )
+    if (isFunction(callback)) {
+      callback()
+    }
+  }
+
+  pause = () => {
+    this.transport?.pause()
+  }
+
+  resume = () => {
+    this.transport?.resume()
+  }
+
+  mvOrCp = () => {
+    const {
+      transfer
+    } = this.props
+    const {
+      fromPath,
+      toPath,
+      typeFrom,
+      sessionId,
+      operation // 'mv' or 'cp'
+    } = transfer
+
+    let finalToPath = toPath
+
+    // Check if it's a copy operation to the same path
+    if (fromPath === toPath && operation === fileOperationsMap.cp) {
+      finalToPath = this.handleRename(toPath, typeFrom === typeMap.remote)
+      transfer.toPath = finalToPath
+      this.update({
+        toPath: finalToPath
+      })
+    }
+    if (typeFrom === typeMap.local) {
+      return fs[operation](fromPath, finalToPath)
+        .then(this.onEnd)
+        .catch(e => {
+          this.onEnd()
+          this.onError(e)
+        })
+    }
+    const sftp = refs.get('sftp-' + sessionId)?.sftp
+    return sftp[operation](fromPath, finalToPath)
+      .then(this.onEnd)
+      .catch(e => {
+        this.onEnd()
+        this.onError(e)
+      })
+  }
+
+  transferFile = async (transfer = this.props.transfer) => {
+    const {
+      fromPath,
+      typeFrom,
+      toFile = {}
+    } = transfer
+    const toPath = this.newPath || transfer.toPath
+    const fromFile = transfer.fromFile || this.fromFile
+    const fromMode = fromFile.mode
+    const transferType = typeFrom === typeMap.local ? transferTypeMap.upload : transferTypeMap.download
+    const isDown = transferType === transferTypeMap.download
+    const localPath = isDown
+      ? toPath
+      : fromPath
+    const remotePath = isDown
+      ? fromPath
+      : toPath
+    const mode = toFile.mode || fromMode
+    const sftp = refs.get('sftp-' + this.sessionId).sftp
+    this.transport = await sftp[transferType]({
+      remotePath,
+      localPath,
+      options: { mode },
+      onData: this.onData,
+      onError: this.onError,
+      onEnd: this.onEnd
+    })
+  }
+
+  isTransferAction = (action) => {
+    return action.includes('rename') || action === 'transfer'
+  }
+
+  initTransfer = async () => {
+    if (this.started) {
+      return
+    }
+    this.started = true
+    const { transfer } = this.props
+    const {
+      id,
+      typeFrom,
+      typeTo,
+      fromPath,
+      toPath,
+      operation
+    } = transfer
+
+    if (
+      typeFrom === typeTo &&
+      fromPath === toPath &&
+      operation === fileOperationsMap.mv
+    ) {
+      return this.cancel()
+    }
+
+    const t = Date.now()
+    this.update({
+      startTime: t
+    })
+    this.startTime = t
+
+    const fromFile = transfer.fromFile
+      ? transfer.fromFile
+      : await this.checkExist(typeFrom, fromPath, this.sessionId)
+    if (!fromFile) {
+      return this.tagTransferError(id, 'file not exist')
+    }
+    this.fromFile = fromFile
+    this.update({
+      fromFile
+    })
+    if (fromPath === toPath && typeFrom === typeTo) {
+      return this.mvOrCp()
+    }
+    const hasConflict = await this.checkConflict()
+    if (hasConflict) {
+      return
+    }
+
+    if (typeFrom === typeTo) {
+      return this.mvOrCp()
+    }
+    this.startTransfer()
+  }
+
+  checkConflict = async (transfer = this.props.transfer) => {
+    const {
+      typeTo,
+      toPath,
+      sessionId
+    } = transfer
+    const transferStillExists = window.store.fileTransfers.some(t => t.id === transfer.id)
+    if (!transferStillExists) {
+      return false
+    }
+    const toFile = await this.checkExist(typeTo, toPath, sessionId)
+
+    if (toFile) {
+      this.update({
+        toFile
+      })
+      if (transfer.resolvePolicy) {
+        return this.onDecision(transfer.resolvePolicy)
+      }
+      if (this.resolvePolicy) {
+        return this.onDecision(this.resolvePolicy)
+      }
+      const transferWithToFile = {
+        ...copy(transfer),
+        toFile,
+        fromFile: copy(transfer.fromFile || this.fromFile)
+      }
+      refsStatic.get('transfer-conflict')?.addConflict(transferWithToFile)
+      return true
+    }
+  }
+
+  onDecision = (policy) => {
+    if (policy === fileActions.skip || policy === fileActions.cancel) {
+      return this.onEnd()
+    }
+
+    if (policy === fileActions.rename) {
+      const {
+        typeTo,
+        toPath
+      } = this.props.transfer
+      const newPath = this.handleRename(toPath, typeTo === typeMap.remote)
+      this.update({
+        toPath: newPath
+      })
+      this.newPath = newPath
+    }
+
+    this.startTransfer()
+  }
+
+  startTransfer = async () => {
+    const { fromFile = this.fromFile } = this.props.transfer
+
+    if (!fromFile.isDirectory) {
+      return this.transferFile()
+    }
+    await this.transferFolderRecursive()
+    this.onEnd({
+      transferred: this.transferred,
+      size: this.total
+    })
+  }
+
+  list = async (type, path, sessionId) => {
+    const sftp = refs.get('sftp-' + sessionId)
+    return sftp[type + 'List'](true, path)
+  }
+
+  handleRename = (fromPath, isRemote) => {
+    const { path, base, ext } = getFolderFromFilePath(fromPath, isRemote)
+    const newName = `${base}(rename-${generate()})${ext ? '.' + ext : ''}`
+    return resolve(path, newName)
+  }
+
+  onFolderData = (transferred) => {
+    if (this.onCancel) {
+      return
+    }
+    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
+    up.status = 'active'
+    up.transferred = this.transferred
+    up.startTime = this.startTime
+    up.speed = format(this.transferred, up.startTime)
+    assign(
+      up,
+      computeLeftTime(this.transferred, this.total, up.startTime)
+    )
+    up.passedTime = computePassedTime(up.startTime)
+    this.update(up)
+  }
+
+  transferFileAsSubTransfer = async (transfer) => {
+    const {
+      fromPath,
+      toPath,
+      typeFrom,
+      fromFile: {
+        mode: fromMode,
+        size: fileSize
+      },
+      toFile = {}
+    } = transfer
+
+    const transferType = typeFrom === typeMap.local ? transferTypeMap.upload : transferTypeMap.download
+    const isDown = transferType === transferTypeMap.download
+    const localPath = isDown ? toPath : fromPath
+    const remotePath = isDown ? fromPath : toPath
+    const mode = toFile.mode || fromMode
+    const sftp = refs.get('sftp-' + this.sessionId).sftp
+
+    return new Promise((resolve, reject) => {
+      let transport
+
+      const onSubEnd = () => {
+        if (fileSize) {
+          this.onFolderData(fileSize)
+        }
+        if (transport) {
+          transport.destroy()
+          transport = null
+        }
+        resolve(fileSize)
+      }
+
+      const onSubError = (error) => {
+        if (transport) {
+          transport.destroy()
+          transport = null
+        }
+        reject(error)
+      }
+
+      sftp[transferType]({
+        remotePath,
+        localPath,
+        options: { mode },
+        onData: () => {},
+        onError: onSubError,
+        onEnd: onSubEnd
+      }).then(transportInstance => {
+        transport = transportInstance
+      }).catch(onSubError)
+    })
+  }
+
+  getDefaultTransfer = () => {
+    const transfer = this.props.transfer
+    if (this.newPath) {
+      const modifiedTransfer = {
+        ...transfer,
+        toPath: this.newPath,
+        isRenamed: true
+      }
+      return modifiedTransfer
+    }
+    return transfer
+  }
+
+  transferFolderRecursive = async (transfer = this.getDefaultTransfer()) => {
+    if (this.onCancel) {
+      return
+    }
+    const {
+      fromPath,
+      toPath,
+      typeFrom,
+      typeTo,
+      sessionId,
+      toFile,
+      isRenamed
+    } = transfer
+    if (!toFile || isRenamed) {
+      const folderCreated = await this.mkdir(transfer)
+      if (!folderCreated) {
+        return
+      }
+    }
+    const list = await this.list(typeFrom, fromPath, sessionId)
+
+    for (const item of list) {
+      if (!item.isDirectory) {
+        this.total += item.size
+      }
+      const fromItemPath = resolve(fromPath, item.name)
+      const toItemPath = resolve(toPath, item.name)
+
+      const itemTransfer = {
+        ...transfer,
+        fromPath: fromItemPath,
+        toPath: toItemPath,
+        fromFile: item
+      }
+
+      const toFile = await this.checkExist(typeTo, toItemPath, sessionId)
+      itemTransfer.toFile = toFile
+      if (item.isDirectory) {
+        await this.transferFolderRecursive(itemTransfer)
+      } else {
+        await this.transferFileAsSubTransfer(itemTransfer)
+      }
+    }
+  }
+
+  onError = (e) => {
+    const up = {
+      status: 'exception',
+      error: e.message
+    }
+    this.onEnd(up)
+    window.store.onError(e)
+  }
+
+  mkdir = async (transfer = this.props.transfer) => {
+    const {
+      typeTo,
+      toPath,
+      sessionId
+    } = transfer
+    if (typeTo === typeMap.local) {
+      return fs.mkdir(toPath)
+        .then(() => true)
+        .catch(() => false)
+    }
+    const sftp = refs.get('sftp-' + sessionId).sftp
+    return sftp.mkdir(toPath)
+      .then(() => true)
+      .catch(() => false)
+  }
+
+  render () {
+    return null
+  }
+}

package/client/components/{sftp → file-transfer}/transports-action-store.jsx

@@ -6,6 +6,8 @@
 import { Component } from 'react'
 import Transports from './transports-ui-store'
 import { maxTransport } from '../../common/constants'
+import { refsStatic } from '../common/ref'
+// import { action } from 'manate'
 
 export default class TransportsActionStore extends Component {
   componentDidMount () {
@@ -26,21 +28,26 @@ export default class TransportsActionStore extends Component {
       fileTransfers
     } = store
 
-    fileTransfers.forEach(t => {
+    // First loop: Handle same type transfers
+    for (const t of fileTransfers) {
       const {
         typeTo,
         typeFrom,
-        fromFile,
-        inited
+        inited,
+        id
       } = t
-      const ready = !!fromFile
-      if (typeTo === typeFrom && ready && !inited) {
-        t.inited = true
+      if (typeTo === typeFrom && !inited) {
+        refsStatic.get('transfer-queue')?.addToQueue(
+          'update',
+          id,
+          {
+            inited: true
+          }
+        )
       }
-    })
-    // if (pauseAllTransfer) {
-    //   return store.setFileTransfers(fileTransfers)
-    // }
+    }
+
+    // Count active transfers
     let count = fileTransfers.filter(t => {
       const {
         typeTo,
@@ -50,44 +57,40 @@ export default class TransportsActionStore extends Component {
       } = t
       return typeTo !== typeFrom && inited && pausing !== true
     }).length
+
     if (count >= maxTransport) {
       return
     }
+
+    // Second loop: Process pending transfers
     const len = fileTransfers.length
-    // const ids = []
+
     for (let i = 0; i < len; i++) {
       const tr = fileTransfers[i]
       const {
         typeTo,
         typeFrom,
         inited,
-        fromFile,
-        action
+        id
       } = tr
-      // if (!error) {
-      //   ids.push(id)
-      // }
+
       const isTransfer = typeTo !== typeFrom
-      const ready = (
-        action && fromFile
-      )
-      if (
-        !ready ||
-        inited ||
-        !isTransfer
-      ) {
+
+      if (inited || !isTransfer) {
         continue
       }
-      // if (isTransfer && tr.fromFile.isDirectory) {
-      //   i = len
-      //   continue
-      // }
-      if (
-        fromFile && count < maxTransport
-      ) {
+
+      if (count < maxTransport) {
         count++
-        tr.inited = true
+        refsStatic.get('transfer-queue')?.addToQueue(
+          'update',
+          id,
+          {
+            inited: true
+          }
+        )
       }
+
       if (count >= maxTransport) {
         break
       }

package/client/components/{sftp → file-transfer}/transports-ui-store.jsx

@@ -2,7 +2,7 @@
  * transporter UI component
  */
 
-import Transport from './transport-action-store'
+import Transport from './transfer'
 
 export default function TransportsUI (props) {
   const { fileTransfers } = props
@@ -22,7 +22,7 @@ export default function TransportsUI (props) {
     return (
       <Transport
         {...trProps}
-        key={id + ':tr:' + i}
+        key={id}
       />
     )
   })