aljaz/flutter_server_box
1
1
Fork 0
mirror of https://github.com/lollipopkit/flutter_server_box.git synced 2025-12-17 07:14:28 +01:00
Code Issues Packages Projects Releases Wiki Activity

new & opt

Browse Source 
new: support set maxRetryCount of server reconnection
opt: server detail UI
opt: server provider
opt: `ssh` page on Android
This commit is contained in:
lollipopkit
2023-02-03 13:12:39 +08:00
parent 7837fa4339
commit 3feef3936c
20 changed files with 245 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
lib/data/provider/server.dart
View File

@@ -2,7 +2,6 @@ import 'dart:async';
import 'package:flutter/foundation.dart';
import 'package:logging/logging.dart';
import 'package:toolbox/data/res/misc.dart';
import '../../core/extension/uint8list.dart';
import '../../core/provider_base.dart';
@@ -28,7 +27,7 @@ class ServerProvider extends BusyProvider {
Timer? _timer;
final logger = Logger('SERVER');
final _logger = Logger('SERVER');
Future<void> loadLocalData() async {
setBusyState(true);
@@ -39,7 +38,7 @@ class ServerProvider extends BusyProvider {
}
Server genServer(ServerPrivateInfo spi) {
return Server(spi, initStatus, null, ServerConnectionState.disconnected);
return Server(spi, initStatus, null, ServerState.disconnected);
}
Future<void> refreshData({ServerPrivateInfo? spi}) async {
@@ -71,8 +70,9 @@ class ServerProvider extends BusyProvider {
void setDisconnected() {
for (var i = 0; i < _servers.length; i++) {
_servers[i].cs = ServerConnectionState.disconnected;
_servers[i].cs = ServerState.disconnected;
}
notifyListeners();
}
void closeServer({ServerPrivateInfo? spi}) {
@@ -81,163 +81,171 @@ class ServerProvider extends BusyProvider {
_servers[i].client?.close();
_servers[i].client = null;
}
notifyListeners();
return;
}
final idx = _servers.indexWhere((e) => e.spi == spi);
if (idx < 0) {
throw RangeError.index(idx, _servers);
}
final idx = getServerIdx(spi.id);
_servers[idx].client?.close();
_servers[idx].client = null;
notifyListeners();
}
void addServer(ServerPrivateInfo spi) {
_servers.add(genServer(spi));
locator<ServerStore>().put(spi);
notifyListeners();
locator<ServerStore>().put(spi);
refreshData(spi: spi);
}
void delServer(ServerPrivateInfo info) {
final idx = _servers.indexWhere((s) => s.spi == info);
if (idx == -1) return;
void delServer(String id) {
final idx = getServerIdx(id);
_servers[idx].client?.close();
_servers.removeAt(idx);
notifyListeners();
locator<ServerStore>().delete(info);
locator<ServerStore>().delete(id);
}
Future<void> updateServer(
ServerPrivateInfo old, ServerPrivateInfo newSpi) async {
final idx = _servers.indexWhere((e) => e.spi == old);
final idx = _servers.indexWhere((e) => e.spi.id == old.id);
if (idx < 0) {
throw RangeError.index(idx, _servers);
}
_servers[idx].spi = newSpi;
locator<ServerStore>().update(old, newSpi);
_servers[idx].client = await genClient(newSpi);
notifyListeners();
locator<ServerStore>().update(old, newSpi);
refreshData(spi: newSpi);
}
int getServerIdx(String id) {
final idx = _servers.indexWhere((s) => s.spi.id == id);
if (idx < 0) {
throw Exception('Server not found: $id');
}
return idx;
}
Server getServer(String id) => _servers[getServerIdx(id)];
Future<void> _getData(ServerPrivateInfo spi) async {
final s = _servers.firstWhere((element) => element.spi == spi);
final sid = spi.id;
final s = getServer(sid);
final state = s.cs;
if (state == ServerConnectionState.failed ||
state == ServerConnectionState.disconnected) {
if (!_limiter.shouldTry(spi.id)) {
s.cs = ServerConnectionState.failed;
if (state.shouldConnect) {
if (!_limiter.shouldTry(sid)) {
s.cs = ServerState.failed;
notifyListeners();
return;
}
s.cs = ServerConnectionState.connecting;
s.cs = ServerState.connecting;
notifyListeners();
final time1 = DateTime.now();
try {
// try to connect
final time1 = DateTime.now();
s.client = await genClient(spi);
final time2 = DateTime.now();
logger.info(
'Connected to [${spi.name}] in [${time2.difference(time1).toString()}].');
s.cs = ServerConnectionState.connected;
final spentTime = time2.difference(time1).inMilliseconds;
_logger.info('Connected to [$sid] in $spentTime ms.');
// after connected
s.cs = ServerState.connected;
final writeResult = await s.client!
.run("echo '$shellCmd' > $shellPath && chmod +x $shellPath")
.string;
// if write failed
if (writeResult.isNotEmpty) {
throw Exception(writeResult);
}
_limiter.resetTryTimes(spi.id);
_limiter.resetTryTimes(sid);
} catch (e) {
s.cs = ServerConnectionState.failed;
s.status.failedInfo = '$e ## ';
logger.warning(e);
s.cs = ServerState.failed;
s.status.failedInfo = '$e';
_logger.warning(e);
} finally {
notifyListeners();
}
}
// if client is null, return
if (s.client == null) return;
// run script to get server status
final raw = await s.client!.run("sh $shellPath").string;
final segments = raw.split(seperator).map((e) => e.trim()).toList();
if (raw.isEmpty || segments.length == 1) {
s.cs = ServerConnectionState.failed;
s.cs = ServerState.failed;
if (s.status.failedInfo == null || s.status.failedInfo!.isEmpty) {
s.status.failedInfo = 'No data received';
}
notifyListeners();
return;
}
// remove first empty segment
segments.removeAt(0);
try {
_getCPU(spi, segments[2], segments[7], segments[8]);
_getMem(spi, segments[6]);
_getSysVer(spi, segments[1]);
_getUpTime(spi, segments[3]);
_getDisk(spi, segments[5]);
_getTcp(spi, segments[4]);
_getNetSpeed(spi, segments[0]);
_getCPU(sid, segments[2], segments[7], segments[8]);
_getMem(sid, segments[6]);
_getSysVer(sid, segments[1]);
_getUpTime(sid, segments[3]);
_getDisk(sid, segments[5]);
_getTcp(sid, segments[4]);
_getNetSpeed(sid, segments[0]);
} catch (e) {
s.cs = ServerConnectionState.failed;
s.cs = ServerState.failed;
s.status.failedInfo = e.toString();
logger.warning(e);
_logger.warning(e);
rethrow;
} finally {
notifyListeners();
}
}
Future<void> _getNetSpeed(ServerPrivateInfo spi, String raw) async {
final info = _servers.firstWhere((e) => e.spi == spi);
info.status.netSpeed.update(await compute(parseNetSpeed, raw));
Future<void> _getNetSpeed(String id, String raw) async {
final net = await compute(parseNetSpeed, raw);
getServer(id).status.netSpeed.update(net);
}
void _getSysVer(ServerPrivateInfo spi, String raw) {
final info = _servers.firstWhere((e) => e.spi == spi);
void _getSysVer(String id, String raw) {
final s = raw.split('=');
if (s.length == 2) {
info.status.sysVer = s[1].replaceAll('"', '').replaceFirst('\n', '');
final ver = s[1].replaceAll('"', '').replaceFirst('\n', '');
getServer(id).status.sysVer = ver;
}
}
Future<void> _getCPU(ServerPrivateInfo spi, String raw, String tempType,
String tempValue) async {
final info = _servers.firstWhere((e) => e.spi == spi);
Future<void> _getCPU(
String id, String raw, String tempType, String tempValue) async {
final cpus = await compute(parseCPU, raw);
final temp = await compute(parseCPUTemp, [tempType, tempValue]);
if (cpus.isNotEmpty) {
info.status.cpu.update(
cpus,
await compute(parseCPUTemp, [tempType, tempValue]),
);
getServer(id).status.cpu.update(cpus, temp);
}
}
void _getUpTime(ServerPrivateInfo spi, String raw) {
_servers.firstWhere((e) => e.spi == spi).status.uptime =
raw.split('up ')[1].split(', ')[0];
void _getUpTime(String id, String raw) {
getServer(id).status.uptime = raw.split('up ')[1].split(', ')[0];
}
Future<void> _getTcp(ServerPrivateInfo spi, String raw) async {
final info = _servers.firstWhere((e) => e.spi == spi);
Future<void> _getTcp(String id, String raw) async {
final status = await compute(parseTcp, raw);
if (status != null) {
info.status.tcp = status;
getServer(id).status.tcp = status;
}
}
Future<void> _getDisk(ServerPrivateInfo spi, String raw) async {
final info = _servers.firstWhere((e) => e.spi == spi);
info.status.disk = await compute(parseDisk, raw);
Future<void> _getDisk(String id, String raw) async {
getServer(id).status.disk = await compute(parseDisk, raw);
}
Future<void> _getMem(ServerPrivateInfo spi, String raw) async {
final info = _servers.firstWhere((e) => e.spi == spi);
info.status.mem = await compute(parseMem, raw);
Future<void> _getMem(String id, String raw) async {
getServer(id).status.mem = await compute(parseMem, raw);
}
Future<String?> runSnippet(String id, Snippet snippet) async {
final client =
_servers.firstWhere((element) => element.spi.id == id).client;
final client = getServer(id).client;
if (client == null) {
return null;
}
@@ -249,8 +257,12 @@ class _TryLimiter {
final Map<String, int> _triedTimes = {};
bool shouldTry(String id) {
final maxCount = locator<SettingStore>().maxRetryCount.fetch()!;
if (maxCount <= 0) {
return true;
}
final times = _triedTimes[id] ?? 0;
if (times >= serverMaxTryTimes) {
if (times >= maxCount) {
return false;
}
_triedTimes[id] = times + 1;