opt. for docker & apt

lib/data/provider/apt.dart

@@ -1,19 +1,15 @@
 import 'dart:async';
-import 'dart:convert';
 import 'dart:typed_data';
 
 import 'package:dartssh2/dartssh2.dart';
 import 'package:logging/logging.dart';
+import 'package:toolbox/core/extension/ssh_client.dart';
 import 'package:toolbox/core/extension/stringx.dart';
 import 'package:toolbox/core/extension/uint8list.dart';
 import 'package:toolbox/core/provider_base.dart';
 import 'package:toolbox/data/model/apt/upgrade_pkg_info.dart';
 import 'package:toolbox/data/model/distribution.dart';
 
-typedef PwdRequestFunc = Future<String> Function(
-    int triedTimes, String? userName);
-final pwdRequestWithUserReg = RegExp(r'\[sudo\] password for (.+):');
-
 class AptProvider extends BusyProvider {
   final logger = Logger('AptProvider');
 
@@ -29,45 +25,37 @@ class AptProvider extends BusyProvider {
   String? upgradeLog;
   String? updateLog;
   String lastLog = '';
-  int triedTimes = 0;
   bool isRequestingPwd = false;
 
   AptProvider();
 
-  Future<void> init(SSHClient client, Distribution dist, Function() onUpgrade,
-      Function() onUpdate, PwdRequestFunc onPasswordRequest) async {
+  Future<void> init(
+      SSHClient client,
+      Distribution dist,
+      Function() onUpgrade,
+      Function() onUpdate,
+      PwdRequestFunc onPasswordRequest,
+      String user) async {
     this.client = client;
     this.dist = dist;
     this.onUpgrade = onUpgrade;
     this.onPasswordRequest = onPasswordRequest;
-    whoami = (await client.run('whoami').string).trim();
+    whoami = user;
   }
 
   bool get isSU => whoami == 'root';
 
   void clear() {
-    client = null;
-    dist = null;
-    upgradeable = null;
-    error = null;
-    upgradeLog = null;
-    updateLog = whoami = null;
-    onUpgrade = null;
-    onUpdate = null;
-    onPasswordRequest = null;
-    triedTimes = 0;
+    client = dist = updateLog = upgradeLog = upgradeable =
+        error = whoami = onUpdate = onUpgrade = onPasswordRequest = null;
     isRequestingPwd = false;
   }
 
   Future<void> refreshInstalled() async {
-    if (client == null) {
-      error = 'No client';
-      return;
-    }
-
     final result = await _update();
-    getUpgradeableList(result);
-    try {} catch (e) {
+    try {
+      getUpgradeableList(result);
+    } catch (e) {
       error = '[Server Raw]:\n$result\n[App Error]:\n$e';
     } finally {
       notifyListeners();
@@ -100,32 +88,27 @@ class AptProvider extends BusyProvider {
     upgradeable = list.map((e) => UpgradePkgInfo(e, dist!)).toList();
   }
 
-  Future<String> _update() async {
+  Future<String?> _update() async {
     switch (dist) {
       case Distribution.rehl:
-        return await client?.run(_wrap('yum check-update')).string ?? '';
+        return await client?.run(_wrap('yum check-update')).string;
       default:
-        final session = await client!.execute(_wrap('apt update'));
-        session.stderr.listen((event) => _onPwd(event, session.stdin));
-        session.stdout.listen((event) {
-          updateLog = (updateLog ?? '') + event.string;
-          notifyListeners();
-          onUpdate ?? () {}();
-        });
-        await session.done;
+        await client!.exec(
+          _wrap('apt update'),
+          onStderr: _onPwd,
+          onStdout: (data, sink) {
+            updateLog = (updateLog ?? '') + data;
+            notifyListeners();
+            onUpdate!();
+          },
+        );
         return await client
-                ?.run('apt list --upgradeable'.withLangExport)
-                .string ??
-            '';
+            ?.run('apt list --upgradeable'.withLangExport)
+            .string;
     }
   }
 
   Future<void> upgrade() async {
-    if (client == null) {
-      error = 'No client';
-      return;
-    }
-
     final upgradeCmd = () {
       switch (dist) {
         case Distribution.rehl:
@@ -135,38 +118,34 @@ class AptProvider extends BusyProvider {
       }
     }();
 
-    final session = await client!.execute(_wrap(upgradeCmd));
-    session.stderr.listen((e) => _onPwd(e, session.stdin));
-
-    session.stdout.listen((data) async {
-      final log = data.string;
-      if (lastLog == log.trim()) return;
-      upgradeLog = (upgradeLog ?? '') + log;
-      lastLog = log.trim();
-      notifyListeners();
-      onUpgrade!();
-    });
+    await client!.exec(
+      _wrap(upgradeCmd),
+      onStderr: (data, sink) => _onPwd(data, sink),
+      onStdout: (log, sink) {
+        if (lastLog == log.trim()) return;
+        upgradeLog = (upgradeLog ?? '') + log;
+        lastLog = log.trim();
+        notifyListeners();
+        onUpgrade!();
+      },
+    );
 
     upgradeLog = null;
-    await session.done;
     refreshInstalled();
   }
 
-  Future<void> _onPwd(Uint8List e, StreamSink<Uint8List> stdin) async {
+  Future<void> _onPwd(String event, StreamSink<Uint8List> stdin) async {
     if (isRequestingPwd) return;
     isRequestingPwd = true;
-    final event = e.string;
     if (event.contains('[sudo] password for ')) {
       final user = pwdRequestWithUserReg.firstMatch(event)?.group(1);
       logger.info('sudo password request for $user');
-      triedTimes++;
-      final pwd =
-          await (onPasswordRequest ?? (_, __) async => '')(triedTimes, user);
+      final pwd = await onPasswordRequest!();
       if (pwd.isEmpty) {
         logger.info('sudo password request cancelled');
         return;
       }
-      stdin.add(Uint8List.fromList(utf8.encode('$pwd\n')));
+      stdin.add('$pwd\n'.uint8List);
     }
     isRequestingPwd = false;
   }

lib/data/provider/docker.dart

@@ -1,13 +1,24 @@
+import 'dart:async';
+import 'dart:typed_data';
+
 import 'package:dartssh2/dartssh2.dart';
+import 'package:logging/logging.dart';
+import 'package:toolbox/core/extension/ssh_client.dart';
 import 'package:toolbox/core/extension/stringx.dart';
 import 'package:toolbox/core/extension/uint8list.dart';
 import 'package:toolbox/core/provider_base.dart';
 import 'package:toolbox/data/model/docker/ps.dart';
+import 'package:toolbox/data/res/error.dart';
+import 'package:toolbox/data/store/docker.dart';
+import 'package:toolbox/locator.dart';
 
 final _dockerNotFound = RegExp(r'command not found|Unknown command');
 final _versionReg = RegExp(r'(Version:)\s+([0-9]+\.[0-9]+\.[0-9]+)');
 final _editionReg = RegExp(r'(Client:)\s+(.+-.+)');
-final _userIdReg = RegExp(r'.+:(\d+:\d+):.+');
+
+const _dockerPS = 'docker ps -a';
+
+final _logger = Logger('DockerProvider');
 
 class DockerProvider extends BusyProvider {
   SSHClient? client;
@@ -15,82 +26,125 @@ class DockerProvider extends BusyProvider {
   List<DockerPsItem>? items;
   String? version;
   String? edition;
-  String? error;
+  DockerErr? error;
+  PwdRequestFunc? onPwdReq;
+  String? hostId;
+  String? runLog;
+  bool isRequestingPwd = false;
 
-  void init(SSHClient client, String userName) {
+  void init(SSHClient client, String userName, PwdRequestFunc onPwdReq,
+      String hostId) {
     this.client = client;
     this.userName = userName;
+    this.onPwdReq = onPwdReq;
+    this.hostId = hostId;
   }
 
   void clear() {
-    client = null;
-    userName = null;
-    error = null;
-    items = null;
-    version = null;
-    edition = null;
+    client = userName = error = items = version = edition = onPwdReq = null;
+    isRequestingPwd = false;
+    hostId = runLog = null;
   }
 
   Future<void> refresh() async {
-    if (client == null) {
-      error = 'no client';
-      notifyListeners();
-      return;
-    }
-
     final verRaw = await client!.run('docker version'.withLangExport).string;
     if (verRaw.contains(_dockerNotFound)) {
-      error = 'docker not found';
+      error = DockerErr(type: DockerErrType.notInstalled);
       notifyListeners();
       return;
     }
 
-    version = _versionReg.firstMatch(verRaw)?.group(2);
-    edition = _editionReg.firstMatch(verRaw)?.group(2);
-
-    final passwd = await client!.run('cat /etc/passwd | grep $userName').string;
-    final userId = _userIdReg.firstMatch(passwd)?.group(1)?.split(':').first;
+    try {
+      version = _versionReg.firstMatch(verRaw)?.group(2);
+      edition = _editionReg.firstMatch(verRaw)?.group(2);
+    } catch (e) {
+      rethrow;
+    }
 
     try {
-      final cmd = 'docker ps -a'.withLangExport;
-      final raw = await () async {
-        final raw = await client!.run(cmd).string;
-        if (raw.contains('permission denied')) {
-          return await client!
-              .run(
-                  'export DOCKER_HOST=unix:///run/user/${userId ?? 1000}/docker.sock && $cmd')
-              .string;
+      // judge whether to use DOCKER_HOST / sudo
+      final dockerHost = locator<DockerStore>().getDockerHost(hostId!);
+      final cmd = () {
+        if (dockerHost == null || dockerHost.isEmpty) {
+          return 'sudo -S $_dockerPS'.withLangExport;
         }
-        return raw;
+        return 'export DOCKER_HOST=$dockerHost && $_dockerPS'.withLangExport;
       }();
+
+      // run docker ps
+      var raw = '';
+      await client!.exec(
+        cmd,
+        onStderr: _onPwd,
+        onStdout: (data, _) => raw = '$raw$data',
+      );
+
+      // parse result
       final lines = raw.split('\n');
       lines.removeAt(0);
       lines.removeWhere((element) => element.isEmpty);
       items = lines.map((e) => DockerPsItem.fromRawString(e)).toList();
     } catch (e) {
-      error = e.toString();
+      error = DockerErr(type: DockerErrType.unknown, message: e.toString());
       rethrow;
     } finally {
       notifyListeners();
     }
   }
 
+  Future<void> _onPwd(String event, StreamSink<Uint8List> stdin) async {
+    if (isRequestingPwd) return;
+    isRequestingPwd = true;
+    if (event.contains('[sudo] password for ')) {
+      _logger.info('sudo password request for $userName');
+      final pwd = await onPwdReq!();
+      if (pwd.isEmpty) {
+        _logger.info('sudo password request cancelled');
+        return;
+      }
+      stdin.add('$pwd\n'.uint8List);
+    }
+    isRequestingPwd = false;
+  }
+
   Future<bool> _do(String id, String cmd) async {
     setBusyState();
-    if (client == null) {
-      error = 'no client';
-      setBusyState(false);
-      return false;
-    }
-    final result = await client!.run(cmd).string;
+    final result = await client!.run('$cmd $id').string;
     await refresh();
     setBusyState(false);
     return result.contains(id);
   }
 
-  Future<bool> stop(String id) async => await _do(id, 'docker stop $id');
+  Future<bool> stop(String id) async => await _do(id, 'docker stop');
 
-  Future<bool> start(String id) async => await _do(id, 'docker start $id');
+  Future<bool> start(String id) async => await _do(id, 'docker start');
 
-  Future<bool> delete(String id) async => await _do(id, 'docker rm $id');
+  Future<bool> delete(String id) async => await _do(id, 'docker rm');
+
+  Future<DockerErr?> run(String cmd) async {
+    if (!cmd.startsWith('docker ')) {
+      return DockerErr(type: DockerErrType.cmdNoPrefix);
+    }
+    setBusyState();
+
+    final errs = <String>[];
+    final code = await client!.exec(
+      cmd,
+      onStderr: (data, _) => errs.add(data),
+      onStdout: (data, _) {
+        runLog = '$runLog$data';
+        notifyListeners();
+      },
+    );
+
+    runLog = null;
+
+    if (errs.isNotEmpty || code != 0) {
+      setBusyState(false);
+      return DockerErr(type: DockerErrType.unknown, message: errs.join('\n'));
+    }
+    await refresh();
+    setBusyState(false);
+    return null;
+  }
 }

lib/data/res/build_data.dart

@@ -2,9 +2,9 @@
 
 class BuildData {
   static const String name = "ServerBox";
-  static const int build = 165;
+  static const int build = 166;
   static const String engine =
       "Flutter 3.3.9 • channel stable • https://github.com/flutter/flutter.git\nFramework • revision b8f7f1f986 (12 days ago) • 2022-11-23 06:43:51 +0900\nEngine • revision 8f2221fbef\nTools • Dart 2.18.5 • DevTools 2.15.0\n";
-  static const String buildAt = "2022-12-04 21:41:26.055331";
-  static const int modifications = 1;
+  static const String buildAt = "2022-12-04 21:57:10.591121";
+  static const int modifications = 2;
 }

lib/data/res/error.dart

@@ -0,0 +1,28 @@
+enum ErrFrom {
+  unknown,
+  apt,
+  docker,
+  sftp,
+  ssh,
+}
+
+abstract class Err<T> {
+  final ErrFrom from;
+  final T type;
+  final String? message;
+
+  Err({required this.from, required this.type, this.message});
+}
+
+enum DockerErrType {
+  unknown,
+  noClient,
+  notInstalled,
+  invalidVersion,
+  cmdNoPrefix
+}
+
+class DockerErr extends Err<DockerErrType> {
+  DockerErr({required DockerErrType type, String? message})
+      : super(from: ErrFrom.docker, type: type, message: message);
+}

lib/data/store/docker.dart

@@ -0,0 +1,11 @@
+import 'package:toolbox/core/persistant_store.dart';
+
+class DockerStore extends PersistentStore {
+  String? getDockerHost(String id) {
+    return box.get(id);
+  }
+
+  void setDockerHost(String id, String host) {
+    box.put(id, host);
+  }
+}

lib/data/store/setting.dart

@@ -5,7 +5,7 @@ class SettingStore extends PersistentStore {
   StoreProperty<int> get primaryColor =>
       property('primaryColor', defaultValue: Colors.deepPurpleAccent.value);
   StoreProperty<int> get serverStatusUpdateInterval =>
-      property('serverStatusUpdateInterval', defaultValue: 2);
+      property('serverStatusUpdateInterval', defaultValue: 5);
   StoreProperty<int> get launchPage => property('launchPage', defaultValue: 0);
 
   StoreProperty<int> get storeVersion =>