467 lines
15 KiB
Dart
467 lines
15 KiB
Dart
import 'package:after_layout/after_layout.dart';
|
|
import 'package:charts_flutter/flutter.dart' as chart;
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/widgets.dart';
|
|
import 'package:flutter_staggered_animations/flutter_staggered_animations.dart';
|
|
import 'package:get_it/get_it.dart';
|
|
import 'package:provider/provider.dart';
|
|
import 'package:ssh2/ssh2.dart';
|
|
import 'package:toolbox/core/extension/stringx.dart';
|
|
import 'package:toolbox/core/utils.dart';
|
|
import 'package:toolbox/data/model/disk_info.dart';
|
|
import 'package:toolbox/data/model/server_private_info.dart';
|
|
import 'package:toolbox/data/model/server_status.dart';
|
|
import 'package:toolbox/data/model/tcp_status.dart';
|
|
import 'package:toolbox/data/provider/server.dart';
|
|
import 'package:toolbox/locator.dart';
|
|
import 'package:toolbox/view/widget/circle_pie.dart';
|
|
|
|
class ServerPage extends StatefulWidget {
|
|
const ServerPage({Key? key}) : super(key: key);
|
|
|
|
@override
|
|
_ServerPageState createState() => _ServerPageState();
|
|
}
|
|
|
|
class _ServerPageState extends State<ServerPage>
|
|
with AutomaticKeepAliveClientMixin, AfterLayoutMixin {
|
|
late MediaQueryData _media;
|
|
late ThemeData _theme;
|
|
bool useKey = false;
|
|
|
|
final nameController = TextEditingController();
|
|
final ipController = TextEditingController();
|
|
final portController = TextEditingController();
|
|
final usernameController = TextEditingController();
|
|
final passwordController = TextEditingController();
|
|
final keyController = TextEditingController();
|
|
final ipFocusNode = FocusNode();
|
|
final portFocusNode = FocusNode();
|
|
final usernameFocusNode = FocusNode();
|
|
final passwordFocusNode = FocusNode();
|
|
|
|
late ServerProvider serverProvider;
|
|
final cachedServerStatus = <ServerStatus?>[];
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
serverProvider = locator<ServerProvider>();
|
|
}
|
|
|
|
@override
|
|
void didChangeDependencies() {
|
|
super.didChangeDependencies();
|
|
_media = MediaQuery.of(context);
|
|
_theme = Theme.of(context);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
super.build(context);
|
|
return Scaffold(
|
|
body: GestureDetector(
|
|
child: SingleChildScrollView(
|
|
padding: const EdgeInsets.symmetric(horizontal: 7),
|
|
child: AnimationLimiter(
|
|
child: Consumer<ServerProvider>(builder: (_, pro, __) {
|
|
return Column(
|
|
children: AnimationConfiguration.toStaggeredList(
|
|
duration: const Duration(milliseconds: 377),
|
|
childAnimationBuilder: (widget) => SlideAnimation(
|
|
verticalOffset: 50.0,
|
|
child: FadeInAnimation(
|
|
child: widget,
|
|
),
|
|
),
|
|
children: [
|
|
const SizedBox(height: 13),
|
|
...pro.servers
|
|
.map((e) => _buildEachServerCard(e, pro.servers.indexOf(e)))
|
|
],
|
|
));
|
|
})),
|
|
),
|
|
onTap: () => FocusScope.of(context).requestFocus(FocusNode()),
|
|
),
|
|
floatingActionButton: FloatingActionButton(
|
|
onPressed: () {
|
|
showRoundDialog(context, '新建服务器连接', _buildTextInputField(context), [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text('关闭')),
|
|
TextButton(
|
|
onPressed: () {
|
|
final authorization = keyController.text.isEmpty
|
|
? passwordController.text
|
|
: {
|
|
"privateKey": keyController.text,
|
|
"passphrase": passwordController.text
|
|
};
|
|
serverProvider.addServer(ServerPrivateInfo(
|
|
name: nameController.text,
|
|
ip: ipController.text,
|
|
port: int.parse(portController.text),
|
|
user: usernameController.text,
|
|
authorization: authorization));
|
|
nameController.clear();
|
|
ipController.clear();
|
|
portController.clear();
|
|
usernameController.clear();
|
|
passwordController.clear();
|
|
keyController.clear();
|
|
Navigator.of(context).pop();
|
|
},
|
|
child: const Text('连接'))
|
|
]);
|
|
},
|
|
tooltip: 'add a server',
|
|
heroTag: 'server page fab',
|
|
child: const Icon(Icons.add),
|
|
),
|
|
);
|
|
}
|
|
|
|
InputDecoration _buildDecoration(String label, {TextStyle? textStyle}) {
|
|
return InputDecoration(labelText: label, labelStyle: textStyle);
|
|
}
|
|
|
|
Widget _buildTextInputField(BuildContext ctx) {
|
|
return SingleChildScrollView(
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
TextField(
|
|
controller: nameController,
|
|
keyboardType: TextInputType.text,
|
|
decoration: _buildDecoration('名称'),
|
|
onSubmitted: (_) =>
|
|
FocusScope.of(context).requestFocus(ipFocusNode),
|
|
),
|
|
TextField(
|
|
controller: ipController,
|
|
focusNode: ipFocusNode,
|
|
keyboardType: TextInputType.text,
|
|
decoration: _buildDecoration('IP'),
|
|
onSubmitted: (_) =>
|
|
FocusScope.of(context).requestFocus(usernameFocusNode),
|
|
),
|
|
TextField(
|
|
controller: portController,
|
|
focusNode: portFocusNode,
|
|
keyboardType: TextInputType.number,
|
|
decoration: _buildDecoration('Port'),
|
|
onSubmitted: (_) =>
|
|
FocusScope.of(context).requestFocus(usernameFocusNode),
|
|
),
|
|
TextField(
|
|
controller: usernameController,
|
|
focusNode: usernameFocusNode,
|
|
keyboardType: TextInputType.text,
|
|
decoration: _buildDecoration('用户名'),
|
|
onSubmitted: (_) =>
|
|
FocusScope.of(context).requestFocus(passwordFocusNode),
|
|
),
|
|
TextField(
|
|
controller: keyController,
|
|
keyboardType: TextInputType.text,
|
|
decoration: _buildDecoration('密钥(可选)'),
|
|
onSubmitted: (_) => {},
|
|
),
|
|
TextField(
|
|
controller: passwordController,
|
|
focusNode: passwordFocusNode,
|
|
obscureText: true,
|
|
keyboardType: TextInputType.text,
|
|
decoration: _buildDecoration('密码'),
|
|
onSubmitted: (_) => {},
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<ServerStatus>? _getData(ServerPrivateInfo info) async {
|
|
final client = SSHClient(
|
|
host: info.ip!,
|
|
port: info.port!,
|
|
username: info.user!,
|
|
passwordOrKey: info.authorization,
|
|
);
|
|
|
|
await client.connect();
|
|
final cpu = await client.execute(
|
|
"top -bn1 | grep load | awk '{printf \"%.2f\", \$(NF-2)}'") ??
|
|
'0';
|
|
final mem = await client.execute('free -m') ?? '';
|
|
final sysVer = await client.execute('cat /etc/issue.net') ?? 'Unkown';
|
|
final upTime = await client.execute('uptime') ?? 'Failed';
|
|
final disk = await client.execute('df -h') ?? 'Failed';
|
|
final tcp = await client.execute('cat /proc/net/snmp') ?? 'Failed';
|
|
|
|
return ServerStatus(
|
|
cpuPercent: double.parse(cpu.trim()),
|
|
memList: _getMem(mem),
|
|
sysVer: sysVer.trim(),
|
|
disk: _getDisk(disk),
|
|
uptime: _getUpTime(upTime),
|
|
tcp: _getTcp(tcp));
|
|
}
|
|
|
|
String _getUpTime(String raw) {
|
|
return raw.split('up ')[1].split(', ')[0];
|
|
}
|
|
|
|
TcpStatus _getTcp(String raw) {
|
|
final lines = raw.split('\n');
|
|
int idx = 0;
|
|
for (var item in lines) {
|
|
if (item.contains('Tcp:')) {
|
|
idx++;
|
|
}
|
|
if (idx == 2) {
|
|
final vals = item.split(RegExp(r'\s{1,}'));
|
|
return TcpStatus(
|
|
maxConn: vals[5].i,
|
|
active: vals[6].i,
|
|
passive: vals[7].i,
|
|
fail: vals[8].i);
|
|
}
|
|
}
|
|
return TcpStatus(maxConn: 0, active: 0, passive: 0, fail: 0);
|
|
}
|
|
|
|
List<DiskInfo> _getDisk(String disk) {
|
|
final list = <DiskInfo>[];
|
|
final items = disk.split('\n');
|
|
for (var item in items) {
|
|
if (items.indexOf(item) == 0 || item.isEmpty) {
|
|
continue;
|
|
}
|
|
final vals = item.split(RegExp(r'\s{1,}'));
|
|
list.add(DiskInfo(
|
|
mountPath: vals[1],
|
|
mountLocation: vals[5],
|
|
usedPercent: double.parse(vals[4].replaceFirst('%', '')),
|
|
used: vals[2],
|
|
size: vals[1],
|
|
avail: vals[3]));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
List<int> _getMem(String mem) {
|
|
for (var item in mem.split('\n')) {
|
|
if (item.contains('Mem:')) {
|
|
return RegExp(r'[1-9][0-9]*')
|
|
.allMatches(item)
|
|
.map((e) => int.parse(item.substring(e.start, e.end)))
|
|
.toList();
|
|
}
|
|
}
|
|
return [];
|
|
}
|
|
|
|
Widget _buildEachServerCard(ServerPrivateInfo e, int index) {
|
|
return FutureBuilder<ServerStatus>(
|
|
future: _getData(e),
|
|
builder: (BuildContext context, AsyncSnapshot<ServerStatus> snapshot) {
|
|
return GestureDetector(
|
|
child: _buildEachCardContent(snapshot, e.name ?? '', index),
|
|
onLongPress: () =>
|
|
showRoundDialog(context, '是否删除', const Text('删除后无法恢复'), [
|
|
TextButton(
|
|
onPressed: () => Navigator.of(context).pop(),
|
|
child: const Text('否')),
|
|
TextButton(
|
|
onPressed: () {
|
|
serverProvider.delServer(e);
|
|
Navigator.of(context).pop();
|
|
},
|
|
child: const Text('是'))
|
|
]),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
Widget _buildEachCardContent(
|
|
AsyncSnapshot<ServerStatus> snapshot, String serverName, int index) {
|
|
Widget child;
|
|
if (snapshot.connectionState != ConnectionState.done) {
|
|
if (cachedServerStatus.length > index && cachedServerStatus.elementAt(index) != null) {
|
|
child = _buildRealServerCard(cachedServerStatus.elementAt(index)!, serverName);
|
|
} else {
|
|
child = _buildRealServerCard(
|
|
ServerStatus(
|
|
cpuPercent: 0,
|
|
memList: [100, 0],
|
|
disk: [
|
|
DiskInfo(
|
|
mountLocation: '',
|
|
mountPath: '',
|
|
used: '',
|
|
size: '',
|
|
avail: '',
|
|
usedPercent: 0)
|
|
],
|
|
sysVer: '',
|
|
uptime: '',
|
|
tcp: TcpStatus(maxConn: 0, active: 0, passive: 0, fail: 0)),
|
|
serverName);
|
|
}
|
|
} else if (snapshot.hasError) {
|
|
child = Column(
|
|
children: [
|
|
Text(
|
|
serverName,
|
|
style: const TextStyle(fontWeight: FontWeight.bold),
|
|
),
|
|
Center(
|
|
child: Text("Error: ${snapshot.error}"),
|
|
)
|
|
],
|
|
);
|
|
} else {
|
|
if (cachedServerStatus.length <= index) {
|
|
cachedServerStatus.add(snapshot.data!);
|
|
} else {
|
|
cachedServerStatus[index] = snapshot.data!;
|
|
}
|
|
child = _buildRealServerCard(snapshot.data!, serverName);
|
|
}
|
|
return Card(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(13),
|
|
child: child,
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildRealServerCard(ServerStatus ss, String serverName) {
|
|
final cpuData = [
|
|
IndexPercent(0, ss.cpuPercent!.toInt()),
|
|
IndexPercent(1, 100 - ss.cpuPercent!.toInt()),
|
|
];
|
|
final memData = <IndexPercent>[];
|
|
for (var e in ss.memList!) {
|
|
memData.add(IndexPercent(ss.memList!.indexOf(e), e!.toInt()));
|
|
}
|
|
return Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
Text(
|
|
serverName,
|
|
style: const TextStyle(fontWeight: FontWeight.bold),
|
|
),
|
|
Text(ss.uptime!,
|
|
style: TextStyle(
|
|
color: _theme.textTheme.bodyText1!.color!.withAlpha(100)))
|
|
],
|
|
),
|
|
const SizedBox(
|
|
height: 13,
|
|
),
|
|
Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
_buildPercentCircle(ss.cpuPercent!, 'CPU', [
|
|
chart.Series<IndexPercent, int>(
|
|
id: 'CPU',
|
|
domainFn: (IndexPercent cpu, _) => cpu.id,
|
|
measureFn: (IndexPercent cpu, _) => cpu.percent,
|
|
data: cpuData,
|
|
)
|
|
]),
|
|
_buildPercentCircle(
|
|
ss.memList![1]! / ss.memList![0]! * 100, 'Mem', [
|
|
chart.Series<IndexPercent, int>(
|
|
id: 'Mem',
|
|
domainFn: (IndexPercent sales, _) => sales.id,
|
|
measureFn: (IndexPercent sales, _) => sales.percent,
|
|
data: memData,
|
|
)
|
|
]),
|
|
_buildIOData('Net', ss.tcp!.maxConn!.toString(), '0kb/s'),
|
|
_buildIOData('Disk', '0kb/s', '0kb/s')
|
|
],
|
|
)
|
|
],
|
|
);
|
|
}
|
|
|
|
Widget _buildIOData(String title, String up, String down) {
|
|
return SizedBox(
|
|
width: _media.size.width * 0.2,
|
|
height: _media.size.height * 0.1,
|
|
child: Stack(
|
|
children: [
|
|
Positioned(
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
Text(
|
|
'↓$up',
|
|
textAlign: TextAlign.start,
|
|
),
|
|
Text(
|
|
'↑$down',
|
|
textAlign: TextAlign.center,
|
|
)
|
|
],
|
|
),
|
|
top: _media.size.height * 0.012,
|
|
left: 0,
|
|
right: 0,
|
|
),
|
|
Positioned(
|
|
child: Text(title, textAlign: TextAlign.center),
|
|
bottom: 0,
|
|
left: 0,
|
|
right: 0)
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget _buildPercentCircle(double percent, String title,
|
|
List<chart.Series<IndexPercent, int>> series) {
|
|
return SizedBox(
|
|
width: _media.size.width * 0.2,
|
|
height: _media.size.height * 0.1,
|
|
child: Stack(
|
|
children: [
|
|
DonutPieChart(series),
|
|
Positioned(
|
|
child: Text(
|
|
'${percent.toStringAsFixed(1)}%',
|
|
textAlign: TextAlign.center,
|
|
),
|
|
left: 0,
|
|
right: 0,
|
|
top: _media.size.height * 0.03,
|
|
),
|
|
Positioned(
|
|
child: Text(title, textAlign: TextAlign.center),
|
|
bottom: 0,
|
|
left: 0,
|
|
right: 0)
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
@override
|
|
bool get wantKeepAlive => true;
|
|
|
|
@override
|
|
Future<void> afterFirstLayout(BuildContext context) async {
|
|
await GetIt.I.allReady();
|
|
await locator<ServerProvider>().loadData();
|
|
}
|
|
}
|