468 lines
18 KiB
Rust
468 lines
18 KiB
Rust
use eframe::{NativeOptions, run_native};
|
|
use egui::{FontDefinitions, FontFamily, FontData, Vec2};
|
|
use crate::api::ProxmoxClient;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::sync::{Arc, RwLock, Mutex};
|
|
use dotenv::dotenv;
|
|
use std::env;
|
|
use std::thread;
|
|
use std::fs;
|
|
use std::path::PathBuf;
|
|
|
|
pub type SharedState = Arc<RwLock<AppState>>;
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Config {
|
|
pub host: String,
|
|
pub port: u16,
|
|
pub token_id: String,
|
|
pub token_secret: String,
|
|
pub vm_id: u32,
|
|
pub node: String,
|
|
}
|
|
|
|
impl Default for Config {
|
|
fn default() -> Self {
|
|
Self {
|
|
host: String::new(),
|
|
port: 8006,
|
|
token_id: String::new(),
|
|
token_secret: String::new(),
|
|
vm_id: 100,
|
|
node: "proxmox".to_string(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Config {
|
|
fn path() -> PathBuf {
|
|
let mut path = dirs_config_path();
|
|
path.push("proxmox-vm-gui.json");
|
|
path
|
|
}
|
|
|
|
fn load() -> Self {
|
|
let path = Self::path();
|
|
if path.exists() {
|
|
if let Ok(content) = fs::read_to_string(&path) {
|
|
if let Ok(config) = serde_json::from_str(&content) {
|
|
return config;
|
|
}
|
|
}
|
|
}
|
|
|
|
dotenv().ok();
|
|
Self {
|
|
host: env::var("PROXMOX_HOST").unwrap_or_default(),
|
|
port: env::var("PROXMOX_PORT").ok().and_then(|p| p.parse().ok()).unwrap_or(8006),
|
|
token_id: env::var("PROXMOX_TOKEN_ID").unwrap_or_default(),
|
|
token_secret: env::var("PROXMOX_TOKEN_SECRET").unwrap_or_default(),
|
|
vm_id: env::var("VM_ID").ok().and_then(|p| p.parse().ok()).unwrap_or(100),
|
|
node: env::var("NODE").unwrap_or_else(|_| "proxmox".to_string()),
|
|
}
|
|
}
|
|
|
|
fn save(&self) {
|
|
let path = Self::path();
|
|
if let Some(parent) = path.parent() {
|
|
let _ = fs::create_dir_all(parent);
|
|
}
|
|
if let Ok(content) = serde_json::to_string_pretty(self) {
|
|
let _ = fs::write(&path, content);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn dirs_config_path() -> PathBuf {
|
|
if let Some(data_dir) = env::var_os("APPDATA") {
|
|
PathBuf::from(data_dir)
|
|
} else if let Some(home) = env::var_os("USERPROFILE") {
|
|
PathBuf::from(home).join("AppData").join("Roaming")
|
|
} else {
|
|
PathBuf::from(".")
|
|
}
|
|
}
|
|
|
|
pub struct AppState {
|
|
pub client: Arc<Mutex<Option<ProxmoxClient>>>,
|
|
pub vm_id: u32,
|
|
pub node: String,
|
|
pub vm_status: String,
|
|
pub log_buffer: Vec<String>,
|
|
pub is_connected: bool,
|
|
}
|
|
|
|
impl AppState {
|
|
pub fn new(config: &Config) -> Self {
|
|
let client = if !config.host.is_empty() && !config.token_id.is_empty() && !config.token_secret.is_empty() {
|
|
let c = ProxmoxClient::new(&config.host, config.port, &config.token_id, &config.token_secret);
|
|
Arc::new(Mutex::new(Some(c)))
|
|
} else {
|
|
Arc::new(Mutex::new(None))
|
|
};
|
|
|
|
let is_connected = !config.host.is_empty() && !config.token_id.is_empty() && !config.token_secret.is_empty();
|
|
|
|
Self {
|
|
client,
|
|
vm_id: config.vm_id,
|
|
node: config.node.clone(),
|
|
vm_status: "未知".to_string(),
|
|
log_buffer: vec!["程序启动".to_string()],
|
|
is_connected,
|
|
}
|
|
}
|
|
|
|
pub fn add_log(&mut self, msg: &str) {
|
|
let time = chrono::Local::now().format("%H:%M:%S").to_string();
|
|
self.log_buffer.push(format!("{} {}", time, msg));
|
|
if self.log_buffer.len() > 100 {
|
|
self.log_buffer.remove(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct SettingsData {
|
|
pub host: String,
|
|
pub port: u16,
|
|
pub token_id: String,
|
|
pub token_secret: String,
|
|
}
|
|
|
|
pub fn gui_run() {
|
|
let options = NativeOptions {
|
|
viewport: egui::ViewportBuilder::default()
|
|
.with_inner_size([520.0, 480.0])
|
|
.with_min_inner_size([450.0, 400.0])
|
|
.with_title("Proxmox VM 控制器"),
|
|
..Default::default()
|
|
};
|
|
|
|
run_native("Proxmox VM Controller", options, Box::new(|cc| {
|
|
let mut fonts = FontDefinitions::default();
|
|
|
|
fonts.font_data.insert(
|
|
"my_font".to_owned(),
|
|
FontData::from_static(include_bytes!(r"C:\Windows\Fonts\msyh.ttc")),
|
|
);
|
|
|
|
fonts.families.get_mut(&FontFamily::Proportional)
|
|
.unwrap()
|
|
.insert(0, "my_font".to_owned());
|
|
fonts.families.get_mut(&FontFamily::Monospace)
|
|
.unwrap()
|
|
.insert(0, "my_font".to_owned());
|
|
|
|
cc.egui_ctx.set_fonts(fonts);
|
|
Ok(Box::new(App::new()))
|
|
})).unwrap();
|
|
}
|
|
|
|
struct App {
|
|
state: SharedState,
|
|
show_settings: bool,
|
|
settings: SettingsData,
|
|
}
|
|
|
|
impl App {
|
|
fn new() -> Self {
|
|
let config = Config::load();
|
|
let settings = SettingsData {
|
|
host: config.host.clone(),
|
|
port: config.port,
|
|
token_id: config.token_id.clone(),
|
|
token_secret: config.token_secret.clone(),
|
|
};
|
|
|
|
Self {
|
|
state: Arc::new(RwLock::new(AppState::new(&config))),
|
|
show_settings: false,
|
|
settings,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl eframe::App for App {
|
|
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
|
|
let state = self.state.clone();
|
|
|
|
egui::CentralPanel::default().show(ctx, |ui| {
|
|
// 标题栏
|
|
ui.horizontal(|ui| {
|
|
ui.heading("Proxmox VM 控制器");
|
|
ui.with_layout(egui::Layout::right_to_left(egui::Align::Min), |ui| {
|
|
if ui.button("⚙ 设置").clicked() {
|
|
self.show_settings = true;
|
|
}
|
|
});
|
|
});
|
|
ui.add_space(8.0);
|
|
ui.separator();
|
|
ui.add_space(8.0);
|
|
|
|
let mut st = state.write().unwrap();
|
|
|
|
// 状态信息卡片
|
|
egui::Frame::group(ui.style()).show(ui, |ui| {
|
|
ui.vertical(|ui| {
|
|
ui.horizontal(|ui| {
|
|
ui.label("连接状态:");
|
|
let status_text = if st.is_connected { "● 已连接" } else { "○ 未连接" };
|
|
let status_color = if st.is_connected { egui::Color32::GREEN } else { egui::Color32::RED };
|
|
ui.colored_label(status_color, status_text);
|
|
});
|
|
ui.add_space(4.0);
|
|
ui.horizontal(|ui| {
|
|
ui.label("VM ID:");
|
|
ui.add(egui::DragValue::new(&mut st.vm_id).range(100..=999).speed(1));
|
|
});
|
|
ui.add_space(4.0);
|
|
ui.horizontal(|ui| {
|
|
ui.label("节点:");
|
|
ui.text_edit_singleline(&mut st.node);
|
|
ui.label("← 请输入正确的节点名称");
|
|
});
|
|
ui.add_space(4.0);
|
|
ui.horizontal(|ui| {
|
|
ui.label("VM 状态:");
|
|
ui.label(&st.vm_status);
|
|
});
|
|
});
|
|
});
|
|
|
|
ui.add_space(12.0);
|
|
|
|
// 控制按钮
|
|
ui.horizontal(|ui| {
|
|
let btn_start = ui.add(egui::Button::new("▶ 启动").min_size(Vec2::new(70.0, 32.0)));
|
|
let btn_stop = ui.add(egui::Button::new("■ 停止").min_size(Vec2::new(70.0, 32.0)));
|
|
let btn_refresh = ui.add(egui::Button::new("↻ 刷新").min_size(Vec2::new(70.0, 32.0)));
|
|
let btn_shutdown = ui.add(egui::Button::new("🔴 关机").min_size(Vec2::new(70.0, 32.0)));
|
|
|
|
let vm_id_start = st.vm_id;
|
|
let node_start = st.node.clone();
|
|
let client_start = st.client.clone();
|
|
|
|
let vm_id_stop = st.vm_id;
|
|
let node_stop = st.node.clone();
|
|
let client_stop = st.client.clone();
|
|
|
|
let vm_id_refresh = st.vm_id;
|
|
let node_refresh = st.node.clone();
|
|
let client_refresh = st.client.clone();
|
|
|
|
let client_shutdown = st.client.clone();
|
|
let node_shutdown = st.node.clone();
|
|
let state_shutdown = state.clone();
|
|
|
|
if btn_start.clicked() {
|
|
let client = client_start.clone();
|
|
let node = node_start.clone();
|
|
let vm_id = vm_id_start;
|
|
let state = state.clone();
|
|
st.add_log("正在启动 VM...");
|
|
ctx.request_repaint();
|
|
thread::spawn(move || {
|
|
let rt = tokio::runtime::Runtime::new().unwrap();
|
|
let result = rt.block_on(async {
|
|
let client = client.lock().unwrap();
|
|
if let Some(c) = client.as_ref() {
|
|
c.start_vm(&node, vm_id).await
|
|
} else {
|
|
Err("未连接".to_string())
|
|
}
|
|
});
|
|
let msg = match result {
|
|
Ok(_) => "启动命令已发送".to_string(),
|
|
Err(e) => format!("启动失败: {}", e),
|
|
};
|
|
state.write().unwrap().add_log(&msg);
|
|
});
|
|
}
|
|
|
|
if btn_stop.clicked() {
|
|
let client = client_stop.clone();
|
|
let node = node_stop.clone();
|
|
let vm_id = vm_id_stop;
|
|
let state = state.clone();
|
|
st.add_log("正在停止 VM...");
|
|
ctx.request_repaint();
|
|
thread::spawn(move || {
|
|
let rt = tokio::runtime::Runtime::new().unwrap();
|
|
let result = rt.block_on(async {
|
|
let client = client.lock().unwrap();
|
|
if let Some(c) = client.as_ref() {
|
|
c.stop_vm(&node, vm_id).await
|
|
} else {
|
|
Err("未连接".to_string())
|
|
}
|
|
});
|
|
let msg = match result {
|
|
Ok(_) => "停止命令已发送".to_string(),
|
|
Err(e) => format!("停止失败: {}", e),
|
|
};
|
|
state.write().unwrap().add_log(&msg);
|
|
});
|
|
}
|
|
|
|
if btn_refresh.clicked() {
|
|
let client = client_refresh.clone();
|
|
let node = node_refresh.clone();
|
|
let vm_id = vm_id_refresh;
|
|
let state = state.clone();
|
|
st.add_log("正在获取状态...");
|
|
ctx.request_repaint();
|
|
thread::spawn(move || {
|
|
let rt = tokio::runtime::Runtime::new().unwrap();
|
|
let result = rt.block_on(async {
|
|
let client = client.lock().unwrap();
|
|
if let Some(c) = client.as_ref() {
|
|
c.get_vm_status(&node, vm_id).await
|
|
} else {
|
|
Err("未连接".to_string())
|
|
}
|
|
});
|
|
let msg = match result {
|
|
Ok(status) => format!("VM状态: {}", status),
|
|
Err(e) => format!("获取状态失败: {}", e),
|
|
};
|
|
state.write().unwrap().add_log(&msg);
|
|
});
|
|
}
|
|
|
|
if btn_shutdown.clicked() {
|
|
let client = client_shutdown.clone();
|
|
let node = node_shutdown.clone();
|
|
let state = state_shutdown.clone();
|
|
st.add_log("开始执行关机流程...");
|
|
st.add_log(&format!("节点: {}", node));
|
|
ctx.request_repaint();
|
|
thread::spawn(move || {
|
|
let rt = tokio::runtime::Runtime::new().unwrap();
|
|
rt.block_on(async {
|
|
let client = client.lock().unwrap();
|
|
if let Some(c) = client.as_ref() {
|
|
match c.shutdown_node(&node).await {
|
|
Ok(response) => {
|
|
state.write().unwrap().add_log("✓ 关机命令发送成功");
|
|
state.write().unwrap().add_log(&format!("响应: {}", response));
|
|
}
|
|
Err(e) => {
|
|
state.write().unwrap().add_log(&format!("✗ 关机失败: {}", e));
|
|
}
|
|
}
|
|
} else {
|
|
state.write().unwrap().add_log("✗ 未连接到服务器");
|
|
}
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
ui.add_space(12.0);
|
|
ui.separator();
|
|
ui.add_space(8.0);
|
|
|
|
// 日志区域
|
|
ui.label("📋 日志:");
|
|
egui::Frame::default()
|
|
.inner_margin(4.0)
|
|
.show(ui, |ui| {
|
|
egui::ScrollArea::vertical().stick_to_bottom(true).show(ui, |ui| {
|
|
for log in &st.log_buffer {
|
|
ui.label(log);
|
|
}
|
|
});
|
|
});
|
|
|
|
drop(st);
|
|
|
|
// 设置窗口
|
|
if self.show_settings {
|
|
egui::Window::new("设置")
|
|
.collapsible(false)
|
|
.resizable(false)
|
|
.min_size(Vec2::new(350.0, 340.0))
|
|
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
|
|
.show(ctx, |ui| {
|
|
ui.set_width(320.0);
|
|
|
|
ui.heading("连接配置");
|
|
ui.separator();
|
|
ui.add_space(8.0);
|
|
|
|
// Base URL 显示
|
|
ui.label("API 地址:");
|
|
ui.colored_label(egui::Color32::GRAY, format!("https://{}:{}/api2/json/", self.settings.host, self.settings.port));
|
|
|
|
ui.add_space(8.0);
|
|
|
|
// Host 输入
|
|
ui.horizontal(|ui| {
|
|
ui.label("Host:");
|
|
ui.add(egui::TextEdit::singleline(&mut self.settings.host).desired_width(200.0));
|
|
});
|
|
|
|
// Port 输入
|
|
ui.horizontal(|ui| {
|
|
ui.label("端口:");
|
|
ui.add(egui::DragValue::new(&mut self.settings.port).range(1..=65535).speed(1));
|
|
});
|
|
|
|
// 令牌ID 输入
|
|
ui.horizontal(|ui| {
|
|
ui.label("令牌ID:");
|
|
ui.add(egui::TextEdit::singleline(&mut self.settings.token_id).desired_width(200.0));
|
|
});
|
|
|
|
// 密钥 输入（密码框）
|
|
ui.horizontal(|ui| {
|
|
ui.label("密钥:");
|
|
ui.add(egui::TextEdit::singleline(&mut self.settings.token_secret).password(true).desired_width(200.0));
|
|
});
|
|
|
|
ui.add_space(12.0);
|
|
|
|
// 按钮
|
|
ui.horizontal(|ui| {
|
|
if ui.button("💾 保存").clicked() {
|
|
if !self.settings.host.is_empty() && !self.settings.token_id.is_empty() && !self.settings.token_secret.is_empty() {
|
|
let client = ProxmoxClient::new(
|
|
&self.settings.host,
|
|
self.settings.port,
|
|
&self.settings.token_id,
|
|
&self.settings.token_secret
|
|
);
|
|
|
|
let config = Config {
|
|
host: self.settings.host.clone(),
|
|
port: self.settings.port,
|
|
token_id: self.settings.token_id.clone(),
|
|
token_secret: self.settings.token_secret.clone(),
|
|
vm_id: state.read().unwrap().vm_id,
|
|
node: state.read().unwrap().node.clone(),
|
|
};
|
|
config.save();
|
|
|
|
let mut st = state.write().unwrap();
|
|
st.client = Arc::new(Mutex::new(Some(client)));
|
|
st.is_connected = true;
|
|
st.add_log("配置已保存");
|
|
|
|
self.show_settings = false;
|
|
}
|
|
}
|
|
|
|
if ui.button("取消").clicked() {
|
|
self.show_settings = false;
|
|
}
|
|
});
|
|
|
|
ui.add_space(8.0);
|
|
ui.separator();
|
|
ui.colored_label(egui::Color32::GRAY, "💡 提示: 修改配置后点击保存以生效");
|
|
});
|
|
}
|
|
});
|
|
}
|
|
} |