#25 new: sftp upload

lib/data/model/app/error.dart

@@ -15,6 +15,21 @@ abstract class Err<T> {
   Err({required this.from, required this.type, this.message});
 }
 
+enum SSHErrType {
+  unknown,
+  noPrivateKey;
+}
+
+class SSHErr extends Err<SSHErrType> {
+  SSHErr({required SSHErrType type, String? message})
+      : super(from: ErrFrom.ssh, type: type, message: message);
+
+  @override
+  String toString() {
+    return 'SSHErr<$type>: $message';
+  }
+}
+
 enum DockerErrType {
   unknown,
   noClient,

lib/data/model/sftp/download_item.dart

@@ -1,16 +0,0 @@
-import '../server/server_private_info.dart';
-
-class DownloadItem {
-  DownloadItem(this.spi, this.remotePath, this.localPath);
-
-  final ServerPrivateInfo spi;
-  final String remotePath;
-  final String localPath;
-}
-
-class DownloadItemEvent {
-  DownloadItemEvent(this.item, this.privateKey);
-
-  final DownloadItem item;
-  final String? privateKey;
-}

lib/data/model/sftp/download_worker.dart

@@ -1,97 +0,0 @@
-import 'dart:async';
-import 'dart:io';
-import 'dart:isolate';
-
-import 'package:dartssh2/dartssh2.dart';
-import 'package:easy_isolate/easy_isolate.dart';
-
-import 'download_item.dart';
-import 'download_status.dart';
-
-class SftpDownloadWorker {
-  SftpDownloadWorker(
-      {required this.onNotify, required this.item, this.privateKey});
-
-  final Function(Object event) onNotify;
-  final DownloadItem item;
-  final worker = Worker();
-  final String? privateKey;
-
-  void dispose() {
-    worker.dispose();
-  }
-
-  /// Initiate the worker (new thread) and start listen from messages between
-  /// the threads
-  Future<void> init() async {
-    if (worker.isInitialized) worker.dispose();
-    await worker.init(
-      mainMessageHandler,
-      isolateMessageHandler,
-      errorHandler: print,
-    );
-    worker.sendMessage(DownloadItemEvent(item, privateKey));
-  }
-
-  /// Handle the messages coming from the isolate
-  void mainMessageHandler(dynamic data, SendPort isolateSendPort) {
-    onNotify(data);
-  }
-
-  /// Handle the messages coming from the main
-  static isolateMessageHandler(
-      dynamic data, SendPort mainSendPort, SendErrorFunction sendError) async {
-    if (data is DownloadItemEvent) {
-      try {
-        mainSendPort.send(SftpWorkerStatus.preparing);
-        final watch = Stopwatch()..start();
-        final item = data.item;
-        final spi = item.spi;
-        final socket = await SSHSocket.connect(spi.ip, spi.port);
-        SSHClient client;
-        if (spi.pubKeyId == null) {
-          client = SSHClient(socket,
-              username: spi.user, onPasswordRequest: () => spi.pwd);
-        } else {
-          client = SSHClient(socket,
-              username: spi.user,
-              identities: SSHKeyPair.fromPem(data.privateKey!));
-        }
-        mainSendPort.send(SftpWorkerStatus.sshConnectted);
-
-        final remotePath = item.remotePath;
-        final localPath = item.localPath;
-        await Directory(localPath.substring(0, item.localPath.lastIndexOf('/')))
-            .create(recursive: true);
-        final local = File(localPath);
-        if (await local.exists()) {
-          await local.delete();
-        }
-        final localFile = local.openWrite(mode: FileMode.append);
-        final file = await (await client.sftp()).open(remotePath);
-        final size = (await file.stat()).size;
-        if (size == null) {
-          mainSendPort.send(Exception('can not get file size'));
-          return;
-        }
-        const defaultChunkSize = 1024 * 1024;
-        final chunkSize = size > defaultChunkSize ? defaultChunkSize : size;
-        mainSendPort.send(size);
-        mainSendPort.send(SftpWorkerStatus.downloading);
-        for (var i = 0; i < size; i += chunkSize) {
-          final fileData = file.read(length: chunkSize);
-          await for (var form in fileData) {
-            localFile.add(form);
-            mainSendPort.send((i + form.length) / size * 100);
-          }
-        }
-        await localFile.close();
-        await file.close();
-        mainSendPort.send(watch.elapsed);
-        mainSendPort.send(SftpWorkerStatus.finished);
-      } catch (e) {
-        mainSendPort.send(e);
-      }
-    }
-  }
-}

lib/data/model/sftp/req.dart

@@ -1,12 +1,29 @@
-import 'package:toolbox/data/model/sftp/download_worker.dart';
+import '../server/server_private_info.dart';
+import 'worker.dart';
 
-import 'download_item.dart';
+class SftpReqItem {
+  final ServerPrivateInfo spi;
+  final String remotePath;
+  final String localPath;
 
-class SftpDownloadStatus {
+  SftpReqItem(this.spi, this.remotePath, this.localPath);
+}
+
+enum SftpReqType { download, upload }
+
+class SftpReq {
+  final SftpReqItem item;
+  final String? privateKey;
+  final SftpReqType type;
+
+  SftpReq({required this.item, this.privateKey, required this.type});
+}
+
+class SftpReqStatus {
   final int id;
-  final DownloadItem item;
+  final SftpReqItem item;
   final void Function() notifyListeners;
-  late SftpDownloadWorker worker;
+  late SftpWorker worker;
 
   String get fileName => item.localPath.split('/').last;
 
@@ -17,16 +34,23 @@ class SftpDownloadStatus {
   Exception? error;
   Duration? spentTime;
 
-  SftpDownloadStatus(this.item, this.notifyListeners, {String? key})
-      : id = DateTime.now().microsecondsSinceEpoch {
-    worker =
-        SftpDownloadWorker(onNotify: onNotify, item: item, privateKey: key);
+  SftpReqStatus({
+    required this.item,
+    required this.notifyListeners,
+    required SftpReqType type,
+    String? key,
+  }) : id = DateTime.now().microsecondsSinceEpoch {
+    worker = SftpWorker(
+      onNotify: onNotify,
+      item: item,
+      privateKey: key,
+      type: type,
+    );
     worker.init();
   }
 
   @override
-  bool operator ==(Object other) =>
-      other is SftpDownloadStatus && id == other.id;
+  bool operator ==(Object other) => other is SftpReqStatus && id == other.id;
 
   @override
   int get hashCode => id ^ super.hashCode;

lib/data/model/sftp/worker.dart

@@ -0,0 +1,170 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:isolate';
+import 'dart:typed_data';
+
+import 'package:dartssh2/dartssh2.dart';
+import 'package:easy_isolate/easy_isolate.dart';
+import 'package:toolbox/core/utils/misc.dart';
+
+import 'req.dart';
+
+class SftpWorker {
+  final Function(Object event) onNotify;
+  final SftpReqItem item;
+  final String? privateKey;
+  final SftpReqType type;
+
+  final worker = Worker();
+
+  SftpWorker({
+    required this.onNotify,
+    required this.item,
+    required this.type,
+    this.privateKey,
+  });
+
+  void dispose() {
+    worker.dispose();
+  }
+
+  /// Initiate the worker (new thread) and start listen from messages between
+  /// the threads
+  Future<void> init() async {
+    if (worker.isInitialized) worker.dispose();
+    await worker.init(
+      mainMessageHandler,
+      isolateMessageHandler,
+      errorHandler: print,
+    );
+    worker.sendMessage(SftpReq(item: item, privateKey: privateKey, type: type));
+  }
+
+  /// Handle the messages coming from the isolate
+  void mainMessageHandler(dynamic data, SendPort isolateSendPort) {
+    onNotify(data);
+  }
+}
+
+/// Handle the messages coming from the main
+Future<void> isolateMessageHandler(
+  dynamic data,
+  SendPort mainSendPort,
+  SendErrorFunction sendError,
+) async {
+  switch (data.runtimeType) {
+    case SftpReq:
+      switch (data.type) {
+        case SftpReqType.download:
+          await _download(data, mainSendPort, sendError);
+          break;
+        case SftpReqType.upload:
+          await _upload(data, mainSendPort, sendError);
+          break;
+        default:
+          sendError(Exception('unknown type'));
+      }
+      break;
+    default:
+      sendError(Exception('unknown event'));
+  }
+}
+
+Future<void> _download(
+  SftpReq data,
+  SendPort mainSendPort,
+  SendErrorFunction sendError,
+) async {
+  try {
+    mainSendPort.send(SftpWorkerStatus.preparing);
+    final watch = Stopwatch()..start();
+    final item = data.item;
+    final spi = item.spi;
+    final socket = await SSHSocket.connect(spi.ip, spi.port);
+    SSHClient client;
+    if (spi.pubKeyId == null) {
+      client = SSHClient(socket,
+          username: spi.user, onPasswordRequest: () => spi.pwd);
+    } else {
+      client = SSHClient(socket,
+          username: spi.user, identities: SSHKeyPair.fromPem(data.privateKey!));
+    }
+    mainSendPort.send(SftpWorkerStatus.sshConnectted);
+
+    final remotePath = item.remotePath;
+    final localPath = item.localPath;
+    await Directory(localPath.substring(0, item.localPath.lastIndexOf('/')))
+        .create(recursive: true);
+    final local = File(localPath);
+    if (await local.exists()) {
+      await local.delete();
+    }
+    final localFile = local.openWrite(mode: FileMode.append);
+    final file = await (await client.sftp()).open(remotePath);
+    final size = (await file.stat()).size;
+    if (size == null) {
+      mainSendPort.send(Exception('can not get file size'));
+      return;
+    }
+    const defaultChunkSize = 1024 * 1024;
+    final chunkSize = size > defaultChunkSize ? defaultChunkSize : size;
+    mainSendPort.send(size);
+    mainSendPort.send(SftpWorkerStatus.downloading);
+    for (var i = 0; i < size; i += chunkSize) {
+      final fileData = file.read(length: chunkSize);
+      await for (var form in fileData) {
+        localFile.add(form);
+        mainSendPort.send((i + form.length) / size * 100);
+      }
+    }
+    await localFile.close();
+    await file.close();
+    mainSendPort.send(watch.elapsed);
+    mainSendPort.send(SftpWorkerStatus.finished);
+  } catch (e) {
+    mainSendPort.send(e);
+  }
+}
+
+Future<void> _upload(
+  SftpReq data,
+  SendPort mainSendPort,
+  SendErrorFunction sendError,
+) async {
+  try {
+    mainSendPort.send(SftpWorkerStatus.preparing);
+    final watch = Stopwatch()..start();
+    final item = data.item;
+    final spi = item.spi;
+    final socket = await SSHSocket.connect(spi.ip, spi.port);
+    SSHClient client;
+    if (spi.pubKeyId == null) {
+      client = SSHClient(socket,
+          username: spi.user, onPasswordRequest: () => spi.pwd);
+    } else {
+      client = SSHClient(socket,
+          username: spi.user, identities: SSHKeyPair.fromPem(data.privateKey!));
+    }
+    mainSendPort.send(SftpWorkerStatus.sshConnectted);
+
+    final localPath = item.localPath;
+    final remotePath =
+        item.remotePath + (getFileName(localPath) ?? 'srvbox_sftp_upload');
+    final local = File(localPath);
+    if (!await local.exists()) {
+      mainSendPort.send(Exception('local file not exists'));
+      return;
+    }
+    final localFile = local.openRead().cast<Uint8List>();
+    final sftp = await client.sftp();
+    final file = await sftp.open(remotePath,
+        mode: SftpFileOpenMode.write | SftpFileOpenMode.create);
+    final writer = file.write(localFile);
+    await writer.done;
+    await file.close();
+    mainSendPort.send(watch.elapsed);
+    mainSendPort.send(SftpWorkerStatus.finished);
+  } catch (e) {
+    mainSendPort.send(e);
+  }
+}